diff --git a/4dm.h/.gitignore b/4dm.h/.gitignore
index ced5c50..665321d 100644
--- a/4dm.h/.gitignore
+++ b/4dm.h/.gitignore
@@ -1,5 +1,7 @@
-.vs/
-x64/
+.vs
+x64
+obj
+.vscode
 4dm.h.sln
 4dm.h.vcxproj
 4dm.h.vcxproj.filters
diff --git a/4dm.h/4dm.h b/4dm.h/4dm.h
index 03a9ded..ab5da88 100644
--- a/4dm.h/4dm.h
+++ b/4dm.h/4dm.h
@@ -1,12 +1,14 @@
 #ifndef __4DM_H__
 #define __4DM_H__
 
-#ifndef MOD_NAME
-#define MOD_NAME "Unknown Mod"
-#endif
-#ifndef MOD_VER
-#define MOD_VER "0.0"
-#endif
+#pragma warning(disable: 26495)
+#pragma warning(disable: 4819)
+#pragma warning(disable: 26444)
+#pragma warning(disable: 6387)
+#pragma warning(disable: 26800)
+#pragma warning(disable: 26819)
+#pragma warning(disable: 4267)
+#pragma warning(disable: 4244)
 
 #include <algorithm>
 #include <map>
@@ -31,15 +33,15 @@
 #include <mutex>
 #include <set>
 #include <unordered_set>
-#include <atomic>  // TODO add this for linuxMint
+// #include <atomic>  // TODO add this for linuxMint
 
-#include "soil/SOIL.h"
+#include "soil/SOIL2.h"
 
 #define __STR_CAT___(str1, str2) str1##str2
-#define __STR_CAT__(str1, str2) __STR_CAT___(str1, str2)
+#define CONCAT(str1, str2) __STR_CAT___(str1, str2)
 
 #ifndef PAD
-#define PAD(size) char __STR_CAT__(__, __STR_CAT__(pad, __LINE__))[size] = {}
+#define PAD(size) char CONCAT(__, CONCAT(pad, __LINE__))[size] = {}
 #endif
 
 #ifndef idaOffsetFix
@@ -52,7 +54,7 @@
 
 #include "hook.h"
 
-void patchMemory(uintptr_t addressToWrite, byte* valueToWrite, int byteNum)
+inline void patchMemory(uintptr_t addressToWrite, byte* valueToWrite, int byteNum)
 {
 	unsigned long OldProtection;
 	VirtualProtect((LPVOID)(addressToWrite), byteNum, PAGE_EXECUTE_READWRITE, &OldProtection);
@@ -60,14 +62,1189 @@ void patchMemory(uintptr_t addressToWrite, byte* valueToWrite, int byteNum)
 	VirtualProtect((LPVOID)(addressToWrite), byteNum, OldProtection, NULL);
 }
 
+#include "msvc_string.h"
+
 namespace fdm
 {
 	inline uintptr_t base = reinterpret_cast<uintptr_t>(GetModuleHandle(0));
+
+	inline msvc_string modID = "";
+
+	namespace Func {
+
+		enum class AudioManager : int {
+			loadSound = 0,
+			playSound4D = 1,
+			setListenerInfo4D = 2,
+			loadBGMfromJSON = 3,
+			updateBGM = 4,
+			getSound = 5,
+			getVoiceGroupInfo = 6,
+		};
+		enum class Hitbox : int {
+			addVelWithMaxHorizSpeed = 7,
+			update = 8,
+			isIntersectingRay = 9,
+			takeStep = 10,
+		};
+		enum class KleinBottle : int {
+			buffData = 11,
+			attrSize = 12,
+			KleinBottle = 13,
+			buffSize = 14,
+			destr_KleinBottle = 15,
+		};
+		namespace Connection_Nested {
+			enum class InMessage : int {
+				InMessageDeleter = 16,
+				destr_InMessage = 17,
+			};
+		}
+		namespace Connection_Nested {
+			enum class OutMessage : int {
+				createMessage = 18,
+				OutMessage = 19,
+				ReleaseHeapMessageData = 20,
+			};
+		}
+		namespace Connection_Nested {
+			enum class Client : int {
+				update = 21,
+				resolveHost = 22,
+				cleanup = 23,
+				connectionStatusChangedCallback = 24,
+			};
+		}
+		enum class WorldTitleScreen : int {
+			loadCube = 25,
+			loadChunk = 26,
+			updateChunkCache = 27,
+			generateMesh = 28,
+			loadChunks = 29,
+		};
+		enum class FontRenderer : int {
+			FontRenderer = 30,
+			FontRendererA = 31,
+			setText = 32,
+			render = 33,
+			updateModel = 34,
+			move = 35,
+		};
+		enum class TexRenderer : int {
+			destr_TexRenderer = 36,
+			operatorEq = 37,
+			init = 38,
+			setClip = 39,
+			setColor = 40,
+			setPos = 41,
+		};
+		enum class Dodecaplex : int {
+			buffCount = 42,
+			buffData = 43,
+			buffSize = 44,
+			attrSize = 45,
+			generateMesh = 46,
+			generateCellColors = 47,
+			addFaces = 48,
+			addCells = 49,
+			destr_Dodecaplex = 50,
+		};
+		enum class Skybox : int {
+			buffData = 51,
+			buffSize = 52,
+			attrSize = 53,
+			vertCount = 54,
+		};
+		enum class PentachoronHollow : int {
+			buffData = 55,
+			PentachoronHollow = 56,
+			buffSize = 57,
+			vertCount = 58,
+			addTetSide = 59,
+		};
+		namespace Hypersphere_Nested {
+			enum class VertInfo : int {
+				VertInfo = 60,
+				destr_VertInfo = 61,
+				add = 62,
+				addA = 63,
+			};
+		}
+		enum class Hypersphere : int {
+			attrCount = 64,
+			attrType = 65,
+			buffCount = 66,
+			Hypersphere = 67,
+			HypersphereA = 68,
+			generateSpherePolygons = 69,
+			addWedgeSide = 70,
+			addCubeSide = 71,
+		};
+		enum class MeshRenderer : int {
+			MeshRenderer = 72,
+			setMesh = 73,
+			updateMesh = 74,
+			destr_MeshRenderer = 75,
+			render = 76,
+			init = 77,
+			cleanup = 78,
+			initAttrs = 79,
+		};
+		namespace PlayerSkin_Nested {
+			enum class SkinMesh : int {
+				vertCount = 80,
+				destr_SkinMesh = 81,
+				generate = 82,
+				buffSize = 83,
+				attrCount = 84,
+				attrType = 85,
+				attrSize = 86,
+				attrStride = 87,
+				addPixelToFace = 88,
+			};
+		}
+		enum class PlayerSkin : int {
+			load = 89,
+			generateMesh = 90,
+			destr_PlayerSkin = 91,
+		};
+		enum class Tex2D : int {
+			destr_Tex2D = 92,
+			loadRawImageData = 93,
+			initFromTexID = 94,
+			loadArrayTexture = 95,
+		};
+		enum class StateCredits : int {
+			init = 96,
+			update = 97,
+			render = 98,
+			windowResize = 99,
+			keyInput = 100,
+			updateProjection = 101,
+		};
+		enum class StateCreateWorld : int {
+			StateCreateWorld = 102,
+			init = 103,
+			close = 104,
+			update = 105,
+			render = 106,
+			resume = 107,
+			mouseInput = 108,
+			scrollInput = 109,
+			keyInput = 110,
+			windowResize = 111,
+			charInput = 112,
+			createNewWorld = 113,
+			viewportCallback = 114,
+			caveCheckboxCallback = 115,
+			handleCreateButton = 116,
+		};
+		enum class StateTitleScreen : int {
+			quitGameButtonCallback = 117,
+			settingsButtonCallback = 118,
+			StateTitleScreen = 119,
+			updateProjection = 120,
+			singleplayerButtonCallback = 121,
+			multiplayerplayerButtonCallback = 122,
+			creditsButtonCallback = 123,
+			tutorialButtonCallback = 124,
+			init = 125,
+			close = 126,
+			update = 127,
+			render = 128,
+			pause = 129,
+			resume = 130,
+			keyInput = 131,
+			windowResize = 132,
+			mouseInput = 133,
+			mouseButtonInput = 134,
+			renderBackground = 135,
+		};
+		enum class StateGame : int {
+			StateGame = 136,
+			resetMouse = 137,
+			updateProjection2D = 138,
+			viewportCallback = 139,
+			updateChatMessages = 140,
+			init = 141,
+			close = 142,
+			pause = 143,
+			resume = 144,
+			update = 145,
+			render = 146,
+			mouseInput = 147,
+			scrollInput = 148,
+			mouseButtonInput = 149,
+			keyInput = 150,
+			windowResize = 151,
+			charInput = 152,
+			updateProjection = 153,
+			setWorld = 154,
+			addChatMessage = 155,
+		};
+		enum class StateWorldGen : int {
+			updateProjection = 156,
+			init = 157,
+			update = 158,
+			render = 159,
+			windowResize = 160,
+		};
+		enum class StateMultiplayer : int {
+			destr_StateMultiplayer = 161,
+			StateMultiplayer = 162,
+			updateProjection = 163,
+			cancelButtonCallback = 164,
+			changeSkinButtonCallback = 165,
+			joinButtonCallback = 166,
+			viewportCallback = 167,
+			uuidCopyButtonCallback = 168,
+			init = 169,
+			close = 170,
+			update = 171,
+			render = 172,
+			mouseInput = 173,
+			scrollInput = 174,
+			mouseButtonInput = 175,
+			keyInput = 176,
+			windowResize = 177,
+			charInput = 178,
+			rejoin = 179,
+			connect = 180,
+			connectionErrorOkButtonCallback = 181,
+		};
+		enum class StateSingleplayer : int {
+			mouseButtonInput = 182,
+			updateProjection = 183,
+			StateSingleplayer = 184,
+			updateWorldListContainer = 185,
+			createCallback = 186,
+			viewportCallback = 187,
+			worldButtonCallback = 188,
+			init = 189,
+			close = 190,
+			update = 191,
+			resume = 192,
+			windowResize = 193,
+			queueWorldLoad = 194,
+		};
+		enum class StateDeathScreen : int {
+			updateProjection = 195,
+			retryButtonCallback = 196,
+			init = 197,
+			close = 198,
+			update = 199,
+			render = 200,
+			mouseInput = 201,
+			scrollInput = 202,
+			mouseButtonInput = 203,
+			keyInput = 204,
+			windowResize = 205,
+		};
+		enum class StateErrorScreen : int {
+			okButtonCallback = 206,
+			init = 207,
+			close = 208,
+			update = 209,
+			render = 210,
+			mouseButtonInput = 211,
+			windowResize = 212,
+		};
+		enum class StateIntro : int {
+			updateProjection = 213,
+			loadFiles = 214,
+			init = 215,
+			update = 216,
+			render = 217,
+			windowResize = 218,
+		};
+		enum class StateTutorial : int {
+			destr_StateTutorial = 219,
+			StateTutorial = 220,
+			updateProjection = 221,
+			backButtonCallback = 222,
+			nextButtonCallback = 223,
+			generateMesh = 224,
+			getSmoothLighting = 225,
+			updatePlayerComponentVectors = 226,
+			updatePlayerPos = 227,
+			updateCurrentBlock = 228,
+			handleCollision = 229,
+			setForgSprite = 230,
+			init = 231,
+			close = 232,
+			update = 233,
+			render = 234,
+			resume = 235,
+			mouseInput = 236,
+			scrollInput = 237,
+			mouseButtonInput = 238,
+			keyInput = 239,
+			windowResize = 240,
+			charInput = 241,
+			updateViewport = 242,
+		};
+		enum class StateTutorialSlideshow : int {
+			destr_StateTutorialSlideshow = 243,
+			StateTutorialSlideshow = 244,
+			updateProjection = 245,
+			updateSlideSize = 246,
+			viewportCallback = 247,
+			init = 248,
+			update = 249,
+			render = 250,
+			resume = 251,
+			windowResize = 252,
+			continueButtonCallback = 253,
+			backButtonCallback = 254,
+			setSlide = 255,
+		};
+		enum class StateSkinChooser : int {
+			mouseInput = 256,
+			scrollInput = 257,
+			keyInput = 258,
+			StateSkinChooser = 259,
+			updateProjection = 260,
+			viewportCallback = 261,
+			chooseFileButtonCallback = 262,
+			init = 263,
+			close = 264,
+			update = 265,
+			render = 266,
+			windowResize = 267,
+			fileDrop = 268,
+			getSkinMessage = 269,
+			loadSkin = 270,
+		};
+		enum class StateSettings : int {
+			updateProjection = 271,
+			destr_StateSettings = 272,
+			StateSettings = 273,
+			getSetting = 274,
+			renderDistanceSliderCallback = 275,
+			scrollSensitivitySliderCallback = 276,
+			lookSensitivitySliderCallback = 277,
+			xInvertCheckBoxCallback = 278,
+			yInvertCheckBoxCallback = 279,
+			fovSliderCallback = 280,
+			globalVolumeSliderCallback = 281,
+			musicVolumeSliderCallback = 282,
+			creatureVolumeSliderCallback = 283,
+			ambienceVolumeSliderCallback = 284,
+			controlsButtonCallback = 285,
+			controlsOkButtonCallback = 286,
+			fullscreenButtonCallback = 287,
+			difficultySliderCallback = 288,
+			smoothLightingCheckBoxCallback = 289,
+			shadowsCheckBoxCallback = 290,
+			lightsCheckBoxCallback = 291,
+			chatCheckBoxCallback = 292,
+			nametagsCheckBoxCallback = 293,
+			skinsCheckBoxCallback = 294,
+			secretButtonCallback = 295,
+			viewportCallback = 296,
+			updateStateGame = 297,
+			updateVolume = 298,
+			load = 299,
+			save = 300,
+			init = 301,
+			close = 302,
+			render = 303,
+			mouseInput = 304,
+			scrollInput = 305,
+			mouseButtonInput = 306,
+			keyInput = 307,
+			windowResize = 308,
+			updateRenderDistance = 309,
+			updateFOV = 310,
+			updateCreatureVolume = 311,
+			updateAmbienceVolume = 312,
+			updateDifficulty = 313,
+			setFullscreenMode = 314,
+		};
+		enum class StatePause : int {
+			StatePause = 315,
+			updateProjection = 316,
+			update = 317,
+			render = 318,
+			pause = 319,
+			resume = 320,
+			windowResize = 321,
+		};
+		enum class StateManager : int {
+			pushState = 322,
+		};
+		namespace m4_Nested {
+			enum class Mat5 : int {
+				operatorInd = 323,
+				Mat5 = 324,
+				Mat5A = 325,
+				toJson = 326,
+				operatorMult = 327,
+				operatorMultEQ = 328,
+				multiply = 329,
+				operatorMult_A = 330,
+				translate = 331,
+				scale = 332,
+			};
+		}
+		namespace m4_Nested {
+			enum class Rotor : int {
+				Rotor = 333,
+				RotorA = 334,
+				operatorMultEq = 335,
+				rotate = 336,
+				normalize = 337,
+			};
+		}
+		namespace m4_Nested {
+			enum class BiVector4 : int {
+				BiVector4 = 338,
+				BiVector4A = 339,
+				toJson = 340,
+				normalize = 341,
+			};
+		}
+		enum class m4 : int {
+			i64vec3ToJson = 342,
+			ivec4ToJson = 343,
+			vec4ToJson = 344,
+			vec4FromJson = 345,
+			cross = 346,
+			adjustToMaxHorizSpeed = 347,
+			createCamera = 833,
+		};
+		enum class Item : int {
+			loadItemInfo = 348,
+			renderItem = 349,
+			renderItemDescription = 350,
+			createFromJson = 351,
+			giveMax = 352,
+			giveOne = 353,
+			instantiateItem = 354,
+			combineItemAttributes = 355,
+			save = 356,
+			destr_Item = 357,
+			takeMax = 358,
+			takeHalf = 359,
+		};
+		enum class World : int {
+			World = 360,
+			getChunk = 361,
+			getChunkFromCoords = 362,
+			getEntityIntersection = 363,
+			castRay = 364,
+			addEntityToChunk = 365,
+		};
+		namespace BlockInfo_Nested {
+			enum class ItemMesh : int {
+				destr_ItemMesh = 366,
+			};
+		}
+		enum class BlockInfo : int {
+			renderItemMesh = 367,
+		};
+		enum class ItemBlock : int {
+			render = 368,
+			renderEntity = 369,
+			isDeadly = 370,
+			isCompatible = 371,
+			saveAttributes = 372,
+			action = 373,
+			postAction = 374,
+			clone = 375,
+		};
+		enum class ItemTool : int {
+			render = 376,
+			renderEntity = 377,
+			isDeadly = 378,
+			isCompatible = 379,
+			getStackLimit = 380,
+			action = 381,
+			breakBlock = 382,
+			entityAction = 383,
+			clone = 384,
+		};
+		enum class ItemMaterial : int {
+			getStackLimit = 385,
+			getName = 386,
+			render = 387,
+			renderEntity = 388,
+			isDeadly = 389,
+			isCompatible = 390,
+			action = 391,
+			postAction = 392,
+			clone = 393,
+		};
+		namespace Chunk_Nested {
+			enum class ChunkMesh : int {
+				destr_ChunkMesh = 394,
+				ChunkMesh = 395,
+				buffSize = 396,
+				attrCount = 397,
+				attrType = 398,
+				attrSize = 399,
+				attrStride = 400,
+				indexBuffData = 401,
+				move = 402,
+				addMeshSide = 403,
+				addMeshPlant = 404,
+			};
+		}
+		enum class Chunk : int {
+			Chunk = 405,
+			setBlock = 406,
+			generateMesh = 407,
+			updateEntitiesClient = 408,
+			clearEntities = 409,
+			render = 410,
+			updateLightingHeightMap = 411,
+			updateMesh = 412,
+			load = 413,
+			save = 414,
+			loadFromMessage = 415,
+			updateCacheSection = 416,
+			updateHeightmapCacheSection = 417,
+			generateMeshSection = 418,
+			getSmoothLighting = 419,
+			getLighting = 420,
+			enableMesh = 421,
+			loadEntitiesFromJson = 422,
+			getFilenamePrefix = 423,
+		};
+		namespace ChunkLoader_Nested {
+			enum class BiomeInfo : int {
+				destr_BiomeInfo = 424,
+				BiomeInfo = 425,
+			};
+		}
+		enum class ChunkLoader : int {
+			init = 426,
+			loadChunk = 427,
+			loadBiomes = 428,
+			loadInfo = 429,
+			generateChunk = 430,
+			getBiome = 431,
+			generateTree = 432,
+			generateTreeBranch = 433,
+			generateTaigaTree = 434,
+			createFlatWorldChests = 435,
+		};
+		namespace CloudChunk_Nested {
+			enum class CloudChunkMesh : int {
+				indexBuffSize = 436,
+				buffSize = 437,
+				attrSize = 438,
+				attrStride = 439,
+				move = 440,
+				destr_CloudChunkMesh = 441,
+			};
+		}
+		enum class CloudChunk : int {
+			generateMesh = 442,
+		};
+		enum class CloudManager : int {
+			destr_CloudManager = 443,
+			render = 444,
+			updateChunks = 445,
+			unloadAllChunks = 446,
+			loadChunks = 447,
+			updateChunk = 448,
+		};
+		namespace CraftingMenu_Nested {
+			enum class CraftableRecipe : int {
+				destr_CraftableRecipe = 449,
+				CraftableRecipe = 450,
+			};
+		}
+		enum class CraftingMenu : int {
+			loadRecipes = 451,
+			render = 452,
+			offsetX = 453,
+			offsetY = 454,
+			getPos = 455,
+			getSize = 456,
+			mouseButtonInput = 457,
+			updateAvailableRecipes = 458,
+		};
+		enum class Entity : int {
+			loadEntityInfo = 459,
+			createFromJson = 460,
+			createWithAttributes = 461,
+			save = 462,
+			instantiateEntity = 463,
+			combineEntityAttributes = 464,
+			destr_Entity = 465,
+		};
+		enum class InventoryPlayer : int {
+			addItem = 466,
+			begin = 467,
+			render = 468,
+			combineItem = 469,
+			placeItem = 470,
+			getSlotIndex = 471,
+			getSlotCount = 472,
+			getSlot = 473,
+			end = 474,
+		};
+		enum class InventoryGrid : int {
+			destr_InventoryGrid = 475,
+			InventoryGrid = 476,
+			render = 477,
+			combineItem = 478,
+			placeItem = 479,
+			getSlotIndex = 480,
+			getSlotCount = 481,
+			getSlot = 482,
+			end = 483,
+			load = 484,
+			save = 485,
+		};
+		enum class InventorySession : int {
+			destr_InventorySession = 486,
+		};
+		enum class InventoryManager : int {
+			destr_InventoryManager = 487,
+			renderInit = 488,
+			mouseButtonInput = 489,
+			windowResize = 490,
+			applyAction = 491,
+			applyTransfer = 492,
+			findInventory = 493,
+			updateCraftingMenuBox = 494,
+			craftingMenuCallback = 495,
+			viewportCallback = 496,
+			updateProjection = 497,
+		};
+		enum class MeshBuilder : int {
+			MeshBuilder = 498,
+			MeshBuilder_A = 499,
+			destr_MeshBuilder = 500,
+			buffCount = 501,
+			buffSize = 502,
+			attrCount = 503,
+			vertCount = 504,
+			indexBuffSize = 505,
+			addBuff = 506,
+			attrType = 507,
+			attrSize = 508,
+			attrStride = 509,
+			addAttr = 510,
+			clear = 511,
+		};
+		enum class Player : int {
+			destr_Player = 512,
+			Player = 513,
+			updatePos = 514,
+			updateCurrentBlock = 515,
+			handleCollision = 516,
+			updateComponentVectors = 517,
+			updateAllComponentVectors = 518,
+			removeVelComp = 519,
+			updateTargetBlock = 520,
+			init = 521,
+			renderHud = 522,
+			renderTargetBlock = 523,
+			getMovementUpdate = 524,
+			setMovementBehavior = 525,
+			hitTargetBlock = 526,
+			breakBlock = 527,
+			throwItem = 528,
+			update = 529,
+			updateLocal = 530,
+			updateCameraPos = 531,
+			resetMouse = 532,
+			keyInput = 533,
+			mouseInput = 534,
+			mouseButtonInput = 535,
+			isHoldingGlasses = 536,
+			isHoldingCompass = 537,
+			isHoldingCollector = 538,
+			headIsInBlock = 539,
+			getHeadBlock = 540,
+			respawn = 541,
+			load = 542,
+			save = 543,
+			loadClientData = 544,
+			saveClientData = 545,
+			saveOrientation = 546,
+		};
+		enum class QuadRenderer : int {
+			destr_QuadRenderer = 547,
+			init = 548,
+			setColor = 549,
+			setPos = 550,
+		};
+		enum class ResourceManager : int {
+			loadArrayTexture = 551,
+			get = 552,
+		};
+		enum class ShaderManager : int {
+			loadFromShaderList = 553,
+			get = 554,
+		};
+		enum class Shader : int {
+			load = 555,
+			compileShader = 556,
+		};
+		enum class WorldManager : int {
+			destr_WorldManager = 557,
+			updateRenderFrustum = 558,
+			setBlockUpdate = 559,
+			render = 560,
+		};
+		enum class WorldClient : int {
+			destr_WorldClient = 561,
+			addEntityToChunk = 562,
+			localPlayerEvent = 563,
+			updateLocal = 564,
+			setRenderDistanceLocal = 565,
+			setSkinVisibility = 566,
+			localPlayerInit = 567,
+			localPlayerRespawn = 568,
+			sendChatMessage = 569,
+			updatePhysics = 570,
+			handleWorldMessage = 571,
+			handleLightingOptionsUpdate = 572,
+			updateChunks = 573,
+			updateChunk = 574,
+			generateChunkMeshes = 575,
+			updateChunkCacheAndMesh = 576,
+			updateChunkCache = 577,
+			regenerateAllChunkMeshes = 578,
+			joinAllChunkLoadingThreads = 579,
+			handleMessage = 580,
+			inventoryUpdateCallback = 581,
+		};
+		enum class WorldSingleplayer : int {
+			WorldSingleplayer = 582,
+			destr_WorldSingleplayer = 583,
+			localPlayerEvent = 584,
+			updateLocal = 585,
+			cleanupLocal = 586,
+			setRenderDistanceLocal = 587,
+			setDifficultyLocal = 588,
+			localPlayerInit = 589,
+			localPlayerRespawn = 590,
+			handleLightingOptionsUpdate = 591,
+			updateChunks = 592,
+			updateChunk = 593,
+			loadChunks = 594,
+			loadChunk = 595,
+			updateChunkCacheAndMesh = 596,
+			updateChunkCache = 597,
+			regenerateAllChunkMeshes = 598,
+		};
+		namespace gui_Nested {
+			enum class Button : int {
+				destr_Button = 599,
+				render = 600,
+				mouseButtonInput = 601,
+				keyInput = 602,
+				offsetX = 603,
+				enabled = 604,
+				select = 605,
+				getPos = 606,
+				getSize = 607,
+				touchingMouse = 608,
+			};
+		}
+		namespace gui_Nested {
+			enum class CheckBox : int {
+				render = 609,
+				mouseButtonInput = 610,
+				keyInput = 611,
+				getPos = 612,
+				getSize = 613,
+				touchingMouse = 614,
+			};
+		}
+		namespace gui_Nested {
+			enum class ContentBox : int {
+				destr_ContentBox = 615,
+				getQuadRenderer = 616,
+				getFont = 617,
+				getGLFWwindow = 618,
+				getCursorPos = 619,
+				getSize = 620,
+				changeViewport = 621,
+				getPos = 622,
+				getSizeA = 623,
+				touchingMouse = 624,
+				resetViewport = 625,
+				render = 626,
+				alignX = 627,
+				alignY = 628,
+				offsetX = 629,
+				offsetY = 630,
+				mouseInput = 631,
+				scrollInput = 632,
+				mouseButtonInput = 633,
+				keyInput = 634,
+				select = 635,
+				deselect = 636,
+				addElement = 637,
+				removeElement = 638,
+				selectElement = 639,
+				clear = 640,
+				empty = 641,
+			};
+		}
+		namespace gui_Nested {
+			enum class Element : int {
+				enabled = 642,
+				getCursorType = 643,
+			};
+		}
+		namespace gui_Nested {
+			enum class Image : int {
+				offsetX = 644,
+				offsetY = 645,
+				render = 646,
+				getPos = 647,
+				getSize = 648,
+			};
+		}
+		namespace gui_Nested {
+			enum class Interface : int {
+				Interface = 649,
+				destr_Interface = 650,
+				render = 651,
+				mouseInput = 652,
+				scrollInput = 653,
+				mouseButtonInput = 654,
+				keyInput = 655,
+				getQuadRenderer = 656,
+				getFont = 657,
+				getGLFWwindow = 658,
+				getCursorPos = 659,
+				getSize = 660,
+				changeViewport = 661,
+				addElement = 662,
+				removeElement = 663,
+				selectElement = 664,
+				clear = 665,
+				empty = 666,
+			};
+		}
+		namespace gui_Nested {
+			enum class Slider : int {
+				offsetX = 667,
+				offsetY = 668,
+				deselect = 669,
+				render = 670,
+				mouseButtonInput = 671,
+				mouseInput = 672,
+				keyInput = 673,
+				alignX = 674,
+				alignY = 675,
+				getPos = 676,
+				getSize = 677,
+			};
+		}
+		namespace gui_Nested {
+			enum class Text : int {
+				render = 678,
+				offsetX = 679,
+				getPos = 680,
+				getSize = 681,
+				setText = 682,
+				renderText = 683,
+			};
+		}
+		namespace gui_Nested {
+			enum class TextInput : int {
+				render = 684,
+				alignX = 685,
+				alignY = 686,
+				offsetX = 687,
+				offsetY = 688,
+				mouseButtonInput = 689,
+				mouseInput = 690,
+				keyInput = 691,
+				charInput = 692,
+				getCursorType = 693,
+				select = 694,
+				deselect = 695,
+				updatePasswordVisualText = 696,
+				updateScrollPos = 697,
+				getPos = 698,
+				getSize = 699,
+				removeInvalidChars = 700,
+				removeHighlightedText = 701,
+			};
+		}
+		enum class EntityButterfly : int {
+			getName = 702,
+			update = 703,
+			render = 704,
+			getServerUpdateAttributes = 705,
+			applyServerUpdate = 706,
+			takeDamage = 707,
+			playHitSound = 708,
+			playDeathSound = 709,
+			collisionCallback = 710,
+		};
+		namespace EntityAlidade_Nested {
+			enum class SPInfo : int {
+				SPInfo = 711,
+				destr_SPInfo = 712,
+			};
+		}
+		enum class EntityAlidade : int {
+			getName = 713,
+			update = 714,
+			render = 715,
+			saveAttributes = 716,
+			getPos = 717,
+			setPos = 718,
+			takeDamage = 719,
+			action = 720,
+			postAction = 721,
+			generateSpherinder = 722,
+			generateSpherinderHollow = 723,
+			generateSemicircle = 724,
+		};
+		enum class EntityItem : int {
+			createWithItem = 725,
+			getName = 726,
+			update = 727,
+			render = 728,
+			saveAttributes = 729,
+			applyServerUpdate = 730,
+			getPos = 731,
+			setPos = 732,
+			shouldSave = 733,
+			isIntersectingRay = 734,
+			give = 735,
+			combineWithNearby = 736,
+			collisionCallback = 737,
+		};
+		enum class EntityPlayer : int {
+			createFromPlayer = 738,
+			EntityPlayer = 739,
+			getName = 740,
+			update = 741,
+			render = 742,
+			saveAttributes = 743,
+			applyServerUpdate = 744,
+			getPos = 745,
+			setPos = 746,
+			isIntersectingRay = 747,
+			takeDamage = 748,
+			deathTimer = 749,
+			applyMovementUpdate = 750,
+			collectItems = 751,
+		};
+		namespace EntitySpider_Nested {
+			enum class SpiderType : int {
+				destr_SpiderType = 752,
+			};
+		}
+		enum class EntitySpider : int {
+			isIntersectingRay = 753,
+			getPos = 754,
+			setPos = 755,
+			getName = 756,
+			update = 757,
+			render = 758,
+			saveAttributes = 759,
+			getServerUpdateAttributes = 760,
+			applyServerUpdate = 761,
+			takeDamage = 762,
+			playHitSound = 763,
+			playDeathSound = 764,
+			collisionCallback = 765,
+			findPlayer = 766,
+			persuePlayer = 767,
+		};
+		enum class EntityChest : int {
+			isClickable = 768,
+			getName = 769,
+			update = 770,
+			render = 771,
+			saveAttributes = 772,
+			getServerUpdateAttributes = 773,
+			applyServerUpdate = 774,
+			getPos = 775,
+			setPos = 776,
+			action = 777,
+		};
+		enum class EntityDying : int {
+			deathTimer = 778,
+			createWithEntity = 779,
+			getName = 780,
+			update = 781,
+			render = 782,
+			getServerUpdateAttributes = 783,
+			applyServerUpdate = 784,
+			getPos = 785,
+			setPos = 786,
+			isBlockEntity = 787,
+			isIntersectingRay = 788,
+		};
+		enum class EntityManager : int {
+			extract = 789,
+			get = 790,
+			getBlockEntity = 791,
+		};
+		enum class Coil : int {
+			Coil = 792,
+			buffSize = 793,
+			attrSize = 794,
+		};
+		enum class CompassRenderer : int {
+			renderHand = 795,
+			renderItemDrop = 796,
+		};
+		enum class DodecaplexWireframe : int {
+			generateMesh = 797,
+			addFaces = 798,
+			addCells = 799,
+		};
+		enum class Framebuffer : int {
+			destr_Framebuffer = 800,
+			render = 801,
+			init = 802,
+			cleanup = 803,
+		};
+		enum class HypercubeHollow : int {
+			attrSize = 804,
+			attrStride = 805,
+			HypercubeHollow = 806,
+			addCubeSide = 807,
+		};
+		enum class PlayerSkinRenderer : int {
+			PlayerSkinRenderer = 808,
+			render = 809,
+			updateAnimation = 810,
+			resetTransformations = 811,
+		};
+		enum class PlayerSkinViewer : int {
+			render = 812,
+			alignX = 813,
+			alignY = 814,
+			getPos = 815,
+			getSize = 816,
+			mouseInput = 817,
+			getCursorType = 818,
+			init = 819,
+			setupFrameBuffer = 820,
+		};
+		enum class Sphere : int {
+			vertCount = 821,
+			buffSize = 822,
+			Sphere = 823,
+			generateCirclePolygons = 824,
+		};
+		enum class main_cpp : int {
+			main = 825,
+			handleRawMouseInput = 826,
+			scrollCallback = 827,
+			mouseButtonCallback = 828,
+			keyCallback = 829,
+			framebufferSizeCallback = 830,
+			charCallback = 831,
+			fileDropCallback = 832,
+		};
+	}
+
+	inline void startConsole()
+	{
+		return reinterpret_cast<void(__stdcall*)()>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "startConsole"))();
+	}
+
+	inline uint64_t getFuncAddr(int func)
+	{
+		return reinterpret_cast<uint64_t(__stdcall*)(int)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "getFuncAddr"))(func);
+	}
+	inline bool isModLoaded(const msvc_string& modId)
+	{
+		return reinterpret_cast<bool(__stdcall*)(const msvc_string&)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "isModLoaded"))(modId);
+	}
+	inline bool isDLLLoaded(const msvc_string& dllFileName)
+	{
+		return reinterpret_cast<bool(__stdcall*)(const msvc_string&)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "isDLLLoaded"))(dllFileName);
+	}
+	inline msvc_string getModDLL(const msvc_string& modId)
+	{
+		return reinterpret_cast<msvc_string(__stdcall*)(const msvc_string&)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "getModDLL"))(modId);
+	}
+	inline msvc_string getModVersion(const msvc_string& modId)
+	{
+		return reinterpret_cast<msvc_string(__stdcall*)(const msvc_string&)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "getModVersion"))(modId);
+	}
+	inline std::string getModName(const msvc_string& modId)
+	{
+		return reinterpret_cast<msvc_string(__stdcall*)(const msvc_string&)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "getModName"))(modId);
+	}
+	inline msvc_string getModAuthor(const msvc_string& modId)
+	{
+		return reinterpret_cast<msvc_string(__stdcall*)(const msvc_string&)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "getModAuthor"))(modId);
+	}
+	inline msvc_string getModDescription(const msvc_string& modId)
+	{
+		return reinterpret_cast<msvc_string(__stdcall*)(const msvc_string&)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "getModDescription"))(modId);
+	}
+	inline HMODULE getModHandle(const msvc_string& modId)
+	{
+		return reinterpret_cast<HMODULE(__stdcall*)(const msvc_string&)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "getModHandle"))(modId);
+	}
+	inline msvc_string getModloaderVersion()
+	{
+		return reinterpret_cast<msvc_string(__stdcall*)()>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "getModloaderVersion"))();
+	}
+	inline msvc_string getGameVersion()
+	{
+		return reinterpret_cast<msvc_string(__stdcall*)()>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "getGameVersion"))();
+	}
+	inline std::string getModPath(const msvc_string& modId)
+	{
+		return reinterpret_cast<msvc_string(__stdcall*)(const msvc_string&)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "getModPath"))(modId);
+	}
+	// useful for creating library mod headers
+	inline FARPROC getModFuncPointer(const msvc_string& modId, const msvc_string& funcName)
+	{
+		HMODULE modModule = getModHandle(modId);
+		if (modModule == nullptr) return nullptr;
+		return GetProcAddress(modModule, funcName.c_str());
+	}
+
+	/* 
+	Compares two version strings with an operator string
+	operators are "==" | ">=" | "<=" | "<" | ">" | "!="
+	it is used by modloader to check dependency versions
+	*/
+	inline bool versionCompare(const msvc_string& aVer, const msvc_string& op, const msvc_string& bVer)
+	{
+		return reinterpret_cast<bool(__stdcall*)(const msvc_string&, const msvc_string&, const msvc_string&)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "versionCompare"))(aVer, op, bVer);
+	}
+	// splits string by a delimiter
+	inline std::vector<msvc_string> splitStr(const msvc_string& str, char delim) {
+		std::vector<msvc_string> tokens;
+		size_t pos = 0;
+		size_t len = str.length();
+		tokens.reserve(len / 2);  // allocate memory for expected number of tokens
+
+		while (pos < len)
+		{
+			size_t end = std::string(str).find_first_of(delim, pos);
+			if (end == std::string::npos)
+			{
+				tokens.emplace_back(std::string(str).substr(pos));
+				break;
+			}
+			tokens.emplace_back(std::string(str).substr(pos, end - pos));
+			pos = end + 1;
+		}
+
+		return tokens;
+	}
 }
 
-#include "addresses.h"
+#include "Console.h"
 
-#include "msvc_string.h"
+// used by modloader
+extern "C" inline __declspec(dllexport) void setModID(const msvc_string& modID) { fdm::modID = modID; }
 
 // Connection namespace
 #include "Connection/MessageData.h"
@@ -181,7 +1358,129 @@ namespace fdm
 #include "StateTutorialSlideshow.h"
 #include "StateWorldGen.h"
 
-extern "C" inline __declspec(dllexport) const char* getModName() { return MOD_NAME; }
-extern "C" inline __declspec(dllexport) const char* getModVer() { return MOD_VER; }
+// allows to execute any code at any location
+#define $exec                                                                                  \
+	template <class>                                                                              \
+	void CONCAT(fdmEFunc, __LINE__)();                                             \
+	namespace \
+	{                                                                                   \
+		struct CONCAT(fdmEFuncU, __LINE__) {};                                         \
+	}                                                                                             \
+	static inline auto CONCAT(fdmEFuncC, __LINE__) =                                             \
+		(CONCAT(fdmEFunc, __LINE__) < CONCAT(fdmEFuncU, __LINE__) > (), \
+		 0);                                                                                      \
+	template <class>                                                                              \
+	void CONCAT(fdmEFunc, __LINE__)()
+
+/*
+creates a hook for a member function (__thiscall)
+to call the original function, do `original(self, <all of the you have arguments>)`
+`this` pointer is called `self`
+*/
+#define $hook(returnType, cl, function, ...) \
+	namespace fdmHooks::cl \
+	{ \
+		using namespace fdm; \
+		class CONCAT(function, H) \
+		{ \
+		public: \
+			inline static returnType(__thiscall* original)(fdm::cl* self, ##__VA_ARGS__) = nullptr; \
+			static returnType __fastcall hook(fdm::cl* self, ##__VA_ARGS__); \
+		}; \
+	} \
+	$exec \
+	{ \
+		uint64_t hookAddr = getFuncAddr((int)(fdm::Func::cl::function)); \
+		if(hookAddr <= 0) { printf("Failed To Hook " #cl "::" #function "\n"); return; } \
+		Hook(hookAddr, &fdmHooks::cl::CONCAT(function, H)::hook, &fdmHooks::cl::CONCAT(function, H)::original); \
+		EnableHook(); \
+	} \
+	inline returnType __fastcall fdmHooks::cl::CONCAT(function, H)::hook(fdm::cl* self, ##__VA_ARGS__)
+
+/*
+creates a hook for a member function (__thiscall) using Func namespace. Useful for hooking functions of classes inside classes/namespaces (like gui classes). Because it turned out to not work properly with those (yea i havent tested it properly previously bruh)
+to call the original function, do `original(self, <all of the you have arguments>)`
+`this` pointer is called `self`
+*/
+#define $hookByFunc(returnType, className, func, ...) \
+	namespace CONCAT(fdmHooks, __LINE__) \
+	{ \
+		class H \
+		{ \
+		public: \
+			inline static returnType(__thiscall* original)(fdm::className* self, __VA_ARGS__) = nullptr; \
+			static returnType __fastcall hook(fdm::className* self, __VA_ARGS__); \
+		}; \
+	} \
+	$exec \
+	{ \
+		uint64_t hookAddr = getFuncAddr((int)(fdm::func)); \
+		if(hookAddr <= 0) { printf("Failed To Hook " #func "\n"); return; } \
+		Hook(hookAddr, &CONCAT(fdmHooks, __LINE__)::H::hook, &CONCAT(fdmHooks, __LINE__)::H::original); \
+		EnableHook(); \
+	} \
+	inline returnType __fastcall CONCAT(fdmHooks, __LINE__)::H::hook(fdm::className* self, __VA_ARGS__)
 
-#endif
\ No newline at end of file
+/*
+creates a hook for a static function (__fastcall)
+to call the original function, do `original(<all of the you have arguments>)`
+*/
+#define $hookStatic(returnType, cl, function, ...) \
+	namespace fdmHooks::cl \
+	{ \
+		class CONCAT(function, H)  \
+		{ \
+		public: \
+			inline static returnType(__fastcall* original)(__VA_ARGS__) = nullptr;\
+			static returnType __fastcall hook(__VA_ARGS__); \
+		}; \
+	} \
+	$exec \
+	{ \
+		uint64_t hookAddr = getFuncAddr((int)(fdm::Func::cl::function)); \
+		if(hookAddr <= 0) { printf("Failed To Hook " #cl "::" #function "\n"); return; } \
+		Hook(hookAddr, &fdmHooks::cl::CONCAT(function, H)::hook, &fdmHooks::cl::CONCAT(function, H)::original); \
+		EnableHook(); \
+	} \
+	inline returnType __fastcall fdmHooks::cl::CONCAT(function, H)::hook(__VA_ARGS__)
+
+/*
+creates a hook for a static function (__fastcall) using Func namespace. Useful for hooking functions of classes inside classes/namespaces (like gui classes). Because it turned out to not work properly with those (yea i havent tested it properly previously bruh)
+to call the original function, do `original(<all of the you have arguments>)`
+*/
+#define $hookStaticByFunc(returnType, func, ...) \
+	namespace CONCAT(fdmHooks, __LINE__) \
+	{ \
+		class H \
+		{ \
+		public: \
+			inline static returnType(__fastcall* original)(__VA_ARGS__) = nullptr; \
+			static returnType __fastcall hook(__VA_ARGS__); \
+		}; \
+	} \
+	$exec \
+	{ \
+		uint64_t hookAddr = getFuncAddr((int)(fdm::func)); \
+		if(hookAddr <= 0) { printf("Failed To Hook " #func "\n"); return; } \
+		Hook(hookAddr, &CONCAT(fdmHooks, __LINE__)::H::hook, &CONCAT(fdmHooks, __LINE__)::H::original); \
+		EnableHook(); \
+	} \
+	inline returnType __fastcall CONCAT(fdmHooks, __LINE__)::H::hook(__VA_ARGS__)
+
+#ifdef DEBUG_CONSOLE
+#define initDLL \
+	BOOL APIENTRY DllMain(HMODULE hModule, DWORD _reason, LPVOID lpReserved) \
+	{ \
+		if (_reason == DLL_PROCESS_ATTACH) \
+			fdm::startConsole(); \
+		return TRUE; \
+	}
+#else
+#define initDLL \
+	BOOL APIENTRY DllMain(HMODULE hModule, DWORD _reason, LPVOID lpReserved) \
+	{ \
+		return TRUE; \
+	}
+#endif
+
+#endif
diff --git a/4dm.h/4dm.h-main.zip b/4dm.h/4dm.h-main.zip
deleted file mode 100644
index e72c948..0000000
Binary files a/4dm.h/4dm.h-main.zip and /dev/null differ
diff --git a/4dm.h/AudioManager.h b/4dm.h/AudioManager.h
index aa2eb10..37ff41a 100644
--- a/4dm.h/AudioManager.h
+++ b/4dm.h/AudioManager.h
@@ -11,44 +11,43 @@ namespace fdm
 		{
 			uint32_t handle; 
 			float volume; // 0x4
-
 		};
 		//inline static SoLoud::Soloud *soloud = reinterpret_cast<SoLoud::Soloud*>((base + 0x29BD00)); 
-		inline static std::map<std::string,AudioManager::voiceGroupInfo>* voiceGroups = reinterpret_cast<std::map<std::string,AudioManager::voiceGroupInfo>*>((base + 0x29BCE0));
-		//inline static std::map<std::string,SoLoud::Wav,std::less<std::string >,std::allocator<std::pair<std::string const ,SoLoud::Wav> > > sounds = reinterpret_cast<std::map<std::string,SoLoud::Wav,std::less<std::string >,std::allocator<std::pair<std::string const ,SoLoud::Wav> > >*>((base + 0x29BCF0)); 
-		inline static std::vector<std::string>* BGMList = reinterpret_cast<std::vector<std::string>*>((base + 0x2C3E38));
-		inline static float* BGMVolume = reinterpret_cast<float*>((base + 0x2783B0));
-		inline static int* BGMNextIndex = reinterpret_cast<int*>((base + 0x29B3C0));
-		inline static uint32_t* currentBGM = reinterpret_cast<uint32_t*>((base + 0x29B3C4));
-		inline static m4::Mat5* hyperplaneView = reinterpret_cast<m4::Mat5*>((base + 0x2787A0));
+		inline static std::map<msvc_string,AudioManager::voiceGroupInfo>* voiceGroups = reinterpret_cast<std::map<msvc_string,AudioManager::voiceGroupInfo>*>((base + idaOffsetFix(0x2BCE0 + 0x270000)));
+		//inline static std::map<msvc_string,SoLoud::Wav,std::less<msvc_string >,std::allocator<std::pair<msvc_string const ,SoLoud::Wav> > > sounds = reinterpret_cast<std::map<msvc_string,SoLoud::Wav,std::less<msvc_string >,std::allocator<std::pair<msvc_string const ,SoLoud::Wav> > >*>((base + 0x29BCF0)); 
+		inline static std::vector<msvc_string>* BGMList = reinterpret_cast<std::vector<msvc_string>*>((base + idaOffsetFix(0x53E38 + 0x270000)));
+		inline static float* BGMVolume = reinterpret_cast<float*>((base + idaOffsetFix(0x83B0 + 0x270000)));
+		inline static int* BGMNextIndex = reinterpret_cast<int*>((base + idaOffsetFix(0x2B3C0 + 0x270000)));
+		inline static uint32_t* currentBGM = reinterpret_cast<uint32_t*>((base + idaOffsetFix(0x2B3C4 + 0x270000)));
+		inline static m4::Mat5* hyperplaneView = reinterpret_cast<m4::Mat5*>((base + idaOffsetFix(0x87A0 + 0x270000)));
 
-		inline static bool loadSound(const std::string& sound) 
+		inline static bool loadSound(const msvc_string& sound) 
 		{
-			return reinterpret_cast<bool (__fastcall*)(const std::string& sound)>(FUNC_AUDIOMANAGER_LOADSOUND)(sound);
+			return reinterpret_cast<bool (__fastcall*)(const msvc_string& sound)>(getFuncAddr((int)Func::AudioManager::loadSound))(sound);
 		}
-		inline static uint32_t playSound4D(std::string& sound, std::string& voiceGroup, const glm::vec4& pos, const glm::vec4& vel) 
+		inline static uint32_t playSound4D(msvc_string& sound, msvc_string& voiceGroup, const glm::vec4& pos, const glm::vec4& vel) 
 		{
-			return reinterpret_cast<uint32_t (__fastcall*)(std::string& sound, std::string& voiceGroup, const glm::vec4& pos, const glm::vec4& vel)>(FUNC_AUDIOMANAGER_PLAYSOUND4D)(sound, voiceGroup, pos, vel);
+			return reinterpret_cast<uint32_t (__fastcall*)(msvc_string& sound, msvc_string& voiceGroup, const glm::vec4& pos, const glm::vec4& vel)>(getFuncAddr((int)Func::AudioManager::playSound4D))(sound, voiceGroup, pos, vel);
 		}
 		inline static void setListenerInfo4D(glm::vec4& pos, const m4::Mat5* orientation, const glm::vec4& vel) 
 		{
-			return reinterpret_cast<void (__fastcall*)(glm::vec4& pos, const m4::Mat5* orientation, const glm::vec4& vel)>(FUNC_AUDIOMANAGER_SETLISTENERINFO4D)(pos, orientation, vel);
+			return reinterpret_cast<void (__fastcall*)(glm::vec4& pos, const m4::Mat5* orientation, const glm::vec4& vel)>(getFuncAddr((int)Func::AudioManager::setListenerInfo4D))(pos, orientation, vel);
 		}
-		inline static bool loadBGMfromJSON(const std::string& jsonListPath) 
+		inline static bool loadBGMfromJSON(const msvc_string& jsonListPath) 
 		{
-			return reinterpret_cast<bool (__fastcall*)(const std::string& jsonListPath)>(FUNC_AUDIOMANAGER_LOADBGMFROMJSON)(jsonListPath);
+			return reinterpret_cast<bool (__fastcall*)(const msvc_string& jsonListPath)>(getFuncAddr((int)Func::AudioManager::loadBGMfromJSON))(jsonListPath);
 		}
 		inline static bool updateBGM() 
 		{
-			return reinterpret_cast<bool (__fastcall*)()>(FUNC_AUDIOMANAGER_UPDATEBGM)();
+			return reinterpret_cast<bool (__fastcall*)()>(getFuncAddr((int)Func::AudioManager::updateBGM))();
 		}
-		/*inline static SoLoud::Wav getSound(std::string& sound) 
+		/*inline static SoLoud::Wav getSound(msvc_string& sound) 
 		{
-			return reinterpret_cast<SoLoud::Wav (__fastcall*)(std::string& sound)>(FUNC_AUDIOMANAGER_GETSOUND)(sound);
+			return reinterpret_cast<SoLoud::Wav (__fastcall*)(msvc_string& sound)>(getFuncAddr((int)Func::AudioManager::getSound))(sound);
 		}*/
-		inline static AudioManager::voiceGroupInfo getVoiceGroupInfo(std::string& voiceGroup) 
+		inline static AudioManager::voiceGroupInfo getVoiceGroupInfo(msvc_string& voiceGroup) 
 		{
-			return reinterpret_cast<AudioManager::voiceGroupInfo (__fastcall*)(std::string& voiceGroup)>(FUNC_AUDIOMANAGER_GETVOICEGROUPINFO)(voiceGroup);
+			return reinterpret_cast<AudioManager::voiceGroupInfo (__fastcall*)(msvc_string& voiceGroup)>(getFuncAddr((int)Func::AudioManager::getVoiceGroupInfo))(voiceGroup);
 		}
 	};
 }
diff --git a/4dm.h/BlockInfo.h b/4dm.h/BlockInfo.h
index fb2ae18..dde8a67 100644
--- a/4dm.h/BlockInfo.h
+++ b/4dm.h/BlockInfo.h
@@ -3,17 +3,47 @@
 #include "4dm.h"
 #include "MeshRenderer.h"
 
+// creates a cube out of tetrahedrons.
+// the offsets are ordered such that each vertex corresponds to one normal component,
+// which allows an index buffer to be used without needing a normal for each vertex.
+#define _cube_tet_indices(offset)\
+(offset)+0,(offset)+6,(offset)+5,(offset)+3,\
+(offset)+0,(offset)+1,(offset)+5,(offset)+3,\
+(offset)+0,(offset)+6,(offset)+2,(offset)+3,\
+(offset)+0,(offset)+6,(offset)+5,(offset)+4,\
+(offset)+7,(offset)+6,(offset)+5,(offset)+3
+
+#define _cube_normal(x, y, z, w)\
+{ (x), (y), (z), (w) },\
+{ (w), (z), (y), (x) }
+
 namespace fdm 
 {
 	class BlockInfo 
 	{
 	public:
+		struct BlockData
+		{
+			glm::u8vec4* tuv_top; // 0x0
+			glm::u8vec4* tuv_side; // 0x8
+			glm::u8vec4* tuv_bottom; // 0x10
+			glm::u8vec4* tuv_full_block; // 0x18
+			glm::u8vec4* uv_top; // 0x20
+			glm::u8vec4* uv_side; // 0x28
+			glm::u8vec4* uv_bottom; // 0x30
+			bool solid; // 0x38
+			bool opaque; // 0x39
+			bool plant; // 0x3A
+			glm::u8vec3 glowColor; // 0x3B
+			PAD(2);
+		};
+		// size is BlockInfo::BLOCK_COUNT
+		inline static const BlockData* Blocks = reinterpret_cast<BlockData*>(base + 0x23F690);
 		struct VertLighting 
 		{
-			uint32_t ambient; 
-			uint32_t shadow; // 0x1
+			uint8_t ambient; 
+			uint8_t shadow; // 0x1
 			glm::u8vec3 glow; // 0x2
-
 		};
 		struct ItemMesh 
 		{
@@ -21,7 +51,7 @@ namespace fdm
 
 			~ItemMesh() 
 			{
-				reinterpret_cast<void(__thiscall*)(BlockInfo::ItemMesh* self)>(FUNC_BLOCKINFO_ITEMMESH_DESTR_ITEMMESH)(this);
+				reinterpret_cast<void(__thiscall*)(BlockInfo::ItemMesh* self)>(getFuncAddr((int)Func::BlockInfo_Nested::ItemMesh::destr_ItemMesh))(this);
 			}
 		};
 
@@ -77,113 +107,231 @@ namespace fdm
 		inline static const int CUBE_VERT_COUNT = 8; 
 		inline static const int HYPERCUBE_VERT_COUNT = 64; 
 		inline static const int PLANT_VERT_COUNT = 48; 
-		inline static glm::u8vec4** tuv_grass_top = reinterpret_cast<glm::u8vec4**>((base + 0x2AA740));
-		inline static glm::u8vec4* *tuv_grass_side = reinterpret_cast<glm::u8vec4**>((base + 0x2AC730)); 
-		inline static glm::u8vec4* *tuv_grass_full = reinterpret_cast<glm::u8vec4**>((base + 0x2A9E70)); 
-		inline static glm::u8vec3* *uv_grass_top = reinterpret_cast<glm::u8vec3**>((base + 0x2AA230)); 
-		inline static glm::u8vec3* *uv_grass_side = reinterpret_cast<glm::u8vec3**>((base + 0x2AB590)); 
-		inline static glm::u8vec4* *tuv_dirt = reinterpret_cast<glm::u8vec4**>((base + 0x2AB0A0)); 
-		inline static glm::u8vec4* *tuv_dirt_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AC7B0)); 
-		inline static glm::u8vec3* *uv_dirt = reinterpret_cast<glm::u8vec3**>((base + 0x2AB980)); 
-		inline static glm::u8vec4* *tuv_stone = reinterpret_cast<glm::u8vec4**>((base + 0x2ABB70)); 
-		inline static glm::u8vec4* *tuv_stone_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AB9B0)); 
-		inline static glm::u8vec3* *uv_stone = reinterpret_cast<glm::u8vec3**>((base + 0x2A9E00)); 
-		inline static glm::u8vec4* *tuv_lava = reinterpret_cast<glm::u8vec4**>((base + 0x2AC180)); 
-		inline static glm::u8vec4* *tuv_lava_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AC610)); 
-		inline static glm::u8vec3* *uv_lava = reinterpret_cast<glm::u8vec3**>((base + 0x2AA780)); 
-		inline static glm::u8vec4* *tuv_wood_top = reinterpret_cast<glm::u8vec4**>((base + 0x2AB990)); 
-		inline static glm::u8vec4* *tuv_wood_side = reinterpret_cast<glm::u8vec4**>((base + 0x2A9E50)); 
-		inline static glm::u8vec4* *tuv_wood_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AB370)); 
-		inline static glm::u8vec4* *tuv_leaf = reinterpret_cast<glm::u8vec4**>((base + 0x2AA720)); 
-		inline static glm::u8vec4* *tuv_leaf_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AB880)); 
-		inline static glm::u8vec4* *tuv_iron_ore = reinterpret_cast<glm::u8vec4**>((base + 0x2AC160)); 
-		inline static glm::u8vec4* *tuv_iron_ore_full = reinterpret_cast<glm::u8vec4**>((base + 0x2ABFA0)); 
-		inline static glm::u8vec4* *tuv_deadly_ore = reinterpret_cast<glm::u8vec4**>((base + 0x2AB820)); 
-		inline static glm::u8vec4* *tuv_deadly_ore_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AC3F0)); 
-		inline static glm::u8vec4* *tuv_chest_top = reinterpret_cast<glm::u8vec4**>((base + 0x2AAA10)); 
-		inline static glm::u8vec4* *tuv_chest_side = reinterpret_cast<glm::u8vec4**>((base + 0x2AA760)); 
-		inline static glm::u8vec4* *tuv_chest_bottom = reinterpret_cast<glm::u8vec4**>((base + 0x2A9DA0)); 
-		inline static glm::u8vec4* *tuv_chest_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AC510)); 
-		inline static glm::u8vec4* *tuv_midnight_grass_top = reinterpret_cast<glm::u8vec4**>((base + 0x2AA0D0)); 
-		inline static glm::u8vec4* *tuv_midnight_grass_side = reinterpret_cast<glm::u8vec4**>((base + 0x2AB490)); 
-		inline static glm::u8vec4* *tuv_midnight_grass_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AC2D0)); 
-		inline static glm::u8vec4* *tuv_midnight_soil = reinterpret_cast<glm::u8vec4**>((base + 0x2ABB90)); 
-		inline static glm::u8vec4* *tuv_midnight_soil_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AC970)); 
-		inline static glm::u8vec4* *tuv_midnight_stone = reinterpret_cast<glm::u8vec4**>((base + 0x2AA090)); 
-		inline static glm::u8vec4* *tuv_midnight_stone_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AA620)); 
-		inline static glm::u8vec4* *tuv_midnight_wood_top = reinterpret_cast<glm::u8vec4**>((base + 0x2AC2B0)); 
-		inline static glm::u8vec4* *tuv_midnight_wood_side = reinterpret_cast<glm::u8vec4**>((base + 0x2AB840)); 
-		inline static glm::u8vec4* *tuv_midnight_wood_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AAEC0)); 
-		inline static glm::u8vec4* *tuv_midnight_leaf = reinterpret_cast<glm::u8vec4**>((base + 0x2AC4F0)); 
-		inline static glm::u8vec4* *tuv_midnight_leaf_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AAA30)); 
-		inline static glm::u8vec4* *tuv_bush = reinterpret_cast<glm::u8vec4**>((base + 0x2AA1F0)); 
-		inline static glm::u8vec4* *tuv_bush_full = reinterpret_cast<glm::u8vec4**>((base + 0x2ABBB0)); 
-		inline static glm::u8vec4* *tuv_midnight_bush = reinterpret_cast<glm::u8vec4**>((base + 0x2A9E10)); 
-		inline static glm::u8vec4* *tuv_midnight_bush_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AAFC0)); 
-		inline static glm::u8vec4* *tuv_red_flower = reinterpret_cast<glm::u8vec4**>((base + 0x2A9DE0)); 
-		inline static glm::u8vec4* *tuv_red_flower_full = reinterpret_cast<glm::u8vec4**>((base + 0x2ABC80)); 
-		inline static glm::u8vec4* *tuv_white_flower = reinterpret_cast<glm::u8vec4**>((base + 0x2AC710)); 
-		inline static glm::u8vec4* *tuv_white_flower_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AB220)); 
-		inline static glm::u8vec4* *tuv_blue_flower = reinterpret_cast<glm::u8vec4**>((base + 0x2ABD40)); 
-		inline static glm::u8vec4* *tuv_blue_flower_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AB4B0)); 
-		inline static glm::u8vec4* *tuv_tall_grass = reinterpret_cast<glm::u8vec4**>((base + 0x2AAC50)); 
-		inline static glm::u8vec4* *tuv_tall_grass_full = reinterpret_cast<glm::u8vec4**>((base + 0x2ABAB0)); 
-		inline static glm::u8vec4* *tuv_sand = reinterpret_cast<glm::u8vec4**>((base + 0x2AB860)); 
-		inline static glm::u8vec4* *tuv_sand_full = reinterpret_cast<glm::u8vec4**>((base + 0x2ACA70)); 
-		inline static glm::u8vec4* *tuv_sandstone = reinterpret_cast<glm::u8vec4**>((base + 0x2AC790)); 
-		inline static glm::u8vec4* *tuv_sandstone_full = reinterpret_cast<glm::u8vec4**>((base + 0x2ABDA0)); 
-		inline static glm::u8vec4* *tuv_cactus = reinterpret_cast<glm::u8vec4**>((base + 0x2AA240)); 
-		inline static glm::u8vec4* *tuv_cactus_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AC0A0)); 
-		inline static glm::u8vec4* *tuv_snow = reinterpret_cast<glm::u8vec4**>((base + 0x2A9E30)); 
-		inline static glm::u8vec4* *tuv_snow_full = reinterpret_cast<glm::u8vec4**>((base + 0x2ACB70)); 
-		inline static glm::u8vec4* *tuv_ice = reinterpret_cast<glm::u8vec4**>((base + 0x2AB080)); 
-		inline static glm::u8vec4* *tuv_ice_full = reinterpret_cast<glm::u8vec4**>((base + 0x2A9F70)); 
-		inline static glm::u8vec4* *tuv_snowy_bush = reinterpret_cast<glm::u8vec4**>((base + 0x2AAC30)); 
-		inline static glm::u8vec4* *tuv_snowy_bush_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AC1A0)); 
-		inline static glm::u8vec4* *tuv_glass = reinterpret_cast<glm::u8vec4**>((base + 0x2AC770)); 
-		inline static glm::u8vec4* *tuv_glass_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AB0D0)); 
-		inline static glm::u8vec4* *tuv_solenoid_ore = reinterpret_cast<glm::u8vec4**>((base + 0x2AC3D0)); 
-		inline static glm::u8vec4* *tuv_solenoid_ore_full = reinterpret_cast<glm::u8vec4**>((base + 0x2ABEA0)); 
-		inline static glm::u8vec4* *tuv_snowy_leaf_top = reinterpret_cast<glm::u8vec4**>((base + 0x2AB470)); 
-		inline static glm::u8vec4* *tuv_snowy_leaf_side = reinterpret_cast<glm::u8vec4**>((base + 0x2AA0B0)); 
-		inline static glm::u8vec4* *tuv_snowy_leaf_bottom = reinterpret_cast<glm::u8vec4**>((base + 0x2A9DC0)); 
-		inline static glm::u8vec4* *tuv_snowy_leaf_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AAB30)); 
-		inline static glm::u8vec4* *tuv_pumpkin_top = reinterpret_cast<glm::u8vec4**>((base + 0x2AA070)); 
-		inline static glm::u8vec4* *tuv_pumpkin_side = reinterpret_cast<glm::u8vec4**>((base + 0x2ABD60)); 
-		inline static glm::u8vec4* *tuv_pumpkin_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AA0F0)); 
-		inline static glm::u8vec4* *tuv_jack_o_lantern_side = reinterpret_cast<glm::u8vec4**>((base + 0x2AC750)); 
-		inline static glm::u8vec4* *tuv_jack_o_lantern_full = reinterpret_cast<glm::u8vec4**>((base + 0x2AAD70)); 
+		
 		inline static const int BLOCK_COUNT = 34; 
-		inline static const int VISIBLE_BLOCK_COUNT = 31; 
-		/*struct 
+		inline static const int VISIBLE_BLOCK_COUNT = 31;
+
+		inline static glm::u8vec4* cube_verts_x = reinterpret_cast<glm::u8vec4*>((base + 0x3B570 + 0x200000));
+		inline static glm::u8vec4* cube_verts_y = reinterpret_cast<glm::u8vec4*>((base + 0x3BD80 + 0x200000));
+		inline static glm::u8vec4* cube_verts_z = reinterpret_cast<glm::u8vec4*>((base + 0x3A210 + 0x200000));
+		inline static glm::u8vec4* cube_verts_w = reinterpret_cast<glm::u8vec4*>((base + 0x3AE98 + 0x200000));
+		inline static const glm::u8vec4 hypercube_full_verts[HYPERCUBE_VERT_COUNT] =
+		{
+			// -x
+			{ 0, 0, 0, 0 },
+			{ 0, 0, 1, 0 },
+			{ 0, 1, 0, 0 },
+			{ 0, 1, 1, 0 },
+			{ 0, 0, 0, 1 },
+			{ 0, 0, 1, 1 },
+			{ 0, 1, 0, 1 },
+			{ 0, 1, 1, 1 },
+			// +x
+			{ 1, 0, 0, 0 },
+			{ 1, 0, 1, 0 },
+			{ 1, 1, 0, 0 },
+			{ 1, 1, 1, 0 },
+			{ 1, 0, 0, 1 },
+			{ 1, 0, 1, 1 },
+			{ 1, 1, 0, 1 },
+			{ 1, 1, 1, 1 },
+			// -y
+			{ 0, 0, 0, 0 },
+			{ 1, 0, 0, 0 },
+			{ 0, 0, 1, 0 },
+			{ 1, 0, 1, 0 },
+			{ 0, 0, 0, 1 },
+			{ 1, 0, 0, 1 },
+			{ 0, 0, 1, 1 },
+			{ 1, 0, 1, 1 },
+			// +y
+			{ 0, 1, 0, 0 },
+			{ 1, 1, 0, 0 },
+			{ 0, 1, 1, 0 },
+			{ 1, 1, 1, 0 },
+			{ 0, 1, 0, 1 },
+			{ 1, 1, 0, 1 },
+			{ 0, 1, 1, 1 },
+			{ 1, 1, 1, 1 },
+			// -z
+			{ 0, 0, 0, 0 },
+			{ 1, 0, 0, 0 },
+			{ 0, 1, 0, 0 },
+			{ 1, 1, 0, 0 },
+			{ 0, 0, 0, 1 },
+			{ 1, 0, 0, 1 },
+			{ 0, 1, 0, 1 },
+			{ 1, 1, 0, 1 },
+			// +z
+			{ 0, 0, 1, 0 },
+			{ 1, 0, 1, 0 },
+			{ 0, 1, 1, 0 },
+			{ 1, 1, 1, 0 },
+			{ 0, 0, 1, 1 },
+			{ 1, 0, 1, 1 },
+			{ 0, 1, 1, 1 },
+			{ 1, 1, 1, 1 },
+			// -w
+			{ 0, 0, 0, 0 },
+			{ 1, 0, 0, 0 },
+			{ 0, 1, 0, 0 },
+			{ 1, 1, 0, 0 },
+			{ 0, 0, 1, 0 },
+			{ 1, 0, 1, 0 },
+			{ 0, 1, 1, 0 },
+			{ 1, 1, 1, 0 },
+			// +w
+			{ 0, 0, 0, 1 },
+			{ 1, 0, 0, 1 },
+			{ 0, 1, 0, 1 },
+			{ 1, 1, 0, 1 },
+			{ 0, 0, 1, 1 },
+			{ 1, 0, 1, 1 },
+			{ 0, 1, 1, 1 },
+			{ 1, 1, 1, 1 },
+		};
+
+		inline static const glm::u8vec3 hypercube_full_tuvs[HYPERCUBE_VERT_COUNT] =
+		{
+			// -x
+			{ 0, 0, 0 },
+			{ 1, 0, 0 },
+			{ 0, 1, 0 },
+			{ 1, 1, 0 },
+			{ 0, 0, 1 },
+			{ 1, 0, 1 },
+			{ 0, 1, 1 },
+			{ 1, 1, 1 },
+			// +x
+			{ 0, 0, 0 },
+			{ 1, 0, 0 },
+			{ 0, 1, 0 },
+			{ 1, 1, 0 },
+			{ 0, 0, 1 },
+			{ 1, 0, 1 },
+			{ 0, 1, 1 },
+			{ 1, 1, 1 },
+			// -y
+			{ 0, 0, 0 },
+			{ 1, 0, 0 },
+			{ 0, 1, 0 },
+			{ 1, 1, 0 },
+			{ 0, 0, 1 },
+			{ 1, 0, 1 },
+			{ 0, 1, 1 },
+			{ 1, 1, 1 },
+			// +y
+			{ 0, 0, 0 },
+			{ 1, 0, 0 },
+			{ 0, 1, 0 },
+			{ 1, 1, 0 },
+			{ 0, 0, 1 },
+			{ 1, 0, 1 },
+			{ 0, 1, 1 },
+			{ 1, 1, 1 },
+			// -z
+			{ 0, 0, 0 },
+			{ 1, 0, 0 },
+			{ 0, 1, 0 },
+			{ 1, 1, 0 },
+			{ 0, 0, 1 },
+			{ 1, 0, 1 },
+			{ 0, 1, 1 },
+			{ 1, 1, 1 },
+			// +z
+			{ 0, 0, 0 },
+			{ 1, 0, 0 },
+			{ 0, 1, 0 },
+			{ 1, 1, 0 },
+			{ 0, 0, 1 },
+			{ 1, 0, 1 },
+			{ 0, 1, 1 },
+			{ 1, 1, 1 },
+			// -w
+			{ 0, 0, 0 },
+			{ 1, 0, 0 },
+			{ 0, 1, 0 },
+			{ 1, 1, 0 },
+			{ 0, 0, 1 },
+			{ 1, 0, 1 },
+			{ 0, 1, 1 },
+			{ 1, 1, 1 },
+			// +w
+			{ 0, 0, 0 },
+			{ 1, 0, 0 },
+			{ 0, 1, 0 },
+			{ 1, 1, 0 },
+			{ 0, 0, 1 },
+			{ 1, 0, 1 },
+			{ 0, 1, 1 },
+			{ 1, 1, 1 },
+		};
+
+		inline static const glm::vec4 hypercube_full_normals[HYPERCUBE_VERT_COUNT / 4] =
 		{
+			// -x
+			_cube_normal(-1, 0, 0, 0),
+			// +x
+			_cube_normal(1, 0, 0, 0),
+
+			// -y
+			_cube_normal(0, -1, 0, 0),
+			// +y
+			_cube_normal(0, 1, 0, 0),
+
+			// -z
+			_cube_normal(0, 0, -1, 0),
+			// +z
+			_cube_normal(0, 0, 1, 0),
 
-		} Blocks;*/
-		inline static glm::u8vec4* *cube_verts_x = reinterpret_cast<glm::u8vec4**>((base + 0x2AB570)); 
-		inline static glm::u8vec4* *cube_verts_y = reinterpret_cast<glm::u8vec4**>((base + 0x2ABD80)); 
-		inline static glm::u8vec4* *cube_verts_z = reinterpret_cast<glm::u8vec4**>((base + 0x2AA210)); 
-		inline static glm::u8vec4* *cube_verts_w = reinterpret_cast<glm::u8vec4**>((base + 0x2AAE98)); 
-		inline static glm::u8vec4* *hypercube_full_verts = reinterpret_cast<glm::u8vec4**>((base + 0x2AAC70)); 
-		inline static glm::u8vec3* *hypercube_full_tuvs = reinterpret_cast<glm::u8vec3**>((base + 0x2AC8B0)); 
-		inline static glm::vec4** hypercube_full_normals = reinterpret_cast<glm::vec4**>((base + 0x2AA910));
-		inline static uint32_t** hypercube_full_indices = reinterpret_cast<uint32_t**>((base + 0x2AB5A0));
-		inline static glm::u8vec4** plant_full_verts = reinterpret_cast<glm::u8vec4**>((base + 0x2AA790));
-		inline static glm::vec4** plant_full_normals = reinterpret_cast<glm::vec4**>((base + 0x2C3E50));
-		inline static uint32_t** plant_full_indices = reinterpret_cast<uint32_t**>((base + 0x2AA260));
-		inline static glm::u8vec3* *square_verts_x = reinterpret_cast<glm::u8vec3**>((base + 0x2AAE88)); 
-		inline static glm::u8vec3* *square_verts_y = reinterpret_cast<glm::u8vec3**>((base + 0x2AB0C0)); 
-		inline static glm::u8vec3* *square_verts_z = reinterpret_cast<glm::u8vec3**>((base + 0x2ABC70)); 
-		inline static glm::u8vec3* *cube_verts = reinterpret_cast<glm::u8vec3**>((base + 0x2AAE70)); 
-		inline static uint32_t** cube_indices = reinterpret_cast<uint32_t**>((base + 0x2AC260));
-		inline static glm::u8vec3* *cube_verts_triangles = reinterpret_cast<glm::u8vec3**>((base + 0x2AB2E0)); 
-		inline static glm::u8vec3* *cube_verts_lines = reinterpret_cast<glm::u8vec3**>((base + 0x2AB1D0)); 
-		inline static std::unordered_map<std::string,uint8_t>* blockIDs = reinterpret_cast<std::unordered_map<std::string,uint8_t>*>((base + 0x2C3FD0));
-		inline static std::unordered_map<uint8_t,std::string>* blockNames = reinterpret_cast<std::unordered_map<uint8_t,std::string>*>((base + 0x2C4010));
-		inline static BlockInfo::ItemMesh** itemMeshes = reinterpret_cast<BlockInfo::ItemMesh**>((base + 0x2BDB30));
+			// -w
+			_cube_normal(0, 0, 0, -1),
+			// +w
+			_cube_normal(0, 0, 0, 1),
+		};
+
+		// indices for the full hypercube mesh
+		inline static const GLuint hypercube_full_indices[HYPERCUBE_FULL_INDEX_COUNT] =
+		{
+			_cube_tet_indices(CUBE_VERT_COUNT * 0),
+			_cube_tet_indices(CUBE_VERT_COUNT * 1),
+			_cube_tet_indices(CUBE_VERT_COUNT * 2),
+			_cube_tet_indices(CUBE_VERT_COUNT * 3),
+			_cube_tet_indices(CUBE_VERT_COUNT * 4),
+			_cube_tet_indices(CUBE_VERT_COUNT * 5),
+			_cube_tet_indices(CUBE_VERT_COUNT * 6),
+			_cube_tet_indices(CUBE_VERT_COUNT * 7),
+		};
+		inline static glm::u8vec4* plant_full_verts = reinterpret_cast<glm::u8vec4*>((base + 0x3A790 + 0x200000));
+		inline static glm::vec4* plant_full_normals = reinterpret_cast<glm::vec4*>((base + 0x53E50 + 0x270000));
+		inline static uint32_t* plant_full_indices = reinterpret_cast<uint32_t*>((base + 0x3A260 + 0x200000));
+		inline static glm::u8vec3* square_verts_x = reinterpret_cast<glm::u8vec3*>((base + 0x3AE88 + 0x200000));
+		inline static glm::u8vec3* square_verts_y = reinterpret_cast<glm::u8vec3*>((base + 0x3B0C0 + 0x200000));
+		inline static glm::u8vec3* square_verts_z = reinterpret_cast<glm::u8vec3*>((base + 0x3BC70 + 0x200000));
+		inline static glm::u8vec3 cube_verts[CUBE_VERT_COUNT] =
+		{
+			{ 0, 0, 0 },
+			{ 1, 0, 0 },
+			{ 0, 1, 0 },
+			{ 1, 1, 0 },
+			{ 0, 0, 1 },
+			{ 1, 0, 1 },
+			{ 0, 1, 1 },
+			{ 1, 1, 1 }
+		};
+		inline static uint32_t cube_indices[CUBE_FULL_INDEX_COUNT] =
+		{
+			1, 2, 4, 7, 0, 1, 2, 4, 2, 4, 6, 7, 1, 2, 3, 7, 1, 4, 5, 7
+		};
+		inline static glm::u8vec3* cube_verts_triangles = reinterpret_cast<glm::u8vec3*>((base + 0x3B2E0 + 0x200000));
+		inline static glm::u8vec3* cube_verts_lines = reinterpret_cast<glm::u8vec3*>((base + 0x3B1D0 + 0x200000));
+		inline static std::unordered_map<msvc_string,uint8_t>* blockIDs = reinterpret_cast<std::unordered_map<msvc_string,uint8_t>*>((base + 0x53FD0 + 0x270000));
+		inline static std::unordered_map<uint8_t,msvc_string>* blockNames = reinterpret_cast<std::unordered_map<uint8_t,msvc_string>*>((base + 0x54010 + 0x270000));
+		inline static BlockInfo::ItemMesh* itemMeshes = reinterpret_cast<BlockInfo::ItemMesh*>((base + 0x4DB30 + 0x270000));
 
 		inline static void renderItemMesh(uint8_t blockID) 
 		{
-			return reinterpret_cast<void (__fastcall*)(uint8_t blockID)>(FUNC_BLOCKINFO_RENDERITEMMESH)(blockID);
+			return reinterpret_cast<void (__fastcall*)(uint8_t blockID)>(getFuncAddr((int)Func::BlockInfo::renderItemMesh))(blockID);
 		}
 	};
 }
diff --git a/4dm.h/Chunk.h b/4dm.h/Chunk.h
index f3669a1..f475ece 100644
--- a/4dm.h/Chunk.h
+++ b/4dm.h/Chunk.h
@@ -29,47 +29,47 @@ namespace fdm
 
 			~ChunkMesh() 
 			{
-				reinterpret_cast<void(__thiscall*)(Chunk::ChunkMesh* self)>(FUNC_CHUNK_CHUNKMESH_DESTR_CHUNKMESH)(this);
+				reinterpret_cast<void(__thiscall*)(Chunk::ChunkMesh* self)>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::destr_ChunkMesh))(this);
 			}
 			ChunkMesh() 
 			{
-				reinterpret_cast<void(__thiscall*)(Chunk::ChunkMesh* self)>(FUNC_CHUNK_CHUNKMESH_CHUNKMESH)(this);
+				reinterpret_cast<void(__thiscall*)(Chunk::ChunkMesh* self)>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::ChunkMesh))(this);
 			}
 			int buffSize(int buffIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const Chunk::ChunkMesh* self, int buffIndex)>(FUNC_CHUNK_CHUNKMESH_BUFFSIZE)(this, buffIndex);
+				return reinterpret_cast<int (__thiscall*)(const Chunk::ChunkMesh* self, int buffIndex)>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::buffSize))(this, buffIndex);
 			}
 			int attrCount(int buffIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const Chunk::ChunkMesh* self, int buffIndex)>(FUNC_CHUNK_CHUNKMESH_ATTRCOUNT)(this, buffIndex);
+				return reinterpret_cast<int (__thiscall*)(const Chunk::ChunkMesh* self, int buffIndex)>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::attrCount))(this, buffIndex);
 			}
 			unsigned int attrType(int buffIndex, int attrIndex) const override
 			{
-				return reinterpret_cast<unsigned int (__thiscall*)(const Chunk::ChunkMesh* self, int buffIndex, int attrIndex)>(FUNC_CHUNK_CHUNKMESH_ATTRTYPE)(this, buffIndex, attrIndex);
+				return reinterpret_cast<unsigned int (__thiscall*)(const Chunk::ChunkMesh* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::attrType))(this, buffIndex, attrIndex);
 			}
 			int attrSize(int buffIndex, int attrIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const Chunk::ChunkMesh* self, int buffIndex, int attrIndex)>(FUNC_CHUNK_CHUNKMESH_ATTRSIZE)(this, buffIndex, attrIndex);
+				return reinterpret_cast<int (__thiscall*)(const Chunk::ChunkMesh* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::attrSize))(this, buffIndex, attrIndex);
 			}
 			int attrStride(int buffIndex, int attrIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const Chunk::ChunkMesh* self, int buffIndex, int attrIndex)>(FUNC_CHUNK_CHUNKMESH_ATTRSTRIDE)(this, buffIndex, attrIndex);
+				return reinterpret_cast<int (__thiscall*)(const Chunk::ChunkMesh* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::attrStride))(this, buffIndex, attrIndex);
 			}
 			const void* indexBuffData() const override
 			{
-				return reinterpret_cast<const void* (__thiscall*)(const Chunk::ChunkMesh* self)>(FUNC_CHUNK_CHUNKMESH_INDEXBUFFDATA)(this);
+				return reinterpret_cast<const void* (__thiscall*)(const Chunk::ChunkMesh* self)>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::indexBuffData))(this);
 			}
 			void move(Chunk::ChunkMesh* other) 
 			{
-				return reinterpret_cast<void (__thiscall*)(Chunk::ChunkMesh* self, Chunk::ChunkMesh* other)>(FUNC_CHUNK_CHUNKMESH_MOVE)(this, other);
+				return reinterpret_cast<void (__thiscall*)(Chunk::ChunkMesh* self, Chunk::ChunkMesh* other)>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::move))(this, other);
 			}
-			void addMeshSide(const glm::u8vec4& side, const glm::u8vec4& side_tuvs, const glm::u8vec4& pos, const BlockInfo::VertLighting* lighting) 
+			void addMeshSide(const glm::u8vec4* side, const glm::u8vec4* side_tuvs, const glm::u8vec4& pos, const BlockInfo::VertLighting lighting[8]) 
 			{
-				return reinterpret_cast<void (__thiscall*)(Chunk::ChunkMesh* self, const glm::u8vec4& side, const glm::u8vec4& side_tuvs, const glm::u8vec4& pos, const BlockInfo::VertLighting* lighting)>(FUNC_CHUNK_CHUNKMESH_ADDMESHSIDE)(this, side, side_tuvs, pos, lighting);
+				return reinterpret_cast<void (__thiscall*)(Chunk::ChunkMesh* self, const glm::u8vec4* side, const glm::u8vec4* side_tuvs, const glm::u8vec4& pos, const BlockInfo::VertLighting lighting[8])>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::addMeshSide))(this, side, side_tuvs, pos, lighting);
 			}
-			void addMeshPlant(const glm::u8vec4& plant, const glm::u8vec4& plant_tuvs, const glm::u8vec4& pos, const BlockInfo::VertLighting* lighting) 
+			void addMeshPlant(const glm::u8vec4* plant, const glm::u8vec4* plant_tuvs, const glm::u8vec4& pos, const BlockInfo::VertLighting lighting[16]) 
 			{
-				return reinterpret_cast<void (__thiscall*)(Chunk::ChunkMesh* self, const glm::u8vec4& plant, const glm::u8vec4& plant_tuvs, const glm::u8vec4& pos, const BlockInfo::VertLighting* lighting)>(FUNC_CHUNK_CHUNKMESH_ADDMESHPLANT)(this, plant, plant_tuvs, pos, lighting);
+				return reinterpret_cast<void (__thiscall*)(Chunk::ChunkMesh* self, const glm::u8vec4* plant, const glm::u8vec4* plant_tuvs, const glm::u8vec4& pos, const BlockInfo::VertLighting lighting[16])>(getFuncAddr((int)Func::Chunk_Nested::ChunkMesh::addMeshPlant))(this, plant, plant_tuvs, pos, lighting);
 			}
 		};
 		inline static const uint32_t SIZE = 8; 
@@ -100,80 +100,80 @@ namespace fdm
 
 		Chunk(const glm::i64vec3& pos) 
 		{
-			reinterpret_cast<void(__thiscall*)(Chunk* self, const glm::i64vec3& pos)>(FUNC_CHUNK_CHUNK)(this, pos);
+			reinterpret_cast<void(__thiscall*)(Chunk* self, const glm::i64vec3& pos)>(getFuncAddr((int)Func::Chunk::Chunk))(this, pos);
 		}
 		void setBlock(const glm::ivec4& block, unsigned char value) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, const glm::ivec4& block, unsigned char value)>(FUNC_CHUNK_SETBLOCK)(this, block, value);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, const glm::ivec4& block, unsigned char value)>(getFuncAddr((int)Func::Chunk::setBlock))(this, block, value);
 		}
 		void generateMesh(bool smoothLighting, bool shadows, bool lights) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, bool smoothLighting, bool shadows, bool lights)>(FUNC_CHUNK_GENERATEMESH)(this, smoothLighting, shadows, lights);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, bool smoothLighting, bool shadows, bool lights)>(getFuncAddr((int)Func::Chunk::generateMesh))(this, smoothLighting, shadows, lights);
 		}
-		void updateEntitiesClient(World* world, double dt, EntityManager* entityManager) 
+		void updateEntitiesClient(World* world, double dt, EntityManager& entityManager) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, World* world, double dt, EntityManager* entityManager)>(FUNC_CHUNK_UPDATEENTITIESCLIENT)(this, world, dt, entityManager);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, World* world, double dt, EntityManager& entityManager)>(getFuncAddr((int)Func::Chunk::updateEntitiesClient))(this, world, dt, entityManager);
 		}
 		void clearEntities(EntityManager* entityManager) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, EntityManager* entityManager)>(FUNC_CHUNK_CLEARENTITIES)(this, entityManager);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, EntityManager* entityManager)>(getFuncAddr((int)Func::Chunk::clearEntities))(this, entityManager);
 		}
-		void render(const World* world, const m4::Mat5& MV, const Frustum* frustum) 
+		void render(const World* world, const m4::Mat5& MV, const Frustum& frustum) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, const World* world, const m4::Mat5& MV, const Frustum* frustum)>(FUNC_CHUNK_RENDER)(this, world, MV, frustum);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, const World* world, const m4::Mat5& MV, const Frustum& frustum)>(getFuncAddr((int)Func::Chunk::render))(this, world, MV, frustum);
 		}
 		void updateLightingHeightMap() 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self)>(FUNC_CHUNK_UPDATELIGHTINGHEIGHTMAP)(this);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self)>(getFuncAddr((int)Func::Chunk::updateLightingHeightMap))(this);
 		}
 		void updateMesh(bool smoothLighting, bool shadows, bool lights) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, bool smoothLighting, bool shadows, bool lights)>(FUNC_CHUNK_UPDATEMESH)(this, smoothLighting, shadows, lights);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, bool smoothLighting, bool shadows, bool lights)>(getFuncAddr((int)Func::Chunk::updateMesh))(this, smoothLighting, shadows, lights);
 		}
 		bool load(const path& chunksFolderPath, World* world) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Chunk* self, const path& chunksFolderPath, World* world)>(FUNC_CHUNK_LOAD)(this, chunksFolderPath, world);
+			return reinterpret_cast<bool (__thiscall*)(Chunk* self, const path& chunksFolderPath, World* world)>(getFuncAddr((int)Func::Chunk::load))(this, chunksFolderPath, world);
 		}
 		void save(const path& chunksFolderPath) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, const path& chunksFolderPath)>(FUNC_CHUNK_SAVE)(this, chunksFolderPath);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, const path& chunksFolderPath)>(getFuncAddr((int)Func::Chunk::save))(this, chunksFolderPath);
 		}
 		void loadFromMessage(const Connection::InMessage& message, World* world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, const Connection::InMessage& message, World* world)>(FUNC_CHUNK_LOADFROMMESSAGE)(this, message, world);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, const Connection::InMessage& message, World* world)>(getFuncAddr((int)Func::Chunk::loadFromMessage))(this, message, world);
 		}
-		void updateCacheSection(const Chunk& other, bool shadows) 
+		void updateCacheSection(const Chunk* other, bool shadows) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, const Chunk& other, bool shadows)>(FUNC_CHUNK_UPDATECACHESECTION)(this, other, shadows);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, const Chunk* other, bool shadows)>(getFuncAddr((int)Func::Chunk::updateCacheSection))(this, other, shadows);
 		}
-		void updateHeightmapCacheSection(glm::i64vec3* borderingChunkPos) 
+		void updateHeightmapCacheSection(glm::i64vec3 borderingChunkPos) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, glm::i64vec3* borderingChunkPos)>(FUNC_CHUNK_UPDATEHEIGHTMAPCACHESECTION)(this, borderingChunkPos);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, glm::i64vec3 borderingChunkPos)>(getFuncAddr((int)Func::Chunk::updateHeightmapCacheSection))(this, borderingChunkPos);
 		}
-		void generateMeshSection(Chunk::ChunkMesh* mesh, unsigned char startY, bool smoothLighting, bool shadows, bool lights) 
+		void generateMeshSection(Chunk::ChunkMesh& mesh, unsigned char startY, bool smoothLighting, bool shadows, bool lights) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, Chunk::ChunkMesh* mesh, unsigned char startY, bool smoothLighting, bool shadows, bool lights)>(FUNC_CHUNK_GENERATEMESHSECTION)(this, mesh, startY, smoothLighting, shadows, lights);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, Chunk::ChunkMesh& mesh, unsigned char startY, bool smoothLighting, bool shadows, bool lights)>(getFuncAddr((int)Func::Chunk::generateMeshSection))(this, mesh, startY, smoothLighting, shadows, lights);
 		}
-		void getSmoothLighting(const glm::ivec4& block, unsigned char face, BlockInfo::VertLighting* lighting, bool shadows, bool lights) 
+		void getSmoothLighting(const glm::ivec4& block, unsigned char face, BlockInfo::VertLighting lighting[8], bool shadows, bool lights) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, const glm::ivec4& block, unsigned char face, BlockInfo::VertLighting* lighting, bool shadows, bool lights)>(FUNC_CHUNK_GETSMOOTHLIGHTING)(this, block, face, lighting, shadows, lights);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, const glm::ivec4& block, unsigned char face, BlockInfo::VertLighting* lighting, bool shadows, bool lights)>(getFuncAddr((int)Func::Chunk::getSmoothLighting))(this, block, face, lighting, shadows, lights);
 		}
-		void getLighting(const glm::ivec4& block, unsigned char face, BlockInfo::VertLighting* lighting, bool shadows, bool lights) 
+		void getLighting(const glm::ivec4& block, unsigned char face, BlockInfo::VertLighting lighting[8], bool shadows, bool lights) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, const glm::ivec4& block, unsigned char face, BlockInfo::VertLighting* lighting, bool shadows, bool lights)>(FUNC_CHUNK_GETLIGHTING)(this, block, face, lighting, shadows, lights);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, const glm::ivec4& block, unsigned char face, BlockInfo::VertLighting* lighting, bool shadows, bool lights)>(getFuncAddr((int)Func::Chunk::getLighting))(this, block, face, lighting, shadows, lights);
 		}
 		void enableMesh() 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self)>(FUNC_CHUNK_ENABLEMESH)(this);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self)>(getFuncAddr((int)Func::Chunk::enableMesh))(this);
 		}
 		void loadEntitiesFromJson(nlohmann::json& j, World* world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Chunk* self, nlohmann::json& j, World* world)>(FUNC_CHUNK_LOADENTITIESFROMJSON)(this, j, world);
+			return reinterpret_cast<void (__thiscall*)(Chunk* self, nlohmann::json& j, World* world)>(getFuncAddr((int)Func::Chunk::loadEntitiesFromJson))(this, j, world);
 		}
-		std::string getFilenamePrefix() 
+		msvc_string getFilenamePrefix() 
 		{
-			std::string result;
-			return reinterpret_cast<std::string (__thiscall*)(Chunk* self, std::string* result)>(FUNC_CHUNK_GETFILENAMEPREFIX)(this, &result);
+			msvc_string result;
+			return reinterpret_cast<msvc_string& (__thiscall*)(Chunk* self, msvc_string* result)>(getFuncAddr((int)Func::Chunk::getFilenamePrefix))(this, &result);
 			return result;
 		}
 	};
diff --git a/4dm.h/ChunkLoader.h b/4dm.h/ChunkLoader.h
index 6ecc8b0..5830d24 100644
--- a/4dm.h/ChunkLoader.h
+++ b/4dm.h/ChunkLoader.h
@@ -17,7 +17,7 @@ namespace fdm
 				TREE_SNOWY = 0x3,
 			};
 
-			std::string name; 
+			msvc_string name; 
 			float weight; // 0x20
 			float hMultiplier; // 0x24
 			float vMultiplier; // 0x28
@@ -34,11 +34,11 @@ namespace fdm
 
 			~BiomeInfo() 
 			{
-				reinterpret_cast<void(__thiscall*)(ChunkLoader::BiomeInfo* self)>(FUNC_CHUNKLOADER_BIOMEINFO_DESTR_BIOMEINFO)(this);
+				reinterpret_cast<void(__thiscall*)(ChunkLoader::BiomeInfo* self)>(getFuncAddr((int)Func::ChunkLoader_Nested::BiomeInfo::destr_BiomeInfo))(this);
 			}
 			BiomeInfo(const ChunkLoader::BiomeInfo& __that) noexcept 
 			{
-				reinterpret_cast<void(__thiscall*)(ChunkLoader::BiomeInfo* self, const ChunkLoader::BiomeInfo & __that)>(FUNC_CHUNKLOADER_BIOMEINFO_BIOMEINFO)(this, __that);
+				reinterpret_cast<void(__thiscall*)(ChunkLoader::BiomeInfo* self, const ChunkLoader::BiomeInfo & __that)>(getFuncAddr((int)Func::ChunkLoader_Nested::BiomeInfo::BiomeInfo))(this, __that);
 			}
 		};
 		struct BiomeMapPixel 
@@ -69,43 +69,43 @@ namespace fdm
 
 		bool init(const path& worldPath, const path& biomeInfoPath) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(ChunkLoader* self, const path& worldPath, const path& biomeInfoPath)>(FUNC_CHUNKLOADER_INIT)(this, worldPath, biomeInfoPath);
+			return reinterpret_cast<bool (__thiscall*)(ChunkLoader* self, const path& worldPath, const path& biomeInfoPath)>(getFuncAddr((int)Func::ChunkLoader::init))(this, worldPath, biomeInfoPath);
 		}
 		void loadChunk(Chunk* c, World* world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, Chunk* c, World* world)>(FUNC_CHUNKLOADER_LOADCHUNK)(this, c, world);
+			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, Chunk* c, World* world)>(getFuncAddr((int)Func::ChunkLoader::loadChunk))(this, c, world);
 		}
 		bool loadBiomes(const path& biomeInfoPath) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(ChunkLoader* self, const path& biomeInfoPath)>(FUNC_CHUNKLOADER_LOADBIOMES)(this, biomeInfoPath);
+			return reinterpret_cast<bool (__thiscall*)(ChunkLoader* self, const path& biomeInfoPath)>(getFuncAddr((int)Func::ChunkLoader::loadBiomes))(this, biomeInfoPath);
 		}
 		bool loadInfo(const path& worldInfoPath) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(ChunkLoader* self, const path& worldInfoPath)>(FUNC_CHUNKLOADER_LOADINFO)(this, worldInfoPath);
+			return reinterpret_cast<bool (__thiscall*)(ChunkLoader* self, const path& worldInfoPath)>(getFuncAddr((int)Func::ChunkLoader::loadInfo))(this, worldInfoPath);
 		}
 		void generateChunk(Chunk* chunk) 
 		{
-			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, Chunk* chunk)>(FUNC_CHUNKLOADER_GENERATECHUNK)(this, chunk);
+			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, Chunk* chunk)>(getFuncAddr((int)Func::ChunkLoader::generateChunk))(this, chunk);
 		}
 		ChunkLoader::BiomeMapPixel getBiome(int x, int z, int w) 
 		{
-			return reinterpret_cast<ChunkLoader::BiomeMapPixel (__thiscall*)(ChunkLoader* self, int x, int z, int w)>(FUNC_CHUNKLOADER_GETBIOME)(this, x, z, w);
+			return reinterpret_cast<ChunkLoader::BiomeMapPixel (__thiscall*)(ChunkLoader* self, int x, int z, int w)>(getFuncAddr((int)Func::ChunkLoader::getBiome))(this, x, z, w);
 		}
 		void generateTree(unsigned char* blocks, const glm::i64vec3& chunkPos, bool dark) 
 		{
-			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, unsigned char* blocks, const glm::i64vec3& chunkPos, bool dark)>(FUNC_CHUNKLOADER_GENERATETREE)(this, blocks, chunkPos, dark);
+			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, unsigned char* blocks, const glm::i64vec3& chunkPos, bool dark)>(getFuncAddr((int)Func::ChunkLoader::generateTree))(this, blocks, chunkPos, dark);
 		}
 		void generateTreeBranch(unsigned char* blocks, const glm::i64vec3& chunkPos, glm::ivec4& startPos, int limit, bool dark) 
 		{
-			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, unsigned char* blocks, const glm::i64vec3& chunkPos, glm::ivec4& startPos, int limit, bool dark)>(FUNC_CHUNKLOADER_GENERATETREEBRANCH)(this, blocks, chunkPos, startPos, limit, dark);
+			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, unsigned char* blocks, const glm::i64vec3& chunkPos, glm::ivec4& startPos, int limit, bool dark)>(getFuncAddr((int)Func::ChunkLoader::generateTreeBranch))(this, blocks, chunkPos, startPos, limit, dark);
 		}
 		void generateTaigaTree(unsigned char* blocks, const glm::i64vec3& chunkPos) 
 		{
-			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, unsigned char* blocks, const glm::i64vec3& chunkPos)>(FUNC_CHUNKLOADER_GENERATETAIGATREE)(this, blocks, chunkPos);
+			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, unsigned char* blocks, const glm::i64vec3& chunkPos)>(getFuncAddr((int)Func::ChunkLoader::generateTaigaTree))(this, blocks, chunkPos);
 		}
 		void createFlatWorldChests(Chunk* chunk, World* world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, Chunk* chunk, World* world)>(FUNC_CHUNKLOADER_CREATEFLATWORLDCHESTS)(this, chunk, world);
+			return reinterpret_cast<void (__thiscall*)(ChunkLoader* self, Chunk* chunk, World* world)>(getFuncAddr((int)Func::ChunkLoader::createFlatWorldChests))(this, chunk, world);
 		}
 	};
 }
diff --git a/4dm.h/CloudChunk.h b/4dm.h/CloudChunk.h
index f0e9520..acc1bf4 100644
--- a/4dm.h/CloudChunk.h
+++ b/4dm.h/CloudChunk.h
@@ -11,35 +11,35 @@ namespace fdm
 		{
 		public:
 			inline static const int TRUNCATED_OCTAHEDRON_VERT_COUNT = 25; 
-			inline static glm::vec4** truncated_octahedron_verts = reinterpret_cast<glm::vec4**>((base + 0x2ACCE0));
+			inline static glm::vec4* truncated_octahedron_verts = reinterpret_cast<glm::vec4*>((base + 0x3CCE0 + 0x200000));
 			inline static const int TRUNCATED_OCTAHEDRON_INDEX_COUNT = 176; 
-			inline static uint32_t** truncated_octahedron_indices = reinterpret_cast<uint32_t**>((base + 0x2ACE70));
+			inline static uint32_t* truncated_octahedron_indices = reinterpret_cast<uint32_t*>((base + 0x3CE70 + 0x200000));
 			std::vector<glm::vec4> verts; // 0x8
 			std::vector<uint32_t> indices; // 0x20
 
 			int indexBuffSize() const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const CloudChunk::CloudChunkMesh* self)>(FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_INDEXBUFFSIZE)(this);
+				return reinterpret_cast<int (__thiscall*)(const CloudChunk::CloudChunkMesh* self)>(getFuncAddr((int)Func::CloudChunk_Nested::CloudChunkMesh::indexBuffSize))(this);
 			}
 			int buffSize(int buffIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const CloudChunk::CloudChunkMesh* self, int buffIndex)>(FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_BUFFSIZE)(this, buffIndex);
+				return reinterpret_cast<int (__thiscall*)(const CloudChunk::CloudChunkMesh* self, int buffIndex)>(getFuncAddr((int)Func::CloudChunk_Nested::CloudChunkMesh::buffSize))(this, buffIndex);
 			}
 			int attrSize(int buffIndex, int attrIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const CloudChunk::CloudChunkMesh* self, int buffIndex, int attrIndex)>(FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_ATTRSIZE)(this, buffIndex, attrIndex);
+				return reinterpret_cast<int (__thiscall*)(const CloudChunk::CloudChunkMesh* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::CloudChunk_Nested::CloudChunkMesh::attrSize))(this, buffIndex, attrIndex);
 			}
 			int attrStride(int buffIndex, int attrIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const CloudChunk::CloudChunkMesh* self, int buffIndex, int attrIndex)>(FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_ATTRSTRIDE)(this, buffIndex, attrIndex);
+				return reinterpret_cast<int (__thiscall*)(const CloudChunk::CloudChunkMesh* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::CloudChunk_Nested::CloudChunkMesh::attrStride))(this, buffIndex, attrIndex);
 			}
 			void move(CloudChunk::CloudChunkMesh* other) 
 			{
-				return reinterpret_cast<void (__thiscall*)(CloudChunk::CloudChunkMesh* self, CloudChunk::CloudChunkMesh* other)>(FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_MOVE)(this, other);
+				return reinterpret_cast<void (__thiscall*)(CloudChunk::CloudChunkMesh* self, CloudChunk::CloudChunkMesh* other)>(getFuncAddr((int)Func::CloudChunk_Nested::CloudChunkMesh::move))(this, other);
 			}
 			~CloudChunkMesh() 
 			{
-				reinterpret_cast<void(__thiscall*)(CloudChunk::CloudChunkMesh* self)>(FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_DESTR_CLOUDCHUNKMESH)(this);
+				reinterpret_cast<void(__thiscall*)(CloudChunk::CloudChunkMesh* self)>(getFuncAddr((int)Func::CloudChunk_Nested::CloudChunkMesh::destr_CloudChunkMesh))(this);
 			}
 		};
 		inline static const uint32_t SIZE = 6; 
@@ -56,7 +56,7 @@ namespace fdm
 
 		void generateMesh() 
 		{
-			return reinterpret_cast<void (__thiscall*)(CloudChunk* self)>(FUNC_CLOUDCHUNK_GENERATEMESH)(this);
+			return reinterpret_cast<void (__thiscall*)(CloudChunk* self)>(getFuncAddr((int)Func::CloudChunk::generateMesh))(this);
 		}
 	};
 }
diff --git a/4dm.h/CloudManager.h b/4dm.h/CloudManager.h
index b7d4747..503b53b 100644
--- a/4dm.h/CloudManager.h
+++ b/4dm.h/CloudManager.h
@@ -14,8 +14,7 @@ namespace fdm
 		glm::vec3 velocity; // 0x14
 		uint32_t seed; // 0x20
 		PAD(0x4);
-		// std::unordered_map<glm::i64vec3,std::unique_ptr<CloudChunk>> chunks; // 0x28
-		std::map<std::tuple<__int64, __int64, __int64>, CloudChunk*> chunks; // 0x28
+		std::unordered_map<glm::i64vec3, std::unique_ptr<CloudChunk>> chunks; // 0x28
 		std::atomic_bool chunksReady; // 0x68
 		PAD(0x3);
 		std::atomic_int loadedChunks; // 0x6C
@@ -26,27 +25,27 @@ namespace fdm
 
 		~CloudManager() 
 		{
-			reinterpret_cast<void(__thiscall*)(CloudManager* self)>(FUNC_CLOUDMANAGER_DESTR_CLOUDMANAGER)(this);
+			reinterpret_cast<void(__thiscall*)(CloudManager* self)>(getFuncAddr((int)Func::CloudManager::destr_CloudManager))(this);
 		}
 		void render(const m4::Mat5& MV, const glm::mat4& P, int matUniformID) 
 		{
-			return reinterpret_cast<void (__thiscall*)(CloudManager* self, const m4::Mat5& MV, const glm::mat4& P, int matUniformID)>(FUNC_CLOUDMANAGER_RENDER)(this, MV, P, matUniformID);
+			return reinterpret_cast<void (__thiscall*)(CloudManager* self, const m4::Mat5& MV, const glm::mat4& P, int matUniformID)>(getFuncAddr((int)Func::CloudManager::render))(this, MV, P, matUniformID);
 		}
 		void updateChunks(const glm::vec4& pos, const glm::vec4& over, unsigned char renderDistance) 
 		{
-			return reinterpret_cast<void (__thiscall*)(CloudManager* self, const glm::vec4& pos, const glm::vec4& over, unsigned char renderDistance)>(FUNC_CLOUDMANAGER_UPDATECHUNKS)(this, pos, over, renderDistance);
+			return reinterpret_cast<void (__thiscall*)(CloudManager* self, const glm::vec4& pos, const glm::vec4& over, unsigned char renderDistance)>(getFuncAddr((int)Func::CloudManager::updateChunks))(this, pos, over, renderDistance);
 		}
 		void unloadAllChunks() 
 		{
-			return reinterpret_cast<void (__thiscall*)(CloudManager* self)>(FUNC_CLOUDMANAGER_UNLOADALLCHUNKS)(this);
+			return reinterpret_cast<void (__thiscall*)(CloudManager* self)>(getFuncAddr((int)Func::CloudManager::unloadAllChunks))(this);
 		}
 		void loadChunks() 
 		{
-			return reinterpret_cast<void (__thiscall*)(CloudManager* self)>(FUNC_CLOUDMANAGER_LOADCHUNKS)(this);
+			return reinterpret_cast<void (__thiscall*)(CloudManager* self)>(getFuncAddr((int)Func::CloudManager::loadChunks))(this);
 		}
 		void updateChunk(const glm::i64vec3& coords) 
 		{
-			return reinterpret_cast<void (__thiscall*)(CloudManager* self, const glm::i64vec3& coords)>(FUNC_CLOUDMANAGER_UPDATECHUNK)(this, coords);
+			return reinterpret_cast<void (__thiscall*)(CloudManager* self, const glm::i64vec3& coords)>(getFuncAddr((int)Func::CloudManager::updateChunk))(this, coords);
 		}
 	};
 }
diff --git a/4dm.h/Coil.h b/4dm.h/Coil.h
index bf53a4c..6f28c06 100644
--- a/4dm.h/Coil.h
+++ b/4dm.h/Coil.h
@@ -12,15 +12,15 @@ namespace fdm
 
 		Coil(int n, int s, float r, float w, float h) 
 		{
-			reinterpret_cast<void(__thiscall*)(Coil* self, int n, int s, float r, float w, float h)>(FUNC_COIL_COIL)(this, n, s, r, w, h);
+			reinterpret_cast<void(__thiscall*)(Coil* self, int n, int s, float r, float w, float h)>(getFuncAddr((int)Func::Coil::Coil))(this, n, s, r, w, h);
 		}
 		int buffSize(int buffIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Coil* self, int buffIndex)>(FUNC_COIL_BUFFSIZE)(this, buffIndex);
+			return reinterpret_cast<int (__thiscall*)(const Coil* self, int buffIndex)>(getFuncAddr((int)Func::Coil::buffSize))(this, buffIndex);
 		}
 		int attrSize(int buffIndex, int attrIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Coil* self, int buffIndex, int attrIndex)>(FUNC_COIL_ATTRSIZE)(this, buffIndex, attrIndex);
+			return reinterpret_cast<int (__thiscall*)(const Coil* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::Coil::attrSize))(this, buffIndex, attrIndex);
 		}
 	};
 }
diff --git a/4dm.h/CompassRenderer.h b/4dm.h/CompassRenderer.h
index ea75c62..72dff5e 100644
--- a/4dm.h/CompassRenderer.h
+++ b/4dm.h/CompassRenderer.h
@@ -23,7 +23,7 @@ namespace fdm
 		inline static MeshRenderer* cubeTriangleRenderer = reinterpret_cast<MeshRenderer*>((base + 0x278908));
 		inline static MeshBuilder* cubeWireframeMesh = reinterpret_cast<MeshBuilder*>((base + 0x278A10));
 		inline static MeshRenderer* cubeWireframeRenderer = reinterpret_cast<MeshRenderer*>((base + 0x278998));
-		inline static glm::vec3** line = reinterpret_cast<glm::vec3**>((base + 0x278440));
+		inline static glm::vec3* line = reinterpret_cast<glm::vec3*>((base + 0x278440));
 		inline static MeshBuilder* lineMesh = reinterpret_cast<MeshBuilder*>((base + 0x278928));
 		inline static MeshRenderer* lineRenderer = reinterpret_cast<MeshRenderer*>((base + 0x2789B8));
 		inline static FontRenderer* fr = reinterpret_cast<FontRenderer*>((base + 0x278AA0));
@@ -37,11 +37,11 @@ namespace fdm
 
 		inline static void renderHand(const glm::mat4& mat) 
 		{
-			return reinterpret_cast<void (__fastcall*)(const glm::mat4& mat)>(FUNC_COMPASSRENDERER_RENDERHAND)(mat);
+			return reinterpret_cast<void (__fastcall*)(const glm::mat4& mat)>(getFuncAddr((int)Func::CompassRenderer::renderHand))(mat);
 		}
 		inline static void renderItemDrop(const m4::Mat5& mat, const glm::vec4& lightDir) 
 		{
-			return reinterpret_cast<void (__fastcall*)(const m4::Mat5& mat, const glm::vec4& lightDir)>(FUNC_COMPASSRENDERER_RENDERITEMDROP)(mat, lightDir);
+			return reinterpret_cast<void (__fastcall*)(const m4::Mat5& mat, const glm::vec4& lightDir)>(getFuncAddr((int)Func::CompassRenderer::renderItemDrop))(mat, lightDir);
 		}
 	};
 }
diff --git a/4dm.h/Connection/Client.h b/4dm.h/Connection/Client.h
index 14b7f34..16d9b83 100644
--- a/4dm.h/Connection/Client.h
+++ b/4dm.h/Connection/Client.h
@@ -23,7 +23,7 @@ namespace fdm::Connection
 		Status status;
 		std::atomic<bool> resolvingHost;
 		PAD(3);
-		std::string address;
+		msvc_string address;
 		std::thread resolveHostThread;
 		unsigned int connectionHandle;
 		PAD(4);
@@ -31,19 +31,19 @@ namespace fdm::Connection
 
 		void update()
 		{
-			return reinterpret_cast<void(__thiscall*)(Client * self)>(FUNC_CONNECTION_CLIENT_UPDATE)(this);
+			return reinterpret_cast<void(__thiscall*)(Client * self)>(getFuncAddr((int)Func::Connection_Nested::Client::update))(this);
 		}
-		void resolveHost(std::string& host)
+		void resolveHost(msvc_string& host)
 		{
-			return reinterpret_cast<void(__thiscall*)(Client * self, std::string& host)>(FUNC_CONNECTION_CLIENT_RESOLVEHOST)(this, host);
+			return reinterpret_cast<void(__thiscall*)(Client * self, msvc_string& host)>(getFuncAddr((int)Func::Connection_Nested::Client::resolveHost))(this, host);
 		}
 		void cleanup()
 		{
-			return reinterpret_cast<void(__thiscall*)(Client * self)>(FUNC_CONNECTION_CLIENT_CLEANUP)(this);
+			return reinterpret_cast<void(__thiscall*)(Client * self)>(getFuncAddr((int)Func::Connection_Nested::Client::cleanup))(this);
 		}
 		inline static void connectionStatusChangedCallback(SteamNetConnectionStatusChangedCallback_t* info)
 		{
-			return reinterpret_cast<void(__fastcall*)(SteamNetConnectionStatusChangedCallback_t * info)>(FUNC_CONNECTION_CLIENT_CONNECTIONSTATUSCHANGEDCALLBACK)(info);
+			return reinterpret_cast<void(__fastcall*)(SteamNetConnectionStatusChangedCallback_t * info)>(getFuncAddr((int)Func::Connection_Nested::Client::connectionStatusChangedCallback))(info);
 		}
 	};
-}
\ No newline at end of file
+}
diff --git a/4dm.h/Connection/InMessage.h b/4dm.h/Connection/InMessage.h
index 17b8c1a..b934f14 100644
--- a/4dm.h/Connection/InMessage.h
+++ b/4dm.h/Connection/InMessage.h
@@ -10,16 +10,16 @@ namespace fdm::Connection
 	public:
 		inline static void InMessageDeleter(SteamNetworkingMessage_t* message)
 		{
-			reinterpret_cast<void(__fastcall*)(SteamNetworkingMessage_t* message)>(FUNC_CONNECTION_INMESSAGE_INMESSAGEDELETER)(message);
+			reinterpret_cast<void(__fastcall*)(SteamNetworkingMessage_t* message)>(getFuncAddr((int)Func::Connection_Nested::InMessage::InMessageDeleter))(message);
 		}
 
 		std::unique_ptr<SteamNetworkingMessage_t, void(__cdecl*)(SteamNetworkingMessage_t*)> messagePtr{ nullptr, InMessageDeleter };
 		~InMessage()
 		{
-			reinterpret_cast<void(__thiscall*)(Connection::InMessage* self)>(FUNC_CONNECTION_INMESSAGE_DESTR_INMESSAGE)(this);
+			reinterpret_cast<void(__thiscall*)(Connection::InMessage* self)>(getFuncAddr((int)Func::Connection_Nested::InMessage::destr_InMessage))(this);
 		}
 		InMessage() : messagePtr(nullptr, InMessageDeleter) {}
 		InMessage(SteamNetworkingMessage_t* msg) : messagePtr(msg, InMessageDeleter) {}
 	};
 
-}
\ No newline at end of file
+}
diff --git a/4dm.h/Connection/OutMessage.h b/4dm.h/Connection/OutMessage.h
index b789ed3..0d0398f 100644
--- a/4dm.h/Connection/OutMessage.h
+++ b/4dm.h/Connection/OutMessage.h
@@ -16,17 +16,17 @@ namespace fdm::Connection
 
 		SteamNetworkingMessage_t* createMessage(unsigned int recipient, int sendFlags)
 		{
-			return reinterpret_cast<SteamNetworkingMessage_t* (__thiscall*)(Connection::OutMessage*, unsigned int, int)>(FUNC_CONNECTION_OUTMESSAGE_CREATEMESSAGE)(this, recipient, sendFlags);
+			return reinterpret_cast<SteamNetworkingMessage_t* (__thiscall*)(Connection::OutMessage*, unsigned int, int)>(getFuncAddr((int)Func::Connection_Nested::OutMessage::createMessage))(this, recipient, sendFlags);
 		}
-		OutMessage(unsigned short type, const std::string& content) : data(nullptr, ReleaseHeapMessageData)
+		OutMessage(unsigned short type, const msvc_string& content) : data(nullptr, ReleaseHeapMessageData)
 		{
-			reinterpret_cast<void(__thiscall*)(Connection::OutMessage*, unsigned short type, const std::string& content)>(FUNC_CONNECTION_OUTMESSAGE_OUTMESSAGE)(this, type, content);
+			reinterpret_cast<void(__thiscall*)(Connection::OutMessage*, unsigned short type, const msvc_string& content)>(getFuncAddr((int)Func::Connection_Nested::OutMessage::OutMessage))(this, type, content);
 		}
 		OutMessage() : data(nullptr, ReleaseHeapMessageData){}
 		OutMessage(Connection::MessageData* msgData) : data(msgData, ReleaseHeapMessageData){}
 		inline static void ReleaseHeapMessageData(Connection::MessageData* data)
 		{
-			reinterpret_cast<void(__fastcall*)(Connection::MessageData* data)>(FUNC_CONNECTION_OUTMESSAGE_RELEASEHEAPMESSAGEDATA)(data);
+			reinterpret_cast<void(__fastcall*)(Connection::MessageData* data)>(getFuncAddr((int)Func::Connection_Nested::OutMessage::ReleaseHeapMessageData))(data);
 		}
 	};
-}
\ No newline at end of file
+}
diff --git a/4dm.h/Console.h b/4dm.h/Console.h
new file mode 100644
index 0000000..17791d1
--- /dev/null
+++ b/4dm.h/Console.h
@@ -0,0 +1,83 @@
+#pragma once
+
+#include "4dm.h"
+
+namespace fdm
+{
+	enum Color
+	{
+		BLACK = 30,
+		RED,
+		GREEN,
+		YELLOW,
+		BLUE,
+		MAGENTA,
+		CYAN,
+		WHITE
+	};
+	enum Variant
+	{
+		NORMAL = 0,
+		BRIGHT,
+		DIM,
+		ITALIC,
+		UNDERLINE,
+		BLINKING,
+		INVERSE = 7,
+		HIDDEN,
+		STRIKETHROUGH
+	};
+	struct Mode
+	{
+		Color color;
+		Variant variant;
+
+		Mode(Color color = WHITE, Variant variant = NORMAL) : color(color), variant(variant) {}
+	};
+}
+
+// some std extensions
+namespace std
+{
+	inline string to_string(const fdm::Mode& mode) noexcept
+	{
+		stringstream ss;
+		ss << "\x1B[";
+		ss << mode.variant << ';' << mode.color << 'm';
+		return ss.str();
+	}
+	inline ostream& operator<<(ostream& os, const fdm::Mode& mode)
+	{
+		os << to_string(mode);
+		return os;
+	}
+}
+
+namespace fdm
+{
+	class Console
+	{
+	public:
+		inline static std::mutex* inputMutex = reinterpret_cast<std::mutex*>((fdm::base + 0x2BDF40));
+		inline static std::vector<msvc_string>* inStrings = reinterpret_cast<std::vector<msvc_string>*>((fdm::base + 0x2C4050));
+
+		// example usage: `Console::print(Mode(GREEN, BRIGHT), "Player ", Mode(WHITE, BRIGHT), playerName, Mode(GREEN, BRIGHT), " joined the game!\n")`. if you dont want to put a new line symbol at the end of the string, use Console::printLine instead, which does it for you
+		template <typename... Args>
+		inline static void print(Args const&... args)
+		{
+			std::cout << Mode();
+			(std::cout << ... << args);
+			std::cout << Mode();
+		}
+
+		// example usage: `Console::print(Mode(GREEN, BRIGHT), "Player ", Mode(WHITE, BRIGHT), playerName, Mode(GREEN, BRIGHT), " joined the game!\n")`. if you dont want a new line symbol at the end of the string, use Console::print instead.
+		template <typename... Args>
+		inline static void printLine(Args const&... args)
+		{
+			std::cout << Mode();
+			(std::cout << ... << args);
+			std::cout << '\n';
+			std::cout << Mode();
+		}
+	};
+}
\ No newline at end of file
diff --git a/4dm.h/CraftingMenu.h b/4dm.h/CraftingMenu.h
index fce6648..4b97c48 100644
--- a/4dm.h/CraftingMenu.h
+++ b/4dm.h/CraftingMenu.h
@@ -11,6 +11,8 @@ namespace fdm
 
 	class InventoryManager;
 	class InventoryCursor;
+	class gui::Window;
+	class gui::Element;
 	class Item;
 
 	class CraftingMenu : public gui::Element 
@@ -26,14 +28,14 @@ namespace fdm
 
 			~CraftableRecipe() 
 			{
-				reinterpret_cast<void(__thiscall*)(CraftingMenu::CraftableRecipe* self)>(FUNC_CRAFTINGMENU_CRAFTABLERECIPE_DESTR_CRAFTABLERECIPE)(this);
+				reinterpret_cast<void(__thiscall*)(CraftingMenu::CraftableRecipe* self)>(getFuncAddr((int)Func::CraftingMenu_Nested::CraftableRecipe::destr_CraftableRecipe))(this);
 			}
 			CraftableRecipe(int recipeIndex, nlohmann::json& j, int availableCount) 
 			{
-				reinterpret_cast<void(__thiscall*)(CraftingMenu::CraftableRecipe* self, int recipeIndex, nlohmann::json& j, int availableCount)>(FUNC_CRAFTINGMENU_CRAFTABLERECIPE_CRAFTABLERECIPE)(this, recipeIndex, j, availableCount);
+				reinterpret_cast<void(__thiscall*)(CraftingMenu::CraftableRecipe* self, int recipeIndex, nlohmann::json& j, int availableCount)>(getFuncAddr((int)Func::CraftingMenu_Nested::CraftableRecipe::CraftableRecipe))(this, recipeIndex, j, availableCount);
 			}
 		};
-		inline static nlohmann::json* recipes = reinterpret_cast<nlohmann::json*>((base + 0x2BDF90));
+		inline static nlohmann::json* recipes = reinterpret_cast<nlohmann::json*>((base + 0x4DF90 + 0x270000));
 		InventoryManager* Interface; // 0x8
 		InventoryCursor* cursor; // 0x10
 		std::vector<CraftingMenu::CraftableRecipe> craftableRecipes; // 0x18
@@ -41,41 +43,41 @@ namespace fdm
 		int yOffset; // 0x34
 		gui::AlignmentX xAlign; // 0x38
 		gui::AlignmentY yAlign; // 0x3C
-		inline static TexRenderer* tr = reinterpret_cast<TexRenderer*>((base + 0x2BDFA0));
+		inline static TexRenderer* tr = reinterpret_cast<TexRenderer*>((base + 0x4DFA0 + 0x270000));
 		CraftingMenuCallback callback = NULL; // 0x40
 		void* user; // 0x48
 
 		inline static bool loadRecipes() 
 		{
-			return reinterpret_cast<bool (__fastcall*)()>(FUNC_CRAFTINGMENU_LOADRECIPES)();
+			return reinterpret_cast<bool (__fastcall*)()>(getFuncAddr((int)Func::CraftingMenu::loadRecipes))();
 		}
 		void render(gui::Window* w) override
 		{
-			return reinterpret_cast<void (__thiscall*)(CraftingMenu* self, gui::Window* w)>(FUNC_CRAFTINGMENU_RENDER)(this, w);
+			return reinterpret_cast<void (__thiscall*)(CraftingMenu* self, gui::Window* w)>(getFuncAddr((int)Func::CraftingMenu::render))(this, w);
 		}
 		void offsetX(int offset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(CraftingMenu* self, int offset)>(FUNC_CRAFTINGMENU_OFFSETX)(this, offset);
+			return reinterpret_cast<void (__thiscall*)(CraftingMenu* self, int offset)>(getFuncAddr((int)Func::CraftingMenu::offsetX))(this, offset);
 		}
 		void offsetY(int offset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(CraftingMenu* self, int offset)>(FUNC_CRAFTINGMENU_OFFSETY)(this, offset);
+			return reinterpret_cast<void (__thiscall*)(CraftingMenu* self, int offset)>(getFuncAddr((int)Func::CraftingMenu::offsetY))(this, offset);
 		}
-		void getPos(gui::Window* w, int* x, int* y) override
+		void getPos(const gui::Window* w, int* x, int* y) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(CraftingMenu* self, gui::Window* w, int* x, int* y)>(FUNC_CRAFTINGMENU_GETPOS)(this, w, x, y);
+			return reinterpret_cast<void (__thiscall*)(const CraftingMenu* self, const gui::Window* w, int* x, int* y)>(getFuncAddr((int)Func::CraftingMenu::getPos))(this, w, x, y);
 		}
-		void getSize(gui::Window* w, int* width, int* height) override
+		void getSize(const gui::Window* w, int* width, int* height) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(CraftingMenu* self, gui::Window* w, int* width, int* height)>(FUNC_CRAFTINGMENU_GETSIZE)(this, w, width, height);
+			return reinterpret_cast<void (__thiscall*)(const CraftingMenu* self, const gui::Window* w, int* width, int* height)>(getFuncAddr((int)Func::CraftingMenu::getSize))(this, w, width, height);
 		}
-		bool mouseButtonInput(gui::Window* w, int button, int action, int mods) override
+		bool mouseButtonInput(const gui::Window* w, int button, int action, int mods) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(CraftingMenu* self, gui::Window* w, int button, int action, int mods)>(FUNC_CRAFTINGMENU_MOUSEBUTTONINPUT)(this, w, button, action, mods);
+			return reinterpret_cast<bool (__thiscall*)(CraftingMenu* self, const gui::Window* w, int button, int action, int mods)>(getFuncAddr((int)Func::CraftingMenu::mouseButtonInput))(this, w, button, action, mods);
 		}
 		void updateAvailableRecipes() 
 		{
-			return reinterpret_cast<void (__thiscall*)(CraftingMenu* self)>(FUNC_CRAFTINGMENU_UPDATEAVAILABLERECIPES)(this);
+			return reinterpret_cast<void (__thiscall*)(CraftingMenu* self)>(getFuncAddr((int)Func::CraftingMenu::updateAvailableRecipes))(this);
 		}
 	};
 }
diff --git a/4dm.h/Dodecaplex.h b/4dm.h/Dodecaplex.h
index 0320aee..f1583b2 100644
--- a/4dm.h/Dodecaplex.h
+++ b/4dm.h/Dodecaplex.h
@@ -39,39 +39,39 @@ namespace fdm
 
 		int buffCount() const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Dodecaplex* self)>(FUNC_DODECAPLEX_BUFFCOUNT)(this);
+			return reinterpret_cast<int (__thiscall*)(const Dodecaplex* self)>(getFuncAddr((int)Func::Dodecaplex::buffCount))(this);
 		}
 		const void* buffData(int buffIndex) const override
 		{
-			return reinterpret_cast<const void* (__thiscall*)(const Dodecaplex* self, int buffIndex)>(FUNC_DODECAPLEX_BUFFDATA)(this, buffIndex);
+			return reinterpret_cast<const void* (__thiscall*)(const Dodecaplex* self, int buffIndex)>(getFuncAddr((int)Func::Dodecaplex::buffData))(this, buffIndex);
 		}
 		int buffSize(int buffIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Dodecaplex* self, int buffIndex)>(FUNC_DODECAPLEX_BUFFSIZE)(this, buffIndex);
+			return reinterpret_cast<int (__thiscall*)(const Dodecaplex* self, int buffIndex)>(getFuncAddr((int)Func::Dodecaplex::buffSize))(this, buffIndex);
 		}
 		int attrSize(int buffIndex, int attrIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Dodecaplex* self, int buffIndex, int attrIndex)>(FUNC_DODECAPLEX_ATTRSIZE)(this, buffIndex, attrIndex);
+			return reinterpret_cast<int (__thiscall*)(const Dodecaplex* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::Dodecaplex::attrSize))(this, buffIndex, attrIndex);
 		}
 		void generateMesh(bool hollow, float distance, bool generateInner, const glm::vec3& colors, bool spider) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Dodecaplex* self, bool hollow, float distance, bool generateInner, const glm::vec3& colors, bool spider)>(FUNC_DODECAPLEX_GENERATEMESH)(this, hollow, distance, generateInner, colors, spider);
+			return reinterpret_cast<void (__thiscall*)(Dodecaplex* self, bool hollow, float distance, bool generateInner, const glm::vec3& colors, bool spider)>(getFuncAddr((int)Func::Dodecaplex::generateMesh))(this, hollow, distance, generateInner, colors, spider);
 		}
 		void generateCellColors(std::vector<glm::vec3>& colors) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Dodecaplex* self, std::vector<glm::vec3>& colors)>(FUNC_DODECAPLEX_GENERATECELLCOLORS)(this, colors);
+			return reinterpret_cast<void (__thiscall*)(Dodecaplex* self, std::vector<glm::vec3>& colors)>(getFuncAddr((int)Func::Dodecaplex::generateCellColors))(this, colors);
 		}
 		void addFaces(Dodecaplex::Face* face, std::vector<DodecaplexWireframe::Face>* list, int recurse_limit) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Dodecaplex* self, Dodecaplex::Face* face, std::vector<DodecaplexWireframe::Face>* list, int recurse_limit)>(FUNC_DODECAPLEX_ADDFACES)(this, face, list, recurse_limit);
+			return reinterpret_cast<void (__thiscall*)(Dodecaplex* self, Dodecaplex::Face* face, std::vector<DodecaplexWireframe::Face>* list, int recurse_limit)>(getFuncAddr((int)Func::Dodecaplex::addFaces))(this, face, list, recurse_limit);
 		}
 		void addCells(Dodecaplex::Cell* cell, std::vector<DodecaplexWireframe::Cell>* list, int recurse_limit) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Dodecaplex* self, Dodecaplex::Cell* cell, std::vector<DodecaplexWireframe::Cell>* list, int recurse_limit)>(FUNC_DODECAPLEX_ADDCELLS)(this, cell, list, recurse_limit);
+			return reinterpret_cast<void (__thiscall*)(Dodecaplex* self, Dodecaplex::Cell* cell, std::vector<DodecaplexWireframe::Cell>* list, int recurse_limit)>(getFuncAddr((int)Func::Dodecaplex::addCells))(this, cell, list, recurse_limit);
 		}
 		~Dodecaplex() 
 		{
-			reinterpret_cast<void(__thiscall*)(Dodecaplex* self)>(FUNC_DODECAPLEX_DESTR_DODECAPLEX)(this);
+			reinterpret_cast<void(__thiscall*)(Dodecaplex* self)>(getFuncAddr((int)Func::Dodecaplex::destr_Dodecaplex))(this);
 		}
 
 		int attrCount(int buffIndex) const { return 0; }
diff --git a/4dm.h/DodecaplexWireframe.h b/4dm.h/DodecaplexWireframe.h
index 3355f70..20fc148 100644
--- a/4dm.h/DodecaplexWireframe.h
+++ b/4dm.h/DodecaplexWireframe.h
@@ -34,15 +34,15 @@ namespace fdm
 
 		void generateMesh() 
 		{
-			return reinterpret_cast<void (__thiscall*)(DodecaplexWireframe* self)>(FUNC_DODECAPLEXWIREFRAME_GENERATEMESH)(this);
+			return reinterpret_cast<void (__thiscall*)(DodecaplexWireframe* self)>(getFuncAddr((int)Func::DodecaplexWireframe::generateMesh))(this);
 		}
 		void addFaces(DodecaplexWireframe::Face* face, std::vector<DodecaplexWireframe::Face>* list, int recurse_limit) 
 		{
-			return reinterpret_cast<void (__thiscall*)(DodecaplexWireframe* self, DodecaplexWireframe::Face* face, std::vector<DodecaplexWireframe::Face>* list, int recurse_limit)>(FUNC_DODECAPLEXWIREFRAME_ADDFACES)(this, face, list, recurse_limit);
+			return reinterpret_cast<void (__thiscall*)(DodecaplexWireframe* self, DodecaplexWireframe::Face* face, std::vector<DodecaplexWireframe::Face>* list, int recurse_limit)>(getFuncAddr((int)Func::DodecaplexWireframe::addFaces))(this, face, list, recurse_limit);
 		}
 		void addCells(DodecaplexWireframe::Cell* cell, std::vector<DodecaplexWireframe::Cell>* list, int recurse_limit) 
 		{
-			return reinterpret_cast<void (__thiscall*)(DodecaplexWireframe* self, DodecaplexWireframe::Cell* cell, std::vector<DodecaplexWireframe::Cell>* list, int recurse_limit)>(FUNC_DODECAPLEXWIREFRAME_ADDCELLS)(this, cell, list, recurse_limit);
+			return reinterpret_cast<void (__thiscall*)(DodecaplexWireframe* self, DodecaplexWireframe::Cell* cell, std::vector<DodecaplexWireframe::Cell>* list, int recurse_limit)>(getFuncAddr((int)Func::DodecaplexWireframe::addCells))(this, cell, list, recurse_limit);
 		}
 	};
 }
diff --git a/4dm.h/Entity.h b/4dm.h/Entity.h
index 46a28ca..89d0c5a 100644
--- a/4dm.h/Entity.h
+++ b/4dm.h/Entity.h
@@ -28,7 +28,7 @@ namespace fdm
 		//PAD(0x1); // --> inline static boost::uuids::string_generator *uuidParser = reinterpret_cast<boost::uuids::string_generator*>((base + 0x29B3E0))
 		inline static TexRenderer* ftr = NULL; 
 		inline static FontRenderer* fr = NULL; 
-		inline static nlohmann::json* blueprints = reinterpret_cast<nlohmann::json*>((base + 0x2BE5A8));
+		inline static nlohmann::json* blueprints = reinterpret_cast<nlohmann::json*>((base + 0x4E5A8 + 0x270000));
 		uuid id; // 0x8
 		bool dead; // 0x18
 
@@ -36,38 +36,38 @@ namespace fdm
 
 		inline static bool loadEntityInfo() 
 		{
-			return reinterpret_cast<bool (__fastcall*)()>(FUNC_ENTITY_LOADENTITYINFO)();
+			return reinterpret_cast<bool (__fastcall*)()>(getFuncAddr((int)Func::Entity::loadEntityInfo))();
 		}
 		inline static std::unique_ptr<Entity> createFromJson(nlohmann::json& j) 
 		{
-			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)( nlohmann::json& j)>(FUNC_ENTITY_CREATEFROMJSON)(j);
+			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)( nlohmann::json& j)>(getFuncAddr((int)Func::Entity::createFromJson))(j);
 		}
-		inline static std::unique_ptr<Entity> createWithAttributes(std::string& entityName, std::string& pos, nlohmann::json& attributes) 
+		inline static std::unique_ptr<Entity> createWithAttributes(msvc_string& entityName, msvc_string& pos, nlohmann::json& attributes) 
 		{
-			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)(std::string& entityName, std::string& pos, nlohmann::json& attributes)>(FUNC_ENTITY_CREATEWITHATTRIBUTES)(entityName, pos, attributes);
+			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)(msvc_string& entityName, msvc_string& pos, nlohmann::json& attributes)>(getFuncAddr((int)Func::Entity::createWithAttributes))(entityName, pos, attributes);
 		}
 		nlohmann::json save() 
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(Entity* self, nlohmann::json* result)>(FUNC_ENTITY_SAVE)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(Entity* self, nlohmann::json* result)>(getFuncAddr((int)Func::Entity::save))(this, &result);
 			return result;
 		}
-		inline static std::unique_ptr<Entity> instantiateEntity(const std::string& itemName, const uuid& id, glm::vec4& pos, const std::string& type, nlohmann::json& attributes) 
+		inline static std::unique_ptr<Entity> instantiateEntity(const msvc_string& itemName, const uuid& id, glm::vec4& pos, const msvc_string& type, nlohmann::json& attributes) 
 		{
-			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)(const std::string& itemName, const uuid& id, glm::vec4& pos, const std::string& type, nlohmann::json& attributes)>(FUNC_ENTITY_INSTANTIATEENTITY)(itemName, id, pos, type, attributes);
+			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)(const msvc_string& itemName, const uuid& id, glm::vec4& pos, const msvc_string& type, nlohmann::json& attributes)>(getFuncAddr((int)Func::Entity::instantiateEntity))(itemName, id, pos, type, attributes);
 		}
 		inline static nlohmann::json combineEntityAttributes(nlohmann::json& baseAttributes, nlohmann::json& additions) 
 		{
-			return reinterpret_cast<nlohmann::json (__fastcall*)(nlohmann::json& baseAttributes, nlohmann::json& additions)>(FUNC_ENTITY_COMBINEENTITYATTRIBUTES)(baseAttributes, additions);
+			return reinterpret_cast<nlohmann::json (__fastcall*)(nlohmann::json& baseAttributes, nlohmann::json& additions)>(getFuncAddr((int)Func::Entity::combineEntityAttributes))(baseAttributes, additions);
 		}
 		virtual ~Entity()
 		{
-			reinterpret_cast<void(__thiscall*)(Entity* self)>(FUNC_ENTITY_DESTR_ENTITY)(this);
+			reinterpret_cast<void(__thiscall*)(Entity* self)>(getFuncAddr((int)Func::Entity::destr_Entity))(this);
 		}
 
 		// VIRTUAL FUNCS
 
-		virtual std::string getName() { return ""; }
+		virtual msvc_string getName() { return ""; }
 		virtual void update(World* world, double dt) {}
 		virtual void render(const World* world, const m4::Mat5& MV, bool glasses) {}
 		virtual nlohmann::json saveAttributes() { return NULL; }
diff --git a/4dm.h/EntityAlidade.h b/4dm.h/EntityAlidade.h
index d8ccd3f..204c654 100644
--- a/4dm.h/EntityAlidade.h
+++ b/4dm.h/EntityAlidade.h
@@ -22,11 +22,11 @@ namespace fdm
 
 			SPInfo() 
 			{
-				reinterpret_cast<void(__thiscall*)(EntityAlidade::SPInfo* self)>(FUNC_ENTITYALIDADE_SPINFO_SPINFO)(this);
+				reinterpret_cast<void(__thiscall*)(EntityAlidade::SPInfo* self)>(getFuncAddr((int)Func::EntityAlidade_Nested::SPInfo::SPInfo))(this);
 			}
 			~SPInfo() 
 			{
-				reinterpret_cast<void(__thiscall*)(EntityAlidade::SPInfo* self)>(FUNC_ENTITYALIDADE_SPINFO_DESTR_SPINFO)(this);
+				reinterpret_cast<void(__thiscall*)(EntityAlidade::SPInfo* self)>(getFuncAddr((int)Func::EntityAlidade_Nested::SPInfo::destr_SPInfo))(this);
 			}
 		};
 		inline static MeshRenderer *telescopeRenderer = reinterpret_cast<MeshRenderer*>((base + 0x278828)); 
@@ -41,59 +41,59 @@ namespace fdm
 		glm::ivec4 currentBlock; // 0x84
 		m4::Mat5 orientation; // 0x94
 
-		std::string getName() override
+		msvc_string getName() override
 		{
-			std::string result;
-			return reinterpret_cast<std::string (__thiscall*)(EntityAlidade* self, std::string* result)>(FUNC_ENTITYALIDADE_GETNAME)(this, &result);
+			msvc_string result;
+			return reinterpret_cast<msvc_string& (__thiscall*)(EntityAlidade* self, msvc_string* result)>(getFuncAddr((int)Func::EntityAlidade::getName))(this, &result);
 			return result;
 		}
 		void update(World* world, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityAlidade* self, World* world, double dt)>(FUNC_ENTITYALIDADE_UPDATE)(this, world, dt);
+			return reinterpret_cast<void (__thiscall*)(EntityAlidade* self, World* world, double dt)>(getFuncAddr((int)Func::EntityAlidade::update))(this, world, dt);
 		}
 		void render(const World* world, const m4::Mat5& MV, bool glasses) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityAlidade* self, const World* world, const m4::Mat5& MV, bool glasses)>(FUNC_ENTITYALIDADE_RENDER)(this, world, MV, glasses);
+			return reinterpret_cast<void (__thiscall*)(EntityAlidade* self, const World* world, const m4::Mat5& MV, bool glasses)>(getFuncAddr((int)Func::EntityAlidade::render))(this, world, MV, glasses);
 		}
 		nlohmann::json saveAttributes() override
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(EntityAlidade* self, nlohmann::json* result)>(FUNC_ENTITYALIDADE_SAVEATTRIBUTES)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(EntityAlidade* self, nlohmann::json* result)>(getFuncAddr((int)Func::EntityAlidade::saveAttributes))(this, &result);
 			return result;
 		}
 		glm::vec4 getPos() override
 		{
 			glm::vec4 result;
-			return reinterpret_cast<glm::vec4 (__thiscall*)(EntityAlidade* self, glm::vec4* result)>(FUNC_ENTITYALIDADE_GETPOS)(this, &result);
+			return reinterpret_cast<glm::vec4& (__thiscall*)(EntityAlidade* self, glm::vec4* result)>(getFuncAddr((int)Func::EntityAlidade::getPos))(this, &result);
 			return result;
 		}
 		void setPos(const glm::vec4& pos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityAlidade* self, const glm::vec4& pos)>(FUNC_ENTITYALIDADE_SETPOS)(this, pos);
+			return reinterpret_cast<void (__thiscall*)(EntityAlidade* self, const glm::vec4& pos)>(getFuncAddr((int)Func::EntityAlidade::setPos))(this, pos);
 		}
 		void takeDamage(float damage, World* world) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityAlidade* self, float damage, World* world)>(FUNC_ENTITYALIDADE_TAKEDAMAGE)(this, damage, world);
+			return reinterpret_cast<void (__thiscall*)(EntityAlidade* self, float damage, World* world)>(getFuncAddr((int)Func::EntityAlidade::takeDamage))(this, damage, world);
 		}
 		bool action(World* world, Entity* actor, int action, const nlohmann::json& details) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(EntityAlidade* self, World* world, Entity* actor, int action, const nlohmann::json & details)>(FUNC_ENTITYALIDADE_ACTION)(this, world, actor, action, details);
+			return reinterpret_cast<bool (__thiscall*)(EntityAlidade* self, World* world, Entity* actor, int action, const nlohmann::json & details)>(getFuncAddr((int)Func::EntityAlidade::action))(this, world, actor, action, details);
 		}
 		void postAction(World* world, Entity* actor, int action) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityAlidade* self, World* world, Entity* actor, int action)>(FUNC_ENTITYALIDADE_POSTACTION)(this, world, actor, action);
+			return reinterpret_cast<void (__thiscall*)(EntityAlidade* self, World* world, Entity* actor, int action)>(getFuncAddr((int)Func::EntityAlidade::postAction))(this, world, actor, action);
 		}
 		inline static void generateSpherinder(MeshRenderer* r, int edges, float height, double diameter) 
 		{
-			return reinterpret_cast<void (__fastcall*)(MeshRenderer* r, int edges, float height, double diameter)>(FUNC_ENTITYALIDADE_GENERATESPHERINDER)(r, edges, height, diameter);
+			return reinterpret_cast<void (__fastcall*)(MeshRenderer* r, int edges, float height, double diameter)>(getFuncAddr((int)Func::EntityAlidade::generateSpherinder))(r, edges, height, diameter);
 		}
 		inline static void generateSpherinderHollow(MeshRenderer* r, int edges, float height, double diameter, float holeDiameter) 
 		{
-			return reinterpret_cast<void (__fastcall*)(MeshRenderer* r, int edges, float height, double diameter, float holeDiameter)>(FUNC_ENTITYALIDADE_GENERATESPHERINDERHOLLOW)(r, edges, height, diameter, holeDiameter);
+			return reinterpret_cast<void (__fastcall*)(MeshRenderer* r, int edges, float height, double diameter, float holeDiameter)>(getFuncAddr((int)Func::EntityAlidade::generateSpherinderHollow))(r, edges, height, diameter, holeDiameter);
 		}
 		inline static void generateSemicircle(MeshRenderer* r, int edges, float diameter, float innerThickness, float sideThickness) 
 		{
-			return reinterpret_cast<void (__fastcall*)(MeshRenderer* r, int edges, float diameter, float innerThickness, float sideThickness)>(FUNC_ENTITYALIDADE_GENERATESEMICIRCLE)(r, edges, diameter, innerThickness, sideThickness);
+			return reinterpret_cast<void (__fastcall*)(MeshRenderer* r, int edges, float diameter, float innerThickness, float sideThickness)>(getFuncAddr((int)Func::EntityAlidade::generateSemicircle))(r, edges, diameter, innerThickness, sideThickness);
 		}
 	};
 }
diff --git a/4dm.h/EntityButterfly.h b/4dm.h/EntityButterfly.h
index e6296a9..0d32899 100644
--- a/4dm.h/EntityButterfly.h
+++ b/4dm.h/EntityButterfly.h
@@ -13,7 +13,7 @@ namespace fdm
 			const glm::vec4 colorB; // 0x10
 
 		};
-		inline static glm::u8vec3** wing_tuv = reinterpret_cast<glm::u8vec3**>((base + 0x2ACC90));
+		inline static glm::u8vec3* wing_tuv = reinterpret_cast<glm::u8vec3*>((base + 0x2ACC90));
 		inline static const float hitboxRadius = 1.4f; 
 		inline static const float maxSpeed = 1.8f; 
 		Hitbox hitbox; // 0x20
@@ -23,7 +23,7 @@ namespace fdm
 		double hitTime; // 0x88
 		inline static const float hitDelay = 0.7f; 
 		inline static const int NUM_TYPES = 4; 
-		inline static EntityButterfly::ButterflyType** ButterflyTypes = reinterpret_cast<EntityButterfly::ButterflyType**>((base + 0x2783C0));
+		inline static EntityButterfly::ButterflyType* ButterflyTypes = reinterpret_cast<EntityButterfly::ButterflyType*>((base + 0x2783C0));
 		int type; // 0x90
 		inline static MeshRenderer* wingRenderer = reinterpret_cast<MeshRenderer*>((base + 0x2788C8));
 		inline static MeshRenderer* wireframeRenderer = reinterpret_cast<MeshRenderer*>((base + 0x2788A8));
@@ -37,45 +37,45 @@ namespace fdm
 		m4::BiVector4 rotationPlane; // 0xA8
 		float angleToRotate; // 0xC0
 
-		std::string getName() override
+		msvc_string getName() override
 		{
-			std::string result;
-			return reinterpret_cast<std::string (__thiscall*)(EntityButterfly* self, std::string* result)>(FUNC_ENTITYBUTTERFLY_GETNAME)(this, &result);
+			msvc_string result;
+			return reinterpret_cast<msvc_string& (__thiscall*)(EntityButterfly* self, msvc_string* result)>(getFuncAddr((int)Func::EntityButterfly::getName))(this, &result);
 			return result;
 		}
 		void update(World* world, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self, World* world, double dt)>(FUNC_ENTITYBUTTERFLY_UPDATE)(this, world, dt);
+			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self, World* world, double dt)>(getFuncAddr((int)Func::EntityButterfly::update))(this, world, dt);
 		}
 		void render(const World* world, const m4::Mat5& MV, bool glasses) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self, const World* world, const m4::Mat5& MV, bool glasses)>(FUNC_ENTITYBUTTERFLY_RENDER)(this, world, MV, glasses);
+			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self, const World* world, const m4::Mat5& MV, bool glasses)>(getFuncAddr((int)Func::EntityButterfly::render))(this, world, MV, glasses);
 		}
 		nlohmann::json getServerUpdateAttributes() override
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(EntityButterfly* self, nlohmann::json* result)>(FUNC_ENTITYBUTTERFLY_GETSERVERUPDATEATTRIBUTES)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(EntityButterfly* self, nlohmann::json* result)>(getFuncAddr((int)Func::EntityButterfly::getServerUpdateAttributes))(this, &result);
 			return result;
 		}
 		void applyServerUpdate(const nlohmann::json& j, World* world) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self, const nlohmann::json& j, World* world)>(FUNC_ENTITYBUTTERFLY_APPLYSERVERUPDATE)(this, j, world);
+			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self, const nlohmann::json& j, World* world)>(getFuncAddr((int)Func::EntityButterfly::applyServerUpdate))(this, j, world);
 		}
 		void takeDamage(float damage, World* world) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self, float damage, World* world)>(FUNC_ENTITYBUTTERFLY_TAKEDAMAGE)(this, damage, world);
+			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self, float damage, World* world)>(getFuncAddr((int)Func::EntityButterfly::takeDamage))(this, damage, world);
 		}
 		void playHitSound() 
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self)>(FUNC_ENTITYBUTTERFLY_PLAYHITSOUND)(this);
+			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self)>(getFuncAddr((int)Func::EntityButterfly::playHitSound))(this);
 		}
 		void playDeathSound() 
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self)>(FUNC_ENTITYBUTTERFLY_PLAYDEATHSOUND)(this);
+			return reinterpret_cast<void (__thiscall*)(EntityButterfly* self)>(getFuncAddr((int)Func::EntityButterfly::playDeathSound))(this);
 		}
 		inline static void collisionCallback(void* user, Hitbox* hitbox, World* world, const glm::ivec4& collisionBlock, int collisionComp, const glm::vec4& prevVel) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, Hitbox* hitbox, World* world, const glm::ivec4& collisionBlock, int collisionComp, const glm::vec4& prevVel)>(FUNC_ENTITYBUTTERFLY_COLLISIONCALLBACK)(user, hitbox, world, collisionBlock, collisionComp, prevVel);
+			return reinterpret_cast<void (__fastcall*)(void* user, Hitbox* hitbox, World* world, const glm::ivec4& collisionBlock, int collisionComp, const glm::vec4& prevVel)>(getFuncAddr((int)Func::EntityButterfly::collisionCallback))(user, hitbox, world, collisionBlock, collisionComp, prevVel);
 		}
 	};
 }
diff --git a/4dm.h/EntityChest.h b/4dm.h/EntityChest.h
index a0cafa3..30988e1 100644
--- a/4dm.h/EntityChest.h
+++ b/4dm.h/EntityChest.h
@@ -19,51 +19,51 @@ namespace fdm
 
 		bool isClickable() override
 		{
-			return reinterpret_cast<bool (__thiscall*)(EntityChest* self)>(FUNC_ENTITYCHEST_ISCLICKABLE)(this);
+			return reinterpret_cast<bool (__thiscall*)(EntityChest* self)>(getFuncAddr((int)Func::EntityChest::isClickable))(this);
 		}
-		std::string getName() override
+		msvc_string getName() override
 		{
-			std::string result;
-			return reinterpret_cast<std::string (__thiscall*)(EntityChest* self, std::string* result)>(FUNC_ENTITYCHEST_GETNAME)(this, &result);
+			msvc_string result;
+			return reinterpret_cast<msvc_string& (__thiscall*)(EntityChest* self, msvc_string* result)>(getFuncAddr((int)Func::EntityChest::getName))(this, &result);
 			return result;
 		}
 		void update(World* world, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityChest* self, World* world, double dt)>(FUNC_ENTITYCHEST_UPDATE)(this, world, dt);
+			return reinterpret_cast<void (__thiscall*)(EntityChest* self, World* world, double dt)>(getFuncAddr((int)Func::EntityChest::update))(this, world, dt);
 		}
 		void render(const World* world, const m4::Mat5& MV, bool glasses) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityChest* self, const World* world, const m4::Mat5& MV, bool glasses)>(FUNC_ENTITYCHEST_RENDER)(this, world, MV, glasses);
+			return reinterpret_cast<void (__thiscall*)(EntityChest* self, const World* world, const m4::Mat5& MV, bool glasses)>(getFuncAddr((int)Func::EntityChest::render))(this, world, MV, glasses);
 		}
 		nlohmann::json saveAttributes() override
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(EntityChest* self, nlohmann::json* result)>(FUNC_ENTITYCHEST_SAVEATTRIBUTES)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(EntityChest* self, nlohmann::json* result)>(getFuncAddr((int)Func::EntityChest::saveAttributes))(this, &result);
 			return result;
 		}
 		nlohmann::json getServerUpdateAttributes() override
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(EntityChest* self, nlohmann::json* result)>(FUNC_ENTITYCHEST_GETSERVERUPDATEATTRIBUTES)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(EntityChest* self, nlohmann::json* result)>(getFuncAddr((int)Func::EntityChest::getServerUpdateAttributes))(this, &result);
 			return result;
 		}
 		void applyServerUpdate(const nlohmann::json& j, World* world) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityChest* self, const nlohmann::json& j, World* world)>(FUNC_ENTITYCHEST_APPLYSERVERUPDATE)(this, j, world);
+			return reinterpret_cast<void (__thiscall*)(EntityChest* self, const nlohmann::json& j, World* world)>(getFuncAddr((int)Func::EntityChest::applyServerUpdate))(this, j, world);
 		}
 		glm::vec4 getPos() override
 		{
 			glm::vec4 result;
-			return reinterpret_cast<glm::vec4 (__thiscall*)(EntityChest* self, glm::vec4* result)>(FUNC_ENTITYCHEST_GETPOS)(this, &result);
+			return reinterpret_cast<glm::vec4& (__thiscall*)(EntityChest* self, glm::vec4* result)>(getFuncAddr((int)Func::EntityChest::getPos))(this, &result);
 			return result;
 		}
 		void setPos(const glm::vec4& pos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityChest* self, const glm::vec4& pos)>(FUNC_ENTITYCHEST_SETPOS)(this, pos);
+			return reinterpret_cast<void (__thiscall*)(EntityChest* self, const glm::vec4& pos)>(getFuncAddr((int)Func::EntityChest::setPos))(this, pos);
 		}
 		bool action(World* world, Entity* actor, int action, const nlohmann::json& details) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(EntityChest* self, World* world, Entity* actor, int action, const nlohmann::json& details)>(FUNC_ENTITYCHEST_ACTION)(this, world, actor, action, details);
+			return reinterpret_cast<bool (__thiscall*)(EntityChest* self, World* world, Entity* actor, int action, const nlohmann::json& details)>(getFuncAddr((int)Func::EntityChest::action))(this, world, actor, action, details);
 		}
 	};
 }
diff --git a/4dm.h/EntityDying.h b/4dm.h/EntityDying.h
index 55b300d..b63a2c4 100644
--- a/4dm.h/EntityDying.h
+++ b/4dm.h/EntityDying.h
@@ -8,57 +8,57 @@ namespace fdm
 	{
 	public:
 		std::unique_ptr<Entity> entity; // 0x20
-		float deathTime; // 0x28
+		double deathTime; // 0x28
 
 		float deathTimer() override
 		{
-			return reinterpret_cast<float (__thiscall*)(EntityDying* self)>(FUNC_ENTITYDYING_DEATHTIMER)(this);
+			return reinterpret_cast<float (__thiscall*)(EntityDying* self)>(getFuncAddr((int)Func::EntityDying::deathTimer))(this);
 		}
 		inline static std::unique_ptr<Entity> createWithEntity(const std::unique_ptr<Entity>& entity, uuid* id) 
 		{
-			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)(const std::unique_ptr<Entity>&entity, uuid* id)>(FUNC_ENTITYDYING_CREATEWITHENTITY)(entity, id);
+			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)(const std::unique_ptr<Entity>&entity, uuid* id)>(getFuncAddr((int)Func::EntityDying::createWithEntity))(entity, id);
 		}
-		std::string getName() override
+		msvc_string getName() override
 		{
-			std::string result;
-			return reinterpret_cast<std::string (__thiscall*)(EntityDying* self, std::string* result)>(FUNC_ENTITYDYING_GETNAME)(this, &result);
+			msvc_string result;
+			return reinterpret_cast<msvc_string& (__thiscall*)(EntityDying* self, msvc_string* result)>(getFuncAddr((int)Func::EntityDying::getName))(this, &result);
 			return result;
 		}
 		void update(World* world, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityDying* self, World* world, double dt)>(FUNC_ENTITYDYING_UPDATE)(this, world, dt);
+			return reinterpret_cast<void (__thiscall*)(EntityDying* self, World* world, double dt)>(getFuncAddr((int)Func::EntityDying::update))(this, world, dt);
 		}
 		void render(const World* world, const m4::Mat5& MV, bool glasses) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityDying* self, const World* world, const m4::Mat5& MV, bool glasses)>(FUNC_ENTITYDYING_RENDER)(this, world, MV, glasses);
+			return reinterpret_cast<void (__thiscall*)(EntityDying* self, const World* world, const m4::Mat5& MV, bool glasses)>(getFuncAddr((int)Func::EntityDying::render))(this, world, MV, glasses);
 		}
 		nlohmann::json getServerUpdateAttributes() override
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(EntityDying* self, nlohmann::json* result)>(FUNC_ENTITYDYING_GETSERVERUPDATEATTRIBUTES)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(EntityDying* self, nlohmann::json* result)>(getFuncAddr((int)Func::EntityDying::getServerUpdateAttributes))(this, &result);
 			return result;
 		}
 		void applyServerUpdate(const nlohmann::json& j, World* world) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityDying* self, const nlohmann::json& j, World* world)>(FUNC_ENTITYDYING_APPLYSERVERUPDATE)(this, j, world);
+			return reinterpret_cast<void (__thiscall*)(EntityDying* self, const nlohmann::json& j, World* world)>(getFuncAddr((int)Func::EntityDying::applyServerUpdate))(this, j, world);
 		}
 		glm::vec4 getPos() override
 		{
 			glm::vec4 result;
-			return reinterpret_cast<glm::vec4 (__thiscall*)(EntityDying* self, glm::vec4* result)>(FUNC_ENTITYDYING_GETPOS)(this, &result);
+			return reinterpret_cast<glm::vec4& (__thiscall*)(EntityDying* self, glm::vec4* result)>(getFuncAddr((int)Func::EntityDying::getPos))(this, &result);
 			return result;
 		}
 		void setPos(const glm::vec4& pos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityDying* self, const glm::vec4& pos)>(FUNC_ENTITYDYING_SETPOS)(this, pos);
+			return reinterpret_cast<void (__thiscall*)(EntityDying* self, const glm::vec4& pos)>(getFuncAddr((int)Func::EntityDying::setPos))(this, pos);
 		}
 		bool isBlockEntity() override
 		{
-			return reinterpret_cast<bool (__thiscall*)(EntityDying* self)>(FUNC_ENTITYDYING_ISBLOCKENTITY)(this);
+			return reinterpret_cast<bool (__thiscall*)(EntityDying* self)>(getFuncAddr((int)Func::EntityDying::isBlockEntity))(this);
 		}
 		bool isIntersectingRay(const Entity::Ray& ray) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(EntityDying* self, const Entity::Ray& ray)>(FUNC_ENTITYDYING_ISINTERSECTINGRAY)(this, ray);
+			return reinterpret_cast<bool (__thiscall*)(EntityDying* self, const Entity::Ray& ray)>(getFuncAddr((int)Func::EntityDying::isIntersectingRay))(this, ray);
 		}
 	};
 }
diff --git a/4dm.h/EntityItem.h b/4dm.h/EntityItem.h
index 0b3971c..df09917 100644
--- a/4dm.h/EntityItem.h
+++ b/4dm.h/EntityItem.h
@@ -20,61 +20,61 @@ namespace fdm
 
 		inline static std::unique_ptr<Entity> createWithItem(const std::unique_ptr<Item>& item, const glm::vec4& pos, const glm::vec4& vel) 
 		{
-			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)(const std::unique_ptr<Item>& item, const glm::vec4& pos, const glm::vec4& vel)>(FUNC_ENTITYITEM_CREATEWITHITEM)(item, pos, vel);
+			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)(const std::unique_ptr<Item>& item, const glm::vec4& pos, const glm::vec4& vel)>(getFuncAddr((int)Func::EntityItem::createWithItem))(item, pos, vel);
 		}
-		std::string getName() override
+		msvc_string getName() override
 		{
-			std::string result;
-			return reinterpret_cast<std::string (__thiscall*)(EntityItem* self, std::string* result)>(FUNC_ENTITYITEM_GETNAME)(this, &result);
+			msvc_string result;
+			return reinterpret_cast<msvc_string& (__thiscall*)(EntityItem* self, msvc_string* result)>(getFuncAddr((int)Func::EntityItem::getName))(this, &result);
 			return result;
 		}
 		void update(World* world, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityItem* self, World* world, double dt)>(FUNC_ENTITYITEM_UPDATE)(this, world, dt);
+			return reinterpret_cast<void (__thiscall*)(EntityItem* self, World* world, double dt)>(getFuncAddr((int)Func::EntityItem::update))(this, world, dt);
 		}
 		void render(const World* world, const m4::Mat5& MV, bool glasses) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityItem* self, const World* world, const m4::Mat5& MV, bool glasses)>(FUNC_ENTITYITEM_RENDER)(this, world, MV, glasses);
+			return reinterpret_cast<void (__thiscall*)(EntityItem* self, const World* world, const m4::Mat5& MV, bool glasses)>(getFuncAddr((int)Func::EntityItem::render))(this, world, MV, glasses);
 		}
 		nlohmann::json saveAttributes() override
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(EntityItem* self, nlohmann::json* result)>(FUNC_ENTITYITEM_SAVEATTRIBUTES)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(EntityItem* self, nlohmann::json* result)>(getFuncAddr((int)Func::EntityItem::saveAttributes))(this, &result);
 			return result;
 		}
 		void applyServerUpdate(const nlohmann::json& j, World* world) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityItem* self, const nlohmann::json& j, World* world)>(FUNC_ENTITYITEM_APPLYSERVERUPDATE)(this, j, world);
+			return reinterpret_cast<void (__thiscall*)(EntityItem* self, const nlohmann::json& j, World* world)>(getFuncAddr((int)Func::EntityItem::applyServerUpdate))(this, j, world);
 		}
 		glm::vec4 getPos() override
 		{
 			glm::vec4 result;
-			return reinterpret_cast<glm::vec4 (__thiscall*)(EntityItem* self, glm::vec4* result)>(FUNC_ENTITYITEM_GETPOS)(this, &result);
+			return reinterpret_cast<glm::vec4& (__thiscall*)(EntityItem* self, glm::vec4* result)>(getFuncAddr((int)Func::EntityItem::getPos))(this, &result);
 			return result;
 		}
 		void setPos(const glm::vec4& pos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityItem* self, const glm::vec4& pos)>(FUNC_ENTITYITEM_SETPOS)(this, pos);
+			return reinterpret_cast<void (__thiscall*)(EntityItem* self, const glm::vec4& pos)>(getFuncAddr((int)Func::EntityItem::setPos))(this, pos);
 		}
 		bool shouldSave() override
 		{
-			return reinterpret_cast<bool (__thiscall*)(EntityItem* self)>(FUNC_ENTITYITEM_SHOULDSAVE)(this);
+			return reinterpret_cast<bool (__thiscall*)(EntityItem* self)>(getFuncAddr((int)Func::EntityItem::shouldSave))(this);
 		}
 		bool isIntersectingRay(const Entity::Ray& ray) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(EntityItem* self, const Entity::Ray& ray)>(FUNC_ENTITYITEM_ISINTERSECTINGRAY)(this, ray);
+			return reinterpret_cast<bool (__thiscall*)(EntityItem* self, const Entity::Ray& ray)>(getFuncAddr((int)Func::EntityItem::isIntersectingRay))(this, ray);
 		}
 		uint32_t give(Inventory* inventory, int maxCount) 
 		{
-			return reinterpret_cast<uint32_t (__thiscall*)(EntityItem* self, Inventory* inventory, int maxCount)>(FUNC_ENTITYITEM_GIVE)(this, inventory, maxCount);
+			return reinterpret_cast<uint32_t (__thiscall*)(EntityItem* self, Inventory* inventory, int maxCount)>(getFuncAddr((int)Func::EntityItem::give))(this, inventory, maxCount);
 		}
 		void combineWithNearby(World* world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityItem* self, World* world)>(FUNC_ENTITYITEM_COMBINEWITHNEARBY)(this, world);
+			return reinterpret_cast<void (__thiscall*)(EntityItem* self, World* world)>(getFuncAddr((int)Func::EntityItem::combineWithNearby))(this, world);
 		}
 		inline static void collisionCallback(void* user, Hitbox* hitbox, World* world, const glm::ivec4& collisionBlock, int collisionComp, const glm::vec4& prevVel) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, Hitbox* hitbox, World* world, const glm::ivec4& collisionBlock, int collisionComp, const glm::vec4& prevVel)>(FUNC_ENTITYITEM_COLLISIONCALLBACK)(user, hitbox, world, collisionBlock, collisionComp, prevVel);
+			return reinterpret_cast<void (__fastcall*)(void* user, Hitbox* hitbox, World* world, const glm::ivec4& collisionBlock, int collisionComp, const glm::vec4& prevVel)>(getFuncAddr((int)Func::EntityItem::collisionCallback))(user, hitbox, world, collisionBlock, collisionComp, prevVel);
 		}
 	};
 }
diff --git a/4dm.h/EntityManager.h b/4dm.h/EntityManager.h
index 2d372ee..ad91df8 100644
--- a/4dm.h/EntityManager.h
+++ b/4dm.h/EntityManager.h
@@ -15,15 +15,15 @@ namespace fdm
 
 		std::unique_ptr<Entity>* extract(const uuid& id) 
 		{
-			return reinterpret_cast<std::unique_ptr<Entity>* (__thiscall*)(EntityManager* self, const uuid& id)>(FUNC_ENTITYMANAGER_EXTRACT)(this, id);
+			return reinterpret_cast<std::unique_ptr<Entity>* (__thiscall*)(EntityManager* self, const uuid& id)>(getFuncAddr((int)Func::EntityManager::extract))(this, id);
 		}
 		Entity* get(const uuid& id) 
 		{
-			return reinterpret_cast<Entity* (__thiscall*)(EntityManager* self, const uuid& id)>(FUNC_ENTITYMANAGER_GET)(this, id);
+			return reinterpret_cast<Entity* (__thiscall*)(EntityManager* self, const uuid& id)>(getFuncAddr((int)Func::EntityManager::get))(this, id);
 		}
 		Entity* getBlockEntity(const glm::ivec4& pos) 
 		{
-			return reinterpret_cast<Entity* (__thiscall*)(EntityManager* self, const glm::ivec4& pos)>(FUNC_ENTITYMANAGER_GETBLOCKENTITY)(this, pos);
+			return reinterpret_cast<Entity* (__thiscall*)(EntityManager* self, const glm::ivec4& pos)>(getFuncAddr((int)Func::EntityManager::getBlockEntity))(this, pos);
 		}
 	};
 }
diff --git a/4dm.h/EntityPlayer.h b/4dm.h/EntityPlayer.h
index a5c4cc1..e8e4550 100644
--- a/4dm.h/EntityPlayer.h
+++ b/4dm.h/EntityPlayer.h
@@ -34,7 +34,7 @@ namespace fdm
 		inline static int* wWidth = reinterpret_cast<int*>((base + 0x29B3F4));
 		inline static int* wHeight = reinterpret_cast<int*>((base + 0x29B3F0));
 		inline static FontRenderer* fr = reinterpret_cast<FontRenderer*>((base + 0x279700));
-		std::string displayName; // 0x710
+		msvc_string displayName; // 0x710
 		double lastMovementUpdateTime; // 0x730
 		bool justDamaged; // 0x738
 		PAD(0x3);
@@ -43,65 +43,65 @@ namespace fdm
 
 		inline static std::unique_ptr<Entity> createFromPlayer(Player* p) 
 		{
-			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)(Player* p)>(FUNC_ENTITYPLAYER_CREATEFROMPLAYER)(p);
+			return reinterpret_cast<std::unique_ptr<Entity> (__fastcall*)(Player* p)>(getFuncAddr((int)Func::EntityPlayer::createFromPlayer))(p);
 		}
 		EntityPlayer(nlohmann::json& j) 
 		{
-			reinterpret_cast<void(__thiscall*)(EntityPlayer* self, nlohmann::json& j)>(FUNC_ENTITYPLAYER_ENTITYPLAYER)(this, j);
+			reinterpret_cast<void(__thiscall*)(EntityPlayer* self, nlohmann::json& j)>(getFuncAddr((int)Func::EntityPlayer::EntityPlayer))(this, j);
 		}
-		std::string getName() override
+		msvc_string getName() override
 		{
-			std::string result;
-			return reinterpret_cast<std::string (__thiscall*)(EntityPlayer* self, std::string* result)>(FUNC_ENTITYPLAYER_GETNAME)(this, &result);
+			msvc_string result;
+			return reinterpret_cast<msvc_string& (__thiscall*)(EntityPlayer* self, msvc_string* result)>(getFuncAddr((int)Func::EntityPlayer::getName))(this, &result);
 			return result;
 		}
 		void update(World* world, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, World* world, double dt)>(FUNC_ENTITYPLAYER_UPDATE)(this, world, dt);
+			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, World* world, double dt)>(getFuncAddr((int)Func::EntityPlayer::update))(this, world, dt);
 		}
 		void render(const World* world, const m4::Mat5& MV, bool glasses) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, const World* world, const m4::Mat5& MV, bool glasses)>(FUNC_ENTITYPLAYER_RENDER)(this, world, MV, glasses);
+			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, const World* world, const m4::Mat5& MV, bool glasses)>(getFuncAddr((int)Func::EntityPlayer::render))(this, world, MV, glasses);
 		}
 		nlohmann::json saveAttributes() override
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(EntityPlayer* self, nlohmann::json* result)>(FUNC_ENTITYPLAYER_SAVEATTRIBUTES)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(EntityPlayer* self, nlohmann::json* result)>(getFuncAddr((int)Func::EntityPlayer::saveAttributes))(this, &result);
 			return result;
 		}
 		void applyServerUpdate(const nlohmann::json& j, World* world) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, const nlohmann::json& j, World* world)>(FUNC_ENTITYPLAYER_APPLYSERVERUPDATE)(this, j, world);
+			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, const nlohmann::json& j, World* world)>(getFuncAddr((int)Func::EntityPlayer::applyServerUpdate))(this, j, world);
 		}
 		glm::vec4 getPos() override
 		{
 			glm::vec4 result;
-			return reinterpret_cast<glm::vec4 (__thiscall*)(EntityPlayer* self, glm::vec4* result)>(FUNC_ENTITYPLAYER_GETPOS)(this, &result);
+			return reinterpret_cast<glm::vec4& (__thiscall*)(EntityPlayer* self, glm::vec4* result)>(getFuncAddr((int)Func::EntityPlayer::getPos))(this, &result);
 			return result;
 		}
 		void setPos(const glm::vec4& pos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, const glm::vec4& pos)>(FUNC_ENTITYPLAYER_SETPOS)(this, pos);
+			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, const glm::vec4& pos)>(getFuncAddr((int)Func::EntityPlayer::setPos))(this, pos);
 		}
 		bool isIntersectingRay(const Entity::Ray& ray) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(EntityPlayer* self, const Entity::Ray& ray)>(FUNC_ENTITYPLAYER_ISINTERSECTINGRAY)(this, ray);
+			return reinterpret_cast<bool (__thiscall*)(EntityPlayer* self, const Entity::Ray& ray)>(getFuncAddr((int)Func::EntityPlayer::isIntersectingRay))(this, ray);
 		}
 		void takeDamage(float damage, World* world) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, float damage, World* world)>(FUNC_ENTITYPLAYER_TAKEDAMAGE)(this, damage, world);
+			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, float damage, World* world)>(getFuncAddr((int)Func::EntityPlayer::takeDamage))(this, damage, world);
 		}
 		float deathTimer() override
 		{
-			return reinterpret_cast<float (__thiscall*)(EntityPlayer* self)>(FUNC_ENTITYPLAYER_DEATHTIMER)(this);
+			return reinterpret_cast<float (__thiscall*)(EntityPlayer* self)>(getFuncAddr((int)Func::EntityPlayer::deathTimer))(this);
 		}
 		void applyMovementUpdate(nlohmann::json& j) 
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, nlohmann::json& j)>(FUNC_ENTITYPLAYER_APPLYMOVEMENTUPDATE)(this, j);
+			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, nlohmann::json& j)>(getFuncAddr((int)Func::EntityPlayer::applyMovementUpdate))(this, j);
 		}
 		void collectItems(World* world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, World* world)>(FUNC_ENTITYPLAYER_COLLECTITEMS)(this, world);
+			return reinterpret_cast<void (__thiscall*)(EntityPlayer* self, World* world)>(getFuncAddr((int)Func::EntityPlayer::collectItems))(this, world);
 		}
 	};
 }
diff --git a/4dm.h/EntitySpider.h b/4dm.h/EntitySpider.h
index 4b61b65..bc81621 100644
--- a/4dm.h/EntitySpider.h
+++ b/4dm.h/EntitySpider.h
@@ -16,17 +16,17 @@ namespace fdm
 
 			~SpiderType() 
 			{
-				reinterpret_cast<void(__thiscall*)(EntitySpider::SpiderType* self)>(FUNC_ENTITYSPIDER_SPIDERTYPE_DESTR_SPIDERTYPE)(this);
+				reinterpret_cast<void(__thiscall*)(EntitySpider::SpiderType* self)>(getFuncAddr((int)Func::EntitySpider_Nested::SpiderType::destr_SpiderType))(this);
 			}
 		};
 		inline static const float hitboxRadius = 0.6f; 
 		inline static const float maxSpeed = 3.f; 
 		Hitbox hitbox; // 0x20
 		inline static const int NUM_TYPES = 5; 
-		inline static EntitySpider::SpiderType** spiderTypes = reinterpret_cast<EntitySpider::SpiderType**>((base + 0x279A30));
+		inline static EntitySpider::SpiderType* spiderTypes = reinterpret_cast<EntitySpider::SpiderType*>((base + 0x279A30));
 		int type; // 0x70
 		inline static const int NUM_LEGS = 32; 
-		inline static glm::vec4** legPositions = reinterpret_cast<glm::vec4**>((base + 0x29B400));
+		inline static glm::vec4* legPositions = reinterpret_cast<glm::vec4*>((base + 0x29B400));
 		inline static MeshRenderer* legRenderer = reinterpret_cast<MeshRenderer*>((base + 0x279D28));
 		glm::vec4 direction; // 0x74
 		float rotation; // 0x84
@@ -47,71 +47,71 @@ namespace fdm
 
 		bool isIntersectingRay(const Entity::Ray& ray) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(EntitySpider* self, const Entity::Ray& ray)>(FUNC_ENTITYSPIDER_ISINTERSECTINGRAY)(this, ray);
+			return reinterpret_cast<bool (__thiscall*)(EntitySpider* self, const Entity::Ray& ray)>(getFuncAddr((int)Func::EntitySpider::isIntersectingRay))(this, ray);
 		}
 		glm::vec4 getPos() override
 		{
 			glm::vec4 result;
-			return reinterpret_cast<glm::vec4 (__thiscall*)(EntitySpider* self, glm::vec4* result)>(FUNC_ENTITYSPIDER_GETPOS)(this, &result);
+			return reinterpret_cast<glm::vec4& (__thiscall*)(EntitySpider* self, glm::vec4* result)>(getFuncAddr((int)Func::EntitySpider::getPos))(this, &result);
 			return result;
 		}
 		void setPos(const glm::vec4& pos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, const glm::vec4& pos)>(FUNC_ENTITYSPIDER_SETPOS)(this, pos);
+			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, const glm::vec4& pos)>(getFuncAddr((int)Func::EntitySpider::setPos))(this, pos);
 		}
-		std::string getName() override
+		msvc_string getName() override
 		{
-			std::string result;
-			return reinterpret_cast<std::string (__thiscall*)(EntitySpider* self, std::string* result)>(FUNC_ENTITYSPIDER_GETNAME)(this, &result);
+			msvc_string result;
+			return reinterpret_cast<msvc_string& (__thiscall*)(EntitySpider* self, msvc_string* result)>(getFuncAddr((int)Func::EntitySpider::getName))(this, &result);
 			return result;
 		}
 		void update(World* world, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, World* world, double dt)>(FUNC_ENTITYSPIDER_UPDATE)(this, world, dt);
+			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, World* world, double dt)>(getFuncAddr((int)Func::EntitySpider::update))(this, world, dt);
 		}
 		void render(const World* world, const m4::Mat5& MV, bool glasses) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, const World* world, const m4::Mat5& MV, bool glasses)>(FUNC_ENTITYSPIDER_RENDER)(this, world, MV, glasses);
+			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, const World* world, const m4::Mat5& MV, bool glasses)>(getFuncAddr((int)Func::EntitySpider::render))(this, world, MV, glasses);
 		}
 		nlohmann::json saveAttributes() override
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(EntitySpider* self, nlohmann::json* result)>(FUNC_ENTITYSPIDER_SAVEATTRIBUTES)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(EntitySpider* self, nlohmann::json* result)>(getFuncAddr((int)Func::EntitySpider::saveAttributes))(this, &result);
 			return result;
 		}
 		nlohmann::json getServerUpdateAttributes() override
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(EntitySpider* self, nlohmann::json* result)>(FUNC_ENTITYSPIDER_GETSERVERUPDATEATTRIBUTES)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(EntitySpider* self, nlohmann::json* result)>(getFuncAddr((int)Func::EntitySpider::getServerUpdateAttributes))(this, &result);
 			return result;
 		}
 		void applyServerUpdate(const nlohmann::json& j, World* world) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, const nlohmann::json& j, World* world)>(FUNC_ENTITYSPIDER_APPLYSERVERUPDATE)(this, j, world);
+			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, const nlohmann::json& j, World* world)>(getFuncAddr((int)Func::EntitySpider::applyServerUpdate))(this, j, world);
 		}
 		void takeDamage(float damage, World* world) override
 		{
-			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, float damage, World* world)>(FUNC_ENTITYSPIDER_TAKEDAMAGE)(this, damage, world);
+			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, float damage, World* world)>(getFuncAddr((int)Func::EntitySpider::takeDamage))(this, damage, world);
 		}
 		void playHitSound() 
 		{
-			return reinterpret_cast<void (__thiscall*)(EntitySpider* self)>(FUNC_ENTITYSPIDER_PLAYHITSOUND)(this);
+			return reinterpret_cast<void (__thiscall*)(EntitySpider* self)>(getFuncAddr((int)Func::EntitySpider::playHitSound))(this);
 		}
 		void playDeathSound() 
 		{
-			return reinterpret_cast<void (__thiscall*)(EntitySpider* self)>(FUNC_ENTITYSPIDER_PLAYDEATHSOUND)(this);
+			return reinterpret_cast<void (__thiscall*)(EntitySpider* self)>(getFuncAddr((int)Func::EntitySpider::playDeathSound))(this);
 		}
 		inline static void collisionCallback(void* user, Hitbox* hitbox, World* world, const glm::ivec4& collisionBlock, int collisionComp) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, Hitbox* hitbox, World* world, const glm::ivec4& collisionBlock, int collisionComp)>(FUNC_ENTITYSPIDER_COLLISIONCALLBACK)(user, hitbox, world, collisionBlock, collisionComp);
+			return reinterpret_cast<void (__fastcall*)(void* user, Hitbox* hitbox, World* world, const glm::ivec4& collisionBlock, int collisionComp)>(getFuncAddr((int)Func::EntitySpider::collisionCallback))(user, hitbox, world, collisionBlock, collisionComp);
 		}
 		EntityPlayer* findPlayer(World* world) 
 		{
-			return reinterpret_cast<EntityPlayer* (__thiscall*)(EntitySpider* self, World* world)>(FUNC_ENTITYSPIDER_FINDPLAYER)(this, world);
+			return reinterpret_cast<EntityPlayer* (__thiscall*)(EntitySpider* self, World* world)>(getFuncAddr((int)Func::EntitySpider::findPlayer))(this, world);
 		}
 		void persuePlayer(World* world, double dt, EntityPlayer* player) 
 		{
-			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, World* world, double dt, EntityPlayer* player)>(FUNC_ENTITYSPIDER_PERSUEPLAYER)(this, world, dt, player);
+			return reinterpret_cast<void (__thiscall*)(EntitySpider* self, World* world, double dt, EntityPlayer* player)>(getFuncAddr((int)Func::EntitySpider::persuePlayer))(this, world, dt, player);
 		}
 	};
 }
diff --git a/4dm.h/FontRenderer.h b/4dm.h/FontRenderer.h
index 1646cad..20c401d 100644
--- a/4dm.h/FontRenderer.h
+++ b/4dm.h/FontRenderer.h
@@ -12,7 +12,7 @@ namespace fdm
 	class FontRenderer 
 	{
 	public:
-		std::string text; 
+		msvc_string text; 
 		glm::ivec2 charSize; // 0x20
 		int fontSize; // 0x28
 		glm::ivec2 pos; // 0x2C
@@ -20,34 +20,34 @@ namespace fdm
 		glm::mat4 model; // 0x44
 		bool centered; // 0x84
 		PAD(0x3);
-		Tex2D* texture; // 0x88
-		Shader* shader; // 0x90
-		uint32_t VAO; // 0x98
-		uint32_t charVBO; // 0x9C
+		const Tex2D* texture; // 0x88
+		const Shader* shader; // 0x90
+		unsigned int VAO; // 0x98
+		unsigned int charVBO; // 0x9C
 
 		FontRenderer(const Tex2D* texture, const Shader* shader) 
 		{
-			reinterpret_cast<void(__thiscall*)(FontRenderer* self, const Tex2D* texture, const Shader* shader)>(FUNC_FONTRENDERER_FONTRENDERER)(this, texture, shader);
+			reinterpret_cast<void(__thiscall*)(FontRenderer* self, const Tex2D* texture, const Shader* shader)>(getFuncAddr((int)Func::FontRenderer::FontRenderer))(this, texture, shader);
 		}
 		FontRenderer() 
 		{
-			reinterpret_cast<void(__thiscall*)(FontRenderer* self)>(FUNC_FONTRENDERER_FONTRENDERER_A)(this);
+			reinterpret_cast<void(__thiscall*)(FontRenderer* self)>(getFuncAddr((int)Func::FontRenderer::FontRendererA))(this);
 		}
-		void setText(const std::string& text) 
+		void setText(const msvc_string& text) 
 		{
-			return reinterpret_cast<void (__thiscall*)(FontRenderer* self, const std::string& text)>(FUNC_FONTRENDERER_SETTEXT)(this, text);
+			return reinterpret_cast<void (__thiscall*)(FontRenderer* self, const msvc_string& text)>(getFuncAddr((int)Func::FontRenderer::setText))(this, text);
 		}
 		void render() 
 		{
-			return reinterpret_cast<void (__thiscall*)(FontRenderer* self)>(FUNC_FONTRENDERER_RENDER)(this);
+			return reinterpret_cast<void (__thiscall*)(FontRenderer* self)>(getFuncAddr((int)Func::FontRenderer::render))(this);
 		}
 		void updateModel() 
 		{
-			return reinterpret_cast<void (__thiscall*)(FontRenderer* self)>(FUNC_FONTRENDERER_UPDATEMODEL)(this);
+			return reinterpret_cast<void (__thiscall*)(FontRenderer* self)>(getFuncAddr((int)Func::FontRenderer::updateModel))(this);
 		}
 		void move(FontRenderer& other) 
 		{
-			return reinterpret_cast<void (__thiscall*)(FontRenderer* self, FontRenderer& other)>(FUNC_FONTRENDERER_MOVE)(this, other);
+			return reinterpret_cast<void (__thiscall*)(FontRenderer* self, FontRenderer& other)>(getFuncAddr((int)Func::FontRenderer::move))(this, other);
 		}
 	};
 }
diff --git a/4dm.h/Framebuffer.h b/4dm.h/Framebuffer.h
index 1d4ba68..8cd41f0 100644
--- a/4dm.h/Framebuffer.h
+++ b/4dm.h/Framebuffer.h
@@ -15,19 +15,36 @@ namespace fdm
 
 		~Framebuffer() 
 		{
-			reinterpret_cast<void(__thiscall*)(Framebuffer* self)>(FUNC_FRAMEBUFFER_DESTR_FRAMEBUFFER)(this);
+			reinterpret_cast<void(__thiscall*)(Framebuffer* self)>(getFuncAddr((int)Func::Framebuffer::destr_Framebuffer))(this);
+		}
+		const Shader* getShader()
+		{
+			return texRenderer.shader;
+		}
+		void setShader(const Shader* shader)
+		{
+			texRenderer.shader = shader;
 		}
 		void render() 
 		{
-			return reinterpret_cast<void (__thiscall*)(Framebuffer* self)>(FUNC_FRAMEBUFFER_RENDER)(this);
+			const Shader* s = getShader();
+			s->use();
+			glActiveTexture(GL_TEXTURE1);
+			glBindTexture(GL_TEXTURE_2D, depthTex2D.ID);
+			glUniform1i(glGetUniformLocation(s->id(), "depth"), 1);
+			glActiveTexture(GL_TEXTURE0);
+			glBindTexture(GL_TEXTURE_2D, tex2D.ID);
+			glUniform1i(glGetUniformLocation(s->id(), "texture"), 0);
+
+			texRenderer.render();
 		}
 		void init(GLsizei width, GLsizei height, bool alphaChannel) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Framebuffer* self, GLsizei width, GLsizei height, bool alphaChannel)>(FUNC_FRAMEBUFFER_INIT)(this, width, height, alphaChannel);
+			return reinterpret_cast<void (__thiscall*)(Framebuffer* self, GLsizei width, GLsizei height, bool alphaChannel)>(getFuncAddr((int)Func::Framebuffer::init))(this, width, height, alphaChannel);
 		}
 		void cleanup() 
 		{
-			return reinterpret_cast<void (__thiscall*)(Framebuffer* self)>(FUNC_FRAMEBUFFER_CLEANUP)(this);
+			return reinterpret_cast<void (__thiscall*)(Framebuffer* self)>(getFuncAddr((int)Func::Framebuffer::cleanup))(this);
 		}
 	};
 }
diff --git a/4dm.h/GUI/Alignment.h b/4dm.h/GUI/Alignment.h
index eddb9d6..9b79614 100644
--- a/4dm.h/GUI/Alignment.h
+++ b/4dm.h/GUI/Alignment.h
@@ -19,4 +19,4 @@ namespace fdm
 			ALIGN_CENTER_Y = 2
 		};
 	}
-}
\ No newline at end of file
+}
diff --git a/4dm.h/GUI/Button.h b/4dm.h/GUI/Button.h
index 879f5cd..ebb09c6 100644
--- a/4dm.h/GUI/Button.h
+++ b/4dm.h/GUI/Button.h
@@ -8,36 +8,40 @@ namespace fdm::gui
 	class Button : public gui::Element
 	{
 	public:
-		std::string text; // 0x8
+		msvc_string text = ""; // 0x8
 		bool clickable = true; // 0x28
 		bool mouseDown; // 0x29
 		bool selected; // 0x2A
 		PAD(0x1);
-		int xOffset; // 0x2C
-		int yOffset; // 0x30
-		gui::AlignmentX xAlign; // 0x34
-		gui::AlignmentY yAlign; // 0x38
-		int width; // 0x3C
-		int height; // 0x40
+		int xOffset = 0; // 0x2C
+		int yOffset = 0; // 0x30
+		gui::AlignmentX xAlign = ALIGN_LEFT; // 0x34
+		gui::AlignmentY yAlign = ALIGN_TOP; // 0x38
+		int width = 100; // 0x3C
+		int height = 50; // 0x40
 		PAD(0x4);
 		void* user; // 0x48
 		ButtonCallback callback = NULL; // 0x50
 
 		~Button()
 		{
-			reinterpret_cast<void(__thiscall*)(gui::Button * self)>(FUNC_GUI_BUTTON_DESTR_BUTTON)(this);
+			reinterpret_cast<void(__thiscall*)(gui::Button * self)>(getFuncAddr((int)Func::gui_Nested::Button::destr_Button))(this);
+		}
+		void setText(const msvc_string& text)
+		{
+			this->text = text;
 		}
 		void render(gui::Window* w) override
 		{
-			return reinterpret_cast<void(__thiscall*)(gui::Button * self, gui::Window * w)>(FUNC_GUI_BUTTON_RENDER)(this, w);
+			return reinterpret_cast<void(__thiscall*)(gui::Button * self, gui::Window * w)>(getFuncAddr((int)Func::gui_Nested::Button::render))(this, w);
 		}
-		bool mouseButtonInput(gui::Window* w, int button, int action, int mods) override
+		bool mouseButtonInput(const gui::Window* w, int button, int action, int mods) override
 		{
-			return reinterpret_cast<bool(__thiscall*)(gui::Button * self, gui::Window * w, int button, int action, int mods)>(FUNC_GUI_BUTTON_MOUSEBUTTONINPUT)(this, w, button, action, mods);
+			return reinterpret_cast<bool(__thiscall*)(gui::Button * self, const gui::Window * w, int button, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::Button::mouseButtonInput))(this, w, button, action, mods);
 		}
-		bool keyInput(gui::Window* w, int key, int scancode, int action, int mods) override
+		bool keyInput(const gui::Window* w, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<bool(__thiscall*)(gui::Button * self, gui::Window * w, int key, int scancode, int action, int mods)>(FUNC_GUI_BUTTON_KEYINPUT)(this, w, key, scancode, action, mods);
+			return reinterpret_cast<bool(__thiscall*)(gui::Button * self, const gui::Window * w, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::Button::keyInput))(this, w, key, scancode, action, mods);
 		}
 		void offsetX(int offset) override
 		{
@@ -57,23 +61,27 @@ namespace fdm::gui
 		}
 		bool enabled() override
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::Button* self)>(FUNC_GUI_BUTTON_ENABLED)(this);
+			return reinterpret_cast<bool (__thiscall*)(gui::Button* self)>(getFuncAddr((int)Func::gui_Nested::Button::enabled))(this);
 		}
 		void select() override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Button* self)>(FUNC_GUI_BUTTON_SELECT)(this);
+			selected = true;
+		}
+		void deselect() override
+		{
+			selected = false;
 		}
-		void getPos(gui::Window* w, int* x, int* y) override
+		void getPos(const gui::Window* w, int* x, int* y) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Button* self, gui::Window* w, int* x, int* y)>(FUNC_GUI_BUTTON_GETPOS)(this, w, x, y);
+			return reinterpret_cast<void (__thiscall*)(const gui::Button* self, const gui::Window* w, int* x, int* y)>(getFuncAddr((int)Func::gui_Nested::Button::getPos))(this, w, x, y);
 		}
-		void getSize(gui::Window* w, int* width, int* height) override
+		void getSize(const gui::Window* w, int* width, int* height) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Button* self, gui::Window* w, int* width, int* height)>(FUNC_GUI_BUTTON_GETSIZE)(this, w, width, height);
+			return reinterpret_cast<void (__thiscall*)(const gui::Button* self, const gui::Window* w, int* width, int* height)>(getFuncAddr((int)Func::gui_Nested::Button::getSize))(this, w, width, height);
 		}
-		bool touchingMouse(gui::Window* w) 
+		bool touchingMouse(const gui::Window* w)
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::Button* self, gui::Window* w)>(FUNC_GUI_BUTTON_TOUCHINGMOUSE)(this, w);
+			return reinterpret_cast<bool (__thiscall*)(gui::Button* self, const gui::Window* w)>(getFuncAddr((int)Func::gui_Nested::Button::touchingMouse))(this, w);
 		}
 	};
 }
diff --git a/4dm.h/GUI/CheckBox.h b/4dm.h/GUI/CheckBox.h
index a99cdfa..7737945 100644
--- a/4dm.h/GUI/CheckBox.h
+++ b/4dm.h/GUI/CheckBox.h
@@ -8,15 +8,15 @@ namespace fdm::gui
 	class CheckBox : public gui::Element 
 	{
 	public:
-		std::string text; // 0x8
+		msvc_string text = ""; // 0x8
 		bool clickable = true; // 0x28
 		bool mouseDown; // 0x29
 		bool selected; // 0x2A
 		PAD(0x1);
-		int xOffset; // 0x2C
-		int yOffset; // 0x30
-		gui::AlignmentX xAlign; // 0x34
-		gui::AlignmentY yAlign; // 0x38
+		int xOffset = 0; // 0x2C
+		int yOffset = 0; // 0x30
+		gui::AlignmentX xAlign = ALIGN_LEFT; // 0x34
+		gui::AlignmentY yAlign = ALIGN_TOP; // 0x38
 		inline static const int width = 20; 
 		inline static const int height = 20; 
 		PAD(0x4);
@@ -24,6 +24,10 @@ namespace fdm::gui
 		CheckBoxCallback callback = NULL; // 0x48
 		bool checked; // 0x50
 
+		void setText(const msvc_string& text)
+		{
+			this->text = text;
+		}
 		void offsetX(int offset) override
 		{
 			this->xOffset = offset;
@@ -42,27 +46,35 @@ namespace fdm::gui
 		}
 		void render(gui::Window* w) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::CheckBox* self, gui::Window* w)>(FUNC_GUI_CHECKBOX_RENDER)(this, w);
+			return reinterpret_cast<void (__thiscall*)(gui::CheckBox* self, gui::Window* w)>(getFuncAddr((int)Func::gui_Nested::CheckBox::render))(this, w);
+		}
+		bool mouseButtonInput(const gui::Window* w, int button, int action, int mods) override
+		{
+			return reinterpret_cast<bool (__thiscall*)(gui::CheckBox* self, const gui::Window* w, int button, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::CheckBox::mouseButtonInput))(this, w, button, action, mods);
+		}
+		bool keyInput(const gui::Window* w, int key, int scancode, int action, int mods) override
+		{
+			return reinterpret_cast<bool (__thiscall*)(gui::CheckBox* self, const gui::Window* w, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::CheckBox::keyInput))(this, w, key, scancode, action, mods);
 		}
-		bool mouseButtonInput(gui::Window* w, int button, int action, int mods) override
+		void getPos(const gui::Window* w, int* x, int* y) const override
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::CheckBox* self, gui::Window* w, int button, int action, int mods)>(FUNC_GUI_CHECKBOX_MOUSEBUTTONINPUT)(this, w, button, action, mods);
+			return reinterpret_cast<void (__thiscall*)(const gui::CheckBox* self, const gui::Window* w, int* x, int* y)>(getFuncAddr((int)Func::gui_Nested::CheckBox::getPos))(this, w, x, y);
 		}
-		bool keyInput(gui::Window* w, int key, int scancode, int action, int mods) override
+		void getSize(const gui::Window* w, int* width, int* height) const override
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::CheckBox* self, gui::Window* w, int key, int scancode, int action, int mods)>(FUNC_GUI_CHECKBOX_KEYINPUT)(this, w, key, scancode, action, mods);
+			return reinterpret_cast<void (__thiscall*)(const gui::CheckBox* self, const gui::Window* w, int* width, int* height)>(getFuncAddr((int)Func::gui_Nested::CheckBox::getSize))(this, w, width, height);
 		}
-		void getPos(gui::Window* w, int* x, int* y) override
+		void select() override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::CheckBox* self, gui::Window* w, int* x, int* y)>(FUNC_GUI_CHECKBOX_GETPOS)(this, w, x, y);
+			selected = true;
 		}
-		void getSize(gui::Window* w, int* width, int* height) override
+		void deselect() override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::CheckBox* self, gui::Window* w, int* width, int* height)>(FUNC_GUI_CHECKBOX_GETSIZE)(this, w, width, height);
+			selected = false;
 		}
 		bool touchingMouse(gui::Window* w) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::CheckBox* self, gui::Window* w)>(FUNC_GUI_CHECKBOX_TOUCHINGMOUSE)(this, w);
+			return reinterpret_cast<bool (__thiscall*)(gui::CheckBox* self, gui::Window* w)>(getFuncAddr((int)Func::gui_Nested::CheckBox::touchingMouse))(this, w);
 		}
 	};
 }
diff --git a/4dm.h/GUI/ContentBox.h b/4dm.h/GUI/ContentBox.h
index 60d591b..709ff32 100644
--- a/4dm.h/GUI/ContentBox.h
+++ b/4dm.h/GUI/ContentBox.h
@@ -18,78 +18,129 @@ namespace fdm
 		class ContentBox : public gui::Element, public gui::Window, public gui::ElemContainer
 		{
 		public:
-			gui::Window* parent; // 0x18
-			std::vector<gui::Element*> elements; // 0x20
-			int selectedElemIndex; // 0x38
-			bool active; // 0x3C
+			gui::Window* parent = nullptr; // 0x18
+			std::vector<gui::Element*> elements{}; // 0x20
+			int selectedElemIndex = -1; // 0x38
+			bool active = false; // 0x3C
 			PAD(0x3);
-			uint32_t width; // 0x40
-			uint32_t height; // 0x44
-			int xOffset; // 0x48
-			int yOffset; // 0x4C
-			gui::AlignmentX xAlign; // 0x50
-			gui::AlignmentY yAlign; // 0x54
-			int xScroll; // 0x58
-			int yScroll; // 0x5C
-			int scrollW; // 0x60
-			int scrollH; // 0x64
+			uint32_t width = 100; // 0x40
+			uint32_t height = 100; // 0x44
+			int xOffset = 0; // 0x48
+			int yOffset = 0; // 0x4C
+			gui::AlignmentX xAlign = AlignmentX::ALIGN_LEFT; // 0x50
+			gui::AlignmentY yAlign = AlignmentY::ALIGN_TOP; // 0x54
+			int xScroll = 0; // 0x58
+			int yScroll = 0; // 0x5C
+			int scrollW = 0; // 0x60
+			int scrollH = 0; // 0x64
 			inline static const int scrollbarWidth = 15;
-			bool scrollingX; // 0x68
-			bool scrollingY; // 0x69
+			bool scrollingX = false; // 0x68
+			bool scrollingY = false; // 0x69
 			PAD(0x2);
-			int scrollbarClickPos; // 0x6C
-			int scrollStep; // 0x70
-			bool viewUpdateFlag; // 0x74
+			int scrollbarClickPos = 0; // 0x6C
+			int scrollStep = 20; // 0x70
+			bool viewUpdateFlag = false; // 0x74
 			PAD(0x3);
-			int currentCursorType; // 0x78
+			int currentCursorType = GLFW_ARROW_CURSOR; // 0x78
 
+			void changeSelection(int index)
+			{
+				// don't deselect if it's already selected
+				if (selectedElemIndex != -1 && selectedElemIndex != index)
+				{
+					elements[selectedElemIndex]->deselect();
+				}
+				selectedElemIndex = index;
+				if (index != -1)
+				{
+					elements[index]->select();
+				}
+			}
 			~ContentBox()
 			{
-				reinterpret_cast<void(__thiscall*)(gui::ContentBox * self)>(FUNC_GUI_CONTENTBOX_DESTR_CONTENTBOX)(this);
+				if (!this->elements.empty())
+				{
+					for (auto it = this->elements.begin(); it != this->elements.end(); ++it)
+					{
+						delete* it;
+					}
+
+					this->elements.clear();
+				}
 			}
-			QuadRenderer* getQuadRenderer() override
+			QuadRenderer* getQuadRenderer() const override
 			{
-				return reinterpret_cast<QuadRenderer * (__thiscall*)(gui::ContentBox * self)>(FUNC_GUI_CONTENTBOX_GETQUADRENDERER)(this);
+				return parent->getQuadRenderer();
 			}
-			FontRenderer* getFont() override
+			FontRenderer* getFont() const override
 			{
-				return reinterpret_cast<FontRenderer * (__thiscall*)(gui::ContentBox * self)>(FUNC_GUI_CONTENTBOX_GETFONT)(this);
+				return parent->getFont();
 			}
-			GLFWwindow* getGLFWwindow() override
+			GLFWwindow* getGLFWwindow() const override
 			{
-				return reinterpret_cast<GLFWwindow * (__thiscall*)(gui::ContentBox * self)>(FUNC_GUI_CONTENTBOX_GETGLFWWINDOW)(this);
+				return parent->getGLFWwindow();
 			}
-			void getCursorPos(int* x, int* y) override
+			void getCursorPos(int* x, int* y) const override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self, int* x, int* y)>(FUNC_GUI_CONTENTBOX_GETCURSORPOS)(this, x, y);
+				int startX, startY;
+				getPos(parent, &startX, &startY);
+				parent->getCursorPos(x, y);
+				*x -= xScroll + startX;
+				*y -= yScroll + startY;
 			}
-			void getSize(int* x, int* y) override
+			void getSize(int* x, int* y) const override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self, int* x, int* y)>(FUNC_GUI_CONTENTBOX_GETSIZE)(this, x, y);
+				*x = width;
+				*y = height;
 			}
 			void changeViewport(const glm::ivec4& pos, const glm::ivec2& scroll) override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self, const glm::ivec4 & pos, const glm::ivec2 & scroll)>(FUNC_GUI_CONTENTBOX_CHANGEVIEWPORT)(this, pos, scroll);
+				// update the viewport relative to this container
+				int xStart, yStart;
+				getPos(parent, &xStart, &yStart);
+
+				glm::ivec4 adjustedPos;
+
+				adjustedPos.x = glm::max(0, glm::min((int)width, pos.x + xScroll));
+				adjustedPos.y = glm::max(0, glm::min((int)height, pos.y + yScroll));
+
+				adjustedPos.z = glm::max(0, glm::min((int)width, pos.x + pos.z + xScroll));
+				adjustedPos.z -= adjustedPos.x;
+
+				adjustedPos.w = glm::max(0, glm::min((int)height, pos.y + pos.w + yScroll));
+				adjustedPos.w -= adjustedPos.y;
+
+				glm::ivec2 adjustedScroll{ scroll.x + pos.x + xScroll - adjustedPos.x, scroll.y + pos.y + yScroll - adjustedPos.y };
+
+				adjustedPos.x += xStart;
+				adjustedPos.y += yStart;
+
+				parent->changeViewport(
+					adjustedPos,
+					adjustedScroll
+				);
+				viewUpdateFlag = true;
 			}
-			void getPos(gui::Window* w, int* x, int* y) override
+			void getPos(const gui::Window* w, int* x, int* y) const override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self, gui::Window * w, int* x, int* y)>(FUNC_GUI_CONTENTBOX_GETPOS)(this, w, x, y);
+				return reinterpret_cast<void(__thiscall*)(const gui::ContentBox * self, const gui::Window * w, int* x, int* y)>(getFuncAddr((int)Func::gui_Nested::ContentBox::getPos))(this, w, x, y);
 			}
-			void getSize(gui::Window* w, int* width, int* height) override
+			void getSize(const gui::Window* w, int* width, int* height) const override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self, gui::Window * w, int* width, int* height)>(FUNC_GUI_CONTENTBOX_GETSIZE_A)(this, w, width, height);
+				*width = this->width;
+				*height = this->height;
 			}
 			bool touchingMouse()
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self)>(FUNC_GUI_CONTENTBOX_TOUCHINGMOUSE)(this);
+				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self)>(getFuncAddr((int)Func::gui_Nested::ContentBox::touchingMouse))(this);
 			}
 			void resetViewport(bool applyScroll)
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self, bool applyScroll)>(FUNC_GUI_CONTENTBOX_RESETVIEWPORT)(this, applyScroll);
+				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self, bool applyScroll)>(getFuncAddr((int)Func::gui_Nested::ContentBox::resetViewport))(this, applyScroll);
 			}
 			void render(gui::Window* w) override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self, gui::Window * w)>(FUNC_GUI_CONTENTBOX_RENDER)(this, w);
+				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self, gui::Window * w)>(getFuncAddr((int)Func::gui_Nested::ContentBox::render))(this, w);
 			}
 			void offsetX(int offset) override
 			{
@@ -107,49 +158,120 @@ namespace fdm
 			{
 				this->yAlign = a;
 			}
-			bool mouseInput(gui::Window* w, double xpos, double ypos) override
+			bool mouseInput(const gui::Window* w, double xpos, double ypos) override
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self, gui::Window * w, double xpos, double ypos)>(FUNC_GUI_CONTENTBOX_MOUSEINPUT)(this, w, xpos, ypos);
+				int mx, my;
+				getCursorPos(&mx, &my);
+
+				// i dont even fucking know. i tried to decompile it and get it to work. this is what i ended up with
+				if (scrollingX && scrollW >= 0)
+				{
+					int off = (width - 2);
+					if (scrollH != 0)
+						off -= 16;
+
+					int t = (int)((float)off - (float)(((float)width / ((float)width + (float)abs(scrollW))) * (float)off));
+					int scroll = (mx - scrollbarClickPos);
+
+					scroll = (int)(((float)scroll / (float)t) * (float)-scrollW);
+
+					xScroll = std::clamp(scroll, -scrollW, 0);
+					return false;
+				}
+				else if (scrollingY && scrollH >= 0)
+				{
+					int off = (height - 2);
+					if (scrollW != 0)
+						off -= 16;
+
+					int t = (int)((float)off - (float)(((float)height / ((float)height + (float)abs(scrollH))) * (float)off));
+					int scroll = (my - scrollbarClickPos);
+
+					scroll = (int)(((float)scroll / (float)t) * (float)-scrollH);
+
+					yScroll = std::clamp(scroll, -scrollH, 0);
+					return false;
+				}
+				else
+				{
+					if (!elements.empty())
+					{
+						for (auto& el : elements)
+						{
+							bool r = el->mouseInput(this, xpos, ypos);
+							if (r)
+							{
+								this->currentCursorType = el->getCursorType();
+								return true;
+							}
+						}
+					}
+				}
+
+				return false;
+				//return reinterpret_cast<bool(__thiscall*)(const gui::ContentBox * self, const gui::Window * w, double xpos, double ypos)>(getFuncAddr((int)Func::gui_Nested::ContentBox::mouseInput))(this, w, xpos, ypos);
 			}
-			bool scrollInput(gui::Window* w, double xoffset, double yoffset) override
+			bool scrollInput(const gui::Window* w, double xoffset, double yoffset) override
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self, gui::Window * w, double xoffset, double yoffset)>(FUNC_GUI_CONTENTBOX_SCROLLINPUT)(this, w, xoffset, yoffset);
+				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self, const gui::Window * w, double xoffset, double yoffset)>(getFuncAddr((int)Func::gui_Nested::ContentBox::scrollInput))(this, w, xoffset, yoffset);
 			}
-			bool mouseButtonInput(gui::Window* w, int button, int action, int mods) override
+			bool mouseButtonInput(const gui::Window* w, int button, int action, int mods) override
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self, gui::Window * w, int button, int action, int mods)>(FUNC_GUI_CONTENTBOX_MOUSEBUTTONINPUT)(this, w, button, action, mods);
+				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self, const gui::Window * w, int button, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::ContentBox::mouseButtonInput))(this, w, button, action, mods);
 			}
-			bool keyInput(gui::Window* w, int key, int scancode, int action, int mods) override
+			bool keyInput(const gui::Window* w, int key, int scancode, int action, int mods) override
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self, gui::Window * w, int key, int scancode, int action, int mods)>(FUNC_GUI_CONTENTBOX_KEYINPUT)(this, w, key, scancode, action, mods);
+				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self, const gui::Window * w, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::ContentBox::keyInput))(this, w, key, scancode, action, mods);
 			}
 			void select() override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self)>(FUNC_GUI_CONTENTBOX_SELECT)(this);
+				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self)>(getFuncAddr((int)Func::gui_Nested::ContentBox::select))(this);
 			}
 			void deselect() override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self)>(FUNC_GUI_CONTENTBOX_DESELECT)(this);
+				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self)>(getFuncAddr((int)Func::gui_Nested::ContentBox::deselect))(this);
 			}
 			void addElement(gui::Element* e) override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self, gui::Element * e)>(FUNC_GUI_CONTENTBOX_ADDELEMENT)(this, e);
+				elements.push_back(e);
 			}
 			bool removeElement(gui::Element* e) override
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self, gui::Element * e)>(FUNC_GUI_CONTENTBOX_REMOVEELEMENT)(this, e);
+				return elements.erase(std::remove(elements.begin(), elements.end(), e), elements.end()) != elements.end();
 			}
 			bool selectElement(gui::Element* e) override
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self, gui::Element * e)>(FUNC_GUI_CONTENTBOX_SELECTELEMENT)(this, e);
+				if (e == nullptr)
+				{
+					changeSelection(-1);
+					return false;
+				}
+
+				for (int i = 0; i < elements.size(); ++i)
+				{
+					if (elements[i] == e)
+					{
+						changeSelection(i);
+						return true;
+					}
+				}
+
+				return false;
 			}
 			void clear() override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::ContentBox * self)>(FUNC_GUI_CONTENTBOX_CLEAR)(this);
+				changeSelection(-1);
+				elements.clear();
 			}
 			bool empty() override
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::ContentBox * self)>(FUNC_GUI_CONTENTBOX_EMPTY)(this);
+				return elements.empty();
+			}
+			bool charInput(const gui::Window* w, uint32_t codepoint) override
+			{
+				if (!empty() && selectedElemIndex != -1)
+					return elements[selectedElemIndex]->charInput(this, codepoint);
+				return false;
 			}
 		};
 	}
diff --git a/4dm.h/GUI/Element.h b/4dm.h/GUI/Element.h
index 4314e43..cb7bd89 100644
--- a/4dm.h/GUI/Element.h
+++ b/4dm.h/GUI/Element.h
@@ -17,22 +17,22 @@ namespace fdm::gui
 		virtual void alignY(gui::AlignmentY alignment) { }
 		virtual void offsetX(int offset) { }
 		virtual void offsetY(int offset) { }
-		virtual void getPos(gui::Window* w, int* x, int* y) { }
-		virtual void getSize(gui::Window* w, int* width, int* height) { }
-		virtual bool mouseInput(gui::Window* w, double xpos, double ypos){ return false; }
-		virtual bool scrollInput(gui::Window* w, double xoff, double yoff){ return false; }
-		virtual bool mouseButtonInput(gui::Window* w, int button, int action, int mods){ return false; }
-		virtual bool keyInput(gui::Window* w, int, int, int, int){ return false; }
-		virtual bool charInput(gui::Window* w, uint32_t codepoint){ return false; }
+		virtual void getPos(const gui::Window* w, int* x, int* y) const { }
+		virtual void getSize(const gui::Window* w, int* width, int* height) const { }
+		virtual bool mouseInput(const gui::Window* w, double xpos, double ypos) { return false; }
+		virtual bool scrollInput(const gui::Window* w, double xoff, double yoff) { return false; }
+		virtual bool mouseButtonInput(const gui::Window* w, int button, int action, int mods) { return false; }
+		virtual bool keyInput(const gui::Window* w, int, int, int, int) { return false; }
+		virtual bool charInput(const gui::Window* w, uint32_t codepoint) { return false; }
 		virtual bool enabled()
 		{
-			return reinterpret_cast<bool(__thiscall*)(gui::Element * self)>(FUNC_GUI_ELEMENT_ENABLED)(this);
+			return reinterpret_cast<bool(__thiscall*)(gui::Element * self)>(getFuncAddr((int)Func::gui_Nested::Element::enabled))(this);
 		}
 		virtual void select() { }
 		virtual void deselect() { }
 		virtual int getCursorType()
 		{
-			return reinterpret_cast<int(__thiscall*)(gui::Element * self)>(FUNC_GUI_ELEMENT_GETCURSORTYPE)(this);
+			return reinterpret_cast<int(__thiscall*)(gui::Element * self)>(getFuncAddr((int)Func::gui_Nested::Element::getCursorType))(this);
 		}
 	};
 }
diff --git a/4dm.h/GUI/Image.h b/4dm.h/GUI/Image.h
index 740bd12..f671f45 100644
--- a/4dm.h/GUI/Image.h
+++ b/4dm.h/GUI/Image.h
@@ -8,12 +8,43 @@ namespace fdm::gui
 	{
 	public:
 		TexRenderer* tr; // 0x8
-		int xOffset; // 0x10
-		int yOffset; // 0x14
-		gui::AlignmentX xAlign; // 0x18
-		gui::AlignmentY yAlign; // 0x1C
-		int width; // 0x20
-		int height; // 0x24
+		int xOffset = 0; // 0x10
+		int yOffset = 0; // 0x14
+		gui::AlignmentX xAlign = ALIGN_LEFT; // 0x18
+		gui::AlignmentY yAlign = ALIGN_TOP; // 0x1C
+		int width = 0; // 0x20
+		int height = 0; // 0x24
+
+		Image() {}
+
+		Image(const msvc_string& imgPath, bool modFolder = false)
+		{
+			const Tex2D* tex = ResourceManager::get(imgPath, modFolder);
+			if (tex == nullptr)
+				return;
+
+			tr = new TexRenderer();
+			tr->texture = tex;
+			tr->shader = ShaderManager::get("tex2DShader");
+			tr->init();
+
+			width = tr->texture->width;
+			height = tr->texture->height;
+		}
+		Image(const msvc_string& imgPath, const msvc_string& folderOverride)
+		{
+			const Tex2D* tex = ResourceManager::get(imgPath, folderOverride);
+			if (tex == nullptr)
+				return;
+
+			tr = new TexRenderer();
+			tr->texture = tex;
+			tr->shader = ShaderManager::get("tex2DShader");
+			tr->init();
+
+			width = tr->texture->width;
+			height = tr->texture->height;
+		}
 
 		void offsetX(int offset) override
 		{
@@ -33,15 +64,19 @@ namespace fdm::gui
 		}
 		void render(gui::Window* w) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Image* self, gui::Window* w)>(FUNC_GUI_IMAGE_RENDER)(this, w);
+			return reinterpret_cast<void (__thiscall*)(gui::Image* self, gui::Window* w)>(getFuncAddr((int)Func::gui_Nested::Image::render))(this, w);
+		}
+		void getPos(const gui::Window* w, int* x, int* y) const override
+		{
+			return reinterpret_cast<void (__thiscall*)(const gui::Image* self, const gui::Window* w, int* x, int* y)>(getFuncAddr((int)Func::gui_Nested::Image::getPos))(this, w, x, y);
 		}
-		void getPos(gui::Window* w, int* x, int* y) override
+		void getSize(const gui::Window* w, int* width, int* height) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Image* self, gui::Window* w, int* x, int* y)>(FUNC_GUI_IMAGE_GETPOS)(this, w, x, y);
+			return reinterpret_cast<void (__thiscall*)(const gui::Image* self, const gui::Window* w, int* width, int* height)>(getFuncAddr((int)Func::gui_Nested::Image::getSize))(this, w, width, height);
 		}
-		void getSize(gui::Window* w, int* width, int* height) override
+		bool enabled() override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Image* self, gui::Window* w, int* width, int* height)>(FUNC_GUI_IMAGE_GETSIZE)(this, w, width, height);
+			return false;
 		}
 	};
 }
diff --git a/4dm.h/GUI/Interface.h b/4dm.h/GUI/Interface.h
index a12cde6..f66d5eb 100644
--- a/4dm.h/GUI/Interface.h
+++ b/4dm.h/GUI/Interface.h
@@ -18,7 +18,7 @@ namespace fdm
 		class Interface : public gui::Window, public gui::ElemContainer
 		{
 		public:
-			std::vector<gui::Element*> elements; // 0x10
+			std::vector<gui::Element*> elements{}; // 0x10
 			int selectedElemIndex; // 0x28
 			PAD(0x4);
 			QuadRenderer* qr; // 0x30
@@ -28,80 +28,159 @@ namespace fdm
 			void* viewportUser; // 0x50
 			bool viewUpdateFlag; // 0x58
 			PAD(0x3);
-			int currentCursorType; // 0x5C
+			int currentCursorType = GLFW_ARROW_CURSOR; // 0x5C
 			GLFWcursor* cursor; // 0x60
-			Interface() {}
-			Interface(GLFWwindow* window)
-			{
-				reinterpret_cast<void(__thiscall*)(gui::Interface * self, GLFWwindow * window)>(FUNC_GUI_INTERFACE_INTERFACE)(this, window);
+			void changeSelection(int index)
+			{
+				// don't deselect if it's already selected
+				if (selectedElemIndex != -1 && selectedElemIndex != index)
+				{
+					elements[selectedElemIndex]->deselect();
+				}
+				selectedElemIndex = index;
+				if (index != -1)
+				{
+					elements[index]->select();
+				}
+			}
+			Interface(GLFWwindow* window = nullptr)
+			{
+				selectedElemIndex = -1;
+				currentCursorType = GLFW_ARROW_CURSOR;
+				elements.clear();
+				qr = nullptr;
+				font = nullptr;
+				this->window = window;
+				viewportCallback = nullptr;
+				viewportUser = nullptr;
+				viewUpdateFlag = false;
+				cursor = glfwCreateStandardCursor(currentCursorType);
 			}
 			~Interface()
 			{
-				reinterpret_cast<void(__thiscall*)(gui::Interface * self)>(FUNC_GUI_INTERFACE_DESTR_INTERFACE)(this);
+				glfwDestroyCursor(this->cursor);
+
+				if (!this->elements.empty())
+				{
+					for (auto it = this->elements.begin(); it != this->elements.end(); ++it)
+					{
+						delete* it;
+					}
+
+					this->elements.clear();
+				}
 			}
 			void render()
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::Interface * self)>(FUNC_GUI_INTERFACE_RENDER)(this);
+				if (!elements.empty())
+				{
+					for (int i = 0; i < elements.size(); i++)
+					{
+						elements[i]->render(this);
+
+						if (viewUpdateFlag)
+						{
+							int width, height;
+							glfwGetWindowSize(window, &width, &height);
+
+							if (width > 0 && height > 0)
+								changeViewport({ 0, 0, width, height }, { 0, 0 });
+
+							viewUpdateFlag = false;
+						}
+					}
+				}
 			}
 			void mouseInput(double xpos, double ypos)
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::Interface * self, double xpos, double ypos)>(FUNC_GUI_INTERFACE_MOUSEINPUT)(this, xpos, ypos);
+				if (elements.empty()) return;
+				return reinterpret_cast<void(__thiscall*)(gui::Interface * self, double xpos, double ypos)>(getFuncAddr((int)Func::gui_Nested::Interface::mouseInput))(this, xpos, ypos);
 			}
 			bool scrollInput(double xoffset, double yoffset)
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::Interface * self, double xoffset, double yoffset)>(FUNC_GUI_INTERFACE_SCROLLINPUT)(this, xoffset, yoffset);
+				return reinterpret_cast<bool(__thiscall*)(gui::Interface * self, double xoffset, double yoffset)>(getFuncAddr((int)Func::gui_Nested::Interface::scrollInput))(this, xoffset, yoffset);
 			}
 			bool mouseButtonInput(int button, int action, int mods)
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::Interface * self, int button, int action, int mods)>(FUNC_GUI_INTERFACE_MOUSEBUTTONINPUT)(this, button, action, mods);
+				if (elements.empty()) return false;
+				return reinterpret_cast<bool(__thiscall*)(gui::Interface * self, int button, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::Interface::mouseButtonInput))(this, button, action, mods);
 			}
 			bool keyInput(int key, int scancode, int action, int mods)
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::Interface * self, int key, int scancode, int action, int mods)>(FUNC_GUI_INTERFACE_KEYINPUT)(this, key, scancode, action, mods);
+				return reinterpret_cast<bool(__thiscall*)(gui::Interface * self, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::Interface::keyInput))(this, key, scancode, action, mods);
 			}
-			QuadRenderer* getQuadRenderer() override
+			QuadRenderer* getQuadRenderer() const override
 			{
-				return reinterpret_cast<QuadRenderer * (__thiscall*)(gui::Interface * self)>(FUNC_GUI_INTERFACE_GETQUADRENDERER)(this);
+				return reinterpret_cast<QuadRenderer * (__thiscall*)(const gui::Interface * self)>(getFuncAddr((int)Func::gui_Nested::Interface::getQuadRenderer))(this);
 			}
-			FontRenderer* getFont() override
+			FontRenderer* getFont() const override
 			{
-				return reinterpret_cast<FontRenderer * (__thiscall*)(gui::Interface * self)>(FUNC_GUI_INTERFACE_GETFONT)(this);
+				return reinterpret_cast<FontRenderer * (__thiscall*)(const gui::Interface * self)>(getFuncAddr((int)Func::gui_Nested::Interface::getFont))(this);
 			}
-			GLFWwindow* getGLFWwindow() override
+			GLFWwindow* getGLFWwindow() const override
 			{
-				return reinterpret_cast<GLFWwindow * (__thiscall*)(gui::Interface * self)>(FUNC_GUI_INTERFACE_GETGLFWWINDOW)(this);
+				return reinterpret_cast<GLFWwindow * (__thiscall*)(const gui::Interface * self)>(getFuncAddr((int)Func::gui_Nested::Interface::getGLFWwindow))(this);
 			}
-			void getCursorPos(int* x, int* y) override
+			void getCursorPos(int* x, int* y) const override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::Interface * self, int* x, int* y)>(FUNC_GUI_INTERFACE_GETCURSORPOS)(this, x, y);
+				double xd, yd;
+				glfwGetCursorPos(window, &xd, &yd);
+				*x = xd;
+				*y = yd;
 			}
-			void getSize(int* x, int* y) override
+			void getSize(int* x, int* y) const override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::Interface * self, int* x, int* y)>(FUNC_GUI_INTERFACE_GETSIZE)(this, x, y);
+				glfwGetWindowSize(window, x, y);
 			}
 			void changeViewport(const glm::ivec4& pos, const glm::ivec2& scroll) override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::Interface * self, const glm::ivec4 & pos, const glm::ivec2 & scroll)>(FUNC_GUI_INTERFACE_CHANGEVIEWPORT)(this, pos, scroll);
+				if (viewportCallback)
+				{
+					viewUpdateFlag = true;
+					viewportCallback(viewportUser, pos, scroll);
+				}
 			}
 			void addElement(gui::Element* e) override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::Interface * self, gui::Element * e)>(FUNC_GUI_INTERFACE_ADDELEMENT)(this, e);
+				elements.push_back(e);
 			}
 			bool removeElement(gui::Element* e) override
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::Interface * self, gui::Element * e)>(FUNC_GUI_INTERFACE_REMOVEELEMENT)(this, e);
+				return elements.erase(std::remove(elements.begin(), elements.end(), e), elements.end()) != elements.end();
 			}
 			bool selectElement(gui::Element* e) override
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::Interface * self, gui::Element * e)>(FUNC_GUI_INTERFACE_SELECTELEMENT)(this, e);
+				if (e == nullptr)
+				{
+					changeSelection(-1);
+					return false;
+				}
+
+				for (int i = 0; i < elements.size(); ++i)
+				{
+					if (elements[i] == e)
+					{
+						changeSelection(i);
+						return true;
+					}
+				}
+
+				return false;
 			}
 			void clear() override
 			{
-				return reinterpret_cast<void(__thiscall*)(gui::Interface * self)>(FUNC_GUI_INTERFACE_CLEAR)(this);
+				elements.clear();
+				changeSelection(-1);
 			}
 			bool empty() override
 			{
-				return reinterpret_cast<bool(__thiscall*)(gui::Interface * self)>(FUNC_GUI_INTERFACE_EMPTY)(this);
+				return elements.empty();
+			}
+			bool charInput(uint32_t codepoint)
+			{
+				if (!empty() && selectedElemIndex != -1)
+					return elements[selectedElemIndex]->charInput(this, codepoint);
+				return false;
 			}
 		};
 	}
diff --git a/4dm.h/GUI/Slider.h b/4dm.h/GUI/Slider.h
index 9c668b5..a7f3ce3 100644
--- a/4dm.h/GUI/Slider.h
+++ b/4dm.h/GUI/Slider.h
@@ -8,65 +8,73 @@ namespace fdm::gui
 	class Slider : public gui::Element 
 	{
 	public:
-		inline static const int height = 50; 
-		std::string text; // 0x8
+		inline static const int height = 50;
+		msvc_string text = ""; // 0x8
 		bool clickable = true; // 0x28
 		bool mouseDown; // 0x29
 		bool selected; // 0x2A
 		PAD(0x1);
-		int range; // 0x2C
-		int width; // 0x30
-		int value; // 0x34
-		int xOffset; // 0x38
-		int yOffset; // 0x3C
-		gui::AlignmentX xAlign; // 0x40
-		gui::AlignmentY yAlign; // 0x44
+		int range = 100; // 0x2C
+		int width = 100; // 0x30
+		int value = 0; // 0x34
+		int xOffset = 0; // 0x38
+		int yOffset = 0; // 0x3C
+		gui::AlignmentX xAlign = ALIGN_LEFT; // 0x40
+		gui::AlignmentY yAlign = ALIGN_TOP; // 0x44
 		void* user; // 0x48
 		SliderCallback callback = NULL; // 0x50
 
+		void setText(const msvc_string& text)
+		{
+			this->text = text;
+		}
 		void offsetX(int offset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, int offset)>(FUNC_GUI_SLIDER_OFFSETX)(this, offset);
+			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, int offset)>(getFuncAddr((int)Func::gui_Nested::Slider::offsetX))(this, offset);
 		}
 		void offsetY(int offset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, int offset)>(FUNC_GUI_SLIDER_OFFSETY)(this, offset);
+			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, int offset)>(getFuncAddr((int)Func::gui_Nested::Slider::offsetY))(this, offset);
+		}
+		void select() override
+		{
+			selected = true;
 		}
 		void deselect() override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Slider* self)>(FUNC_GUI_SLIDER_DESELECT)(this);
+			selected = false;
 		}
 		void render(gui::Window* w) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, gui::Window* w)>(FUNC_GUI_SLIDER_RENDER)(this, w);
+			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, gui::Window* w)>(getFuncAddr((int)Func::gui_Nested::Slider::render))(this, w);
 		}
-		bool mouseButtonInput(gui::Window* w, int button, int action, int mods) override
+		bool mouseButtonInput(const gui::Window* w, int button, int action, int mods) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::Slider* self, gui::Window* w, int button, int action, int mods)>(FUNC_GUI_SLIDER_MOUSEBUTTONINPUT)(this, w, button, action, mods);
+			return reinterpret_cast<bool (__thiscall*)(gui::Slider* self, const gui::Window* w, int button, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::Slider::mouseButtonInput))(this, w, button, action, mods);
 		}
-		bool mouseInput(gui::Window* w, double xpos, double ypos) override
+		bool mouseInput(const gui::Window* w, double xpos, double ypos) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::Slider* self, gui::Window* w, double xpos, double ypos)>(FUNC_GUI_SLIDER_MOUSEINPUT)(this, w, xpos, ypos);
+			return reinterpret_cast<bool (__thiscall*)(gui::Slider* self, const gui::Window* w, double xpos, double ypos)>(getFuncAddr((int)Func::gui_Nested::Slider::mouseInput))(this, w, xpos, ypos);
 		}
-		bool keyInput(gui::Window* w, int key, int scancode, int action, int mods) override
+		bool keyInput(const gui::Window* w, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::Slider* self, gui::Window* w, int key, int scancode, int action, int mods)>(FUNC_GUI_SLIDER_KEYINPUT)(this, w, key, scancode, action, mods);
+			return reinterpret_cast<bool (__thiscall*)(gui::Slider* self, const gui::Window* w, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::Slider::keyInput))(this, w, key, scancode, action, mods);
 		}
 		void alignX(gui::AlignmentX a) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, gui::AlignmentX a)>(FUNC_GUI_SLIDER_ALIGNX)(this, a);
+			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, gui::AlignmentX a)>(getFuncAddr((int)Func::gui_Nested::Slider::alignX))(this, a);
 		}
 		void alignY(gui::AlignmentY a) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, gui::AlignmentY a)>(FUNC_GUI_SLIDER_ALIGNY)(this, a);
+			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, gui::AlignmentY a)>(getFuncAddr((int)Func::gui_Nested::Slider::alignY))(this, a);
 		}
-		void getPos(gui::Window* w, int* x, int* y) override
+		void getPos(const gui::Window* w, int* x, int* y) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, gui::Window* w, int* x, int* y)>(FUNC_GUI_SLIDER_GETPOS)(this, w, x, y);
+			return reinterpret_cast<void (__thiscall*)(const gui::Slider* self, const gui::Window* w, int* x, int* y)>(getFuncAddr((int)Func::gui_Nested::Slider::getPos))(this, w, x, y);
 		}
-		void getSize(gui::Window* w, int* width, int* height) override
+		void getSize(const gui::Window* w, int* width, int* height) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Slider* self, gui::Window* w, int* width, int* height)>(FUNC_GUI_SLIDER_GETSIZE)(this, w, width, height);
+			return reinterpret_cast<void (__thiscall*)(const gui::Slider* self, const gui::Window* w, int* width, int* height)>(getFuncAddr((int)Func::gui_Nested::Slider::getSize))(this, w, width, height);
 		}
 	};
 }
diff --git a/4dm.h/GUI/Text.h b/4dm.h/GUI/Text.h
index 4efc3ee..7b93efe 100644
--- a/4dm.h/GUI/Text.h
+++ b/4dm.h/GUI/Text.h
@@ -7,20 +7,21 @@ namespace fdm::gui
 	class Text : public gui::Element 
 	{
 	public:
-		msvc_string text; // 0x8
-		int xOffset; // 0x28
-		int yOffset; // 0x2C
-		gui::AlignmentX xAlign; // 0x30
-		gui::AlignmentY yAlign; // 0x34
+		msvc_string text = ""; // 0x8
+		int xOffset = 0; // 0x28
+		int yOffset = 0; // 0x2C
+		gui::AlignmentX xAlign = ALIGN_LEFT; // 0x30
+		gui::AlignmentY yAlign = ALIGN_TOP;  // 0x34
 		glm::vec4 color{1}; // 0x38
-		uint32_t size; // 0x48
+		uint32_t size = 1; // 0x48
 		uint32_t wrapWidth; // 0x4C
 		bool shadow; // 0x50
 		bool fancy; // 0x51
 
+		bool enabled() override { return false; }
 		void render(gui::Window* w) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Text* self, gui::Window* w)>(FUNC_GUI_TEXT_RENDER)(this, w);
+			return reinterpret_cast<void (__thiscall*)(gui::Text* self, gui::Window* w)>(getFuncAddr((int)Func::gui_Nested::Text::render))(this, w);
 		}
 		void offsetX(int offset) override
 		{
@@ -38,21 +39,21 @@ namespace fdm::gui
 		{
 			this->yAlign = a;
 		}
-		void getPos(gui::Window* w, int* x, int* y) override
+		void getPos(const gui::Window* w, int* x, int* y) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Text* self, gui::Window* w, int* x, int* y)>(FUNC_GUI_TEXT_GETPOS)(this, w, x, y);
+			return reinterpret_cast<void (__thiscall*)(const gui::Text* self, const gui::Window* w, int* x, int* y)>(getFuncAddr((int)Func::gui_Nested::Text::getPos))(this, w, x, y);
 		}
-		void getSize(gui::Window* w, int* width, int* height) override
+		void getSize(const gui::Window* w, int* width, int* height) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Text* self, gui::Window* w, int* width, int* height)>(FUNC_GUI_TEXT_GETSIZE)(this, w, width, height);
+			return reinterpret_cast<void (__thiscall*)(const gui::Text* self, const gui::Window* w, int* width, int* height)>(getFuncAddr((int)Func::gui_Nested::Text::getSize))(this, w, width, height);
 		}
-		void setText(const std::string& text) 
+		void setText(const msvc_string& text) 
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Text* self, const std::string& text)>(FUNC_GUI_TEXT_SETTEXT)(this, text);
+			return reinterpret_cast<void (__thiscall*)(gui::Text* self, const msvc_string& text)>(getFuncAddr((int)Func::gui_Nested::Text::setText))(this, text);
 		}
-		void renderText(gui::Window* w, FontRenderer* text, int x, int y, bool align) 
+		void renderText(gui::Window* w, const msvc_string& text, int x, int y, bool align) 
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::Text* self, gui::Window* w, FontRenderer* text, int x, int y, bool align)>(FUNC_GUI_TEXT_RENDERTEXT)(this, w, text, x, y, align);
+			return reinterpret_cast<void (__thiscall*)(gui::Text* self, gui::Window* w, const msvc_string & text, int x, int y, bool align)>(getFuncAddr((int)Func::gui_Nested::Text::renderText))(this, w, text, x, y, align);
 		}
 	};
 }
diff --git a/4dm.h/GUI/TextInput.h b/4dm.h/GUI/TextInput.h
index 1b6690c..8e5d759 100644
--- a/4dm.h/GUI/TextInput.h
+++ b/4dm.h/GUI/TextInput.h
@@ -4,29 +4,29 @@
 
 namespace fdm::gui
 {
-	using TextInputCallback = std::add_pointer<void(void* user, std::string& text)>::type;
+	using TextInputCallback = std::add_pointer<void(void* user, msvc_string& text)>::type;
 	class TextInput : public gui::Element 
 	{
 	public:
-		msvc_string text; // 0x8
+		msvc_string text = ""; // 0x8
 		bool enabled = true; // 0x28
 		bool editable = true; // 0x29
 		bool mouseDown; // 0x2A
 		bool active; // 0x2B
-		bool highlight; // 0x2C
-		bool passwordMode; // 0x2D
+		bool highlight = false; // 0x2C
+		bool passwordMode = false; // 0x2D
 		PAD(0x2);
-		msvc_string passwordVisualText; // 0x30
-		int cursorPos; // 0x50
-		int highlightStart; // 0x54
-		uint32_t width; // 0x58
-		uint32_t height; // 0x5C
+		msvc_string passwordVisualText = ""; // 0x30
+		int cursorPos = 0; // 0x50
+		int highlightStart = 0; // 0x54
+		uint32_t width = 100; // 0x58
+		uint32_t height = 50; // 0x5C
 		inline static const int maxScrollPos = 4; 
-		int scrollPos; // 0x60
+		int scrollPos = 4; // 0x60
 		inline static const float cursorBlinkTime = 0.5f; 
 		float cursorBlinkTimer; // 0x64
 		inline static const float lastTypedCharTime = 0.2f; 
-		float lastTypedCharTimer; // 0x68
+		float lastTypedCharTimer = 0.f; // 0x68
 		int lastTypedCharIndex; // 0x6C
 		int xOffset; // 0x70
 		int yOffset; // 0x74
@@ -37,77 +37,77 @@ namespace fdm::gui
 
 		void render(gui::Window* w) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, gui::Window* w)>(FUNC_GUI_TEXTINPUT_RENDER)(this, w);
+			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, gui::Window* w)>(getFuncAddr((int)Func::gui_Nested::TextInput::render))(this, w);
 		}
 		void alignX(gui::AlignmentX a) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, gui::AlignmentX a)>(FUNC_GUI_TEXTINPUT_ALIGNX)(this, a);
+			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, gui::AlignmentX a)>(getFuncAddr((int)Func::gui_Nested::TextInput::alignX))(this, a);
 		}
 		void alignY(gui::AlignmentY a) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, gui::AlignmentY a)>(FUNC_GUI_TEXTINPUT_ALIGNY)(this, a);
+			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, gui::AlignmentY a)>(getFuncAddr((int)Func::gui_Nested::TextInput::alignY))(this, a);
 		}
 		void offsetX(int offset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, int offset)>(FUNC_GUI_TEXTINPUT_OFFSETX)(this, offset);
+			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, int offset)>(getFuncAddr((int)Func::gui_Nested::TextInput::offsetX))(this, offset);
 		}
 		void offsetY(int offset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, int offset)>(FUNC_GUI_TEXTINPUT_OFFSETY)(this, offset);
+			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, int offset)>(getFuncAddr((int)Func::gui_Nested::TextInput::offsetY))(this, offset);
 		}
-		bool mouseButtonInput(gui::Window* w, int button, int action, int mods) override
+		bool mouseButtonInput(const gui::Window* w, int button, int action, int mods) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::TextInput* self, gui::Window* w, int button, int action, int mods)>(FUNC_GUI_TEXTINPUT_MOUSEBUTTONINPUT)(this, w, button, action, mods);
+			return reinterpret_cast<bool (__thiscall*)(gui::TextInput* self, const gui::Window* w, int button, int action, int mods)>(getFuncAddr((int)Func::gui_Nested::TextInput::mouseButtonInput))(this, w, button, action, mods);
 		}
-		bool mouseInput(gui::Window* w, double xpos, double ypos) override
+		bool mouseInput(const gui::Window* w, double xpos, double ypos) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::TextInput* self, gui::Window* w, double xpos, double ypos)>(FUNC_GUI_TEXTINPUT_MOUSEINPUT)(this, w, xpos, ypos);
+			return reinterpret_cast<bool (__thiscall*)(gui::TextInput* self, const gui::Window* w, double xpos, double ypos)>(getFuncAddr((int)Func::gui_Nested::TextInput::mouseInput))(this, w, xpos, ypos);
 		}
-		bool keyInput(gui::Window* w, int key, int scancode, int action, int mods) override
+		bool keyInput(const gui::Window* w, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::TextInput* self, gui::Window* w, int key, int scancode, int action, char mods)>(FUNC_GUI_TEXTINPUT_KEYINPUT)(this, w, key, scancode, action, mods);
+			return reinterpret_cast<bool (__thiscall*)(gui::TextInput* self, const gui::Window* w, int key, int scancode, int action, char mods)>(getFuncAddr((int)Func::gui_Nested::TextInput::keyInput))(this, w, key, scancode, action, mods);
 		}
-		bool charInput(gui::Window* w, uint32_t codepoint) override
+		bool charInput(const gui::Window* w, uint32_t codepoint) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(gui::TextInput* self, gui::Window* w, uint32_t codepoint)>(FUNC_GUI_TEXTINPUT_CHARINPUT)(this, w, codepoint);
+			return reinterpret_cast<bool (__thiscall*)(gui::TextInput* self, const gui::Window* w, uint32_t codepoint)>(getFuncAddr((int)Func::gui_Nested::TextInput::charInput))(this, w, codepoint);
 		}
 		int getCursorType() override
 		{
-			return reinterpret_cast<int (__thiscall*)(gui::TextInput* self)>(FUNC_GUI_TEXTINPUT_GETCURSORTYPE)(this);
+			return reinterpret_cast<int (__thiscall*)(gui::TextInput* self)>(getFuncAddr((int)Func::gui_Nested::TextInput::getCursorType))(this);
 		}
 		void select() override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self)>(FUNC_GUI_TEXTINPUT_SELECT)(this);
+			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self)>(getFuncAddr((int)Func::gui_Nested::TextInput::select))(this);
 		}
 		void deselect() override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self)>(FUNC_GUI_TEXTINPUT_DESELECT)(this);
+			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self)>(getFuncAddr((int)Func::gui_Nested::TextInput::deselect))(this);
 		}
 		void updatePasswordVisualText() 
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self)>(FUNC_GUI_TEXTINPUT_UPDATEPASSWORDVISUALTEXT)(this);
+			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self)>(getFuncAddr((int)Func::gui_Nested::TextInput::updatePasswordVisualText))(this);
 		}
-		void updateScrollPos(gui::Window* w) 
+		void updateScrollPos(const gui::Window* w)
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, gui::Window* w)>(FUNC_GUI_TEXTINPUT_UPDATESCROLLPOS)(this, w);
+			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, const gui::Window* w)>(getFuncAddr((int)Func::gui_Nested::TextInput::updateScrollPos))(this, w);
 		}
-		void getPos(gui::Window* w, int* x, int* y) override
+		void getPos(const gui::Window* w, int* x, int* y) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, gui::Window* w, int* x, int* y)>(FUNC_GUI_TEXTINPUT_GETPOS)(this, w, x, y);
-		}
-		void getSize(gui::Window* w, int* width, int* height) override
+			return reinterpret_cast<void (__thiscall*)(const gui::TextInput* self, const gui::Window* w, int* x, int* y)>(getFuncAddr((int)Func::gui_Nested::TextInput::getPos))(this, w, x, y);
+		} 
+		void getSize(const gui::Window* w, int* width, int* height) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self, gui::Window* w, int* width, int* height)>(FUNC_GUI_TEXTINPUT_GETSIZE)(this, w, width, height);
+			return reinterpret_cast<void (__thiscall*)(const gui::TextInput* self, const gui::Window* w, int* width, int* height)>(getFuncAddr((int)Func::gui_Nested::TextInput::getSize))(this, w, width, height);
 		}
-		std::string removeInvalidChars(const char* str) 
+		msvc_string removeInvalidChars(const char* str) 
 		{
-			std::string result;
-			reinterpret_cast<std::string (__thiscall*)(gui::TextInput* self, std::string* result, const char* str)>(FUNC_GUI_TEXTINPUT_REMOVEINVALIDCHARS)(this, &result, str);
+			msvc_string result;
+			reinterpret_cast<msvc_string& (__thiscall*)(gui::TextInput* self, msvc_string* result, const char* str)>(getFuncAddr((int)Func::gui_Nested::TextInput::removeInvalidChars))(this, &result, str);
 			return result;
 		}
 		void removeHighlightedText() 
 		{
-			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self)>(FUNC_GUI_TEXTINPUT_REMOVEHIGHLIGHTEDTEXT)(this);
+			return reinterpret_cast<void (__thiscall*)(gui::TextInput* self)>(getFuncAddr((int)Func::gui_Nested::TextInput::removeHighlightedText))(this);
 		}
 	};
 }
diff --git a/4dm.h/GUI/Window.h b/4dm.h/GUI/Window.h
index df3b1b3..3b488b1 100644
--- a/4dm.h/GUI/Window.h
+++ b/4dm.h/GUI/Window.h
@@ -13,11 +13,11 @@ namespace fdm
 		class Window
 		{
 		public:
-			virtual QuadRenderer* getQuadRenderer() { return NULL; }
-			virtual FontRenderer* getFont() { return NULL; }
-			virtual GLFWwindow* getGLFWwindow() { return NULL; }
-			virtual void getCursorPos(int* x, int* y) { }
-			virtual void getSize(int* width, int* height) { }
+			virtual QuadRenderer* getQuadRenderer() const { return NULL; }
+			virtual FontRenderer* getFont() const { return NULL; }
+			virtual GLFWwindow* getGLFWwindow() const { return NULL; }
+			virtual void getCursorPos(int* x, int* y) const { }
+			virtual void getSize(int* width, int* height) const { }
 			virtual void changeViewport(const glm::ivec4& pos, const glm::ivec2& scroll) { }
 		};
 	}
diff --git a/4dm.h/GlobalShapes.h b/4dm.h/GlobalShapes.h
index 1e5c25b..6945f4f 100644
--- a/4dm.h/GlobalShapes.h
+++ b/4dm.h/GlobalShapes.h
@@ -15,21 +15,21 @@ namespace fdm
 	public:
 		inline static const MeshBuilder* pentachoron = reinterpret_cast<const MeshBuilder*>((base + 0x2C0B08));
 		inline static const PentachoronHollow* pentachoronHollow = reinterpret_cast<const PentachoronHollow*>((base + 0x2C0970));
-		inline static glm::vec4** five_cell_normals = reinterpret_cast<glm::vec4**>((base + 0x2C0920));
+		inline static glm::vec4* five_cell_normals = reinterpret_cast<glm::vec4*>((base + 0x2C0920));
 		inline static const MeshBuilder* pentachoronOriginBase = reinterpret_cast<const MeshBuilder*>((base + 0x2BFAA8));
 		inline static const MeshBuilder* spiderLeg = reinterpret_cast<const MeshBuilder*>((base + 0x2C0AD0));
-		inline static glm::vec4** five_cell_tet_origin_base = reinterpret_cast<glm::vec4**>((base + 0x2C0770));
+		inline static glm::vec4* five_cell_tet_origin_base = reinterpret_cast<glm::vec4*>((base + 0x2C0770));
 		inline static const MeshBuilder* hypercube = reinterpret_cast<const MeshBuilder*>((base + 0x2C0B48));
 		inline static const HypercubeHollow* hypercubeHollow = reinterpret_cast<const HypercubeHollow*>((base + 0x2C0B80));
-		inline static glm::vec4* *hypercube_vert = NULL; 
-		inline static glm::vec3* *hypercube_vert_colors_deadly = NULL; 
-		inline static glm::vec4* *hypercube_cubes = reinterpret_cast<glm::vec4**>((base + 0x2AEA90)); 
-		inline static glm::vec4* *hypercube_cubes_normals = reinterpret_cast<glm::vec4**>((base + 0x2AEA10)); 
-		inline static glm::vec3* *hypercube_cubes_colors_deadly = reinterpret_cast<glm::vec3**>((base + 0x2ADD10)); 
-		inline static glm::vec4* *hypercube_tet = reinterpret_cast<glm::vec4**>((base + 0x2AE010)); 
-		inline static glm::vec3* *hypercube_tet_colors = reinterpret_cast<glm::vec3**>((base + 0x2AD590)); 
-		inline static glm::vec4* *hypercube_wireframe = reinterpret_cast<glm::vec4**>((base + 0x2AEE90)); 
-		inline static glm::vec4* *hypercube_block_tet = NULL; 
+		inline static glm::vec4* hypercube_vert = NULL; 
+		inline static glm::vec3* hypercube_vert_colors_deadly = NULL; 
+		inline static glm::vec4* hypercube_cubes = reinterpret_cast<glm::vec4*>((base + 0x2AEA90)); 
+		inline static glm::vec4* hypercube_cubes_normals = reinterpret_cast<glm::vec4*>((base + 0x2AEA10)); 
+		inline static glm::vec3* hypercube_cubes_colors_deadly = reinterpret_cast<glm::vec3*>((base + 0x2ADD10)); 
+		inline static glm::vec4* hypercube_tet = reinterpret_cast<glm::vec4*>((base + 0x2AE010)); 
+		inline static glm::vec3* hypercube_tet_colors = reinterpret_cast<glm::vec3*>((base + 0x2AD590)); 
+		inline static glm::vec4* hypercube_wireframe = reinterpret_cast<glm::vec4*>((base + 0x2AEE90)); 
+		inline static glm::vec4* hypercube_block_tet = NULL; 
 		inline static const Dodecaplex* dodecaplexHollow = reinterpret_cast<const Dodecaplex*>((base + 0x279950));
 		inline static const Dodecaplex* dodecaplex = reinterpret_cast<const Dodecaplex*>((base + 0x2798F0));
 		inline static const Dodecaplex* rock = reinterpret_cast<const Dodecaplex*>((base + 0x2799D0));
diff --git a/4dm.h/Hitbox.h b/4dm.h/Hitbox.h
index 13b93c2..ad91daa 100644
--- a/4dm.h/Hitbox.h
+++ b/4dm.h/Hitbox.h
@@ -20,19 +20,19 @@ namespace fdm
 
 		void addVelWithMaxHorizSpeed(const glm::vec4& adjustment, float maxHorizSpeed) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Hitbox* self, const glm::vec4& adjustment, float maxHorizSpeed)>(FUNC_HITBOX_ADDVELWITHMAXHORIZSPEED)(this, adjustment, maxHorizSpeed);
+			return reinterpret_cast<void (__thiscall*)(Hitbox* self, const glm::vec4& adjustment, float maxHorizSpeed)>(getFuncAddr((int)Func::Hitbox::addVelWithMaxHorizSpeed))(this, adjustment, maxHorizSpeed);
 		}
 		void update(World* world, double dt) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Hitbox* self, World* world, double dt)>(FUNC_HITBOX_UPDATE)(this, world, dt);
+			return reinterpret_cast<void (__thiscall*)(Hitbox* self, World* world, double dt)>(getFuncAddr((int)Func::Hitbox::update))(this, world, dt);
 		}
 		bool isIntersectingRay(const Entity::Ray& ray) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Hitbox* self, const Entity::Ray& ray)>(FUNC_HITBOX_ISINTERSECTINGRAY)(this, ray);
+			return reinterpret_cast<bool (__thiscall*)(Hitbox* self, const Entity::Ray& ray)>(getFuncAddr((int)Func::Hitbox::isIntersectingRay))(this, ray);
 		}
 		bool takeStep(World* world, uint32_t comp, float step) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Hitbox* self, World* world, uint32_t comp, float step)>(FUNC_HITBOX_TAKESTEP)(this, world, comp, step);
+			return reinterpret_cast<bool (__thiscall*)(Hitbox* self, World* world, uint32_t comp, float step)>(getFuncAddr((int)Func::Hitbox::takeStep))(this, world, comp, step);
 		}
 	};
 }
diff --git a/4dm.h/HypercubeHollow.h b/4dm.h/HypercubeHollow.h
index 88a4017..b9b0828 100644
--- a/4dm.h/HypercubeHollow.h
+++ b/4dm.h/HypercubeHollow.h
@@ -17,19 +17,19 @@ namespace fdm
 
 		int attrSize(int buffIndex, int attrIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const HypercubeHollow* self, int buffIndex, int attrIndex)>(FUNC_HYPERCUBEHOLLOW_ATTRSIZE)(this, buffIndex, attrIndex);
+			return reinterpret_cast<int (__thiscall*)(const HypercubeHollow* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::HypercubeHollow::attrSize))(this, buffIndex, attrIndex);
 		}
 		int attrStride(int buffIndex, int attriIdex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const HypercubeHollow* self, int buffIndex, int attriIdex)>(FUNC_HYPERCUBEHOLLOW_ATTRSTRIDE)(this, buffIndex, attriIdex);
+			return reinterpret_cast<int (__thiscall*)(const HypercubeHollow* self, int buffIndex, int attriIdex)>(getFuncAddr((int)Func::HypercubeHollow::attrStride))(this, buffIndex, attriIdex);
 		}
 		HypercubeHollow(float distance) 
 		{
-			reinterpret_cast<void(__thiscall*)(HypercubeHollow* self, float distance)>(FUNC_HYPERCUBEHOLLOW_HYPERCUBEHOLLOW)(this, distance);
+			reinterpret_cast<void(__thiscall*)(HypercubeHollow* self, float distance)>(getFuncAddr((int)Func::HypercubeHollow::HypercubeHollow))(this, distance);
 		}
 		void addCubeSide(const glm::vec4* cube_ptr, const glm::vec4* inner, int i0, int i1, int i2, int i3) 
 		{
-			return reinterpret_cast<void (__thiscall*)(HypercubeHollow* self, const glm::vec4* cube_ptr, const glm::vec4* inner, int i0, int i1, int i2, int i3)>(FUNC_HYPERCUBEHOLLOW_ADDCUBESIDE)(this, cube_ptr, inner, i0, i1, i2, i3);
+			return reinterpret_cast<void (__thiscall*)(HypercubeHollow* self, const glm::vec4* cube_ptr, const glm::vec4* inner, int i0, int i1, int i2, int i3)>(getFuncAddr((int)Func::HypercubeHollow::addCubeSide))(this, cube_ptr, inner, i0, i1, i2, i3);
 		}
 	};
 }
diff --git a/4dm.h/Hypersphere.h b/4dm.h/Hypersphere.h
index 068d266..099a636 100644
--- a/4dm.h/Hypersphere.h
+++ b/4dm.h/Hypersphere.h
@@ -14,19 +14,19 @@ namespace fdm
 
 			VertInfo() 
 			{
-				reinterpret_cast<void(__thiscall*)(Hypersphere::VertInfo* self)>(FUNC_HYPERSPHERE_VERTINFO_VERTINFO)(this);
+				reinterpret_cast<void(__thiscall*)(Hypersphere::VertInfo* self)>(getFuncAddr((int)Func::Hypersphere_Nested::VertInfo::VertInfo))(this);
 			}
 			~VertInfo() 
 			{
-				reinterpret_cast<void(__thiscall*)(Hypersphere::VertInfo* self)>(FUNC_HYPERSPHERE_VERTINFO_DESTR_VERTINFO)(this);
+				reinterpret_cast<void(__thiscall*)(Hypersphere::VertInfo* self)>(getFuncAddr((int)Func::Hypersphere_Nested::VertInfo::destr_VertInfo))(this);
 			}
 			void add(const glm::vec4& vert, MeshBuilder::AttrInfo* tuv) 
 			{
-				return reinterpret_cast<void (__thiscall*)(Hypersphere::VertInfo* self, const glm::vec4& vert, MeshBuilder::AttrInfo* tuv)>(FUNC_HYPERSPHERE_VERTINFO_ADD)(this, vert, tuv);
+				return reinterpret_cast<void (__thiscall*)(Hypersphere::VertInfo* self, const glm::vec4& vert, MeshBuilder::AttrInfo* tuv)>(getFuncAddr((int)Func::Hypersphere_Nested::VertInfo::add))(this, vert, tuv);
 			}
 			void add(const Hypersphere::VertInfo* v, int index) 
 			{
-				return reinterpret_cast<void (__thiscall*)(Hypersphere::VertInfo* self, const Hypersphere::VertInfo* v, int index)>(FUNC_HYPERSPHERE_VERTINFO_ADD_A)(this, v, index);
+				return reinterpret_cast<void (__thiscall*)(Hypersphere::VertInfo* self, const Hypersphere::VertInfo* v, int index)>(getFuncAddr((int)Func::Hypersphere_Nested::VertInfo::addA))(this, v, index);
 			}
 		};
 		struct HSInfo 
@@ -41,35 +41,35 @@ namespace fdm
 
 		int attrCount(int buffIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Hypersphere* self, int buffIndex)>(FUNC_HYPERSPHERE_ATTRCOUNT)(this, buffIndex);
+			return reinterpret_cast<int (__thiscall*)(const Hypersphere* self, int buffIndex)>(getFuncAddr((int)Func::Hypersphere::attrCount))(this, buffIndex);
 		}
 		uint32_t attrType(int buffIndex, int attrIndex) const override
 		{
-			return reinterpret_cast<uint32_t (__thiscall*)(const Hypersphere* self, int buffIndex, int attrIndex)>(FUNC_HYPERSPHERE_ATTRTYPE)(this, buffIndex, attrIndex);
+			return reinterpret_cast<uint32_t (__thiscall*)(const Hypersphere* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::Hypersphere::attrType))(this, buffIndex, attrIndex);
 		}
 		int buffCount() const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Hypersphere* self)>(FUNC_HYPERSPHERE_BUFFCOUNT)(this);
+			return reinterpret_cast<int (__thiscall*)(const Hypersphere* self)>(getFuncAddr((int)Func::Hypersphere::buffCount))(this);
 		}
 		Hypersphere(int edges) 
 		{
-			reinterpret_cast<void(__thiscall*)(Hypersphere* self, int edges)>(FUNC_HYPERSPHERE_HYPERSPHERE)(this, edges);
+			reinterpret_cast<void(__thiscall*)(Hypersphere* self, int edges)>(getFuncAddr((int)Func::Hypersphere::Hypersphere))(this, edges);
 		}
 		Hypersphere(int edges, float distance) 
 		{
-			reinterpret_cast<void(__thiscall*)(Hypersphere* self, int edges, float distance)>(FUNC_HYPERSPHERE_HYPERSPHERE_A)(this, edges, distance);
+			reinterpret_cast<void(__thiscall*)(Hypersphere* self, int edges, float distance)>(getFuncAddr((int)Func::Hypersphere::HypersphereA))(this, edges, distance);
 		}
 		inline static void generateSpherePolygons(Hypersphere::VertInfo* triangles, Hypersphere::VertInfo* trapezoids, const Hypersphere::HSInfo* hsi, int wi) 
 		{
-			return reinterpret_cast<void (__fastcall*)(Hypersphere::VertInfo* triangles, Hypersphere::VertInfo* trapezoids, const Hypersphere::HSInfo* hsi, int wi)>(FUNC_HYPERSPHERE_GENERATESPHEREPOLYGONS)(triangles, trapezoids, hsi, wi);
+			return reinterpret_cast<void (__fastcall*)(Hypersphere::VertInfo* triangles, Hypersphere::VertInfo* trapezoids, const Hypersphere::HSInfo* hsi, int wi)>(getFuncAddr((int)Func::Hypersphere::generateSpherePolygons))(triangles, trapezoids, hsi, wi);
 		}
 		void addWedgeSide(const Hypersphere::VertInfo* outer, const Hypersphere::VertInfo* inner, int i0, int i1, int i2) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Hypersphere* self, const Hypersphere::VertInfo* outer, const Hypersphere::VertInfo* inner, int i0, int i1, int i2)>(FUNC_HYPERSPHERE_ADDWEDGESIDE)(this, outer, inner, i0, i1, i2);
+			return reinterpret_cast<void (__thiscall*)(Hypersphere* self, const Hypersphere::VertInfo* outer, const Hypersphere::VertInfo* inner, int i0, int i1, int i2)>(getFuncAddr((int)Func::Hypersphere::addWedgeSide))(this, outer, inner, i0, i1, i2);
 		}
 		void addCubeSide(const Hypersphere::VertInfo* outer, const Hypersphere::VertInfo* inner, int i0, int i1, int i2, int i3) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Hypersphere* self, const Hypersphere::VertInfo* outer, const Hypersphere::VertInfo* inner, int i0, int i1, int i2, int i3)>(FUNC_HYPERSPHERE_ADDCUBESIDE)(this, outer, inner, i0, i1, i2, i3);
+			return reinterpret_cast<void (__thiscall*)(Hypersphere* self, const Hypersphere::VertInfo* outer, const Hypersphere::VertInfo* inner, int i0, int i1, int i2, int i3)>(getFuncAddr((int)Func::Hypersphere::addCubeSide))(this, outer, inner, i0, i1, i2, i3);
 		}
 	};
 }
diff --git a/4dm.h/Inventory.h b/4dm.h/Inventory.h
index 9b637f6..a8e8628 100644
--- a/4dm.h/Inventory.h
+++ b/4dm.h/Inventory.h
@@ -15,7 +15,7 @@ namespace fdm
 			Inventory* inventory; 
 			int index; // 0x8
 		};
-		std::string name; // 0x8
+		msvc_string name; // 0x8
 		bool updateFlag; // 0x28
 
 
diff --git a/4dm.h/InventoryGrid.h b/4dm.h/InventoryGrid.h
index 6a867ac..594241f 100644
--- a/4dm.h/InventoryGrid.h
+++ b/4dm.h/InventoryGrid.h
@@ -22,17 +22,17 @@ namespace fdm
 		glm::ivec2 size; // 0x38
 		int selectedIndex; // 0x40
 		PAD(0x4);
-		std::string label; // 0x48
+		msvc_string label; // 0x48
 		std::vector<std::unique_ptr<Item>> slots; // 0x68
 
 		~InventoryGrid() 
 		{
-			reinterpret_cast<void(__thiscall*)(InventoryGrid* self)>(FUNC_INVENTORYGRID_DESTR_INVENTORYGRID)(this);
+			reinterpret_cast<void(__thiscall*)(InventoryGrid* self)>(getFuncAddr((int)Func::InventoryGrid::destr_InventoryGrid))(this);
 		}
 		InventoryGrid() {}
 		InventoryGrid(const glm::ivec2& size) 
 		{
-			reinterpret_cast<void(__thiscall*)(InventoryGrid* self, const glm::ivec2& size)>(FUNC_INVENTORYGRID_INVENTORYGRID)(this, size);
+			reinterpret_cast<void(__thiscall*)(InventoryGrid* self, const glm::ivec2& size)>(getFuncAddr((int)Func::InventoryGrid::InventoryGrid))(this, size);
 		}
 		bool addItem(std::unique_ptr<Item>& item) override
 		{
@@ -47,27 +47,27 @@ namespace fdm
 		}
 		void render(const glm::ivec2& cursorPos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(InventoryGrid* self, const glm::ivec2& cursorPos)>(FUNC_INVENTORYGRID_RENDER)(this, cursorPos);
+			return reinterpret_cast<void (__thiscall*)(InventoryGrid* self, const glm::ivec2& cursorPos)>(getFuncAddr((int)Func::InventoryGrid::render))(this, cursorPos);
 		}
 		bool combineItem(std::unique_ptr<Item>& item) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(InventoryGrid* self, std::unique_ptr<Item>& item)>(FUNC_INVENTORYGRID_COMBINEITEM)(this, item);
+			return reinterpret_cast<bool (__thiscall*)(InventoryGrid* self, std::unique_ptr<Item>& item)>(getFuncAddr((int)Func::InventoryGrid::combineItem))(this, item);
 		}
 		bool placeItem(std::unique_ptr<Item>& item) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(InventoryGrid* self, std::unique_ptr<Item>& item)>(FUNC_INVENTORYGRID_PLACEITEM)(this, item);
+			return reinterpret_cast<bool (__thiscall*)(InventoryGrid* self, std::unique_ptr<Item>& item)>(getFuncAddr((int)Func::InventoryGrid::placeItem))(this, item);
 		}
 		int getSlotIndex(const glm::ivec2& cursorPos) override
 		{
-			return reinterpret_cast<int (__thiscall*)(InventoryGrid* self, const glm::ivec2& cursorPos)>(FUNC_INVENTORYGRID_GETSLOTINDEX)(this, cursorPos);
+			return reinterpret_cast<int (__thiscall*)(InventoryGrid* self, const glm::ivec2& cursorPos)>(getFuncAddr((int)Func::InventoryGrid::getSlotIndex))(this, cursorPos);
 		}
 		uint32_t getSlotCount() override
 		{
-			return reinterpret_cast<uint32_t (__thiscall*)(InventoryGrid* self)>(FUNC_INVENTORYGRID_GETSLOTCOUNT)(this);
+			return reinterpret_cast<uint32_t (__thiscall*)(InventoryGrid* self)>(getFuncAddr((int)Func::InventoryGrid::getSlotCount))(this);
 		}
 		std::unique_ptr<Item>* getSlot(int index) override
 		{
-			return reinterpret_cast<std::unique_ptr<Item>* (__thiscall*)(InventoryGrid* self, int index)>(FUNC_INVENTORYGRID_GETSLOT)(this, index);
+			return reinterpret_cast<std::unique_ptr<Item>* (__thiscall*)(InventoryGrid* self, int index)>(getFuncAddr((int)Func::InventoryGrid::getSlot))(this, index);
 		}
 		Inventory::iterator begin() override
 		{
@@ -77,17 +77,17 @@ namespace fdm
 		Inventory::iterator end() override
 		{
 			iterator result;
-			return reinterpret_cast<Inventory::iterator (__thiscall*)(InventoryGrid* self, Inventory::iterator* result)>(FUNC_INVENTORYGRID_END)(this, &result);
+			return reinterpret_cast<Inventory::iterator& (__thiscall*)(InventoryGrid* self, Inventory::iterator* result)>(getFuncAddr((int)Func::InventoryGrid::end))(this, &result);
 			return result;
 		}
 		void load(nlohmann::json& j) 
 		{
-			return reinterpret_cast<void (__thiscall*)(InventoryGrid* self, nlohmann::json& j)>(FUNC_INVENTORYGRID_LOAD)(this, j);
+			return reinterpret_cast<void (__thiscall*)(InventoryGrid* self, nlohmann::json& j)>(getFuncAddr((int)Func::InventoryGrid::load))(this, j);
 		}
 		nlohmann::json save() 
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(InventoryGrid* self, nlohmann::json* result)>(FUNC_INVENTORYGRID_SAVE)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(InventoryGrid* self, nlohmann::json* result)>(getFuncAddr((int)Func::InventoryGrid::save))(this, &result);
 			return result;
 		}
 	};
diff --git a/4dm.h/InventoryManager.h b/4dm.h/InventoryManager.h
index 5bb26ff..f9469f5 100644
--- a/4dm.h/InventoryManager.h
+++ b/4dm.h/InventoryManager.h
@@ -46,47 +46,51 @@ namespace fdm
 		InventoryManager(){}
 		~InventoryManager() 
 		{
-			reinterpret_cast<void(__thiscall*)(InventoryManager* self)>(FUNC_INVENTORYMANAGER_DESTR_INVENTORYMANAGER)(this);
+			reinterpret_cast<void(__thiscall*)(InventoryManager* self)>(getFuncAddr((int)Func::InventoryManager::destr_InventoryManager))(this);
 		}
 		void renderInit(GLFWwindow* w) 
 		{
-			return reinterpret_cast<void (__thiscall*)(InventoryManager* self, GLFWwindow* w)>(FUNC_INVENTORYMANAGER_RENDERINIT)(this, w);
+			return reinterpret_cast<void (__thiscall*)(InventoryManager* self, GLFWwindow* w)>(getFuncAddr((int)Func::InventoryManager::renderInit))(this, w);
 		}
 		bool mouseButtonInput(uint32_t x, uint32_t y, uint32_t button, int action, int mods) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(InventoryManager* self, uint32_t x, uint32_t y, uint32_t button, int action, int mods)>(FUNC_INVENTORYMANAGER_MOUSEBUTTONINPUT)(this, x, y, button, action, mods);
+			return reinterpret_cast<bool (__thiscall*)(InventoryManager* self, uint32_t x, uint32_t y, uint32_t button, int action, int mods)>(getFuncAddr((int)Func::InventoryManager::mouseButtonInput))(this, x, y, button, action, mods);
 		}
 		void windowResize(GLFWwindow* w, int width, int height) 
 		{
-			return reinterpret_cast<void (__thiscall*)(InventoryManager* self, GLFWwindow* w, int width, int height)>(FUNC_INVENTORYMANAGER_WINDOWRESIZE)(this, w, width, height);
+			return reinterpret_cast<void (__thiscall*)(InventoryManager* self, GLFWwindow* w, int width, int height)>(getFuncAddr((int)Func::InventoryManager::windowResize))(this, w, width, height);
 		}
 		bool applyAction(World* world, Player* player, nlohmann::json& action) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(InventoryManager* self, World* world, Player* player, nlohmann::json& action)>(FUNC_INVENTORYMANAGER_APPLYACTION)(this, world, player, action);
+			return reinterpret_cast<bool (__thiscall*)(InventoryManager* self, World* world, Player* player, nlohmann::json& action)>(getFuncAddr((int)Func::InventoryManager::applyAction))(this, world, player, action);
 		}
 		bool applyTransfer(InventoryManager::TransferAction action, std::unique_ptr<Item>& selectedSlot, std::unique_ptr<Item>& cursorSlot, Inventory* other) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(InventoryManager* self, InventoryManager::TransferAction action, std::unique_ptr<Item>& selectedSlot, std::unique_ptr<Item>& cursorSlot, Inventory* other)>(FUNC_INVENTORYMANAGER_APPLYTRANSFER)(this, action, selectedSlot, cursorSlot, other);
+			return reinterpret_cast<bool (__thiscall*)(InventoryManager* self, InventoryManager::TransferAction action, std::unique_ptr<Item>& selectedSlot, std::unique_ptr<Item>& cursorSlot, Inventory* other)>(getFuncAddr((int)Func::InventoryManager::applyTransfer))(this, action, selectedSlot, cursorSlot, other);
 		}
-		Inventory* findInventory(World* world, Player* player, const std::string& inventoryName) 
+		Inventory* findInventory(World* world, Player* player, const msvc_string& inventoryName) 
 		{
-			return reinterpret_cast<Inventory* (__thiscall*)(InventoryManager* self, World* world, Player* player, const std::string& inventoryName)>(FUNC_INVENTORYMANAGER_FINDINVENTORY)(this, world, player, inventoryName);
+			return reinterpret_cast<Inventory* (__thiscall*)(InventoryManager* self, World* world, Player* player, const msvc_string& inventoryName)>(getFuncAddr((int)Func::InventoryManager::findInventory))(this, world, player, inventoryName);
 		}
 		void updateCraftingMenuBox() 
 		{
-			return reinterpret_cast<void (__thiscall*)(InventoryManager* self)>(FUNC_INVENTORYMANAGER_UPDATECRAFTINGMENUBOX)(this);
+			return reinterpret_cast<void (__thiscall*)(InventoryManager* self)>(getFuncAddr((int)Func::InventoryManager::updateCraftingMenuBox))(this);
 		}
 		inline static bool craftingMenuCallback(int recipeIndex, void* user) 
 		{
-			return reinterpret_cast<bool (__fastcall*)(int recipeIndex, void* user)>(FUNC_INVENTORYMANAGER_CRAFTINGMENUCALLBACK)(recipeIndex, user);
+			return reinterpret_cast<bool (__fastcall*)(int recipeIndex, void* user)>(getFuncAddr((int)Func::InventoryManager::craftingMenuCallback))(recipeIndex, user);
 		}
 		inline static void viewportCallback(void* user, const glm::ivec4& pos, const glm::ivec2& scroll) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(FUNC_INVENTORYMANAGER_VIEWPORTCALLBACK)(user, pos, scroll);
+			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(getFuncAddr((int)Func::InventoryManager::viewportCallback))(user, pos, scroll);
 		}
 		void updateProjection(const glm::ivec2& size, const glm::ivec2& translate2D) 
 		{
-			return reinterpret_cast<void (__thiscall*)(InventoryManager* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(FUNC_INVENTORYMANAGER_UPDATEPROJECTION)(this, size, translate2D);
+			return reinterpret_cast<void (__thiscall*)(InventoryManager* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(getFuncAddr((int)Func::InventoryManager::updateProjection))(this, size, translate2D);
+		}
+		bool isOpen()
+		{
+			return primary && secondary;
 		}
 	};
 }
diff --git a/4dm.h/InventoryPlayer.h b/4dm.h/InventoryPlayer.h
index 6a7f872..594d412 100644
--- a/4dm.h/InventoryPlayer.h
+++ b/4dm.h/InventoryPlayer.h
@@ -12,42 +12,42 @@ namespace fdm
 
 		bool addItem(std::unique_ptr<Item>& item) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(InventoryPlayer* self, std::unique_ptr<Item>& item)>(FUNC_INVENTORYPLAYER_ADDITEM)(this, item);
+			return reinterpret_cast<bool (__thiscall*)(InventoryPlayer* self, std::unique_ptr<Item>& item)>(getFuncAddr((int)Func::InventoryPlayer::addItem))(this, item);
 		}
 		Inventory::iterator begin() override
 		{
 			iterator result;
-			return reinterpret_cast<Inventory::iterator (__thiscall*)(InventoryPlayer* self, Inventory::iterator* result)>(FUNC_INVENTORYPLAYER_BEGIN)(this, &result);
+			return reinterpret_cast<Inventory::iterator& (__thiscall*)(InventoryPlayer* self, Inventory::iterator* result)>(getFuncAddr((int)Func::InventoryPlayer::begin))(this, &result);
 			return result;
 		}
 		void render(const glm::ivec2& cursorPos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(InventoryPlayer* self, const glm::ivec2& cursorPos)>(FUNC_INVENTORYPLAYER_RENDER)(this, cursorPos);
+			return reinterpret_cast<void (__thiscall*)(InventoryPlayer* self, const glm::ivec2& cursorPos)>(getFuncAddr((int)Func::InventoryPlayer::render))(this, cursorPos);
 		}
 		bool combineItem(std::unique_ptr<Item>& item) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(InventoryPlayer* self, std::unique_ptr<Item>& item)>(FUNC_INVENTORYPLAYER_COMBINEITEM)(this, item);
+			return reinterpret_cast<bool (__thiscall*)(InventoryPlayer* self, std::unique_ptr<Item>& item)>(getFuncAddr((int)Func::InventoryPlayer::combineItem))(this, item);
 		}
 		bool placeItem(std::unique_ptr<Item>& item) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(InventoryPlayer* self, std::unique_ptr<Item>& item)>(FUNC_INVENTORYPLAYER_PLACEITEM)(this, item);
+			return reinterpret_cast<bool (__thiscall*)(InventoryPlayer* self, std::unique_ptr<Item>& item)>(getFuncAddr((int)Func::InventoryPlayer::placeItem))(this, item);
 		}
 		int getSlotIndex(const glm::ivec2& cursorPos) override
 		{
-			return reinterpret_cast<int (__thiscall*)(InventoryPlayer* self, const glm::ivec2& cursorPos)>(FUNC_INVENTORYPLAYER_GETSLOTINDEX)(this, cursorPos);
+			return reinterpret_cast<int (__thiscall*)(InventoryPlayer* self, const glm::ivec2& cursorPos)>(getFuncAddr((int)Func::InventoryPlayer::getSlotIndex))(this, cursorPos);
 		}
 		uint32_t getSlotCount() override
 		{
-			return reinterpret_cast<uint32_t (__thiscall*)(InventoryPlayer* self)>(FUNC_INVENTORYPLAYER_GETSLOTCOUNT)(this);
+			return reinterpret_cast<uint32_t (__thiscall*)(InventoryPlayer* self)>(getFuncAddr((int)Func::InventoryPlayer::getSlotCount))(this);
 		}
 		std::unique_ptr<Item>* getSlot(int index) override
 		{
-			return reinterpret_cast<std::unique_ptr<Item>* (__thiscall*)(InventoryPlayer* self, uint32_t index)>(FUNC_INVENTORYPLAYER_GETSLOT)(this, index);
+			return reinterpret_cast<std::unique_ptr<Item>* (__thiscall*)(InventoryPlayer* self, uint32_t index)>(getFuncAddr((int)Func::InventoryPlayer::getSlot))(this, index);
 		}
 		Inventory::iterator end() override
 		{
 			iterator result;
-			return reinterpret_cast<Inventory::iterator (__thiscall*)(InventoryPlayer* self, Inventory::iterator* result)>(FUNC_INVENTORYPLAYER_END)(this, &result);
+			return reinterpret_cast<Inventory::iterator& (__thiscall*)(InventoryPlayer* self, Inventory::iterator* result)>(getFuncAddr((int)Func::InventoryPlayer::end))(this, &result);
 			return result;
 		}
 	};
diff --git a/4dm.h/InventorySession.h b/4dm.h/InventorySession.h
index 2dd301d..2e201d8 100644
--- a/4dm.h/InventorySession.h
+++ b/4dm.h/InventorySession.h
@@ -13,7 +13,7 @@ namespace fdm
 
 		~InventorySession() 
 		{
-			reinterpret_cast<void(__thiscall*)(InventorySession* self)>(FUNC_INVENTORYSESSION_DESTR_INVENTORYSESSION)(this);
+			reinterpret_cast<void(__thiscall*)(InventorySession* self)>(getFuncAddr((int)Func::InventorySession::destr_InventorySession))(this);
 		}
 	};
 }
diff --git a/4dm.h/Item.h b/4dm.h/Item.h
index 8626e4f..76feff8 100644
--- a/4dm.h/Item.h
+++ b/4dm.h/Item.h
@@ -20,59 +20,59 @@ namespace fdm
 
 		inline static bool loadItemInfo() 
 		{
-			return reinterpret_cast<bool (__fastcall*)()>(FUNC_ITEM_LOADITEMINFO)();
+			return reinterpret_cast<bool (__fastcall*)()>(getFuncAddr((int)Func::Item::loadItemInfo))();
 		}
 		inline static void renderItem(std::unique_ptr<Item>& item, const glm::ivec2& pos) 
 		{
-			return reinterpret_cast<void (__fastcall*)(std::unique_ptr<Item>& item, const glm::ivec2& pos)>(FUNC_ITEM_RENDERITEM)(item, pos);
+			return reinterpret_cast<void (__fastcall*)(std::unique_ptr<Item>& item, const glm::ivec2& pos)>(getFuncAddr((int)Func::Item::renderItem))(item, pos);
 		}
 		inline static void renderItemDescription(std::unique_ptr<Item>& item, const glm::ivec2& pos) 
 		{
-			return reinterpret_cast<void (__fastcall*)(std::unique_ptr<Item>& item, const glm::ivec2& pos)>(FUNC_ITEM_RENDERITEMDESCRIPTION)(item, pos);
+			return reinterpret_cast<void (__fastcall*)(std::unique_ptr<Item>& item, const glm::ivec2& pos)>(getFuncAddr((int)Func::Item::renderItemDescription))(item, pos);
 		}
 		inline static std::unique_ptr<Item> createFromJson(nlohmann::json& j) 
 		{
-			return reinterpret_cast<std::unique_ptr<Item> (__fastcall*)(nlohmann::json& j)>(FUNC_ITEM_CREATEFROMJSON)(j);
+			return reinterpret_cast<std::unique_ptr<Item> (__fastcall*)(nlohmann::json& j)>(getFuncAddr((int)Func::Item::createFromJson))(j);
 		}
 		inline static bool giveMax(std::unique_ptr<Item>& from, std::unique_ptr<Item>& to) 
 		{
-			return reinterpret_cast<bool (__fastcall*)(std::unique_ptr<Item>& from, std::unique_ptr<Item>& to)>(FUNC_ITEM_GIVEMAX)(from, to);
+			return reinterpret_cast<bool (__fastcall*)(std::unique_ptr<Item>& from, std::unique_ptr<Item>& to)>(getFuncAddr((int)Func::Item::giveMax))(from, to);
 		}
 		inline static bool giveOne(std::unique_ptr<Item>& from, std::unique_ptr<Item>& to) 
 		{
-			return reinterpret_cast<bool (__fastcall*)(std::unique_ptr<Item>& from, std::unique_ptr<Item>& to)>(FUNC_ITEM_GIVEONE)(from, to);
+			return reinterpret_cast<bool (__fastcall*)(std::unique_ptr<Item>& from, std::unique_ptr<Item>& to)>(getFuncAddr((int)Func::Item::giveOne))(from, to);
 		}
-		inline static std::unique_ptr<Item> instantiateItem(const std::string& itemName, uint32_t count, const std::string& type, nlohmann::json& attributes) 
+		inline static std::unique_ptr<Item> instantiateItem(const msvc_string& itemName, uint32_t count, const msvc_string& type, nlohmann::json& attributes) 
 		{
-			return reinterpret_cast<std::unique_ptr<Item> (__fastcall*)(const std::string& itemName, uint32_t count, const std::string& type, nlohmann::json& attributes)>(FUNC_ITEM_INSTANTIATEITEM)(itemName, count, type, attributes);
+			return reinterpret_cast<std::unique_ptr<Item> (__fastcall*)(const msvc_string& itemName, uint32_t count, const msvc_string& type, nlohmann::json& attributes)>(getFuncAddr((int)Func::Item::instantiateItem))(itemName, count, type, attributes);
 		}
 		inline static nlohmann::json combineItemAttributes(nlohmann::json& baseAttributes, nlohmann::json& additions) 
 		{
-			return reinterpret_cast<nlohmann::json (__fastcall*)(nlohmann::json& baseAttributes, nlohmann::json& additions)>(FUNC_ITEM_COMBINEITEMATTRIBUTES)(baseAttributes, additions);
+			return reinterpret_cast<nlohmann::json (__fastcall*)(nlohmann::json& baseAttributes, nlohmann::json& additions)>(getFuncAddr((int)Func::Item::combineItemAttributes))(baseAttributes, additions);
 		}
 		nlohmann::json save() 
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(Item* self, nlohmann::json* result)>(FUNC_ITEM_SAVE)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(Item* self, nlohmann::json* result)>(getFuncAddr((int)Func::Item::save))(this, &result);
 			return result;
 		}
-		~Item()
+		virtual ~Item()
 		{
-			reinterpret_cast<void(__thiscall*)(Item* self)>(FUNC_ITEM_DESTR_ITEM)(this);
+			reinterpret_cast<void(__thiscall*)(Item* self)>(getFuncAddr((int)Func::Item::destr_Item))(this);
 		}
 		bool takeMax(std::unique_ptr<Item>& other) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Item* self, std::unique_ptr<Item>& other)>(FUNC_ITEM_TAKEMAX)(this, other);
+			return reinterpret_cast<bool (__thiscall*)(Item* self, std::unique_ptr<Item>& other)>(getFuncAddr((int)Func::Item::takeMax))(this, other);
 		}
 		bool takeHalf(std::unique_ptr<Item>& other) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Item* self, std::unique_ptr<Item>& other)>(FUNC_ITEM_TAKEHALF)(this, other);
+			return reinterpret_cast<bool (__thiscall*)(Item* self, std::unique_ptr<Item>& other)>(getFuncAddr((int)Func::Item::takeHalf))(this, other);
 		}
 
 
 		// VIRTUAL FUNCS
 
-		virtual std::string getName() { return ""; }
+		virtual msvc_string getName() { return ""; }
 		virtual void render(const glm::ivec2& pos) {}
 		virtual void renderEntity(const m4::Mat5& MV, bool inHand, const glm::vec4& lightDir) {}
 		virtual bool isDeadly() { return false; }
diff --git a/4dm.h/ItemBlock.h b/4dm.h/ItemBlock.h
index ad82448..f3f1516 100644
--- a/4dm.h/ItemBlock.h
+++ b/4dm.h/ItemBlock.h
@@ -14,37 +14,37 @@ namespace fdm
 
 		void render(const glm::ivec2& pos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(ItemBlock* self, const glm::ivec2& pos)>(FUNC_ITEMBLOCK_RENDER)(this, pos);
+			return reinterpret_cast<void (__thiscall*)(ItemBlock* self, const glm::ivec2& pos)>(getFuncAddr((int)Func::ItemBlock::render))(this, pos);
 		}
 		void renderEntity(const m4::Mat5& MV, bool inHand, const glm::vec4& lightDir) override
 		{
-			return reinterpret_cast<void (__thiscall*)(ItemBlock* self, const m4::Mat5& MV, bool inHand, const glm::vec4& lightDir)>(FUNC_ITEMBLOCK_RENDERENTITY)(this, MV, inHand, lightDir);
+			return reinterpret_cast<void (__thiscall*)(ItemBlock* self, const m4::Mat5& MV, bool inHand, const glm::vec4& lightDir)>(getFuncAddr((int)Func::ItemBlock::renderEntity))(this, MV, inHand, lightDir);
 		}
 		bool isDeadly() override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemBlock* self)>(FUNC_ITEMBLOCK_ISDEADLY)(this);
+			return reinterpret_cast<bool (__thiscall*)(ItemBlock* self)>(getFuncAddr((int)Func::ItemBlock::isDeadly))(this);
 		}
 		bool isCompatible(const std::unique_ptr<Item>& other) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemBlock* self, const std::unique_ptr<Item>& other)>(FUNC_ITEMBLOCK_ISCOMPATIBLE)(this, other);
+			return reinterpret_cast<bool (__thiscall*)(ItemBlock* self, const std::unique_ptr<Item>& other)>(getFuncAddr((int)Func::ItemBlock::isCompatible))(this, other);
 		}
 		nlohmann::json saveAttributes() override
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(ItemBlock* self, nlohmann::json* result)>(FUNC_ITEMBLOCK_SAVEATTRIBUTES)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(ItemBlock* self, nlohmann::json* result)>(getFuncAddr((int)Func::ItemBlock::saveAttributes))(this, &result);
 		}
 		bool action(World* world, Player* player, int action) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemBlock* self, World* world, Player* player, int action)>(FUNC_ITEMBLOCK_ACTION)(this, world, player, action);
+			return reinterpret_cast<bool (__thiscall*)(ItemBlock* self, World* world, Player* player, int action)>(getFuncAddr((int)Func::ItemBlock::action))(this, world, player, action);
 		}
 		void postAction(World* world, Player* player, int action) override
 		{
-			return reinterpret_cast<void (__thiscall*)(ItemBlock* self, World* world, Player* player, int action)>(FUNC_ITEMBLOCK_POSTACTION)(this, world, player, action);
+			return reinterpret_cast<void (__thiscall*)(ItemBlock* self, World* world, Player* player, int action)>(getFuncAddr((int)Func::ItemBlock::postAction))(this, world, player, action);
 		}
 		std::unique_ptr<Item> clone() override
 		{
 			std::unique_ptr<Item> item;
-			return reinterpret_cast<std::unique_ptr<Item> (__thiscall*)(ItemBlock* self, std::unique_ptr<Item>* result)>(FUNC_ITEMBLOCK_CLONE)(this, &item);
+			return reinterpret_cast<std::unique_ptr<Item> (__thiscall*)(ItemBlock* self, std::unique_ptr<Item>* result)>(getFuncAddr((int)Func::ItemBlock::clone))(this, &item);
 		}
 	};
 }
diff --git a/4dm.h/ItemMaterial.h b/4dm.h/ItemMaterial.h
index 2c2f02c..01f4c1d 100644
--- a/4dm.h/ItemMaterial.h
+++ b/4dm.h/ItemMaterial.h
@@ -8,9 +8,9 @@ namespace fdm
 	{
 	public:
 		inline static const int STACK_MAX = 4096; 
-		std::string name; // 0x10
+		msvc_string name; // 0x10
 		inline static TexRenderer* tr = reinterpret_cast<TexRenderer*>((base + 0x2BF0A8));
-		inline static glm::u8vec4** barTUV = reinterpret_cast<glm::u8vec4**>((base + 0x2AD220));
+		inline static glm::u8vec4* barTUV = reinterpret_cast<glm::u8vec4*>((base + 0x2AD220));
 		inline static MeshRenderer *hypersilkRenderer = reinterpret_cast<MeshRenderer*>((base + 0x2795C0)); 
 		inline static MeshRenderer *rockRenderer = reinterpret_cast<MeshRenderer*>((base + 0x2795E0)); 
 		inline static MeshRenderer *barRenderer = reinterpret_cast<MeshRenderer*>((base + 0x279580)); 
@@ -21,41 +21,42 @@ namespace fdm
 
 		uint32_t getStackLimit() override
 		{
-			return reinterpret_cast<uint32_t (__thiscall*)(ItemMaterial* self)>(FUNC_ITEMMATERIAL_GETSTACKLIMIT)(this);
+			return reinterpret_cast<uint32_t (__thiscall*)(ItemMaterial* self)>(getFuncAddr((int)Func::ItemMaterial::getStackLimit))(this);
 		}
-		std::string getName() override
+		msvc_string getName() override
 		{
-			std::string result;
-			return reinterpret_cast<std::string (__thiscall*)(ItemMaterial* self, std::string* result)>(FUNC_ITEMMATERIAL_GETNAME)(this, &result);
+			msvc_string result;
+			return reinterpret_cast<msvc_string& (__thiscall*)(ItemMaterial* self, msvc_string* result)>(getFuncAddr((int)Func::ItemMaterial::getName))(this, &result);
 		}
 		void render(const glm::ivec2& pos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(ItemMaterial* self, const glm::ivec2& pos)>(FUNC_ITEMMATERIAL_RENDER)(this, pos);
+			return reinterpret_cast<void (__thiscall*)(ItemMaterial* self, const glm::ivec2& pos)>(getFuncAddr((int)Func::ItemMaterial::render))(this, pos);
 		}
 		void renderEntity(const m4::Mat5& MV, bool inHand, const glm::vec4& lightDir) override
 		{
-			return reinterpret_cast<void (__thiscall*)(ItemMaterial* self, const m4::Mat5 & MV, bool inHand, const glm::vec4 & lightDir)>(FUNC_ITEMMATERIAL_RENDERENTITY)(this, MV, inHand, lightDir);
+			return reinterpret_cast<void (__thiscall*)(ItemMaterial* self, const m4::Mat5 & MV, bool inHand, const glm::vec4 & lightDir)>(getFuncAddr((int)Func::ItemMaterial::renderEntity))(this, MV, inHand, lightDir);
 		}
 		bool isDeadly() override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemMaterial* self)>(FUNC_ITEMMATERIAL_ISDEADLY)(this);
+			return reinterpret_cast<bool (__thiscall*)(ItemMaterial* self)>(getFuncAddr((int)Func::ItemMaterial::isDeadly))(this);
 		}
 		bool isCompatible(const std::unique_ptr<Item>& other) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemMaterial* self, const std::unique_ptr<Item>& other)>(FUNC_ITEMMATERIAL_ISCOMPATIBLE)(this, other);
+			return reinterpret_cast<bool (__thiscall*)(ItemMaterial* self, const std::unique_ptr<Item>& other)>(getFuncAddr((int)Func::ItemMaterial::isCompatible))(this, other);
 		}
 		bool action(World* world, Player* player, int action) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemMaterial* self, World* world, Player* player, int action)>(FUNC_ITEMMATERIAL_ACTION)(this, world, player, action);
+			return reinterpret_cast<bool (__thiscall*)(ItemMaterial* self, World* world, Player* player, int action)>(getFuncAddr((int)Func::ItemMaterial::action))(this, world, player, action);
 		}
 		void postAction(World* world, Player* player, int action) override
 		{
-			return reinterpret_cast<void (__thiscall*)(ItemMaterial* self, World* world, Player* player, int action)>(FUNC_ITEMMATERIAL_POSTACTION)(this, world, player, action);
+			return reinterpret_cast<void (__thiscall*)(ItemMaterial* self, World* world, Player* player, int action)>(getFuncAddr((int)Func::ItemMaterial::postAction))(this, world, player, action);
 		}
 		std::unique_ptr<Item> clone() override
 		{
 			std::unique_ptr<Item> result;
-			return reinterpret_cast<std::unique_ptr<Item> (__thiscall*)(ItemMaterial* self, std::unique_ptr<Item>* result)>(FUNC_ITEMMATERIAL_CLONE)(this, &result);
+			reinterpret_cast<std::unique_ptr<Item>* (__thiscall*)(ItemMaterial* self, std::unique_ptr<Item>* result)>(getFuncAddr((int)Func::ItemMaterial::clone))(this, &result);
+			return result;
 		}
 	};
 }
diff --git a/4dm.h/ItemTool.h b/4dm.h/ItemTool.h
index dce943f..1075403 100644
--- a/4dm.h/ItemTool.h
+++ b/4dm.h/ItemTool.h
@@ -7,14 +7,14 @@ namespace fdm
 	class ItemTool : public Item 
 	{
 	public:
-		std::string name; // 0x10
+		msvc_string name; // 0x10
 		inline static const float scaleFactor = 0.15f; 
-		inline static glm::vec4* *pickaxeVerts = reinterpret_cast<glm::vec4**>((base + 0x29B600)); 
-		inline static glm::vec4* *pickaxeNormals = reinterpret_cast<glm::vec4**>((base + 0x29BC40)); 
-		inline static glm::vec3* *ironPickTUV = reinterpret_cast<glm::vec3**>((base + 0x29BA60)); 
-		inline static glm::vec3* *deadlyPickTUV = reinterpret_cast<glm::vec3**>((base + 0x29B880)); 
-		inline static glm::u8vec4* *ultrahammerTUV = reinterpret_cast<glm::u8vec4**>((base + 0x2AF3F0)); 
-		inline static glm::u8vec4* *solenoidCollectorTUV = reinterpret_cast<glm::u8vec4**>((base + 0x2AF2F0)); 
+		inline static glm::vec4* pickaxeVerts = reinterpret_cast<glm::vec4*>((base + 0x29B600)); 
+		inline static glm::vec4* pickaxeNormals = reinterpret_cast<glm::vec4*>((base + 0x29BC40)); 
+		inline static glm::vec3* ironPickTUV = reinterpret_cast<glm::vec3*>((base + 0x29BA60)); 
+		inline static glm::vec3* deadlyPickTUV = reinterpret_cast<glm::vec3*>((base + 0x29B880)); 
+		inline static glm::u8vec4* ultrahammerTUV = reinterpret_cast<glm::u8vec4*>((base + 0x2AF3F0)); 
+		inline static glm::u8vec4* solenoidCollectorTUV = reinterpret_cast<glm::u8vec4*>((base + 0x2AF2F0)); 
 		inline static MeshRenderer *ironPickaxeRenderer = reinterpret_cast<MeshRenderer*>((base + 0x279D68)); 
 		inline static MeshRenderer *deadlyPickaxeRenderer = reinterpret_cast<MeshRenderer*>((base + 0x279D88)); 
 		inline static MeshRenderer *rockRenderer = reinterpret_cast<MeshRenderer*>((base + 0x279E48)); 
@@ -29,40 +29,41 @@ namespace fdm
 
 		void render(const glm::ivec2& pos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(ItemTool* self, const glm::ivec2& pos)>(FUNC_ITEMTOOL_RENDER)(this, pos);
+			return reinterpret_cast<void (__thiscall*)(ItemTool* self, const glm::ivec2& pos)>(getFuncAddr((int)Func::ItemTool::render))(this, pos);
 		}
 		void renderEntity(const m4::Mat5& mat, bool inHand, const glm::vec4& lightDir) override
 		{
-			return reinterpret_cast<void (__thiscall*)(ItemTool* self, const m4::Mat5& mat, bool inHand, const glm::vec4& lightDir)>(FUNC_ITEMTOOL_RENDERENTITY)(this, mat, inHand, lightDir);
+			return reinterpret_cast<void (__thiscall*)(ItemTool* self, const m4::Mat5& mat, bool inHand, const glm::vec4& lightDir)>(getFuncAddr((int)Func::ItemTool::renderEntity))(this, mat, inHand, lightDir);
 		}
 		bool isDeadly() override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemTool* self)>(FUNC_ITEMTOOL_ISDEADLY)(this);
+			return reinterpret_cast<bool (__thiscall*)(ItemTool* self)>(getFuncAddr((int)Func::ItemTool::isDeadly))(this);
 		}
 		bool isCompatible(const std::unique_ptr<Item>& other) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemTool* self, const std::unique_ptr<Item>& other)>(FUNC_ITEMTOOL_ISCOMPATIBLE)(this, other);
+			return reinterpret_cast<bool (__thiscall*)(ItemTool* self, const std::unique_ptr<Item>& other)>(getFuncAddr((int)Func::ItemTool::isCompatible))(this, other);
 		}
 		uint32_t getStackLimit() override
 		{
-			return reinterpret_cast<uint32_t (__thiscall*)(ItemTool* self)>(FUNC_ITEMTOOL_GETSTACKLIMIT)(this);
+			return reinterpret_cast<uint32_t (__thiscall*)(ItemTool* self)>(getFuncAddr((int)Func::ItemTool::getStackLimit))(this);
 		}
 		bool action(World* world, Player* player, int action) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemTool* self, World* world, Player* player, int action)>(FUNC_ITEMTOOL_ACTION)(this, world, player, action);
+			return reinterpret_cast<bool (__thiscall*)(ItemTool* self, World* world, Player* player, int action)>(getFuncAddr((int)Func::ItemTool::action))(this, world, player, action);
 		}
 		bool breakBlock(World* world, Player* player, unsigned char block, const glm::ivec4& blockPos) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemTool* self, World* world, Player* player, unsigned char block, const glm::ivec4& blockPos)>(FUNC_ITEMTOOL_BREAKBLOCK)(this, world, player, block, blockPos);
+			return reinterpret_cast<bool (__thiscall*)(ItemTool* self, World* world, Player* player, unsigned char block, const glm::ivec4& blockPos)>(getFuncAddr((int)Func::ItemTool::breakBlock))(this, world, player, block, blockPos);
 		}
 		bool entityAction(World* world, Player* player, Entity* entity, int action) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(ItemTool* self, World* world, Player* player, Entity* entity, int action)>(FUNC_ITEMTOOL_ENTITYACTION)(this, world, player, entity, action);
+			return reinterpret_cast<bool (__thiscall*)(ItemTool* self, World* world, Player* player, Entity* entity, int action)>(getFuncAddr((int)Func::ItemTool::entityAction))(this, world, player, entity, action);
 		}
 		std::unique_ptr<Item> clone() override
 		{
 			std::unique_ptr<Item> result;
-			return reinterpret_cast<std::unique_ptr<Item> (__thiscall*)(ItemTool* self, std::unique_ptr<Item>* result)>(FUNC_ITEMTOOL_CLONE)(this, &result);
+			reinterpret_cast<std::unique_ptr<Item>* (__thiscall*)(ItemTool* self, std::unique_ptr<Item>* result)>(getFuncAddr((int)Func::ItemTool::clone))(this, &result);
+			return result;
 		}
 	};
 }
diff --git a/4dm.h/KleinBottle.h b/4dm.h/KleinBottle.h
index ad0aa74..40e38f2 100644
--- a/4dm.h/KleinBottle.h
+++ b/4dm.h/KleinBottle.h
@@ -12,23 +12,23 @@ namespace fdm
 
 		const void* buffData(int buffIndex) const override
 		{
-			return reinterpret_cast<const void* (__thiscall*)(const KleinBottle* self, int buffIndex)>(FUNC_KLEINBOTTLE_BUFFDATA)(this, buffIndex);
+			return reinterpret_cast<const void* (__thiscall*)(const KleinBottle* self, int buffIndex)>(getFuncAddr((int)Func::KleinBottle::buffData))(this, buffIndex);
 		}
 		int attrSize(int buffIndex, int attrIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const KleinBottle* self, int buffIndex, int attrIndex)>(FUNC_KLEINBOTTLE_ATTRSIZE)(this, buffIndex, attrIndex);
+			return reinterpret_cast<int (__thiscall*)(const KleinBottle* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::KleinBottle::attrSize))(this, buffIndex, attrIndex);
 		}
 		KleinBottle(int edges, float tubeRaduis, float tubeCenterRadius, const glm::vec3& colorA, const glm::vec3& colorB) 
 		{
-			reinterpret_cast<void(__thiscall*)(KleinBottle* self, int edges, float tubeRaduis, float tubeCenterRadius, const glm::vec3& colorA, const glm::vec3& colorB)>(FUNC_KLEINBOTTLE_KLEINBOTTLE)(this, edges, tubeRaduis, tubeCenterRadius, colorA, colorB);
+			reinterpret_cast<void(__thiscall*)(KleinBottle* self, int edges, float tubeRaduis, float tubeCenterRadius, const glm::vec3& colorA, const glm::vec3& colorB)>(getFuncAddr((int)Func::KleinBottle::KleinBottle))(this, edges, tubeRaduis, tubeCenterRadius, colorA, colorB);
 		}
 		int buffSize(int buffIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const KleinBottle* self, int buffIndex)>(FUNC_KLEINBOTTLE_BUFFSIZE)(this, buffIndex);
+			return reinterpret_cast<int (__thiscall*)(const KleinBottle* self, int buffIndex)>(getFuncAddr((int)Func::KleinBottle::buffSize))(this, buffIndex);
 		}
 		~KleinBottle() 
 		{
-			reinterpret_cast<void(__thiscall*)(KleinBottle* self)>(FUNC_KLEINBOTTLE_DESTR_KLEINBOTTLE)(this);
+			reinterpret_cast<void(__thiscall*)(KleinBottle* self)>(getFuncAddr((int)Func::KleinBottle::destr_KleinBottle))(this);
 		}
 	};
 }
diff --git a/4dm.h/LICENSE b/4dm.h/LICENSE
new file mode 100644
index 0000000..f288702
--- /dev/null
+++ b/4dm.h/LICENSE
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
diff --git a/4dm.h/MeshBuilder.h b/4dm.h/MeshBuilder.h
index 68185c2..6749784 100644
--- a/4dm.h/MeshBuilder.h
+++ b/4dm.h/MeshBuilder.h
@@ -138,4 +138,4 @@ namespace fdm
 			indexBufferSize = 0;
 		}
 	};
-}
\ No newline at end of file
+}
diff --git a/4dm.h/MeshRenderer.h b/4dm.h/MeshRenderer.h
index 9fd0876..4f2b813 100644
--- a/4dm.h/MeshRenderer.h
+++ b/4dm.h/MeshRenderer.h
@@ -17,35 +17,35 @@ namespace fdm
 
 		MeshRenderer() 
 		{
-			reinterpret_cast<void(__thiscall*)(MeshRenderer* self)>(FUNC_MESHRENDERER_MESHRENDERER)(this);
+			reinterpret_cast<void(__thiscall*)(MeshRenderer* self)>(getFuncAddr((int)Func::MeshRenderer::MeshRenderer))(this);
 		}
 		void setMesh(Mesh* mesh) 
 		{
-			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self, Mesh* mesh)>(FUNC_MESHRENDERER_SETMESH)(this, mesh);
+			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self, Mesh* mesh)>(getFuncAddr((int)Func::MeshRenderer::setMesh))(this, mesh);
 		}
 		void updateMesh(Mesh* mesh) 
 		{
-			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self, Mesh* mesh)>(FUNC_MESHRENDERER_UPDATEMESH)(this, mesh);
+			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self, Mesh* mesh)>(getFuncAddr((int)Func::MeshRenderer::updateMesh))(this, mesh);
 		}
 		~MeshRenderer() 
 		{
-			reinterpret_cast<void(__thiscall*)(MeshRenderer* self)>(FUNC_MESHRENDERER_DESTR_MESHRENDERER)(this);
+			reinterpret_cast<void(__thiscall*)(MeshRenderer* self)>(getFuncAddr((int)Func::MeshRenderer::destr_MeshRenderer))(this);
 		}
 		void render() 
 		{
-			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self)>(FUNC_MESHRENDERER_RENDER)(this);
+			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self)>(getFuncAddr((int)Func::MeshRenderer::render))(this);
 		}
 		void init(Mesh* mesh) 
 		{
-			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self, Mesh* mesh)>(FUNC_MESHRENDERER_INIT)(this, mesh);
+			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self, Mesh* mesh)>(getFuncAddr((int)Func::MeshRenderer::init))(this, mesh);
 		}
 		void cleanup() 
 		{
-			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self)>(FUNC_MESHRENDERER_CLEANUP)(this);
+			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self)>(getFuncAddr((int)Func::MeshRenderer::cleanup))(this);
 		}
 		void initAttrs(Mesh* mesh) 
 		{
-			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self, Mesh* mesh)>(FUNC_MESHRENDERER_INITATTRS)(this, mesh);
+			return reinterpret_cast<void (__thiscall*)(MeshRenderer* self, Mesh* mesh)>(getFuncAddr((int)Func::MeshRenderer::initAttrs))(this, mesh);
 		}
 	};
 }
diff --git a/4dm.h/PentachoronHollow.h b/4dm.h/PentachoronHollow.h
index 19d1c7b..d81cb90 100644
--- a/4dm.h/PentachoronHollow.h
+++ b/4dm.h/PentachoronHollow.h
@@ -17,23 +17,23 @@ namespace fdm
 
 		const void* buffData(int buffIndex) const override
 		{
-			return reinterpret_cast<const void* (__thiscall*)(const PentachoronHollow* self, int buffIndex)>(FUNC_PENTACHORONHOLLOW_BUFFDATA)(this, buffIndex);
+			return reinterpret_cast<const void* (__thiscall*)(const PentachoronHollow* self, int buffIndex)>(getFuncAddr((int)Func::PentachoronHollow::buffData))(this, buffIndex);
 		}
 		PentachoronHollow(float distance) 
 		{
-			reinterpret_cast<void(__thiscall*)(PentachoronHollow* self, float distance)>(FUNC_PENTACHORONHOLLOW_PENTACHORONHOLLOW)(this, distance);
+			reinterpret_cast<void(__thiscall*)(PentachoronHollow* self, float distance)>(getFuncAddr((int)Func::PentachoronHollow::PentachoronHollow))(this, distance);
 		}
 		int buffSize(int buffIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const PentachoronHollow* self, int buffIndex)>(FUNC_PENTACHORONHOLLOW_BUFFSIZE)(this, buffIndex);
+			return reinterpret_cast<int (__thiscall*)(const PentachoronHollow* self, int buffIndex)>(getFuncAddr((int)Func::PentachoronHollow::buffSize))(this, buffIndex);
 		}
 		int vertCount() const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const PentachoronHollow* self)>(FUNC_PENTACHORONHOLLOW_VERTCOUNT)(this);
+			return reinterpret_cast<int (__thiscall*)(const PentachoronHollow* self)>(getFuncAddr((int)Func::PentachoronHollow::vertCount))(this);
 		}
 		void addTetSide(const glm::vec4& simp_ptr, const glm::vec4& inner, int i0, int i1, int i2) 
 		{
-			return reinterpret_cast<void (__thiscall*)(PentachoronHollow* self, const glm::vec4& simp_ptr, const glm::vec4& inner, int i0, int i1, int i2)>(FUNC_PENTACHORONHOLLOW_ADDTETSIDE)(this, simp_ptr, inner, i0, i1, i2);
+			return reinterpret_cast<void (__thiscall*)(PentachoronHollow* self, const glm::vec4& simp_ptr, const glm::vec4& inner, int i0, int i1, int i2)>(getFuncAddr((int)Func::PentachoronHollow::addTetSide))(this, simp_ptr, inner, i0, i1, i2);
 		}
 	};
 }
diff --git a/4dm.h/Player.h b/4dm.h/Player.h
index 6f949f4..43feaba 100644
--- a/4dm.h/Player.h
+++ b/4dm.h/Player.h
@@ -15,6 +15,7 @@ namespace fdm
 	class InventoryGrid;
 	class InventoryManager;
 	class InventoryPlayer;
+	class m4::Mat5;
 	class MeshRenderer;
 	class TexRenderer;
 	class FontRenderer;
@@ -122,147 +123,147 @@ namespace fdm
 
 		~Player() 
 		{
-			reinterpret_cast<void(__thiscall*)(Player* self)>(FUNC_PLAYER_DESTR_PLAYER)(this);
+			reinterpret_cast<void(__thiscall*)(Player* self)>(getFuncAddr((int)Func::Player::destr_Player))(this);
 		}
 		Player() 
 		{
-			reinterpret_cast<void(__thiscall*)(Player* self)>(FUNC_PLAYER_PLAYER)(this);
+			reinterpret_cast<void(__thiscall*)(Player* self)>(getFuncAddr((int)Func::Player::Player))(this);
 		}
 		void updatePos(World* world, double dt) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, double dt)>(FUNC_PLAYER_UPDATEPOS)(this, world, dt);
+			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, double dt)>(getFuncAddr((int)Func::Player::updatePos))(this, world, dt);
 		}
 		void updateCurrentBlock() 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self)>(FUNC_PLAYER_UPDATECURRENTBLOCK)(this);
+			return reinterpret_cast<void (__thiscall*)(Player* self)>(getFuncAddr((int)Func::Player::updateCurrentBlock))(this);
 		}
 		void handleCollision(World* world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, World* world)>(FUNC_PLAYER_HANDLECOLLISION)(this, world);
+			return reinterpret_cast<void (__thiscall*)(Player* self, World* world)>(getFuncAddr((int)Func::Player::handleCollision))(this, world);
 		}
 		void updateComponentVectors() 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self)>(FUNC_PLAYER_UPDATECOMPONENTVECTORS)(this);
+			return reinterpret_cast<void (__thiscall*)(Player* self)>(getFuncAddr((int)Func::Player::updateComponentVectors))(this);
 		}
 		void updateAllComponentVectors() 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self)>(FUNC_PLAYER_UPDATEALLCOMPONENTVECTORS)(this);
+			return reinterpret_cast<void (__thiscall*)(Player* self)>(getFuncAddr((int)Func::Player::updateAllComponentVectors))(this);
 		}
 		void removeVelComp(uint32_t comp) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, uint32_t comp)>(FUNC_PLAYER_REMOVEVELCOMP)(this, comp);
+			return reinterpret_cast<void (__thiscall*)(Player* self, uint32_t comp)>(getFuncAddr((int)Func::Player::removeVelComp))(this, comp);
 		}
 		void updateTargetBlock(World* world, float maxDist) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, float maxDist)>(FUNC_PLAYER_UPDATETARGETBLOCK)(this, world, maxDist);
+			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, float maxDist)>(getFuncAddr((int)Func::Player::updateTargetBlock))(this, world, maxDist);
 		}
 		void init(const glm::ivec4& spawnPoint) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, const glm::ivec4& spawnPoint)>(FUNC_PLAYER_INIT)(this, spawnPoint);
+			return reinterpret_cast<void (__thiscall*)(Player* self, const glm::ivec4& spawnPoint)>(getFuncAddr((int)Func::Player::init))(this, spawnPoint);
 		}
 		void renderHud(GLFWwindow* window) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, GLFWwindow* window)>(FUNC_PLAYER_RENDERHUD)(this, window);
+			return reinterpret_cast<void (__thiscall*)(Player* self, GLFWwindow* window)>(getFuncAddr((int)Func::Player::renderHud))(this, window);
 		}
 		void renderTargetBlock(const m4::Mat5& MV, bool renderBG) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, const m4::Mat5& MV, bool renderBG)>(FUNC_PLAYER_RENDERTARGETBLOCK)(this, MV, renderBG);
+			return reinterpret_cast<void (__thiscall*)(Player* self, const m4::Mat5& MV, bool renderBG)>(getFuncAddr((int)Func::Player::renderTargetBlock))(this, MV, renderBG);
 		}
 		nlohmann::json getMovementUpdate() 
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(Player* self, nlohmann::json* result)>(FUNC_PLAYER_GETMOVEMENTUPDATE)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(Player* self, nlohmann::json* result)>(getFuncAddr((int)Func::Player::getMovementUpdate))(this, &result);
 		}
 		void setMovementBehavior(nlohmann::json& movementKeys, bool keepOnEdge) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, nlohmann::json& movementKeys, bool keepOnEdge)>(FUNC_PLAYER_SETMOVEMENTBEHAVIOR)(this, movementKeys, keepOnEdge);
+			return reinterpret_cast<void (__thiscall*)(Player* self, nlohmann::json& movementKeys, bool keepOnEdge)>(getFuncAddr((int)Func::Player::setMovementBehavior))(this, movementKeys, keepOnEdge);
 		}
 		void hitTargetBlock(World* world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, World* world)>(FUNC_PLAYER_HITTARGETBLOCK)(this, world);
+			return reinterpret_cast<void (__thiscall*)(Player* self, World* world)>(getFuncAddr((int)Func::Player::hitTargetBlock))(this, world);
 		}
 		bool breakBlock(World* world) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Player* self, World* world)>(FUNC_PLAYER_BREAKBLOCK)(this, world);
+			return reinterpret_cast<bool (__thiscall*)(Player* self, World* world)>(getFuncAddr((int)Func::Player::breakBlock))(this, world);
 		}
 		void throwItem(World* world, std::unique_ptr<Item>& item, uint32_t maxCount) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, std::unique_ptr<Item>& item, uint32_t maxCount)>(FUNC_PLAYER_THROWITEM)(this, world, item, maxCount);
+			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, std::unique_ptr<Item>& item, uint32_t maxCount)>(getFuncAddr((int)Func::Player::throwItem))(this, world, item, maxCount);
 		}
 		void update(World* world, double dt, EntityPlayer* entityPlayer) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, double dt, EntityPlayer* entityPlayer)>(FUNC_PLAYER_UPDATE)(this, world, dt, entityPlayer);
+			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, double dt, EntityPlayer* entityPlayer)>(getFuncAddr((int)Func::Player::update))(this, world, dt, entityPlayer);
 		}
 		void updateLocal(World* world, double dt, GLFWwindow* window) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, double dt, GLFWwindow* window)>(FUNC_PLAYER_UPDATELOCAL)(this, world, dt, window);
+			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, double dt, GLFWwindow* window)>(getFuncAddr((int)Func::Player::updateLocal))(this, world, dt, window);
 		}
 		void updateCameraPos(World* world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, World* world)>(FUNC_PLAYER_UPDATECAMERAPOS)(this, world);
+			return reinterpret_cast<void (__thiscall*)(Player* self, World* world)>(getFuncAddr((int)Func::Player::updateCameraPos))(this, world);
 		}
 		void resetMouse(GLFWwindow* window) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, GLFWwindow* window)>(FUNC_PLAYER_RESETMOUSE)(this, window);
+			return reinterpret_cast<void (__thiscall*)(Player* self, GLFWwindow* window)>(getFuncAddr((int)Func::Player::resetMouse))(this, window);
 		}
 		bool keyInput(GLFWwindow* window, World* world, int key, int scancode, int action, char mods) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Player* self, GLFWwindow* window, World* world, int key, int scancode, int action, char mods)>(FUNC_PLAYER_KEYINPUT)(this, window, world, key, scancode, action, mods);
+			return reinterpret_cast<bool (__thiscall*)(Player* self, GLFWwindow* window, World* world, int key, int scancode, int action, char mods)>(getFuncAddr((int)Func::Player::keyInput))(this, window, world, key, scancode, action, mods);
 		}
 		void mouseInput(GLFWwindow* window, World* world, double xpos, double ypos) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, GLFWwindow* window, World* world, double xpos, double ypos)>(FUNC_PLAYER_MOUSEINPUT)(this, window, world, xpos, ypos);
+			return reinterpret_cast<void (__thiscall*)(Player* self, GLFWwindow* window, World* world, double xpos, double ypos)>(getFuncAddr((int)Func::Player::mouseInput))(this, window, world, xpos, ypos);
 		}
 		void mouseButtonInput(GLFWwindow* window, World* world, int button, int action, int mods) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, GLFWwindow* window, World* world, int button, int action, int mods)>(FUNC_PLAYER_MOUSEBUTTONINPUT)(this, window, world, button, action, mods);
+			return reinterpret_cast<void (__thiscall*)(Player* self, GLFWwindow* window, World* world, int button, int action, int mods)>(getFuncAddr((int)Func::Player::mouseButtonInput))(this, window, world, button, action, mods);
 		}
 		bool isHoldingGlasses() 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Player* self)>(FUNC_PLAYER_ISHOLDINGGLASSES)(this);
+			return reinterpret_cast<bool (__thiscall*)(Player* self)>(getFuncAddr((int)Func::Player::isHoldingGlasses))(this);
 		}
 		bool isHoldingCompass() 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Player* self)>(FUNC_PLAYER_ISHOLDINGCOMPASS)(this);
+			return reinterpret_cast<bool (__thiscall*)(Player* self)>(getFuncAddr((int)Func::Player::isHoldingCompass))(this);
 		}
 		bool isHoldingCollector() 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Player* self)>(FUNC_PLAYER_ISHOLDINGCOLLECTOR)(this);
+			return reinterpret_cast<bool (__thiscall*)(Player* self)>(getFuncAddr((int)Func::Player::isHoldingCollector))(this);
 		}
 		bool headIsInBlock() 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Player* self)>(FUNC_PLAYER_HEADISINBLOCK)(this);
+			return reinterpret_cast<bool (__thiscall*)(Player* self)>(getFuncAddr((int)Func::Player::headIsInBlock))(this);
 		}
 		uint32_t getHeadBlock() 
 		{
-			return reinterpret_cast<uint32_t (__thiscall*)(Player* self)>(FUNC_PLAYER_GETHEADBLOCK)(this);
+			return reinterpret_cast<uint32_t (__thiscall*)(Player* self)>(getFuncAddr((int)Func::Player::getHeadBlock))(this);
 		}
 		void respawn(World* world, const glm::ivec4& spawnPoint) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, const glm::ivec4& spawnPoint)>(FUNC_PLAYER_RESPAWN)(this, world, spawnPoint);
+			return reinterpret_cast<void (__thiscall*)(Player* self, World* world, const glm::ivec4& spawnPoint)>(getFuncAddr((int)Func::Player::respawn))(this, world, spawnPoint);
 		}
 		void load(nlohmann::json& j) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, nlohmann::json& j)>(FUNC_PLAYER_LOAD)(this, j);
+			return reinterpret_cast<void (__thiscall*)(Player* self, nlohmann::json& j)>(getFuncAddr((int)Func::Player::load))(this, j);
 		}
 		nlohmann::json save() 
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(Player* self, nlohmann::json* result)>(FUNC_PLAYER_SAVE)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(Player* self, nlohmann::json* result)>(getFuncAddr((int)Func::Player::save))(this, &result);
 		}
 		void loadClientData(nlohmann::json& j) 
 		{
-			return reinterpret_cast<void (__thiscall*)(Player* self, nlohmann::json& j)>(FUNC_PLAYER_LOADCLIENTDATA)(this, j);
+			return reinterpret_cast<void (__thiscall*)(Player* self, nlohmann::json& j)>(getFuncAddr((int)Func::Player::loadClientData))(this, j);
 		}
 		nlohmann::json saveClientData() 
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(Player* self, nlohmann::json* result)>(FUNC_PLAYER_SAVECLIENTDATA)(this, &result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(Player* self, nlohmann::json* result)>(getFuncAddr((int)Func::Player::saveClientData))(this, &result);
 		}
 		nlohmann::json saveOrientation() 
 		{
 			nlohmann::json result;
-			return reinterpret_cast<nlohmann::json (__thiscall*)(Player* self, nlohmann::json* result)>(FUNC_PLAYER_SAVEORIENTATION)(this,& result);
+			return reinterpret_cast<nlohmann::json& (__thiscall*)(Player* self, nlohmann::json* result)>(getFuncAddr((int)Func::Player::saveOrientation))(this, &result);
 		}
 	};
 }
diff --git a/4dm.h/PlayerSkin.h b/4dm.h/PlayerSkin.h
index 23f2d9a..5c61722 100644
--- a/4dm.h/PlayerSkin.h
+++ b/4dm.h/PlayerSkin.h
@@ -7,6 +7,20 @@ namespace fdm
 	class PlayerSkin 
 	{
 	public:
+		enum MeshComp
+		{
+			HEAD = 0x0,
+			TORSO = 0x1,
+			UPPER_ARM_L = 0x2,
+			UPPER_ARM_R = 0x3,
+			FOREARM_L = 0x4,
+			FOREARM_R = 0x5,
+			THIGH_L = 0x6,
+			THIGH_R = 0x7,
+			LOWER_LEG_L = 0x8,
+			LOWER_LEG_R = 0x9,
+			MESH_COMP_COUNT = 0xA
+		};
 		struct MeshBounds 
 		{
 			const glm::u8vec3 upperBound; 
@@ -44,59 +58,121 @@ namespace fdm
 
 			int vertCount() const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const PlayerSkin::SkinMesh* self)>(FUNC_PLAYERSKIN_SKINMESH_VERTCOUNT)(this);
+				return reinterpret_cast<int (__thiscall*)(const PlayerSkin::SkinMesh* self)>(getFuncAddr((int)Func::PlayerSkin_Nested::SkinMesh::vertCount))(this);
 			}
 			~SkinMesh() 
 			{
-				reinterpret_cast<void(__thiscall*)(PlayerSkin::SkinMesh* self)>(FUNC_PLAYERSKIN_SKINMESH_DESTR_SKINMESH)(this);
+				reinterpret_cast<void(__thiscall*)(PlayerSkin::SkinMesh* self)>(getFuncAddr((int)Func::PlayerSkin_Nested::SkinMesh::destr_SkinMesh))(this);
 			}
 			void generate(const PlayerSkin::SkinMesh::Pixel* data, PlayerSkin::SkinMesh* meshBounds) 
 			{
-				return reinterpret_cast<void (__thiscall*)(PlayerSkin::SkinMesh* self, const PlayerSkin::SkinMesh::Pixel* data, PlayerSkin::SkinMesh* meshBounds)>(FUNC_PLAYERSKIN_SKINMESH_GENERATE)(this, data, meshBounds);
+				return reinterpret_cast<void (__thiscall*)(PlayerSkin::SkinMesh* self, const PlayerSkin::SkinMesh::Pixel* data, PlayerSkin::SkinMesh* meshBounds)>(getFuncAddr((int)Func::PlayerSkin_Nested::SkinMesh::generate))(this, data, meshBounds);
 			}
 			int buffSize(int buffIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const PlayerSkin::SkinMesh* self, int buffIndex)>(FUNC_PLAYERSKIN_SKINMESH_BUFFSIZE)(this, buffIndex);
+				return reinterpret_cast<int (__thiscall*)(const PlayerSkin::SkinMesh* self, int buffIndex)>(getFuncAddr((int)Func::PlayerSkin_Nested::SkinMesh::buffSize))(this, buffIndex);
 			}
 			int attrCount(int buffIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const PlayerSkin::SkinMesh* self, int buffIndex)>(FUNC_PLAYERSKIN_SKINMESH_ATTRCOUNT)(this, buffIndex);
+				return reinterpret_cast<int (__thiscall*)(const PlayerSkin::SkinMesh* self, int buffIndex)>(getFuncAddr((int)Func::PlayerSkin_Nested::SkinMesh::attrCount))(this, buffIndex);
 			}
 			uint32_t attrType(int buffIndex, int attrIndex) const override
 			{
-				return reinterpret_cast<uint32_t (__thiscall*)(const PlayerSkin::SkinMesh* self, int buffIndex, int attrIndex)>(FUNC_PLAYERSKIN_SKINMESH_ATTRTYPE)(this, buffIndex, attrIndex);
+				return reinterpret_cast<uint32_t (__thiscall*)(const PlayerSkin::SkinMesh* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::PlayerSkin_Nested::SkinMesh::attrType))(this, buffIndex, attrIndex);
 			}
 			int attrSize(int buffIndex, int attrIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const PlayerSkin::SkinMesh* self, int buffIndex, int attrIndex)>(FUNC_PLAYERSKIN_SKINMESH_ATTRSIZE)(this, buffIndex, attrIndex);
+				return reinterpret_cast<int (__thiscall*)(const PlayerSkin::SkinMesh* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::PlayerSkin_Nested::SkinMesh::attrSize))(this, buffIndex, attrIndex);
 			}
 			int attrStride(int buffIndex, int attrIndex) const override
 			{
-				return reinterpret_cast<int (__thiscall*)(const PlayerSkin::SkinMesh* self, int buffIndex, int attrIndex)>(FUNC_PLAYERSKIN_SKINMESH_ATTRSTRIDE)(this, buffIndex, attrIndex);
+				return reinterpret_cast<int (__thiscall*)(const PlayerSkin::SkinMesh* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::PlayerSkin_Nested::SkinMesh::attrStride))(this, buffIndex, attrIndex);
 			}
 			void addPixelToFace(std::unordered_map<glm::u8vec2, FaceInfo>& faceMap, const glm::i8vec2& compPos, const glm::u8vec3& pos) 
 			{
-				return reinterpret_cast<void (__thiscall*)(PlayerSkin::SkinMesh* self, std::unordered_map<glm::u8vec2, FaceInfo>& faceMap, const glm::i8vec2& compPos, const glm::u8vec3& pos)>(FUNC_PLAYERSKIN_SKINMESH_ADDPIXELTOFACE)(this, faceMap, compPos, pos);
+				return reinterpret_cast<void (__thiscall*)(PlayerSkin::SkinMesh* self, std::unordered_map<glm::u8vec2, FaceInfo>& faceMap, const glm::i8vec2& compPos, const glm::u8vec3& pos)>(getFuncAddr((int)Func::PlayerSkin_Nested::SkinMesh::addPixelToFace))(this, faceMap, compPos, pos);
 			}
 		};
 		inline static const int WIDTH = 24; 
 		inline static const int HEIGHT = 48; 
 		inline static const int DEPTH = 42; 
-		inline static PlayerSkin::MeshBounds** meshBounds = reinterpret_cast<PlayerSkin::MeshBounds**>((base + 0x2B2F10));
+		inline static const PlayerSkin::MeshBounds meshBounds[MESH_COMP_COUNT] =
+		{
+		  {
+			{ { 18u }, { 12u }, { 12u } },
+			{ { 6u }, { 0u }, { 0u } },
+			{ { 12u }, { 11u }, { 8u } },
+			0u
+		  },
+		  {
+			{ { 21u }, { 32u }, { 42u } },
+			{ { 3u }, { 8u }, { 27u } },
+			{ { 12u }, { 20u }, { 33u } },
+			27u
+		  },
+		  {
+			{ { 24u }, { 23u }, { 27u } },
+			{ { 15u }, { 8u }, { 15u } },
+			{ { 17u }, { 13u }, { 21u } },
+			13u
+		  },
+		  {
+			{ { 9u }, { 23u }, { 27u } },
+			{ { 0u }, { 8u }, { 15u } },
+			{ { 6u }, { 13u }, { 21u } },
+			13u
+		  },
+		  {
+			{ { 24u }, { 33u }, { 14u } },
+			{ { 15u }, { 18u }, { 2u } },
+			{ { 20u }, { 20u }, { 8u } },
+			0u
+		  },
+		  {
+			{ { 9u }, { 33u }, { 14u } },
+			{ { 0u }, { 18u }, { 2u } },
+			{ { 4u }, { 20u }, { 8u } },
+			0u
+		  },
+		  {
+			{ { 21u }, { 38u }, { 26u } },
+			{ { 12u }, { 23u }, { 14u } },
+			{ { 14u }, { 27u }, { 19u } },
+			13u
+		  },
+		  {
+			{ { 12u }, { 38u }, { 26u } },
+			{ { 3u }, { 23u }, { 14u } },
+			{ { 9u }, { 27u }, { 19u } },
+			13u
+		  },
+		  {
+			{ { 21u }, { 48u }, { 12u } },
+			{ { 12u }, { 33u }, { 0u } },
+			{ { 15u }, { 36u }, { 7u } },
+			0u
+		  },
+		  {
+			{ { 12u }, { 48u }, { 12u } },
+			{ { 3u }, { 33u }, { 0u } },
+			{ { 8u }, { 36u }, { 7u } },
+			0u
+		  }
+		};
 		Tex2D tex; 
-		MeshRenderer meshComps[10]; // 0x10
+		MeshRenderer meshComps[MESH_COMP_COUNT]; // 0x10
 
-		bool load(std::string& path) 
+		bool load(msvc_string& path) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(PlayerSkin* self, std::string& path)>(FUNC_PLAYERSKIN_LOAD)(this, path);
+			return reinterpret_cast<bool (__thiscall*)(PlayerSkin* self, msvc_string& path)>(getFuncAddr((int)Func::PlayerSkin::load))(this, path);
 		}
 		bool generateMesh(const PlayerSkin::SkinMesh::Pixel* data, int texWidth, int texHeight) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(PlayerSkin* self, const PlayerSkin::SkinMesh::Pixel* data, int texWidth, int texHeight)>(FUNC_PLAYERSKIN_GENERATEMESH)(this, data, texWidth, texHeight);
+			return reinterpret_cast<bool (__thiscall*)(PlayerSkin* self, const PlayerSkin::SkinMesh::Pixel* data, int texWidth, int texHeight)>(getFuncAddr((int)Func::PlayerSkin::generateMesh))(this, data, texWidth, texHeight);
 		}
 		~PlayerSkin() 
 		{
-			reinterpret_cast<void(__thiscall*)(PlayerSkin* self)>(FUNC_PLAYERSKIN_DESTR_PLAYERSKIN)(this);
+			reinterpret_cast<void(__thiscall*)(PlayerSkin* self)>(getFuncAddr((int)Func::PlayerSkin::destr_PlayerSkin))(this);
 		}
 	};
 }
diff --git a/4dm.h/PlayerSkinRenderer.h b/4dm.h/PlayerSkinRenderer.h
index d8565bc..c9e1664 100644
--- a/4dm.h/PlayerSkinRenderer.h
+++ b/4dm.h/PlayerSkinRenderer.h
@@ -45,19 +45,19 @@ namespace fdm
 		PlayerSkinRenderer(){}
 		PlayerSkinRenderer(const PlayerSkin* skin) 
 		{
-			reinterpret_cast<void(__thiscall*)(PlayerSkinRenderer* self, const PlayerSkin* skin)>(FUNC_PLAYERSKINRENDERER_PLAYERSKINRENDERER)(this, skin);
+			reinterpret_cast<void(__thiscall*)(PlayerSkinRenderer* self, const PlayerSkin* skin)>(getFuncAddr((int)Func::PlayerSkinRenderer::PlayerSkinRenderer))(this, skin);
 		}
 		void render(const m4::Mat5& MV, const glm::vec4& lightDir, const std::unique_ptr<Item>* handSlot, const std::unique_ptr<Item>* equipmentSlot, bool glasses) 
 		{
-			return reinterpret_cast<void (__thiscall*)(PlayerSkinRenderer* self, const m4::Mat5& MV, const glm::vec4& lightDir, const std::unique_ptr<Item>* handSlot, const std::unique_ptr<Item>* equipmentSlot, bool glasses)>(FUNC_PLAYERSKINRENDERER_RENDER)(this, MV, lightDir, handSlot, equipmentSlot, glasses);
+			return reinterpret_cast<void (__thiscall*)(PlayerSkinRenderer* self, const m4::Mat5& MV, const glm::vec4& lightDir, const std::unique_ptr<Item>* handSlot, const std::unique_ptr<Item>* equipmentSlot, bool glasses)>(getFuncAddr((int)Func::PlayerSkinRenderer::render))(this, MV, lightDir, handSlot, equipmentSlot, glasses);
 		}
 		void updateAnimation(double dt) 
 		{
-			return reinterpret_cast<void (__thiscall*)(PlayerSkinRenderer* self, double dt)>(FUNC_PLAYERSKINRENDERER_UPDATEANIMATION)(this, dt);
+			return reinterpret_cast<void (__thiscall*)(PlayerSkinRenderer* self, double dt)>(getFuncAddr((int)Func::PlayerSkinRenderer::updateAnimation))(this, dt);
 		}
 		void resetTransformations() 
 		{
-			return reinterpret_cast<void (__thiscall*)(PlayerSkinRenderer* self)>(FUNC_PLAYERSKINRENDERER_RESETTRANSFORMATIONS)(this);
+			return reinterpret_cast<void (__thiscall*)(PlayerSkinRenderer* self)>(getFuncAddr((int)Func::PlayerSkinRenderer::resetTransformations))(this);
 		}
 	};
 }
diff --git a/4dm.h/PlayerSkinViewer.h b/4dm.h/PlayerSkinViewer.h
index a8ee0e7..c562daf 100644
--- a/4dm.h/PlayerSkinViewer.h
+++ b/4dm.h/PlayerSkinViewer.h
@@ -20,39 +20,39 @@ namespace fdm
 
 		void render(gui::Window* w) override
 		{
-			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self, gui::Window* w)>(FUNC_PLAYERSKINVIEWER_RENDER)(this, w);
+			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self, gui::Window* w)>(getFuncAddr((int)Func::PlayerSkinViewer::render))(this, w);
 		}
 		void alignX(gui::AlignmentX a) override
 		{
-			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self, gui::AlignmentX a)>(FUNC_PLAYERSKINVIEWER_ALIGNX)(this, a);
+			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self, gui::AlignmentX a)>(getFuncAddr((int)Func::PlayerSkinViewer::alignX))(this, a);
 		}
 		void alignY(gui::AlignmentY a) override
 		{
-			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self, gui::AlignmentY a)>(FUNC_PLAYERSKINVIEWER_ALIGNY)(this, a);
+			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self, gui::AlignmentY a)>(getFuncAddr((int)Func::PlayerSkinViewer::alignY))(this, a);
 		}
-		void getPos(gui::Window* w, int* x, int* y) override
+		void getPos(const gui::Window* w, int* x, int* y) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self, gui::Window* w, int* x, int* y)>(FUNC_PLAYERSKINVIEWER_GETPOS)(this, w, x, y);
+			return reinterpret_cast<void (__thiscall*)(const PlayerSkinViewer* self, const gui::Window* w, int* x, int* y)>(getFuncAddr((int)Func::PlayerSkinViewer::getPos))(this, w, x, y);
 		}
-		void getSize(gui::Window* w, int* width, int* height) override
+		void getSize(const gui::Window* w, int* width, int* height) const override
 		{
-			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self, gui::Window* w, int* width, int* height)>(FUNC_PLAYERSKINVIEWER_GETSIZE)(this, w, width, height);
+			return reinterpret_cast<void (__thiscall*)(const PlayerSkinViewer* self, const gui::Window* w, int* width, int* height)>(getFuncAddr((int)Func::PlayerSkinViewer::getSize))(this, w, width, height);
 		}
-		bool mouseInput(gui::Window* w, double xpos, double ypos) override
+		bool mouseInput(const gui::Window* w, double xpos, double ypos) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(PlayerSkinViewer* self, gui::Window* w, double xpos, double ypos)>(FUNC_PLAYERSKINVIEWER_MOUSEINPUT)(this, w, xpos, ypos);
+			return reinterpret_cast<bool (__thiscall*)(PlayerSkinViewer* self, const gui::Window* w, double xpos, double ypos)>(getFuncAddr((int)Func::PlayerSkinViewer::mouseInput))(this, w, xpos, ypos);
 		}
 		int getCursorType() override
 		{
-			return reinterpret_cast<int (__thiscall*)(PlayerSkinViewer* self)>(FUNC_PLAYERSKINVIEWER_GETCURSORTYPE)(this);
+			return reinterpret_cast<int (__thiscall*)(PlayerSkinViewer* self)>(getFuncAddr((int)Func::PlayerSkinViewer::getCursorType))(this);
 		}
 		void init(PlayerSkinRenderer* skinRenderer) 
 		{
-			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self, PlayerSkinRenderer* skinRenderer)>(FUNC_PLAYERSKINVIEWER_INIT)(this, skinRenderer);
+			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self, PlayerSkinRenderer* skinRenderer)>(getFuncAddr((int)Func::PlayerSkinViewer::init))(this, skinRenderer);
 		}
 		void setupFrameBuffer() 
 		{
-			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self)>(FUNC_PLAYERSKINVIEWER_SETUPFRAMEBUFFER)(this);
+			return reinterpret_cast<void (__thiscall*)(PlayerSkinViewer* self)>(getFuncAddr((int)Func::PlayerSkinViewer::setupFrameBuffer))(this);
 		}
 	};
 }
diff --git a/4dm.h/QuadRenderer.h b/4dm.h/QuadRenderer.h
index cc55d45..c371271 100644
--- a/4dm.h/QuadRenderer.h
+++ b/4dm.h/QuadRenderer.h
@@ -8,17 +8,20 @@ namespace fdm
 	class QuadRenderer 
 	{
 	public:
-		const Shader* shader; 
-		unsigned int VAO; // 0x8
-		unsigned int buffers[4]; // 0xC
-		unsigned int mode; // 0x1C
-		unsigned int elementCount; // 0x20
+		const Shader* shader = nullptr;
+		unsigned int VAO = 0; // 0x8
+		unsigned int buffers[4] = { 0 }; // 0xC
+		unsigned int mode = 4; // 0x1C
+		unsigned int elementCount = 6; // 0x20
 
 		~QuadRenderer()
 		{
-			glBindVertexArray(this->VAO);
-			glDeleteBuffers(4, this->buffers);
-			glDeleteVertexArrays(1, &this->VAO);
+			if (VAO)
+			{
+				glBindVertexArray(this->VAO);
+				glDeleteBuffers(4, this->buffers);
+				glDeleteVertexArrays(1, &this->VAO);
+			}
 		}
 		QuadRenderer() {}
 		QuadRenderer(const Shader* shader)
@@ -27,34 +30,80 @@ namespace fdm
 		}
 		bool init() 
 		{
-			return reinterpret_cast<bool (__thiscall*)(QuadRenderer* self)>(FUNC_QUADRENDERER_INIT)(this);
+			return reinterpret_cast<bool (__thiscall*)(QuadRenderer* self)>(getFuncAddr((int)Func::QuadRenderer::init))(this);
+		}
+		void setColor(const glm::vec4 (&colors)[4])
+		{
+			glBindVertexArray(VAO);
+
+			glBindBuffer(GL_ARRAY_BUFFER, buffers[2]);
+			glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 16, colors, GL_STATIC_DRAW);
+
+			glBindVertexArray(0);
+			glBindBuffer(GL_ARRAY_BUFFER, 0);
 		}
-		void setColor(float r, float g, float b, float a) 
+		void setColor(float r, float g, float b, float a)
 		{
-			return reinterpret_cast<void (__thiscall*)(QuadRenderer* self, float r, float g, float b, float a)>(FUNC_QUADRENDERER_SETCOLOR)(this, r, g, b, a);
+			setColor(
+				{
+					{r, g, b, a},
+					{r, g, b, a},
+					{r, g, b, a},
+					{r, g, b, a}
+				});
+			//return reinterpret_cast<void (__thiscall*)(QuadRenderer* self, float r, float g, float b, float a)>(getFuncAddr((int)Func::QuadRenderer::setColor))(this, r, g, b, a);
 		}
 		void setPos(int x, int y, int w, int h)
 		{
-			return reinterpret_cast<void (__thiscall*)(QuadRenderer* self, int x, int y, int w, int h)>(FUNC_QUADRENDERER_SETPOS)(this, x, y, w, h);
+			return reinterpret_cast<void (__thiscall*)(QuadRenderer* self, int x, int y, int w, int h)>(getFuncAddr((int)Func::QuadRenderer::setPos))(this, x, y, w, h);
 		}
-
-		// thx compiler for removing that and thx to mashpoe for telling me that it exists
-		void render()
+		// mash thx so much
+		void setQuadRendererMode(GLuint mode)
 		{
-			if (mode != 4)
+			if (mode == this->mode)
+			{
+				return;
+			}
+
+			if (mode == GL_TRIANGLES)
+			{
+				constexpr GLuint indices[] = {
+					0, 1, 2, // first triangle
+					2, 3, 0  // second triangle
+				};
+
+				if (this->VAO != 0)
+				{
+					glBindVertexArray(this->VAO);
+					glBindBuffer(GL_ARRAY_BUFFER, this->buffers[0]);
+					glBufferData(GL_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
+					glBindBuffer(GL_ARRAY_BUFFER, 0);
+				}
+
+				this->mode = GL_TRIANGLES;
+				this->elementCount = 6;
+			}
+			else
 			{
-				if (VAO)
+				if (this->VAO != 0)
 				{
-					int data[5] = { 0, 1, 2, 2, 3 };
-					glBindVertexArray(VAO);
-					glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
-					glBufferData(GL_ARRAY_BUFFER, 24, data, GL_STATIC_DRAW);
-					glBindBuffer(GL_ARRAY_BUFFER, NULL);
+					constexpr GLuint indices[] = {
+						0, 1, 2, 3
+					};
+
+					glBindVertexArray(this->VAO);
+					glBindBuffer(GL_ARRAY_BUFFER, this->buffers[0]);
+					glBufferData(GL_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
+					glBindBuffer(GL_ARRAY_BUFFER, 0);
 				}
-				mode = 4;
-				elementCount = 6;
+
+				this->mode = GL_LINE_LOOP;
+				this->elementCount = 4;
 			}
-			glUseProgram(shader->id());
+		}
+		void render()
+		{
+			shader->use();
 			glBindVertexArray(VAO);
 			glDrawElements(mode, elementCount, GL_UNSIGNED_INT, 0);
 			glBindVertexArray(NULL);
diff --git a/4dm.h/README.md b/4dm.h/README.md
index b3df533..01fea35 100644
--- a/4dm.h/README.md
+++ b/4dm.h/README.md
@@ -9,5 +9,5 @@ Inspired by [gd.h](https://github.com/HJfod/gd.h "gd.h") (Geometry Dash modding
 
 ## Links:
  - [4DMod Example](https://github.com/4D-Modding/4dmod-example)
- - [4D-Modding web-site](https://gdpseditor.com/4dmodding/)
+ - [4D-Modding web-site](https://www.4dmodding.me/)
  - [4D-Modding Discord Server](https://discord.gg/AmGKpYXBwX)
diff --git a/4dm.h/ResourceManager.h b/4dm.h/ResourceManager.h
index dde7c49..42f283d 100644
--- a/4dm.h/ResourceManager.h
+++ b/4dm.h/ResourceManager.h
@@ -7,33 +7,44 @@ namespace fdm
 	class ResourceManager 
 	{
 	public:
-		inline static std::unordered_map<std::string,Tex2D *>* textures = reinterpret_cast<std::unordered_map<std::string,Tex2D *>*>((base + 0x2C40F0));
+		inline static std::unordered_map<msvc_string,Tex2D *>* textures = reinterpret_cast<std::unordered_map<msvc_string,Tex2D *>*>((base + 0x2C40F0));
 
-		// if you use modFolder assets (custom assets from yur mod's folder) then base path will become "mods/MOD_NAME/" instead of "assets/textures/"
-		inline static const Tex2D* get(const std::string& filename, bool modFolder = false)
+		inline static const Tex2D* get(const std::string& filename, const std::string& folderOverride)
 		{
-			if (!modFolder)
-			{
-				return reinterpret_cast<const Tex2D * (__fastcall*)(const std::string&)>(
-					FUNC_RESOURCEMANAGER_GET
-					)(filename);
-			}
-			else
+			std::string path = (std::filesystem::path(folderOverride) / filename).string();
+
+			if (textures->contains(path))
+				return textures->at(path);
+
+			Tex2D* tex = new Tex2D();
+			tex->ID = 0;
+			tex->height = 0;
+			tex->width = 0;
+			tex->target = GL_TEXTURE_2D;
+
+			if (!tex->load(path))
 			{
-				Tex2D* texture = new Tex2D();
-				if (texture->load("mods/" + std::string(MOD_NAME) + "/" + filename))
-					return texture;
-				else
-				{
-					glDeleteTextures(1, &texture->ID);
-					delete(texture);
-				}
-				return NULL;
+				delete tex;
+				tex = nullptr;
 			}
+
+			textures->insert({ path, tex });
+			return tex;
+		}
+
+		inline static const Tex2D* get(const std::string& filename, bool modFolder = false)
+		{
+			if (modFolder)
+				return get(filename, fdm::getModPath(fdm::modID));
+
+			return reinterpret_cast<const Tex2D * (__fastcall*)(const std::string&)>(
+					getFuncAddr((int)Func::ResourceManager::get)
+					)(filename);
 		}
-		inline static bool loadArrayTexture(const std::string& filename, int cols, int rows) 
+		
+		inline static bool loadArrayTexture(const msvc_string& filename, int cols, int rows) 
 		{
-			return reinterpret_cast<bool (__fastcall*)(const std::string& filename, int cols, int rows)>(FUNC_RESOURCEMANAGER_LOADARRAYTEXTURE)(filename, cols, rows);
+			return reinterpret_cast<bool (__fastcall*)(const msvc_string& filename, int cols, int rows)>(getFuncAddr((int)Func::ResourceManager::loadArrayTexture))(filename, cols, rows);
 		}
 	};
 }
diff --git a/4dm.h/Shader.h b/4dm.h/Shader.h
index d7370be..f5f06c7 100644
--- a/4dm.h/Shader.h
+++ b/4dm.h/Shader.h
@@ -9,19 +9,13 @@ namespace fdm
 	public:
 		enum shaderType
 		{
-			VERTEX_SHADER = 0x8B31,
-			GEOMETRY_SHADER = 0x8DD9,
-			FRAGMENT_SHADER = 0x8B30
+			VERTEX_SHADER = GL_VERTEX_SHADER,
+			GEOMETRY_SHADER = GL_GEOMETRY_SHADER,
+			FRAGMENT_SHADER = GL_FRAGMENT_SHADER
 		};
 		unsigned int ID;
-		bool load(const std::string& vertexPath, const std::string& fragmentPath) 
-		{
-			return reinterpret_cast<bool(__thiscall*)(Shader*, const std::string & vertexPath, const std::string & fragmentPath)>(
-				FUNC_SHADER_LOAD
-				)(this, vertexPath, fragmentPath);
-		}
 		// thank you mashed potatoes for this
-		bool load(const std::string& vertexPath, const std::string& geometryPath, const std::string& fragmentPath)
+		bool load(const msvc_string& vertexPath, const msvc_string& geometryPath, const msvc_string& fragmentPath)
 		{
 			if (ID != 0)
 			{
@@ -58,22 +52,16 @@ namespace fdm
 
 			return ID != 0;
 		}
-		unsigned int compileShader(const std::string& path, shaderType type) 
-		{
-			return reinterpret_cast<unsigned int(__thiscall*)(Shader*, const std::string & path, shaderType fragmentPath)>(
-				FUNC_SHADER_COMPILESHADER
-				)(this, path, type);
-		}
-		bool load(const std::string& vertexPath, const std::string& fragmentPath) const
+		bool load(const msvc_string& vertexPath, const msvc_string& fragmentPath)
 		{
-			return reinterpret_cast<bool(__thiscall*)(const Shader*, const std::string & vertexPath, const std::string & fragmentPath)>(
-				FUNC_SHADER_LOAD
+			return reinterpret_cast<bool(__thiscall*)(Shader*, const msvc_string & vertexPath, const msvc_string & fragmentPath)>(
+				getFuncAddr((int)Func::Shader::load)
 				)(this, vertexPath, fragmentPath);
 		}
-		unsigned int compileShader(const std::string& path, shaderType type) const
+		unsigned int compileShader(const msvc_string& path, shaderType type) const
 		{
-			return reinterpret_cast<unsigned int(__thiscall*)(const Shader*, const std::string & path, shaderType fragmentPath)>(
-				FUNC_SHADER_COMPILESHADER
+			return reinterpret_cast<unsigned int(__thiscall*)(const Shader*, const msvc_string & path, shaderType fragmentPath)>(
+				getFuncAddr((int)Func::Shader::compileShader)
 				)(this, path, type);
 		}
 		unsigned int id() const
@@ -84,13 +72,5 @@ namespace fdm
 		{
 			glUseProgram(ID);
 		}
-		unsigned int id()
-		{
-			return ID;
-		}
-		void use()
-		{
-			glUseProgram(ID);
-		}
 	};
-}
\ No newline at end of file
+}
diff --git a/4dm.h/ShaderManager.h b/4dm.h/ShaderManager.h
index e79fcc2..eccc83d 100644
--- a/4dm.h/ShaderManager.h
+++ b/4dm.h/ShaderManager.h
@@ -9,18 +9,56 @@ namespace fdm
 	class ShaderManager 
 	{
 	public:
-		inline static std::map<std::string,Shader *>* shaders = reinterpret_cast<std::map<std::string,Shader *>*>((base + 0x2C0728));
+		inline static std::map<msvc_string,Shader *>* shaders = reinterpret_cast<std::map<msvc_string,Shader *>*>((base + 0x2C0728));
 
-		inline static const Shader* get(const std::string& shaderName)
+		// will load relative to the mod's directory!! (will load a new shader only if the shaderName wasnt found in shaders tho)
+		inline static const Shader* load(const std::string& shaderName, const std::string& vertexPath, const std::string& fragmentPath)
 		{
-			return reinterpret_cast<const Shader * (__fastcall*)(const std::string&)>(
-				FUNC_SHADERMANAGER_GET
+			std::string vertP = (std::filesystem::path(fdm::getModPath(fdm::modID)) / vertexPath).string();
+			std::string fragP = (std::filesystem::path(fdm::getModPath(fdm::modID)) / fragmentPath).string();
+			if (shaders->contains(shaderName))
+				return shaders->at(shaderName);
+
+			Shader* shader = new Shader();
+			if (!shader->load(vertP, fragP))
+			{
+				delete shader;
+				shader = nullptr;
+			}
+			
+			shaders->insert({ shaderName, shader });
+			return shader;
+		}
+		// will load relative to the mod's directory!! (will load a new shader only if the shaderName wasnt found in shaders tho)
+		inline static const Shader* load(const std::string& shaderName, const std::string& vertexPath, const std::string& fragmentPath, const std::string& geometryPath)
+		{
+			std::string vertP = (std::filesystem::path(fdm::getModPath(fdm::modID)) / vertexPath).string();
+			std::string fragP = (std::filesystem::path(fdm::getModPath(fdm::modID)) / fragmentPath).string();
+			std::string geoP = (std::filesystem::path(fdm::getModPath(fdm::modID)) / geometryPath).string();
+			if (shaders->contains(shaderName))
+				return shaders->at(shaderName);
+
+			Shader* shader = new Shader();
+			if (!shader->load(vertP, geoP, fragP))
+			{
+				delete shader;
+				shader = nullptr;
+			}
+
+			shaders->insert({ shaderName, shader });
+			return shader;
+		}
+
+		inline static const Shader* get(const msvc_string& shaderName)
+		{
+			return reinterpret_cast<const Shader * (__fastcall*)(const msvc_string&)>(
+				getFuncAddr((int)Func::ShaderManager::get)
 				)(shaderName);
 		}
 
-		inline static bool loadFromShaderList(const std::string& jsonListPath) 
+		inline static bool loadFromShaderList(const msvc_string& jsonListPath) 
 		{
-			return reinterpret_cast<bool (__fastcall*)(const std::string& jsonListPath)>(FUNC_SHADERMANAGER_LOADFROMSHADERLIST)(jsonListPath);
+			return reinterpret_cast<bool (__fastcall*)(const msvc_string& jsonListPath)>(getFuncAddr((int)Func::ShaderManager::loadFromShaderList))(jsonListPath);
 		}
 	};
 }
diff --git a/4dm.h/Skybox.h b/4dm.h/Skybox.h
index fd26ca4..db81bd2 100644
--- a/4dm.h/Skybox.h
+++ b/4dm.h/Skybox.h
@@ -9,24 +9,24 @@ namespace fdm
 	public:
 		inline static Skybox* instance = reinterpret_cast<Skybox*>((base + 0x279138));
 		inline static const int VERTEX_COUNT = 36; 
-		inline static glm::vec3** verts = reinterpret_cast<glm::vec3**>((base + 0x2784D0));
-		inline static glm::vec2** uv = reinterpret_cast<glm::vec2**>((base + 0x278680));
+		inline static glm::vec3* verts = reinterpret_cast<glm::vec3*>((base + 0x2784D0));
+		inline static glm::vec2* uv = reinterpret_cast<glm::vec2*>((base + 0x278680));
 
 		const void* buffData(int buffIndex) const override
 		{
-			return reinterpret_cast<const void* (__thiscall*)(const Skybox* self, int buffIndex)>(FUNC_SKYBOX_BUFFDATA)(this, buffIndex);
+			return reinterpret_cast<const void* (__thiscall*)(const Skybox* self, int buffIndex)>(getFuncAddr((int)Func::Skybox::buffData))(this, buffIndex);
 		}
 		int buffSize(int buffIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Skybox* self, int buffIndex)>(FUNC_SKYBOX_BUFFSIZE)(this, buffIndex);
+			return reinterpret_cast<int (__thiscall*)(const Skybox* self, int buffIndex)>(getFuncAddr((int)Func::Skybox::buffSize))(this, buffIndex);
 		}
 		int attrSize(int buffIndex, int attrIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Skybox* self, int buffIndex, int attrIndex)>(FUNC_SKYBOX_ATTRSIZE)(this, buffIndex, attrIndex);
+			return reinterpret_cast<int (__thiscall*)(const Skybox* self, int buffIndex, int attrIndex)>(getFuncAddr((int)Func::Skybox::attrSize))(this, buffIndex, attrIndex);
 		}
 		int vertCount() const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Skybox* self)>(FUNC_SKYBOX_VERTCOUNT)(this);
+			return reinterpret_cast<int (__thiscall*)(const Skybox* self)>(getFuncAddr((int)Func::Skybox::vertCount))(this);
 		}
 	};
 }
diff --git a/4dm.h/Sphere.h b/4dm.h/Sphere.h
index 1361964..1c513c6 100644
--- a/4dm.h/Sphere.h
+++ b/4dm.h/Sphere.h
@@ -12,19 +12,19 @@ namespace fdm
 
 		int vertCount() const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Sphere* self)>(FUNC_SPHERE_VERTCOUNT)(this);
+			return reinterpret_cast<int (__thiscall*)(const Sphere* self)>(getFuncAddr((int)Func::Sphere::vertCount))(this);
 		}
 		int buffSize(int buffIndex) const override
 		{
-			return reinterpret_cast<int (__thiscall*)(const Sphere* self, int buffIndex)>(FUNC_SPHERE_BUFFSIZE)(this, buffIndex);
+			return reinterpret_cast<int (__thiscall*)(const Sphere* self, int buffIndex)>(getFuncAddr((int)Func::Sphere::buffSize))(this, buffIndex);
 		}
 		Sphere(int edges) 
 		{
-			reinterpret_cast<void(__thiscall*)(Sphere* self, int edges)>(FUNC_SPHERE_SPHERE)(this, edges);
+			reinterpret_cast<void(__thiscall*)(Sphere* self, int edges)>(getFuncAddr((int)Func::Sphere::Sphere))(this, edges);
 		}
 		inline static void generateCirclePolygons(int wi, std::vector<glm::vec4>* verts, std::vector<glm::vec3>* tuvs, const std::vector<float>* sinVert, const std::vector<float>* cosVert) 
 		{
-			return reinterpret_cast<void (__fastcall*)(int wi, std::vector<glm::vec4>* verts, std::vector<glm::vec3>* tuvs, const std::vector<float>* sinVert, const std::vector<float>* cosVert)>(FUNC_SPHERE_GENERATECIRCLEPOLYGONS)(wi, verts, tuvs, sinVert, cosVert);
+			return reinterpret_cast<void (__fastcall*)(int wi, std::vector<glm::vec4>* verts, std::vector<glm::vec3>* tuvs, const std::vector<float>* sinVert, const std::vector<float>* cosVert)>(getFuncAddr((int)Func::Sphere::generateCirclePolygons))(wi, verts, tuvs, sinVert, cosVert);
 		}
 	};
 }
diff --git a/4dm.h/State.h b/4dm.h/State.h
index ce60e8b..5e59623 100644
--- a/4dm.h/State.h
+++ b/4dm.h/State.h
@@ -1,10 +1,10 @@
 #pragma once
 
 #include "4dm.h"
-#include "StateManager.h"
 
 namespace fdm 
 {
+	class StateManager;
 	class State 
 	{
 	public:
diff --git a/4dm.h/StateCreateWorld.h b/4dm.h/StateCreateWorld.h
index ce509ec..e77bd4e 100644
--- a/4dm.h/StateCreateWorld.h
+++ b/4dm.h/StateCreateWorld.h
@@ -36,63 +36,63 @@ namespace fdm
 
 		StateCreateWorld() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateCreateWorld* self)>(FUNC_STATECREATEWORLD_STATECREATEWORLD)(this);
+			reinterpret_cast<void(__thiscall*)(StateCreateWorld* self)>(getFuncAddr((int)Func::StateCreateWorld::StateCreateWorld))(this);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s)>(FUNC_STATECREATEWORLD_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s)>(getFuncAddr((int)Func::StateCreateWorld::init))(this, s);
 		}
 		void close(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s)>(FUNC_STATECREATEWORLD_CLOSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s)>(getFuncAddr((int)Func::StateCreateWorld::close))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, double dt)>(FUNC_STATECREATEWORLD_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateCreateWorld::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s)>(FUNC_STATECREATEWORLD_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s)>(getFuncAddr((int)Func::StateCreateWorld::render))(this, s);
 		}
 		void resume(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s)>(FUNC_STATECREATEWORLD_RESUME)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s)>(getFuncAddr((int)Func::StateCreateWorld::resume))(this, s);
 		}
 		void mouseInput(StateManager& s, double xpos, double ypos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, double xpos, double ypos)>(FUNC_STATECREATEWORLD_MOUSEINPUT)(this, s, xpos, ypos);
+			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, double xpos, double ypos)>(getFuncAddr((int)Func::StateCreateWorld::mouseInput))(this, s, xpos, ypos);
 		}
 		void scrollInput(StateManager& s, double xoffset, double yoffset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, double xoffset, double yoffset)>(FUNC_STATECREATEWORLD_SCROLLINPUT)(this, s, xoffset, yoffset);
+			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, double xoffset, double yoffset)>(getFuncAddr((int)Func::StateCreateWorld::scrollInput))(this, s, xoffset, yoffset);
 		}
 		void keyInput(StateManager& s, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, int key, int scancode, int action, int mods)>(FUNC_STATECREATEWORLD_KEYINPUT)(this, s, key, scancode, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::StateCreateWorld::keyInput))(this, s, key, scancode, action, mods);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, int width, int height)>(FUNC_STATECREATEWORLD_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateCreateWorld::windowResize))(this, s, width, height);
 		}
 		void charInput(StateManager& s, uint32_t codepoint) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, uint32_t codepoint)>(FUNC_STATECREATEWORLD_CHARINPUT)(this, s, codepoint);
+			return reinterpret_cast<void (__thiscall*)(StateCreateWorld* self, StateManager& s, uint32_t codepoint)>(getFuncAddr((int)Func::StateCreateWorld::charInput))(this, s, codepoint);
 		}
 		inline static void createNewWorld(std::vector<Chunk *>* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(std::vector<Chunk *>* user)>(FUNC_STATECREATEWORLD_CREATENEWWORLD)(user);
+			return reinterpret_cast<void (__fastcall*)(std::vector<Chunk *>* user)>(getFuncAddr((int)Func::StateCreateWorld::createNewWorld))(user);
 		}
 		inline static void viewportCallback(void* user, const glm::ivec4& pos, const glm::ivec2& scroll) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(FUNC_STATECREATEWORLD_VIEWPORTCALLBACK)(user, pos, scroll);
+			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(getFuncAddr((int)Func::StateCreateWorld::viewportCallback))(user, pos, scroll);
 		}
 		inline static void caveCheckboxCallback(void* user, bool checked) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(FUNC_STATECREATEWORLD_CAVECHECKBOXCALLBACK)(user, checked);
+			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(getFuncAddr((int)Func::StateCreateWorld::caveCheckboxCallback))(user, checked);
 		}
 		bool handleCreateButton() 
 		{
-			return reinterpret_cast<bool (__thiscall*)(StateCreateWorld* self)>(FUNC_STATECREATEWORLD_HANDLECREATEBUTTON)(this);
+			return reinterpret_cast<bool (__thiscall*)(StateCreateWorld* self)>(getFuncAddr((int)Func::StateCreateWorld::handleCreateButton))(this);
 		}
 	};
 }
diff --git a/4dm.h/StateCredits.h b/4dm.h/StateCredits.h
index 7ed366b..07192f7 100644
--- a/4dm.h/StateCredits.h
+++ b/4dm.h/StateCredits.h
@@ -19,27 +19,27 @@ namespace fdm
 
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCredits* self, StateManager& s)>(FUNC_STATECREDITS_INIT_A)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateCredits* self, StateManager& s)>(getFuncAddr((int)Func::StateCredits::init))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCredits* self, StateManager& s, double dt)>(FUNC_STATECREDITS_UPDATE_A)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateCredits* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateCredits::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCredits* self, StateManager& s)>(FUNC_STATECREDITS_RENDER_A)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateCredits* self, StateManager& s)>(getFuncAddr((int)Func::StateCredits::render))(this, s);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCredits* self, StateManager& s, int width, int height)>(FUNC_STATECREDITS_WINDOWRESIZE_A)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateCredits* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateCredits::windowResize))(this, s, width, height);
 		}
 		void keyInput(StateManager& s, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCredits* self, StateManager& s, int key, int scancode, int action, int mods)>(FUNC_STATECREDITS_KEYINPUT_A)(this, s, key, scancode, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateCredits* self, StateManager& s, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::StateCredits::keyInput))(this, s, key, scancode, action, mods);
 		}
 		void updateProjection(int width, int height) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateCredits* self, int width, int height)>(FUNC_STATECREDITS_UPDATEPROJECTION_A)(this, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateCredits* self, int width, int height)>(getFuncAddr((int)Func::StateCredits::updateProjection))(this, width, height);
 		}
 	};
 }
diff --git a/4dm.h/StateDeathScreen.h b/4dm.h/StateDeathScreen.h
index ec769fb..6dc8fc9 100644
--- a/4dm.h/StateDeathScreen.h
+++ b/4dm.h/StateDeathScreen.h
@@ -19,51 +19,51 @@ namespace fdm
 		gui::Button quitButton; // 0x1C8
 		inline static const float bgFadeTime = 1.f; 
 		inline static const float skullFadeTime = 1.f; 
-		float animationStartTime; // 0x220
+		double animationStartTime; // 0x220
 
 		void updateProjection(const glm::ivec2& size, const glm::ivec2& translate2D) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(FUNC_STATEDEATHSCREEN_UPDATEPROJECTION)(this, size, translate2D);
+			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(getFuncAddr((int)Func::StateDeathScreen::updateProjection))(this, size, translate2D);
 		}
 		inline static void retryButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATEDEATHSCREEN_RETRYBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateDeathScreen::retryButtonCallback))(user);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s)>(FUNC_STATEDEATHSCREEN_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateDeathScreen::init))(this, s);
 		}
 		void close(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s)>(FUNC_STATEDEATHSCREEN_CLOSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateDeathScreen::close))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, double dt)>(FUNC_STATEDEATHSCREEN_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateDeathScreen::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s)>(FUNC_STATEDEATHSCREEN_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateDeathScreen::render))(this, s);
 		}
 		void mouseInput(StateManager& s, double xpos, double ypos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, double xpos, double ypos)>(FUNC_STATEDEATHSCREEN_MOUSEINPUT)(this, s, xpos, ypos);
+			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, double xpos, double ypos)>(getFuncAddr((int)Func::StateDeathScreen::mouseInput))(this, s, xpos, ypos);
 		}
 		void scrollInput(StateManager& s, double xoffset, double yoffset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, double xoffset, double yoffset)>(FUNC_STATEDEATHSCREEN_SCROLLINPUT)(this, s, xoffset, yoffset);
+			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, double xoffset, double yoffset)>(getFuncAddr((int)Func::StateDeathScreen::scrollInput))(this, s, xoffset, yoffset);
 		}
 		void mouseButtonInput(StateManager& s, int button, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, int button, int action, int mods)>(FUNC_STATEDEATHSCREEN_MOUSEBUTTONINPUT)(this, s, button, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, int button, int action, int mods)>(getFuncAddr((int)Func::StateDeathScreen::mouseButtonInput))(this, s, button, action, mods);
 		}
 		void keyInput(StateManager& s, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, int key, int scancode, int action, int mods)>(FUNC_STATEDEATHSCREEN_KEYINPUT)(this, s, key, scancode, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::StateDeathScreen::keyInput))(this, s, key, scancode, action, mods);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, int width, int height)>(FUNC_STATEDEATHSCREEN_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateDeathScreen* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateDeathScreen::windowResize))(this, s, width, height);
 		}
 	};
 }
diff --git a/4dm.h/StateErrorScreen.h b/4dm.h/StateErrorScreen.h
index f2990c2..4c5017b 100644
--- a/4dm.h/StateErrorScreen.h
+++ b/4dm.h/StateErrorScreen.h
@@ -19,31 +19,31 @@ namespace fdm
 
 		inline static void okButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATEERRORSCREEN_OKBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateErrorScreen::okButtonCallback))(user);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s)>(FUNC_STATEERRORSCREEN_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateErrorScreen::init))(this, s);
 		}
 		void close(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s)>(FUNC_STATEERRORSCREEN_CLOSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateErrorScreen::close))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s, double dt)>(FUNC_STATEERRORSCREEN_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateErrorScreen::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s)>(FUNC_STATEERRORSCREEN_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateErrorScreen::render))(this, s);
 		}
 		void mouseButtonInput(StateManager& s, int button, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s, int button, int action, int mods)>(FUNC_STATEERRORSCREEN_MOUSEBUTTONINPUT)(this, s, button, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s, int button, int action, int mods)>(getFuncAddr((int)Func::StateErrorScreen::mouseButtonInput))(this, s, button, action, mods);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s, int width, int height)>(FUNC_STATEERRORSCREEN_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateErrorScreen* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateErrorScreen::windowResize))(this, s, width, height);
 		}
 	};
 }
diff --git a/4dm.h/StateGame.h b/4dm.h/StateGame.h
index 6022636..b4928a6 100644
--- a/4dm.h/StateGame.h
+++ b/4dm.h/StateGame.h
@@ -9,9 +9,8 @@ namespace fdm
 	{
 	public:
 		inline static StateGame* instanceObj = reinterpret_cast<StateGame*>((base + 0x2BE5E0));
-		std::unique_ptr<WorldManager,std::default_delete<WorldManager> > world; // 0x8
+		std::unique_ptr<WorldManager> world; // 0x8
 		CloudManager clouds; // 0x10
-		PAD(0xA0-sizeof(CloudManager)); // ideally 0xB0, but we live in an imperfect world
 		glm::mat4 projection2D; // 0xB0
 		glm::mat4 projection3D; // 0xF0
 		Shader* cloudShader; // 0x130
@@ -49,87 +48,87 @@ namespace fdm
 		bool chatOpen; // 0xAA8
 		bool chatReady; // 0xAA9
 		PAD(0x6);
-		float lastChatMessageTime; // 0xAB0
+		double lastChatMessageTime; // 0xAB0
 
 		StateGame() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateGame* self)>(FUNC_STATEGAME_STATEGAME)(this);
+			reinterpret_cast<void(__thiscall*)(StateGame* self)>(getFuncAddr((int)Func::StateGame::StateGame))(this);
 		}
 		void resetMouse(GLFWwindow* w) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, GLFWwindow* w)>(FUNC_STATEGAME_RESETMOUSE)(this, w);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, GLFWwindow* w)>(getFuncAddr((int)Func::StateGame::resetMouse))(this, w);
 		}
 		void updateProjection2D(const glm::ivec2& size, const glm::ivec2& translate2D) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(FUNC_STATEGAME_UPDATEPROJECTION2D)(this, size, translate2D);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(getFuncAddr((int)Func::StateGame::updateProjection2D))(this, size, translate2D);
 		}
 		inline static void viewportCallback(void* user, const glm::ivec4& pos, const glm::ivec2& scroll) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(FUNC_STATEGAME_VIEWPORTCALLBACK)(user, pos, scroll);
+			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(getFuncAddr((int)Func::StateGame::viewportCallback))(user, pos, scroll);
 		}
 		void updateChatMessages() 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self)>(FUNC_STATEGAME_UPDATECHATMESSAGES)(this);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self)>(getFuncAddr((int)Func::StateGame::updateChatMessages))(this);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s)>(FUNC_STATEGAME_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s)>(getFuncAddr((int)Func::StateGame::init))(this, s);
 		}
 		void close(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s)>(FUNC_STATEGAME_CLOSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s)>(getFuncAddr((int)Func::StateGame::close))(this, s);
 		}
 		void pause(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s)>(FUNC_STATEGAME_PAUSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s)>(getFuncAddr((int)Func::StateGame::pause))(this, s);
 		}
 		void resume(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s)>(FUNC_STATEGAME_RESUME)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s)>(getFuncAddr((int)Func::StateGame::resume))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, double dt)>(FUNC_STATEGAME_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateGame::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s)>(FUNC_STATEGAME_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s)>(getFuncAddr((int)Func::StateGame::render))(this, s);
 		}
 		void mouseInput(StateManager& s, double xpos, double ypos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, double xpos, double ypos)>(FUNC_STATEGAME_MOUSEINPUT)(this, s, xpos, ypos);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, double xpos, double ypos)>(getFuncAddr((int)Func::StateGame::mouseInput))(this, s, xpos, ypos);
 		}
 		void scrollInput(StateManager& s, double xoffset, double yoffset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, double xoffset, double yoffset)>(FUNC_STATEGAME_SCROLLINPUT)(this, s, xoffset, yoffset);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, double xoffset, double yoffset)>(getFuncAddr((int)Func::StateGame::scrollInput))(this, s, xoffset, yoffset);
 		}
 		void mouseButtonInput(StateManager& s, int button, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, int button, int action, int mods)>(FUNC_STATEGAME_MOUSEBUTTONINPUT)(this, s, button, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, int button, int action, int mods)>(getFuncAddr((int)Func::StateGame::mouseButtonInput))(this, s, button, action, mods);
 		}
 		void keyInput(StateManager& s, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, int key, int scancode, int action, int mods)>(FUNC_STATEGAME_KEYINPUT)(this, s, key, scancode, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::StateGame::keyInput))(this, s, key, scancode, action, mods);
 		}
 		void windowResize(StateManager& s, GLsizei width, GLsizei height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, GLsizei width, GLsizei height)>(FUNC_STATEGAME_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, GLsizei width, GLsizei height)>(getFuncAddr((int)Func::StateGame::windowResize))(this, s, width, height);
 		}
 		void charInput(StateManager& s, uint32_t codepoint) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, uint32_t codepoint)>(FUNC_STATEGAME_CHARINPUT)(this, s, codepoint);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, StateManager& s, uint32_t codepoint)>(getFuncAddr((int)Func::StateGame::charInput))(this, s, codepoint);
 		}
 		void updateProjection(GLsizei width, GLsizei height) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, GLsizei width, GLsizei height)>(FUNC_STATEGAME_UPDATEPROJECTION)(this, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, GLsizei width, GLsizei height)>(getFuncAddr((int)Func::StateGame::updateProjection))(this, width, height);
 		}
 		void setWorld(std::unique_ptr<WorldManager>& world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, std::unique_ptr<WorldManager>& world)>(FUNC_STATEGAME_SETWORLD)(this, world);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, std::unique_ptr<WorldManager>& world)>(getFuncAddr((int)Func::StateGame::setWorld))(this, world);
 		}
-		void addChatMessage(Player* player, const std::string& message, uint32_t color) 
+		void addChatMessage(Player* player, const msvc_string& message, uint32_t color) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateGame* self, Player* player, const std::string& message, uint32_t color)>(FUNC_STATEGAME_ADDCHATMESSAGE)(this, player, message, color);
+			return reinterpret_cast<void (__thiscall*)(StateGame* self, Player* player, const msvc_string& message, uint32_t color)>(getFuncAddr((int)Func::StateGame::addChatMessage))(this, player, message, color);
 		}
 	};
 }
diff --git a/4dm.h/StateIntro.h b/4dm.h/StateIntro.h
index fecd20b..5a6c21b 100644
--- a/4dm.h/StateIntro.h
+++ b/4dm.h/StateIntro.h
@@ -31,27 +31,27 @@ namespace fdm
 
 		void updateProjection(int width, int height) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateIntro* self, int width, int height)>(FUNC_STATEINTRO_UPDATEPROJECTION)(this, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateIntro* self, int width, int height)>(getFuncAddr((int)Func::StateIntro::updateProjection))(this, width, height);
 		}
 		void loadFiles() 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateIntro* self)>(FUNC_STATEINTRO_LOADFILES)(this);
+			return reinterpret_cast<void (__thiscall*)(StateIntro* self)>(getFuncAddr((int)Func::StateIntro::loadFiles))(this);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateIntro* self, StateManager& s)>(FUNC_STATEINTRO_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateIntro* self, StateManager& s)>(getFuncAddr((int)Func::StateIntro::init))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateIntro* self, StateManager& s, double dt)>(FUNC_STATEINTRO_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateIntro* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateIntro::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateIntro* self, StateManager& s)>(FUNC_STATEINTRO_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateIntro* self, StateManager& s)>(getFuncAddr((int)Func::StateIntro::render))(this, s);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateIntro* self, StateManager& s, int width, int height)>(FUNC_STATEINTRO_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateIntro* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateIntro::windowResize))(this, s, width, height);
 		}
 	};
 }
diff --git a/4dm.h/StateManager.h b/4dm.h/StateManager.h
index 54ac4d5..fa51ff4 100644
--- a/4dm.h/StateManager.h
+++ b/4dm.h/StateManager.h
@@ -1,10 +1,10 @@
 #pragma once
 
 #include "4dm.h"
+#include "State.h"
 
 namespace fdm 
 {
-	class State;
 	class StateManager 
 	{
 	public:
@@ -13,7 +13,44 @@ namespace fdm
 
 		void pushState(State* state) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateManager* self, State* state)>(FUNC_STATEMANAGER_PUSHSTATE)(this, state);
+			return reinterpret_cast<void (__thiscall*)(StateManager* self, State* state)>(getFuncAddr((int)Func::StateManager::pushState))(this, state);
+		}
+
+		// thanks mashpoe for telling me about the fact that those funcs exist
+		// thanks to me the tr1ngledev for writing them
+
+		/* // I COMPLETELY FORGOT PUSHSTATE IS COMPILED IN THE GAME AND EXISTS IN HERE LMFAO
+
+		void pushState(State* state)
+		{
+			State* lastState = states.back();
+			if (lastState != state)
+				lastState->pause(*this);
+
+			states.push_back(state);
+
+			state->init(*this);
+		}
+
+		*/
+
+		void popState()
+		{
+			if (!states.empty())
+			{
+				states.back()->close(*this);
+
+				states.pop_back();
+
+				if (!states.empty())
+					states.back()->resume(*this);
+			}
+		}
+
+		void changeState(State* newState)
+		{
+			popState();
+			pushState(newState);
 		}
 	};
 }
diff --git a/4dm.h/StateMultiplayer.h b/4dm.h/StateMultiplayer.h
index 9ac8031..74eed0d 100644
--- a/4dm.h/StateMultiplayer.h
+++ b/4dm.h/StateMultiplayer.h
@@ -38,87 +38,87 @@ namespace fdm
 
 		~StateMultiplayer() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateMultiplayer* self)>(FUNC_STATEMULTIPLAYER_DESTR_STATEMULTIPLAYER)(this);
+			reinterpret_cast<void(__thiscall*)(StateMultiplayer* self)>(getFuncAddr((int)Func::StateMultiplayer::destr_StateMultiplayer))(this);
 		}
 		StateMultiplayer() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateMultiplayer* self)>(FUNC_STATEMULTIPLAYER_STATEMULTIPLAYER)(this);
+			reinterpret_cast<void(__thiscall*)(StateMultiplayer* self)>(getFuncAddr((int)Func::StateMultiplayer::StateMultiplayer))(this);
 		}
 		void updateProjection(const glm::ivec2& size, const glm::ivec2& translate2D) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(FUNC_STATEMULTIPLAYER_UPDATEPROJECTION)(this, size, translate2D);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(getFuncAddr((int)Func::StateMultiplayer::updateProjection))(this, size, translate2D);
 		}
 		inline static void cancelButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATEMULTIPLAYER_CANCELBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateMultiplayer::cancelButtonCallback))(user);
 		}
 		inline static void changeSkinButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATEMULTIPLAYER_CHANGESKINBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateMultiplayer::changeSkinButtonCallback))(user);
 		}
 		inline static void joinButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATEMULTIPLAYER_JOINBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateMultiplayer::joinButtonCallback))(user);
 		}
 		inline static void viewportCallback(void* user, const glm::ivec4& pos, const glm::ivec2& scroll) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(FUNC_STATEMULTIPLAYER_VIEWPORTCALLBACK)(user, pos, scroll);
+			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(getFuncAddr((int)Func::StateMultiplayer::viewportCallback))(user, pos, scroll);
 		}
 		inline static void uuidCopyButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATEMULTIPLAYER_UUIDCOPYBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateMultiplayer::uuidCopyButtonCallback))(user);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s)>(FUNC_STATEMULTIPLAYER_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s)>(getFuncAddr((int)Func::StateMultiplayer::init))(this, s);
 		}
 		void close(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s)>(FUNC_STATEMULTIPLAYER_CLOSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s)>(getFuncAddr((int)Func::StateMultiplayer::close))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, double dt)>(FUNC_STATEMULTIPLAYER_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateMultiplayer::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s)>(FUNC_STATEMULTIPLAYER_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s)>(getFuncAddr((int)Func::StateMultiplayer::render))(this, s);
 		}
 		void mouseInput(StateManager& s, double xpos, double ypos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, double xpos, double ypos)>(FUNC_STATEMULTIPLAYER_MOUSEINPUT)(this, s, xpos, ypos);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, double xpos, double ypos)>(getFuncAddr((int)Func::StateMultiplayer::mouseInput))(this, s, xpos, ypos);
 		}
 		void scrollInput(StateManager& s, double xoffset, double yoffset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, double xoffset, double yoffset)>(FUNC_STATEMULTIPLAYER_SCROLLINPUT)(this, s, xoffset, yoffset);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, double xoffset, double yoffset)>(getFuncAddr((int)Func::StateMultiplayer::scrollInput))(this, s, xoffset, yoffset);
 		}
 		void mouseButtonInput(StateManager& s, int button, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, int button, int action, int mods)>(FUNC_STATEMULTIPLAYER_MOUSEBUTTONINPUT)(this, s, button, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, int button, int action, int mods)>(getFuncAddr((int)Func::StateMultiplayer::mouseButtonInput))(this, s, button, action, mods);
 		}
 		void keyInput(StateManager& s, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, int key, int scancode, int action, int mods)>(FUNC_STATEMULTIPLAYER_KEYINPUT)(this, s, key, scancode, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::StateMultiplayer::keyInput))(this, s, key, scancode, action, mods);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, int width, int height)>(FUNC_STATEMULTIPLAYER_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateMultiplayer::windowResize))(this, s, width, height);
 		}
 		void charInput(StateManager& s, uint32_t codepoint) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, uint32_t codepoint)>(FUNC_STATEMULTIPLAYER_CHARINPUT)(this, s, codepoint);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, StateManager& s, uint32_t codepoint)>(getFuncAddr((int)Func::StateMultiplayer::charInput))(this, s, codepoint);
 		}
 		void rejoin(std::shared_ptr<Connection::Client> client, const std::unique_ptr<WorldClient>& world) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, std::shared_ptr<Connection::Client> client, const std::unique_ptr<WorldClient>& world)>(FUNC_STATEMULTIPLAYER_REJOIN)(this, client, world);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self, std::shared_ptr<Connection::Client> client, const std::unique_ptr<WorldClient>& world)>(getFuncAddr((int)Func::StateMultiplayer::rejoin))(this, client, world);
 		}
 		void connect() 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self)>(FUNC_STATEMULTIPLAYER_CONNECT)(this);
+			return reinterpret_cast<void (__thiscall*)(StateMultiplayer* self)>(getFuncAddr((int)Func::StateMultiplayer::connect))(this);
 		}
 		inline static void connectionErrorOkButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATEMULTIPLAYER_CONNECTIONERROROKBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateMultiplayer::connectionErrorOkButtonCallback))(user);
 		}
 	};
 }
diff --git a/4dm.h/StatePause.h b/4dm.h/StatePause.h
index 1ec36db..1543410 100644
--- a/4dm.h/StatePause.h
+++ b/4dm.h/StatePause.h
@@ -23,31 +23,31 @@ namespace fdm
 
 		StatePause() 
 		{
-			reinterpret_cast<void(__thiscall*)(StatePause* self)>(FUNC_STATEPAUSE_STATEPAUSE)(this);
+			reinterpret_cast<void(__thiscall*)(StatePause* self)>(getFuncAddr((int)Func::StatePause::StatePause))(this);
 		}
 		void updateProjection(const glm::ivec2& size, const glm::ivec2& translate2D) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StatePause* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(FUNC_STATEPAUSE_UPDATEPROJECTION)(this, size, translate2D);
+			return reinterpret_cast<void (__thiscall*)(StatePause* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(getFuncAddr((int)Func::StatePause::updateProjection))(this, size, translate2D);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StatePause* self, StateManager& s, double dt)>(FUNC_STATEPAUSE_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StatePause* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StatePause::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StatePause* self, StateManager& s)>(FUNC_STATEPAUSE_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StatePause* self, StateManager& s)>(getFuncAddr((int)Func::StatePause::render))(this, s);
 		}
 		void pause(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StatePause* self, StateManager& s)>(FUNC_STATEPAUSE_PAUSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StatePause* self, StateManager& s)>(getFuncAddr((int)Func::StatePause::pause))(this, s);
 		}
 		void resume(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StatePause* self, StateManager& s)>(FUNC_STATEPAUSE_RESUME)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StatePause* self, StateManager& s)>(getFuncAddr((int)Func::StatePause::resume))(this, s);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StatePause* self, StateManager& s, int width, int height)>(FUNC_STATEPAUSE_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StatePause* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StatePause::windowResize))(this, s, width, height);
 		}
 	};
 }
diff --git a/4dm.h/StateSettings.h b/4dm.h/StateSettings.h
index c1dcc5f..961a671 100644
--- a/4dm.h/StateSettings.h
+++ b/4dm.h/StateSettings.h
@@ -91,179 +91,179 @@ namespace fdm
 
 		void updateProjection(const glm::ivec2& size, const glm::ivec2& translate2D) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(FUNC_STATESETTINGS_UPDATEPROJECTION)(this, size, translate2D);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(getFuncAddr((int)Func::StateSettings::updateProjection))(this, size, translate2D);
 		}
 		~StateSettings() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateSettings* self)>(FUNC_STATESETTINGS_DESTR_STATESETTINGS)(this);
+			reinterpret_cast<void(__thiscall*)(StateSettings* self)>(getFuncAddr((int)Func::StateSettings::destr_StateSettings))(this);
 		}
 		StateSettings() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateSettings* self)>(FUNC_STATESETTINGS_STATESETTINGS)(this);
+			reinterpret_cast<void(__thiscall*)(StateSettings* self)>(getFuncAddr((int)Func::StateSettings::StateSettings))(this);
 		}
-		nlohmann::json getSetting(std::string& settingName, nlohmann::json& settings, const nlohmann::json& defaultSettings) 
+		nlohmann::json getSetting(msvc_string& settingName, nlohmann::json& settings, const nlohmann::json& defaultSettings) 
 		{
-			return reinterpret_cast<nlohmann::json (__thiscall*)(StateSettings* self, std::string& settingName, nlohmann::json& settings, const nlohmann::json& defaultSettings)>(FUNC_STATESETTINGS_GETSETTING)(this, settingName, settings, defaultSettings);
+			return reinterpret_cast<nlohmann::json (__thiscall*)(StateSettings* self, msvc_string& settingName, nlohmann::json& settings, const nlohmann::json& defaultSettings)>(getFuncAddr((int)Func::StateSettings::getSetting))(this, settingName, settings, defaultSettings);
 		}
 		inline static void renderDistanceSliderCallback(void* user, int value) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(FUNC_STATESETTINGS_RENDERDISTANCESLIDERCALLBACK)(user, value);
+			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(getFuncAddr((int)Func::StateSettings::renderDistanceSliderCallback))(user, value);
 		}
 		inline static void scrollSensitivitySliderCallback(void* user, int value) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(FUNC_STATESETTINGS_SCROLLSENSITIVITYSLIDERCALLBACK)(user, value);
+			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(getFuncAddr((int)Func::StateSettings::scrollSensitivitySliderCallback))(user, value);
 		}
 		inline static void lookSensitivitySliderCallback(void* user, int value) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(FUNC_STATESETTINGS_LOOKSENSITIVITYSLIDERCALLBACK)(user, value);
+			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(getFuncAddr((int)Func::StateSettings::lookSensitivitySliderCallback))(user, value);
 		}
 		inline static void xInvertCheckBoxCallback(void* user, bool checked) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(FUNC_STATESETTINGS_XINVERTCHECKBOXCALLBACK)(user, checked);
+			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(getFuncAddr((int)Func::StateSettings::xInvertCheckBoxCallback))(user, checked);
 		}
 		inline static void yInvertCheckBoxCallback(void* user, bool checked) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(FUNC_STATESETTINGS_YINVERTCHECKBOXCALLBACK)(user, checked);
+			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(getFuncAddr((int)Func::StateSettings::yInvertCheckBoxCallback))(user, checked);
 		}
 		inline static void fovSliderCallback(void* user, int value) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(FUNC_STATESETTINGS_FOVSLIDERCALLBACK)(user, value);
+			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(getFuncAddr((int)Func::StateSettings::fovSliderCallback))(user, value);
 		}
 		inline static void globalVolumeSliderCallback(void* user, int value) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(FUNC_STATESETTINGS_GLOBALVOLUMESLIDERCALLBACK)(user, value);
+			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(getFuncAddr((int)Func::StateSettings::globalVolumeSliderCallback))(user, value);
 		}
 		inline static void musicVolumeSliderCallback(void* user, int value) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(FUNC_STATESETTINGS_MUSICVOLUMESLIDERCALLBACK)(user, value);
+			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(getFuncAddr((int)Func::StateSettings::musicVolumeSliderCallback))(user, value);
 		}
 		inline static void creatureVolumeSliderCallback(void* user, int value) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(FUNC_STATESETTINGS_CREATUREVOLUMESLIDERCALLBACK)(user, value);
+			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(getFuncAddr((int)Func::StateSettings::creatureVolumeSliderCallback))(user, value);
 		}
 		inline static void ambienceVolumeSliderCallback(void* user, int value) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(FUNC_STATESETTINGS_AMBIENCEVOLUMESLIDERCALLBACK)(user, value);
+			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(getFuncAddr((int)Func::StateSettings::ambienceVolumeSliderCallback))(user, value);
 		}
 		inline static void controlsButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATESETTINGS_CONTROLSBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateSettings::controlsButtonCallback))(user);
 		}
 		inline static void controlsOkButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATESETTINGS_CONTROLSOKBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateSettings::controlsOkButtonCallback))(user);
 		}
 		inline static void fullscreenButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATESETTINGS_FULLSCREENBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateSettings::fullscreenButtonCallback))(user);
 		}
 		inline static void difficultySliderCallback(void* user, int value) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(FUNC_STATESETTINGS_DIFFICULTYSLIDERCALLBACK)(user, value);
+			return reinterpret_cast<void (__fastcall*)(void* user, int value)>(getFuncAddr((int)Func::StateSettings::difficultySliderCallback))(user, value);
 		}
 		inline static void smoothLightingCheckBoxCallback(void* user, bool checked) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(FUNC_STATESETTINGS_SMOOTHLIGHTINGCHECKBOXCALLBACK)(user, checked);
+			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(getFuncAddr((int)Func::StateSettings::smoothLightingCheckBoxCallback))(user, checked);
 		}
 		inline static void shadowsCheckBoxCallback(void* user, bool checked) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(FUNC_STATESETTINGS_SHADOWSCHECKBOXCALLBACK)(user, checked);
+			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(getFuncAddr((int)Func::StateSettings::shadowsCheckBoxCallback))(user, checked);
 		}
 		inline static void lightsCheckBoxCallback(void* user, bool checked) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(FUNC_STATESETTINGS_LIGHTSCHECKBOXCALLBACK)(user, checked);
+			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(getFuncAddr((int)Func::StateSettings::lightsCheckBoxCallback))(user, checked);
 		}
 		inline static void chatCheckBoxCallback(void* user, bool checked) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(FUNC_STATESETTINGS_CHATCHECKBOXCALLBACK)(user, checked);
+			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(getFuncAddr((int)Func::StateSettings::chatCheckBoxCallback))(user, checked);
 		}
 		inline static void nametagsCheckBoxCallback(void* user, bool checked) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(FUNC_STATESETTINGS_NAMETAGSCHECKBOXCALLBACK)(user, checked);
+			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(getFuncAddr((int)Func::StateSettings::nametagsCheckBoxCallback))(user, checked);
 		}
 		inline static void skinsCheckBoxCallback(void* user, bool checked) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(FUNC_STATESETTINGS_SKINSCHECKBOXCALLBACK)(user, checked);
+			return reinterpret_cast<void (__fastcall*)(void* user, bool checked)>(getFuncAddr((int)Func::StateSettings::skinsCheckBoxCallback))(user, checked);
 		}
 		inline static void secretButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATESETTINGS_SECRETBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateSettings::secretButtonCallback))(user);
 		}
 		inline static void viewportCallback(void* user, const glm::ivec4& pos, const glm::ivec2& scroll) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(FUNC_STATESETTINGS_VIEWPORTCALLBACK)(user, pos, scroll);
+			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(getFuncAddr((int)Func::StateSettings::viewportCallback))(user, pos, scroll);
 		}
 		void updateStateGame() 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self)>(FUNC_STATESETTINGS_UPDATESTATEGAME)(this);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self)>(getFuncAddr((int)Func::StateSettings::updateStateGame))(this);
 		}
 		void updateVolume() 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self)>(FUNC_STATESETTINGS_UPDATEVOLUME)(this);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self)>(getFuncAddr((int)Func::StateSettings::updateVolume))(this);
 		}
 		void load(GLFWwindow* window) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, GLFWwindow* window)>(FUNC_STATESETTINGS_LOAD)(this, window);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, GLFWwindow* window)>(getFuncAddr((int)Func::StateSettings::load))(this, window);
 		}
 		void save() 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self)>(FUNC_STATESETTINGS_SAVE)(this);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self)>(getFuncAddr((int)Func::StateSettings::save))(this);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s)>(FUNC_STATESETTINGS_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s)>(getFuncAddr((int)Func::StateSettings::init))(this, s);
 		}
 		void close(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s)>(FUNC_STATESETTINGS_CLOSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s)>(getFuncAddr((int)Func::StateSettings::close))(this, s);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s)>(FUNC_STATESETTINGS_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s)>(getFuncAddr((int)Func::StateSettings::render))(this, s);
 		}
 		void mouseInput(StateManager& s, double xpos, double ypos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s, double xpos, double ypos)>(FUNC_STATESETTINGS_MOUSEINPUT)(this, s, xpos, ypos);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s, double xpos, double ypos)>(getFuncAddr((int)Func::StateSettings::mouseInput))(this, s, xpos, ypos);
 		}
 		void scrollInput(StateManager& s, double xoffset, double yoffset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s, double xoffset, double yoffset)>(FUNC_STATESETTINGS_SCROLLINPUT)(this, s, xoffset, yoffset);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s, double xoffset, double yoffset)>(getFuncAddr((int)Func::StateSettings::scrollInput))(this, s, xoffset, yoffset);
 		}
 		void mouseButtonInput(StateManager& s, int button, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s, int button, int action, int mods)>(FUNC_STATESETTINGS_MOUSEBUTTONINPUT)(this, s, button, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s, int button, int action, int mods)>(getFuncAddr((int)Func::StateSettings::mouseButtonInput))(this, s, button, action, mods);
 		}
 		void keyInput(StateManager& s, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s, int key, int scancode, int action, int mods)>(FUNC_STATESETTINGS_KEYINPUT)(this, s, key, scancode, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::StateSettings::keyInput))(this, s, key, scancode, action, mods);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s, int width, int height)>(FUNC_STATESETTINGS_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateSettings::windowResize))(this, s, width, height);
 		}
 		void updateRenderDistance(int value) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, int value)>(FUNC_STATESETTINGS_UPDATERENDERDISTANCE)(this, value);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, int value)>(getFuncAddr((int)Func::StateSettings::updateRenderDistance))(this, value);
 		}
 		void updateFOV(int value) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, int value)>(FUNC_STATESETTINGS_UPDATEFOV)(this, value);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, int value)>(getFuncAddr((int)Func::StateSettings::updateFOV))(this, value);
 		}
 		void updateCreatureVolume(int value) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, int value)>(FUNC_STATESETTINGS_UPDATECREATUREVOLUME)(this, value);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, int value)>(getFuncAddr((int)Func::StateSettings::updateCreatureVolume))(this, value);
 		}
 		void updateAmbienceVolume(int value) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, int value)>(FUNC_STATESETTINGS_UPDATEAMBIENCEVOLUME)(this, value);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, int value)>(getFuncAddr((int)Func::StateSettings::updateAmbienceVolume))(this, value);
 		}
 		void updateDifficulty(int value) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, int value)>(FUNC_STATESETTINGS_UPDATEDIFFICULTY)(this, value);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, int value)>(getFuncAddr((int)Func::StateSettings::updateDifficulty))(this, value);
 		}
 		void setFullscreenMode(GLFWwindow* window, bool fullscreenMode) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSettings* self, GLFWwindow* window, bool fullscreenMode)>(FUNC_STATESETTINGS_SETFULLSCREENMODE)(this, window, fullscreenMode);
+			return reinterpret_cast<void (__thiscall*)(StateSettings* self, GLFWwindow* window, bool fullscreenMode)>(getFuncAddr((int)Func::StateSettings::setFullscreenMode))(this, window, fullscreenMode);
 		}
 	};
 }
diff --git a/4dm.h/StateSingleplayer.h b/4dm.h/StateSingleplayer.h
index 1fbc56b..1539059 100644
--- a/4dm.h/StateSingleplayer.h
+++ b/4dm.h/StateSingleplayer.h
@@ -20,60 +20,60 @@ namespace fdm
 		gui::Text yourWorlds; // 0x278
 		gui::Text noWorlds; // 0x2D0
 		std::vector<gui::Button> worldButtons; // 0x328
-		std::vector<std::string> worldPaths; // 0x340
+		std::vector<msvc_string> worldPaths; // 0x340
 		bool shouldLoadWorld; // 0x358
 
 		void mouseButtonInput(StateManager& s, int button, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s, int button, int action, int mods)>(FUNC_STATESINGLEPLAYER_MOUSEBUTTONINPUT)(this, s, button, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s, int button, int action, int mods)>(getFuncAddr((int)Func::StateSingleplayer::mouseButtonInput))(this, s, button, action, mods);
 		}
 		void updateProjection(const glm::ivec2& size, const glm::ivec2& translate2D) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(FUNC_STATESINGLEPLAYER_UPDATEPROJECTION)(this, size, translate2D);
+			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(getFuncAddr((int)Func::StateSingleplayer::updateProjection))(this, size, translate2D);
 		}
 		StateSingleplayer() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateSingleplayer* self)>(FUNC_STATESINGLEPLAYER_STATESINGLEPLAYER)(this);
+			reinterpret_cast<void(__thiscall*)(StateSingleplayer* self)>(getFuncAddr((int)Func::StateSingleplayer::StateSingleplayer))(this);
 		}
 		void updateWorldListContainer(int wWidth, int wHeight) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, int wWidth, int wHeight)>(FUNC_STATESINGLEPLAYER_UPDATEWORLDLISTCONTAINER)(this, wWidth, wHeight);
+			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, int wWidth, int wHeight)>(getFuncAddr((int)Func::StateSingleplayer::updateWorldListContainer))(this, wWidth, wHeight);
 		}
 		inline static void createCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATESINGLEPLAYER_CREATECALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateSingleplayer::createCallback))(user);
 		}
 		inline static void viewportCallback(void* user, const glm::ivec4& pos, const glm::ivec2& scroll) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(FUNC_STATESINGLEPLAYER_VIEWPORTCALLBACK)(user, pos, scroll);
+			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(getFuncAddr((int)Func::StateSingleplayer::viewportCallback))(user, pos, scroll);
 		}
 		inline static void worldButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATESINGLEPLAYER_WORLDBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateSingleplayer::worldButtonCallback))(user);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s)>(FUNC_STATESINGLEPLAYER_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s)>(getFuncAddr((int)Func::StateSingleplayer::init))(this, s);
 		}
 		void close(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s)>(FUNC_STATESINGLEPLAYER_CLOSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s)>(getFuncAddr((int)Func::StateSingleplayer::close))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s, double dt)>(FUNC_STATESINGLEPLAYER_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateSingleplayer::update))(this, s, dt);
 		}
 		void resume(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s)>(FUNC_STATESINGLEPLAYER_RESUME)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s)>(getFuncAddr((int)Func::StateSingleplayer::resume))(this, s);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s, int width, int height)>(FUNC_STATESINGLEPLAYER_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateSingleplayer::windowResize))(this, s, width, height);
 		}
-		void queueWorldLoad(std::string& path) 
+		void queueWorldLoad(msvc_string& path) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, std::string& path)>(FUNC_STATESINGLEPLAYER_QUEUEWORLDLOAD)(this, path);
+			return reinterpret_cast<void (__thiscall*)(StateSingleplayer* self, msvc_string& path)>(getFuncAddr((int)Func::StateSingleplayer::queueWorldLoad))(this, path);
 		}
 	};
 }
diff --git a/4dm.h/StateSkinChooser.h b/4dm.h/StateSkinChooser.h
index 9510c38..47c7844 100644
--- a/4dm.h/StateSkinChooser.h
+++ b/4dm.h/StateSkinChooser.h
@@ -7,7 +7,7 @@ namespace fdm
 	class StateSkinChooser : public State 
 	{
 	public:
-		inline static const std::string* defaultSkinPath = reinterpret_cast<const std::string*>((base + 0x2C0F40));
+		inline static const msvc_string* defaultSkinPath = reinterpret_cast<const msvc_string*>((base + 0x2C0F40));
 		inline static StateSkinChooser* instanceObj = reinterpret_cast<StateSkinChooser*>((base + 0x2C0F60));
 		FontRenderer font; // 0x8
 		QuadRenderer qr; // 0xA8
@@ -19,71 +19,72 @@ namespace fdm
 		gui::Button chooseFileButton; // 0x1A0
 		gui::Button resetOrientation; // 0x1F8
 		gui::Button resetPosition; // 0x250
-		std::string skinPath; // 0x2A8
+		msvc_string skinPath; // 0x2A8
 		PlayerSkin skin; // 0x2C8
 		PlayerSkinRenderer skinRenderer; // 0x418
 		PlayerSkinViewer skinViewer; // 0x9A8
 
 		void mouseInput(StateManager& s, double xpos, double ypos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, double xpos, double ypos)>(FUNC_STATESKINCHOOSER_MOUSEINPUT)(this, s, xpos, ypos);
+			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, double xpos, double ypos)>(getFuncAddr((int)Func::StateSkinChooser::mouseInput))(this, s, xpos, ypos);
 		}
 		void scrollInput(StateManager& s, double xoffset, double yoffset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, double xoffset, double yoffset)>(FUNC_STATESKINCHOOSER_SCROLLINPUT)(this, s, xoffset, yoffset);
+			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, double xoffset, double yoffset)>(getFuncAddr((int)Func::StateSkinChooser::scrollInput))(this, s, xoffset, yoffset);
 		}
 		void keyInput(StateManager& s, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, uint32_t key, uint32_t scancode, int action, int mods)>(FUNC_STATESKINCHOOSER_KEYINPUT)(this, s, key, scancode, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, uint32_t key, uint32_t scancode, int action, int mods)>(getFuncAddr((int)Func::StateSkinChooser::keyInput))(this, s, key, scancode, action, mods);
 		}
 		StateSkinChooser() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateSkinChooser* self)>(FUNC_STATESKINCHOOSER_STATESKINCHOOSER)(this);
+			reinterpret_cast<void(__thiscall*)(StateSkinChooser* self)>(getFuncAddr((int)Func::StateSkinChooser::StateSkinChooser))(this);
 		}
 		void updateProjection(const glm::ivec2& size, const glm::ivec2& translate2D) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(FUNC_STATESKINCHOOSER_UPDATEPROJECTION)(this, size, translate2D);
+			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(getFuncAddr((int)Func::StateSkinChooser::updateProjection))(this, size, translate2D);
 		}
 		inline static void viewportCallback(void* user, const glm::ivec4& pos, const glm::ivec2& scroll) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(FUNC_STATESKINCHOOSER_VIEWPORTCALLBACK)(user, pos, scroll);
+			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(getFuncAddr((int)Func::StateSkinChooser::viewportCallback))(user, pos, scroll);
 		}
 		inline static void chooseFileButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATESKINCHOOSER_CHOOSEFILEBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateSkinChooser::chooseFileButtonCallback))(user);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s)>(FUNC_STATESKINCHOOSER_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s)>(getFuncAddr((int)Func::StateSkinChooser::init))(this, s);
 		}
 		void close(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s)>(FUNC_STATESKINCHOOSER_CLOSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s)>(getFuncAddr((int)Func::StateSkinChooser::close))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, double dt)>(FUNC_STATESKINCHOOSER_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateSkinChooser::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s)>(FUNC_STATESKINCHOOSER_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s)>(getFuncAddr((int)Func::StateSkinChooser::render))(this, s);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, int width, int height)>(FUNC_STATESKINCHOOSER_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateSkinChooser::windowResize))(this, s, width, height);
 		}
 		void fileDrop(StateManager& s, int path_count, const char* *paths) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, int path_count, const char* *paths)>(FUNC_STATESKINCHOOSER_FILEDROP)(this, s, path_count, paths);
+			return reinterpret_cast<void (__thiscall*)(StateSkinChooser* self, StateManager& s, int path_count, const char* *paths)>(getFuncAddr((int)Func::StateSkinChooser::fileDrop))(this, s, path_count, paths);
 		}
 		Connection::OutMessage getSkinMessage() 
 		{
 			Connection::OutMessage result;
-			return reinterpret_cast<Connection::OutMessage (__thiscall*)(StateSkinChooser* self, Connection::OutMessage* result)>(FUNC_STATESKINCHOOSER_GETSKINMESSAGE)(this, &result);
+			reinterpret_cast<Connection::OutMessage* (__thiscall*)(StateSkinChooser* self, Connection::OutMessage* result)>(getFuncAddr((int)Func::StateSkinChooser::getSkinMessage))(this, &result);
+			return result;
 		}
 		bool loadSkin(path* p) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(StateSkinChooser* self, path* p)>(FUNC_STATESKINCHOOSER_LOADSKIN)(this, p);
+			return reinterpret_cast<bool (__thiscall*)(StateSkinChooser* self, path* p)>(getFuncAddr((int)Func::StateSkinChooser::loadSkin))(this, p);
 		}
 	};
 }
diff --git a/4dm.h/StateTitleScreen.h b/4dm.h/StateTitleScreen.h
index cd71ff0..d06778e 100644
--- a/4dm.h/StateTitleScreen.h
+++ b/4dm.h/StateTitleScreen.h
@@ -36,79 +36,79 @@ namespace fdm
 
 		inline static void quitGameButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATETITLESCREEN_QUITGAMEBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateTitleScreen::quitGameButtonCallback))(user);
 		}
 		inline static void settingsButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATETITLESCREEN_SETTINGSBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateTitleScreen::settingsButtonCallback))(user);
 		}
 		StateTitleScreen() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateTitleScreen* self)>(FUNC_STATETITLESCREEN_STATETITLESCREEN)(this);
+			reinterpret_cast<void(__thiscall*)(StateTitleScreen* self)>(getFuncAddr((int)Func::StateTitleScreen::StateTitleScreen))(this);
 		}
 		void updateProjection(int width, int height) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, int width, int height)>(FUNC_STATETITLESCREEN_UPDATEPROJECTION)(this, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, int width, int height)>(getFuncAddr((int)Func::StateTitleScreen::updateProjection))(this, width, height);
 		}
 		inline static void singleplayerButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATETITLESCREEN_SINGLEPLAYERBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateTitleScreen::singleplayerButtonCallback))(user);
 		}
 		inline static void multiplayerplayerButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATETITLESCREEN_MULTIPLAYERPLAYERBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateTitleScreen::multiplayerplayerButtonCallback))(user);
 		}
 		inline static void creditsButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATETITLESCREEN_CREDITSBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateTitleScreen::creditsButtonCallback))(user);
 		}
 		inline static void tutorialButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATETITLESCREEN_TUTORIALBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateTitleScreen::tutorialButtonCallback))(user);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s)>(FUNC_STATETITLESCREEN_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateTitleScreen::init))(this, s);
 		}
 		void close(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s)>(FUNC_STATETITLESCREEN_CLOSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateTitleScreen::close))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s, double dt)>(FUNC_STATETITLESCREEN_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateTitleScreen::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s)>(FUNC_STATETITLESCREEN_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateTitleScreen::render))(this, s);
 		}
 		void pause(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s)>(FUNC_STATETITLESCREEN_PAUSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateTitleScreen::pause))(this, s);
 		}
 		void resume(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s)>(FUNC_STATETITLESCREEN_RESUME)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s)>(getFuncAddr((int)Func::StateTitleScreen::resume))(this, s);
 		}
 		void keyInput(StateManager& s, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s, int key, int scancode, int action, int mods)>(FUNC_STATETITLESCREEN_KEYINPUT)(this, s, key, scancode, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::StateTitleScreen::keyInput))(this, s, key, scancode, action, mods);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s, int width, int height)>(FUNC_STATETITLESCREEN_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateTitleScreen::windowResize))(this, s, width, height);
 		}
 		void mouseInput(StateManager& s, double xpos, double ypos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s, double xpos, double ypos)>(FUNC_STATETITLESCREEN_MOUSEINPUT)(this, s, xpos, ypos);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s, double xpos, double ypos)>(getFuncAddr((int)Func::StateTitleScreen::mouseInput))(this, s, xpos, ypos);
 		}
 		void mouseButtonInput(StateManager& s, int button, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s, int button, int action, int mods)>(FUNC_STATETITLESCREEN_MOUSEBUTTONINPUT)(this, s, button, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, StateManager& s, int button, int action, int mods)>(getFuncAddr((int)Func::StateTitleScreen::mouseButtonInput))(this, s, button, action, mods);
 		}
 		void renderBackground(int width, int height) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, int width, int height)>(FUNC_STATETITLESCREEN_RENDERBACKGROUND)(this, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateTitleScreen* self, int width, int height)>(getFuncAddr((int)Func::StateTitleScreen::renderBackground))(this, width, height);
 		}
 	};
 }
diff --git a/4dm.h/StateTutorial.h b/4dm.h/StateTutorial.h
index 79a9e50..d251f27 100644
--- a/4dm.h/StateTutorial.h
+++ b/4dm.h/StateTutorial.h
@@ -95,99 +95,99 @@ namespace fdm
 
 		~StateTutorial() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateTutorial* self)>(FUNC_STATETUTORIAL_DESTR_STATETUTORIAL)(this);
+			reinterpret_cast<void(__thiscall*)(StateTutorial* self)>(getFuncAddr((int)Func::StateTutorial::destr_StateTutorial))(this);
 		}
 		StateTutorial() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateTutorial* self)>(FUNC_STATETUTORIAL_STATETUTORIAL)(this);
+			reinterpret_cast<void(__thiscall*)(StateTutorial* self)>(getFuncAddr((int)Func::StateTutorial::StateTutorial))(this);
 		}
 		void updateProjection(const glm::ivec2& size, const glm::ivec2& translate2D) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(FUNC_STATETUTORIAL_UPDATEPROJECTION)(this, size, translate2D);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(getFuncAddr((int)Func::StateTutorial::updateProjection))(this, size, translate2D);
 		}
 		inline static void backButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATETUTORIAL_BACKBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateTutorial::backButtonCallback))(user);
 		}
 		inline static void nextButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATETUTORIAL_NEXTBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateTutorial::nextButtonCallback))(user);
 		}
 		void generateMesh() 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self)>(FUNC_STATETUTORIAL_GENERATEMESH)(this);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self)>(getFuncAddr((int)Func::StateTutorial::generateMesh))(this);
 		}
 		void getSmoothLighting(const glm::ivec3& block, unsigned char face, unsigned char* lighting) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, const glm::ivec3& block, unsigned char face, unsigned char* lighting)>(FUNC_STATETUTORIAL_GETSMOOTHLIGHTING)(this, block, face, lighting);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, const glm::ivec3& block, unsigned char face, unsigned char* lighting)>(getFuncAddr((int)Func::StateTutorial::getSmoothLighting))(this, block, face, lighting);
 		}
 		void updatePlayerComponentVectors() 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self)>(FUNC_STATETUTORIAL_UPDATEPLAYERCOMPONENTVECTORS)(this);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self)>(getFuncAddr((int)Func::StateTutorial::updatePlayerComponentVectors))(this);
 		}
 		void updatePlayerPos() 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self)>(FUNC_STATETUTORIAL_UPDATEPLAYERPOS)(this);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self)>(getFuncAddr((int)Func::StateTutorial::updatePlayerPos))(this);
 		}
 		void updateCurrentBlock() 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self)>(FUNC_STATETUTORIAL_UPDATECURRENTBLOCK)(this);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self)>(getFuncAddr((int)Func::StateTutorial::updateCurrentBlock))(this);
 		}
 		bool handleCollision(const glm::vec3& foot, const glm::vec3& head, uint32_t face) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(StateTutorial* self, const glm::vec3& foot, const glm::vec3& head, uint32_t face)>(FUNC_STATETUTORIAL_HANDLECOLLISION)(this, foot, head, face);
+			return reinterpret_cast<bool (__thiscall*)(StateTutorial* self, const glm::vec3& foot, const glm::vec3& head, uint32_t face)>(getFuncAddr((int)Func::StateTutorial::handleCollision))(this, foot, head, face);
 		}
 		void setForgSprite(int x, int y) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, int x, int y)>(FUNC_STATETUTORIAL_SETFORGSPRITE)(this, x, y);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, int x, int y)>(getFuncAddr((int)Func::StateTutorial::setForgSprite))(this, x, y);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s)>(FUNC_STATETUTORIAL_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s)>(getFuncAddr((int)Func::StateTutorial::init))(this, s);
 		}
 		void close(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s)>(FUNC_STATETUTORIAL_CLOSE)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s)>(getFuncAddr((int)Func::StateTutorial::close))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, double dt)>(FUNC_STATETUTORIAL_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateTutorial::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s)>(FUNC_STATETUTORIAL_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s)>(getFuncAddr((int)Func::StateTutorial::render))(this, s);
 		}
 		void resume(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s)>(FUNC_STATETUTORIAL_RESUME)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s)>(getFuncAddr((int)Func::StateTutorial::resume))(this, s);
 		}
 		void mouseInput(StateManager& s, double xpos, double ypos) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, double xpos, double ypos)>(FUNC_STATETUTORIAL_MOUSEINPUT)(this, s, xpos, ypos);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, double xpos, double ypos)>(getFuncAddr((int)Func::StateTutorial::mouseInput))(this, s, xpos, ypos);
 		}
 		void scrollInput(StateManager& s, double xoffset, double yoffset) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, double xoffset, double yoffset)>(FUNC_STATETUTORIAL_SCROLLINPUT)(this, s, xoffset, yoffset);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, double xoffset, double yoffset)>(getFuncAddr((int)Func::StateTutorial::scrollInput))(this, s, xoffset, yoffset);
 		}
 		void mouseButtonInput(StateManager& s, int button, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, int button, int action, int mods)>(FUNC_STATETUTORIAL_MOUSEBUTTONINPUT)(this, s, button, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, int button, int action, int mods)>(getFuncAddr((int)Func::StateTutorial::mouseButtonInput))(this, s, button, action, mods);
 		}
 		void keyInput(StateManager& s, int key, int scancode, int action, int mods) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, int key, int scancode, int action, int mods)>(FUNC_STATETUTORIAL_KEYINPUT)(this, s, key, scancode, action, mods);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, int key, int scancode, int action, int mods)>(getFuncAddr((int)Func::StateTutorial::keyInput))(this, s, key, scancode, action, mods);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, int width, int height)>(FUNC_STATETUTORIAL_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateTutorial::windowResize))(this, s, width, height);
 		}
 		void charInput(StateManager& s, uint32_t codepoint) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, uint32_t codepoint)>(FUNC_STATETUTORIAL_CHARINPUT)(this, s, codepoint);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, StateManager& s, uint32_t codepoint)>(getFuncAddr((int)Func::StateTutorial::charInput))(this, s, codepoint);
 		}
 		void updateViewport(GLFWwindow* w, const glm::ivec4& pos, const glm::ivec2& scroll) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, GLFWwindow* w, const glm::ivec4& pos, const glm::ivec2& scroll)>(FUNC_STATETUTORIAL_UPDATEVIEWPORT)(this, w, pos, scroll);
+			return reinterpret_cast<void (__thiscall*)(StateTutorial* self, GLFWwindow* w, const glm::ivec4& pos, const glm::ivec2& scroll)>(getFuncAddr((int)Func::StateTutorial::updateViewport))(this, w, pos, scroll);
 		}
 	};
 }
diff --git a/4dm.h/StateTutorialSlideshow.h b/4dm.h/StateTutorialSlideshow.h
index 4bf4d0c..4e24afc 100644
--- a/4dm.h/StateTutorialSlideshow.h
+++ b/4dm.h/StateTutorialSlideshow.h
@@ -47,55 +47,55 @@ namespace fdm
 
 		~StateTutorialSlideshow() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateTutorialSlideshow* self)>(FUNC_STATETUTORIALSLIDESHOW_DESTR_STATETUTORIALSLIDESHOW)(this);
+			reinterpret_cast<void(__thiscall*)(StateTutorialSlideshow* self)>(getFuncAddr((int)Func::StateTutorialSlideshow::destr_StateTutorialSlideshow))(this);
 		}
 		StateTutorialSlideshow() 
 		{
-			reinterpret_cast<void(__thiscall*)(StateTutorialSlideshow* self)>(FUNC_STATETUTORIALSLIDESHOW_STATETUTORIALSLIDESHOW)(this);
+			reinterpret_cast<void(__thiscall*)(StateTutorialSlideshow* self)>(getFuncAddr((int)Func::StateTutorialSlideshow::StateTutorialSlideshow))(this);
 		}
 		void updateProjection(const glm::ivec2& size, const glm::ivec2& translate2D) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(FUNC_STATETUTORIALSLIDESHOW_UPDATEPROJECTION)(this, size, translate2D);
+			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, const glm::ivec2& size, const glm::ivec2& translate2D)>(getFuncAddr((int)Func::StateTutorialSlideshow::updateProjection))(this, size, translate2D);
 		}
 		void updateSlideSize(int width, int height) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, int width, int height)>(FUNC_STATETUTORIALSLIDESHOW_UPDATESLIDESIZE)(this, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, int width, int height)>(getFuncAddr((int)Func::StateTutorialSlideshow::updateSlideSize))(this, width, height);
 		}
 		inline static void viewportCallback(void* user, const glm::ivec4& pos, const glm::ivec2& scroll) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(FUNC_STATETUTORIALSLIDESHOW_VIEWPORTCALLBACK)(user, pos, scroll);
+			return reinterpret_cast<void (__fastcall*)(void* user, const glm::ivec4& pos, const glm::ivec2& scroll)>(getFuncAddr((int)Func::StateTutorialSlideshow::viewportCallback))(user, pos, scroll);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s)>(FUNC_STATETUTORIALSLIDESHOW_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s)>(getFuncAddr((int)Func::StateTutorialSlideshow::init))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s, double dt)>(FUNC_STATETUTORIALSLIDESHOW_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateTutorialSlideshow::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s)>(FUNC_STATETUTORIALSLIDESHOW_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s)>(getFuncAddr((int)Func::StateTutorialSlideshow::render))(this, s);
 		}
 		void resume(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s)>(FUNC_STATETUTORIALSLIDESHOW_RESUME)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s)>(getFuncAddr((int)Func::StateTutorialSlideshow::resume))(this, s);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s, int width, int height)>(FUNC_STATETUTORIALSLIDESHOW_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateTutorialSlideshow::windowResize))(this, s, width, height);
 		}
 		inline static void continueButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATETUTORIALSLIDESHOW_CONTINUEBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateTutorialSlideshow::continueButtonCallback))(user);
 		}
 		inline static void backButtonCallback(void* user) 
 		{
-			return reinterpret_cast<void (__fastcall*)(void* user)>(FUNC_STATETUTORIALSLIDESHOW_BACKBUTTONCALLBACK)(user);
+			return reinterpret_cast<void (__fastcall*)(void* user)>(getFuncAddr((int)Func::StateTutorialSlideshow::backButtonCallback))(user);
 		}
 		void setSlide(StateManager& s, int index) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s, int index)>(FUNC_STATETUTORIALSLIDESHOW_SETSLIDE)(this, s, index);
+			return reinterpret_cast<void (__thiscall*)(StateTutorialSlideshow* self, StateManager& s, int index)>(getFuncAddr((int)Func::StateTutorialSlideshow::setSlide))(this, s, index);
 		}
 	};
 }
diff --git a/4dm.h/StateWorldGen.h b/4dm.h/StateWorldGen.h
index 23a03c9..cbbf5bd 100644
--- a/4dm.h/StateWorldGen.h
+++ b/4dm.h/StateWorldGen.h
@@ -22,23 +22,23 @@ namespace fdm
 
 		void updateProjection(int width, int height) 
 		{
-			return reinterpret_cast<void (__thiscall*)(StateWorldGen* self, int width, int height)>(FUNC_STATEWORLDGEN_UPDATEPROJECTION)(this, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateWorldGen* self, int width, int height)>(getFuncAddr((int)Func::StateWorldGen::updateProjection))(this, width, height);
 		}
 		void init(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateWorldGen* self, StateManager& s)>(FUNC_STATEWORLDGEN_INIT)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateWorldGen* self, StateManager& s)>(getFuncAddr((int)Func::StateWorldGen::init))(this, s);
 		}
 		void update(StateManager& s, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateWorldGen* self, StateManager& s, double dt)>(FUNC_STATEWORLDGEN_UPDATE)(this, s, dt);
+			return reinterpret_cast<void (__thiscall*)(StateWorldGen* self, StateManager& s, double dt)>(getFuncAddr((int)Func::StateWorldGen::update))(this, s, dt);
 		}
 		void render(StateManager& s) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateWorldGen* self, StateManager& s)>(FUNC_STATEWORLDGEN_RENDER)(this, s);
+			return reinterpret_cast<void (__thiscall*)(StateWorldGen* self, StateManager& s)>(getFuncAddr((int)Func::StateWorldGen::render))(this, s);
 		}
 		void windowResize(StateManager& s, int width, int height) override
 		{
-			return reinterpret_cast<void (__thiscall*)(StateWorldGen* self, StateManager& s, int width, int height)>(FUNC_STATEWORLDGEN_WINDOWRESIZE)(this, s, width, height);
+			return reinterpret_cast<void (__thiscall*)(StateWorldGen* self, StateManager& s, int width, int height)>(getFuncAddr((int)Func::StateWorldGen::windowResize))(this, s, width, height);
 		}
 	};
 }
diff --git a/4dm.h/Tex2D.h b/4dm.h/Tex2D.h
index 5d707c2..3ff5b49 100644
--- a/4dm.h/Tex2D.h
+++ b/4dm.h/Tex2D.h
@@ -7,19 +7,19 @@ namespace fdm
 	class Tex2D 
 	{
 	public:
-		uint32_t ID; 
-		int width; // 0x4
-		int height; // 0x8
-		uint32_t target; // 0xC
+		unsigned int ID = 0;
+		int width = 0; // 0x4
+		int height = 0; // 0x8
+		unsigned int target = 0; // 0xC
 
 		~Tex2D() 
 		{
-			reinterpret_cast<void(__thiscall*)(Tex2D* self)>(FUNC_TEX2D_DESTR_TEX2D_A)(this);
+			reinterpret_cast<void(__thiscall*)(Tex2D* self)>(getFuncAddr((int)Func::Tex2D::destr_Tex2D))(this);
 		}
 		// decompiled from old version. since it got removed (probably optimized out) in newer versions
-		bool load(const std::string& filename)
+		bool load(const msvc_string& filename)
 		{
-			if(this->ID)
+			if (this->ID)
 			{
 				glDeleteTextures(1, &this->ID);
 				this->ID = 0;
@@ -28,27 +28,27 @@ namespace fdm
 			this->ID = OGL_texture;
 			if (!OGL_texture)
 				return false;
-			glBindTexture(GL_TEXTURE_2D, OGL_texture);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-			glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &this->width);
-			glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &this->height);
-			glBindTexture(GL_TEXTURE_2D, 0);
+			glBindTexture(target, OGL_texture);
+			glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0);
+			glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, 0);
+			glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+			glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+			glGetTexLevelParameteriv(target, 0, GL_TEXTURE_WIDTH, &this->width);
+			glGetTexLevelParameteriv(target, 0, GL_TEXTURE_HEIGHT, &this->height);
+			glBindTexture(target, 0);
 			return true;
 		}
 		bool loadRawImageData(const unsigned char* data, int texWidth, int texHeight, int channels) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Tex2D* self, const unsigned char* data, int texWidth, int texHeight, int channels)>(FUNC_TEX2D_LOADRAWIMAGEDATA_A)(this, data, texWidth, texHeight, channels);
+			return reinterpret_cast<bool (__thiscall*)(Tex2D* self, const unsigned char* data, int texWidth, int texHeight, int channels)>(getFuncAddr((int)Func::Tex2D::loadRawImageData))(this, data, texWidth, texHeight, channels);
 		}
 		bool initFromTexID(uint32_t texID) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Tex2D* self, uint32_t texID)>(FUNC_TEX2D_INITFROMTEXID_A)(this, texID);
+			return reinterpret_cast<bool (__thiscall*)(Tex2D* self, uint32_t texID)>(getFuncAddr((int)Func::Tex2D::initFromTexID))(this, texID);
 		}
 		bool loadArrayTexture(const unsigned char* data, GLint texWidth, int texHeight, int channels, int cols, int rows) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(Tex2D* self, const unsigned char* data, GLint texWidth, int texHeight, int channels, int cols, int rows)>(FUNC_TEX2D_LOADARRAYTEXTURE_A)(this, data, texWidth, texHeight, channels, cols, rows);
+			return reinterpret_cast<bool (__thiscall*)(Tex2D* self, const unsigned char* data, GLint texWidth, int texHeight, int channels, int cols, int rows)>(getFuncAddr((int)Func::Tex2D::loadArrayTexture))(this, data, texWidth, texHeight, channels, cols, rows);
 		}
 	};
 }
diff --git a/4dm.h/TexRenderer.h b/4dm.h/TexRenderer.h
index 3761d9a..b3416a9 100644
--- a/4dm.h/TexRenderer.h
+++ b/4dm.h/TexRenderer.h
@@ -14,28 +14,51 @@ namespace fdm
 
 		~TexRenderer() 
 		{
-			reinterpret_cast<void(__thiscall*)(TexRenderer* self)>(FUNC_TEXRENDERER_DESTR_TEXRENDERER)(this);
+			reinterpret_cast<void(__thiscall*)(TexRenderer* self)>(getFuncAddr((int)Func::TexRenderer::destr_TexRenderer))(this);
+		}
+		TexRenderer() {}
+		TexRenderer(const Tex2D* texture, const Shader* shader)
+		{
+			this->texture = texture;
+			this->shader = shader;
 		}
 		TexRenderer& operator=(TexRenderer& other) 
 		{
-			reinterpret_cast<TexRenderer& (__thiscall*)(TexRenderer* self, TexRenderer& other)>(FUNC_TEXRENDERER_OPERATOREQ)(this, other);
+			reinterpret_cast<TexRenderer& (__thiscall*)(TexRenderer* self, TexRenderer& other)>(getFuncAddr((int)Func::TexRenderer::operatorEq))(this, other);
 			return *this;
 		}
 		bool init() 
 		{
-			return reinterpret_cast<bool (__thiscall*)(TexRenderer* self)>(FUNC_TEXRENDERER_INIT)(this);
+			return reinterpret_cast<bool (__thiscall*)(TexRenderer* self)>(getFuncAddr((int)Func::TexRenderer::init))(this);
 		}
 		void setClip(int x, int y, int w, int h)
 		{
-			return reinterpret_cast<void (__thiscall*)(TexRenderer* self, int x, int y, int w, int h)>(FUNC_TEXRENDERER_SETCLIP)(this, x, y, w, h);
+			return reinterpret_cast<void (__thiscall*)(TexRenderer* self, int x, int y, int w, int h)>(getFuncAddr((int)Func::TexRenderer::setClip))(this, x, y, w, h);
+		}
+		void setColor(const glm::vec4 (&colors)[4])
+		{
+			glBindVertexArray(VAO);
+
+			glBindBuffer(GL_ARRAY_BUFFER, buffers[4]);
+			glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 16, colors, GL_STATIC_DRAW);
+
+			glBindVertexArray(0);
+			glBindBuffer(GL_ARRAY_BUFFER, 0);
 		}
-		void setColor(float r, float g, float b, float a) 
+		void setColor(float r, float g, float b, float a)
 		{
-			return reinterpret_cast<void (__thiscall*)(TexRenderer* self, float r, float g, float b, float a)>(FUNC_TEXRENDERER_SETCOLOR)(this, r, g, b, a);
+			setColor(
+				{
+					{r, g, b, a},
+					{r, g, b, a},
+					{r, g, b, a},
+					{r, g, b, a}
+				});
+			//return reinterpret_cast<void (__thiscall*)(TexRenderer* self, float r, float g, float b, float a)>(getFuncAddr((int)Func::TexRenderer::setColor))(this, r, g, b, a);
 		}
 		void setPos(int x, int y, int w, int h)
 		{
-			return reinterpret_cast<void (__thiscall*)(TexRenderer* self, int x, int y, int w, int h)>(FUNC_TEXRENDERER_SETPOS)(this, x, y, w, h);
+			return reinterpret_cast<void (__thiscall*)(TexRenderer* self, int x, int y, int w, int h)>(getFuncAddr((int)Func::TexRenderer::setPos))(this, x, y, w, h);
 		}
 		// thx compiler for removing that and thx to mashpoe for telling me that it exists
 		void render()
diff --git a/4dm.h/World.h b/4dm.h/World.h
index afbf008..57d60fd 100644
--- a/4dm.h/World.h
+++ b/4dm.h/World.h
@@ -26,33 +26,57 @@ namespace fdm
 
 		World() 
 		{
-			reinterpret_cast<void(__thiscall*)(World* self)>(FUNC_WORLD_WORLD)(this);
+			reinterpret_cast<void(__thiscall*)(World* self)>(getFuncAddr((int)Func::World::World))(this);
 		}
 		Chunk* getChunk(const glm::i64vec3& chunkPos) 
 		{
-			return reinterpret_cast<Chunk* (__thiscall*)(World* self, const glm::i64vec3& chunkPos)>(FUNC_WORLD_GETCHUNK)(this, chunkPos);
+			return reinterpret_cast<Chunk* (__thiscall*)(World* self, const glm::i64vec3& chunkPos)>(getFuncAddr((int)Func::World::getChunk))(this, chunkPos);
 		}
 		Chunk* getChunkFromCoords(float x, float z, float w) 
 		{
-			return reinterpret_cast<Chunk* (__thiscall*)(World* self, float x, float z, float w)>(FUNC_WORLD_GETCHUNKFROMCOORDS)(this, x, z, w);
+			return reinterpret_cast<Chunk* (__thiscall*)(World* self, float x, float z, float w)>(getFuncAddr((int)Func::World::getChunkFromCoords))(this, x, z, w);
 		}
 		Entity* getEntityIntersection(glm::vec4& a, glm::vec4& b, const uuid& ignoreEntity) 
 		{
-			return reinterpret_cast<Entity* (__thiscall*)(World* self, glm::vec4& a, glm::vec4& b, const uuid& ignoreEntity)>(FUNC_WORLD_GETENTITYINTERSECTION)(this, a, b, ignoreEntity);
+			return reinterpret_cast<Entity* (__thiscall*)(World* self, glm::vec4& a, glm::vec4& b, const uuid& ignoreEntity)>(getFuncAddr((int)Func::World::getEntityIntersection))(this, a, b, ignoreEntity);
 		}
 		bool castRay(glm::vec4& currentPos, glm::ivec4& currentBlock, glm::ivec4& intersectBlock, glm::vec4& endpoint) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(World* self, glm::vec4& currentPos, glm::ivec4& currentBlock, glm::ivec4& intersectBlock, glm::vec4& endpoint)>(FUNC_WORLD_CASTRAY)(this, currentPos, currentBlock, intersectBlock, endpoint);
+			return reinterpret_cast<bool (__thiscall*)(World* self, glm::vec4& currentPos, glm::ivec4& currentBlock, glm::ivec4& intersectBlock, glm::vec4& endpoint)>(getFuncAddr((int)Func::World::castRay))(this, currentPos, currentBlock, intersectBlock, endpoint);
+		}
+		uint8_t getBlock(const glm::ivec4& block)
+		{
+			if (block.y >= Chunk::HEIGHT || block.y < 0)
+			{
+				return 0;
+			}
+
+			Chunk* c = getChunkFromCoords(block.x, block.z, block.w);
+			if (c != nullptr)
+			{
+				// coords must be floats
+				glm::vec4 coords = block;
+
+				glm::ivec4 b = {
+					coords.x - (glm::floor(coords.x / Chunk::SIZE) * Chunk::SIZE),
+					coords.y,
+					coords.z - (glm::floor(coords.z / Chunk::SIZE) * Chunk::SIZE),
+					coords.w - (glm::floor(coords.w / Chunk::SIZE) * Chunk::SIZE),
+				};
+
+				return c->blocks[b.x + 1][b.z + 1][b.w + 1][b.y];
+			}
+			return BlockInfo::BARRIER;
 		}
 		
 		// VIRTUAL FUNCS
 
 		virtual ~World() {}
 		virtual World::Type getType() { return TYPE_CLIENT; }
-		virtual void setBlockUpdate(const glm::ivec4& block, unsigned char value) {}
+		virtual bool setBlockUpdate(const glm::ivec4& block, unsigned char value) {}
 		virtual bool addEntityToChunk(std::unique_ptr<Entity>& entity, Chunk* c)
 		{
-			return reinterpret_cast<bool(__thiscall*)(World * self, std::unique_ptr<Entity>& entity, Chunk* c)>(FUNC_WORLD_ADDENTITYTOCHUNK)(this, entity, c);
+			return reinterpret_cast<bool(__thiscall*)(World * self, std::unique_ptr<Entity>& entity, Chunk* c)>(getFuncAddr((int)Func::World::addEntityToChunk))(this, entity, c);
 		}
 		virtual void localPlayerEvent(Player* player, Packet::ClientPacket eventType, int64_t eventValue, void* data) {}
 		virtual void handlePlayerDeath(Player* player, std::string_view reason) {}
diff --git a/4dm.h/WorldClient.h b/4dm.h/WorldClient.h
index 294ef66..6de54ee 100644
--- a/4dm.h/WorldClient.h
+++ b/4dm.h/WorldClient.h
@@ -25,87 +25,87 @@ namespace fdm
 
 		~WorldClient() override
 		{
-			reinterpret_cast<void(__thiscall*)(WorldClient* self)>(FUNC_WORLDCLIENT_DESTR_WORLDCLIENT)(this);
+			reinterpret_cast<void(__thiscall*)(WorldClient* self)>(getFuncAddr((int)Func::WorldClient::destr_WorldClient))(this);
 		}
 		bool addEntityToChunk(std::unique_ptr<Entity>& entity, Chunk* c) override
 		{
-			return reinterpret_cast<bool (__thiscall*)(WorldClient* self, std::unique_ptr<Entity>& entity, Chunk* c)>(FUNC_WORLDCLIENT_ADDENTITYTOCHUNK)(this, entity, c);
+			return reinterpret_cast<bool (__thiscall*)(WorldClient* self, std::unique_ptr<Entity>& entity, Chunk* c)>(getFuncAddr((int)Func::WorldClient::addEntityToChunk))(this, entity, c);
 		}
 		void localPlayerEvent(Player* player, Packet::ClientPacket eventType, __int64 eventValue, void* data) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Player* player, Packet::ClientPacket eventType, __int64 eventValue, void* data)>(FUNC_WORLDCLIENT_LOCALPLAYEREVENT)(this, player, eventType, eventValue, data);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Player* player, Packet::ClientPacket eventType, __int64 eventValue, void* data)>(getFuncAddr((int)Func::WorldClient::localPlayerEvent))(this, player, eventType, eventValue, data);
 		}
 		void updateLocal(StateManager& s, Player* player, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, StateManager& s, Player* player, double dt)>(FUNC_WORLDCLIENT_UPDATELOCAL)(this, s, player, dt);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, StateManager& s, Player* player, double dt)>(getFuncAddr((int)Func::WorldClient::updateLocal))(this, s, player, dt);
 		}
 		void setRenderDistanceLocal(Player* player, unsigned char distance) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Player* player, unsigned char distance)>(FUNC_WORLDCLIENT_SETRENDERDISTANCELOCAL)(this, player, distance);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Player* player, unsigned char distance)>(getFuncAddr((int)Func::WorldClient::setRenderDistanceLocal))(this, player, distance);
 		}
 		void setSkinVisibility(bool visible) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, bool visible)>(FUNC_WORLDCLIENT_SETSKINVISIBILITY)(this, visible);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, bool visible)>(getFuncAddr((int)Func::WorldClient::setSkinVisibility))(this, visible);
 		}
 		void localPlayerInit(Player* player) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Player* player)>(FUNC_WORLDCLIENT_LOCALPLAYERINIT)(this, player);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Player* player)>(getFuncAddr((int)Func::WorldClient::localPlayerInit))(this, player);
 		}
 		void localPlayerRespawn(StateManager& s, Player* player) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, StateManager& s, Player* player)>(FUNC_WORLDCLIENT_LOCALPLAYERRESPAWN)(this, s, player);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, StateManager& s, Player* player)>(getFuncAddr((int)Func::WorldClient::localPlayerRespawn))(this, s, player);
 		}
-		void sendChatMessage(Player* player, const std::string& message) override
+		void sendChatMessage(Player* player, const msvc_string& message) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Player* player, const std::string& message)>(FUNC_WORLDCLIENT_SENDCHATMESSAGE)(this, player, message);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Player* player, const msvc_string& message)>(getFuncAddr((int)Func::WorldClient::sendChatMessage))(this, player, message);
 		}
 		void updatePhysics(Player* player, double dt) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Player* player, double dt)>(FUNC_WORLDCLIENT_UPDATEPHYSICS)(this, player, dt);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Player* player, double dt)>(getFuncAddr((int)Func::WorldClient::updatePhysics))(this, player, dt);
 		}
 		bool handleWorldMessage(const Connection::InMessage& message, Player* player) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(WorldClient* self, const Connection::InMessage& message, Player* player)>(FUNC_WORLDCLIENT_HANDLEWORLDMESSAGE)(this, message, player);
+			return reinterpret_cast<bool (__thiscall*)(WorldClient* self, const Connection::InMessage& message, Player* player)>(getFuncAddr((int)Func::WorldClient::handleWorldMessage))(this, message, player);
 		}
 		void handleLightingOptionsUpdate() override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self)>(FUNC_WORLDCLIENT_HANDLELIGHTINGOPTIONSUPDATE)(this);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self)>(getFuncAddr((int)Func::WorldClient::handleLightingOptionsUpdate))(this);
 		}
 		bool updateChunks(Player* player) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(WorldClient* self, Player* player)>(FUNC_WORLDCLIENT_UPDATECHUNKS)(this, player);
+			return reinterpret_cast<bool (__thiscall*)(WorldClient* self, Player* player)>(getFuncAddr((int)Func::WorldClient::updateChunks))(this, player);
 		}
 		void updateChunk(const glm::i64vec3& coords, float theta, const glm::vec3& playerPos, unsigned char renderDist) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, const glm::i64vec3& coords, float theta, const glm::vec3& playerPos, unsigned char renderDist)>(FUNC_WORLDCLIENT_UPDATECHUNK)(this, coords, theta, playerPos, renderDist);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, const glm::i64vec3& coords, float theta, const glm::vec3& playerPos, unsigned char renderDist)>(getFuncAddr((int)Func::WorldClient::updateChunk))(this, coords, theta, playerPos, renderDist);
 		}
 		void generateChunkMeshes() 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self)>(FUNC_WORLDCLIENT_GENERATECHUNKMESHES)(this);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self)>(getFuncAddr((int)Func::WorldClient::generateChunkMeshes))(this);
 		}
 		void updateChunkCacheAndMesh(Chunk* c, bool useSmoothLighting, bool useShadows, bool useLights) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Chunk* c, bool useSmoothLighting, bool useShadows, bool useLights)>(FUNC_WORLDCLIENT_UPDATECHUNKCACHEANDMESH)(this, c, useSmoothLighting, useShadows, useLights);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Chunk* c, bool useSmoothLighting, bool useShadows, bool useLights)>(getFuncAddr((int)Func::WorldClient::updateChunkCacheAndMesh))(this, c, useSmoothLighting, useShadows, useLights);
 		}
 		void updateChunkCache(Chunk* c, bool useSmoothLighting, bool useShadows) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Chunk* c, bool useSmoothLighting, bool useShadows)>(FUNC_WORLDCLIENT_UPDATECHUNKCACHE)(this, c, useSmoothLighting, useShadows);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, Chunk* c, bool useSmoothLighting, bool useShadows)>(getFuncAddr((int)Func::WorldClient::updateChunkCache))(this, c, useSmoothLighting, useShadows);
 		}
 		void regenerateAllChunkMeshes() 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self)>(FUNC_WORLDCLIENT_REGENERATEALLCHUNKMESHES)(this);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self)>(getFuncAddr((int)Func::WorldClient::regenerateAllChunkMeshes))(this);
 		}
 		void joinAllChunkLoadingThreads() 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self)>(FUNC_WORLDCLIENT_JOINALLCHUNKLOADINGTHREADS)(this);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self)>(getFuncAddr((int)Func::WorldClient::joinAllChunkLoadingThreads))(this);
 		}
 		void handleMessage(const Connection::InMessage& message, Player* player) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldClient* self, const Connection::InMessage& message, Player* player)>(FUNC_WORLDCLIENT_HANDLEMESSAGE)(this, message, player);
+			return reinterpret_cast<void (__thiscall*)(WorldClient* self, const Connection::InMessage& message, Player* player)>(getFuncAddr((int)Func::WorldClient::handleMessage))(this, message, player);
 		}
 		inline static bool inventoryUpdateCallback(nlohmann::json& action, void* user) 
 		{
-			return reinterpret_cast<bool (__fastcall*)(nlohmann::json& action, void* user)>(FUNC_WORLDCLIENT_INVENTORYUPDATECALLBACK)(action, user);
+			return reinterpret_cast<bool (__fastcall*)(nlohmann::json& action, void* user)>(getFuncAddr((int)Func::WorldClient::inventoryUpdateCallback))(action, user);
 		}
 	};
 }
diff --git a/4dm.h/WorldManager.h b/4dm.h/WorldManager.h
index 79355c8..dcb8d49 100644
--- a/4dm.h/WorldManager.h
+++ b/4dm.h/WorldManager.h
@@ -16,21 +16,21 @@ namespace fdm
 
 		~WorldManager() override
 		{
-			reinterpret_cast<void(__thiscall*)(WorldManager* self)>(FUNC_WORLDMANAGER_DESTR_WORLDMANAGER)(this);
+			reinterpret_cast<void(__thiscall*)(WorldManager* self)>(getFuncAddr((int)Func::WorldManager::destr_WorldManager))(this);
 		}
 		void updateRenderFrustum(const glm::mat4& p) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldManager* self, const glm::mat4& p)>(FUNC_WORLDMANAGER_UPDATERENDERFRUSTUM)(this, p);
+			return reinterpret_cast<void (__thiscall*)(WorldManager* self, const glm::mat4& p)>(getFuncAddr((int)Func::WorldManager::updateRenderFrustum))(this, p);
 		}
-		void setBlockUpdate(const glm::ivec4& block, unsigned char value) override
+		bool setBlockUpdate(const glm::ivec4& block, unsigned char value) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldManager* self, const glm::ivec4& block, unsigned char value)>(FUNC_WORLDMANAGER_SETBLOCKUPDATE)(this, block, value);
+			return reinterpret_cast<bool (__thiscall*)(WorldManager* self, const glm::ivec4& block, unsigned char value)>(getFuncAddr((int)Func::WorldManager::setBlockUpdate))(this, block, value);
 		}
 		
 
 		virtual void render(const m4::Mat5& MV, bool glasses, glm::vec3& worldColor)
 		{
-			return reinterpret_cast<void(__thiscall*)(WorldManager * self, const m4::Mat5 & MV, bool glasses, glm::vec3 & worldColor)>(FUNC_WORLDMANAGER_RENDER)(this, MV, glasses, worldColor);
+			return reinterpret_cast<void(__thiscall*)(WorldManager * self, const m4::Mat5 & MV, bool glasses, glm::vec3 & worldColor)>(getFuncAddr((int)Func::WorldManager::render))(this, MV, glasses, worldColor);
 		}
 		virtual void updateLocal(StateManager& s, Player* player, double dt) {}
 		virtual void cleanupLocal(Player* player) {}
@@ -39,7 +39,7 @@ namespace fdm
 		virtual void setSkinVisibility(bool visible) {}
 		virtual void localPlayerInit(Player* player) {}
 		virtual void localPlayerRespawn(StateManager&, Player*) {}
-		virtual void sendChatMessage(Player* player, const std::string&) {}
+		virtual void sendChatMessage(Player* player, const msvc_string&) {}
 		virtual void handleLightingOptionsUpdate() {}
 	};
 }
diff --git a/4dm.h/WorldServer.h b/4dm.h/WorldServer.h
index 9a6316e..5fd31aa 100644
--- a/4dm.h/WorldServer.h
+++ b/4dm.h/WorldServer.h
@@ -21,7 +21,7 @@ namespace fdm
 			uuid id; // 0x8
 			uint32_t handle; // 0x18
 			PAD(0x4);
-			std::string displayName; // 0x20
+			msvc_string displayName; // 0x20
 			Status status;
 			PAD(0x8);
 			Connection::OutMessage skinMessage; // 0x48
diff --git a/4dm.h/WorldSingleplayer.h b/4dm.h/WorldSingleplayer.h
index 6580f9d..0bd421f 100644
--- a/4dm.h/WorldSingleplayer.h
+++ b/4dm.h/WorldSingleplayer.h
@@ -19,71 +19,71 @@ namespace fdm
 
 		WorldSingleplayer(const path& worldPath, const path& biomeInfoPath) 
 		{
-			reinterpret_cast<void(__thiscall*)(WorldSingleplayer* self, const path& worldPath, const path& biomeInfoPath)>(FUNC_WORLDSINGLEPLAYER_WORLDSINGLEPLAYER)(this, worldPath, biomeInfoPath);
+			reinterpret_cast<void(__thiscall*)(WorldSingleplayer* self, const path& worldPath, const path& biomeInfoPath)>(getFuncAddr((int)Func::WorldSingleplayer::WorldSingleplayer))(this, worldPath, biomeInfoPath);
 		}
 		~WorldSingleplayer() override
 		{
-			reinterpret_cast<void(__thiscall*)(WorldSingleplayer* self)>(FUNC_WORLDSINGLEPLAYER_DESTR_WORLDSINGLEPLAYER)(this);
+			reinterpret_cast<void(__thiscall*)(WorldSingleplayer* self)>(getFuncAddr((int)Func::WorldSingleplayer::destr_WorldSingleplayer))(this);
 		}
 		void localPlayerEvent(Player* player, Packet::ClientPacket eventType, int64_t eventValue, void* data) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Player* player, Packet::ClientPacket eventType, int64_t eventValue, void* data)>(FUNC_WORLDSINGLEPLAYER_LOCALPLAYEREVENT)(this, player, eventType, eventValue, data);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Player* player, Packet::ClientPacket eventType, int64_t eventValue, void* data)>(getFuncAddr((int)Func::WorldSingleplayer::localPlayerEvent))(this, player, eventType, eventValue, data);
 		}
 		void updateLocal(StateManager& s, Player* player, double dt) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, StateManager& s, Player* player, double dt)>(FUNC_WORLDSINGLEPLAYER_UPDATELOCAL)(this, s, player, dt);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, StateManager& s, Player* player, double dt)>(getFuncAddr((int)Func::WorldSingleplayer::updateLocal))(this, s, player, dt);
 		}
 		void cleanupLocal(Player* player) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Player* player)>(FUNC_WORLDSINGLEPLAYER_CLEANUPLOCAL)(this, player);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Player* player)>(getFuncAddr((int)Func::WorldSingleplayer::cleanupLocal))(this, player);
 		}
 		void setRenderDistanceLocal(Player* player, unsigned char distance) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Player* player, unsigned char distance)>(FUNC_WORLDSINGLEPLAYER_SETRENDERDISTANCELOCAL)(this, player, distance);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Player* player, unsigned char distance)>(getFuncAddr((int)Func::WorldSingleplayer::setRenderDistanceLocal))(this, player, distance);
 		}
 		void setDifficultyLocal(Player* player, int difficulty) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Player* player, int difficulty)>(FUNC_WORLDSINGLEPLAYER_SETDIFFICULTYLOCAL)(this, player, difficulty);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Player* player, int difficulty)>(getFuncAddr((int)Func::WorldSingleplayer::setDifficultyLocal))(this, player, difficulty);
 		}
 		void localPlayerInit(Player* player) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Player* player)>(FUNC_WORLDSINGLEPLAYER_LOCALPLAYERINIT)(this, player);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Player* player)>(getFuncAddr((int)Func::WorldSingleplayer::localPlayerInit))(this, player);
 		}
 		void localPlayerRespawn(StateManager& s, Player* player) override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, StateManager& s, Player* player)>(FUNC_WORLDSINGLEPLAYER_LOCALPLAYERRESPAWN)(this, s, player);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, StateManager& s, Player* player)>(getFuncAddr((int)Func::WorldSingleplayer::localPlayerRespawn))(this, s, player);
 		}
 		void handleLightingOptionsUpdate() override
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self)>(FUNC_WORLDSINGLEPLAYER_HANDLELIGHTINGOPTIONSUPDATE)(this);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self)>(getFuncAddr((int)Func::WorldSingleplayer::handleLightingOptionsUpdate))(this);
 		}
 		bool updateChunks(Player* player) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(WorldSingleplayer* self, Player* player)>(FUNC_WORLDSINGLEPLAYER_UPDATECHUNKS)(this, player);
+			return reinterpret_cast<bool (__thiscall*)(WorldSingleplayer* self, Player* player)>(getFuncAddr((int)Func::WorldSingleplayer::updateChunks))(this, player);
 		}
 		void updateChunk(const glm::i64vec3& coords) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, const glm::i64vec3& coords)>(FUNC_WORLDSINGLEPLAYER_UPDATECHUNK)(this, coords);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, const glm::i64vec3& coords)>(getFuncAddr((int)Func::WorldSingleplayer::updateChunk))(this, coords);
 		}
 		void loadChunks() 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self)>(FUNC_WORLDSINGLEPLAYER_LOADCHUNKS)(this);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self)>(getFuncAddr((int)Func::WorldSingleplayer::loadChunks))(this);
 		}
 		void loadChunk(Chunk* c, bool shadows) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Chunk* c, bool shadows)>(FUNC_WORLDSINGLEPLAYER_LOADCHUNK)(this, c, shadows);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Chunk* c, bool shadows)>(getFuncAddr((int)Func::WorldSingleplayer::loadChunk))(this, c, shadows);
 		}
 		void updateChunkCacheAndMesh(Chunk* c, bool useSmoothLighting, bool useShadows, bool useLights) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Chunk* c, bool useSmoothLighting, bool useShadows, bool useLights)>(FUNC_WORLDSINGLEPLAYER_UPDATECHUNKCACHEANDMESH)(this, c, useSmoothLighting, useShadows, useLights);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Chunk* c, bool useSmoothLighting, bool useShadows, bool useLights)>(getFuncAddr((int)Func::WorldSingleplayer::updateChunkCacheAndMesh))(this, c, useSmoothLighting, useShadows, useLights);
 		}
 		void updateChunkCache(Chunk* c, bool useSmoothLighting, bool useShadows, bool updateNeighbors) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Chunk* c, bool useSmoothLighting, bool useShadows, bool updateNeighbors)>(FUNC_WORLDSINGLEPLAYER_UPDATECHUNKCACHE)(this, c, useSmoothLighting, useShadows, updateNeighbors);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self, Chunk* c, bool useSmoothLighting, bool useShadows, bool updateNeighbors)>(getFuncAddr((int)Func::WorldSingleplayer::updateChunkCache))(this, c, useSmoothLighting, useShadows, updateNeighbors);
 		}
 		void regenerateAllChunkMeshes() 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self)>(FUNC_WORLDSINGLEPLAYER_REGENERATEALLCHUNKMESHES)(this);
+			return reinterpret_cast<void (__thiscall*)(WorldSingleplayer* self)>(getFuncAddr((int)Func::WorldSingleplayer::regenerateAllChunkMeshes))(this);
 		}
 	};
 }
diff --git a/4dm.h/WorldTitleScreen.h b/4dm.h/WorldTitleScreen.h
index 9866851..aae5cb3 100644
--- a/4dm.h/WorldTitleScreen.h
+++ b/4dm.h/WorldTitleScreen.h
@@ -13,23 +13,23 @@ namespace fdm
 
 		bool loadCube(const glm::vec4& pos, unsigned char distance) 
 		{
-			return reinterpret_cast<bool (__thiscall*)(WorldTitleScreen* self, const glm::vec4& pos, unsigned char distance)>(FUNC_WORLDTITLESCREEN_LOADCUBE)(this, pos, distance);
+			return reinterpret_cast<bool (__thiscall*)(WorldTitleScreen* self, const glm::vec4& pos, unsigned char distance)>(getFuncAddr((int)Func::WorldTitleScreen::loadCube))(this, pos, distance);
 		}
 		void loadChunk(Chunk* c, bool shadows) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldTitleScreen* self, Chunk* c, bool shadows)>(FUNC_WORLDTITLESCREEN_LOADCHUNK)(this, c, shadows);
+			return reinterpret_cast<void (__thiscall*)(WorldTitleScreen* self, Chunk* c, bool shadows)>(getFuncAddr((int)Func::WorldTitleScreen::loadChunk))(this, c, shadows);
 		}
 		void updateChunkCache(Chunk* c, bool useSmoothLighting, bool useShadows) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldTitleScreen* self, Chunk* c, bool useSmoothLighting, bool useShadows)>(FUNC_WORLDTITLESCREEN_UPDATECHUNKCACHE)(this, c, useSmoothLighting, useShadows);
+			return reinterpret_cast<void (__thiscall*)(WorldTitleScreen* self, Chunk* c, bool useSmoothLighting, bool useShadows)>(getFuncAddr((int)Func::WorldTitleScreen::updateChunkCache))(this, c, useSmoothLighting, useShadows);
 		}
 		void generateMesh(Chunk* c, bool useSmoothLighting, bool useShadows, bool useLights) 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldTitleScreen* self, Chunk* c, bool useSmoothLighting, bool useShadows, bool useLights)>(FUNC_WORLDTITLESCREEN_GENERATEMESH)(this, c, useSmoothLighting, useShadows, useLights);
+			return reinterpret_cast<void (__thiscall*)(WorldTitleScreen* self, Chunk* c, bool useSmoothLighting, bool useShadows, bool useLights)>(getFuncAddr((int)Func::WorldTitleScreen::generateMesh))(this, c, useSmoothLighting, useShadows, useLights);
 		}
 		void loadChunks() 
 		{
-			return reinterpret_cast<void (__thiscall*)(WorldTitleScreen* self)>(FUNC_WORLDTITLESCREEN_LOADCHUNKS)(this);
+			return reinterpret_cast<void (__thiscall*)(WorldTitleScreen* self)>(getFuncAddr((int)Func::WorldTitleScreen::loadChunks))(this);
 		}
 	};
 }
diff --git a/4dm.h/addresses.h b/4dm.h/addresses.h
deleted file mode 100644
index 05249b8..0000000
--- a/4dm.h/addresses.h
+++ /dev/null
@@ -1,1131 +0,0 @@
-#pragma once
-
-#include "4dm.h"
-
-// AudioManager
-
-#define FUNC_AUDIOMANAGER_LOADSOUND (base + idaOffsetFix(0x67D0))
-#define FUNC_AUDIOMANAGER_PLAYSOUND4D (base + idaOffsetFix(0x6A80))
-#define FUNC_AUDIOMANAGER_SETLISTENERINFO4D (base + idaOffsetFix(0x6DD0))
-#define FUNC_AUDIOMANAGER_LOADBGMFROMJSON (base + idaOffsetFix(0x7290))
-#define FUNC_AUDIOMANAGER_UPDATEBGM (base + idaOffsetFix(0x7760))
-#define FUNC_AUDIOMANAGER_GETSOUND (base + idaOffsetFix(0x78A0))
-#define FUNC_AUDIOMANAGER_GETVOICEGROUPINFO (base + idaOffsetFix(0x7930))
-
-// Hitbox
-
-#define FUNC_HITBOX_ADDVELWITHMAXHORIZSPEED (base + idaOffsetFix(0x83440))
-#define FUNC_HITBOX_UPDATE (base + idaOffsetFix(0x83760))
-#define FUNC_HITBOX_ISINTERSECTINGRAY (base + idaOffsetFix(0x83FD0))
-#define FUNC_HITBOX_TAKESTEP (base + idaOffsetFix(0x842C0))
-
-// KleinBottle
-
-#define FUNC_KLEINBOTTLE_BUFFDATA (base + idaOffsetFix(0x4A9F0))
-#define FUNC_KLEINBOTTLE_ATTRSIZE (base + idaOffsetFix(0x92F50))
-#define FUNC_KLEINBOTTLE_KLEINBOTTLE (base + idaOffsetFix(0x9CF80))
-#define FUNC_KLEINBOTTLE_BUFFSIZE (base + idaOffsetFix(0x9DC60))
-#define FUNC_KLEINBOTTLE_DESTR_KLEINBOTTLE (base + idaOffsetFix(0x9EED0))
-
-// Connection::InMessage
-
-#define FUNC_CONNECTION_INMESSAGE_INMESSAGEDELETER (base + idaOffsetFix(0x4FC40))
-#define FUNC_CONNECTION_INMESSAGE_DESTR_INMESSAGE (base + idaOffsetFix(0x1F680))
-
-// Connection::OutMessage
-
-#define FUNC_CONNECTION_OUTMESSAGE_CREATEMESSAGE (base + idaOffsetFix(0x4FB90))
-#define FUNC_CONNECTION_OUTMESSAGE_OUTMESSAGE (base + idaOffsetFix(0x4FB00))
-#define FUNC_CONNECTION_OUTMESSAGE_RELEASEHEAPMESSAGEDATA (base + idaOffsetFix(0x4FC00))
-
-// Connection::Client
-
-#define FUNC_CONNECTION_CLIENT_UPDATE (base + idaOffsetFix(0x55EE0))
-#define FUNC_CONNECTION_CLIENT_RESOLVEHOST (base + idaOffsetFix(0x56000))
-#define FUNC_CONNECTION_CLIENT_CLEANUP (base + idaOffsetFix(0x567B0))
-#define FUNC_CONNECTION_CLIENT_CONNECTIONSTATUSCHANGEDCALLBACK (base + idaOffsetFix(0x56940))
-
-// WorldTitleScreen
-
-#define FUNC_WORLDTITLESCREEN_LOADCUBE (base + idaOffsetFix(0xF52D0))
-#define FUNC_WORLDTITLESCREEN_LOADCHUNK (base + idaOffsetFix(0xF55B0))
-#define FUNC_WORLDTITLESCREEN_UPDATECHUNKCACHE (base + idaOffsetFix(0xF5610))
-#define FUNC_WORLDTITLESCREEN_GENERATEMESH (base + idaOffsetFix(0xF5AE0))
-#define FUNC_WORLDTITLESCREEN_LOADCHUNKS (base + idaOffsetFix(0xF5B30))
-
-// FontRenderer
-
-#define FUNC_FONTRENDERER_FONTRENDERER (base + idaOffsetFix(0x7B650))
-#define FUNC_FONTRENDERER_FONTRENDERER_A (base + idaOffsetFix(0x7B7F0))
-#define FUNC_FONTRENDERER_SETTEXT (base + idaOffsetFix(0x7B8A0))
-#define FUNC_FONTRENDERER_RENDER (base + idaOffsetFix(0x7B930))
-#define FUNC_FONTRENDERER_UPDATEMODEL (base + idaOffsetFix(0x7BA50))
-#define FUNC_FONTRENDERER_MOVE (base + idaOffsetFix(0x7BB20))
-
-// TexRenderer
-
-#define FUNC_TEXRENDERER_DESTR_TEXRENDERER (base + idaOffsetFix(0xDEDA0))
-#define FUNC_TEXRENDERER_OPERATOREQ (base + idaOffsetFix(0xDEDF0))
-#define FUNC_TEXRENDERER_INIT (base + idaOffsetFix(0xDEEA0))
-#define FUNC_TEXRENDERER_SETCLIP (base + idaOffsetFix(0xDF370))
-#define FUNC_TEXRENDERER_SETCOLOR (base + idaOffsetFix(0xDF4A0))
-#define FUNC_TEXRENDERER_SETPOS (base + idaOffsetFix(0xDF580))
-
-// Dodecaplex
-
-#define FUNC_DODECAPLEX_BUFFCOUNT (base + idaOffsetFix(0x70FD0))
-#define FUNC_DODECAPLEX_BUFFDATA (base + idaOffsetFix(0x70FE0))
-#define FUNC_DODECAPLEX_BUFFSIZE (base + idaOffsetFix(0x71000))
-#define FUNC_DODECAPLEX_ATTRSIZE (base + idaOffsetFix(0x71050))
-#define FUNC_DODECAPLEX_GENERATEMESH (base + idaOffsetFix(0x71070))
-#define FUNC_DODECAPLEX_GENERATECELLCOLORS (base + idaOffsetFix(0x73440))
-#define FUNC_DODECAPLEX_ADDFACES (base + idaOffsetFix(0x73640))
-#define FUNC_DODECAPLEX_ADDCELLS (base + idaOffsetFix(0x740A0))
-#define FUNC_DODECAPLEX_DESTR_DODECAPLEX (base + idaOffsetFix(0xCC9F0))
-
-// Skybox
-
-#define FUNC_SKYBOX_BUFFDATA (base + idaOffsetFix(0xCF4A0))
-#define FUNC_SKYBOX_BUFFSIZE (base + idaOffsetFix(0xCF4C0))
-#define FUNC_SKYBOX_ATTRSIZE (base + idaOffsetFix(0xCF4D0))
-#define FUNC_SKYBOX_VERTCOUNT (base + idaOffsetFix(0xCF4E0))
-
-// PentachoronHollow
-
-#define FUNC_PENTACHORONHOLLOW_BUFFDATA (base + idaOffsetFix(0x3C380))
-#define FUNC_PENTACHORONHOLLOW_PENTACHORONHOLLOW (base + idaOffsetFix(0xCB550))
-#define FUNC_PENTACHORONHOLLOW_BUFFSIZE (base + idaOffsetFix(0xCB940))
-#define FUNC_PENTACHORONHOLLOW_VERTCOUNT (base + idaOffsetFix(0xCB970))
-#define FUNC_PENTACHORONHOLLOW_ADDTETSIDE (base + idaOffsetFix(0xCB9C0))
-
-// Hypersphere::VertInfo
-
-#define FUNC_HYPERSPHERE_VERTINFO_VERTINFO (base + idaOffsetFix(0x8E1E0))
-#define FUNC_HYPERSPHERE_VERTINFO_DESTR_VERTINFO (base + idaOffsetFix(0x8E200))
-#define FUNC_HYPERSPHERE_VERTINFO_ADD (base + idaOffsetFix(0x92E10))
-#define FUNC_HYPERSPHERE_VERTINFO_ADD_A (base + idaOffsetFix(0x92E80))
-
-// Hypersphere
-
-#define FUNC_HYPERSPHERE_ATTRCOUNT (base + idaOffsetFix(0x3C370))
-#define FUNC_HYPERSPHERE_ATTRTYPE (base + idaOffsetFix(0x44F20))
-#define FUNC_HYPERSPHERE_BUFFCOUNT (base + idaOffsetFix(0x4A9E0))
-#define FUNC_HYPERSPHERE_HYPERSPHERE (base + idaOffsetFix(0x8C410))
-#define FUNC_HYPERSPHERE_HYPERSPHERE_A (base + idaOffsetFix(0x8E2D0))
-#define FUNC_HYPERSPHERE_GENERATESPHEREPOLYGONS (base + idaOffsetFix(0x920E0))
-#define FUNC_HYPERSPHERE_ADDWEDGESIDE (base + idaOffsetFix(0x92B40))
-#define FUNC_HYPERSPHERE_ADDCUBESIDE (base + idaOffsetFix(0x92C60))
-
-// MeshRenderer
-
-#define FUNC_MESHRENDERER_MESHRENDERER (base + idaOffsetFix(0xABA90))
-#define FUNC_MESHRENDERER_SETMESH (base + idaOffsetFix(0xABAB0))
-#define FUNC_MESHRENDERER_UPDATEMESH (base + idaOffsetFix(0xABAE0))
-#define FUNC_MESHRENDERER_DESTR_MESHRENDERER (base + idaOffsetFix(0xABBE0))
-#define FUNC_MESHRENDERER_RENDER (base + idaOffsetFix(0xABC00))
-#define FUNC_MESHRENDERER_INIT (base + idaOffsetFix(0xABC70))
-#define FUNC_MESHRENDERER_CLEANUP (base + idaOffsetFix(0xABD80))
-#define FUNC_MESHRENDERER_INITATTRS (base + idaOffsetFix(0xABDF0))
-
-// PlayerSkin::SkinMesh
-
-#define FUNC_PLAYERSKIN_SKINMESH_VERTCOUNT (base + idaOffsetFix(0x3C420))
-#define FUNC_PLAYERSKIN_SKINMESH_DESTR_SKINMESH (base + idaOffsetFix(0x5DBE0))
-#define FUNC_PLAYERSKIN_SKINMESH_GENERATE (base + idaOffsetFix(0x5DC90))
-#define FUNC_PLAYERSKIN_SKINMESH_BUFFSIZE (base + idaOffsetFix(0x5ECE0))
-#define FUNC_PLAYERSKIN_SKINMESH_ATTRCOUNT (base + idaOffsetFix(0x5ECF0))
-#define FUNC_PLAYERSKIN_SKINMESH_ATTRTYPE (base + idaOffsetFix(0x5ED00))
-#define FUNC_PLAYERSKIN_SKINMESH_ATTRSIZE (base + idaOffsetFix(0x5ED20))
-#define FUNC_PLAYERSKIN_SKINMESH_ATTRSTRIDE (base + idaOffsetFix(0x5ED40))
-#define FUNC_PLAYERSKIN_SKINMESH_ADDPIXELTOFACE (base + idaOffsetFix(0x5ED50))
-
-// PlayerSkin
-
-#define FUNC_PLAYERSKIN_LOAD (base + idaOffsetFix(0x5D900))
-#define FUNC_PLAYERSKIN_GENERATEMESH (base + idaOffsetFix(0x5D9E0))
-#define FUNC_PLAYERSKIN_DESTR_PLAYERSKIN (base + idaOffsetFix(0xC0EA0))
-
-// Tex2D
-
-#define FUNC_TEX2D_DESTR_TEX2D (base + idaOffsetFix(0xDF7F0))
-#define FUNC_TEX2D_LOADRAWIMAGEDATA (base + idaOffsetFix(0xDF820))
-#define FUNC_TEX2D_INITFROMTEXID (base + idaOffsetFix(0xDF940))
-#define FUNC_TEX2D_LOADARRAYTEXTURE (base + idaOffsetFix(0xDFA30))
-
-// StateCredits
-
-#define FUNC_STATECREDITS_INIT (base + idaOffsetFix(0x6D140))
-#define FUNC_STATECREDITS_UPDATE (base + idaOffsetFix(0x6DCA0))
-#define FUNC_STATECREDITS_RENDER (base + idaOffsetFix(0x6DD40))
-#define FUNC_STATECREDITS_WINDOWRESIZE (base + idaOffsetFix(0x6F200))
-#define FUNC_STATECREDITS_KEYINPUT (base + idaOffsetFix(0x6F210))
-#define FUNC_STATECREDITS_UPDATEPROJECTION (base + idaOffsetFix(0x6F270))
-
-// StateCreateWorld
-
-#define FUNC_STATECREATEWORLD_STATECREATEWORLD (base + idaOffsetFix(0x6A1A0))
-#define FUNC_STATECREATEWORLD_INIT (base + idaOffsetFix(0x6A6F0))
-#define FUNC_STATECREATEWORLD_CLOSE (base + idaOffsetFix(0x6B1A0))
-#define FUNC_STATECREATEWORLD_UPDATE (base + idaOffsetFix(0x6B1B0))
-#define FUNC_STATECREATEWORLD_RENDER (base + idaOffsetFix(0x6B230))
-#define FUNC_STATECREATEWORLD_RESUME (base + idaOffsetFix(0x6B410))
-#define FUNC_STATECREATEWORLD_MOUSEINPUT (base + idaOffsetFix(0x6B480))
-#define FUNC_STATECREATEWORLD_SCROLLINPUT (base + idaOffsetFix(0x6B4A0))
-#define FUNC_STATECREATEWORLD_KEYINPUT (base + idaOffsetFix(0x6B4E0))
-#define FUNC_STATECREATEWORLD_WINDOWRESIZE (base + idaOffsetFix(0x6B560))
-#define FUNC_STATECREATEWORLD_CHARINPUT (base + idaOffsetFix(0x6B590))
-#define FUNC_STATECREATEWORLD_CREATENEWWORLD (base + idaOffsetFix(0x6BB40))
-#define FUNC_STATECREATEWORLD_VIEWPORTCALLBACK (base + idaOffsetFix(0x6BCD0))
-#define FUNC_STATECREATEWORLD_CAVECHECKBOXCALLBACK (base + idaOffsetFix(0x6BD60))
-#define FUNC_STATECREATEWORLD_HANDLECREATEBUTTON (base + idaOffsetFix(0x6C010))
-
-// StateTitleScreen
-
-#define FUNC_STATETITLESCREEN_QUITGAMEBUTTONCALLBACK (base + idaOffsetFix(0x6BAF0))
-#define FUNC_STATETITLESCREEN_SETTINGSBUTTONCALLBACK (base + idaOffsetFix(0xB1360))
-#define FUNC_STATETITLESCREEN_STATETITLESCREEN (base + idaOffsetFix(0xDFC70))
-#define FUNC_STATETITLESCREEN_UPDATEPROJECTION (base + idaOffsetFix(0xE0030))
-#define FUNC_STATETITLESCREEN_SINGLEPLAYERBUTTONCALLBACK (base + idaOffsetFix(0xE0590))
-#define FUNC_STATETITLESCREEN_MULTIPLAYERPLAYERBUTTONCALLBACK (base + idaOffsetFix(0xE0620))
-#define FUNC_STATETITLESCREEN_CREDITSBUTTONCALLBACK (base + idaOffsetFix(0xE06B0))
-#define FUNC_STATETITLESCREEN_TUTORIALBUTTONCALLBACK (base + idaOffsetFix(0xE0740))
-#define FUNC_STATETITLESCREEN_INIT (base + idaOffsetFix(0xE07D0))
-#define FUNC_STATETITLESCREEN_CLOSE (base + idaOffsetFix(0xE1460))
-#define FUNC_STATETITLESCREEN_UPDATE (base + idaOffsetFix(0xE1510))
-#define FUNC_STATETITLESCREEN_RENDER (base + idaOffsetFix(0xE1650))
-#define FUNC_STATETITLESCREEN_PAUSE (base + idaOffsetFix(0xE1E50))
-#define FUNC_STATETITLESCREEN_RESUME (base + idaOffsetFix(0xE1E60))
-#define FUNC_STATETITLESCREEN_KEYINPUT (base + idaOffsetFix(0xE1ED0))
-#define FUNC_STATETITLESCREEN_WINDOWRESIZE (base + idaOffsetFix(0xE1F60))
-#define FUNC_STATETITLESCREEN_MOUSEINPUT (base + idaOffsetFix(0xE1F70))
-#define FUNC_STATETITLESCREEN_MOUSEBUTTONINPUT (base + idaOffsetFix(0xE1F90))
-#define FUNC_STATETITLESCREEN_RENDERBACKGROUND (base + idaOffsetFix(0xE1FC0))
-
-// StateGame
-
-#define FUNC_STATEGAME_STATEGAME (base + idaOffsetFix(0x7CE40))
-#define FUNC_STATEGAME_RESETMOUSE (base + idaOffsetFix(0x7D660))
-#define FUNC_STATEGAME_UPDATEPROJECTION2D (base + idaOffsetFix(0x7D710))
-#define FUNC_STATEGAME_VIEWPORTCALLBACK (base + idaOffsetFix(0x7DBC0))
-#define FUNC_STATEGAME_UPDATECHATMESSAGES (base + idaOffsetFix(0x7DC50))
-#define FUNC_STATEGAME_INIT (base + idaOffsetFix(0x7DDD0))
-#define FUNC_STATEGAME_CLOSE (base + idaOffsetFix(0x7EC40))
-#define FUNC_STATEGAME_PAUSE (base + idaOffsetFix(0x7ECE0))
-#define FUNC_STATEGAME_RESUME (base + idaOffsetFix(0x7ED30))
-#define FUNC_STATEGAME_UPDATE (base + idaOffsetFix(0x7EDF0))
-#define FUNC_STATEGAME_RENDER (base + idaOffsetFix(0x7EF70))
-#define FUNC_STATEGAME_MOUSEINPUT (base + idaOffsetFix(0x80D90))
-#define FUNC_STATEGAME_SCROLLINPUT (base + idaOffsetFix(0x80DE0))
-#define FUNC_STATEGAME_MOUSEBUTTONINPUT (base + idaOffsetFix(0x80EE0))
-#define FUNC_STATEGAME_KEYINPUT (base + idaOffsetFix(0x80F40))
-#define FUNC_STATEGAME_WINDOWRESIZE (base + idaOffsetFix(0x815C0))
-#define FUNC_STATEGAME_CHARINPUT (base + idaOffsetFix(0x81640))
-#define FUNC_STATEGAME_UPDATEPROJECTION (base + idaOffsetFix(0x81680))
-#define FUNC_STATEGAME_SETWORLD (base + idaOffsetFix(0x82A90))
-#define FUNC_STATEGAME_ADDCHATMESSAGE (base + idaOffsetFix(0x82B40))
-
-// StateWorldGen
-
-#define FUNC_STATEWORLDGEN_UPDATEPROJECTION (base + idaOffsetFix(0x100230))
-#define FUNC_STATEWORLDGEN_INIT (base + idaOffsetFix(0x100420))
-#define FUNC_STATEWORLDGEN_UPDATE (base + idaOffsetFix(0x100960))
-#define FUNC_STATEWORLDGEN_RENDER (base + idaOffsetFix(0x100AC0))
-#define FUNC_STATEWORLDGEN_WINDOWRESIZE (base + idaOffsetFix(0x1017D0))
-
-// StateMultiplayer
-
-#define FUNC_STATEMULTIPLAYER_DESTR_STATEMULTIPLAYER (base + idaOffsetFix(0xAC0D0))
-#define FUNC_STATEMULTIPLAYER_STATEMULTIPLAYER (base + idaOffsetFix(0xAC260))
-#define FUNC_STATEMULTIPLAYER_UPDATEPROJECTION (base + idaOffsetFix(0xAC8F0))
-#define FUNC_STATEMULTIPLAYER_CANCELBUTTONCALLBACK (base + idaOffsetFix(0xACE20))
-#define FUNC_STATEMULTIPLAYER_CHANGESKINBUTTONCALLBACK (base + idaOffsetFix(0xACF20))
-#define FUNC_STATEMULTIPLAYER_JOINBUTTONCALLBACK (base + idaOffsetFix(0xACFB0))
-#define FUNC_STATEMULTIPLAYER_VIEWPORTCALLBACK (base + idaOffsetFix(0xACFC0))
-#define FUNC_STATEMULTIPLAYER_UUIDCOPYBUTTONCALLBACK (base + idaOffsetFix(0xAD050))
-#define FUNC_STATEMULTIPLAYER_INIT (base + idaOffsetFix(0xAD0A0))
-#define FUNC_STATEMULTIPLAYER_CLOSE (base + idaOffsetFix(0xAE590))
-#define FUNC_STATEMULTIPLAYER_UPDATE (base + idaOffsetFix(0xAEC30))
-#define FUNC_STATEMULTIPLAYER_RENDER (base + idaOffsetFix(0xAFCD0))
-#define FUNC_STATEMULTIPLAYER_MOUSEINPUT (base + idaOffsetFix(0xB0020))
-#define FUNC_STATEMULTIPLAYER_SCROLLINPUT (base + idaOffsetFix(0xB0040))
-#define FUNC_STATEMULTIPLAYER_MOUSEBUTTONINPUT (base + idaOffsetFix(0xB0060))
-#define FUNC_STATEMULTIPLAYER_KEYINPUT (base + idaOffsetFix(0xB0080))
-#define FUNC_STATEMULTIPLAYER_WINDOWRESIZE (base + idaOffsetFix(0xB0100))
-#define FUNC_STATEMULTIPLAYER_CHARINPUT (base + idaOffsetFix(0xB0150))
-#define FUNC_STATEMULTIPLAYER_REJOIN (base + idaOffsetFix(0xB0250))
-#define FUNC_STATEMULTIPLAYER_CONNECT (base + idaOffsetFix(0xB0470))
-#define FUNC_STATEMULTIPLAYER_CONNECTIONERROROKBUTTONCALLBACK (base + idaOffsetFix(0xB0640))
-
-// StateSingleplayer
-
-#define FUNC_STATESINGLEPLAYER_MOUSEBUTTONINPUT (base + idaOffsetFix(0x6B4C0))
-#define FUNC_STATESINGLEPLAYER_UPDATEPROJECTION (base + idaOffsetFix(0x6B5C0))
-#define FUNC_STATESINGLEPLAYER_STATESINGLEPLAYER (base + idaOffsetFix(0xCCDD0))
-#define FUNC_STATESINGLEPLAYER_UPDATEWORLDLISTCONTAINER (base + idaOffsetFix(0xCD0A0))
-#define FUNC_STATESINGLEPLAYER_CREATECALLBACK (base + idaOffsetFix(0xCD1C0))
-#define FUNC_STATESINGLEPLAYER_VIEWPORTCALLBACK (base + idaOffsetFix(0xCD250))
-#define FUNC_STATESINGLEPLAYER_WORLDBUTTONCALLBACK (base + idaOffsetFix(0xCD2E0))
-#define FUNC_STATESINGLEPLAYER_INIT (base + idaOffsetFix(0xCD2F0))
-#define FUNC_STATESINGLEPLAYER_CLOSE (base + idaOffsetFix(0xCE5C0))
-#define FUNC_STATESINGLEPLAYER_UPDATE (base + idaOffsetFix(0xCE5F0))
-#define FUNC_STATESINGLEPLAYER_RESUME (base + idaOffsetFix(0xCE7C0))
-#define FUNC_STATESINGLEPLAYER_WINDOWRESIZE (base + idaOffsetFix(0xCE840))
-#define FUNC_STATESINGLEPLAYER_QUEUEWORLDLOAD (base + idaOffsetFix(0xCE8A0))
-
-// StateDeathScreen
-
-#define FUNC_STATEDEATHSCREEN_UPDATEPROJECTION (base + idaOffsetFix(0x6FAB0))
-#define FUNC_STATEDEATHSCREEN_RETRYBUTTONCALLBACK (base + idaOffsetFix(0x6FE70))
-#define FUNC_STATEDEATHSCREEN_INIT (base + idaOffsetFix(0x6FFC0))
-#define FUNC_STATEDEATHSCREEN_CLOSE (base + idaOffsetFix(0x70830))
-#define FUNC_STATEDEATHSCREEN_UPDATE (base + idaOffsetFix(0x70840))
-#define FUNC_STATEDEATHSCREEN_RENDER (base + idaOffsetFix(0x70900))
-#define FUNC_STATEDEATHSCREEN_MOUSEINPUT (base + idaOffsetFix(0x70EC0))
-#define FUNC_STATEDEATHSCREEN_SCROLLINPUT (base + idaOffsetFix(0x70EE0))
-#define FUNC_STATEDEATHSCREEN_MOUSEBUTTONINPUT (base + idaOffsetFix(0x70F00))
-#define FUNC_STATEDEATHSCREEN_KEYINPUT (base + idaOffsetFix(0x70F20))
-#define FUNC_STATEDEATHSCREEN_WINDOWRESIZE (base + idaOffsetFix(0x70FA0))
-
-// StateErrorScreen
-
-#define FUNC_STATEERRORSCREEN_OKBUTTONCALLBACK (base + idaOffsetFix(0x6FED0))
-#define FUNC_STATEERRORSCREEN_INIT (base + idaOffsetFix(0x7C3D0))
-#define FUNC_STATEERRORSCREEN_CLOSE (base + idaOffsetFix(0x7C920))
-#define FUNC_STATEERRORSCREEN_UPDATE (base + idaOffsetFix(0x7C930))
-#define FUNC_STATEERRORSCREEN_RENDER (base + idaOffsetFix(0x7C9C0))
-#define FUNC_STATEERRORSCREEN_MOUSEBUTTONINPUT (base + idaOffsetFix(0x7CBE0))
-#define FUNC_STATEERRORSCREEN_WINDOWRESIZE (base + idaOffsetFix(0x7CC80))
-
-// StateIntro
-
-#define FUNC_STATEINTRO_UPDATEPROJECTION (base + idaOffsetFix(0x94350))
-#define FUNC_STATEINTRO_LOADFILES (base + idaOffsetFix(0x94690))
-#define FUNC_STATEINTRO_INIT (base + idaOffsetFix(0x948F0))
-#define FUNC_STATEINTRO_UPDATE (base + idaOffsetFix(0x94ED0))
-#define FUNC_STATEINTRO_RENDER (base + idaOffsetFix(0x95200))
-#define FUNC_STATEINTRO_WINDOWRESIZE (base + idaOffsetFix(0x95DF0))
-
-// StateTutorial
-
-#define FUNC_STATETUTORIAL_DESTR_STATETUTORIAL (base + idaOffsetFix(0xED010))
-#define FUNC_STATETUTORIAL_STATETUTORIAL (base + idaOffsetFix(0xED2D0))
-#define FUNC_STATETUTORIAL_UPDATEPROJECTION (base + idaOffsetFix(0xED630))
-#define FUNC_STATETUTORIAL_BACKBUTTONCALLBACK (base + idaOffsetFix(0xEDD10))
-#define FUNC_STATETUTORIAL_NEXTBUTTONCALLBACK (base + idaOffsetFix(0xEDD80))
-#define FUNC_STATETUTORIAL_GENERATEMESH (base + idaOffsetFix(0xEDDF0))
-#define FUNC_STATETUTORIAL_GETSMOOTHLIGHTING (base + idaOffsetFix(0xEEEE0))
-#define FUNC_STATETUTORIAL_UPDATEPLAYERCOMPONENTVECTORS (base + idaOffsetFix(0xEF3F0))
-#define FUNC_STATETUTORIAL_UPDATEPLAYERPOS (base + idaOffsetFix(0xEF4E0))
-#define FUNC_STATETUTORIAL_UPDATECURRENTBLOCK (base + idaOffsetFix(0xEFF60))
-#define FUNC_STATETUTORIAL_HANDLECOLLISION (base + idaOffsetFix(0xF00B0))
-#define FUNC_STATETUTORIAL_SETFORGSPRITE (base + idaOffsetFix(0xF0840))
-#define FUNC_STATETUTORIAL_INIT (base + idaOffsetFix(0xF0E10))
-#define FUNC_STATETUTORIAL_CLOSE (base + idaOffsetFix(0xF18C0))
-#define FUNC_STATETUTORIAL_UPDATE (base + idaOffsetFix(0xF1910))
-#define FUNC_STATETUTORIAL_RENDER (base + idaOffsetFix(0xF1EA0))
-#define FUNC_STATETUTORIAL_RESUME (base + idaOffsetFix(0xF3E50))
-#define FUNC_STATETUTORIAL_MOUSEINPUT (base + idaOffsetFix(0xF3EC0))
-#define FUNC_STATETUTORIAL_SCROLLINPUT (base + idaOffsetFix(0xF3F90))
-#define FUNC_STATETUTORIAL_MOUSEBUTTONINPUT (base + idaOffsetFix(0xF3FB0))
-#define FUNC_STATETUTORIAL_KEYINPUT (base + idaOffsetFix(0xF40B0))
-#define FUNC_STATETUTORIAL_WINDOWRESIZE (base + idaOffsetFix(0xF4280))
-#define FUNC_STATETUTORIAL_CHARINPUT (base + idaOffsetFix(0xF42B0))
-#define FUNC_STATETUTORIAL_UPDATEVIEWPORT (base + idaOffsetFix(0xF42E0))
-
-// StateTutorialSlideshow
-
-#define FUNC_STATETUTORIALSLIDESHOW_DESTR_STATETUTORIALSLIDESHOW (base + idaOffsetFix(0xEA010))
-#define FUNC_STATETUTORIALSLIDESHOW_STATETUTORIALSLIDESHOW (base + idaOffsetFix(0xEA250))
-#define FUNC_STATETUTORIALSLIDESHOW_UPDATEPROJECTION (base + idaOffsetFix(0xEABC0))
-#define FUNC_STATETUTORIALSLIDESHOW_UPDATESLIDESIZE (base + idaOffsetFix(0xEB350))
-#define FUNC_STATETUTORIALSLIDESHOW_VIEWPORTCALLBACK (base + idaOffsetFix(0xEB430))
-#define FUNC_STATETUTORIALSLIDESHOW_INIT (base + idaOffsetFix(0xEB4C0))
-#define FUNC_STATETUTORIALSLIDESHOW_UPDATE (base + idaOffsetFix(0xECA20))
-#define FUNC_STATETUTORIALSLIDESHOW_RENDER (base + idaOffsetFix(0xECA80))
-#define FUNC_STATETUTORIALSLIDESHOW_RESUME (base + idaOffsetFix(0xECD90))
-#define FUNC_STATETUTORIALSLIDESHOW_WINDOWRESIZE (base + idaOffsetFix(0xECE10))
-#define FUNC_STATETUTORIALSLIDESHOW_CONTINUEBUTTONCALLBACK (base + idaOffsetFix(0xECE70))
-#define FUNC_STATETUTORIALSLIDESHOW_BACKBUTTONCALLBACK (base + idaOffsetFix(0xECE90))
-#define FUNC_STATETUTORIALSLIDESHOW_SETSLIDE (base + idaOffsetFix(0xECEB0))
-
-// StateSkinChooser
-
-#define FUNC_STATESKINCHOOSER_MOUSEINPUT (base + idaOffsetFix(0x7CBA0))
-#define FUNC_STATESKINCHOOSER_SCROLLINPUT (base + idaOffsetFix(0x7CBC0))
-#define FUNC_STATESKINCHOOSER_KEYINPUT (base + idaOffsetFix(0x7CC00))
-#define FUNC_STATESKINCHOOSER_STATESKINCHOOSER (base + idaOffsetFix(0xDD100))
-#define FUNC_STATESKINCHOOSER_UPDATEPROJECTION (base + idaOffsetFix(0xDD420))
-#define FUNC_STATESKINCHOOSER_VIEWPORTCALLBACK (base + idaOffsetFix(0xDDBA0))
-#define FUNC_STATESKINCHOOSER_CHOOSEFILEBUTTONCALLBACK (base + idaOffsetFix(0xDDC30))
-#define FUNC_STATESKINCHOOSER_INIT (base + idaOffsetFix(0xDDE00))
-#define FUNC_STATESKINCHOOSER_CLOSE (base + idaOffsetFix(0xDE420))
-#define FUNC_STATESKINCHOOSER_UPDATE (base + idaOffsetFix(0xDE450))
-#define FUNC_STATESKINCHOOSER_RENDER (base + idaOffsetFix(0xDE520))
-#define FUNC_STATESKINCHOOSER_WINDOWRESIZE (base + idaOffsetFix(0xDE710))
-#define FUNC_STATESKINCHOOSER_FILEDROP (base + idaOffsetFix(0xDE780))
-#define FUNC_STATESKINCHOOSER_GETSKINMESSAGE (base + idaOffsetFix(0xDE8F0))
-#define FUNC_STATESKINCHOOSER_LOADSKIN (base + idaOffsetFix(0xDEAE0))
-
-// StateSettings
-
-#define FUNC_STATESETTINGS_UPDATEPROJECTION (base + idaOffsetFix(0x7C010))
-#define FUNC_STATESETTINGS_DESTR_STATESETTINGS (base + idaOffsetFix(0xC5040))
-#define FUNC_STATESETTINGS_STATESETTINGS (base + idaOffsetFix(0xC5210))
-#define FUNC_STATESETTINGS_GETSETTING (base + idaOffsetFix(0xC5E80))
-#define FUNC_STATESETTINGS_RENDERDISTANCESLIDERCALLBACK (base + idaOffsetFix(0xC5EB0))
-#define FUNC_STATESETTINGS_SCROLLSENSITIVITYSLIDERCALLBACK (base + idaOffsetFix(0xC5EC0))
-#define FUNC_STATESETTINGS_LOOKSENSITIVITYSLIDERCALLBACK (base + idaOffsetFix(0xC5ED0))
-#define FUNC_STATESETTINGS_XINVERTCHECKBOXCALLBACK (base + idaOffsetFix(0xC5EE0))
-#define FUNC_STATESETTINGS_YINVERTCHECKBOXCALLBACK (base + idaOffsetFix(0xC5EF0))
-#define FUNC_STATESETTINGS_FOVSLIDERCALLBACK (base + idaOffsetFix(0xC5F00))
-#define FUNC_STATESETTINGS_GLOBALVOLUMESLIDERCALLBACK (base + idaOffsetFix(0xC5F10))
-#define FUNC_STATESETTINGS_MUSICVOLUMESLIDERCALLBACK (base + idaOffsetFix(0xC5F40))
-#define FUNC_STATESETTINGS_CREATUREVOLUMESLIDERCALLBACK (base + idaOffsetFix(0xC5FA0))
-#define FUNC_STATESETTINGS_AMBIENCEVOLUMESLIDERCALLBACK (base + idaOffsetFix(0xC5FB0))
-#define FUNC_STATESETTINGS_CONTROLSBUTTONCALLBACK (base + idaOffsetFix(0xC5FC0))
-#define FUNC_STATESETTINGS_CONTROLSOKBUTTONCALLBACK (base + idaOffsetFix(0xC5FD0))
-#define FUNC_STATESETTINGS_FULLSCREENBUTTONCALLBACK (base + idaOffsetFix(0xC5FE0))
-#define FUNC_STATESETTINGS_DIFFICULTYSLIDERCALLBACK (base + idaOffsetFix(0xC6000))
-#define FUNC_STATESETTINGS_SMOOTHLIGHTINGCHECKBOXCALLBACK (base + idaOffsetFix(0xC6010))
-#define FUNC_STATESETTINGS_SHADOWSCHECKBOXCALLBACK (base + idaOffsetFix(0xC6020))
-#define FUNC_STATESETTINGS_LIGHTSCHECKBOXCALLBACK (base + idaOffsetFix(0xC6030))
-#define FUNC_STATESETTINGS_CHATCHECKBOXCALLBACK (base + idaOffsetFix(0xC6040))
-#define FUNC_STATESETTINGS_NAMETAGSCHECKBOXCALLBACK (base + idaOffsetFix(0xC60D0))
-#define FUNC_STATESETTINGS_SKINSCHECKBOXCALLBACK (base + idaOffsetFix(0xC60E0))
-#define FUNC_STATESETTINGS_SECRETBUTTONCALLBACK (base + idaOffsetFix(0xC60F0))
-#define FUNC_STATESETTINGS_VIEWPORTCALLBACK (base + idaOffsetFix(0xC6100))
-#define FUNC_STATESETTINGS_UPDATESTATEGAME (base + idaOffsetFix(0xC6190))
-#define FUNC_STATESETTINGS_UPDATEVOLUME (base + idaOffsetFix(0xC6220))
-#define FUNC_STATESETTINGS_LOAD (base + idaOffsetFix(0xC62D0))
-#define FUNC_STATESETTINGS_SAVE (base + idaOffsetFix(0xC7130))
-#define FUNC_STATESETTINGS_INIT (base + idaOffsetFix(0xC78C0))
-#define FUNC_STATESETTINGS_CLOSE (base + idaOffsetFix(0xC9110))
-#define FUNC_STATESETTINGS_RENDER (base + idaOffsetFix(0xC9160))
-#define FUNC_STATESETTINGS_MOUSEINPUT (base + idaOffsetFix(0xC9370))
-#define FUNC_STATESETTINGS_SCROLLINPUT (base + idaOffsetFix(0xC93A0))
-#define FUNC_STATESETTINGS_MOUSEBUTTONINPUT (base + idaOffsetFix(0xC93D0))
-#define FUNC_STATESETTINGS_KEYINPUT (base + idaOffsetFix(0xC9400))
-#define FUNC_STATESETTINGS_WINDOWRESIZE (base + idaOffsetFix(0xC94B0))
-#define FUNC_STATESETTINGS_UPDATERENDERDISTANCE (base + idaOffsetFix(0xC95D0))
-#define FUNC_STATESETTINGS_UPDATEFOV (base + idaOffsetFix(0xC96B0))
-#define FUNC_STATESETTINGS_UPDATECREATUREVOLUME (base + idaOffsetFix(0xC97C0))
-#define FUNC_STATESETTINGS_UPDATEAMBIENCEVOLUME (base + idaOffsetFix(0xC9850))
-#define FUNC_STATESETTINGS_UPDATEDIFFICULTY (base + idaOffsetFix(0xC98E0))
-#define FUNC_STATESETTINGS_SETFULLSCREENMODE (base + idaOffsetFix(0xC99C0))
-
-// StatePause
-
-#define FUNC_STATEPAUSE_STATEPAUSE (base + idaOffsetFix(0xB0DA0))
-#define FUNC_STATEPAUSE_UPDATEPROJECTION (base + idaOffsetFix(0xB0FA0))
-#define FUNC_STATEPAUSE_UPDATE (base + idaOffsetFix(0xB1A70))
-#define FUNC_STATEPAUSE_RENDER (base + idaOffsetFix(0xB1B20))
-#define FUNC_STATEPAUSE_PAUSE (base + idaOffsetFix(0xB1D20))
-#define FUNC_STATEPAUSE_RESUME (base + idaOffsetFix(0xB1D30))
-#define FUNC_STATEPAUSE_WINDOWRESIZE (base + idaOffsetFix(0xB1D40))
-
-// StateCredits
-
-#define FUNC_STATECREDITS_INIT_A (base + idaOffsetFix(0x6D140))
-#define FUNC_STATECREDITS_UPDATE_A (base + idaOffsetFix(0x6DCA0))
-#define FUNC_STATECREDITS_RENDER_A (base + idaOffsetFix(0x6DD40))
-#define FUNC_STATECREDITS_WINDOWRESIZE_A (base + idaOffsetFix(0x6F200))
-#define FUNC_STATECREDITS_KEYINPUT_A (base + idaOffsetFix(0x6F210))
-#define FUNC_STATECREDITS_UPDATEPROJECTION_A (base + idaOffsetFix(0x6F270))
-
-// StateManager
-
-#define FUNC_STATEMANAGER_PUSHSTATE (base + idaOffsetFix(0xD35E0))
-
-// m4::Mat5
-
-#define FUNC_M4_MAT5_OPERATORIND (base + idaOffsetFix(0x67C0))
-#define FUNC_M4_MAT5_MAT5 (base + idaOffsetFix(0xAA8A0))
-#define FUNC_M4_MAT5_MAT5_A (base + idaOffsetFix(0xAA8E0))
-#define FUNC_M4_MAT5_TOJSON (base + idaOffsetFix(0xAA990))
-#define FUNC_M4_MAT5_OPERATORMULT (base + idaOffsetFix(0xAB0C0))
-#define FUNC_M4_MAT5_OPERATORMULTEQ (base + idaOffsetFix(0xAB1B0))
-#define FUNC_M4_MAT5_MULTIPLY (base + idaOffsetFix(0xAB250))
-#define FUNC_M4_MAT5_OPERATORMULT_A (base + idaOffsetFix(0xAB320))
-#define FUNC_M4_MAT5_TRANSLATE (base + idaOffsetFix(0xAB340))
-#define FUNC_M4_MAT5_SCALE (base + idaOffsetFix(0xAB440))
-
-// m4::Rotor
-
-#define FUNC_M4_ROTOR_ROTOR (base + idaOffsetFix(0xA9D00))
-#define FUNC_M4_ROTOR_ROTOR_A (base + idaOffsetFix(0xA9E50))
-#define FUNC_M4_ROTOR_OPERATORMULTEQ (base + idaOffsetFix(0xA9F10))
-#define FUNC_M4_ROTOR_ROTATE (base + idaOffsetFix(0xAA2A0))
-#define FUNC_M4_ROTOR_NORMALIZE (base + idaOffsetFix(0xAA730))
-
-// m4::BiVector4
-
-#define FUNC_M4_BIVECTOR4_BIVECTOR4 (base + idaOffsetFix(0x274C0))
-#define FUNC_M4_BIVECTOR4_BIVECTOR4_A (base + idaOffsetFix(0xA9690))
-#define FUNC_M4_BIVECTOR4_TOJSON (base + idaOffsetFix(0xA9940))
-#define FUNC_M4_BIVECTOR4_NORMALIZE (base + idaOffsetFix(0xA9AD0))
-
-// m4::
-
-#define FUNC_M4_I64VEC3TOJSON (base + idaOffsetFix(0x3EC70))
-#define FUNC_M4_IVEC4TOJSON (base + idaOffsetFix(0x25BA0))
-//#define FUNC_M4_IVEC4FROMJSON (base + idaOffsetFix(0x25BA0))
-#define FUNC_M4_VEC4TOJSON (base + idaOffsetFix(0x2B1F0))
-#define FUNC_M4_VEC4FROMJSON (base + idaOffsetFix(0x2AFC0))
-#define FUNC_M4_CROSS (base + idaOffsetFix(0xA94D0))
-#define FUNC_M4_ADJUSTTOMAXHORIZSPEED (base + idaOffsetFix(0xAB700))
-
-// Item
-
-#define FUNC_ITEM_LOADITEMINFO (base + idaOffsetFix(0x99CD0))
-#define FUNC_ITEM_RENDERITEM (base + idaOffsetFix(0x9A510))
-#define FUNC_ITEM_RENDERITEMDESCRIPTION (base + idaOffsetFix(0x9A6A0))
-#define FUNC_ITEM_CREATEFROMJSON (base + idaOffsetFix(0x9ABE0))
-#define FUNC_ITEM_GIVEMAX (base + idaOffsetFix(0x9ADB0))
-#define FUNC_ITEM_GIVEONE (base + idaOffsetFix(0x9AEA0))
-#define FUNC_ITEM_INSTANTIATEITEM (base + idaOffsetFix(0x9B010))
-#define FUNC_ITEM_COMBINEITEMATTRIBUTES (base + idaOffsetFix(0x9B170))
-#define FUNC_ITEM_SAVE (base + idaOffsetFix(0x9B3E0))
-#define FUNC_ITEM_DESTR_ITEM (base + idaOffsetFix(0x9B500))
-#define FUNC_ITEM_TAKEMAX (base + idaOffsetFix(0x9B510))
-#define FUNC_ITEM_TAKEHALF (base + idaOffsetFix(0x9B5D0))
-
-// World
-
-#define FUNC_WORLD_WORLD (base + idaOffsetFix(0xF5050))
-#define FUNC_WORLD_GETCHUNK (base + idaOffsetFix(0xF6B40))
-#define FUNC_WORLD_GETCHUNKFROMCOORDS (base + idaOffsetFix(0xF6C10))
-#define FUNC_WORLD_GETENTITYINTERSECTION (base + idaOffsetFix(0xF6DF0))
-#define FUNC_WORLD_CASTRAY (base + idaOffsetFix(0xF7490))
-#define FUNC_WORLD_ADDENTITYTOCHUNK (base + idaOffsetFix(0xF8440))
-
-// BlockInfo::ItemMesh
-
-#define FUNC_BLOCKINFO_ITEMMESH_DESTR_ITEMMESH (base + idaOffsetFix(0x195B0))
-
-// BlockInfo
-
-#define FUNC_BLOCKINFO_RENDERITEMMESH (base + idaOffsetFix(0x19B10))
-
-// ItemBlock
-
-#define FUNC_ITEMBLOCK_RENDER (base + idaOffsetFix(0x26BC0))
-#define FUNC_ITEMBLOCK_RENDERENTITY (base + idaOffsetFix(0x26C80))
-#define FUNC_ITEMBLOCK_ISDEADLY (base + idaOffsetFix(0x27060))
-#define FUNC_ITEMBLOCK_ISCOMPATIBLE (base + idaOffsetFix(0x27070))
-#define FUNC_ITEMBLOCK_SAVEATTRIBUTES (base + idaOffsetFix(0x270D0))
-#define FUNC_ITEMBLOCK_ACTION (base + idaOffsetFix(0x27100))
-#define FUNC_ITEMBLOCK_POSTACTION (base + idaOffsetFix(0x273D0))
-#define FUNC_ITEMBLOCK_CLONE (base + idaOffsetFix(0x27400))
-
-// ItemTool
-
-#define FUNC_ITEMTOOL_RENDER (base + idaOffsetFix(0xE4050))
-#define FUNC_ITEMTOOL_RENDERENTITY (base + idaOffsetFix(0xE42B0))
-#define FUNC_ITEMTOOL_ISDEADLY (base + idaOffsetFix(0xE9380))
-#define FUNC_ITEMTOOL_ISCOMPATIBLE (base + idaOffsetFix(0xE9400))
-#define FUNC_ITEMTOOL_GETSTACKLIMIT (base + idaOffsetFix(0xE9480))
-#define FUNC_ITEMTOOL_ACTION (base + idaOffsetFix(0xE94C0))
-#define FUNC_ITEMTOOL_BREAKBLOCK (base + idaOffsetFix(0xE96A0))
-#define FUNC_ITEMTOOL_ENTITYACTION (base + idaOffsetFix(0xE9E50))
-#define FUNC_ITEMTOOL_CLONE (base + idaOffsetFix(0xE9FA0))
-
-// ItemMaterial
-
-#define FUNC_ITEMMATERIAL_GETSTACKLIMIT (base + idaOffsetFix(0x270C0))
-#define FUNC_ITEMMATERIAL_GETNAME (base + idaOffsetFix(0x9EFA0))
-#define FUNC_ITEMMATERIAL_RENDER (base + idaOffsetFix(0x9EFC0))
-#define FUNC_ITEMMATERIAL_RENDERENTITY (base + idaOffsetFix(0x9F310))
-#define FUNC_ITEMMATERIAL_ISDEADLY (base + idaOffsetFix(0xA32A0))
-#define FUNC_ITEMMATERIAL_ISCOMPATIBLE (base + idaOffsetFix(0xA3340))
-#define FUNC_ITEMMATERIAL_ACTION (base + idaOffsetFix(0xA33C0))
-#define FUNC_ITEMMATERIAL_POSTACTION (base + idaOffsetFix(0xA3880))
-#define FUNC_ITEMMATERIAL_CLONE (base + idaOffsetFix(0xA3900))
-
-// Chunk::ChunkMesh
-
-#define FUNC_CHUNK_CHUNKMESH_DESTR_CHUNKMESH (base + idaOffsetFix(0x2DC40))
-#define FUNC_CHUNK_CHUNKMESH_CHUNKMESH (base + idaOffsetFix(0x3C340))
-#define FUNC_CHUNK_CHUNKMESH_BUFFSIZE (base + idaOffsetFix(0x3C390))
-#define FUNC_CHUNK_CHUNKMESH_ATTRCOUNT (base + idaOffsetFix(0x3C3C0))
-#define FUNC_CHUNK_CHUNKMESH_ATTRTYPE (base + idaOffsetFix(0x3C3D0))
-#define FUNC_CHUNK_CHUNKMESH_ATTRSIZE (base + idaOffsetFix(0x3C3E0))
-#define FUNC_CHUNK_CHUNKMESH_ATTRSTRIDE (base + idaOffsetFix(0x3C410))
-#define FUNC_CHUNK_CHUNKMESH_INDEXBUFFDATA (base + idaOffsetFix(0x3C430))
-#define FUNC_CHUNK_CHUNKMESH_MOVE (base + idaOffsetFix(0x3C450))
-#define FUNC_CHUNK_CHUNKMESH_ADDMESHSIDE (base + idaOffsetFix(0x3C530))
-#define FUNC_CHUNK_CHUNKMESH_ADDMESHPLANT (base + idaOffsetFix(0x3C710))
-
-// Chunk
-
-#define FUNC_CHUNK_CHUNK (base + idaOffsetFix(0x2DA10))
-#define FUNC_CHUNK_SETBLOCK (base + idaOffsetFix(0x2DCB0))
-#define FUNC_CHUNK_GENERATEMESH (base + idaOffsetFix(0x2DD90))
-#define FUNC_CHUNK_UPDATEENTITIESCLIENT (base + idaOffsetFix(0x2DEF0))
-#define FUNC_CHUNK_CLEARENTITIES (base + idaOffsetFix(0x2E1C0))
-#define FUNC_CHUNK_RENDER (base + idaOffsetFix(0x2E280))
-#define FUNC_CHUNK_UPDATELIGHTINGHEIGHTMAP (base + idaOffsetFix(0x2EBC0))
-#define FUNC_CHUNK_UPDATEMESH (base + idaOffsetFix(0x2ECA0))
-#define FUNC_CHUNK_LOAD (base + idaOffsetFix(0x2EE90))
-#define FUNC_CHUNK_SAVE (base + idaOffsetFix(0x2FF50))
-#define FUNC_CHUNK_LOADFROMMESSAGE (base + idaOffsetFix(0x30890))
-#define FUNC_CHUNK_UPDATECACHESECTION (base + idaOffsetFix(0x30A30))
-#define FUNC_CHUNK_UPDATEHEIGHTMAPCACHESECTION (base + idaOffsetFix(0x38310))
-#define FUNC_CHUNK_GENERATEMESHSECTION (base + idaOffsetFix(0x38B00))
-#define FUNC_CHUNK_GETSMOOTHLIGHTING (base + idaOffsetFix(0x3A8D0))
-#define FUNC_CHUNK_GETLIGHTING (base + idaOffsetFix(0x3BD20))
-#define FUNC_CHUNK_ENABLEMESH (base + idaOffsetFix(0x3BF20))
-#define FUNC_CHUNK_LOADENTITIESFROMJSON (base + idaOffsetFix(0x3C0E0))
-#define FUNC_CHUNK_GETFILENAMEPREFIX (base + idaOffsetFix(0x3C220))
-
-// ChunkLoader::BiomeInfo
-
-#define FUNC_CHUNKLOADER_BIOMEINFO_DESTR_BIOMEINFO (base + idaOffsetFix(0xD5710))
-#define FUNC_CHUNKLOADER_BIOMEINFO_BIOMEINFO (base + idaOffsetFix(0xDD000))
-
-// ChunkLoader
-
-#define FUNC_CHUNKLOADER_INIT (base + idaOffsetFix(0xD3790))
-#define FUNC_CHUNKLOADER_LOADCHUNK (base + idaOffsetFix(0xD3970))
-#define FUNC_CHUNKLOADER_LOADBIOMES (base + idaOffsetFix(0xD3F90))
-#define FUNC_CHUNKLOADER_LOADINFO (base + idaOffsetFix(0xD5810))
-#define FUNC_CHUNKLOADER_GENERATECHUNK (base + idaOffsetFix(0xD6430))
-#define FUNC_CHUNKLOADER_GETBIOME (base + idaOffsetFix(0xD7350))
-#define FUNC_CHUNKLOADER_GENERATETREE (base + idaOffsetFix(0xD7690))
-#define FUNC_CHUNKLOADER_GENERATETREEBRANCH (base + idaOffsetFix(0xD7D40))
-#define FUNC_CHUNKLOADER_GENERATETAIGATREE (base + idaOffsetFix(0xD86E0))
-#define FUNC_CHUNKLOADER_CREATEFLATWORLDCHESTS (base + idaOffsetFix(0xD8A70))
-
-// CloudChunk::CloudChunkMesh
-
-#define FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_INDEXBUFFSIZE (base + idaOffsetFix(0x3C440))
-#define FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_BUFFSIZE (base + idaOffsetFix(0x44F10))
-#define FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_ATTRSIZE (base + idaOffsetFix(0x44F30))
-#define FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_ATTRSTRIDE (base + idaOffsetFix(0x44F40))
-#define FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_MOVE (base + idaOffsetFix(0x44F50))
-#define FUNC_CLOUDCHUNK_CLOUDCHUNKMESH_DESTR_CLOUDCHUNKMESH (base + idaOffsetFix(0x45010))
-
-// CloudChunk
-
-#define FUNC_CLOUDCHUNK_GENERATEMESH (base + idaOffsetFix(0x450C0))
-
-// CloudManager
-
-#define FUNC_CLOUDMANAGER_DESTR_CLOUDMANAGER (base + idaOffsetFix(0x45710))
-#define FUNC_CLOUDMANAGER_RENDER (base + idaOffsetFix(0x457A0))
-#define FUNC_CLOUDMANAGER_UPDATECHUNKS (base + idaOffsetFix(0x45B80))
-#define FUNC_CLOUDMANAGER_UNLOADALLCHUNKS (base + idaOffsetFix(0x46F50))
-#define FUNC_CLOUDMANAGER_LOADCHUNKS (base + idaOffsetFix(0x47020))
-#define FUNC_CLOUDMANAGER_UPDATECHUNK (base + idaOffsetFix(0x47340))
-
-// CraftingMenu::CraftableRecipe
-
-#define FUNC_CRAFTINGMENU_CRAFTABLERECIPE_DESTR_CRAFTABLERECIPE (base + idaOffsetFix(0x5B4F0))
-#define FUNC_CRAFTINGMENU_CRAFTABLERECIPE_CRAFTABLERECIPE (base + idaOffsetFix(0x5C070))
-
-// CraftingMenu
-
-#define FUNC_CRAFTINGMENU_LOADRECIPES (base + idaOffsetFix(0x5A270))
-#define FUNC_CRAFTINGMENU_RENDER (base + idaOffsetFix(0x5A700))
-#define FUNC_CRAFTINGMENU_OFFSETX (base + idaOffsetFix(0x5ABA0))
-#define FUNC_CRAFTINGMENU_OFFSETY (base + idaOffsetFix(0x5ABB0))
-#define FUNC_CRAFTINGMENU_GETPOS (base + idaOffsetFix(0x5ABC0))
-#define FUNC_CRAFTINGMENU_GETSIZE (base + idaOffsetFix(0x5ACA0))
-#define FUNC_CRAFTINGMENU_MOUSEBUTTONINPUT (base + idaOffsetFix(0x5AD50))
-#define FUNC_CRAFTINGMENU_UPDATEAVAILABLERECIPES (base + idaOffsetFix(0x5AE90))
-
-// Entity
-
-#define FUNC_ENTITY_LOADENTITYINFO (base + idaOffsetFix(0x78500))
-#define FUNC_ENTITY_CREATEFROMJSON (base + idaOffsetFix(0x78F20))
-#define FUNC_ENTITY_CREATEWITHATTRIBUTES (base + idaOffsetFix(0x791F0))
-#define FUNC_ENTITY_SAVE (base + idaOffsetFix(0x792D0))
-#define FUNC_ENTITY_INSTANTIATEENTITY (base + idaOffsetFix(0x79ED0))
-#define FUNC_ENTITY_COMBINEENTITYATTRIBUTES (base + idaOffsetFix(0x7A780))
-#define FUNC_ENTITY_DESTR_ENTITY (base + idaOffsetFix(0x7A9F0))
-
-// InventoryPlayer
-
-#define FUNC_INVENTORYPLAYER_ADDITEM (base + idaOffsetFix(0x96800))
-#define FUNC_INVENTORYPLAYER_BEGIN (base + idaOffsetFix(0x96A50))
-#define FUNC_INVENTORYPLAYER_RENDER (base + idaOffsetFix(0xC3B90))
-#define FUNC_INVENTORYPLAYER_COMBINEITEM (base + idaOffsetFix(0xC3BC0))
-#define FUNC_INVENTORYPLAYER_PLACEITEM (base + idaOffsetFix(0xC3C30))
-#define FUNC_INVENTORYPLAYER_GETSLOTINDEX (base + idaOffsetFix(0xC3CA0))
-#define FUNC_INVENTORYPLAYER_GETSLOTCOUNT (base + idaOffsetFix(0xC3CF0))
-#define FUNC_INVENTORYPLAYER_GETSLOT (base + idaOffsetFix(0xC3D20))
-#define FUNC_INVENTORYPLAYER_END (base + idaOffsetFix(0xC3D90))
-
-// InventoryGrid
-
-#define FUNC_INVENTORYGRID_DESTR_INVENTORYGRID (base + idaOffsetFix(0x2BB40))
-#define FUNC_INVENTORYGRID_INVENTORYGRID (base + idaOffsetFix(0x96360))
-#define FUNC_INVENTORYGRID_RENDER (base + idaOffsetFix(0x96410))
-#define FUNC_INVENTORYGRID_COMBINEITEM (base + idaOffsetFix(0x96870))
-#define FUNC_INVENTORYGRID_PLACEITEM (base + idaOffsetFix(0x96920))
-#define FUNC_INVENTORYGRID_GETSLOTINDEX (base + idaOffsetFix(0x96970))
-#define FUNC_INVENTORYGRID_GETSLOTCOUNT (base + idaOffsetFix(0x969E0))
-#define FUNC_INVENTORYGRID_GETSLOT (base + idaOffsetFix(0x969F0))
-#define FUNC_INVENTORYGRID_END (base + idaOffsetFix(0x96A60))
-#define FUNC_INVENTORYGRID_LOAD (base + idaOffsetFix(0x96A80))
-#define FUNC_INVENTORYGRID_SAVE (base + idaOffsetFix(0x96C60))
-
-// InventorySession
-
-#define FUNC_INVENTORYSESSION_DESTR_INVENTORYSESSION (base + idaOffsetFix(0x96F00))
-
-// InventoryManager
-
-#define FUNC_INVENTORYMANAGER_DESTR_INVENTORYMANAGER (base + idaOffsetFix(0x7CD50))
-#define FUNC_INVENTORYMANAGER_RENDERINIT (base + idaOffsetFix(0x96F20))
-#define FUNC_INVENTORYMANAGER_MOUSEBUTTONINPUT (base + idaOffsetFix(0x973D0))
-#define FUNC_INVENTORYMANAGER_WINDOWRESIZE (base + idaOffsetFix(0x97AB0))
-#define FUNC_INVENTORYMANAGER_APPLYACTION (base + idaOffsetFix(0x97B60))
-#define FUNC_INVENTORYMANAGER_APPLYTRANSFER (base + idaOffsetFix(0x98D70))
-#define FUNC_INVENTORYMANAGER_FINDINVENTORY (base + idaOffsetFix(0x98EF0))
-#define FUNC_INVENTORYMANAGER_UPDATECRAFTINGMENUBOX (base + idaOffsetFix(0x99190))
-#define FUNC_INVENTORYMANAGER_CRAFTINGMENUCALLBACK (base + idaOffsetFix(0x99240))
-#define FUNC_INVENTORYMANAGER_VIEWPORTCALLBACK (base + idaOffsetFix(0x995A0))
-#define FUNC_INVENTORYMANAGER_UPDATEPROJECTION (base + idaOffsetFix(0x99600))
-
-// MeshBuilder
-
-#define FUNC_MESHBUILDER_MESHBUILDER (base + idaOffsetFix(0x84AD0))
-#define FUNC_MESHBUILDER_MESHBUILDER_A (base + idaOffsetFix(0x84B00))
-#define FUNC_MESHBUILDER_DESTR_MESHBUILDER (base + idaOffsetFix(0x84C70))
-#define FUNC_MESHBUILDER_BUFFCOUNT (base + idaOffsetFix(0x84C90))
-#define FUNC_MESHBUILDER_BUFFSIZE (base + idaOffsetFix(0x84CD0))
-#define FUNC_MESHBUILDER_ATTRCOUNT (base + idaOffsetFix(0x84CE0))
-#define FUNC_MESHBUILDER_VERTCOUNT (base + idaOffsetFix(0x84D10))
-#define FUNC_MESHBUILDER_INDEXBUFFSIZE (base + idaOffsetFix(0x84D30))
-#define FUNC_MESHBUILDER_ADDBUFF (base + idaOffsetFix(0x84D40))
-#define FUNC_MESHBUILDER_ATTRTYPE (base + idaOffsetFix(0x84DC0))
-#define FUNC_MESHBUILDER_ATTRSIZE (base + idaOffsetFix(0x84DE0))
-#define FUNC_MESHBUILDER_ATTRSTRIDE (base + idaOffsetFix(0x84E00))
-#define FUNC_MESHBUILDER_ADDATTR (base + idaOffsetFix(0x84E20))
-#define FUNC_MESHBUILDER_CLEAR (base + idaOffsetFix(0x84E70))
-
-// Player
-
-#define FUNC_PLAYER_DESTR_PLAYER (base + idaOffsetFix(0x7CCB0))
-#define FUNC_PLAYER_PLAYER (base + idaOffsetFix(0x7D1A0))
-#define FUNC_PLAYER_UPDATEPOS (base + idaOffsetFix(0xB1D70))
-#define FUNC_PLAYER_UPDATECURRENTBLOCK (base + idaOffsetFix(0xB2BA0))
-#define FUNC_PLAYER_HANDLECOLLISION (base + idaOffsetFix(0xB2CD0))
-#define FUNC_PLAYER_UPDATECOMPONENTVECTORS (base + idaOffsetFix(0xB3F80))
-#define FUNC_PLAYER_UPDATEALLCOMPONENTVECTORS (base + idaOffsetFix(0xB4710))
-#define FUNC_PLAYER_REMOVEVELCOMP (base + idaOffsetFix(0xB4810))
-#define FUNC_PLAYER_UPDATETARGETBLOCK (base + idaOffsetFix(0xB4CC0))
-#define FUNC_PLAYER_INIT (base + idaOffsetFix(0xB58A0))
-#define FUNC_PLAYER_RENDERHUD (base + idaOffsetFix(0xB5DC0))
-#define FUNC_PLAYER_RENDERTARGETBLOCK (base + idaOffsetFix(0xB7720))
-#define FUNC_PLAYER_GETMOVEMENTUPDATE (base + idaOffsetFix(0xB7DF0))
-#define FUNC_PLAYER_SETMOVEMENTBEHAVIOR (base + idaOffsetFix(0xB92A0))
-#define FUNC_PLAYER_HITTARGETBLOCK (base + idaOffsetFix(0xB9790))
-#define FUNC_PLAYER_BREAKBLOCK (base + idaOffsetFix(0xB9890))
-#define FUNC_PLAYER_THROWITEM (base + idaOffsetFix(0xB9D20))
-#define FUNC_PLAYER_UPDATE (base + idaOffsetFix(0xBA010))
-#define FUNC_PLAYER_UPDATELOCAL (base + idaOffsetFix(0xBACB0))
-#define FUNC_PLAYER_UPDATECAMERAPOS (base + idaOffsetFix(0xBB380))
-#define FUNC_PLAYER_RESETMOUSE (base + idaOffsetFix(0xBC210))
-#define FUNC_PLAYER_KEYINPUT (base + idaOffsetFix(0xBC2F0))
-#define FUNC_PLAYER_MOUSEINPUT (base + idaOffsetFix(0xBCB50))
-#define FUNC_PLAYER_MOUSEBUTTONINPUT (base + idaOffsetFix(0xBD410))
-#define FUNC_PLAYER_ISHOLDINGGLASSES (base + idaOffsetFix(0xBD5F0))
-#define FUNC_PLAYER_ISHOLDINGCOMPASS (base + idaOffsetFix(0xBD700))
-#define FUNC_PLAYER_ISHOLDINGCOLLECTOR (base + idaOffsetFix(0xBD780))
-#define FUNC_PLAYER_HEADISINBLOCK (base + idaOffsetFix(0xBD800))
-#define FUNC_PLAYER_GETHEADBLOCK (base + idaOffsetFix(0xBD820))
-#define FUNC_PLAYER_RESPAWN (base + idaOffsetFix(0xBD840))
-#define FUNC_PLAYER_LOAD (base + idaOffsetFix(0xBD9F0))
-#define FUNC_PLAYER_SAVE (base + idaOffsetFix(0xBDEA0))
-#define FUNC_PLAYER_LOADCLIENTDATA (base + idaOffsetFix(0xBF080))
-#define FUNC_PLAYER_SAVECLIENTDATA (base + idaOffsetFix(0xBF400))
-#define FUNC_PLAYER_SAVEORIENTATION (base + idaOffsetFix(0xC0680))
-
-// QuadRenderer
-
-#define FUNC_QUADRENDERER_DESTR_QUADRENDERER (base + idaOffsetFix(0xC3DE0))
-#define FUNC_QUADRENDERER_INIT (base + idaOffsetFix(0xC3E30))
-#define FUNC_QUADRENDERER_SETCOLOR (base + idaOffsetFix(0xC4250))
-#define FUNC_QUADRENDERER_SETPOS (base + idaOffsetFix(0xC4330))
-
-// ResourceManager
-
-#define FUNC_RESOURCEMANAGER_LOADARRAYTEXTURE (base + idaOffsetFix(0xC47F0))
-#define FUNC_RESOURCEMANAGER_GET (base + idaOffsetFix(0xC45A0))
-
-// ShaderManager
-
-#define FUNC_SHADERMANAGER_LOADFROMSHADERLIST (base + idaOffsetFix(0xCA290))
-#define FUNC_SHADERMANAGER_GET (base + idaOffsetFix(0xCA200))
-
-// Shader
-
-#define FUNC_SHADER_LOAD (base + idaOffsetFix(0xC9BA0))
-#define FUNC_SHADER_COMPILESHADER (base + idaOffsetFix(0xC9CD0))
-
-// Tex2D
-
-#define FUNC_TEX2D_DESTR_TEX2D_A (base + idaOffsetFix(0xDF7F0))
-#define FUNC_TEX2D_LOADRAWIMAGEDATA_A (base + idaOffsetFix(0xDF820))
-#define FUNC_TEX2D_INITFROMTEXID_A (base + idaOffsetFix(0xDF940))
-#define FUNC_TEX2D_LOADARRAYTEXTURE_A (base + idaOffsetFix(0xDFA30))
-
-// WorldManager
-
-#define FUNC_WORLDMANAGER_DESTR_WORLDMANAGER (base + idaOffsetFix(0xF4FF0))
-#define FUNC_WORLDMANAGER_UPDATERENDERFRUSTUM (base + idaOffsetFix(0x1017E0))
-#define FUNC_WORLDMANAGER_SETBLOCKUPDATE (base + idaOffsetFix(0x101D10))
-#define FUNC_WORLDMANAGER_RENDER (base + idaOffsetFix(0x1025C0))
-
-// WorldClient
-
-#define FUNC_WORLDCLIENT_DESTR_WORLDCLIENT (base + idaOffsetFix(0xF8980))
-#define FUNC_WORLDCLIENT_ADDENTITYTOCHUNK (base + idaOffsetFix(0xF8B20))
-#define FUNC_WORLDCLIENT_LOCALPLAYEREVENT (base + idaOffsetFix(0xF8D10))
-#define FUNC_WORLDCLIENT_UPDATELOCAL (base + idaOffsetFix(0xF9770))
-#define FUNC_WORLDCLIENT_SETRENDERDISTANCELOCAL (base + idaOffsetFix(0xF9BD0))
-#define FUNC_WORLDCLIENT_SETSKINVISIBILITY (base + idaOffsetFix(0xF9CA0))
-#define FUNC_WORLDCLIENT_LOCALPLAYERINIT (base + idaOffsetFix(0xFA060))
-#define FUNC_WORLDCLIENT_LOCALPLAYERRESPAWN (base + idaOffsetFix(0xFA090))
-#define FUNC_WORLDCLIENT_SENDCHATMESSAGE (base + idaOffsetFix(0xFA2D0))
-#define FUNC_WORLDCLIENT_UPDATEPHYSICS (base + idaOffsetFix(0xFA3C0))
-#define FUNC_WORLDCLIENT_HANDLEWORLDMESSAGE (base + idaOffsetFix(0xFA520))
-#define FUNC_WORLDCLIENT_HANDLELIGHTINGOPTIONSUPDATE (base + idaOffsetFix(0xFCD30))
-#define FUNC_WORLDCLIENT_UPDATECHUNKS (base + idaOffsetFix(0xFCE50))
-#define FUNC_WORLDCLIENT_UPDATECHUNK (base + idaOffsetFix(0xFE2D0))
-#define FUNC_WORLDCLIENT_GENERATECHUNKMESHES (base + idaOffsetFix(0xFE5E0))
-#define FUNC_WORLDCLIENT_UPDATECHUNKCACHEANDMESH (base + idaOffsetFix(0xFECA0))
-#define FUNC_WORLDCLIENT_UPDATECHUNKCACHE (base + idaOffsetFix(0xFECF0))
-#define FUNC_WORLDCLIENT_REGENERATEALLCHUNKMESHES (base + idaOffsetFix(0xFF260))
-#define FUNC_WORLDCLIENT_JOINALLCHUNKLOADINGTHREADS (base + idaOffsetFix(0xFF2F0))
-#define FUNC_WORLDCLIENT_HANDLEMESSAGE (base + idaOffsetFix(0xFF3A0))
-#define FUNC_WORLDCLIENT_INVENTORYUPDATECALLBACK (base + idaOffsetFix(0xFFBA0))
-
-// WorldSingleplayer
-
-#define FUNC_WORLDSINGLEPLAYER_WORLDSINGLEPLAYER (base + idaOffsetFix(0x102A60))
-#define FUNC_WORLDSINGLEPLAYER_DESTR_WORLDSINGLEPLAYER (base + idaOffsetFix(0x102BE0))
-#define FUNC_WORLDSINGLEPLAYER_LOCALPLAYEREVENT (base + idaOffsetFix(0x102E40))
-#define FUNC_WORLDSINGLEPLAYER_UPDATELOCAL (base + idaOffsetFix(0x103230))
-#define FUNC_WORLDSINGLEPLAYER_CLEANUPLOCAL (base + idaOffsetFix(0x103520))
-#define FUNC_WORLDSINGLEPLAYER_SETRENDERDISTANCELOCAL (base + idaOffsetFix(0x1039E0))
-#define FUNC_WORLDSINGLEPLAYER_SETDIFFICULTYLOCAL (base + idaOffsetFix(0x103A10))
-#define FUNC_WORLDSINGLEPLAYER_LOCALPLAYERINIT (base + idaOffsetFix(0x103AB0))
-#define FUNC_WORLDSINGLEPLAYER_LOCALPLAYERRESPAWN (base + idaOffsetFix(0x103AD0))
-#define FUNC_WORLDSINGLEPLAYER_HANDLELIGHTINGOPTIONSUPDATE (base + idaOffsetFix(0x103BE0))
-#define FUNC_WORLDSINGLEPLAYER_UPDATECHUNKS (base + idaOffsetFix(0x103D40))
-#define FUNC_WORLDSINGLEPLAYER_UPDATECHUNK (base + idaOffsetFix(0x105080))
-#define FUNC_WORLDSINGLEPLAYER_LOADCHUNKS (base + idaOffsetFix(0x105290))
-#define FUNC_WORLDSINGLEPLAYER_LOADCHUNK (base + idaOffsetFix(0x105B40))
-#define FUNC_WORLDSINGLEPLAYER_UPDATECHUNKCACHEANDMESH (base + idaOffsetFix(0x105BA0))
-#define FUNC_WORLDSINGLEPLAYER_UPDATECHUNKCACHE (base + idaOffsetFix(0x105BF0))
-#define FUNC_WORLDSINGLEPLAYER_REGENERATEALLCHUNKMESHES (base + idaOffsetFix(0x106160))
-
-// gui::Button
-
-#define FUNC_GUI_BUTTON_DESTR_BUTTON (base + idaOffsetFix(0x2BB70))
-#define FUNC_GUI_BUTTON_RENDER (base + idaOffsetFix(0x85EE0))
-#define FUNC_GUI_BUTTON_MOUSEBUTTONINPUT (base + idaOffsetFix(0x865F0))
-#define FUNC_GUI_BUTTON_KEYINPUT (base + idaOffsetFix(0x86670))
-#define FUNC_GUI_BUTTON_OFFSETX (base + idaOffsetFix(0x866C0))
-#define FUNC_GUI_BUTTON_ENABLED (base + idaOffsetFix(0x866D0))
-#define FUNC_GUI_BUTTON_SELECT (base + idaOffsetFix(0x866E0))
-#define FUNC_GUI_BUTTON_GETPOS (base + idaOffsetFix(0x86700))
-#define FUNC_GUI_BUTTON_GETSIZE (base + idaOffsetFix(0x867C0))
-#define FUNC_GUI_BUTTON_TOUCHINGMOUSE (base + idaOffsetFix(0x867D0))
-
-// gui::CheckBox
-
-#define FUNC_GUI_CHECKBOX_RENDER (base + idaOffsetFix(0x86860))
-#define FUNC_GUI_CHECKBOX_MOUSEBUTTONINPUT (base + idaOffsetFix(0x87000))
-#define FUNC_GUI_CHECKBOX_KEYINPUT (base + idaOffsetFix(0x87090))
-#define FUNC_GUI_CHECKBOX_GETPOS (base + idaOffsetFix(0x870E0))
-#define FUNC_GUI_CHECKBOX_GETSIZE (base + idaOffsetFix(0x871C0))
-#define FUNC_GUI_CHECKBOX_TOUCHINGMOUSE (base + idaOffsetFix(0x87210))
-
-// gui::ContentBox
-
-#define FUNC_GUI_CONTENTBOX_DESTR_CONTENTBOX (base + idaOffsetFix(0x7CDE0))
-#define FUNC_GUI_CONTENTBOX_GETQUADRENDERER (base + idaOffsetFix(0x89600))
-#define FUNC_GUI_CONTENTBOX_GETFONT (base + idaOffsetFix(0x89610))
-#define FUNC_GUI_CONTENTBOX_GETGLFWWINDOW (base + idaOffsetFix(0x89620))
-#define FUNC_GUI_CONTENTBOX_GETCURSORPOS (base + idaOffsetFix(0x89630))
-#define FUNC_GUI_CONTENTBOX_GETSIZE (base + idaOffsetFix(0x896A0))
-#define FUNC_GUI_CONTENTBOX_CHANGEVIEWPORT (base + idaOffsetFix(0x896B0))
-#define FUNC_GUI_CONTENTBOX_GETPOS (base + idaOffsetFix(0x897F0))
-#define FUNC_GUI_CONTENTBOX_GETSIZE_A (base + idaOffsetFix(0x898A0))
-#define FUNC_GUI_CONTENTBOX_TOUCHINGMOUSE (base + idaOffsetFix(0x898B0))
-#define FUNC_GUI_CONTENTBOX_RESETVIEWPORT (base + idaOffsetFix(0x89950))
-#define FUNC_GUI_CONTENTBOX_RENDER (base + idaOffsetFix(0x899F0))
-#define FUNC_GUI_CONTENTBOX_ALIGNX (base + idaOffsetFix(0x8A540))
-#define FUNC_GUI_CONTENTBOX_ALIGNY (base + idaOffsetFix(0x8A550))
-#define FUNC_GUI_CONTENTBOX_OFFSETX (base + idaOffsetFix(0x8A560))
-#define FUNC_GUI_CONTENTBOX_OFFSETY (base + idaOffsetFix(0x8A570))
-#define FUNC_GUI_CONTENTBOX_MOUSEINPUT (base + idaOffsetFix(0x8A580))
-#define FUNC_GUI_CONTENTBOX_SCROLLINPUT (base + idaOffsetFix(0x8A840))
-#define FUNC_GUI_CONTENTBOX_MOUSEBUTTONINPUT (base + idaOffsetFix(0x8A9B0))
-#define FUNC_GUI_CONTENTBOX_KEYINPUT (base + idaOffsetFix(0x8ACC0))
-#define FUNC_GUI_CONTENTBOX_SELECT (base + idaOffsetFix(0x8AE80))
-#define FUNC_GUI_CONTENTBOX_DESELECT (base + idaOffsetFix(0x8AEB0))
-#define FUNC_GUI_CONTENTBOX_ADDELEMENT (base + idaOffsetFix(0x8AEF0))
-#define FUNC_GUI_CONTENTBOX_REMOVEELEMENT (base + idaOffsetFix(0x8AF30))
-#define FUNC_GUI_CONTENTBOX_SELECTELEMENT (base + idaOffsetFix(0x8AFA0))
-#define FUNC_GUI_CONTENTBOX_CLEAR (base + idaOffsetFix(0x8B060))
-#define FUNC_GUI_CONTENTBOX_EMPTY (base + idaOffsetFix(0x8B0B0))
-
-// gui::Element
-
-#define FUNC_GUI_ELEMENT_ENABLED (base + idaOffsetFix(0x1DB80))
-#define FUNC_GUI_ELEMENT_GETCURSORTYPE (base + idaOffsetFix(0x5A260))
-
-// gui::Image
-
-#define FUNC_GUI_IMAGE_OFFSETX (base + idaOffsetFix(0x69D80))
-#define FUNC_GUI_IMAGE_OFFSETY (base + idaOffsetFix(0x69D90))
-#define FUNC_GUI_IMAGE_RENDER (base + idaOffsetFix(0x8BD40))
-#define FUNC_GUI_IMAGE_GETPOS (base + idaOffsetFix(0x8BE00))
-#define FUNC_GUI_IMAGE_GETSIZE (base + idaOffsetFix(0x8BEE0))
-
-// gui::Interface
-
-#define FUNC_GUI_INTERFACE_INTERFACE (base + idaOffsetFix(0x85600))
-#define FUNC_GUI_INTERFACE_DESTR_INTERFACE (base + idaOffsetFix(0x85670))
-#define FUNC_GUI_INTERFACE_RENDER (base + idaOffsetFix(0x856F0))
-#define FUNC_GUI_INTERFACE_MOUSEINPUT (base + idaOffsetFix(0x857E0))
-#define FUNC_GUI_INTERFACE_SCROLLINPUT (base + idaOffsetFix(0x858E0))
-#define FUNC_GUI_INTERFACE_MOUSEBUTTONINPUT (base + idaOffsetFix(0x85980))
-#define FUNC_GUI_INTERFACE_KEYINPUT (base + idaOffsetFix(0x85A80))
-#define FUNC_GUI_INTERFACE_GETQUADRENDERER (base + idaOffsetFix(0x85C30))
-#define FUNC_GUI_INTERFACE_GETFONT (base + idaOffsetFix(0x85C40))
-#define FUNC_GUI_INTERFACE_GETGLFWWINDOW (base + idaOffsetFix(0x85C50))
-#define FUNC_GUI_INTERFACE_GETCURSORPOS (base + idaOffsetFix(0x85C60))
-#define FUNC_GUI_INTERFACE_GETSIZE (base + idaOffsetFix(0x85CC0))
-#define FUNC_GUI_INTERFACE_CHANGEVIEWPORT (base + idaOffsetFix(0x85CD0))
-#define FUNC_GUI_INTERFACE_ADDELEMENT (base + idaOffsetFix(0x85CF0))
-#define FUNC_GUI_INTERFACE_REMOVEELEMENT (base + idaOffsetFix(0x85D30))
-#define FUNC_GUI_INTERFACE_SELECTELEMENT (base + idaOffsetFix(0x85DC0))
-#define FUNC_GUI_INTERFACE_CLEAR (base + idaOffsetFix(0x85E80))
-#define FUNC_GUI_INTERFACE_EMPTY (base + idaOffsetFix(0x85ED0))
-
-// gui::Slider
-
-#define FUNC_GUI_SLIDER_OFFSETX (base + idaOffsetFix(0x5AB80))
-#define FUNC_GUI_SLIDER_OFFSETY (base + idaOffsetFix(0x5AB90))
-#define FUNC_GUI_SLIDER_DESELECT (base + idaOffsetFix(0x866F0))
-#define FUNC_GUI_SLIDER_RENDER (base + idaOffsetFix(0x872A0))
-#define FUNC_GUI_SLIDER_MOUSEBUTTONINPUT (base + idaOffsetFix(0x87920))
-#define FUNC_GUI_SLIDER_MOUSEINPUT (base + idaOffsetFix(0x87A00))
-#define FUNC_GUI_SLIDER_KEYINPUT (base + idaOffsetFix(0x87AE0))
-#define FUNC_GUI_SLIDER_ALIGNX (base + idaOffsetFix(0x87B40))
-#define FUNC_GUI_SLIDER_ALIGNY (base + idaOffsetFix(0x87B50))
-#define FUNC_GUI_SLIDER_GETPOS (base + idaOffsetFix(0x87B60))
-#define FUNC_GUI_SLIDER_GETSIZE (base + idaOffsetFix(0x87C10))
-
-// gui::Text
-
-#define FUNC_GUI_TEXT_RENDER (base + idaOffsetFix(0x8B0C0))
-#define FUNC_GUI_TEXT_OFFSETX (base + idaOffsetFix(0x8B4D0))
-#define FUNC_GUI_TEXT_GETPOS (base + idaOffsetFix(0x8B4E0))
-#define FUNC_GUI_TEXT_GETSIZE (base + idaOffsetFix(0x8B5C0))
-#define FUNC_GUI_TEXT_SETTEXT (base + idaOffsetFix(0x8B820))
-#define FUNC_GUI_TEXT_RENDERTEXT (base + idaOffsetFix(0x8B9C0))
-
-// gui::TextInput
-
-#define FUNC_GUI_TEXTINPUT_RENDER (base + idaOffsetFix(0x87C20))
-#define FUNC_GUI_TEXTINPUT_ALIGNX (base + idaOffsetFix(0x88730))
-#define FUNC_GUI_TEXTINPUT_ALIGNY (base + idaOffsetFix(0x88740))
-#define FUNC_GUI_TEXTINPUT_OFFSETX (base + idaOffsetFix(0x88750))
-#define FUNC_GUI_TEXTINPUT_OFFSETY (base + idaOffsetFix(0x88760))
-#define FUNC_GUI_TEXTINPUT_MOUSEBUTTONINPUT (base + idaOffsetFix(0x88770))
-#define FUNC_GUI_TEXTINPUT_MOUSEINPUT (base + idaOffsetFix(0x888E0))
-#define FUNC_GUI_TEXTINPUT_KEYINPUT (base + idaOffsetFix(0x88A40))
-#define FUNC_GUI_TEXTINPUT_CHARINPUT (base + idaOffsetFix(0x890B0))
-#define FUNC_GUI_TEXTINPUT_GETCURSORTYPE (base + idaOffsetFix(0x891E0))
-#define FUNC_GUI_TEXTINPUT_SELECT (base + idaOffsetFix(0x891F0))
-#define FUNC_GUI_TEXTINPUT_DESELECT (base + idaOffsetFix(0x89200))
-#define FUNC_GUI_TEXTINPUT_UPDATEPASSWORDVISUALTEXT (base + idaOffsetFix(0x89210))
-#define FUNC_GUI_TEXTINPUT_UPDATESCROLLPOS (base + idaOffsetFix(0x892D0))
-#define FUNC_GUI_TEXTINPUT_GETPOS (base + idaOffsetFix(0x89350))
-#define FUNC_GUI_TEXTINPUT_GETSIZE (base + idaOffsetFix(0x89410))
-#define FUNC_GUI_TEXTINPUT_REMOVEINVALIDCHARS (base + idaOffsetFix(0x89420))
-#define FUNC_GUI_TEXTINPUT_REMOVEHIGHLIGHTEDTEXT (base + idaOffsetFix(0x89550))
-
-// EntityButterfly
-
-#define FUNC_ENTITYBUTTERFLY_GETNAME (base + idaOffsetFix(0x27800))
-#define FUNC_ENTITYBUTTERFLY_UPDATE (base + idaOffsetFix(0x27840))
-#define FUNC_ENTITYBUTTERFLY_RENDER (base + idaOffsetFix(0x27D20))
-#define FUNC_ENTITYBUTTERFLY_GETSERVERUPDATEATTRIBUTES (base + idaOffsetFix(0x29D10))
-#define FUNC_ENTITYBUTTERFLY_APPLYSERVERUPDATE (base + idaOffsetFix(0x2A020))
-#define FUNC_ENTITYBUTTERFLY_TAKEDAMAGE (base + idaOffsetFix(0x2A230))
-#define FUNC_ENTITYBUTTERFLY_PLAYHITSOUND (base + idaOffsetFix(0x2A980))
-#define FUNC_ENTITYBUTTERFLY_PLAYDEATHSOUND (base + idaOffsetFix(0x2AA30))
-#define FUNC_ENTITYBUTTERFLY_COLLISIONCALLBACK (base + idaOffsetFix(0x2AAE0))
-
-// EntityAlidade::SPInfo
-
-#define FUNC_ENTITYALIDADE_SPINFO_SPINFO (base + idaOffsetFix(0x1F580))
-#define FUNC_ENTITYALIDADE_SPINFO_DESTR_SPINFO (base + idaOffsetFix(0x1F5A0))
-
-// EntityAlidade
-
-#define FUNC_ENTITYALIDADE_GETNAME (base + idaOffsetFix(0x1C620))
-#define FUNC_ENTITYALIDADE_UPDATE (base + idaOffsetFix(0x1C660))
-#define FUNC_ENTITYALIDADE_RENDER (base + idaOffsetFix(0x1C850))
-#define FUNC_ENTITYALIDADE_SAVEATTRIBUTES (base + idaOffsetFix(0x1D510))
-#define FUNC_ENTITYALIDADE_GETPOS (base + idaOffsetFix(0x1DB10))
-#define FUNC_ENTITYALIDADE_SETPOS (base + idaOffsetFix(0x1DB20))
-#define FUNC_ENTITYALIDADE_TAKEDAMAGE (base + idaOffsetFix(0x1DBB0))
-#define FUNC_ENTITYALIDADE_ACTION (base + idaOffsetFix(0x1DBC0))
-#define FUNC_ENTITYALIDADE_POSTACTION (base + idaOffsetFix(0x1DBD0))
-#define FUNC_ENTITYALIDADE_GENERATESPHERINDER (base + idaOffsetFix(0x1DD40))
-#define FUNC_ENTITYALIDADE_GENERATESPHERINDERHOLLOW (base + idaOffsetFix(0x1F660))
-#define FUNC_ENTITYALIDADE_GENERATESEMICIRCLE (base + idaOffsetFix(0x21D90))
-
-// EntityItem
-
-#define FUNC_ENTITYITEM_CREATEWITHITEM (base + idaOffsetFix(0x9B8E0))
-#define FUNC_ENTITYITEM_GETNAME (base + idaOffsetFix(0x9BA90))
-#define FUNC_ENTITYITEM_UPDATE (base + idaOffsetFix(0x9BAD0))
-#define FUNC_ENTITYITEM_RENDER (base + idaOffsetFix(0x9BDC0))
-#define FUNC_ENTITYITEM_SAVEATTRIBUTES (base + idaOffsetFix(0x9C700))
-#define FUNC_ENTITYITEM_APPLYSERVERUPDATE (base + idaOffsetFix(0x9C960))
-#define FUNC_ENTITYITEM_GETPOS (base + idaOffsetFix(0x9C9D0))
-#define FUNC_ENTITYITEM_SETPOS (base + idaOffsetFix(0x9C9E0))
-#define FUNC_ENTITYITEM_SHOULDSAVE (base + idaOffsetFix(0x9C9F0))
-#define FUNC_ENTITYITEM_ISINTERSECTINGRAY (base + idaOffsetFix(0x9CA00))
-#define FUNC_ENTITYITEM_GIVE (base + idaOffsetFix(0x9CA10))
-#define FUNC_ENTITYITEM_COMBINEWITHNEARBY (base + idaOffsetFix(0x9CC40))
-#define FUNC_ENTITYITEM_COLLISIONCALLBACK (base + idaOffsetFix(0x9CF30))
-
-// EntityPlayer
-
-#define FUNC_ENTITYPLAYER_CREATEFROMPLAYER (base + idaOffsetFix(0xC11F0))
-#define FUNC_ENTITYPLAYER_ENTITYPLAYER (base + idaOffsetFix(0xC1370))
-#define FUNC_ENTITYPLAYER_GETNAME (base + idaOffsetFix(0xC1580))
-#define FUNC_ENTITYPLAYER_UPDATE (base + idaOffsetFix(0xC15C0))
-#define FUNC_ENTITYPLAYER_RENDER (base + idaOffsetFix(0xC2010))
-#define FUNC_ENTITYPLAYER_SAVEATTRIBUTES (base + idaOffsetFix(0xC2900))
-#define FUNC_ENTITYPLAYER_APPLYSERVERUPDATE (base + idaOffsetFix(0xC2DB0))
-#define FUNC_ENTITYPLAYER_GETPOS (base + idaOffsetFix(0xC2E90))
-#define FUNC_ENTITYPLAYER_SETPOS (base + idaOffsetFix(0xC2EA0))
-#define FUNC_ENTITYPLAYER_ISINTERSECTINGRAY (base + idaOffsetFix(0xC2EF0))
-#define FUNC_ENTITYPLAYER_TAKEDAMAGE (base + idaOffsetFix(0xC31D0))
-#define FUNC_ENTITYPLAYER_DEATHTIMER (base + idaOffsetFix(0xC3250))
-#define FUNC_ENTITYPLAYER_APPLYMOVEMENTUPDATE (base + idaOffsetFix(0xC3270))
-#define FUNC_ENTITYPLAYER_COLLECTITEMS (base + idaOffsetFix(0xC3690))
-
-// EntitySpider::SpiderType
-
-#define FUNC_ENTITYSPIDER_SPIDERTYPE_DESTR_SPIDERTYPE (base + idaOffsetFix(0xCF4F0))
-
-// EntitySpider
-
-#define FUNC_ENTITYSPIDER_ISINTERSECTINGRAY (base + idaOffsetFix(0x1DBA0))
-#define FUNC_ENTITYSPIDER_GETPOS (base + idaOffsetFix(0x2A210))
-#define FUNC_ENTITYSPIDER_SETPOS (base + idaOffsetFix(0x2A220))
-#define FUNC_ENTITYSPIDER_GETNAME (base + idaOffsetFix(0xCF580))
-#define FUNC_ENTITYSPIDER_UPDATE (base + idaOffsetFix(0xCF5C0))
-#define FUNC_ENTITYSPIDER_RENDER (base + idaOffsetFix(0xCFF30))
-#define FUNC_ENTITYSPIDER_SAVEATTRIBUTES (base + idaOffsetFix(0xD1E40))
-#define FUNC_ENTITYSPIDER_GETSERVERUPDATEATTRIBUTES (base + idaOffsetFix(0xD1F90))
-#define FUNC_ENTITYSPIDER_APPLYSERVERUPDATE (base + idaOffsetFix(0xD24D0))
-#define FUNC_ENTITYSPIDER_TAKEDAMAGE (base + idaOffsetFix(0xD28E0))
-#define FUNC_ENTITYSPIDER_PLAYHITSOUND (base + idaOffsetFix(0xD2D70))
-#define FUNC_ENTITYSPIDER_PLAYDEATHSOUND (base + idaOffsetFix(0xD2E60))
-#define FUNC_ENTITYSPIDER_COLLISIONCALLBACK (base + idaOffsetFix(0xD2FA0))
-#define FUNC_ENTITYSPIDER_FINDPLAYER (base + idaOffsetFix(0xD2FC0))
-#define FUNC_ENTITYSPIDER_PERSUEPLAYER (base + idaOffsetFix(0xD3340))
-
-// EntityChest
-
-#define FUNC_ENTITYCHEST_ISCLICKABLE (base + idaOffsetFix(0x1DB90))
-#define FUNC_ENTITYCHEST_GETNAME (base + idaOffsetFix(0x2BB80))
-#define FUNC_ENTITYCHEST_UPDATE (base + idaOffsetFix(0x2BBC0))
-#define FUNC_ENTITYCHEST_RENDER (base + idaOffsetFix(0x2BE40))
-#define FUNC_ENTITYCHEST_SAVEATTRIBUTES (base + idaOffsetFix(0x2C470))
-#define FUNC_ENTITYCHEST_GETSERVERUPDATEATTRIBUTES (base + idaOffsetFix(0x2C4F0))
-#define FUNC_ENTITYCHEST_APPLYSERVERUPDATE (base + idaOffsetFix(0x2C710))
-#define FUNC_ENTITYCHEST_GETPOS (base + idaOffsetFix(0x2C740))
-#define FUNC_ENTITYCHEST_SETPOS (base + idaOffsetFix(0x2C750))
-#define FUNC_ENTITYCHEST_ACTION (base + idaOffsetFix(0x2C760))
-
-// EntityDying
-
-#define FUNC_ENTITYDYING_DEATHTIMER (base + idaOffsetFix(0x1DCD0))
-#define FUNC_ENTITYDYING_CREATEWITHENTITY (base + idaOffsetFix(0x266A0))
-#define FUNC_ENTITYDYING_GETNAME (base + idaOffsetFix(0x26840))
-#define FUNC_ENTITYDYING_UPDATE (base + idaOffsetFix(0x26880))
-#define FUNC_ENTITYDYING_RENDER (base + idaOffsetFix(0x268E0))
-#define FUNC_ENTITYDYING_GETSERVERUPDATEATTRIBUTES (base + idaOffsetFix(0x268F0))
-#define FUNC_ENTITYDYING_APPLYSERVERUPDATE (base + idaOffsetFix(0x26910))
-#define FUNC_ENTITYDYING_GETPOS (base + idaOffsetFix(0x26920))
-#define FUNC_ENTITYDYING_SETPOS (base + idaOffsetFix(0x26940))
-#define FUNC_ENTITYDYING_ISBLOCKENTITY (base + idaOffsetFix(0x26950))
-#define FUNC_ENTITYDYING_ISINTERSECTINGRAY (base + idaOffsetFix(0x26960))
-
-// EntityManager
-
-#define FUNC_ENTITYMANAGER_EXTRACT (base + idaOffsetFix(0x2D740))
-#define FUNC_ENTITYMANAGER_GET (base + idaOffsetFix(0x78360))
-#define FUNC_ENTITYMANAGER_GETBLOCKENTITY (base + idaOffsetFix(0xF6A30))
-
-// Coil
-
-#define FUNC_COIL_COIL (base + idaOffsetFix(0x49330))
-#define FUNC_COIL_BUFFSIZE (base + idaOffsetFix(0x4AA00))
-#define FUNC_COIL_ATTRSIZE (base + idaOffsetFix(0x4AA20))
-
-// CompassRenderer
-
-#define FUNC_COMPASSRENDERER_RENDERHAND (base + idaOffsetFix(0x4B7C0))
-#define FUNC_COMPASSRENDERER_RENDERITEMDROP (base + idaOffsetFix(0x4D9C0))
-
-// DodecaplexWireframe
-
-#define FUNC_DODECAPLEXWIREFRAME_GENERATEMESH (base + idaOffsetFix(0x75260))
-#define FUNC_DODECAPLEXWIREFRAME_ADDFACES (base + idaOffsetFix(0x75B80))
-#define FUNC_DODECAPLEXWIREFRAME_ADDCELLS (base + idaOffsetFix(0x765D0))
-
-// Framebuffer
-
-#define FUNC_FRAMEBUFFER_DESTR_FRAMEBUFFER (base + idaOffsetFix(0x7BBE0))
-#define FUNC_FRAMEBUFFER_RENDER (base + idaOffsetFix(0x7BC70))
-#define FUNC_FRAMEBUFFER_INIT (base + idaOffsetFix(0x7BD80))
-#define FUNC_FRAMEBUFFER_CLEANUP (base + idaOffsetFix(0x7BFA0))
-
-// HypercubeHollow
-
-#define FUNC_HYPERCUBEHOLLOW_ATTRSIZE (base + idaOffsetFix(0xCB9A0))
-#define FUNC_HYPERCUBEHOLLOW_ATTRSTRIDE (base + idaOffsetFix(0xCB9B0))
-#define FUNC_HYPERCUBEHOLLOW_HYPERCUBEHOLLOW (base + idaOffsetFix(0xCBEB0))
-#define FUNC_HYPERCUBEHOLLOW_ADDCUBESIDE (base + idaOffsetFix(0xCC240))
-
-// PlayerSkinRenderer
-
-#define FUNC_PLAYERSKINRENDERER_PLAYERSKINRENDERER (base + idaOffsetFix(0x5F4F0))
-#define FUNC_PLAYERSKINRENDERER_RENDER (base + idaOffsetFix(0x5F6D0))
-#define FUNC_PLAYERSKINRENDERER_UPDATEANIMATION (base + idaOffsetFix(0x62480))
-#define FUNC_PLAYERSKINRENDERER_RESETTRANSFORMATIONS (base + idaOffsetFix(0x68F40))
-
-// PlayerSkinViewer
-
-#define FUNC_PLAYERSKINVIEWER_RENDER (base + idaOffsetFix(0x69420))
-#define FUNC_PLAYERSKINVIEWER_ALIGNX (base + idaOffsetFix(0x69D60))
-#define FUNC_PLAYERSKINVIEWER_ALIGNY (base + idaOffsetFix(0x69D70))
-#define FUNC_PLAYERSKINVIEWER_GETPOS (base + idaOffsetFix(0x69DA0))
-#define FUNC_PLAYERSKINVIEWER_GETSIZE (base + idaOffsetFix(0x69E50))
-#define FUNC_PLAYERSKINVIEWER_MOUSEINPUT (base + idaOffsetFix(0x69E60))
-#define FUNC_PLAYERSKINVIEWER_GETCURSORTYPE (base + idaOffsetFix(0x69F10))
-#define FUNC_PLAYERSKINVIEWER_INIT (base + idaOffsetFix(0x69F20))
-#define FUNC_PLAYERSKINVIEWER_SETUPFRAMEBUFFER (base + idaOffsetFix(0x6A070))
-
-// Sphere
-
-#define FUNC_SPHERE_VERTCOUNT (base + idaOffsetFix(0x4AA30))
-#define FUNC_SPHERE_BUFFSIZE (base + idaOffsetFix(0x92F20))
-#define FUNC_SPHERE_SPHERE (base + idaOffsetFix(0x92F60))
-#define FUNC_SPHERE_GENERATECIRCLEPOLYGONS (base + idaOffsetFix(0x93FE0))
-
diff --git a/4dm.h/hook.h b/4dm.h/hook.h
index 3a9b26a..96e4f75 100644
--- a/4dm.h/hook.h
+++ b/4dm.h/hook.h
@@ -6,19 +6,23 @@
 
 // 4DModLoader-Core hooking stuff for multihooking yea
 
-inline void Hook(LPVOID target, LPVOID detour, LPVOID* original)
-{
+inline void __stdcall Hook(LPVOID target, LPVOID detour, LPVOID* original) {
 	reinterpret_cast<void(__stdcall*)(LPVOID target, LPVOID detour, LPVOID * original)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "Hook"))(target, detour, original);
 }
+
 template<typename FuncPtr> inline void Hook( unsigned long long target, FuncPtr detour, FuncPtr* original ) {
-	static_assert( std::is_function<typename std::remove_pointer<FuncPtr>::type>::value, "Hook must be called with a function and a pointer to a function of identical signature");
+	static_assert(
+		std::is_function<typename std::remove_pointer<FuncPtr>::type>::value,
+		"Hook must be called with a function and a pointer to a function of identical signature"
+	);
 	Hook( reinterpret_cast<LPVOID>(target), reinterpret_cast<LPVOID>(detour), reinterpret_cast<LPVOID*>(original) );
 }
 
-// if target is NULL (0), enables every hook.
-inline void EnableHook(LPVOID target)
-{
+inline void __stdcall EnableHook(LPVOID target){ // enables specific hook.
 	reinterpret_cast<void(__stdcall*)(LPVOID target)>(GetProcAddress(GetModuleHandleA("4DModLoader-Core.dll"), "EnableHook"))(target);
 }
+inline void EnableHook(){ // enables every hook.
+	EnableHook(nullptr);
+}
 
 #endif // !HOOK_H
diff --git a/4dm.h/m4.h b/4dm.h/m4.h
index 9c512b9..5ebcb21 100644
--- a/4dm.h/m4.h
+++ b/4dm.h/m4.h
@@ -20,21 +20,21 @@ namespace fdm
 			BiVector4(const nlohmann::json& j)
 			{
 				reinterpret_cast<void(__thiscall*)(BiVector4*, const nlohmann::json & j)>(
-					FUNC_M4_BIVECTOR4_BIVECTOR4_A
+					getFuncAddr((int)Func::m4_Nested::BiVector4::BiVector4A)
 					)(this, j);
 			}
 
 			nlohmann::json toJson()
 			{
 				nlohmann::json result{};
-				return reinterpret_cast<nlohmann::json(__thiscall*)(m4::BiVector4 * self, nlohmann::json * result)>(FUNC_M4_BIVECTOR4_TOJSON)(this, &result);
+				return reinterpret_cast<nlohmann::json&(__thiscall*)(m4::BiVector4 * self, nlohmann::json * result)>(getFuncAddr((int)Func::m4_Nested::BiVector4::toJson))(this, &result);
 				return result;
 			}
 
 			void normalize()
 			{
 				return reinterpret_cast<void(__thiscall*)(BiVector4*)>(
-					FUNC_M4_BIVECTOR4_NORMALIZE
+					getFuncAddr((int)Func::m4_Nested::BiVector4::normalize)
 					)(this);
 			}
 
@@ -47,9 +47,9 @@ namespace fdm
 		};
 		inline glm::vec4 cross(const glm::vec4& u, const glm::vec4& v, const glm::vec4& w)
 		{
-			glm::vec4 result(0.0f);
+			glm::vec4 result{};
 			return reinterpret_cast<glm::vec4& (__fastcall*)(glm::vec4*, const glm::vec4&, const glm::vec4&, const glm::vec4&)>(
-				FUNC_M4_CROSS
+				getFuncAddr((int)Func::m4::cross)
 				)(&result, u, v, w);
 			return result;
 		}
@@ -75,36 +75,27 @@ namespace fdm
 			Rotor(const BiVector4& plane, float radians)
 			{
 				reinterpret_cast<void(__thiscall*)(Rotor*, const BiVector4&, float)>(
-					FUNC_M4_ROTOR_ROTOR_A
+					getFuncAddr((int)Func::m4_Nested::Rotor::RotorA)
 					)(this, plane, radians);
 			}
 			Rotor(const glm::vec4& from, const glm::vec4& to)
 			{
 				reinterpret_cast<void(__thiscall*)(Rotor*, const glm::vec4 & from, const glm::vec4 & to)>(
-					FUNC_M4_ROTOR_ROTOR
+					getFuncAddr((int)Func::m4_Nested::Rotor::Rotor)
 					)(this, from, to);
 			}
 			Rotor& operator*=(const Rotor& r)
 			{
 				reinterpret_cast<void(__thiscall*)(Rotor*, const Rotor&)>(
-					FUNC_M4_ROTOR_OPERATORMULTEQ
+					getFuncAddr((int)Func::m4_Nested::Rotor::operatorMultEq)
 					)(this, r);
 				return *this;
 			}
-			glm::vec4 rotate(const glm::vec4& v)
-			{
-				glm::vec4 result{};
-				return reinterpret_cast<glm::vec4(__thiscall*)(Rotor*, glm::vec4*, const glm::vec4&)>(
-					FUNC_M4_ROTOR_ROTATE
-					)(this, &result, v);
-
-				return result;
-			}
 			glm::vec4 rotate(const glm::vec4& v) const
 			{
 				glm::vec4 result{};
-				return reinterpret_cast<glm::vec4(__thiscall*)(const Rotor*, glm::vec4*, const glm::vec4&)>(
-					FUNC_M4_ROTOR_ROTATE
+				return reinterpret_cast<glm::vec4&(__thiscall*)(const Rotor*, glm::vec4*, const glm::vec4&)>(
+					getFuncAddr((int)Func::m4_Nested::Rotor::rotate)
 					)(this, &result, v);
 
 				return result;
@@ -112,54 +103,80 @@ namespace fdm
 			void normalize()
 			{
 				return reinterpret_cast<void(__thiscall*)(Rotor*)>(
-					FUNC_M4_ROTOR_NORMALIZE
+					getFuncAddr((int)Func::m4_Nested::Rotor::normalize)
 					)(this);
 			}
 		};
 		class Mat5
 		{
 		public:
-			float value[5][5];
+			float value[5][5] = { 0.f };
 			// 0.0
 			Mat5()
 			{
 				reinterpret_cast<void(__thiscall*)(Mat5*, float)>(
-					FUNC_M4_MAT5_MAT5
+					getFuncAddr((int)Func::m4_Nested::Mat5::Mat5)
 					)(this, 0.0);
 			}
 			Mat5(float x)
 			{
 				reinterpret_cast<void(__thiscall*)(Mat5*, float)>(
-					FUNC_M4_MAT5_MAT5
+					getFuncAddr((int)Func::m4_Nested::Mat5::Mat5)
 					)(this, x);
 			}
 			Mat5(nlohmann::json& j)
 			{
 				reinterpret_cast<void(__thiscall*)(Mat5*, nlohmann::json&)>(
-					FUNC_M4_MAT5_MAT5_A
+					getFuncAddr((int)Func::m4_Nested::Mat5::Mat5A)
 					)(this, j);
 			}
+			Mat5(const Rotor& rotor)
+			{
+				glm::vec4 x = rotor.rotate({ 1, 0, 0, 0 });
+				value[0][0] = x[0];
+				value[0][1] = x[1];
+				value[0][2] = x[2];
+				value[0][3] = x[3];
+				glm::vec4 y = rotor.rotate({ 0, 1, 0, 0 });
+				value[1][0] = y[0];
+				value[1][1] = y[1];
+				value[1][2] = y[2];
+				value[1][3] = y[3];
+				glm::vec4 z = rotor.rotate({ 0, 0, 1, 0 });
+				value[2][0] = z[0];
+				value[2][1] = z[1];
+				value[2][2] = z[2];
+				value[2][3] = z[3];
+				glm::vec4 w = rotor.rotate({ 0, 0, 0, 1 });
+				value[3][0] = w[0];
+				value[3][1] = w[1];
+				value[3][2] = w[2];
+				value[3][3] = w[3];
+
+				value[4][4] = 1.0;
+			}
 			nlohmann::json toJson()
 			{
 				nlohmann::json result{};
-				return reinterpret_cast<nlohmann::json(__thiscall*)(m4::Mat5* self, nlohmann::json* result)>(FUNC_M4_MAT5_TOJSON)(this, &result);
+				return reinterpret_cast<nlohmann::json&(__thiscall*)(m4::Mat5* self, nlohmann::json* result)>(getFuncAddr((int)Func::m4_Nested::Mat5::toJson))(this, &result);
 				return result;
 			}
 			inline static Mat5 identity()
 			{
 				return { 1 };
 			}
-			Mat5 operator*(const Mat5& other) const
+			Mat5& operator*(const Mat5& other) const
 			{
-				Mat5 result{ 1 };
+				Mat5 result;
 
-				for (int i = 0; i < 5; i++)
+				for (int col = 0; col < 5; ++col)
 				{
-					for (int j = 0; j < 5; j++)
+					for (int row = 0; row < 5; ++row)
 					{
-						result[i][j] = 0.f;
-						for (int k = 0; k < 5; k++)
-							result[i][j] += this->value[i][k] * other.value[k][j];
+						for (int k = 0; k < 5; ++k)
+						{
+							result.value[col][row] += value[k][row] * other.value[col][k];
+						}
 					}
 				}
 
@@ -176,8 +193,8 @@ namespace fdm
 			glm::vec4 multiply(const glm::vec4& v, float finalComp)
 			{
 				glm::vec4 result{};
-				return reinterpret_cast<glm::vec4(__thiscall*)(Mat5*, glm::vec4*, const glm::vec4&, float)>(
-					FUNC_M4_MAT5_MULTIPLY
+				return reinterpret_cast<glm::vec4&(__thiscall*)(Mat5*, glm::vec4*, const glm::vec4&, float)>(
+					getFuncAddr((int)Func::m4_Nested::Mat5::multiply)
 					)(this, &result, v, finalComp);
 				return result;
 			}
@@ -188,13 +205,13 @@ namespace fdm
 			void translate(const glm::vec4& v)
 			{
 				return reinterpret_cast<void(__thiscall*)(Mat5*, const glm::vec4&)>(
-					FUNC_M4_MAT5_TRANSLATE
+					getFuncAddr((int)Func::m4_Nested::Mat5::translate)
 					)(this, v);
 			}
 			void scale(const glm::vec4& s)
 			{
 				return reinterpret_cast<void(__thiscall*)(Mat5*, const glm::vec4&)>(
-					FUNC_M4_MAT5_SCALE
+					getFuncAddr((int)Func::m4_Nested::Mat5::scale)
 					)(this, s);
 			}
 
@@ -274,22 +291,29 @@ namespace fdm
 				return s;
 			}
 		};
-		inline Mat5 createCamera(const glm::vec4& eye, const glm::vec4& forward, const glm::vec4& up, const glm::vec4& left, const glm::vec4& over)
+		inline Mat5 createCamera(const glm::vec4& eye, const glm::vec4& forward, const glm::vec4& up, const glm::vec4& right, const glm::vec4& over)
 		{
+			Mat5 result;
+
+			return reinterpret_cast<Mat5 & (__fastcall*)(Mat5*, const glm::vec4 & eye, const glm::vec4 & forward, const glm::vec4 & up, const glm::vec4 & right, const glm::vec4 & over)>(
+				getFuncAddr((int)Func::m4::createCamera)
+				)(&result, eye, forward, up, right, over);
+			return result;
+			/*
 			Mat5 cameraD{ 1 };
 
-			cameraD[0][0] = left.x;
-			cameraD[1][0] = left.y;
-			cameraD[2][0] = left.z;
-			cameraD[3][0] = left.w;
+			cameraD[0][0] = right.x;
+			cameraD[1][0] = right.y;
+			cameraD[2][0] = right.z;
+			cameraD[3][0] = right.w;
 			cameraD[0][1] = up.x;
 			cameraD[1][1] = up.y;
 			cameraD[2][1] = up.z;
 			cameraD[3][1] = up.w;
-			cameraD[0][2] = forward.x;
-			cameraD[1][2] = forward.y;
-			cameraD[2][2] = forward.z;
-			cameraD[3][2] = forward.w;
+			cameraD[0][2] = -forward.x;
+			cameraD[1][2] = -forward.y;
+			cameraD[2][2] = -forward.z;
+			cameraD[3][2] = -forward.w;
 			cameraD[0][3] = over.x;
 			cameraD[1][3] = over.y;
 			cameraD[2][3] = over.z;
@@ -301,22 +325,23 @@ namespace fdm
 			cameraP[4][2] = -eye.z;
 			cameraP[4][3] = -eye.w;
 
-			return cameraD * cameraP;
+			return cameraD * cameraP;*/
 		}
 		inline glm::vec4 adjustToMaxHorizSpeed(const glm::vec4& vel, const glm::vec4& deltaVel, float maxHorizSpeed)
 		{
+			glm::vec4 result;
 			return reinterpret_cast<glm::vec4 & (__fastcall*)(glm::vec4*, const glm::vec4&, const glm::vec4&, float)>(
-				FUNC_M4_ADJUSTTOMAXHORIZSPEED
-				)(nullptr, vel, deltaVel, maxHorizSpeed);
+				getFuncAddr((int)Func::m4::adjustToMaxHorizSpeed)
+				)(&result, vel, deltaVel, maxHorizSpeed);
 		}
 
 		inline nlohmann::json i64vec3ToJson(const glm::i64vec3& vec)
 		{
-			return reinterpret_cast<nlohmann::json(__fastcall*)(const glm::i64vec3 & vec)>(FUNC_M4_I64VEC3TOJSON)(vec);
+			return reinterpret_cast<nlohmann::json(__fastcall*)(const glm::i64vec3 & vec)>(getFuncAddr((int)Func::m4::i64vec3ToJson))(vec);
 		}
 		inline nlohmann::json ivec4ToJson(const glm::ivec4& vec)
 		{
-			return reinterpret_cast<nlohmann::json(__fastcall*)(const glm::ivec4 & vec)>(FUNC_M4_IVEC4TOJSON)(vec);
+			return reinterpret_cast<nlohmann::json(__fastcall*)(const glm::ivec4 & vec)>(getFuncAddr((int)Func::m4::ivec4ToJson))(vec);
 		}
 		//inline glm::ivec4 ivec4FromJson(const nlohmann::json& j)
 		//{
@@ -324,11 +349,11 @@ namespace fdm
 		//}
 		inline nlohmann::json vec4ToJson(const glm::vec4& vec)
 		{
-			return reinterpret_cast<nlohmann::json(__fastcall*)(const glm::vec4 & vec)>(FUNC_M4_VEC4TOJSON)(vec);
+			return reinterpret_cast<nlohmann::json(__fastcall*)(const glm::vec4 & vec)>(getFuncAddr((int)Func::m4::vec4ToJson))(vec);
 		}
 		inline glm::vec4 vec4FromJson(const nlohmann::json& j)
 		{
-			return reinterpret_cast<glm::vec4(__fastcall*)(const nlohmann::json & j)>(FUNC_M4_VEC4FROMJSON)(j);
+			return reinterpret_cast<glm::vec4(__fastcall*)(const nlohmann::json & j)>(getFuncAddr((int)Func::m4::vec4FromJson))(j);
 		}
 
 		inline void printMat5(const Mat5& m)
@@ -341,4 +366,4 @@ namespace fdm
 				m[4][0], m[4][1], m[4][2], m[4][3], m[4][4]);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/4dm.h/msvc_string.h b/4dm.h/msvc_string.h
index 3172aff..5d8a4b4 100644
--- a/4dm.h/msvc_string.h
+++ b/4dm.h/msvc_string.h
@@ -1,76 +1,178 @@
 
+#define StringCastable(Type) template<typename Type, typename =std::enable_if_t<std::is_constructible<std::string,Type>::value > >
+
 class msvc_string {
-// public:
-	char _content[0x10]; // this could contain a pointer
-	uint64_t _length;  // 0x10
-	uint64_t _maxlength;  // 0x18
+	char _content[0x10] = "\0"; // this could contain a pointer
+	uint64_t _length = 0;  // 0x10
+	uint64_t _maxlength = 0x10-1;  // 0x18
 	
-	bool isSSO(){
+public:
+	constexpr bool isSSO() const {
 		return this->_maxlength < 0x10;
 	}
-	char* read() {
-		if ( this->isSSO() )
+	constexpr char* data() {
+		if (this->isSSO())
 			return this->_content;
 		return *reinterpret_cast<char**>(this->_content);
 	}
-	msvc_string write( const char* str, uint64_t length ) {
+	constexpr const char* data() const {
+		if (this->isSSO())
+			return this->_content;
+		return *reinterpret_cast<char*const*>(this->_content);
+	}
+	constexpr uint64_t max_size() const { return 0x7fffffffffffffff; }
+	constexpr uint64_t   length() const { return this->_length; }
+	constexpr uint64_t     size() const { return this->length(); }
+	constexpr uint64_t capacity() const { return this->_maxlength; }
+	[[nodiscard]] constexpr bool empty() const {
+		return this->length();
+	}
+private:
+	constexpr void resize(uint64_t new_maxlength, bool copy = true){
+		
+		auto newAlloc = ( new_maxlength/0x10 + 1 )*0x10;  // allocate up to next 0x10
+		
+		if (newAlloc == (this->_maxlength+1))
+			return;
+		
+		char* oldstr = this->data();
+		char* newstr;
+		if (newAlloc <= 0x10)
+			newstr = this->_content;
+		else
+			newstr = new char[newAlloc];
+		
+		if (oldstr == newstr)
+			return;
+		
+		if (copy)
+			memcpy(newstr,oldstr,this->length()+1);
+		
+		if (!this->isSSO())
+			delete[] oldstr;
 		
-		uint64_t actualLength = length + 1;  // including NULL terminator
+		this->_maxlength = newAlloc - 1;
+		if (newAlloc > 0x10)
+			*reinterpret_cast<char**>(this->_content) = newstr;
+	}
+	constexpr void write( const char* str, uint64_t length ) {
 		
-		if ( length > this->_maxlength ) {
-			if (!this->isSSO())
-				delete[] this->data();
-			
-			uint64_t newAlloc = ( (actualLength-1)/0x10 + 1 )*0x10;  // allocate up to next 0x10
-			
-			this->_maxlength = newAlloc - 1;
-			*reinterpret_cast<char**>(this->_content) = new char[newAlloc];
-		}
+		if ( length > this->capacity() )
+			resize(length,false);
 		
 		this->_length = length;
 		memcpy(this->data(),str,length);
-		this->data()[actualLength] = NULL;
-		
-		return *this;
+		this->data()[length] = NULL;
 	}
 	
 public:
-	uint64_t length() {
-		return this->_length;
-	}
-	char* data() {
-		return this->read();
-	}
-	const char* c_str() {
+	const char* c_str() const {
 		return this->data();
 	}
-	char& operator[](uint64_t index) {
+	constexpr char& operator[](uint64_t index) {
 		return this->data()[index];
 	}
-	
-	operator std::string() {
-		return std::string(this->data());
+	constexpr const char& operator[](uint64_t index) const {
+		return this->data()[index];
+	}
+	template<typename... Args> auto at(Args&&... args) const {
+		return std::string(*this).at(args...);
+	}
+	template<typename... Args> constexpr msvc_string& assign(Args&&... args){
+		return *this = std::string(*this).assign(args...);
+	}
+	constexpr void reserve(uint64_t new_cap){
+		if (new_cap <= this->capacity())
+			return;
+		this->resize(new_cap);
+	}
+	constexpr void shrink_to_fit(){
+		this->resize(this->length());
 	}
+	constexpr void clear(){
+		*this = "";
+	}
+	template<typename... Args> constexpr msvc_string& operator+=(Args&&... args){
+		return *this = std::string(*this).operator+=(args...);
+	}
+	
 	
-	msvc_string operator=(msvc_string str) {
-		return this->write(str.data(),str.length());
+	constexpr operator std::string() const {
+		return *new std::string(this->data());
 	}
-	msvc_string operator=(const char* str) {
-		return this->write(str,strlen(str));
+	constexpr ~msvc_string(){
+		if (!this->isSSO())
+			delete[] this->data();
 	}
-	msvc_string operator=(std::string str) {
-		return this->write(str.c_str(),str.length());
+	constexpr msvc_string(){}
+	constexpr msvc_string(const msvc_string& str) {
+		this->write(str.data(),str.length());
 	}
-	msvc_string* operator=(auto arg) {
-		static_assert(false,"assignment with this type of argument not yet implemented");
+	constexpr msvc_string(const std::string str) {
+		this->write(str.data(),str.length());
+	}
+	// cast all other stuff to std::string, let it do the main work
+	StringCastable(String) constexpr msvc_string(const String& rawstr){
+		std::string str = rawstr;
+		this->write(str.data(),str.length());
 	}
 	
-	bool operator==(std::string str) {
-		return str == std::string(*this);
+	constexpr msvc_string& operator=(const msvc_string& str){
+		this->write(str.data(),str.length());
+		return *this;
 	}
 };
 
-std::ostream& operator<<(std::ostream& os, msvc_string str) {
-	os << str.data();
-	return os;
+// we are gonna use a bunch of constexpr which may or may not actually compile to constexpr, so we supress the warnings about that
+// we could duplicate all the functions and do it properly, but ¯\_(ツ)_/¯
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winvalid-constexpr"
+
+constexpr auto operator+(const msvc_string& str1, const msvc_string& str2){
+	return (std::string) str1 + (std::string) str2;
+}
+StringCastable(String) constexpr auto operator+(const msvc_string& str1, const String str2){
+	return (std::string) str1 + (std::string) str2;
+}
+StringCastable(String) constexpr auto operator+(const String str1, const msvc_string& str2){
+	return (std::string) str1 + (std::string) str2;
+}
+
+constexpr auto operator==(const msvc_string& str1, const msvc_string& str2){
+	return (std::string) str1 == (std::string) str2;
+}
+StringCastable(String) constexpr auto operator==(const msvc_string& str1, const String str2){
+	return (std::string) str1 == (std::string) str2;
+}
+StringCastable(String) constexpr auto operator==(const String str1, const msvc_string& str2){
+	return (std::string) str1 == (std::string) str2;
+}
+
+constexpr auto operator<=>(const msvc_string& str1, const msvc_string& str2){
+	return (std::string) str1 <=> (std::string) str2;
 }
+StringCastable(String) constexpr auto operator<=>(const msvc_string& str1, const String str2){
+	return (std::string) str1 <=> (std::string) str2;
+}
+StringCastable(String) constexpr auto operator<=>(const String str1, const msvc_string& str2){
+	return (std::string) str1 <=> (std::string) str2;
+}
+
+#pragma GCC diagnostic pop
+
+std::ostream& operator<<( std::ostream& os, const msvc_string& str ){
+	return os << str.data();
+}
+
+std::istream& operator>>( std::istream& is, msvc_string& str ){
+	std::string capture;
+	is >> capture;
+	str = capture;
+	return is;
+}
+
+template<> struct std::hash<msvc_string> {
+    auto operator()(msvc_string const& s) const noexcept {
+        return std::hash<std::string>{}(s);
+    }
+};
\ No newline at end of file
diff --git a/4dm.h/path.h b/4dm.h/path.h
index 860bb8c..ddc6857 100644
--- a/4dm.h/path.h
+++ b/4dm.h/path.h
@@ -1,29 +1,42 @@
 #pragma once
 
 #include "4dm.h"
+
 namespace fdm
 {
     class path
     {
     public:
-        std::string pathName;
+        std::wstring pathName;
         path()
         {
-            pathName = "";
+            pathName = L"";
         }
         path(const path& src)
         {
             pathName = src.pathName;
         }
-        path(const char* src)
+        path(const std::string& src)
         {
-            pathName = std::string(src);
+            pathName = std::wstring(src.begin(), src.end());
         }
-        const std::string string(void)
+        path(const std::wstring& src)
+        {
+            pathName = src;
+        }
+        const std::wstring wstring(void)
         {
             return pathName;
         }
+        const std::string string(void)
+        {
+            return std::string(pathName.begin(), pathName.end());
+        }
         const char* c_str(void)
+        {
+            return string().c_str();
+        }
+        const wchar_t* c_wstr(void)
         {
             return pathName.c_str();
         }
diff --git a/4dm.h/soil/SOIL.lib b/4dm.h/soil/SOIL.lib
deleted file mode 100644
index a5b43c0..0000000
Binary files a/4dm.h/soil/SOIL.lib and /dev/null differ
diff --git a/4dm.h/soil/SOIL.c b/4dm.h/soil/SOIL2.c
similarity index 54%
rename from 4dm.h/soil/SOIL.c
rename to 4dm.h/soil/SOIL2.c
index 1ee4daf..543b011 100644
--- a/4dm.h/soil/SOIL.c
+++ b/4dm.h/soil/SOIL2.c
@@ -1,8 +1,11 @@
 /*
+ 	Fork by Martin Lucas Golini
+ 	 
+ 	Original author
 	Jonathan Dummer
 	2007-07-26-10.36
 
-	Simple OpenGL Image Library
+	Simple OpenGL Image Library 2
 
 	Public Domain
 	using Sean Barret's stb_image as a base
@@ -15,7 +18,56 @@
 
 #define SOIL_CHECK_FOR_GL_ERRORS 0
 
-#ifdef WIN32
+#if defined( __APPLE_CC__ ) || defined ( __APPLE__ )
+	#include <TargetConditionals.h>
+
+	#if defined( __IPHONE__ ) || ( defined( TARGET_OS_IPHONE ) && TARGET_OS_IPHONE ) || ( defined( TARGET_IPHONE_SIMULATOR ) && TARGET_IPHONE_SIMULATOR )
+		#define SOIL_PLATFORM_IOS
+		#include <dlfcn.h>
+	#else
+		#define SOIL_PLATFORM_OSX
+	#endif
+#elif defined( __ANDROID__ ) || defined( ANDROID )
+	#define SOIL_PLATFORM_ANDROID
+#elif ( defined ( linux ) || defined( __linux__ ) || defined( __FreeBSD__ ) || defined(__OpenBSD__) || defined( __NetBSD__ ) || defined( __DragonFly__ ) || defined( __SVR4 ) )
+	#define SOIL_X11_PLATFORM
+#endif
+
+#if ( defined( SOIL_PLATFORM_IOS ) || defined( SOIL_PLATFORM_ANDROID ) ) && ( !defined( SOIL_GLES1 ) && !defined( SOIL_GLES2 ) )
+	#define SOIL_GLES2
+#endif
+
+#if ( defined( SOIL_GLES2 ) || defined( SOIL_GLES1 ) ) && !defined( SOIL_NO_EGL ) && !defined( SOIL_PLATFORM_IOS )
+	#include <EGL/egl.h>
+#endif
+
+#if defined( SOIL_GLES2 )
+	#ifdef SOIL_PLATFORM_IOS
+		#include <OpenGLES/ES2/gl.h>
+		#include <OpenGLES/ES2/glext.h>
+	#else
+		#include <GLES2/gl2.h>
+		#include <GLES2/gl2ext.h>
+	#endif
+
+	#define APIENTRY GL_APIENTRY
+#elif defined( SOIL_GLES1 )
+	#ifndef GL_GLEXT_PROTOTYPES
+	#define GL_GLEXT_PROTOTYPES
+	#endif
+	#ifdef SOIL_PLATFORM_IOS
+		#include <OpenGLES/ES1/gl.h>
+		#include <OpenGLES/ES1/glext.h>
+	#else
+		#include <GLES/gl.h>
+		#include <GLES/glext.h>
+	#endif
+
+	#define APIENTRY GL_APIENTRY
+#else
+
+#if defined( __WIN32__ ) || defined( _WIN32 ) || defined( WIN32 )
+	#define SOIL_PLATFORM_WIN32
 	#define WIN32_LEAN_AND_MEAN
 	#include <windows.h>
 	#include <wingdi.h>
@@ -25,21 +77,53 @@
 	#include <OpenGL/gl.h>
 	#include <Carbon/Carbon.h>
 	#define APIENTRY
-#else
+#elif defined( SOIL_X11_PLATFORM )
 	#include <GL/gl.h>
 	#include <GL/glx.h>
+#else
+	#include <GL/gl.h>
+#endif
+
 #endif
 
-#include "SOIL.h"
-#include "stb_image_aug.h"
+#ifndef GL_BGRA
+#define GL_BGRA 0x80E1
+#endif
+
+#ifndef GL_RG
+#define GL_RG 0x8227
+#endif
+
+#ifndef GL_UNSIGNED_SHORT_4_4_4_4
+#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
+#endif
+#ifndef GL_UNSIGNED_SHORT_5_5_5_1
+#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
+#endif
+#ifndef GL_UNSIGNED_SHORT_5_6_5
+#define GL_UNSIGNED_SHORT_5_6_5 0x8363
+#endif
+
+#ifndef GL_UNSIGNED_BYTE_3_3_2
+#define GL_UNSIGNED_BYTE_3_3_2 0x8032
+#endif
+
+#include "SOIL2.h"
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
 #include "image_helper.h"
 #include "image_DXT.h"
+#include "pvr_helper.h"
+#include "pkm_helper.h"
+#include "jo_jpeg.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 /*	error reporting	*/
-char *result_string_pointer = "SOIL initialized";
+const char *result_string_pointer = "SOIL initialized";
 
 /*	for loading cube maps	*/
 enum{
@@ -64,6 +148,7 @@ int query_cubemap_capability( void );
 #define SOIL_PROXY_TEXTURE_CUBE_MAP			0x851B
 #define SOIL_MAX_CUBE_MAP_TEXTURE_SIZE		0x851C
 /*	for non-power-of-two texture	*/
+#define SOIL_IS_POW2( v ) ( ( v & ( v - 1 ) ) == 0 )
 static int has_NPOT_capability = SOIL_CAPABILITY_UNKNOWN;
 int query_NPOT_capability( void );
 /*	for texture rectangles	*/
@@ -74,29 +159,237 @@ int query_tex_rectangle_capability( void );
 /*	for using DXT compression	*/
 static int has_DXT_capability = SOIL_CAPABILITY_UNKNOWN;
 int query_DXT_capability( void );
+#define SOIL_GL_SRGB			0x8C40
+#define SOIL_GL_SRGB_ALPHA		0x8C42
 #define SOIL_RGB_S3TC_DXT1		0x83F0
 #define SOIL_RGBA_S3TC_DXT1		0x83F1
 #define SOIL_RGBA_S3TC_DXT3		0x83F2
 #define SOIL_RGBA_S3TC_DXT5		0x83F3
+#define SOIL_GL_COMPRESSED_SRGB_S3TC_DXT1_EXT  0x8C4C
+#define SOIL_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT 0x8C4F
+static int has_sRGB_capability = SOIL_CAPABILITY_UNKNOWN;
+int query_sRGB_capability( void );
 typedef void (APIENTRY * P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data);
-P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC soilGlCompressedTexImage2D = NULL;
-unsigned int SOIL_direct_load_DDS(
-		const char *filename,
-		unsigned int reuse_texture_ID,
-		int flags,
-		int loading_as_cubemap );
-unsigned int SOIL_direct_load_DDS_from_memory(
-		const unsigned char *const buffer,
-		int buffer_length,
-		unsigned int reuse_texture_ID,
-		int flags,
-		int loading_as_cubemap );
+static P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC soilGlCompressedTexImage2D = NULL;
+
+typedef void (APIENTRY *P_SOIL_GLGENERATEMIPMAPPROC)(GLenum target);
+static P_SOIL_GLGENERATEMIPMAPPROC soilGlGenerateMipmap = NULL;
+
+static int has_gen_mipmap_capability = SOIL_CAPABILITY_UNKNOWN;
+static int query_gen_mipmap_capability( void );
+
+static int has_PVR_capability = SOIL_CAPABILITY_UNKNOWN;
+int query_PVR_capability( void );
+static int has_BGRA8888_capability = SOIL_CAPABILITY_UNKNOWN;
+int query_BGRA8888_capability( void );
+static int has_ETC1_capability = SOIL_CAPABILITY_UNKNOWN;
+int query_ETC1_capability( void );
+
+/* GL_IMG_texture_compression_pvrtc */
+#define SOIL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG                      0x8C00
+#define SOIL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG                      0x8C01
+#define SOIL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG                     0x8C02
+#define SOIL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG                     0x8C03
+#define SOIL_GL_ETC1_RGB8_OES                                     0x8D64
+
+#if defined( SOIL_X11_PLATFORM ) || defined( SOIL_PLATFORM_WIN32 ) || defined( SOIL_PLATFORM_OSX )
+typedef const GLubyte *(APIENTRY * P_SOIL_glGetStringiFunc) (GLenum, GLuint);
+static P_SOIL_glGetStringiFunc soilGlGetStringiFunc = NULL;
+
+static int isAtLeastGL3()
+{
+	static int is_gl3 = SOIL_CAPABILITY_UNKNOWN;
+
+	if ( SOIL_CAPABILITY_UNKNOWN == is_gl3 )
+	{
+		const char * verstr	= (const char *) glGetString( GL_VERSION );
+		is_gl3				= ( verstr && ( atoi(verstr) >= 3 ) );
+	}
+
+	return is_gl3;
+}
+#endif
+
+#ifdef SOIL_PLATFORM_WIN32
+static HMODULE openglModule = NULL;
+static int soilTestWinProcPointer(const PROC pTest)
+{
+	ptrdiff_t iTest;
+	if(!pTest) return 0;
+	iTest = (ptrdiff_t)pTest;
+	if(iTest == 1 || iTest == 2 || iTest == 3 || iTest == -1) return 0;
+	return 1;
+}
+#endif
+
+#if defined(__sgi) || defined (__sun) || defined(__HAIKU__)
+#include <dlfcn.h>
+
+void* dlGetProcAddress (const char* name)
+{
+  static void* h = NULL;
+  static void* gpa;
+
+  if (h == NULL)
+  {
+	if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL;
+	gpa = dlsym(h, "glXGetProcAddress");
+  }
+
+  if (gpa != NULL)
+	return ((void*(*)(const GLubyte*))gpa)((const GLubyte*)name);
+  else
+	return dlsym(h, (const char*)name);
+}
+#endif
+
+void * SOIL_GL_GetProcAddress(const char *proc)
+{
+	void *func = NULL;
+
+#if defined( SOIL_PLATFORM_IOS )
+	func = dlsym( RTLD_DEFAULT, proc );
+#elif defined( SOIL_GLES2 ) || defined( SOIL_GLES1 )
+	#ifndef SOIL_NO_EGL
+		func = eglGetProcAddress( proc );
+	#else
+		func = NULL;
+	#endif
+#elif defined( SOIL_PLATFORM_WIN32 )
+	if ( NULL == openglModule )
+		openglModule = LoadLibraryA("opengl32.dll");
+
+	func =  wglGetProcAddress( proc );
+
+	if (!soilTestWinProcPointer((const PROC)func)) {
+		func = (void *)GetProcAddress(openglModule, proc);
+	}
+
+#elif defined( SOIL_PLATFORM_OSX )
+	/*	I can't test this Apple stuff!	*/
+	CFBundleRef bundle;
+	CFURLRef bundleURL =
+	CFURLCreateWithFileSystemPath(
+								  kCFAllocatorDefault,
+								  CFSTR("/System/Library/Frameworks/OpenGL.framework"),
+								  kCFURLPOSIXPathStyle,
+								  true );
+	CFStringRef extensionName =
+	CFStringCreateWithCString(
+							  kCFAllocatorDefault,
+							  proc,
+							  kCFStringEncodingASCII );
+	bundle = CFBundleCreate( kCFAllocatorDefault, bundleURL );
+	assert( bundle != NULL );
+
+	func = CFBundleGetFunctionPointerForName( bundle, extensionName );
+
+	CFRelease( bundleURL );
+	CFRelease( extensionName );
+	CFRelease( bundle );
+#elif defined( SOIL_X11_PLATFORM )
+	func =
+#if !defined(GLX_VERSION_1_4)
+	glXGetProcAddressARB
+#else
+	glXGetProcAddress
+#endif
+	( (const GLubyte *)proc );
+#elif defined(__sgi) || defined (__sun) || defined(__HAIKU__)
+	func = dlGetProcAddress(proc);
+#endif
+
+	return func;
+}
+
+/* Based on the SDL2 implementation */
+int SOIL_GL_ExtensionSupported(const char *extension)
+{
+	const char *extensions;
+	const char *start;
+	const char *where, *terminator;
+
+	/* Extension names should not have spaces. */
+	where = strchr(extension, ' ');
+
+	if (where || *extension == '\0')
+	{
+		return 0;
+	}
+
+	#if defined( SOIL_X11_PLATFORM ) || defined( SOIL_PLATFORM_WIN32 ) || defined( SOIL_PLATFORM_OSX )
+	/* Lookup the available extensions */
+	if ( isAtLeastGL3() )
+	{
+		GLint num_exts = 0;
+		GLint i;
+
+		if ( NULL == soilGlGetStringiFunc )
+		{
+			soilGlGetStringiFunc = (P_SOIL_glGetStringiFunc)SOIL_GL_GetProcAddress("glGetStringi");
+
+			if ( NULL == soilGlGetStringiFunc )
+			{
+				return 0;
+			}
+		}
+
+		#ifndef GL_NUM_EXTENSIONS
+		#define GL_NUM_EXTENSIONS 0x821D
+		#endif
+		glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts);
+		for (i = 0; i < num_exts; i++)
+		{
+			const char *thisext = (const char *) soilGlGetStringiFunc(GL_EXTENSIONS, i);
+
+			if (strcmp(thisext, extension) == 0)
+			{
+				return 1;
+			}
+		}
+
+		return 0;
+	}
+	#endif
+
+	/* Try the old way with glGetString(GL_EXTENSIONS) ... */
+	extensions = (const char *) glGetString(GL_EXTENSIONS);
+
+	if (!extensions)
+	{
+		return 0;
+	}
+
+	/*
+	 * It takes a bit of care to be fool-proof about parsing the OpenGL
+	 * extensions string. Don't be fooled by sub-strings, etc.
+	 */
+	start = extensions;
+
+	for (;;) {
+		where = strstr(start, extension);
+
+		if (!where)
+			break;
+
+		terminator = where + strlen(extension);
+
+		if (where == start || *(where - 1) == ' ')
+			if (*terminator == ' ' || *terminator == '\0')
+				return 1;
+
+		start = terminator;
+	}
+
+	return 0;
+}
+
 /*	other functions	*/
 unsigned int
 	SOIL_internal_create_OGL_texture
 	(
 		const unsigned char *const data,
-		int width, int height, int channels,
+		int *width, int *height, int channels,
 		unsigned int reuse_texture_ID,
 		unsigned int flags,
 		unsigned int opengl_texture_type,
@@ -132,6 +425,27 @@ unsigned int
 			return tex_id;
 		}
 	}
+
+	if( flags & SOIL_FLAG_PVR_LOAD_DIRECT )
+	{
+		tex_id = SOIL_direct_load_PVR( filename, reuse_texture_ID, flags, 0 );
+		if( tex_id )
+		{
+			/*	hey, it worked!!	*/
+			return tex_id;
+		}
+	}
+
+	if( flags & SOIL_FLAG_ETC1_LOAD_DIRECT )
+	{
+		tex_id = SOIL_direct_load_ETC1( filename, reuse_texture_ID, flags );
+		if( tex_id )
+		{
+			/*	hey, it worked!!	*/
+			return tex_id;
+		}
+	}
+
 	/*	try to load the image	*/
 	img = SOIL_load_image( filename, &width, &height, &channels, force_channels );
 	/*	channels holds the original number of channels, which may have been forced	*/
@@ -147,7 +461,7 @@ unsigned int
 	}
 	/*	OK, make it a texture!	*/
 	tex_id = SOIL_internal_create_OGL_texture(
-			img, width, height, channels,
+			img, &width, &height, channels,
 			reuse_texture_ID, flags,
 			GL_TEXTURE_2D, GL_TEXTURE_2D,
 			GL_MAX_TEXTURE_SIZE );
@@ -168,7 +482,7 @@ unsigned int
 	)
 {
 	/*	variables	*/
-	unsigned char* img;
+	unsigned char* img = NULL;
 	int width, height, channels;
 	unsigned int tex_id;
 	/*	no direct uploading of the image as a DDS file	*/
@@ -180,8 +494,14 @@ unsigned int
 		result_string_pointer = "Invalid fake HDR format specified";
 		return 0;
 	}
-	/*	try to load the image (only the HDR type) */
-	img = stbi_hdr_load_rgbe( filename, &width, &height, &channels, 4 );
+
+	/* check if the image is HDR */
+	if ( stbi_is_hdr( filename ) )
+	{
+		/*	try to load the image (only the HDR type) */
+		img = stbi_load( filename, &width, &height, &channels, 4 );
+	}
+
 	/*	channels holds the original number of channels, which may have been forced	*/
 	if( NULL == img )
 	{
@@ -199,7 +519,7 @@ unsigned int
 	}
 	/*	OK, make it a texture!	*/
 	tex_id = SOIL_internal_create_OGL_texture(
-			img, width, height, channels,
+			img, &width, &height, channels,
 			reuse_texture_ID, flags,
 			GL_TEXTURE_2D, GL_TEXTURE_2D,
 			GL_MAX_TEXTURE_SIZE );
@@ -239,6 +559,31 @@ unsigned int
 			return tex_id;
 		}
 	}
+
+	if( flags & SOIL_FLAG_PVR_LOAD_DIRECT )
+	{
+		tex_id = SOIL_direct_load_PVR_from_memory(
+				buffer, buffer_length,
+				reuse_texture_ID, flags, 0 );
+		if( tex_id )
+		{
+			/*	hey, it worked!!	*/
+			return tex_id;
+		}
+	}
+
+	if( flags & SOIL_FLAG_ETC1_LOAD_DIRECT )
+	{
+		tex_id = SOIL_direct_load_ETC1_from_memory(
+				buffer, buffer_length,
+				reuse_texture_ID, flags );
+		if( tex_id )
+		{
+			/*	hey, it worked!!	*/
+			return tex_id;
+		}
+	}
+
 	/*	try to load the image	*/
 	img = SOIL_load_image_from_memory(
 					buffer, buffer_length,
@@ -257,7 +602,7 @@ unsigned int
 	}
 	/*	OK, make it a texture!	*/
 	tex_id = SOIL_internal_create_OGL_texture(
-			img, width, height, channels,
+			img, &width, &height, channels,
 			reuse_texture_ID, flags,
 			GL_TEXTURE_2D, GL_TEXTURE_2D,
 			GL_MAX_TEXTURE_SIZE );
@@ -317,7 +662,7 @@ unsigned int
 	}
 	/*	upload the texture, and create a texture ID if necessary	*/
 	tex_id = SOIL_internal_create_OGL_texture(
-			img, width, height, channels,
+			img, &width, &height, channels,
 			reuse_texture_ID, flags,
 			SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_POSITIVE_X,
 			SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -341,7 +686,7 @@ unsigned int
 		}
 		/*	upload the texture, but reuse the assigned texture ID	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				img, width, height, channels,
+				img, &width, &height, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_NEGATIVE_X,
 				SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -366,7 +711,7 @@ unsigned int
 		}
 		/*	upload the texture, but reuse the assigned texture ID	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				img, width, height, channels,
+				img, &width, &height, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_POSITIVE_Y,
 				SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -391,7 +736,7 @@ unsigned int
 		}
 		/*	upload the texture, but reuse the assigned texture ID	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				img, width, height, channels,
+				img, &width, &height, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
 				SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -416,7 +761,7 @@ unsigned int
 		}
 		/*	upload the texture, but reuse the assigned texture ID	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				img, width, height, channels,
+				img, &width, &height, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_POSITIVE_Z,
 				SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -441,7 +786,7 @@ unsigned int
 		}
 		/*	upload the texture, but reuse the assigned texture ID	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				img, width, height, channels,
+				img, &width, &height, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
 				SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -510,7 +855,7 @@ unsigned int
 	}
 	/*	upload the texture, and create a texture ID if necessary	*/
 	tex_id = SOIL_internal_create_OGL_texture(
-			img, width, height, channels,
+			img, &width, &height, channels,
 			reuse_texture_ID, flags,
 			SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_POSITIVE_X,
 			SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -536,7 +881,7 @@ unsigned int
 		}
 		/*	upload the texture, but reuse the assigned texture ID	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				img, width, height, channels,
+				img, &width, &height, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_NEGATIVE_X,
 				SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -563,7 +908,7 @@ unsigned int
 		}
 		/*	upload the texture, but reuse the assigned texture ID	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				img, width, height, channels,
+				img, &width, &height, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_POSITIVE_Y,
 				SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -590,7 +935,7 @@ unsigned int
 		}
 		/*	upload the texture, but reuse the assigned texture ID	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				img, width, height, channels,
+				img, &width, &height, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
 				SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -617,7 +962,7 @@ unsigned int
 		}
 		/*	upload the texture, but reuse the assigned texture ID	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				img, width, height, channels,
+				img, &width, &height, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_POSITIVE_Z,
 				SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -644,7 +989,7 @@ unsigned int
 		}
 		/*	upload the texture, but reuse the assigned texture ID	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				img, width, height, channels,
+				img, &width, &height, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP, SOIL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
 				SOIL_MAX_CUBE_MAP_TEXTURE_SIZE );
@@ -689,6 +1034,22 @@ unsigned int
 			return tex_id;
 		}
 	}
+
+	if ( flags & SOIL_FLAG_PVR_LOAD_DIRECT )
+	{
+		tex_id = SOIL_direct_load_PVR( filename, reuse_texture_ID, flags, 1 );
+		if( tex_id )
+		{
+			/*	hey, it worked!!	*/
+			return tex_id;
+		}
+	}
+
+	if ( flags & SOIL_FLAG_ETC1_LOAD_DIRECT )
+	{
+		return 0;
+	}
+
 	/*	face order checking	*/
 	for( i = 0; i < 6; ++i )
 	{
@@ -777,6 +1138,24 @@ unsigned int
 			return tex_id;
 		}
 	}
+
+	if ( flags & SOIL_FLAG_PVR_LOAD_DIRECT )
+	{
+		tex_id = SOIL_direct_load_PVR_from_memory(
+				buffer, buffer_length,
+				reuse_texture_ID, flags, 1 );
+		if ( tex_id )
+		{
+			/*	hey, it worked!!	*/
+			return tex_id;
+		}
+	}
+
+	if ( flags & SOIL_FLAG_ETC1_LOAD_DIRECT )
+	{
+		return 0;
+	}
+
 	/*	face order checking	*/
 	for( i = 0; i < 6; ++i )
 	{
@@ -930,7 +1309,7 @@ unsigned int
 		}
 		/*	upload it as a texture	*/
 		tex_id = SOIL_internal_create_OGL_texture(
-				sub_img, sz, sz, channels,
+				sub_img, &sz, &sz, channels,
 				tex_id, flags,
 				SOIL_TEXTURE_CUBE_MAP,
 				cubemap_target,
@@ -946,7 +1325,7 @@ unsigned int
 	SOIL_create_OGL_texture
 	(
 		const unsigned char *const data,
-		int width, int height, int channels,
+		int *width, int *height, int channels,
 		unsigned int reuse_texture_ID,
 		unsigned int flags
 	)
@@ -977,11 +1356,91 @@ void check_for_GL_errors( const char *calling_location )
 }
 #endif
 
+static void createMipmaps(const unsigned char *const img,
+		int width, int height, int channels,
+		unsigned int flags,
+		unsigned int opengl_texture_target,
+		unsigned int internal_texture_format,
+		unsigned int original_texture_format,
+		int DXT_mode)
+{
+	if ( ( flags & SOIL_FLAG_GL_MIPMAPS ) && query_gen_mipmap_capability() == SOIL_CAPABILITY_PRESENT )
+	{
+		soilGlGenerateMipmap(opengl_texture_target);
+	}
+	else
+	{
+		int MIPlevel = 1;
+		int MIPwidth = (width+1) / 2;
+		int MIPheight = (height+1) / 2;
+		unsigned char *resampled = (unsigned char*)malloc( channels*MIPwidth*MIPheight );
+
+		while( ((1<<MIPlevel) <= width) || ((1<<MIPlevel) <= height) )
+		{
+			/*	do this MIPmap level	*/
+			mipmap_image(
+					img, width, height, channels,
+					resampled,
+					(1 << MIPlevel), (1 << MIPlevel) );
+
+			/*  upload the MIPmaps	*/
+			if( DXT_mode == SOIL_CAPABILITY_PRESENT )
+			{
+				/*	user wants me to do the DXT conversion!	*/
+				int DDS_size;
+				unsigned char *DDS_data = NULL;
+				if( (channels & 1) == 1 )
+				{
+					/*	RGB, use DXT1	*/
+					DDS_data = convert_image_to_DXT1(
+							resampled, MIPwidth, MIPheight, channels, &DDS_size );
+				} else
+				{
+					/*	RGBA, use DXT5	*/
+					DDS_data = convert_image_to_DXT5(
+							resampled, MIPwidth, MIPheight, channels, &DDS_size );
+				}
+				if( DDS_data )
+				{
+					soilGlCompressedTexImage2D(
+						opengl_texture_target, MIPlevel,
+						internal_texture_format, MIPwidth, MIPheight, 0,
+						DDS_size, DDS_data );
+					check_for_GL_errors( "glCompressedTexImage2D" );
+					SOIL_free_image_data( DDS_data );
+				} else
+				{
+					/*	my compression failed, try the OpenGL driver's version	*/
+					glTexImage2D(
+						opengl_texture_target, MIPlevel,
+						internal_texture_format, MIPwidth, MIPheight, 0,
+						original_texture_format, GL_UNSIGNED_BYTE, resampled );
+					check_for_GL_errors( "glTexImage2D" );
+				}
+			} else
+			{
+				/*	user want OpenGL to do all the work!	*/
+				glTexImage2D(
+					opengl_texture_target, MIPlevel,
+					internal_texture_format, MIPwidth, MIPheight, 0,
+					original_texture_format, GL_UNSIGNED_BYTE, resampled );
+				check_for_GL_errors( "glTexImage2D" );
+			}
+			/*	prep for the next level	*/
+			++MIPlevel;
+			MIPwidth = (MIPwidth + 1) / 2;
+			MIPheight = (MIPheight + 1) / 2;
+		}
+
+		SOIL_free_image_data( resampled );
+	}
+}
+
 unsigned int
 	SOIL_internal_create_OGL_texture
 	(
 		const unsigned char *const data,
-		int width, int height, int channels,
+		int *width, int *height, int channels,
 		unsigned int reuse_texture_ID,
 		unsigned int flags,
 		unsigned int opengl_texture_type,
@@ -990,11 +1449,21 @@ unsigned int
 	)
 {
 	/*	variables	*/
-	unsigned char* img;
+	unsigned char* img = NULL;
 	unsigned int tex_id;
 	unsigned int internal_texture_format = 0, original_texture_format = 0;
 	int DXT_mode = SOIL_CAPABILITY_UNKNOWN;
+	int sRGB_texture = query_sRGB_capability() == SOIL_CAPABILITY_PRESENT && ( flags & SOIL_FLAG_SRGB_COLOR_SPACE );;
 	int max_supported_size;
+	int iwidth = *width;
+	int iheight = *height;
+	int needCopy;
+	GLint unpack_aligment;
+
+	/*	how large of a texture can this OpenGL implementation handle?	*/
+	/*	texture_check_size_enum will be GL_MAX_TEXTURE_SIZE or SOIL_MAX_CUBE_MAP_TEXTURE_SIZE	*/
+	glGetIntegerv( texture_check_size_enum, &max_supported_size );
+
 	/*	If the user wants to use the texture rectangle I kill a few flags	*/
 	if( flags & SOIL_FLAG_TEXTURE_RECTANGLE )
 	{
@@ -1025,18 +1494,36 @@ unsigned int
 			return 0;
 		}
 	}
-	/*	create a copy the image data	*/
-	img = (unsigned char*)malloc( width*height*channels );
-	memcpy( img, data, width*height*channels );
+
+	/*	if the user can't support NPOT textures, make sure we force the POT option	*/
+	if( (query_NPOT_capability() == SOIL_CAPABILITY_NONE) &&
+		!(flags & SOIL_FLAG_TEXTURE_RECTANGLE) )
+	{
+		/*	add in the POT flag */
+		flags |= SOIL_FLAG_POWER_OF_TWO;
+	}
+
+	needCopy = ( ( flags & SOIL_FLAG_INVERT_Y ) ||
+				 ( flags & SOIL_FLAG_NTSC_SAFE_RGB ) ||
+				 ( flags & SOIL_FLAG_MULTIPLY_ALPHA ) ||
+				 ( flags & SOIL_FLAG_CoCg_Y )
+				);
+
+	/*	create a copy the image data only if needed */
+	if ( needCopy ) {
+		img = (unsigned char*)malloc( iwidth*iheight*channels );
+		memcpy( img, data, iwidth*iheight*channels );
+	}
+
 	/*	does the user want me to invert the image?	*/
 	if( flags & SOIL_FLAG_INVERT_Y )
 	{
 		int i, j;
-		for( j = 0; j*2 < height; ++j )
+		for( j = 0; j*2 < iheight; ++j )
 		{
-			int index1 = j * width * channels;
-			int index2 = (height - 1 - j) * width * channels;
-			for( i = width * channels; i > 0; --i )
+			int index1 = j * iwidth * channels;
+			int index2 = (iheight - 1 - j) * iwidth * channels;
+			for( i = iwidth * channels; i > 0; --i )
 			{
 				unsigned char temp = img[index1];
 				img[index1] = img[index2];
@@ -1049,7 +1536,7 @@ unsigned int
 	/*	does the user want me to scale the colors into the NTSC safe RGB range?	*/
 	if( flags & SOIL_FLAG_NTSC_SAFE_RGB )
 	{
-		scale_image_RGB_to_NTSC_safe( img, width, height, channels );
+		scale_image_RGB_to_NTSC_safe( img, iwidth, iheight, channels );
 	}
 	/*	does the user want me to convert from straight to pre-multiplied alpha?
 		(and do we even _have_ alpha?)	*/
@@ -1059,13 +1546,13 @@ unsigned int
 		switch( channels )
 		{
 		case 2:
-			for( i = 0; i < 2*width*height; i += 2 )
+			for( i = 0; i < 2*iwidth*iheight; i += 2 )
 			{
 				img[i] = (img[i] * img[i+1] + 128) >> 8;
 			}
 			break;
 		case 4:
-			for( i = 0; i < 4*width*height; i += 4 )
+			for( i = 0; i < 4*iwidth*iheight; i += 4 )
 			{
 				img[i+0] = (img[i+0] * img[i+3] + 128) >> 8;
 				img[i+1] = (img[i+1] * img[i+3] + 128) >> 8;
@@ -1077,98 +1564,88 @@ unsigned int
 			break;
 		}
 	}
-	/*	if the user can't support NPOT textures, make sure we force the POT option	*/
-	if( (query_NPOT_capability() == SOIL_CAPABILITY_NONE) &&
-		!(flags & SOIL_FLAG_TEXTURE_RECTANGLE) )
-	{
-		/*	add in the POT flag */
-		flags |= SOIL_FLAG_POWER_OF_TWO;
-	}
-	/*	how large of a texture can this OpenGL implementation handle?	*/
-	/*	texture_check_size_enum will be GL_MAX_TEXTURE_SIZE or SOIL_MAX_CUBE_MAP_TEXTURE_SIZE	*/
-	glGetIntegerv( texture_check_size_enum, &max_supported_size );
-	/*	do I need to make it a power of 2?	*/
-	if(
-		(flags & SOIL_FLAG_POWER_OF_TWO) ||	/*	user asked for it	*/
-		(flags & SOIL_FLAG_MIPMAPS) ||		/*	need it for the MIP-maps	*/
-		(width > max_supported_size) ||		/*	it's too big, (make sure it's	*/
-		(height > max_supported_size) )		/*	2^n for later down-sampling)	*/
+
+	/*	do I need to make it a power of 2?	*/
+	if(
+		( ( flags & SOIL_FLAG_POWER_OF_TWO) && ( !SOIL_IS_POW2(iwidth) || !SOIL_IS_POW2(iheight) ) ) ||	/*	user asked for it and the texture is not power of 2	*/
+		( (flags & SOIL_FLAG_MIPMAPS)&& !( ( flags & SOIL_FLAG_GL_MIPMAPS ) &&
+										   query_gen_mipmap_capability() == SOIL_CAPABILITY_PRESENT &&
+										   query_NPOT_capability() == SOIL_CAPABILITY_PRESENT ) ) ||	/*	need it for the MIP-maps when mipmaps required
+																											and not GL mipmaps required and supported	*/
+		(iwidth > max_supported_size) ||		/*	it's too big, (make sure it's	*/
+		(iheight > max_supported_size) )		/*	2^n for later down-sampling)	*/
 	{
 		int new_width = 1;
 		int new_height = 1;
-		while( new_width < width )
+		while( new_width < iwidth )
 		{
 			new_width *= 2;
 		}
-		while( new_height < height )
+		while( new_height < iheight )
 		{
 			new_height *= 2;
 		}
 		/*	still?	*/
-		if( (new_width != width) || (new_height != height) )
+		if( (new_width != iwidth) || (new_height != iheight) )
 		{
 			/*	yep, resize	*/
 			unsigned char *resampled = (unsigned char*)malloc( channels*new_width*new_height );
 			up_scale_image(
-					img, width, height, channels,
+					NULL != img ? img : data, iwidth, iheight, channels,
 					resampled, new_width, new_height );
-			/*	OJO	this is for debug only!	*/
-			/*
-			SOIL_save_image( "\\showme.bmp", SOIL_SAVE_TYPE_BMP,
-							new_width, new_height, channels,
-							resampled );
-			*/
-			/*	nuke the old guy, then point it at the new guy	*/
+
+			/*	nuke the old guy ( if a copy exists ), then point it at the new guy	*/
 			SOIL_free_image_data( img );
 			img = resampled;
-			width = new_width;
-			height = new_height;
+			*width = new_width;
+			*height = new_height;
+			iwidth = new_width;
+			iheight = new_height;
 		}
 	}
 	/*	now, if it is too large...	*/
-	if( (width > max_supported_size) || (height > max_supported_size) )
+	if( (iwidth > max_supported_size) || (iheight > max_supported_size) )
 	{
 		/*	I've already made it a power of two, so simply use the MIPmapping
 			code to reduce its size to the allowable maximum.	*/
 		unsigned char *resampled;
 		int reduce_block_x = 1, reduce_block_y = 1;
 		int new_width, new_height;
-		if( width > max_supported_size )
+		if( iwidth > max_supported_size )
 		{
-			reduce_block_x = width / max_supported_size;
+			reduce_block_x = iwidth / max_supported_size;
 		}
-		if( height > max_supported_size )
+		if( iheight > max_supported_size )
 		{
-			reduce_block_y = height / max_supported_size;
+			reduce_block_y = iheight / max_supported_size;
 		}
-		new_width = width / reduce_block_x;
-		new_height = height / reduce_block_y;
+		new_width = iwidth / reduce_block_x;
+		new_height = iheight / reduce_block_y;
 		resampled = (unsigned char*)malloc( channels*new_width*new_height );
 		/*	perform the actual reduction	*/
-		mipmap_image(	img, width, height, channels,
+		mipmap_image( NULL != img ? img : data, iwidth, iheight, channels,
 						resampled, reduce_block_x, reduce_block_y );
 		/*	nuke the old guy, then point it at the new guy	*/
 		SOIL_free_image_data( img );
 		img = resampled;
-		width = new_width;
-		height = new_height;
+		*width = new_width;
+		*height = new_height;
+		iwidth = new_width;
+		iheight = new_height;
 	}
 	/*	does the user want us to use YCoCg color space?	*/
 	if( flags & SOIL_FLAG_CoCg_Y )
 	{
 		/*	this will only work with RGB and RGBA images */
-		convert_RGB_to_YCoCg( img, width, height, channels );
-		/*
-		save_image_as_DDS( "CoCg_Y.dds", width, height, channels, img );
-		*/
+		convert_RGB_to_YCoCg( img, iwidth, iheight, channels );
 	}
 	/*	create the OpenGL texture ID handle
-    	(note: allowing a forced texture ID lets me reload a texture)	*/
-    tex_id = reuse_texture_ID;
-    if( tex_id == 0 )
-    {
+		(note: allowing a forced texture ID lets me reload a texture)	*/
+	tex_id = reuse_texture_ID;
+	if( tex_id == 0 )
+	{
 		glGenTextures( 1, &tex_id );
-    }
+	}
 	check_for_GL_errors( "glGenTextures" );
 	/* Note: sometimes glGenTextures fails (usually no OpenGL context)	*/
 	if( tex_id )
@@ -1200,17 +1677,38 @@ unsigned int
 				if( (channels & 1) == 1 )
 				{
 					/*	1 or 3 channels = DXT1	*/
-					internal_texture_format = SOIL_RGB_S3TC_DXT1;
+					internal_texture_format = sRGB_texture ? SOIL_GL_COMPRESSED_SRGB_S3TC_DXT1_EXT : SOIL_RGB_S3TC_DXT1;
 				} else
 				{
 					/*	2 or 4 channels = DXT5	*/
-					internal_texture_format = SOIL_RGBA_S3TC_DXT5;
+					internal_texture_format = sRGB_texture ? SOIL_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT : SOIL_RGBA_S3TC_DXT5;
 				}
 			}
 		}
+		else if ( sRGB_texture )
+		{
+			switch( channels )
+			{
+			case 3:
+				internal_texture_format = SOIL_GL_SRGB;
+				break;
+			case 4:
+				internal_texture_format = SOIL_GL_SRGB_ALPHA;
+				break;
+			}
+		}
+
 		/*  bind an OpenGL texture ID	*/
 		glBindTexture( opengl_texture_type, tex_id );
 		check_for_GL_errors( "glBindTexture" );
+
+		/* set the unpack aligment */
+		glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpack_aligment);
+		if ( 1 != unpack_aligment )
+		{
+			glPixelStorei(GL_UNPACK_ALIGNMENT,1);
+		}
+
 		/*  upload the main image	*/
 		if( DXT_mode == SOIL_CAPABILITY_PRESENT )
 		{
@@ -1220,17 +1718,17 @@ unsigned int
 			if( (channels & 1) == 1 )
 			{
 				/*	RGB, use DXT1	*/
-				DDS_data = convert_image_to_DXT1( img, width, height, channels, &DDS_size );
+				DDS_data = convert_image_to_DXT1( NULL != img ? img : data, iwidth, iheight, channels, &DDS_size );
 			} else
 			{
 				/*	RGBA, use DXT5	*/
-				DDS_data = convert_image_to_DXT5( img, width, height, channels, &DDS_size );
+				DDS_data = convert_image_to_DXT5( NULL != img ? img : data, iwidth, iheight, channels, &DDS_size );
 			}
 			if( DDS_data )
 			{
 				soilGlCompressedTexImage2D(
 					opengl_texture_target, 0,
-					internal_texture_format, width, height, 0,
+					internal_texture_format, iwidth, iheight, 0,
 					DDS_size, DDS_data );
 				check_for_GL_errors( "glCompressedTexImage2D" );
 				SOIL_free_image_data( DDS_data );
@@ -1240,8 +1738,8 @@ unsigned int
 				/*	my compression failed, try the OpenGL driver's version	*/
 				glTexImage2D(
 					opengl_texture_target, 0,
-					internal_texture_format, width, height, 0,
-					original_texture_format, GL_UNSIGNED_BYTE, img );
+					internal_texture_format, iwidth, iheight, 0,
+					original_texture_format, GL_UNSIGNED_BYTE, NULL != img ? img : data );
 				check_for_GL_errors( "glTexImage2D" );
 				/*	printf( "OpenGL DXT compressor\n" );	*/
 			}
@@ -1250,74 +1748,18 @@ unsigned int
 			/*	user want OpenGL to do all the work!	*/
 			glTexImage2D(
 				opengl_texture_target, 0,
-				internal_texture_format, width, height, 0,
-				original_texture_format, GL_UNSIGNED_BYTE, img );
+				internal_texture_format, iwidth, iheight, 0,
+				original_texture_format, GL_UNSIGNED_BYTE, NULL != img ? img : data );
+
 			check_for_GL_errors( "glTexImage2D" );
 			/*printf( "OpenGL DXT compressor\n" );	*/
 		}
+
 		/*	are any MIPmaps desired?	*/
-		if( flags & SOIL_FLAG_MIPMAPS )
+		if( flags & SOIL_FLAG_MIPMAPS || flags & SOIL_FLAG_GL_MIPMAPS )
 		{
-			int MIPlevel = 1;
-			int MIPwidth = (width+1) / 2;
-			int MIPheight = (height+1) / 2;
-			unsigned char *resampled = (unsigned char*)malloc( channels*MIPwidth*MIPheight );
-			while( ((1<<MIPlevel) <= width) || ((1<<MIPlevel) <= height) )
-			{
-				/*	do this MIPmap level	*/
-				mipmap_image(
-						img, width, height, channels,
-						resampled,
-						(1 << MIPlevel), (1 << MIPlevel) );
-				/*  upload the MIPmaps	*/
-				if( DXT_mode == SOIL_CAPABILITY_PRESENT )
-				{
-					/*	user wants me to do the DXT conversion!	*/
-					int DDS_size;
-					unsigned char *DDS_data = NULL;
-					if( (channels & 1) == 1 )
-					{
-						/*	RGB, use DXT1	*/
-						DDS_data = convert_image_to_DXT1(
-								resampled, MIPwidth, MIPheight, channels, &DDS_size );
-					} else
-					{
-						/*	RGBA, use DXT5	*/
-						DDS_data = convert_image_to_DXT5(
-								resampled, MIPwidth, MIPheight, channels, &DDS_size );
-					}
-					if( DDS_data )
-					{
-						soilGlCompressedTexImage2D(
-							opengl_texture_target, MIPlevel,
-							internal_texture_format, MIPwidth, MIPheight, 0,
-							DDS_size, DDS_data );
-						check_for_GL_errors( "glCompressedTexImage2D" );
-						SOIL_free_image_data( DDS_data );
-					} else
-					{
-						/*	my compression failed, try the OpenGL driver's version	*/
-						glTexImage2D(
-							opengl_texture_target, MIPlevel,
-							internal_texture_format, MIPwidth, MIPheight, 0,
-							original_texture_format, GL_UNSIGNED_BYTE, resampled );
-						check_for_GL_errors( "glTexImage2D" );
-					}
-				} else
-				{
-					/*	user want OpenGL to do all the work!	*/
-					glTexImage2D(
-						opengl_texture_target, MIPlevel,
-						internal_texture_format, MIPwidth, MIPheight, 0,
-						original_texture_format, GL_UNSIGNED_BYTE, resampled );
-					check_for_GL_errors( "glTexImage2D" );
-				}
-				/*	prep for the next level	*/
-				++MIPlevel;
-				MIPwidth = (MIPwidth + 1) / 2;
-				MIPheight = (MIPheight + 1) / 2;
-			}
-			SOIL_free_image_data( resampled );
+			createMipmaps( NULL != img ? img : data, iwidth, iheight, channels, flags, opengl_texture_target, internal_texture_format, original_texture_format, DXT_mode );
+
 			/*	instruct OpenGL to use the MIPmaps	*/
 			glTexParameteri( opengl_texture_type, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
 			glTexParameteri( opengl_texture_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
@@ -1329,6 +1771,13 @@ unsigned int
 			glTexParameteri( opengl_texture_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
 			check_for_GL_errors( "GL_TEXTURE_MIN/MAG_FILTER" );
 		}
+
+		/* recover the unpack aligment */
+		if ( 1 != unpack_aligment )
+		{
+			glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_aligment);
+		}
+
 		/*	does the user want clamping, or wrapping?	*/
 		if( flags & SOIL_FLAG_TEXTURE_REPEATS )
 		{
@@ -1342,8 +1791,8 @@ unsigned int
 			check_for_GL_errors( "GL_TEXTURE_WRAP_*" );
 		} else
 		{
-			/*	unsigned int clamp_mode = SOIL_CLAMP_TO_EDGE;	*/
-			unsigned int clamp_mode = GL_CLAMP;
+			unsigned int clamp_mode = SOIL_CLAMP_TO_EDGE;
+			/* unsigned int clamp_mode = GL_CLAMP; */
 			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_S, clamp_mode );
 			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_T, clamp_mode );
 			if( opengl_texture_type == SOIL_TEXTURE_CUBE_MAP )
@@ -1360,7 +1809,9 @@ unsigned int
 		/*	failed	*/
 		result_string_pointer = "Failed to generate an OpenGL texture name; missing OpenGL context?";
 	}
+
 	SOIL_free_image_data( img );
+
 	return tex_id;
 }
 
@@ -1376,6 +1827,7 @@ int
 	unsigned char *pixel_data;
 	int i, j;
 	int save_result;
+	GLint pack_aligment;
 
 	/*	error checks	*/
 	if( (width < 1) || (height < 1) )
@@ -1394,12 +1846,23 @@ int
 		return 0;
 	}
 
-    /*  Get the data from OpenGL	*/
-    pixel_data = (unsigned char*)malloc( 3*width*height );
-    glReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, pixel_data);
+	glGetIntegerv(GL_PACK_ALIGNMENT, &pack_aligment);
+	if ( 1 != pack_aligment )
+	{
+		glPixelStorei(GL_PACK_ALIGNMENT,1);
+	}
+
+	/*  Get the data from OpenGL	*/
+	pixel_data = (unsigned char*)malloc( 3*width*height );
+	glReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, pixel_data);
 
-    /*	invert the image	*/
-    for( j = 0; j*2 < height; ++j )
+	if ( 1 != pack_aligment )
+	{
+		glPixelStorei(GL_PACK_ALIGNMENT, pack_aligment);
+	}
+
+	/*	invert the image	*/
+	for( j = 0; j*2 < height; ++j )
 	{
 		int index1 = j * width * 3;
 		int index2 = (height - 1 - j) * width * 3;
@@ -1413,11 +1876,11 @@ int
 		}
 	}
 
-    /*	save the image	*/
-    save_result = SOIL_save_image( filename, image_type, width, height, 3, pixel_data);
+	/*	save the image	*/
+	save_result = SOIL_save_image( filename, image_type, width, height, 3, pixel_data);
 
-    /*  And free the memory	*/
-    SOIL_free_image_data( pixel_data );
+	/*	And free the memory	*/
+	SOIL_free_image_data( pixel_data );
 	return save_result;
 }
 
@@ -1464,6 +1927,7 @@ unsigned char*
 	return result;
 }
 
+
 int
 	SOIL_save_image
 	(
@@ -1472,6 +1936,19 @@ int
 		int width, int height, int channels,
 		const unsigned char *const data
 	)
+{
+	return SOIL_save_image_quality( filename, image_type, width, height, channels, data, 80 );
+}
+
+int
+	SOIL_save_image_quality
+	(
+		const char *filename,
+		int image_type,
+		int width, int height, int channels,
+		const unsigned char *const data,
+		int quality
+	)
 {
 	int save_result;
 
@@ -1498,9 +1975,20 @@ int
 		save_result = save_image_as_DDS( filename,
 				width, height, channels, (const unsigned char *const)data );
 	} else
+	if( image_type == SOIL_SAVE_TYPE_PNG )
+	{
+		save_result = stbi_write_png( filename,
+				width, height, channels, (const unsigned char *const)data, 0 );
+	} else
+	if ( image_type == SOIL_SAVE_TYPE_JPG )
+	{
+		save_result = jo_write_jpg( filename, (const void*)data, width, height, channels, quality );
+	}
+	else
 	{
 		save_result = 0;
 	}
+
 	if( save_result == 0 )
 	{
 		result_string_pointer = "Saving the image failed";
@@ -1517,7 +2005,8 @@ void
 		unsigned char *img_data
 	)
 {
-	free( (void*)img_data );
+	if ( img_data )
+		free( (void*)img_data );
 }
 
 const char*
@@ -1550,6 +2039,7 @@ unsigned int SOIL_direct_load_DDS_from_memory(
 	unsigned int flag;
 	unsigned int cf_target, ogl_target_start, ogl_target_end;
 	unsigned int opengl_texture_type;
+	unsigned int format_type = GL_UNSIGNED_BYTE;
 	int i;
 	/*	1st off, does the filename even exist?	*/
 	if( NULL == buffer )
@@ -1581,7 +2071,7 @@ unsigned int SOIL_direct_load_DDS_from_memory(
 		uncompressed.  Some DDS writers do not conform to the
 		spec, so I need to make my reader more tolerant	*/
 	/*	I need one of these	*/
-	flag = DDPF_FOURCC | DDPF_RGB;
+	flag = DDPF_FOURCC | DDPF_RGB | DDPF_LUMINANCE;
 	if( (header.sPixelFormat.dwFlags & flag) == 0 ) {goto quick_exit;}
 	if( header.sPixelFormat.dwSize != 32 ) {goto quick_exit;}
 	if( (header.sCaps.dwCaps1 & DDSCAPS_TEXTURE) == 0 ) {goto quick_exit;}
@@ -1603,12 +2093,61 @@ unsigned int SOIL_direct_load_DDS_from_memory(
 	cubemap = (header.sCaps.dwCaps2 & DDSCAPS2_CUBEMAP) / DDSCAPS2_CUBEMAP;
 	if( uncompressed )
 	{
-		S3TC_type = GL_RGB;
-		block_size = 3;
-		if( header.sPixelFormat.dwFlags & DDPF_ALPHAPIXELS )
+		if ( header.sPixelFormat.dwRGBBitCount == 8 )
 		{
-			S3TC_type = GL_RGBA;
-			block_size = 4;
+			if ( (header.sPixelFormat.dwRBitMask == 0xe0) &&
+				 (header.sPixelFormat.dwGBitMask == 0x1c) &&
+				 (header.sPixelFormat.dwBBitMask == 0x3))
+			{
+				S3TC_type = GL_RGB;
+				format_type = GL_UNSIGNED_BYTE_3_3_2;
+				block_size = 1;
+			} else
+			{
+				S3TC_type = GL_LUMINANCE;
+				block_size = 1;
+			}
+		} else if ( header.sPixelFormat.dwRGBBitCount == 16 )
+		{
+			if ( (header.sPixelFormat.dwRBitMask == 0xf800) &&
+				 (header.sPixelFormat.dwGBitMask == 0x7e0) &&
+				 (header.sPixelFormat.dwBBitMask == 0x1f))
+			{
+				//DXGI_FORMAT_B5G6R5_UNORM
+				S3TC_type = GL_RGBA;
+				format_type = GL_UNSIGNED_SHORT_5_5_5_1;
+				block_size = 2;
+			} else if ( (header.sPixelFormat.dwRBitMask == 0xf00) &&
+				 (header.sPixelFormat.dwGBitMask == 0xf0) &&
+				 (header.sPixelFormat.dwBBitMask == 0xf) &&
+				 (header.sPixelFormat.dwAlphaBitMask == 0xf000))
+			{
+				//D3DFMT_A4R4G4B4
+				S3TC_type = GL_RGBA;
+				format_type = GL_UNSIGNED_SHORT_4_4_4_4;
+				block_size = 2;
+			} else if ( (header.sPixelFormat.dwRBitMask == 0x7c00) &&
+				 (header.sPixelFormat.dwGBitMask == 0x3e0) &&
+				 (header.sPixelFormat.dwBBitMask == 0x1f))
+			{
+				//DXGI_FORMAT_B5G5R5A1_UNORM
+				S3TC_type = GL_RGBA;
+				format_type = GL_UNSIGNED_SHORT_5_5_5_1;
+				block_size = 2;
+			} else
+			{
+				S3TC_type = GL_RG;
+				block_size = 2;
+			}
+		} else
+		{
+			S3TC_type = GL_RGB;
+			block_size = 3;
+			if( header.sPixelFormat.dwFlags & DDPF_ALPHAPIXELS )
+			{
+				S3TC_type = GL_RGBA;
+				block_size = 4;
+			}
 		}
 		DDS_main_size = width * height * block_size;
 	} else
@@ -1672,23 +2211,13 @@ unsigned int SOIL_direct_load_DDS_from_memory(
 	}
 	if( (header.sCaps.dwCaps1 & DDSCAPS_MIPMAP) && (header.dwMipMapCount > 1) )
 	{
-		int shift_offset;
 		mipmaps = header.dwMipMapCount - 1;
 		DDS_full_size = DDS_main_size;
-		if( uncompressed )
-		{
-			/*	uncompressed DDS, simple MIPmap size calculation	*/
-			shift_offset = 0;
-		} else
-		{
-			/*	compressed DDS, MIPmap size calculation is block based	*/
-			shift_offset = 2;
-		}
 		for( i = 1; i <= mipmaps; ++ i )
 		{
 			int w, h;
-			w = width >> (shift_offset + i);
-			h = height >> (shift_offset + i);
+			w = width >> i;
+			h = height >> i;
 			if( w < 1 )
 			{
 				w = 1;
@@ -1697,7 +2226,15 @@ unsigned int SOIL_direct_load_DDS_from_memory(
 			{
 				h = 1;
 			}
-			DDS_full_size += w*h*block_size;
+			if ( uncompressed )
+			{
+				/*	uncompressed DDS, simple MIPmap size calculation	*/
+				DDS_full_size += w*h*block_size;
+			} else
+			{
+				/*	compressed DDS, MIPmap size calculation is block based	*/
+				DDS_full_size += ((w+3)/4)*((h+3)/4)*block_size;
+			}
 		}
 	} else
 	{
@@ -1716,7 +2253,7 @@ unsigned int SOIL_direct_load_DDS_from_memory(
 	/*	do this for each face of the cubemap!	*/
 	for( cf_target = ogl_target_start; cf_target <= ogl_target_end; ++cf_target )
 	{
-		if( buffer_index + DDS_full_size <= buffer_length )
+		if( buffer_index + DDS_full_size <= (unsigned int)buffer_length )
 		{
 			unsigned int byte_offset = DDS_main_size;
 			memcpy( (void*)DDS_data, (const void*)(&buffer[buffer_index]), DDS_full_size );
@@ -1724,18 +2261,54 @@ unsigned int SOIL_direct_load_DDS_from_memory(
 			/*	upload the main chunk	*/
 			if( uncompressed )
 			{
-				/*	and remember, DXT uncompressed uses BGR(A),
-					so swap to RGB(A) for ALL MIPmap levels	*/
-				for( i = 0; i < DDS_full_size; i += block_size )
+				if ( (header.sPixelFormat.dwRBitMask == 0xff0000) && ( ( block_size == 3 && S3TC_type == GL_RGB ) || ( block_size == 4 && S3TC_type == GL_RGBA ) ) )
 				{
-					unsigned char temp = DDS_data[i];
-					DDS_data[i] = DDS_data[i+2];
-					DDS_data[i+2] = temp;
+					for( i = 0; i < (int)DDS_full_size; i += block_size )
+					{
+						unsigned char temp = DDS_data[i];
+						DDS_data[i] = DDS_data[i+2];
+						DDS_data[i+2] = temp;
+					}
+				} else if ( block_size == 2 &&
+							(header.sPixelFormat.dwRBitMask == 0xf800 || header.sPixelFormat.dwRBitMask == 0x7c00) )
+				{
+					// convert to R5G5B5A1
+					for( i = 0; i < (int)DDS_full_size; i += block_size )
+					{
+						unsigned short pixel = DDS_data[i] << 0 | DDS_data[i+1] << 8;
+						char r = ((pixel & header.sPixelFormat.dwRBitMask) >> 10);
+						char g = ((pixel & header.sPixelFormat.dwGBitMask) >> 5);
+						char b = ((pixel & header.sPixelFormat.dwBBitMask) >> 0);
+						char a = 1;
+						if ( header.sPixelFormat.dwAlphaBitMask != 0 ) {
+							a = (pixel & header.sPixelFormat.dwAlphaBitMask) >> 15;
+						}
+						unsigned short pixel_new = (r << 11) | (g << 6) | (b << 1) | a;
+						DDS_data[i] = (pixel_new >> 0) & 0xff;
+						DDS_data[i+1] = (pixel_new >> 8) & 0xff;
+					}
+				} else if ( block_size == 2 &&
+							(header.sPixelFormat.dwRBitMask == 0xf00) &&
+							(header.sPixelFormat.dwGBitMask == 0xf0) &&
+							(header.sPixelFormat.dwBBitMask == 0xf) &&
+							(header.sPixelFormat.dwAlphaBitMask == 0xf000))
+				{
+					for( i = 0; i < (int)DDS_full_size; i += block_size )
+					{
+						unsigned short pixel = DDS_data[i] << 0 | DDS_data[i+1] << 8;
+						char r = ((pixel & header.sPixelFormat.dwRBitMask) >> 8);
+						char g = ((pixel & header.sPixelFormat.dwGBitMask) >> 4);
+						char b = ((pixel & header.sPixelFormat.dwBBitMask) >> 0);
+						char a = ((pixel & header.sPixelFormat.dwAlphaBitMask) >> 12);
+						unsigned short pixel_new = (r << 12) | (g << 8) | (b << 4) | a;
+						DDS_data[i] = (pixel_new >> 0) & 0xff;
+						DDS_data[i+1] = (pixel_new >> 8) & 0xff;
+					}
 				}
 				glTexImage2D(
 					cf_target, 0,
 					S3TC_type, width, height, 0,
-					S3TC_type, GL_UNSIGNED_BYTE, DDS_data );
+					S3TC_type, format_type, DDS_data );
 			} else
 			{
 				soilGlCompressedTexImage2D(
@@ -1764,7 +2337,7 @@ unsigned int SOIL_direct_load_DDS_from_memory(
 					glTexImage2D(
 						cf_target, i,
 						S3TC_type, w, h, 0,
-						S3TC_type, GL_UNSIGNED_BYTE, &DDS_data[byte_offset] );
+						S3TC_type, format_type, &DDS_data[byte_offset] );
 				} else
 				{
 					mip_size = ((w+3)/4)*((h+3)/4)*block_size;
@@ -1809,8 +2382,8 @@ unsigned int SOIL_direct_load_DDS_from_memory(
 			glTexParameteri( opengl_texture_type, SOIL_TEXTURE_WRAP_R, GL_REPEAT );
 		} else
 		{
-			/*	unsigned int clamp_mode = SOIL_CLAMP_TO_EDGE;	*/
-			unsigned int clamp_mode = GL_CLAMP;
+			unsigned int clamp_mode = SOIL_CLAMP_TO_EDGE;
+			/* unsigned int clamp_mode = GL_CLAMP; */
 			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_S, clamp_mode );
 			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_T, clamp_mode );
 			glTexParameteri( opengl_texture_type, SOIL_TEXTURE_WRAP_R, clamp_mode );
@@ -1864,12 +2437,466 @@ unsigned int SOIL_direct_load_DDS(
 	}
 	/*	now try to do the loading	*/
 	tex_ID = SOIL_direct_load_DDS_from_memory(
-		(const unsigned char *const)buffer, buffer_length,
+		(const unsigned char *const)buffer, (int)buffer_length,
 		reuse_texture_ID, flags, loading_as_cubemap );
 	SOIL_free_image_data( buffer );
 	return tex_ID;
 }
 
+unsigned int SOIL_direct_load_PVR_from_memory(
+		const unsigned char *const buffer,
+		int buffer_length,
+		unsigned int reuse_texture_ID,
+		int flags,
+		int loading_as_cubemap )
+{
+	PVR_Texture_Header* header = (PVR_Texture_Header*)buffer;
+	int num_surfs = 1;
+	GLuint tex_ID = 0;
+	GLenum PVR_format = 0;
+	GLenum PVR_type = GL_RGB;
+	unsigned int opengl_texture_type = loading_as_cubemap ? SOIL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D;
+	int is_PVRTC_supported = query_PVR_capability() == SOIL_CAPABILITY_PRESENT;
+	int is_BGRA8888_supported  = query_BGRA8888_capability() == SOIL_CAPABILITY_PRESENT;
+	int is_compressed_format_supported = 0;
+	int is_compressed_format = 0;
+	int mipmaps = 0;
+	int i;
+	GLint unpack_aligment;
+
+	// Check the header size
+	if ( header->dwHeaderSize != sizeof(PVR_Texture_Header) ) {
+		if ( header->dwHeaderSize == PVRTEX_V1_HEADER_SIZE ) {
+			result_string_pointer = "this is an old pvr ( update the PVR file )";
+
+			if ( loading_as_cubemap ) {
+				if( header->dwpfFlags & PVRTEX_CUBEMAP ) {
+					num_surfs = 6;
+				} else {
+					result_string_pointer = "tried to load a non-cubemap PVR as cubemap";
+					return 0;
+				}
+			}
+		} else {
+			result_string_pointer = "invalid PVR header";
+
+			return 0;
+		}
+	} else {
+		if ( loading_as_cubemap ) {
+			// Header V2
+			if( header->dwNumSurfs < 1 ) {
+				if( header->dwpfFlags & PVRTEX_CUBEMAP ) {
+					num_surfs = 6;
+				} else {
+					result_string_pointer = "tried to load a non-cubemap PVR as cubemap";
+					return 0;
+				}
+			} else {
+				num_surfs = header->dwNumSurfs;
+			}
+		}
+	}
+
+	// Check the magic identifier
+	if ( header->dwPVR != PVRTEX_IDENTIFIER ) {
+		result_string_pointer = "invalid PVR header";
+		return 0;
+	}
+
+	/* Only accept untwiddled data UNLESS texture format is PVRTC */
+	if ( ((header->dwpfFlags & PVRTEX_TWIDDLE) == PVRTEX_TWIDDLE)
+		&& ((header->dwpfFlags & PVRTEX_PIXELTYPE)!=OGL_PVRTC2)
+		&& ((header->dwpfFlags & PVRTEX_PIXELTYPE)!=OGL_PVRTC4) )
+	{
+		// We need to load untwiddled textures -- hw will twiddle for us.
+		result_string_pointer = "pvr is not compressed ( untwiddled texture )";
+		return 0;
+	}
+
+	switch( header->dwpfFlags & PVRTEX_PIXELTYPE )
+	{
+		case OGL_RGBA_4444:
+			PVR_format = GL_UNSIGNED_SHORT_4_4_4_4;
+			PVR_type = GL_RGBA;
+			break;
+		case OGL_RGBA_5551:
+			PVR_format = GL_UNSIGNED_SHORT_5_5_5_1;
+			PVR_type = GL_RGBA;
+			break;
+		case OGL_RGBA_8888:
+			PVR_format = GL_UNSIGNED_BYTE;
+			PVR_type = GL_RGBA;
+			break;
+		case OGL_RGB_565:
+			PVR_format = GL_UNSIGNED_SHORT_5_6_5;
+			PVR_type = GL_RGB;
+			break;
+		case OGL_RGB_555:
+			result_string_pointer = "failed: pixel type OGL_RGB_555 not supported.";
+			return 0;
+		case OGL_RGB_888:
+			PVR_format = GL_UNSIGNED_BYTE;
+			PVR_type = GL_RGB;
+			break;
+		case OGL_I_8:
+			PVR_format = GL_UNSIGNED_BYTE;
+			PVR_type = GL_LUMINANCE;
+			break;
+		case OGL_AI_88:
+			PVR_format = GL_UNSIGNED_BYTE;
+			PVR_type = GL_LUMINANCE_ALPHA;
+			break;
+		case MGLPT_PVRTC2:
+		case OGL_PVRTC2:
+			if(is_PVRTC_supported) {
+				is_compressed_format_supported = is_compressed_format = 1;
+				PVR_format = header->dwAlphaBitMask==0 ? SOIL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG : SOIL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG ;	// PVRTC2
+			} else {
+				result_string_pointer = "error: PVRTC2 not supported.Decompress the texture first.";
+				return 0;
+			}
+			break;
+		case MGLPT_PVRTC4:
+		case OGL_PVRTC4:
+			if(is_PVRTC_supported) {
+				is_compressed_format_supported = is_compressed_format = 1;
+				PVR_format = header->dwAlphaBitMask==0 ? SOIL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG : SOIL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG ;	// PVRTC4
+			} else {
+				result_string_pointer = "error: PVRTC4 not supported. Decompress the texture first.";
+				return 0;
+			}
+			break;
+		case OGL_BGRA_8888:
+			if(is_BGRA8888_supported) {
+				PVR_format = GL_UNSIGNED_BYTE;
+				PVR_type   = GL_BGRA;
+				break;
+			} else {
+				result_string_pointer = "Unable to load GL_BGRA texture as extension GL_IMG_texture_format_BGRA8888 is unsupported.";
+				return 0;
+			}
+		default:											// NOT SUPPORTED
+			result_string_pointer = "failed: pixel type not supported.";
+			return 0;
+	}
+
+	#ifdef SOIL_GLES1
+	//  check that this data is cube map data or not.
+	if( loading_as_cubemap ) {
+		result_string_pointer = "cube map textures are not available in GLES1.x.";
+		return 0;
+	}
+	#endif
+
+	// load the texture up
+	tex_ID = reuse_texture_ID;
+	if( tex_ID == 0 )
+	{
+		glGenTextures( 1, &tex_ID );
+	}
+
+	glBindTexture( opengl_texture_type, tex_ID );
+
+	if( glGetError() ) {
+		result_string_pointer = "failed: glBindTexture() failed.";
+		return 0;
+	}
+
+	glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpack_aligment);
+	if ( 1 != unpack_aligment )
+	{
+		glPixelStorei(GL_UNPACK_ALIGNMENT,1);				// Never have row-aligned in headers
+	}
+
+	#define _MAX( a, b ) (( a <= b )? b : a)
+	for(i=0; i<num_surfs; i++) {
+		char *texture_ptr = (char*)buffer + header->dwHeaderSize + header->dwTextureDataSize * i;
+		char *cur_texture_ptr = 0;
+		int	mipmap_level;
+		unsigned int width= header->dwWidth, height = header->dwHeight;
+		unsigned int compressed_image_size = 0;
+
+		mipmaps = ( ( flags & SOIL_FLAG_MIPMAPS ) && (header->dwpfFlags & PVRTEX_MIPMAP) ) ? header->dwMipMapCount : 0;
+
+		for(mipmap_level = 0; mipmap_level <= mipmaps; width = _MAX(width/2, (unsigned int)1), height = _MAX(height/2, (unsigned int)1), mipmap_level++ ) {
+			// Do Alpha-swap if needed
+			cur_texture_ptr = texture_ptr;
+
+			// Load the Texture
+			/* If the texture is PVRTC then use GLCompressedTexImage2D */
+			if( is_compressed_format ) {
+				/* Calculate how many bytes this MIP level occupies */
+				if ((header->dwpfFlags & PVRTEX_PIXELTYPE)==OGL_PVRTC2) {
+					compressed_image_size = ( _MAX(width, PVRTC2_MIN_TEXWIDTH) * _MAX(height, PVRTC2_MIN_TEXHEIGHT) * header->dwBitCount + 7 ) / 8;
+				} else {// PVRTC4 case
+					compressed_image_size = ( _MAX(width, PVRTC4_MIN_TEXWIDTH) * _MAX(height, PVRTC4_MIN_TEXHEIGHT) * header->dwBitCount + 7 ) / 8;
+				}
+
+				if ( is_compressed_format_supported ) {
+					/* Load compressed texture data at selected MIP level */
+					if ( loading_as_cubemap ) {
+						soilGlCompressedTexImage2D( SOIL_TEXTURE_CUBE_MAP_POSITIVE_X + i, mipmap_level, PVR_format, width, height, 0, compressed_image_size, cur_texture_ptr );
+					} else {
+						soilGlCompressedTexImage2D( opengl_texture_type, mipmap_level, PVR_format, width, height, 0, compressed_image_size, cur_texture_ptr );
+					}
+				} else {
+					result_string_pointer = "failed: GPU doesnt support compressed textures";
+				}
+			} else {
+				/* Load uncompressed texture data at selected MIP level */
+				if ( loading_as_cubemap ) {
+					glTexImage2D( SOIL_TEXTURE_CUBE_MAP_POSITIVE_X + i, mipmap_level, PVR_type, width, height, 0, PVR_type, PVR_format, cur_texture_ptr );
+				} else {
+					glTexImage2D( opengl_texture_type, mipmap_level, PVR_type, width, height, 0, PVR_type, PVR_format, cur_texture_ptr );
+				}
+			}
+
+			if( glGetError() ) {
+				result_string_pointer = "failed: glCompressedTexImage2D() failed.";
+				if ( 1 != unpack_aligment )
+				{
+					glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_aligment);
+				}
+				return 0;
+			}
+
+			// offset the texture pointer by one mip-map level
+			/* PVRTC case */
+			if ( is_compressed_format ) {
+				texture_ptr += compressed_image_size;
+			} else {
+				/* New formula that takes into account bit counts inferior to 8 (e.g. 1 bpp) */
+				texture_ptr += (width * height * header->dwBitCount + 7) / 8;
+			}
+		}
+	}
+	#undef _MAX
+
+	if ( 1 != unpack_aligment )
+	{
+		glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_aligment);
+	}
+
+	if( tex_ID )
+	{
+		/*	did I have MIPmaps?	*/
+		if( mipmaps )
+		{
+			/*	instruct OpenGL to use the MIPmaps	*/
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
+		} else
+		{
+			/*	instruct OpenGL _NOT_ to use the MIPmaps	*/
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+		}
+
+		/*	does the user want clamping, or wrapping?	*/
+		if( flags & SOIL_FLAG_TEXTURE_REPEATS )
+		{
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_S, GL_REPEAT );
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_T, GL_REPEAT );
+			glTexParameteri( opengl_texture_type, SOIL_TEXTURE_WRAP_R, GL_REPEAT );
+		} else
+		{
+			unsigned int clamp_mode = SOIL_CLAMP_TO_EDGE;
+			/* unsigned int clamp_mode = GL_CLAMP; */
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_S, clamp_mode );
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_T, clamp_mode );
+			glTexParameteri( opengl_texture_type, SOIL_TEXTURE_WRAP_R, clamp_mode );
+		}
+	}
+
+	return tex_ID;
+}
+
+unsigned int SOIL_direct_load_PVR(
+		const char *filename,
+		unsigned int reuse_texture_ID,
+		int flags,
+		int loading_as_cubemap )
+{
+	FILE *f;
+	unsigned char *buffer;
+	size_t buffer_length, bytes_read;
+	unsigned int tex_ID = 0;
+	/*	error checks	*/
+	if( NULL == filename )
+	{
+		result_string_pointer = "NULL filename";
+		return 0;
+	}
+	f = fopen( filename, "rb" );
+	if( NULL == f )
+	{
+		/*	the file doesn't seem to exist (or be open-able)	*/
+		result_string_pointer = "Can not find PVR file";
+		return 0;
+	}
+	fseek( f, 0, SEEK_END );
+	buffer_length = ftell( f );
+	fseek( f, 0, SEEK_SET );
+	buffer = (unsigned char *) malloc( buffer_length );
+	if( NULL == buffer )
+	{
+		result_string_pointer = "malloc failed";
+		fclose( f );
+		return 0;
+	}
+	bytes_read = fread( (void*)buffer, 1, buffer_length, f );
+	fclose( f );
+	if( bytes_read < buffer_length )
+	{
+		/*	huh?	*/
+		buffer_length = bytes_read;
+	}
+	/*	now try to do the loading	*/
+	tex_ID = SOIL_direct_load_PVR_from_memory(
+		(const unsigned char *const)buffer, (int)buffer_length,
+		reuse_texture_ID, flags, loading_as_cubemap );
+	SOIL_free_image_data( buffer );
+	return tex_ID;
+}
+
+unsigned int SOIL_direct_load_ETC1_from_memory(
+		const unsigned char *const buffer,
+		int buffer_length,
+		unsigned int reuse_texture_ID,
+		int flags )
+{
+	GLuint tex_ID = 0;
+	PKMHeader* header = (PKMHeader*)buffer;
+	unsigned int opengl_texture_type = GL_TEXTURE_2D;
+	unsigned int width;
+	unsigned int height;
+	unsigned long compressed_image_size = buffer_length - PKM_HEADER_SIZE;
+	char *texture_ptr = (char*)buffer + PKM_HEADER_SIZE;
+	GLint unpack_aligment;
+
+	if ( query_ETC1_capability() != SOIL_CAPABILITY_PRESENT ) {
+		result_string_pointer = "error: ETC1 not supported. Decompress the texture first.";
+		return 0;
+	}
+
+	if ( 0 != strcmp( header->aName, "PKM 10" ) ) {
+		result_string_pointer = "error: PKM 10 header not found.";
+		return 0;
+	}
+
+	width = (header->iWidthMSB << 8) | header->iWidthLSB;
+	height = (header->iHeightMSB << 8) | header->iHeightLSB;
+	compressed_image_size = (((width + 3) & ~3) * ((height + 3) & ~3)) >> 1;
+
+	// load the texture up
+	tex_ID = reuse_texture_ID;
+	if( tex_ID == 0 )
+	{
+		glGenTextures( 1, &tex_ID );
+	}
+
+	glBindTexture( opengl_texture_type, tex_ID );
+
+	if( glGetError() ) {
+		result_string_pointer = "failed: glBindTexture() failed.";
+		return 0;
+	}
+
+	glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpack_aligment);
+	if ( 1 != unpack_aligment )
+	{
+		glPixelStorei(GL_UNPACK_ALIGNMENT,1);				// Never have row-aligned in headers
+	}
+
+	soilGlCompressedTexImage2D( opengl_texture_type, 0, SOIL_GL_ETC1_RGB8_OES, width, height, 0, compressed_image_size, texture_ptr );
+
+	if( glGetError() ) {
+		result_string_pointer = "failed: glCompressedTexImage2D() failed.";
+
+		if ( 1 != unpack_aligment )
+		{
+			glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_aligment);
+		}
+		return 0;
+	}
+
+	if ( 1 != unpack_aligment )
+	{
+		glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_aligment);
+	}
+
+	if( tex_ID )
+	{
+		/* No MIPmaps for ETC1 */
+		glTexParameteri( opengl_texture_type, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+		glTexParameteri( opengl_texture_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+
+		/*	does the user want clamping, or wrapping?	*/
+		if( flags & SOIL_FLAG_TEXTURE_REPEATS )
+		{
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_S, GL_REPEAT );
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_T, GL_REPEAT );
+			glTexParameteri( opengl_texture_type, SOIL_TEXTURE_WRAP_R, GL_REPEAT );
+		} else
+		{
+			unsigned int clamp_mode = SOIL_CLAMP_TO_EDGE;
+			/* unsigned int clamp_mode = GL_CLAMP; */
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_S, clamp_mode );
+			glTexParameteri( opengl_texture_type, GL_TEXTURE_WRAP_T, clamp_mode );
+			glTexParameteri( opengl_texture_type, SOIL_TEXTURE_WRAP_R, clamp_mode );
+		}
+	}
+
+	return tex_ID;
+}
+
+unsigned int SOIL_direct_load_ETC1(const char *filename,
+		unsigned int reuse_texture_ID,
+		int flags )
+{
+	FILE *f;
+	unsigned char *buffer;
+	size_t buffer_length, bytes_read;
+	unsigned int tex_ID = 0;
+	/*	error checks	*/
+	if( NULL == filename )
+	{
+		result_string_pointer = "NULL filename";
+		return 0;
+	}
+	f = fopen( filename, "rb" );
+	if( NULL == f )
+	{
+		/*	the file doesn't seem to exist (or be open-able)	*/
+		result_string_pointer = "Can not find PVR file";
+		return 0;
+	}
+	fseek( f, 0, SEEK_END );
+	buffer_length = ftell( f );
+	fseek( f, 0, SEEK_SET );
+	buffer = (unsigned char *) malloc( buffer_length );
+	if( NULL == buffer )
+	{
+		result_string_pointer = "malloc failed";
+		fclose( f );
+		return 0;
+	}
+	bytes_read = fread( (void*)buffer, 1, buffer_length, f );
+	fclose( f );
+	if( bytes_read < buffer_length )
+	{
+		/*	huh?	*/
+		buffer_length = bytes_read;
+	}
+	/*	now try to do the loading	*/
+	tex_ID = SOIL_direct_load_ETC1_from_memory(
+		(const unsigned char *const)buffer, (int)buffer_length,
+		reuse_texture_ID, flags );
+	SOIL_free_image_data( buffer );
+	return tex_ID;
+}
+
 int query_NPOT_capability( void )
 {
 	/*	check for the capability	*/
@@ -1877,8 +2904,11 @@ int query_NPOT_capability( void )
 	{
 		/*	we haven't yet checked for the capability, do so	*/
 		if(
-			(NULL == strstr( (char const*)glGetString( GL_EXTENSIONS ),
+			(0 == SOIL_GL_ExtensionSupported(
 				"GL_ARB_texture_non_power_of_two" ) )
+		&&
+			(0 == SOIL_GL_ExtensionSupported(
+				"GL_OES_texture_npot" ) )
 			)
 		{
 			/*	not there, flag the failure	*/
@@ -1888,6 +2918,10 @@ int query_NPOT_capability( void )
 			/*	it's there!	*/
 			has_NPOT_capability = SOIL_CAPABILITY_PRESENT;
 		}
+
+		#if defined( __emscripten__ ) || defined( EMSCRIPTEN )
+		has_NPOT_capability = SOIL_CAPABILITY_PRESENT;
+		#endif
 	}
 	/*	let the user know if we can do non-power-of-two textures or not	*/
 	return has_NPOT_capability;
@@ -1900,13 +2934,13 @@ int query_tex_rectangle_capability( void )
 	{
 		/*	we haven't yet checked for the capability, do so	*/
 		if(
-			(NULL == strstr( (char const*)glGetString( GL_EXTENSIONS ),
+			(0 == SOIL_GL_ExtensionSupported(
 				"GL_ARB_texture_rectangle" ) )
 		&&
-			(NULL == strstr( (char const*)glGetString( GL_EXTENSIONS ),
+			(0 == SOIL_GL_ExtensionSupported(
 				"GL_EXT_texture_rectangle" ) )
 		&&
-			(NULL == strstr( (char const*)glGetString( GL_EXTENSIONS ),
+			(0 == SOIL_GL_ExtensionSupported(
 				"GL_NV_texture_rectangle" ) )
 			)
 		{
@@ -1929,10 +2963,10 @@ int query_cubemap_capability( void )
 	{
 		/*	we haven't yet checked for the capability, do so	*/
 		if(
-			(NULL == strstr( (char const*)glGetString( GL_EXTENSIONS ),
+			(0 == SOIL_GL_ExtensionSupported(
 				"GL_ARB_texture_cube_map" ) )
 		&&
-			(NULL == strstr( (char const*)glGetString( GL_EXTENSIONS ),
+			(0 == SOIL_GL_ExtensionSupported(
 				"GL_EXT_texture_cube_map" ) )
 			)
 		{
@@ -1948,59 +2982,43 @@ int query_cubemap_capability( void )
 	return has_cubemap_capability;
 }
 
+static P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC get_glCompressedTexImage2D_addr()
+{
+	/*	and find the address of the extension function	*/
+	P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC ext_addr = NULL;
+	
+#if defined( SOIL_PLATFORM_WIN32 ) || defined( SOIL_PLATFORM_OSX ) || defined( SOIL_X11_PLATFORM )
+	ext_addr = (P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC)SOIL_GL_GetProcAddress( "glCompressedTexImage2D" );
+#else
+	ext_addr = (P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC)&glCompressedTexImage2D;
+#endif
+	
+	return ext_addr;
+}
+
 int query_DXT_capability( void )
 {
 	/*	check for the capability	*/
 	if( has_DXT_capability == SOIL_CAPABILITY_UNKNOWN )
 	{
 		/*	we haven't yet checked for the capability, do so	*/
-		if( NULL == strstr(
-				(char const*)glGetString( GL_EXTENSIONS ),
-				"GL_EXT_texture_compression_s3tc" ) )
+		if (	0 == SOIL_GL_ExtensionSupported(
+					"GL_EXT_texture_compression_s3tc" )  &&
+				0 == SOIL_GL_ExtensionSupported(
+					"WEBGL_compressed_texture_s3tc ") &&
+				0 == SOIL_GL_ExtensionSupported(
+					"WEBKIT_WEBGL_compressed_texture_s3tc") &&
+				0 == SOIL_GL_ExtensionSupported(
+					"MOZ_WEBGL_compressed_texture_s3tc"
+				)
+			)
 		{
 			/*	not there, flag the failure	*/
 			has_DXT_capability = SOIL_CAPABILITY_NONE;
 		} else
 		{
-			/*	and find the address of the extension function	*/
-			P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC ext_addr = NULL;
-			#ifdef WIN32
-				ext_addr = (P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC)
-						wglGetProcAddress
-						(
-							"glCompressedTexImage2DARB"
-						);
-			#elif defined(__APPLE__) || defined(__APPLE_CC__)
-				/*	I can't test this Apple stuff!	*/
-				CFBundleRef bundle;
-				CFURLRef bundleURL =
-					CFURLCreateWithFileSystemPath(
-						kCFAllocatorDefault,
-						CFSTR("/System/Library/Frameworks/OpenGL.framework"),
-						kCFURLPOSIXPathStyle,
-						true );
-				CFStringRef extensionName =
-					CFStringCreateWithCString(
-						kCFAllocatorDefault,
-						"glCompressedTexImage2DARB",
-						kCFStringEncodingASCII );
-				bundle = CFBundleCreate( kCFAllocatorDefault, bundleURL );
-				assert( bundle != NULL );
-				ext_addr = (P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC)
-						CFBundleGetFunctionPointerForName
-						(
-							bundle, extensionName
-						);
-				CFRelease( bundleURL );
-				CFRelease( extensionName );
-				CFRelease( bundle );
-			#else
-				ext_addr = (P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC)
-						glXGetProcAddressARB
-						(
-							(const GLubyte *)"glCompressedTexImage2DARB"
-						);
-			#endif
+			P_SOIL_GLCOMPRESSEDTEXIMAGE2DPROC ext_addr = get_glCompressedTexImage2D_addr();
+
 			/*	Flag it so no checks needed later	*/
 			if( NULL == ext_addr )
 			{
@@ -2022,3 +3040,158 @@ int query_DXT_capability( void )
 	/*	let the user know if we can do DXT or not	*/
 	return has_DXT_capability;
 }
+
+int query_PVR_capability( void )
+{
+	/*	check for the capability	*/
+	if( has_PVR_capability == SOIL_CAPABILITY_UNKNOWN )
+	{
+		/*	we haven't yet checked for the capability, do so	*/
+		if (0 == SOIL_GL_ExtensionSupported(
+				"GL_IMG_texture_compression_pvrtc" ) )
+		{
+			/*	not there, flag the failure	*/
+			has_PVR_capability = SOIL_CAPABILITY_NONE;
+		} else
+		{
+			if ( NULL == soilGlCompressedTexImage2D ) {
+				soilGlCompressedTexImage2D = get_glCompressedTexImage2D_addr();
+			}
+			
+			/*	it's there!	*/
+			has_PVR_capability = SOIL_CAPABILITY_PRESENT;
+		}
+	}
+	/*	let the user know if we can do cubemaps or not	*/
+	return has_PVR_capability;
+}
+
+int query_BGRA8888_capability( void )
+{
+	/*	check for the capability	*/
+	if( has_BGRA8888_capability == SOIL_CAPABILITY_UNKNOWN )
+	{
+		/*	we haven't yet checked for the capability, do so	*/
+		if (0 == SOIL_GL_ExtensionSupported(
+				"GL_IMG_texture_format_BGRA8888" ) )
+		{
+			/*	not there, flag the failure	*/
+			has_BGRA8888_capability = SOIL_CAPABILITY_NONE;
+		} else
+		{
+			/*	it's there!	*/
+			has_BGRA8888_capability = SOIL_CAPABILITY_PRESENT;
+		}
+	}
+	/*	let the user know if we can do cubemaps or not	*/
+	return has_BGRA8888_capability;
+}
+
+int query_sRGB_capability( void )
+{
+	if ( has_sRGB_capability == SOIL_CAPABILITY_UNKNOWN )
+	{
+		if (0 == SOIL_GL_ExtensionSupported(
+				"GL_EXT_texture_sRGB" )
+				&&
+			0 == SOIL_GL_ExtensionSupported(
+				"GL_EXT_sRGB" )
+				&&
+			0 == SOIL_GL_ExtensionSupported(
+				"EXT_sRGB" ) )
+		{
+			has_sRGB_capability = SOIL_CAPABILITY_NONE;
+		} else
+		{
+			has_sRGB_capability = SOIL_CAPABILITY_PRESENT;
+		}
+	}
+
+	return has_sRGB_capability;
+}
+
+int query_ETC1_capability( void )
+{
+	/*	check for the capability	*/
+	if( has_ETC1_capability == SOIL_CAPABILITY_UNKNOWN )
+	{
+		/*	we haven't yet checked for the capability, do so	*/
+		if (0 == SOIL_GL_ExtensionSupported(
+				"GL_OES_compressed_ETC1_RGB8_texture" ) )
+		{
+			/*	not there, flag the failure	*/
+			has_ETC1_capability = SOIL_CAPABILITY_NONE;
+		} else
+		{
+			if ( NULL == soilGlCompressedTexImage2D ) {
+				soilGlCompressedTexImage2D = get_glCompressedTexImage2D_addr();
+			}
+
+			/*	it's there!	*/
+			has_ETC1_capability = SOIL_CAPABILITY_PRESENT;
+		}
+	}
+	/*	let the user know if we can do cubemaps or not	*/
+	return has_ETC1_capability;
+}
+
+int query_gen_mipmap_capability( void )
+{
+	/* check for the capability   */
+	P_SOIL_GLGENERATEMIPMAPPROC ext_addr = NULL;
+
+	if( has_gen_mipmap_capability == SOIL_CAPABILITY_UNKNOWN )
+	{
+		if (	0 == SOIL_GL_ExtensionSupported(
+					"GL_ARB_framebuffer_object" )
+			&&
+				0 == SOIL_GL_ExtensionSupported(
+					"GL_EXT_framebuffer_object" )
+			&&  0 == SOIL_GL_ExtensionSupported(
+					"GL_OES_framebuffer_object" )
+			)
+		{
+			/* not there, flag the failure */
+			has_gen_mipmap_capability = SOIL_CAPABILITY_NONE;
+		}
+		else
+		{
+			#if !defined( SOIL_GLES1 ) && !defined( SOIL_GLES2 )
+
+			ext_addr = (P_SOIL_GLGENERATEMIPMAPPROC)SOIL_GL_GetProcAddress("glGenerateMipmap");
+
+			if(ext_addr == NULL)
+			{
+				ext_addr = (P_SOIL_GLGENERATEMIPMAPPROC)SOIL_GL_GetProcAddress("glGenerateMipmapEXT");
+			}
+
+			#elif !defined( SOIL_NO_EGL )
+
+			ext_addr = (P_SOIL_GLGENERATEMIPMAPPROC)SOIL_GL_GetProcAddress("glGenerateMipmapOES");
+
+			if(ext_addr == NULL)
+			{
+				ext_addr = (P_SOIL_GLGENERATEMIPMAPPROC)SOIL_GL_GetProcAddress("glGenerateMipmap");
+			}
+
+			#elif defined( SOIL_GLES2 )
+				ext_addr = 	&glGenerateMipmap;
+			#else /** SOIL_GLES1 */
+				ext_addr = &glGenerateMipmapOES;
+			#endif
+		}
+
+		if(ext_addr == NULL)
+		{
+			/* this should never happen */
+			has_gen_mipmap_capability = SOIL_CAPABILITY_NONE;
+		} else
+		{
+			/* it's there! */
+			has_gen_mipmap_capability = SOIL_CAPABILITY_PRESENT;
+			soilGlGenerateMipmap = ext_addr;
+		}
+	}
+
+	return has_gen_mipmap_capability;
+}
diff --git a/4dm.h/soil/SOIL.h b/4dm.h/soil/SOIL2.h
similarity index 84%
rename from 4dm.h/soil/SOIL.h
rename to 4dm.h/soil/SOIL2.h
index 43f634f..eace403 100644
--- a/4dm.h/soil/SOIL.h
+++ b/4dm.h/soil/SOIL2.h
@@ -1,10 +1,12 @@
 /**
-	@mainpage SOIL
+	@mainpage SOIL2
 
-	Jonathan Dummer
+	Fork by Martin Lucas Golini
+	
+	Original author Jonathan Dummer
 	2007-07-26-10.36
 
-	Simple OpenGL Image Library
+	Simple OpenGL Image Library 2
 
 	A tiny c library for uploading images as
 	textures into OpenGL.  Also saving and
@@ -21,8 +23,11 @@
 	- BMP		load & save
 	- TGA		load & save
 	- DDS		load & save
-	- PNG		load
-	- JPG		load
+	- PNG		load & save
+	- JPG		load & save
+	- PSD		load
+	- HDR		load
+	- PIC		load
 
 	OpenGL Texture Features:
 	- resample to power-of-two sizes
@@ -87,10 +92,11 @@ enum
 	SOIL_FLAG_MULTIPLY_ALPHA: for using (GL_ONE,GL_ONE_MINUS_SRC_ALPHA) blending
 	SOIL_FLAG_INVERT_Y: flip the image vertically
 	SOIL_FLAG_COMPRESS_TO_DXT: if the card can display them, will convert RGB to DXT1, RGBA to DXT5
-	SOIL_FLAG_DDS_LOAD_DIRECT: will load DDS files directly without _ANY_ additional processing
+	SOIL_FLAG_DDS_LOAD_DIRECT: will load DDS files directly without _ANY_ additional processing ( if supported )
 	SOIL_FLAG_NTSC_SAFE_RGB: clamps RGB components to the range [16,235]
 	SOIL_FLAG_CoCg_Y: Google YCoCg; RGB=>CoYCg, RGBA=>CoCgAY
 	SOIL_FLAG_TEXTURE_RECTANGE: uses ARB_texture_rectangle ; pixel indexed & no repeat or MIPmaps or cubemaps
+	SOIL_FLAG_PVR_LOAD_DIRECT: will load PVR files directly without _ANY_ additional processing ( if supported )
 **/
 enum
 {
@@ -103,7 +109,11 @@ enum
 	SOIL_FLAG_DDS_LOAD_DIRECT = 64,
 	SOIL_FLAG_NTSC_SAFE_RGB = 128,
 	SOIL_FLAG_CoCg_Y = 256,
-	SOIL_FLAG_TEXTURE_RECTANGLE = 512
+	SOIL_FLAG_TEXTURE_RECTANGLE = 512,
+	SOIL_FLAG_PVR_LOAD_DIRECT = 1024,
+	SOIL_FLAG_ETC1_LOAD_DIRECT = 2048,
+	SOIL_FLAG_GL_MIPMAPS = 4096,
+	SOIL_FLAG_SRGB_COLOR_SPACE = 8192
 };
 
 /**
@@ -111,12 +121,15 @@ enum
 	(TGA supports uncompressed RGB / RGBA)
 	(BMP supports uncompressed RGB)
 	(DDS supports DXT1 and DXT5)
+	(PNG supports RGB / RGBA)
 **/
 enum
 {
 	SOIL_SAVE_TYPE_TGA = 0,
 	SOIL_SAVE_TYPE_BMP = 1,
-	SOIL_SAVE_TYPE_DDS = 2
+	SOIL_SAVE_TYPE_PNG = 2,
+	SOIL_SAVE_TYPE_DDS = 3,
+	SOIL_SAVE_TYPE_JPG = 4
 };
 
 /**
@@ -305,8 +318,8 @@ unsigned int
 	Creates a 2D OpenGL texture from raw image data.  Note that the raw data is
 	_NOT_ freed after the upload (so the user can load various versions).
 	\param data the raw data to be uploaded as an OpenGL texture
-	\param width the width of the image in pixels
-	\param height the height of the image in pixels
+	\param width the pointer of the width of the image in pixels ( if the texture size change, width will be overrided with the new width )
+	\param height the pointer of the height of the image in pixels ( if the texture size change, height will be overrided with the new height )
 	\param channels the number of channels: 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
 	\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
 	\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT
@@ -316,7 +329,7 @@ unsigned int
 	SOIL_create_OGL_texture
 	(
 		const unsigned char *const data,
-		int width, int height, int channels,
+		int *width, int *height, int channels,
 		unsigned int reuse_texture_ID,
 		unsigned int flags
 	);
@@ -392,8 +405,19 @@ unsigned char*
 
 /**
 	Saves an image from an array of unsigned chars (RGBA) to disk
+	\param quality parameter only used for SOIL_SAVE_TYPE_JPG files, values accepted between 0 and 100.
 	\return 0 if failed, otherwise returns 1
 **/
+int
+	SOIL_save_image_quality
+	(
+		const char *filename,
+		int image_type,
+		int width, int height, int channels,
+		const unsigned char *const data,
+		int quality
+	);
+
 int
 	SOIL_save_image
 	(
@@ -425,6 +449,60 @@ const char*
 		void
 	);
 
+/** @return The address of the GL function proc, or NULL if the function is not found. */
+void *
+	SOIL_GL_GetProcAddress
+	(
+		const char *proc
+	);
+
+/** @return 1 if an OpenGL extension is supported for the current context, 0 otherwise. */
+int
+	SOIL_GL_ExtensionSupported
+	(
+		const char *extension
+	);
+
+/** Loads the DDS texture directly to the GPU memory ( if supported ) */
+unsigned int SOIL_direct_load_DDS(
+		const char *filename,
+		unsigned int reuse_texture_ID,
+		int flags,
+		int loading_as_cubemap );
+
+/** Loads the DDS texture directly to the GPU memory ( if supported ) */
+unsigned int SOIL_direct_load_DDS_from_memory(
+		const unsigned char *const buffer,
+		int buffer_length,
+		unsigned int reuse_texture_ID,
+		int flags,
+		int loading_as_cubemap );
+
+/** Loads the PVR texture directly to the GPU memory ( if supported ) */
+unsigned int SOIL_direct_load_PVR(
+		const char *filename,
+		unsigned int reuse_texture_ID,
+		int flags,
+		int loading_as_cubemap );
+
+/** Loads the PVR texture directly to the GPU memory ( if supported ) */
+unsigned int SOIL_direct_load_PVR_from_memory(
+		const unsigned char *const buffer,
+		int buffer_length,
+		unsigned int reuse_texture_ID,
+		int flags,
+		int loading_as_cubemap );
+
+/** Loads the PVR texture directly to the GPU memory ( if supported ) */
+unsigned int SOIL_direct_load_ETC1(const char *filename,
+		unsigned int reuse_texture_ID,
+		int flags );
+
+/** Loads the PVR texture directly to the GPU memory ( if supported ) */
+unsigned int SOIL_direct_load_ETC1_from_memory(const unsigned char *const buffer,
+		int buffer_length,
+		unsigned int reuse_texture_ID,
+		int flags );
 
 #ifdef __cplusplus
 }
diff --git a/4dm.h/soil/image_DXT.h b/4dm.h/soil/image_DXT.h
index 75f604f..7bae19b 100644
--- a/4dm.h/soil/image_DXT.h
+++ b/4dm.h/soil/image_DXT.h
@@ -102,6 +102,7 @@ DDS_header ;
 #define DDPF_ALPHAPIXELS	0x00000001
 #define DDPF_FOURCC	0x00000004
 #define DDPF_RGB	0x00000040
+#define DDPF_LUMINANCE 0x20000
 
 /*	The dwCaps1 member of the DDSCAPS2 structure can be
 	set to one or more of the following values.	*/
diff --git a/4dm.h/soil/image_helper.c b/4dm.h/soil/image_helper.c
index d22340f..12c701e 100644
--- a/4dm.h/soil/image_helper.c
+++ b/4dm.h/soil/image_helper.c
@@ -322,7 +322,7 @@ find_max_RGBE
 	for( i = width * height; i > 0; --i )
 	{
 		/* float scale = powf( 2.0f, img[3] - 128.0f ) / 255.0f; */
-		float scale = ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
+		float scale = (float)ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
 		for( j = 0; j < 3; ++j )
 		{
 			if( img[j] * scale > max_val )
@@ -363,14 +363,14 @@ RGBE_to_RGBdivA
 		/* decode this pixel, and find the max */
 		float r,g,b,e, m;
 		/* e = scale * powf( 2.0f, img[3] - 128.0f ) / 255.0f; */
-		e = scale * ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
+		e = scale * (float)ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
 		r = e * img[0];
 		g = e * img[1];
 		b = e * img[2];
 		m = (r > g) ? r : g;
 		m = (b > m) ? b : m;
 		/* and encode it into RGBdivA */
-		iv = (m != 0.0f) ? (int)(255.0f / m) : 1.0f;
+		iv = (m != 0.0f) ? (int)(255.0f / m) : 1;
 		iv = (iv < 1) ? 1 : iv;
 		img[3] = (iv > 255) ? 255 : iv;
 		iv = (int)(img[3] * r + 0.5f);
@@ -412,14 +412,14 @@ RGBE_to_RGBdivA2
 		/* decode this pixel, and find the max */
 		float r,g,b,e, m;
 		/* e = scale * powf( 2.0f, img[3] - 128.0f ) / 255.0f; */
-		e = scale * ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
+		e = scale * (float)ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
 		r = e * img[0];
 		g = e * img[1];
 		b = e * img[2];
 		m = (r > g) ? r : g;
 		m = (b > m) ? b : m;
 		/* and encode it into RGBdivA */
-		iv = (m != 0.0f) ? (int)sqrtf( 255.0f * 255.0f / m ) : 1.0f;
+		iv = (m != 0.0f) ? (int)sqrtf( 255.0f * 255.0f / m ) : 1;
 		iv = (iv < 1) ? 1 : iv;
 		img[3] = (iv > 255) ? 255 : iv;
 		iv = (int)(img[3] * img[3] * r / 255.0f + 0.5f);
diff --git a/4dm.h/soil/jo_jpeg.h b/4dm.h/soil/jo_jpeg.h
new file mode 100644
index 0000000..353300b
--- /dev/null
+++ b/4dm.h/soil/jo_jpeg.h
@@ -0,0 +1,340 @@
+/* public domain Simple, Minimalistic JPEG writer - http://jonolick.com
+ *
+ * Quick Notes:
+ * 	Based on a javascript jpeg writer
+ * 	JPEG baseline (no JPEG progressive)
+ * 	Supports 1, 3 or 4 component input. (luminance, RGB or RGBX)
+ *
+ * Latest revisions:
+ *	1.53 (2016-07-08) Added support to compile as plain C code.
+ *	1.52 (2012-22-11) Added support for specifying Luminance, RGB, or RGBA via comp(onents) argument (1, 3 and 4 respectively). 
+ *	1.51 (2012-19-11) Fixed some warnings
+ *	1.50 (2012-18-11) MT safe. Simplified. Optimized. Reduced memory requirements. Zero allocations. No namespace polution. Approx 340 lines code.
+ *	1.10 (2012-16-11) compile fixes, added docs,
+ *		changed from .h to .cpp (simpler to bootstrap), etc
+ * 	1.00 (2012-02-02) initial release
+ *
+ * Basic usage:
+ *	char *foo = new char[128*128*4]; // 4 component. RGBX format, where X is unused 
+ *	jo_write_jpg("foo.jpg", foo, 128, 128, 4, 90); // comp can be 1, 3, or 4. Lum, RGB, or RGBX respectively.
+ * 	
+ * */
+
+#ifndef JO_INCLUDE_JPEG_H
+#define JO_INCLUDE_JPEG_H
+
+// To get a header file for this, either cut and paste the header,
+// or create jo_jpeg.h, #define JO_JPEG_HEADER_FILE_ONLY, and
+// then include jo_jpeg.c from it.
+
+// Returns false on failure
+extern int jo_write_jpg(const char *filename, const void *data, int width, int height, int comp, int quality);
+
+#endif // JO_INCLUDE_JPEG_H
+
+#ifndef JO_JPEG_HEADER_FILE_ONLY
+
+#if defined(_MSC_VER) && _MSC_VER >= 0x1400
+#define _CRT_SECURE_NO_WARNINGS // suppress warnings about fopen()
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+static const unsigned char s_jo_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 jo_writeBits(FILE *fp, int *bitBuf, int *bitCnt, const unsigned short *bs) {
+	*bitCnt += bs[1];
+	*bitBuf |= bs[0] << (24 - *bitCnt);
+	while(*bitCnt >= 8) {
+		unsigned char c = (*bitBuf >> 16) & 255;
+		putc(c, fp);
+		if(c == 255) {
+			putc(0, fp);
+		}
+		*bitBuf <<= 8;
+		*bitCnt -= 8;
+	}
+}
+
+static void jo_DCT(float *d0, float *d1, float *d2, float *d3, float *d4, float *d5, float *d6, float *d7) {
+	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;
+
+	float 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.
+	float z5 = (tmp10 - tmp12) * 0.382683433f; // c6
+	float z2 = tmp10 * 0.541196100f + z5; // c2-c6
+	float z4 = tmp12 * 1.306562965f + z5; // c2+c6
+	float z3 = tmp11 * 0.707106781f; // c4
+
+	float z11 = tmp7 + z3;		// phase 5
+	float z13 = tmp7 - z3;
+
+	*d5 = z13 + z2;			// phase 6
+	*d3 = z13 - z2;
+	*d1 = z11 + z4;
+	*d7 = z11 - z4;
+} 
+
+static void jo_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 jo_processDU(FILE *fp, 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, nrmarker;
+	
+	// DCT rows
+	for(dataOff=0; dataOff<64; dataOff+=8) {
+		jo_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) {
+		jo_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
+	int DU[64];
+	for(i=0; i<64; ++i) {
+		float v = CDU[i]*fdtbl[i];
+		DU[s_jo_ZigZag[i]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));
+	}
+
+	// Encode DC
+	int diff = DU[0] - DC; 
+	if (diff == 0) {
+		jo_writeBits(fp, bitBuf, bitCnt, HTDC[0]);
+	} else {
+		unsigned short bits[2];
+		jo_calcBits(diff, bits);
+		jo_writeBits(fp, bitBuf, bitCnt, HTDC[bits[1]]);
+		jo_writeBits(fp, bitBuf, bitCnt, bits);
+	}
+	// Encode ACs
+	int end0pos = 63;
+	for(; (end0pos>0)&&(DU[end0pos]==0); --end0pos) {
+	}
+	// end0pos = first element in reverse order !=0
+	if(end0pos == 0) {
+		jo_writeBits(fp, bitBuf, bitCnt, EOB);
+		return DU[0];
+	}
+	for(i = 1; i <= end0pos; ++i) {
+		int startpos = i;
+		for (; DU[i]==0 && i<=end0pos; ++i) {
+		}
+		int nrzeroes = i-startpos;
+		if ( nrzeroes >= 16 ) {
+			int lng = nrzeroes>>4;
+			for (nrmarker=1; nrmarker <= lng; ++nrmarker)
+				jo_writeBits(fp, bitBuf, bitCnt, M16zeroes);
+			nrzeroes &= 15;
+		}
+		unsigned short bits[2];
+		jo_calcBits(DU[i], bits);
+		jo_writeBits(fp, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]);
+		jo_writeBits(fp, bitBuf, bitCnt, bits);
+	}
+	if(end0pos != 63) {
+		jo_writeBits(fp, bitBuf, bitCnt, EOB);
+	}
+	return DU[0];
+}
+
+int jo_write_jpg(const char *filename, const void *data, int width, int height, int comp, 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 i, row, col, x, y, k, pos;
+	
+	if(!data || !filename || !width || !height || comp > 4 || comp < 1 || comp == 2) {
+		return 0;
+	}
+
+	FILE *fp = fopen(filename, "wb");
+	if(!fp) {
+		return 0;
+	}
+
+	quality = quality ? quality : 90;
+	quality = quality < 1 ? 1 : quality > 100 ? 100 : quality;
+	quality = quality < 50 ? 5000 / quality : 200 - quality * 2;
+
+	unsigned char YTable[64], UVTable[64];
+	for(i = 0; i < 64; ++i) {
+		int yti = (YQT[i]*quality+50)/100;
+		YTable[s_jo_ZigZag[i]] = yti < 1 ? 1 : yti > 255 ? 255 : yti;
+		int uvti  = (UVQT[i]*quality+50)/100;
+		UVTable[s_jo_ZigZag[i]] = uvti < 1 ? 1 : uvti > 255 ? 255 : uvti;
+	}
+
+	float fdtbl_Y[64], fdtbl_UV[64];
+	for(row = 0, k = 0; row < 8; ++row) {
+		for(col = 0; col < 8; ++col, ++k) {
+			fdtbl_Y[k]  = 1 / (YTable [s_jo_ZigZag[k]] * aasf[row] * aasf[col]);
+			fdtbl_UV[k] = 1 / (UVTable[s_jo_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 };
+	fwrite(head0, sizeof(head0), 1, fp);
+	fwrite(YTable, sizeof(YTable), 1, fp);
+	putc(1, fp);
+	fwrite(UVTable, sizeof(UVTable), 1, fp);
+	const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),(unsigned char)(height&0xFF),(unsigned char)(width>>8),(unsigned char)(width&0xFF),3,1,0x11,0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 };
+	fwrite(head1, sizeof(head1), 1, fp);
+	fwrite(std_dc_luminance_nrcodes+1, sizeof(std_dc_luminance_nrcodes)-1, 1, fp);
+	fwrite(std_dc_luminance_values, sizeof(std_dc_luminance_values), 1, fp);
+	putc(0x10, fp); // HTYACinfo
+	fwrite(std_ac_luminance_nrcodes+1, sizeof(std_ac_luminance_nrcodes)-1, 1, fp);
+	fwrite(std_ac_luminance_values, sizeof(std_ac_luminance_values), 1, fp);
+	putc(1, fp); // HTUDCinfo
+	fwrite(std_dc_chrominance_nrcodes+1, sizeof(std_dc_chrominance_nrcodes)-1, 1, fp);
+	fwrite(std_dc_chrominance_values, sizeof(std_dc_chrominance_values), 1, fp);
+	putc(0x11, fp); // HTUACinfo
+	fwrite(std_ac_chrominance_nrcodes+1, sizeof(std_ac_chrominance_nrcodes)-1, 1, fp);
+	fwrite(std_ac_chrominance_values, sizeof(std_ac_chrominance_values), 1, fp);
+	static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 };
+	fwrite(head2, sizeof(head2), 1, fp);
+
+	// Encode 8x8 macroblocks
+	const unsigned char *imageData = (const unsigned char *)data;
+	int DCY=0, DCU=0, DCV=0;
+	int bitBuf=0, bitCnt=0;
+	int ofsG = comp > 1 ? 1 : 0, ofsB = comp > 1 ? 2 : 0;
+	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) {
+				for(col = x; col < x+8; ++col, ++pos) {
+					int p = row*width*comp + col*comp;
+					if(row >= height) {
+						p -= width*comp*(row+1 - height);
+					}
+					if(col >= width) {
+						p -= comp*(col+1 - width);
+					}
+
+					float 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 = jo_processDU(fp, &bitBuf, &bitCnt, YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+			DCU = jo_processDU(fp, &bitBuf, &bitCnt, UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
+			DCV = jo_processDU(fp, &bitBuf, &bitCnt, VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
+		}
+	}
+	
+	// Do the bit alignment of the EOI marker
+	static const unsigned short fillBits[] = {0x7F, 7};
+	jo_writeBits(fp, &bitBuf, &bitCnt, fillBits);
+
+	// EOI
+	putc(0xFF, fp);
+	putc(0xD9, fp);
+
+	fclose(fp);
+	return 1;
+}
+
+#endif
+
diff --git a/4dm.h/soil/libSOIL.a b/4dm.h/soil/libSOIL.a
deleted file mode 100644
index bd18523..0000000
Binary files a/4dm.h/soil/libSOIL.a and /dev/null differ
diff --git a/4dm.h/soil/original/stb_image-1.09.c b/4dm.h/soil/original/stb_image-1.09.c
deleted file mode 100644
index ee848ad..0000000
--- a/4dm.h/soil/original/stb_image-1.09.c
+++ /dev/null
@@ -1,3632 +0,0 @@
-/* stbi-1.09 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
-                      when you control the images you're loading
-
-   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, no oddball channel decimations)
-      PNG non-interlaced
-      BMP non-1bpp, non-RLE
-      TGA (not sure what subset, if a subset)
-      PSD (composited view only, no extra channels)
-      HDR (radiance rgbE format)
-      writes BMP,TGA (define STBI_NO_WRITE to remove code)
-      decoded from memory or through stdio FILE (define STBI_NO_STDIO to remove code)
-        
-   TODO:
-      stbi_info_*
-  
-   history:
-      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
-*/
-
-
-////   begin header file  ////////////////////////////////////////////////////
-//
-// Limitations:
-//    - no progressive/interlaced support (jpeg, png)
-//    - 8-bit samples only (jpeg, png)
-//    - not threadsafe
-//    - channel subsampling of at most 2 in each dimension (jpeg)
-//    - no delayed line count (jpeg) -- IJG doesn't support either
-//
-// 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
-//    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 and BMP images are automatically depalettized.
-//
-//
-// ===========================================================================
-//
-// 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);
-
-
-#ifndef STBI_NO_STDIO
-#include <stdio.h>
-#endif
-
-#ifndef STBI_NO_HDR
-#include <math.h>  // ldexp
-#include <string.h> // strcmp
-#endif
-
-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
-
-// WRITING API
-
-#if !defined(STBI_NO_WRITE) && !defined(STBI_NO_STDIO)
-// write a BMP/TGA file given tightly packed 'comp' channels (no padding, nor bmp-stride-padding)
-// (you must include the appropriate extension in the filename).
-// returns TRUE on success, FALSE if couldn't open file, error writing file
-extern int      stbi_write_bmp       (char *filename,           int x, int y, int comp, void *data);
-extern int      stbi_write_tga       (char *filename,           int x, int y, int comp, void *data);
-#endif
-
-// PRIMARY API - works on images of any type
-
-// load image by filename, open file, or memory buffer
-#ifndef STBI_NO_STDIO
-extern stbi_uc *stbi_load            (char *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);
-extern int      stbi_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-#endif
-extern stbi_uc *stbi_load_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);
-// for stbi_load_from_file, file pointer is left pointing immediately after image
-
-#ifndef STBI_NO_HDR
-#ifndef STBI_NO_STDIO
-extern float *stbi_loadf            (char *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_memory(stbi_uc *buffer, int len, 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
-
-// get a VERY brief reason for failure
-extern 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 *buffer, int len, int *x, int *y, int *comp);
-extern int      stbi_is_hdr_from_memory(stbi_uc *buffer, int len);
-#ifndef STBI_NO_STDIO
-extern int      stbi_info            (char *filename,           int *x, int *y, int *comp);
-extern int      stbi_is_hdr          (char *filename);
-extern int      stbi_is_hdr_from_file(FILE *f);
-#endif
-
-// ZLIB client - used by PNG, available for other purposes
-
-extern char *stbi_zlib_decode_malloc_guesssize(int initial_size, int *outlen);
-extern char *stbi_zlib_decode_malloc(char *buffer, int len, int *outlen);
-extern int   stbi_zlib_decode_buffer(char *obuffer, int olen, char *ibuffer, int ilen);
-
-extern char *stbi_zlib_decode_noheader_malloc(char *buffer, int len, int *outlen);
-extern int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, char *ibuffer, int ilen);
-
-
-// TYPE-SPECIFIC ACCESS
-
-// is it a jpeg?
-extern int      stbi_jpeg_test_memory     (stbi_uc *buffer, int len);
-extern stbi_uc *stbi_jpeg_load_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);
-extern int      stbi_jpeg_info_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp);
-
-#ifndef STBI_NO_STDIO
-extern stbi_uc *stbi_jpeg_load            (char *filename,           int *x, int *y, int *comp, int req_comp);
-extern int      stbi_jpeg_test_file       (FILE *f);
-extern stbi_uc *stbi_jpeg_load_from_file  (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-
-extern int      stbi_jpeg_info            (char *filename,           int *x, int *y, int *comp);
-extern int      stbi_jpeg_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-#endif
-
-extern int      stbi_jpeg_dc_only; // only decode DC component
-
-// is it a png?
-extern int      stbi_png_test_memory      (stbi_uc *buffer, int len);
-extern stbi_uc *stbi_png_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);
-extern int      stbi_png_info_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp);
-
-#ifndef STBI_NO_STDIO
-extern stbi_uc *stbi_png_load             (char *filename,           int *x, int *y, int *comp, int req_comp);
-extern int      stbi_png_info             (char *filename,           int *x, int *y, int *comp);
-extern int      stbi_png_test_file        (FILE *f);
-extern stbi_uc *stbi_png_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-extern int      stbi_png_info_from_file   (FILE *f,                  int *x, int *y, int *comp);
-#endif
-
-// is it a bmp?
-extern int      stbi_bmp_test_memory      (stbi_uc *buffer, int len);
-
-extern stbi_uc *stbi_bmp_load             (char *filename,           int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_bmp_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_bmp_test_file        (FILE *f);
-extern stbi_uc *stbi_bmp_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// is it a tga?
-extern int      stbi_tga_test_memory      (stbi_uc *buffer, int len);
-
-extern stbi_uc *stbi_tga_load             (char *filename,           int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_tga_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_tga_test_file        (FILE *f);
-extern stbi_uc *stbi_tga_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// is it a psd?
-extern int      stbi_psd_test_memory      (stbi_uc *buffer, int len);
-
-extern stbi_uc *stbi_psd_load             (char *filename,           int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_psd_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_psd_test_file        (FILE *f);
-extern stbi_uc *stbi_psd_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// is it an hdr?
-extern int      stbi_hdr_test_memory      (stbi_uc *buffer, int len);
-
-extern float *  stbi_hdr_load             (char *filename,           int *x, int *y, int *comp, int req_comp);
-extern float *  stbi_hdr_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_hdr_test_file        (FILE *f);
-extern float *  stbi_hdr_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// define new loaders
-typedef struct
-{
-   int       (*test_memory)(stbi_uc *buffer, int len);
-   stbi_uc * (*load_from_memory)(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);
-   #ifndef STBI_NO_STDIO
-   int       (*test_file)(FILE *f);
-   stbi_uc * (*load_from_file)(FILE *f, int *x, int *y, int *comp, int req_comp);
-   #endif
-} stbi_loader;
-
-// register a loader by filling out the above structure (you must defined ALL functions)
-// returns 1 if added or already added, 0 if not added (too many loaders)
-extern int stbi_register_loader(stbi_loader *loader);
-
-#ifdef __cplusplus
-}
-#endif
-
-//
-//
-////   end header file   /////////////////////////////////////////////////////
-
-#ifndef STBI_NO_STDIO
-#include <stdio.h>
-#endif
-#include <stdlib.h>
-#include <memory.h>
-#include <assert.h>
-#include <stdarg.h>
-
-#ifndef _MSC_VER
-#define __forceinline
-#endif
-
-// implementation:
-typedef unsigned char uint8;
-typedef unsigned short uint16;
-typedef   signed short  int16;
-typedef unsigned int   uint32;
-typedef   signed int    int32;
-typedef unsigned int   uint;
-
-// should produce compiler error if size is wrong
-typedef unsigned char validate_uint32[sizeof(uint32)==4];
-
-#if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE)
-#define STBI_NO_WRITE
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Generic API that works on all image types
-//
-
-static char *failure_reason;
-
-char *stbi_failure_reason(void)
-{
-   return failure_reason;
-}
-
-static int e(char *str)
-{
-   failure_reason = str;
-   return 0;
-}
-
-#ifdef STBI_NO_FAILURE_STRINGS
-   #define e(x,y)  0
-#elif defined(STBI_FAILURE_USERMSG)
-   #define e(x,y)  e(y)
-#else
-   #define e(x,y)  e(x)
-#endif
-
-#define epf(x,y)   ((float *) (e(x,y)?NULL:NULL))
-#define epuc(x,y)  ((unsigned char *) (e(x,y)?NULL:NULL))
-
-void stbi_image_free(void *retval_from_stbi_load)
-{
-   free(retval_from_stbi_load);
-}
-
-#define MAX_LOADERS  32
-stbi_loader *loaders[MAX_LOADERS];
-static int max_loaders = 0;
-
-int stbi_register_loader(stbi_loader *loader)
-{
-   int i;
-   for (i=0; i < MAX_LOADERS; ++i) {
-      // already present?
-      if (loaders[i] == loader)
-         return 1;
-      // end of the list?
-      if (loaders[i] == NULL) {
-         loaders[i] = loader;
-         max_loaders = i+1;
-         return 1;
-      }
-   }
-   // no room for it
-   return 0;
-}
-
-#ifndef STBI_NO_HDR
-static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
-static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp);
-#endif
-
-#ifndef STBI_NO_STDIO
-unsigned char *stbi_load(char *filename, int *x, int *y, int *comp, int req_comp)
-{
-   FILE *f = fopen(filename, "rb");
-   unsigned char *result;
-   if (!f) return epuc("can't fopen", "Unable to open file");
-   result = stbi_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   int i;
-   if (stbi_jpeg_test_file(f))
-      return stbi_jpeg_load_from_file(f,x,y,comp,req_comp);
-   if (stbi_png_test_file(f))
-      return stbi_png_load_from_file(f,x,y,comp,req_comp);
-   if (stbi_bmp_test_file(f))
-      return stbi_bmp_load_from_file(f,x,y,comp,req_comp);
-   if (stbi_psd_test_file(f))
-      return stbi_psd_load_from_file(f,x,y,comp,req_comp);
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_file(f)) {
-      float *hdr = stbi_hdr_load_from_file(f, x,y,comp,req_comp);
-      return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
-   }
-   #endif
-   for (i=0; i < max_loaders; ++i)
-      if (loaders[i]->test_file(f))
-         return loaders[i]->load_from_file(f,x,y,comp,req_comp);
-   // test tga last because it's a crappy test!
-   if (stbi_tga_test_file(f))
-      return stbi_tga_load_from_file(f,x,y,comp,req_comp);
-   return epuc("unknown image type", "Image not of any known type, or corrupt");
-}
-#endif
-
-unsigned char *stbi_load_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   int i;
-   if (stbi_jpeg_test_memory(buffer,len))
-      return stbi_jpeg_load_from_memory(buffer,len,x,y,comp,req_comp);
-   if (stbi_png_test_memory(buffer,len))
-      return stbi_png_load_from_memory(buffer,len,x,y,comp,req_comp);
-   if (stbi_bmp_test_memory(buffer,len))
-      return stbi_bmp_load_from_memory(buffer,len,x,y,comp,req_comp);
-   if (stbi_psd_test_memory(buffer,len))
-      return stbi_psd_load_from_memory(buffer,len,x,y,comp,req_comp);
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_memory(buffer, len)) {
-      float *hdr = stbi_hdr_load_from_memory(buffer, len,x,y,comp,req_comp);
-      return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
-   }
-   #endif
-   for (i=0; i < max_loaders; ++i)
-      if (loaders[i]->test_memory(buffer,len))
-         return loaders[i]->load_from_memory(buffer,len,x,y,comp,req_comp);
-   // test tga last because it's a crappy test!
-   if (stbi_tga_test_memory(buffer,len))
-      return stbi_tga_load_from_memory(buffer,len,x,y,comp,req_comp);
-   return epuc("unknown image type", "Image not of any known type, or corrupt");
-}
-
-#ifndef STBI_NO_HDR
-
-#ifndef STBI_NO_STDIO
-float *stbi_loadf(char *filename, int *x, int *y, int *comp, int req_comp)
-{
-   FILE *f = fopen(filename, "rb");
-   float *result;
-   if (!f) return epf("can't fopen", "Unable to open file");
-   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_file(f))
-      return stbi_hdr_load_from_file(f,x,y,comp,req_comp);
-   #endif
-   data = stbi_load_from_file(f, x, y, comp, req_comp);
-   if (data)
-      return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
-   return epf("unknown image type", "Image not of any known type, or corrupt");
-}
-#endif
-
-float *stbi_loadf_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_memory(buffer, len))
-      return stbi_hdr_load_from_memory(buffer, len,x,y,comp,req_comp);
-   #endif
-   data = stbi_load_from_memory(buffer, len, x, y, comp, req_comp);
-   if (data)
-      return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
-   return epf("unknown image type", "Image not of any known type, or corrupt");
-}
-#endif
-
-// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is
-// defined, for API simplicity; if STBI_NO_HDR is defined, it always
-// reports false!
-
-extern int      stbi_is_hdr_from_memory(stbi_uc *buffer, int len)
-{
-   #ifndef STBI_NO_HDR
-   return stbi_hdr_test_memory(buffer, len);
-   #else
-   return 0;
-   #endif
-}
-
-#ifndef STBI_NO_STDIO
-extern int      stbi_is_hdr          (char *filename)
-{
-   FILE *f = fopen(filename, "rb");
-   int result=0;
-   if (f) {
-      result = stbi_is_hdr_from_file(f);
-      fclose(f);
-   }
-   return result;
-}
-
-extern int      stbi_is_hdr_from_file(FILE *f)
-{
-   #ifndef STBI_NO_HDR
-   return stbi_hdr_test_file(f);
-   #else
-   return 0;
-   #endif
-}
-
-#endif
-
-// @TODO: get image dimensions & components without fully decoding
-#ifndef STBI_NO_STDIO
-extern int      stbi_info            (char *filename,           int *x, int *y, int *comp);
-extern int      stbi_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-#endif
-extern int      stbi_info_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp);
-
-#ifndef STBI_NO_HDR
-static float h2l_gamma_i=1.0f/2.2f, h2l_scale_i=1.0f;
-static float l2h_gamma=2.2f, l2h_scale=1.0f;
-
-void   stbi_hdr_to_ldr_gamma(float gamma) { h2l_gamma_i = 1/gamma; }
-void   stbi_hdr_to_ldr_scale(float scale) { h2l_scale_i = 1/scale; }
-
-void   stbi_ldr_to_hdr_gamma(float gamma) { l2h_gamma = gamma; }
-void   stbi_ldr_to_hdr_scale(float scale) { l2h_scale = scale; }
-#endif
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Common code used by all image loaders
-//
-
-// image width, height, # components
-static uint32 img_x, img_y;
-static int img_n, img_out_n;
-
-enum
-{
-   SCAN_load=0,
-   SCAN_type,
-   SCAN_header,
-};
-
-// An API for reading either from memory or file.
-#ifndef STBI_NO_STDIO
-static FILE  *img_file;
-#endif
-static uint8 *img_buffer, *img_buffer_end;
-
-#ifndef STBI_NO_STDIO
-static void start_file(FILE *f)
-{
-   img_file = f;
-}
-#endif
-
-static void start_mem(uint8 *buffer, int len)
-{
-#ifndef STBI_NO_STDIO
-   img_file = NULL;
-#endif
-   img_buffer = buffer;
-   img_buffer_end = buffer+len;
-}
-
-static int get8(void)
-{
-#ifndef STBI_NO_STDIO
-   if (img_file) {
-      int c = fgetc(img_file);
-      return c == EOF ? 0 : c;
-   }
-#endif
-   if (img_buffer < img_buffer_end)
-      return *img_buffer++;
-   return 0;
-}
-
-static int at_eof(void)
-{
-#ifndef STBI_NO_STDIO
-   if (img_file)
-      return feof(img_file);
-#endif
-   return img_buffer >= img_buffer_end;   
-}
-
-static uint8 get8u(void)
-{
-   return (uint8) get8();
-}
-
-static void skip(int n)
-{
-#ifndef STBI_NO_STDIO
-   if (img_file)
-      fseek(img_file, n, SEEK_CUR);
-   else
-#endif
-      img_buffer += n;
-}
-
-static int get16(void)
-{
-   int z = get8();
-   return (z << 8) + get8();
-}
-
-static uint32 get32(void)
-{
-   uint32 z = get16();
-   return (z << 16) + get16();
-}
-
-static int get16le(void)
-{
-   int z = get8();
-   return z + (get8() << 8);
-}
-
-static uint32 get32le(void)
-{
-   uint32 z = get16le();
-   return z + (get16le() << 16);
-}
-
-static void getn(stbi_uc *buffer, int n)
-{
-#ifndef STBI_NO_STDIO
-   if (img_file) {
-      fread(buffer, 1, n, img_file);
-      return;
-   }
-#endif
-   memcpy(buffer, img_buffer, n);
-   img_buffer += n;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//  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 uint8 compute_y(int r, int g, int b)
-{
-   return (uint8) (((r*77) + (g*150) +  (29*b)) >> 8);
-}
-
-static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp)
-{
-   uint i,j;
-   unsigned char *good;
-
-   if (req_comp == img_n) return data;
-   assert(req_comp >= 1 && req_comp <= 4);
-
-   good = (unsigned char *) malloc(req_comp * img_x * img_y);
-   if (good == NULL) {
-      free(data);
-      return epuc("outofmem", "Out of memory");
-   }
-
-   for (j=0; j < img_y; ++j) {
-      unsigned char *src  = data + j * img_x * img_n   ;
-      unsigned char *dest = good + j * img_x * req_comp;
-
-      #define COMBO(a,b)  ((a)*8+(b))
-      #define CASE(a,b)   case COMBO(a,b): for(i=0; i < img_x; ++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(COMBO(img_n, req_comp)) {
-         CASE(1,2) dest[0]=src[0], dest[1]=255; break;
-         CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break;
-         CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break;
-         CASE(2,1) dest[0]=src[0]; break;
-         CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break;
-         CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break;
-         CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break;
-         CASE(3,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
-         CASE(3,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = 255; break;
-         CASE(4,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
-         CASE(4,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break;
-         CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break;
-         default: assert(0);
-      }
-      #undef CASE
-   }
-
-   free(data);
-   img_out_n = req_comp;
-   return good;
-}
-
-#ifndef STBI_NO_HDR
-static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
-{
-   int i,k,n;
-   float *output = (float *) malloc(x * y * comp * sizeof(float));
-   if (output == NULL) { free(data); return epf("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, l2h_gamma) * l2h_scale;
-      }
-      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
-   }
-   free(data);
-   return output;
-}
-
-#define float2int(x)   ((int) (x))
-static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp)
-{
-   int i,k,n;
-   stbi_uc *output = (stbi_uc *) malloc(x * y * comp);
-   if (output == NULL) { free(data); return epuc("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]*h2l_scale_i, h2l_gamma_i) * 255 + 0.5f;
-         if (z < 0) z = 0;
-         if (z > 255) z = 255;
-         output[i*comp + k] = 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] = float2int(z);
-      }
-   }
-   free(data);
-   return output;
-}
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//  "baseline" JPEG/JFIF decoder (not actually fully baseline implementation)
-//
-//    simple implementation
-//      - channel subsampling of at most 2 in each dimension
-//      - 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
-//      - uses a lot of intermediate memory, could cache poorly
-//      - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4
-//          stb_jpeg:   1.34 seconds (MSVC6, default release build)
-//          stb_jpeg:   1.06 seconds (MSVC6, processor = Pentium Pro)
-//          IJL11.dll:  1.08 seconds (compiled by intel)
-//          IJG 1998:   0.98 seconds (MSVC6, makefile provided by IJG)
-//          IJG 1998:   0.95 seconds (MSVC6, makefile + proc=PPro)
-
-int stbi_jpeg_dc_only;
-
-// huffman decoding acceleration
-#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
-
-typedef struct
-{
-   uint8  fast[1 << FAST_BITS];
-   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
-   uint16 code[256];
-   uint8  values[256];
-   uint8  size[257];
-   unsigned int maxcode[18];
-   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
-} huffman;
-
-static huffman huff_dc[4];  // baseline is 2 tables, extended is 4
-static huffman huff_ac[4];
-static uint8 dequant[4][64];
-
-static int build_huffman(huffman *h, int *count)
-{
-   int i,j,k=0,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++] = (uint8) (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++] = (uint16) (code++);
-         if (code-1 >= (1 << j)) return e("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] = (uint8) i;
-         }
-      }
-   }
-   return 1;
-}
-
-// sizes for components, interleaved MCUs
-static int img_h_max, img_v_max;
-static int img_mcu_x, img_mcu_y;
-static int img_mcu_w, img_mcu_h;
-
-// definition of jpeg image component
-static struct
-{
-   int id;
-   int h,v;
-   int tq;
-   int hd,ha;
-   int dc_pred;
-
-   int x,y,w2,h2;
-   uint8 *data;
-} img_comp[4];
-
-static unsigned long  code_buffer; // jpeg entropy-coded buffer
-static int            code_bits;   // number of valid bits
-static unsigned char  marker;      // marker seen while filling entropy buffer
-static int            nomore;      // flag if we saw a marker so must stop
- 
-static void grow_buffer_unsafe(void)
-{
-   do {
-      int b = nomore ? 0 : get8();
-      if (b == 0xff) {
-         int c = get8();
-         if (c != 0) {
-            marker = (unsigned char) c;
-            nomore = 1;
-            return;
-         }
-      }
-      code_buffer = (code_buffer << 8) | b;
-      code_bits += 8;
-   } while (code_bits <= 24);
-}
-
-// (1 << n) - 1
-static unsigned long 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
-__forceinline static int decode(huffman *h)
-{
-   unsigned int temp;
-   int c,k;
-
-   if (code_bits < 16) grow_buffer_unsafe();
-
-   // look at the top FAST_BITS and determine what symbol ID it is,
-   // if the code is <= FAST_BITS
-   c = (code_buffer >> (code_bits - FAST_BITS)) & ((1 << FAST_BITS)-1);
-   k = h->fast[c];
-   if (k < 255) {
-      if (h->size[k] > code_bits)
-         return -1;
-      code_bits -= h->size[k];
-      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.
-   if (code_bits < 16)
-      temp = (code_buffer << (16 - code_bits)) & 0xffff;
-   else
-      temp = (code_buffer >> (code_bits - 16)) & 0xffff;
-   for (k=FAST_BITS+1 ; ; ++k)
-      if (temp < h->maxcode[k])
-         break;
-   if (k == 17) {
-      // error! code not found
-      code_bits -= 16;
-      return -1;
-   }
-
-   if (k > code_bits)
-      return -1;
-
-   // convert the huffman code to the symbol id
-   c = ((code_buffer >> (code_bits - k)) & bmask[k]) + h->delta[k];
-   assert((((code_buffer) >> (code_bits - h->size[c])) & bmask[h->size[c]]) == h->code[c]);
-
-   // convert the id to a symbol
-   code_bits -= k;
-   return h->values[c];
-}
-
-// combined JPEG 'receive' and JPEG 'extend', since baseline
-// always extends everything it receives.
-__forceinline static int extend_receive(int n)
-{
-   unsigned int m = 1 << (n-1);
-   unsigned int k;
-   if (code_bits < n) grow_buffer_unsafe();
-   k = (code_buffer >> (code_bits - n)) & bmask[n];
-   code_bits -= n;
-   // the following test is probably a random branch that won't
-   // predict well. I tried to table accelerate it but failed.
-   // maybe it's compiling as a conditional move?
-   if (k < m)
-      return (-1 << n) + k + 1;
-   else
-      return k;
-}
-
-// 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 uint8 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 decode_block(short data[64], huffman *hdc, huffman *hac, int b)
-{
-   int diff,dc,k;
-   int t = decode(hdc);
-   if (t < 0) return e("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 ? extend_receive(t) : 0;
-   dc = img_comp[b].dc_pred + diff;
-   img_comp[b].dc_pred = dc;
-   data[0] = (short) dc;
-
-   // decode AC components, see JPEG spec
-   k = 1;
-   do {
-      int r,s;
-      int rs = decode(hac);
-      if (rs < 0) return e("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
-         data[dezigzag[k++]] = (short) extend_receive(s);
-      }
-   } while (k < 64);
-   return 1;
-}
-
-// take a -128..127 value and clamp it and convert to 0..255
-__forceinline static uint8 clamp(int x)
-{
-   x += 128;
-   // 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 (uint8) x;
-}
-
-#define f2f(x)  (int) (((x) * 4096 + 0.5))
-#define fsh(x)  ((x) << 12)
-
-// derived from jidctint -- DCT_ISLOW
-#define 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) * f2f(0.5411961f);             \
-   t2 = p1 + p3*f2f(-1.847759065f);            \
-   t3 = p1 + p2*f2f( 0.765366865f);            \
-   p2 = s0;                                    \
-   p3 = s4;                                    \
-   t0 = fsh(p2+p3);                            \
-   t1 = 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)*f2f( 1.175875602f);            \
-   t0 = t0*f2f( 0.298631336f);                 \
-   t1 = t1*f2f( 2.053119869f);                 \
-   t2 = t2*f2f( 3.072711026f);                 \
-   t3 = t3*f2f( 1.501321110f);                 \
-   p1 = p5 + p1*f2f(-0.899976223f);            \
-   p2 = p5 + p2*f2f(-2.562915447f);            \
-   p3 = p3*f2f(-1.961570560f);                 \
-   p4 = p4*f2f(-0.390180644f);                 \
-   t3 += p1+p4;                                \
-   t2 += p2+p3;                                \
-   t1 += p2+p4;                                \
-   t0 += p1+p3;
-
-// .344 seconds on 3*anemones.jpg
-static void idct_block(uint8 *out, int out_stride, short data[64], uint8 *dequantize)
-{
-   int i,val[64],*v=val;
-   uint8 *o,*dq = dequantize;
-   short *d = data;
-
-   if (stbi_jpeg_dc_only) {
-      // ok, I don't really know why this is right, but it seems to be:
-      int z = 128 + ((d[0] * dq[0]) >> 3);
-      for (i=0; i < 8; ++i) {
-         out[0] = out[1] = out[2] = out[3] = out[4] = out[5] = out[6] = out[7] = z;
-         out += out_stride;
-      }
-      return;
-   }
-
-   // columns
-   for (i=0; i < 8; ++i,++d,++dq, ++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] * dq[0] << 2;
-         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
-      } else {
-         IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24],
-                 d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[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
-      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.
-      x0 += 65536; x1 += 65536; x2 += 65536; x3 += 65536;
-      o[0] = clamp((x0+t3) >> 17);
-      o[7] = clamp((x0-t3) >> 17);
-      o[1] = clamp((x1+t2) >> 17);
-      o[6] = clamp((x1-t2) >> 17);
-      o[2] = clamp((x2+t1) >> 17);
-      o[5] = clamp((x2-t1) >> 17);
-      o[3] = clamp((x3+t0) >> 17);
-      o[4] = clamp((x3-t0) >> 17);
-   }
-}
-
-#define 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 uint8 get_marker(void)
-{
-   uint8 x;
-   if (marker != MARKER_none) { x = marker; marker = MARKER_none; return x; }
-   x = get8u();
-   if (x != 0xff) return MARKER_none;
-   while (x == 0xff)
-      x = get8u();
-   return x;
-}
-
-// in each scan, we'll have scan_n components, and the order
-// of the components is specified by order[]
-static int scan_n, order[4];
-static int restart_interval, todo;
-#define RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
-
-// after a restart interval, reset the entropy decoder and
-// the dc prediction
-static void reset(void)
-{
-   code_bits = 0;
-   code_buffer = 0;
-   nomore = 0;
-   img_comp[0].dc_pred = img_comp[1].dc_pred = img_comp[2].dc_pred = 0;
-   marker = MARKER_none;
-   todo = restart_interval ? restart_interval : 0x7fffffff;
-   // 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 parse_entropy_coded_data(void)
-{
-   reset();
-   if (scan_n == 1) {
-      int i,j;
-      short data[64];
-      int n = 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 = (img_comp[n].x+7) >> 3;
-      int h = (img_comp[n].y+7) >> 3;
-      for (j=0; j < h; ++j) {
-         for (i=0; i < w; ++i) {
-            if (!decode_block(data, huff_dc+img_comp[n].hd, huff_ac+img_comp[n].ha, n)) return 0;
-            idct_block(img_comp[n].data+img_comp[n].w2*j*8+i*8, img_comp[n].w2, data, dequant[img_comp[n].tq]);
-            // every data block is an MCU, so countdown the restart interval
-            if (--todo <= 0) {
-               if (code_bits < 24) grow_buffer_unsafe();
-               // if it's NOT a restart, then just bail, so we get corrupt data
-               // rather than no data
-               if (!RESTART(marker)) return 1;
-               reset();
-            }
-         }
-      }
-   } else { // interleaved!
-      int i,j,k,x,y;
-      short data[64];
-      for (j=0; j < img_mcu_y; ++j) {
-         for (i=0; i < img_mcu_x; ++i) {
-            // scan an interleaved mcu... process scan_n components in order
-            for (k=0; k < scan_n; ++k) {
-               int n = 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 < img_comp[n].v; ++y) {
-                  for (x=0; x < img_comp[n].h; ++x) {
-                     int x2 = (i*img_comp[n].h + x)*8;
-                     int y2 = (j*img_comp[n].v + y)*8;
-                     if (!decode_block(data, huff_dc+img_comp[n].hd, huff_ac+img_comp[n].ha, n)) return 0;
-                     idct_block(img_comp[n].data+img_comp[n].w2*y2+x2, img_comp[n].w2, data, dequant[img_comp[n].tq]);
-                  }
-               }
-            }
-            // after all interleaved components, that's an interleaved MCU,
-            // so now count down the restart interval
-            if (--todo <= 0) {
-               if (code_bits < 24) grow_buffer_unsafe();
-               // if it's NOT a restart, then just bail, so we get corrupt data
-               // rather than no data
-               if (!RESTART(marker)) return 1;
-               reset();
-            }
-         }
-      }
-   }
-   return 1;
-}
-
-static int process_marker(int m)
-{
-   int L;
-   switch (m) {
-      case MARKER_none: // no marker found
-         return e("expected marker","Corrupt JPEG");
-
-      case 0xC2: // SOF - progressive
-         return e("progressive jpeg","JPEG format not supported (progressive)");
-
-      case 0xDD: // DRI - specify restart interval
-         if (get16() != 4) return e("bad DRI len","Corrupt JPEG");
-         restart_interval = get16();
-         return 1;
-
-      case 0xDB: // DQT - define quantization table
-         L = get16()-2;
-         while (L > 0) {
-            int z = get8();
-            int p = z >> 4;
-            int t = z & 15,i;
-            if (p != 0) return e("bad DQT type","Corrupt JPEG");
-            if (t > 3) return e("bad DQT table","Corrupt JPEG");
-            for (i=0; i < 64; ++i)
-               dequant[t][dezigzag[i]] = get8u();
-            L -= 65;
-         }
-         return L==0;
-
-      case 0xC4: // DHT - define huffman table
-         L = get16()-2;
-         while (L > 0) {
-            uint8 *v;
-            int sizes[16],i,m=0;
-            int z = get8();
-            int tc = z >> 4;
-            int th = z & 15;
-            if (tc > 1 || th > 3) return e("bad DHT header","Corrupt JPEG");
-            for (i=0; i < 16; ++i) {
-               sizes[i] = get8();
-               m += sizes[i];
-            }
-            L -= 17;
-            if (tc == 0) {
-               if (!build_huffman(huff_dc+th, sizes)) return 0;
-               v = huff_dc[th].values;
-            } else {
-               if (!build_huffman(huff_ac+th, sizes)) return 0;
-               v = huff_ac[th].values;
-            }
-            for (i=0; i < m; ++i)
-               v[i] = get8u();
-            L -= m;
-         }
-         return L==0;
-   }
-   // check for comment block or APP blocks
-   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
-      skip(get16()-2);
-      return 1;
-   }
-   return 0;
-}
-
-// after we see SOS
-static int process_scan_header(void)
-{
-   int i;
-   int Ls = get16();
-   scan_n = get8();
-   if (scan_n < 1 || scan_n > 4 || scan_n > (int) img_n) return e("bad SOS component count","Corrupt JPEG");
-   if (Ls != 6+2*scan_n) return e("bad SOS len","Corrupt JPEG");
-   for (i=0; i < scan_n; ++i) {
-      int id = get8(), which;
-      int z = get8();
-      for (which = 0; which < img_n; ++which)
-         if (img_comp[which].id == id)
-            break;
-      if (which == img_n) return 0;
-      img_comp[which].hd = z >> 4;   if (img_comp[which].hd > 3) return e("bad DC huff","Corrupt JPEG");
-      img_comp[which].ha = z & 15;   if (img_comp[which].ha > 3) return e("bad AC huff","Corrupt JPEG");
-      order[i] = which;
-   }
-   if (get8() != 0) return e("bad SOS","Corrupt JPEG");
-   get8(); // should be 63, but might be 0
-   if (get8() != 0) return e("bad SOS","Corrupt JPEG");
-
-   return 1;
-}
-
-static int process_frame_header(int scan)
-{
-   int Lf,p,i,z, h_max=1,v_max=1;
-   Lf = get16();         if (Lf < 11) return e("bad SOF len","Corrupt JPEG"); // JPEG
-   p  = get8();          if (p != 8) return e("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
-   img_y = get16();      if (img_y == 0) return e("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
-   img_x = get16();      if (img_x == 0) return e("0 width","Corrupt JPEG"); // JPEG requires
-   img_n = get8();
-   if (img_n != 3 && img_n != 1) return e("bad component count","Corrupt JPEG");    // JFIF requires
-
-   if (Lf != 8+3*img_n) return e("bad SOF len","Corrupt JPEG");
-
-   for (i=0; i < img_n; ++i) {
-      img_comp[i].id = get8();
-      if (img_comp[i].id != i+1)   // JFIF requires
-         if (img_comp[i].id != i)  // jpegtran outputs non-JFIF-compliant files!
-            return e("bad component ID","Corrupt JPEG");
-      z = get8();
-      img_comp[i].h = (z >> 4);  if (!img_comp[i].h || img_comp[i].h > 4) return e("bad H","Corrupt JPEG");
-      img_comp[i].v = z & 15;    if (!img_comp[i].v || img_comp[i].v > 4) return e("bad V","Corrupt JPEG");
-      img_comp[i].tq = get8();   if (img_comp[i].tq > 3) return e("bad TQ","Corrupt JPEG");
-   }
-
-   if (scan != SCAN_load) return 1;
-
-   if ((1 << 30) / img_x / img_n < img_y) return e("too large", "Image too large to decode");
-
-   for (i=0; i < img_n; ++i) {
-      if (img_comp[i].h > h_max) h_max = img_comp[i].h;
-      if (img_comp[i].v > v_max) v_max = img_comp[i].v;
-   }
-
-   // compute interleaved mcu info
-   img_h_max = h_max;
-   img_v_max = v_max;
-   img_mcu_w = h_max * 8;
-   img_mcu_h = v_max * 8;
-   img_mcu_x = (img_x + img_mcu_w-1) / img_mcu_w;
-   img_mcu_y = (img_y + img_mcu_h-1) / img_mcu_h;
-
-   for (i=0; i < img_n; ++i) {
-      // number of effective pixels (e.g. for non-interleaved MCU)
-      img_comp[i].x = (img_x * img_comp[i].h + h_max-1) / h_max;
-      img_comp[i].y = (img_y * 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_comp[i].w2 = img_mcu_x * img_comp[i].h * 8;
-      img_comp[i].h2 = img_mcu_y * img_comp[i].v * 8;
-      img_comp[i].data = (uint8 *) malloc(img_comp[i].w2 * img_comp[i].h2);
-      if (img_comp[i].data == NULL) {
-         for(--i; i >= 0; --i)
-            free(img_comp[i].data);
-         return e("outofmem", "Out of memory");
-      }
-   }
-
-   return 1;
-}
-
-// use comparisons since in some cases we handle more than one case (e.g. SOF)
-#define DNL(x)         ((x) == 0xdc)
-#define SOI(x)         ((x) == 0xd8)
-#define EOI(x)         ((x) == 0xd9)
-#define SOF(x)         ((x) == 0xc0 || (x) == 0xc1)
-#define SOS(x)         ((x) == 0xda)
-
-static int decode_jpeg_header(int scan)
-{
-   int m;
-   marker = MARKER_none; // initialize cached marker to empty
-   m = get_marker();
-   if (!SOI(m)) return e("no SOI","Corrupt JPEG");
-   if (scan == SCAN_type) return 1;
-   m = get_marker();
-   while (!SOF(m)) {
-      if (!process_marker(m)) return 0;
-      m = get_marker();
-      while (m == MARKER_none) {
-         // some files have extra padding after their blocks, so ok, we'll scan
-         if (at_eof()) return e("no SOF", "Corrupt JPEG");
-         m = get_marker();
-      }
-   }
-   if (!process_frame_header(scan)) return 0;
-   return 1;
-}
-
-static int decode_jpeg_image(void)
-{
-   int m;
-   restart_interval = 0;
-   if (!decode_jpeg_header(SCAN_load)) return 0;
-   m = get_marker();
-   while (!EOI(m)) {
-      if (SOS(m)) {
-         if (!process_scan_header()) return 0;
-         if (!parse_entropy_coded_data()) return 0;
-      } else {
-         if (!process_marker(m)) return 0;
-      }
-      m = get_marker();
-   }
-   return 1;
-}
-
-// static jfif-centered resampling with cross-block smoothing
-// here by cross-block smoothing what I mean is that the resampling
-// is bilerp and crosses blocks; I dunno what IJG means
-
-#define div4(x) ((uint8) ((x) >> 2))
-
-static void resample_v_2(uint8 *out1, uint8 *input, int w, int h, int s)
-{
-   // need to generate two samples vertically for every one in input
-   uint8 *above;
-   uint8 *below;
-   uint8 *source;
-   uint8 *out2;
-   int i,j;
-   source = input;
-   out2 = out1+w;
-   for (j=0; j < h; ++j) {
-      above = source;
-      source = input + j*s;
-      below = source + s; if (j == h-1) below = source;
-      for (i=0; i < w; ++i) {
-         int n = source[i]*3;
-         out1[i] = div4(above[i] + n);
-         out2[i] = div4(below[i] + n);
-      }
-      out1 += w*2;
-      out2 += w*2;
-   }
-}
-
-static void resample_h_2(uint8 *out, uint8 *input, int w, int h, int s)
-{
-   // need to generate two samples horizontally for every one in input
-   int i,j;
-   if (w == 1) {
-      for (j=0; j < h; ++j)
-         out[j*2+0] = out[j*2+1] = input[j*s];
-      return;
-   }
-   for (j=0; j < h; ++j) {
-      out[0] = input[0];
-      out[1] = div4(input[0]*3 + input[1]);
-      for (i=1; i < w-1; ++i) {
-         int n = input[i]*3;
-         out[i*2-2] = div4(input[i-1] + n);
-         out[i*2-1] = div4(input[i+1] + n);
-      }
-      out[w*2-2] = div4(input[w-2]*3 + input[w-1]);
-      out[w*2-1] = input[w-1];
-      out += w*2;
-      input += s;
-   }
-}
-
-// .172 seconds on 3*anemones.jpg
-static void resample_hv_2(uint8 *out, uint8 *input, int w, int h, int s)
-{
-   // need to generate 2x2 samples for every one in input
-   int i,j;
-   int os = w*2;
-   // generate edge samples... @TODO lerp them!
-   for (i=0; i < w; ++i) {
-      out[i*2+0] = out[i*2+1] = input[i];
-      out[i*2+(2*h-1)*os+0] = out[i*2+(2*h-1)*os+1] = input[i+(h-1)*w];
-   }
-   for (j=0; j < h; ++j) {
-      out[j*os*2+0] = out[j*os*2+os+0] = input[j*w];
-      out[j*os*2+os-1] = out[j*os*2+os+os-1] = input[j*w+i-1];
-   }
-   // now generate interior samples; i & j point to top left of input
-   for (j=0; j < h-1; ++j) {
-      uint8 *in1 = input+j*s;
-      uint8 *in2 = in1 + s;
-      uint8 *out1 = out + (j*2+1)*os + 1;
-      uint8 *out2 = out1 + os;
-      for (i=0; i < w-1; ++i) {
-         int p00 = in1[0], p01=in1[1], p10=in2[0], p11=in2[1];
-         int p00_3 = p00*3, p01_3 = p01*3, p10_3 = p10*3, p11_3 = p11*3;
-
-         #define div16(x)  ((uint8) ((x) >> 4))
-
-         out1[0] = div16(p00*9 + p01_3 + p10_3 + p11);
-         out1[1] = div16(p01*9 + p00_3 + p01_3 + p10);
-         out2[0] = div16(p10*9 + p11_3 + p00_3 + p01);
-         out2[1] = div16(p11*9 + p10_3 + p01_3 + p00);
-         out1 += 2;
-         out2 += 2;                                                         
-         ++in1;
-         ++in2;
-      }
-   }
-}
-
-#define float2fixed(x)  ((int) ((x) * 65536 + 0.5))
-
-// 0.38 seconds on 3*anemones.jpg   (0.25 with processor = Pro)
-// VC6 without processor=Pro is generating multiple LEAs per multiply!
-static void YCbCr_to_RGB_row(uint8 *out, uint8 *y, uint8 *pcb, uint8 *pcr, int count, int step)
-{
-   int i;
-   for (i=0; i < count; ++i) {
-      int y_fixed = (y[i] << 16) + 32768; // rounding
-      int r,g,b;
-      int cr = pcr[i] - 128;
-      int cb = pcb[i] - 128;
-      r = y_fixed + cr*float2fixed(1.40200f);
-      g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f);
-      b = y_fixed                            + cb*float2fixed(1.77200f);
-      r >>= 16;
-      g >>= 16;
-      b >>= 16;
-      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] = (uint8)r;
-      out[1] = (uint8)g;
-      out[2] = (uint8)b;
-      if (step == 4) out[3] = 255;
-      out += step;
-   }
-}
-
-// clean up the temporary component buffers
-static void cleanup_jpeg(void)
-{
-   int i;
-   for (i=0; i < img_n; ++i) {
-      if (img_comp[i].data) {
-         free(img_comp[i].data);
-         img_comp[i].data = NULL;
-      }
-   }
-}
-
-static uint8 *load_jpeg_image(int *out_x, int *out_y, int *comp, int req_comp)
-{
-   int i, n;
-   // validate req_comp
-   if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
-
-   // load a jpeg image from whichever source
-   if (!decode_jpeg_image()) { cleanup_jpeg(); return NULL; }
-
-   // determine actual number of components to generate
-   n = req_comp ? req_comp : img_n;
-
-   // resample components to full size... memory wasteful, but this
-   // lets us bilerp across blocks while upsampling
-   for (i=0; i < img_n; ++i) {
-      // if we're outputting fewer than 3 components, we're grey not RGB;
-      // in that case, don't bother upsampling Cb or Cr
-      if (n < 3 && i) continue;
-
-      // check if the component scale is less than max; if so it needs upsampling
-      if (img_comp[i].h != img_h_max || img_comp[i].v != img_v_max) {
-         int stride = img_x;
-         // allocate final size; make sure it's big enough for upsampling off
-         // the edges with upsample up to 4x4 (although we only support 2x2
-         // currently)
-         uint8 *new_data = (uint8 *) malloc((img_x+3)*(img_y+3));
-         if (new_data == NULL) {
-            cleanup_jpeg();
-            return epuc("outofmem", "Out of memory (image too large?)");
-         }
-         if (img_comp[i].h*2 == img_h_max && img_comp[i].v*2 == img_v_max) {
-            int tx = (img_x+1)>>1;
-            resample_hv_2(new_data, img_comp[i].data, tx,(img_y+1)>>1, img_comp[i].w2);
-            stride = tx*2;
-         } else if (img_comp[i].h == img_h_max && img_comp[i].v*2 == img_v_max) {
-            resample_v_2(new_data, img_comp[i].data, img_x,(img_y+1)>>1, img_comp[i].w2);
-         } else if (img_comp[i].h*2 == img_h_max && img_comp[i].v == img_v_max) {
-            int tx = (img_x+1)>>1;
-            resample_h_2(new_data, img_comp[i].data, tx,img_y, img_comp[i].w2);
-            stride = tx*2;
-         } else {
-            // @TODO resample uncommon sampling pattern with nearest neighbor
-            free(new_data);
-            cleanup_jpeg();
-            return epuc("uncommon H or V", "JPEG not supported: atypical downsampling mode");
-         }
-         img_comp[i].w2 = stride;
-         free(img_comp[i].data);
-         img_comp[i].data = new_data;
-      }
-   }
-
-   // now convert components to output image
-   {
-      uint32 i,j;
-      uint8 *output = (uint8 *) malloc(n * img_x * img_y + 1);
-      if (n >= 3) { // output STBI_rgb_*
-         for (j=0; j < img_y; ++j) {
-            uint8 *y  = img_comp[0].data + j*img_comp[0].w2;
-            uint8 *out = output + n * img_x * j;
-            if (img_n == 3) {
-               uint8 *cb = img_comp[1].data + j*img_comp[1].w2;
-               uint8 *cr = img_comp[2].data + j*img_comp[2].w2;
-               YCbCr_to_RGB_row(out, y, cb, cr, img_x, n);
-            } else {
-               for (i=0; i < img_x; ++i) {
-                  out[0] = out[1] = out[2] = y[i];
-                  out[3] = 255; // not used if n == 3
-                  out += n;
-               }
-            }
-         }
-      } else {      // output STBI_grey_*
-         for (j=0; j < img_y; ++j) {
-            uint8 *y  = img_comp[0].data + j*img_comp[0].w2;
-            uint8 *out = output + n * img_x * j;
-            if (n == 1)
-               for (i=0; i < img_x; ++i) *out++ = *y++;
-            else
-               for (i=0; i < img_x; ++i) *out++ = *y++, *out++ = 255;
-         }
-      }
-      cleanup_jpeg();
-      *out_x = img_x;
-      *out_y = img_y;
-      if (comp) *comp  = img_n; // report original components, not output
-      return output;
-   }
-}
-
-#ifndef STBI_NO_STDIO
-unsigned char *stbi_jpeg_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   start_file(f);
-   return load_jpeg_image(x,y,comp,req_comp);
-}
-
-unsigned char *stbi_jpeg_load(char *filename, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_jpeg_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-#endif
-
-unsigned char *stbi_jpeg_load_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   start_mem(buffer,len);
-   return load_jpeg_image(x,y,comp,req_comp);
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_jpeg_test_file(FILE *f)
-{
-   int n,r;
-   n = ftell(f);
-   start_file(f);
-   r = decode_jpeg_header(SCAN_type);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int stbi_jpeg_test_memory(unsigned char *buffer, int len)
-{
-   start_mem(buffer,len);
-   return decode_jpeg_header(SCAN_type);
-}
-
-// @TODO:
-#ifndef STBI_NO_STDIO
-extern int      stbi_jpeg_info            (char *filename,           int *x, int *y, int *comp);
-extern int      stbi_jpeg_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-#endif
-extern int      stbi_jpeg_info_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp);
-
-// 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
-
-// fast-way is faster to check than jpeg huffman, but slow way is slower
-#define ZFAST_BITS  9 // accelerate all cases in default tables
-#define ZFAST_MASK  ((1 << ZFAST_BITS) - 1)
-
-// zlib-style huffman encoding
-// (jpegs packs from left, zlib from right, so can't share code)
-typedef struct
-{
-   uint16 fast[1 << ZFAST_BITS];
-   uint16 firstcode[16];
-   int maxcode[17];
-   uint16 firstsymbol[16];
-   uint8  size[288];
-   uint16 value[288]; 
-} zhuffman;
-
-__forceinline static int 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;
-}
-
-__forceinline static int bit_reverse(int v, int bits)
-{
-   assert(bits <= 16);
-   // to bit reverse n bits, reverse 16 and shift
-   // e.g. 11 bits, bit reverse and shift away 5
-   return bitreverse16(v) >> (16-bits);
-}
-
-static int zbuild_huffman(zhuffman *z, uint8 *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, 255, sizeof(z->fast));
-   for (i=0; i < num; ++i) 
-      ++sizes[sizelist[i]];
-   sizes[0] = 0;
-   for (i=1; i < 16; ++i)
-      assert(sizes[i] <= (1 << i));
-   code = 0;
-   for (i=1; i < 16; ++i) {
-      next_code[i] = code;
-      z->firstcode[i] = (uint16) code;
-      z->firstsymbol[i] = (uint16) k;
-      code = (code + sizes[i]);
-      if (sizes[i])
-         if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG");
-      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];
-         z->size[c] = (uint8)s;
-         z->value[c] = (uint16)i;
-         if (s <= ZFAST_BITS) {
-            int k = bit_reverse(next_code[s],s);
-            while (k < (1 << ZFAST_BITS)) {
-               z->fast[k] = (uint16) c;
-               k += (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
-
-static uint8 *zbuffer, *zbuffer_end;
-
-__forceinline static int zget8(void)
-{
-   if (zbuffer >= zbuffer_end) return 0;
-   return *zbuffer++;
-}
-
-//static unsigned long code_buffer;
-static int           num_bits;
-
-static void fill_bits(void)
-{
-   do {
-      assert(code_buffer < (1U << num_bits));
-      code_buffer |= zget8() << num_bits;
-      num_bits += 8;
-   } while (num_bits <= 24);
-}
-
-__forceinline static unsigned int zreceive(int n)
-{
-   unsigned int k;
-   if (num_bits < n) fill_bits();
-   k = code_buffer & ((1 << n) - 1);
-   code_buffer >>= n;
-   num_bits -= n;
-   return k;   
-}
-
-__forceinline static int zhuffman_decode(zhuffman *z)
-{
-   int b,s,k;
-   if (num_bits < 16) fill_bits();
-   b = z->fast[code_buffer & ZFAST_MASK];
-   if (b < 0xffff) {
-      s = z->size[b];
-      code_buffer >>= s;
-      num_bits -= s;
-      return z->value[b];
-   }
-
-   // not resolved by fast table, so compute it the slow way
-   // use jpeg approach, which requires MSbits at top
-   k = bit_reverse(code_buffer, 16);
-   for (s=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];
-   assert(z->size[b] == s);
-   code_buffer >>= s;
-   num_bits -= s;
-   return z->value[b];
-}
-
-static char *zout;
-static char *zout_start;
-static char *zout_end;
-static int   z_expandable;
-
-static int expand(int n)  // need to make room for n bytes
-{
-   char *q;
-   int cur, limit;
-   if (!z_expandable) return e("output buffer limit","Corrupt PNG");
-   cur   = (int) (zout     - zout_start);
-   limit = (int) (zout_end - zout_start);
-   while (cur + n > limit)
-      limit *= 2;
-   q = (char *) realloc(zout_start, limit);
-   if (q == NULL) return e("outofmem", "Out of memory");
-   zout_start = q;
-   zout       = q + cur;
-   zout_end   = q + limit;
-   return 1;
-}
-
-static zhuffman z_length, z_distance;
-
-static int length_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 int length_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 int dist_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 int dist_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 parse_huffman_block(void)
-{
-   for(;;) {
-      int z = zhuffman_decode(&z_length);
-      if (z < 256) {
-         if (z < 0) return e("bad huffman code","Corrupt PNG"); // error in huffman codes
-         if (zout >= zout_end) if (!expand(1)) return 0;
-         *zout++ = (char) z;
-      } else {
-         uint8 *p;
-         int len,dist;
-         if (z == 256) return 1;
-         z -= 257;
-         len = length_base[z];
-         if (length_extra[z]) len += zreceive(length_extra[z]);
-         z = zhuffman_decode(&z_distance);
-         if (z < 0) return e("bad huffman code","Corrupt PNG");
-         dist = dist_base[z];
-         if (dist_extra[z]) dist += zreceive(dist_extra[z]);
-         if (zout - zout_start < dist) return e("bad dist","Corrupt PNG");
-         if (zout + len > zout_end) if (!expand(len)) return 0;
-         p = (uint8 *) (zout - dist);
-         while (len--)
-            *zout++ = *p++;
-      }
-   }
-}
-
-static int compute_huffman_codes(void)
-{
-   static uint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
-   static zhuffman z_codelength; // static just to save stack space
-   uint8 lencodes[286+32+137];//padding for maximum single op
-   uint8 codelength_sizes[19];
-   int i,n;
-
-   int hlit  = zreceive(5) + 257;
-   int hdist = zreceive(5) + 1;
-   int hclen = zreceive(4) + 4;
-
-   memset(codelength_sizes, 0, sizeof(codelength_sizes));
-   for (i=0; i < hclen; ++i) {
-      int s = zreceive(3);
-      codelength_sizes[length_dezigzag[i]] = (uint8) s;
-   }
-   if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
-
-   n = 0;
-   while (n < hlit + hdist) {
-      int c = zhuffman_decode(&z_codelength);
-      assert(c >= 0 && c < 19);
-      if (c < 16)
-         lencodes[n++] = (uint8) c;
-      else if (c == 16) {
-         c = zreceive(2)+3;
-         memset(lencodes+n, lencodes[n-1], c);
-         n += c;
-      } else if (c == 17) {
-         c = zreceive(3)+3;
-         memset(lencodes+n, 0, c);
-         n += c;
-      } else {
-         assert(c == 18);
-         c = zreceive(7)+11;
-         memset(lencodes+n, 0, c);
-         n += c;
-      }
-   }
-   if (n != hlit+hdist) return e("bad codelengths","Corrupt PNG");
-   if (!zbuild_huffman(&z_length, lencodes, hlit)) return 0;
-   if (!zbuild_huffman(&z_distance, lencodes+hlit, hdist)) return 0;
-   return 1;
-}
-
-static int parse_uncompressed_block(void)
-{
-   uint8 header[4];
-   int len,nlen,k;
-   if (num_bits & 7)
-      zreceive(num_bits & 7); // discard
-   // drain the bit-packed data into header
-   k = 0;
-   while (num_bits > 0) {
-      header[k++] = (uint8) (code_buffer & 255); // wtf this warns?
-      code_buffer >>= 8;
-      num_bits -= 8;
-   }
-   assert(num_bits == 0);
-   // now fill header the normal way
-   while (k < 4)
-      header[k++] = (uint8) zget8();
-   len  = header[1] * 256 + header[0];
-   nlen = header[3] * 256 + header[2];
-   if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG");
-   if (zbuffer + len > zbuffer_end) return e("read past buffer","Corrupt PNG");
-   if (zout + len > zout_end)
-      if (!expand(len)) return 0;
-   memcpy(zout, zbuffer, len);
-   zbuffer += len;
-   zout += len;
-   return 1;
-}
-
-static int parse_zlib_header(void)
-{
-   int cmf   = zget8();
-   int cm    = cmf & 15;
-   /* int cinfo = cmf >> 4; */
-   int flg   = zget8();
-   if ((cmf*256+flg) % 31 != 0) return e("bad zlib header","Corrupt PNG"); // zlib spec
-   if (flg & 32) return e("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
-   if (cm != 8) return e("bad compression","Corrupt PNG"); // DEFLATE required for png
-   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
-   return 1;
-}
-
-static uint8 default_length[288], default_distance[32];
-static void init_defaults(void)
-{
-   int i;   // use <= to match clearly with spec
-   for (i=0; i <= 143; ++i)     default_length[i]   = 8;
-   for (   ; i <= 255; ++i)     default_length[i]   = 9;
-   for (   ; i <= 279; ++i)     default_length[i]   = 7;
-   for (   ; i <= 287; ++i)     default_length[i]   = 8;
-
-   for (i=0; i <=  31; ++i)     default_distance[i] = 5;
-}
-
-static int parse_zlib(int parse_header)
-{
-   int final, type;
-   if (parse_header)
-      if (!parse_zlib_header()) return 0;
-   num_bits = 0;
-   code_buffer = 0;
-   do {
-      final = zreceive(1);
-      type = zreceive(2);
-      if (type == 0) {
-         if (!parse_uncompressed_block()) return 0;
-      } else if (type == 3) {
-         return 0;
-      } else {
-         if (type == 1) {
-            // use fixed code lengths
-            if (!default_length[0]) init_defaults();
-            if (!zbuild_huffman(&z_length  , default_length  , 288)) return 0;
-            if (!zbuild_huffman(&z_distance, default_distance,  32)) return 0;
-         } else {
-            if (!compute_huffman_codes()) return 0;
-         }
-         if (!parse_huffman_block()) return 0;
-      }
-   } while (!final);
-   return 1;
-}
-
-static int do_zlib(char *obuf, int olen, int exp, int parse_header)
-{
-   zout_start = obuf;
-   zout       = obuf;
-   zout_end   = obuf + olen;
-   z_expandable = exp;
-
-   return parse_zlib(parse_header);
-}
-
-char *stbi_zlib_decode_malloc_guesssize(int initial_size, int *outlen)
-{
-   char *p = (char *) malloc(initial_size);
-   if (p == NULL) return NULL;
-   if (do_zlib(p, initial_size, 1, 1)) {
-      *outlen = (int) (zout - zout_start);
-      return zout_start;
-   } else {
-      free(zout_start);
-      return NULL;
-   }
-}
-
-char *stbi_zlib_decode_malloc(char *buffer, int len, int *outlen)
-{
-   zbuffer = (uint8 *) buffer;
-   zbuffer_end = (uint8 *) buffer+len;
-   return stbi_zlib_decode_malloc_guesssize(16384, outlen);
-}
-
-int stbi_zlib_decode_buffer(char *obuffer, int olen, char *ibuffer, int ilen)
-{
-   zbuffer = (uint8 *) ibuffer;
-   zbuffer_end = (uint8 *) ibuffer + ilen;
-   if (do_zlib(obuffer, olen, 0, 1))
-      return (int) (zout - zout_start);
-   else
-      return -1;
-}
-
-char *stbi_zlib_decode_noheader_malloc(char *buffer, int len, int *outlen)
-{
-   char *p = (char *) malloc(16384);
-   if (p == NULL) return NULL;
-   zbuffer = (uint8 *) buffer;
-   zbuffer_end = (uint8 *) buffer+len;
-   if (do_zlib(p, 16384, 1, 0)) {
-      *outlen = (int) (zout - zout_start);
-      return zout_start;
-   } else {
-      free(zout_start);
-      return NULL;
-   }
-}
-
-int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, char *ibuffer, int ilen)
-{
-   zbuffer = (uint8 *) ibuffer;
-   zbuffer_end = (uint8 *) ibuffer + ilen;
-   if (do_zlib(obuffer, olen, 0, 0))
-      return (int) (zout - zout_start);
-   else
-      return -1;
-}
-
-// 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
-
-
-typedef struct
-{
-   unsigned long length;
-   unsigned long type;
-} chunk;
-
-#define PNG_TYPE(a,b,c,d)  (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
-
-static chunk get_chunk_header(void)
-{
-   chunk c;
-   c.length = get32();
-   c.type   = get32();
-   return c;
-}
-
-static int check_png_header(void)
-{
-   static uint8 png_sig[8] = { 137,80,78,71,13,10,26,10 };
-   int i;
-   for (i=0; i < 8; ++i)
-      if (get8() != png_sig[i]) return e("bad png sig","Not a PNG");
-   return 1;
-}
-
-static uint8 *idata, *expanded, *out;
-
-enum {
-   F_none=0, F_sub=1, F_up=2, F_avg=3, F_paeth=4,
-   F_avg_first, F_paeth_first,
-};
-
-static uint8 first_row_filter[5] =
-{
-   F_none, F_sub, F_none, F_avg_first, F_paeth_first
-};
-
-static int 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;
-}
-
-// create the png data from post-deflated data
-static int create_png_image(uint8 *raw, uint32 raw_len, int out_n)
-{
-   uint32 i,j,stride = img_x*out_n;
-   int k;
-   assert(out_n == img_n || out_n == img_n+1);
-   out = (uint8 *) malloc(img_x * img_y * out_n);
-   if (!out) return e("outofmem", "Out of memory");
-   if (raw_len != (img_n * img_x + 1) * img_y) return e("not enough pixels","Corrupt PNG");
-   for (j=0; j < img_y; ++j) {
-      uint8 *cur = out + stride*j;
-      uint8 *prior = cur - stride;
-      int filter = *raw++;
-      if (filter > 4) return e("invalid filter","Corrupt PNG");
-      // if first row, use special filter that doesn't sample previous row
-      if (j == 0) filter = first_row_filter[filter];
-      // handle first pixel explicitly
-      for (k=0; k < img_n; ++k) {
-         switch(filter) {
-            case F_none       : cur[k] = raw[k]; break;
-            case F_sub        : cur[k] = raw[k]; break;
-            case F_up         : cur[k] = raw[k] + prior[k]; break;
-            case F_avg        : cur[k] = raw[k] + (prior[k]>>1); break;
-            case F_paeth      : cur[k] = (uint8) (raw[k] + paeth(0,prior[k],0)); break;
-            case F_avg_first  : cur[k] = raw[k]; break;
-            case F_paeth_first: cur[k] = raw[k]; break;
-         }
-      }
-      if (img_n != out_n) cur[img_n] = 255;
-      raw += img_n;
-      cur += out_n;
-      prior += out_n;
-      // this is a little gross, so that we don't switch per-pixel or per-component
-      if (img_n == out_n) {
-         #define CASE(f) \
-             case f:     \
-                for (i=1; i < img_x; ++i, raw+=img_n,cur+=img_n,prior+=img_n) \
-                   for (k=0; k < img_n; ++k)
-         switch(filter) {
-            CASE(F_none)  cur[k] = raw[k]; break;
-            CASE(F_sub)   cur[k] = raw[k] + cur[k-img_n]; break;
-            CASE(F_up)    cur[k] = raw[k] + prior[k]; break;
-            CASE(F_avg)   cur[k] = raw[k] + ((prior[k] + cur[k-img_n])>>1); break;
-            CASE(F_paeth)  cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break;
-            CASE(F_avg_first)    cur[k] = raw[k] + (cur[k-img_n] >> 1); break;
-            CASE(F_paeth_first)  cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],0,0)); break;
-         }
-         #undef CASE
-      } else {
-         assert(img_n+1 == out_n);
-         #define CASE(f) \
-             case f:     \
-                for (i=1; i < img_x; ++i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \
-                   for (k=0; k < img_n; ++k)
-         switch(filter) {
-            CASE(F_none)  cur[k] = raw[k]; break;
-            CASE(F_sub)   cur[k] = raw[k] + cur[k-out_n]; break;
-            CASE(F_up)    cur[k] = raw[k] + prior[k]; break;
-            CASE(F_avg)   cur[k] = raw[k] + ((prior[k] + cur[k-out_n])>>1); break;
-            CASE(F_paeth)  cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break;
-            CASE(F_avg_first)    cur[k] = raw[k] + (cur[k-out_n] >> 1); break;
-            CASE(F_paeth_first)  cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],0,0)); break;
-         }
-         #undef CASE
-      }
-   }
-   return 1;
-}
-
-static int compute_transparency(uint8 tc[3], int out_n)
-{
-   uint32 i, pixel_count = img_x * img_y;
-   uint8 *p = out;
-
-   // compute color-based transparency, assuming we've
-   // already got 255 as the alpha value in the output
-   assert(out_n == 2 || out_n == 4);
-
-   p = out;
-   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 expand_palette(uint8 *palette, int len, int pal_img_n)
-{
-   uint32 i, pixel_count = img_x * img_y;
-   uint8 *p, *temp_out, *orig = out;
-
-   p = (uint8 *) malloc(pixel_count * pal_img_n);
-   if (p == NULL) return e("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;
-      }
-   }
-   free(out);
-   out = temp_out;
-   return 1;
-}
-
-static int parse_png_file(int scan, int req_comp)
-{
-   uint8 palette[1024], pal_img_n=0;
-   uint8 has_trans=0, tc[3];
-   uint32 ioff=0, idata_limit=0, i, pal_len=0;
-   int first=1,k;
-
-   if (!check_png_header()) return 0;
-
-   if (scan == SCAN_type) return 1;
-
-   for(;;first=0) {
-      chunk c = get_chunk_header();
-      if (first && c.type != PNG_TYPE('I','H','D','R'))
-         return e("first not IHDR","Corrupt PNG");
-      switch (c.type) {
-         case PNG_TYPE('I','H','D','R'): {
-            int depth,color,interlace,comp,filter;
-            if (!first) return e("multiple IHDR","Corrupt PNG");
-            if (c.length != 13) return e("bad IHDR len","Corrupt PNG");
-            img_x = get32(); if (img_x > (1 << 24)) return e("too large","Very large image (corrupt?)");
-            img_y = get32(); if (img_y > (1 << 24)) return e("too large","Very large image (corrupt?)");
-            depth = get8();  if (depth != 8)        return e("8bit only","PNG not supported: 8-bit only");
-            color = get8();  if (color > 6)         return e("bad ctype","Corrupt PNG");
-            if (color == 3) pal_img_n = 3; else if (color & 1) return e("bad ctype","Corrupt PNG");
-            comp  = get8();  if (comp) return e("bad comp method","Corrupt PNG");
-            filter= get8();  if (filter) return e("bad filter method","Corrupt PNG");
-            interlace = get8(); if (interlace) return e("interlaced","PNG not supported: interlaced mode");
-            if (!img_x || !img_y) return e("0-pixel image","Corrupt PNG");
-            if (!pal_img_n) {
-               img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
-               if ((1 << 30) / img_x / img_n < img_y) return e("too large", "Image too large to decode");
-               if (scan == SCAN_header) return 1;
-            } else {
-               // if paletted, then pal_n is our final components, and
-               // img_n is # components to decompress/filter.
-               img_n = 1;
-               if ((1 << 30) / img_x / 4 < img_y) return e("too large","Corrupt PNG");
-               // if SCAN_header, have to scan to see if we have a tRNS
-            }
-            break;
-         }
-
-         case PNG_TYPE('P','L','T','E'):  {
-            if (c.length > 256*3) return e("invalid PLTE","Corrupt PNG");
-            pal_len = c.length / 3;
-            if (pal_len * 3 != c.length) return e("invalid PLTE","Corrupt PNG");
-            for (i=0; i < pal_len; ++i) {
-               palette[i*4+0] = get8u();
-               palette[i*4+1] = get8u();
-               palette[i*4+2] = get8u();
-               palette[i*4+3] = 255;
-            }
-            break;
-         }
-
-         case PNG_TYPE('t','R','N','S'): {
-            if (idata) return e("tRNS after IDAT","Corrupt PNG");
-            if (pal_img_n) {
-               if (scan == SCAN_header) { img_n = 4; return 1; }
-               if (pal_len == 0) return e("tRNS before PLTE","Corrupt PNG");
-               if (c.length > pal_len) return e("bad tRNS len","Corrupt PNG");
-               pal_img_n = 4;
-               for (i=0; i < c.length; ++i)
-                  palette[i*4+3] = get8u();
-            } else {
-               if (!(img_n & 1)) return e("tRNS with alpha","Corrupt PNG");
-               if (c.length != (uint32) img_n*2) return e("bad tRNS len","Corrupt PNG");
-               has_trans = 1;
-               for (k=0; k < img_n; ++k)
-                  tc[k] = (uint8) get16(); // non 8-bit images will be larger
-            }
-            break;
-         }
-
-         case PNG_TYPE('I','D','A','T'): {
-            if (pal_img_n && !pal_len) return e("no PLTE","Corrupt PNG");
-            if (scan == SCAN_header) { img_n = pal_img_n; return 1; }
-            if (ioff + c.length > idata_limit) {
-               uint8 *p;
-               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
-               while (ioff + c.length > idata_limit)
-                  idata_limit *= 2;
-               p = (uint8 *) realloc(idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory");
-               idata = p;
-            }
-            #ifndef STBI_NO_STDIO
-            if (img_file)
-            {
-               if (fread(idata+ioff,1,c.length,img_file) != c.length) return e("outofdata","Corrupt PNG");
-            }
-            else
-            #endif
-            {
-               memcpy(idata+ioff, img_buffer, c.length);
-               img_buffer += c.length;
-            }
-            ioff += c.length;
-            break;
-         }
-
-         case PNG_TYPE('I','E','N','D'): {
-            uint32 raw_len;
-            if (scan != SCAN_load) return 1;
-            if (idata == NULL) return e("no IDAT","Corrupt PNG");
-            expanded = (uint8 *) stbi_zlib_decode_malloc((char *) idata, ioff, (int *) &raw_len);
-            if (expanded == NULL) return 0; // zlib should set error
-            free(idata); idata = NULL;
-            if ((req_comp == img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
-               img_out_n = img_n+1;
-            else
-               img_out_n = img_n;
-            if (!create_png_image(expanded, raw_len, img_out_n)) return 0;
-            if (has_trans)
-               if (!compute_transparency(tc, img_out_n)) return 0;
-            if (pal_img_n) {
-               // pal_img_n == 3 or 4
-               img_n = pal_img_n; // record the actual colors we had
-               img_out_n = pal_img_n;
-               if (req_comp >= 3) img_out_n = req_comp;
-               if (!expand_palette(palette, pal_len, img_out_n))
-                  return 0;
-            }
-            free(expanded); expanded = NULL;
-            return 1;
-         }
-
-         default:
-            // if critical, fail
-            if ((c.type & (1 << 29)) == 0) {
-               #ifndef STBI_NO_FAILURE_STRINGS
-               static char invalid_chunk[] = "XXXX chunk not known";
-               invalid_chunk[0] = (uint8) (c.type >> 24);
-               invalid_chunk[1] = (uint8) (c.type >> 16);
-               invalid_chunk[2] = (uint8) (c.type >>  8);
-               invalid_chunk[3] = (uint8) (c.type >>  0);
-               #endif
-               return e(invalid_chunk, "PNG not supported: unknown chunk type");
-            }
-            skip(c.length);
-            break;
-      }
-      // end of chunk, read and skip CRC
-      get8(); get8(); get8(); get8();
-   }
-}
-
-static unsigned char *do_png(int *x, int *y, int *n, int req_comp)
-{
-   unsigned char *result=NULL;
-   if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
-   if (parse_png_file(SCAN_load, req_comp)) {
-      result = out;
-      out = NULL;
-      if (req_comp && req_comp != img_out_n) {
-         result = convert_format(result, img_out_n, req_comp);
-         if (result == NULL) return result;
-      }
-      *x = img_x;
-      *y = img_y;
-      if (n) *n = img_n;
-   }
-   free(out);      out      = NULL;
-   free(expanded); expanded = NULL;
-   free(idata);    idata    = NULL;
-
-   return result;
-}
-
-#ifndef STBI_NO_STDIO
-unsigned char *stbi_png_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   start_file(f);
-   return do_png(x,y,comp,req_comp);
-}
-
-unsigned char *stbi_png_load(char *filename, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_png_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-#endif
-
-unsigned char *stbi_png_load_from_memory(unsigned char *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   start_mem(buffer,len);
-   return do_png(x,y,comp,req_comp);
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_png_test_file(FILE *f)
-{
-   int n,r;
-   n = ftell(f);
-   start_file(f);
-   r = parse_png_file(SCAN_type,STBI_default);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int stbi_png_test_memory(unsigned char *buffer, int len)
-{
-   start_mem(buffer, len);
-   return parse_png_file(SCAN_type,STBI_default);
-}
-
-// TODO: load header from png
-#ifndef STBI_NO_STDIO
-extern int      stbi_png_info             (char *filename,           int *x, int *y, int *comp);
-extern int      stbi_png_info_from_file   (FILE *f,                  int *x, int *y, int *comp);
-#endif
-extern int      stbi_png_info_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp);
-
-// Microsoft/Windows BMP image
-
-static int bmp_test(void)
-{
-   int sz;
-   if (get8() != 'B') return 0;
-   if (get8() != 'M') return 0;
-   get32le(); // discard filesize
-   get16le(); // discard reserved
-   get16le(); // discard reserved
-   get32le(); // discard data offset
-   sz = get32le();
-   if (sz == 12 || sz == 40 || sz == 56 || sz == 108) return 1;
-   return 0;
-}
-
-#ifndef STBI_NO_STDIO
-int      stbi_bmp_test_file        (FILE *f)
-{
-   int r,n = ftell(f);
-   start_file(f);
-   r = bmp_test();
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int      stbi_bmp_test_memory      (stbi_uc *buffer, int len)
-{
-   start_mem(buffer, len);
-   return bmp_test();
-}
-
-// returns 0..31 for the highest set bit
-static int 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 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;
-}
-
-static int shiftsigned(int v, int shift, int bits)
-{
-   int result;
-   int z=0;
-
-   if (shift < 0) v <<= -shift;
-   else v >>= shift;
-   result = v;
-
-   z = bits;
-   while (z < 8) {
-      result += v >> z;
-      z += bits;
-   }
-   return result;
-}
-
-static stbi_uc *bmp_load(int *x, int *y, int *comp, int req_comp)
-{
-   unsigned int mr=0,mg=0,mb=0,ma=0;
-   stbi_uc pal[256][4];
-   int psize=0,i,j,compress=0,width;
-   int bpp, flip_vertically, pad, target, offset, hsz;
-   if (get8() != 'B' || get8() != 'M') return epuc("not BMP", "Corrupt BMP");
-   get32le(); // discard filesize
-   get16le(); // discard reserved
-   get16le(); // discard reserved
-   offset = get32le();
-   hsz = get32le();
-   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) return epuc("unknown BMP", "BMP type not supported: unknown");
-   failure_reason = "bad BMP";
-   if (hsz == 12) {
-      img_x = get16le();
-      img_y = get16le();
-   } else {
-      img_x = get32le();
-      img_y = get32le();
-   }
-   if (get16le() != 1) return 0;
-   bpp = get16le();
-   if (bpp == 1) return epuc("monochrome", "BMP type not supported: 1-bit");
-   flip_vertically = ((int) img_y) > 0;
-   img_y = abs((int) img_y);
-   if (hsz == 12) {
-      if (bpp < 24)
-         psize = (offset - 14 - 24) / 3;
-   } else {
-      compress = get32le();
-      if (compress == 1 || compress == 2) return epuc("BMP RLE", "BMP type not supported: RLE");
-      get32le(); // discard sizeof
-      get32le(); // discard hres
-      get32le(); // discard vres
-      get32le(); // discard colorsused
-      get32le(); // discard max important
-      if (hsz == 40 || hsz == 56) {
-         if (hsz == 56) {
-            get32le();
-            get32le();
-            get32le();
-            get32le();
-         }
-         if (bpp == 16 || bpp == 32) {
-            mr = mg = mb = 0;
-            if (compress == 0) {
-               if (bpp == 32) {
-                  mr = 0xff << 16;
-                  mg = 0xff <<  8;
-                  mb = 0xff <<  0;
-               } else {
-                  mr = 31 << 10;
-                  mg = 31 <<  5;
-                  mb = 31 <<  0;
-               }
-            } else if (compress == 3) {
-               mr = get32le();
-               mg = get32le();
-               mb = get32le();
-               // not documented, but generated by photoshop and handled by mspaint
-               if (mr == mg && mg == mb) {
-                  // ?!?!?
-                  return NULL;
-               }
-            } else
-               return NULL;
-         }
-      } else {
-         assert(hsz == 108);
-         mr = get32le();
-         mg = get32le();
-         mb = get32le();
-         ma = get32le();
-         get32le(); // discard color space
-         for (i=0; i < 12; ++i)
-            get32le(); // discard color space parameters
-      }
-      if (bpp < 16)
-         psize = (offset - 14 - hsz) >> 2;
-   }
-   img_n = ma ? 4 : 3;
-   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
-      target = req_comp;
-   else
-      target = img_n; // if they want monochrome, we'll post-convert
-   out = (stbi_uc *) malloc(target * img_x * img_y);
-   if (!out) return epuc("outofmem", "Out of memory");
-   if (bpp < 16) {
-      int z=0;
-      if (psize == 0 || psize > 256) return epuc("invalid", "Corrupt BMP");
-      for (i=0; i < psize; ++i) {
-         pal[i][2] = get8();
-         pal[i][1] = get8();
-         pal[i][0] = get8();
-         if (hsz != 12) get8();
-         pal[i][3] = 255;
-      }
-      skip(offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4));
-      if (bpp == 4) width = (img_x + 1) >> 1;
-      else if (bpp == 8) width = img_x;
-      else return epuc("bad bpp", "Corrupt BMP");
-      pad = (-width)&3;
-      for (j=0; j < (int) img_y; ++j) {
-         for (i=0; i < (int) img_x; i += 2) {
-            int v=get8(),v2=0;
-            if (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) img_x) break;
-            v = (bpp == 8) ? get8() : v2;
-            out[z++] = pal[v][0];
-            out[z++] = pal[v][1];
-            out[z++] = pal[v][2];
-            if (target == 4) out[z++] = 255;
-         }
-         skip(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;
-      skip(offset - 14 - hsz);
-      if (bpp == 24) width = 3 * img_x;
-      else if (bpp == 16) width = 2*img_x;
-      else /* bpp = 32 and pad = 0 */ width=0;
-      pad = (-width) & 3;
-      if (bpp == 24) {
-         easy = 1;
-      } else if (bpp == 32) {
-         if (mb == 0xff && mg == 0xff00 && mr == 0xff000000 && ma == 0xff000000)
-            easy = 2;
-      }
-      if (!easy) {
-         if (!mr || !mg || !mb) return epuc("bad masks", "Corrupt BMP");
-         // right shift amt to put high bit in position #7
-         rshift = high_bit(mr)-7; rcount = bitcount(mr);
-         gshift = high_bit(mg)-7; gcount = bitcount(mr);
-         bshift = high_bit(mb)-7; bcount = bitcount(mr);
-         ashift = high_bit(ma)-7; acount = bitcount(mr);
-      }
-      for (j=0; j < (int) img_y; ++j) {
-         if (easy) {
-            for (i=0; i < (int) img_x; ++i) {
-               int a;
-               out[z+2] = get8();
-               out[z+1] = get8();
-               out[z+0] = get8();
-               z += 3;
-               a = (easy == 2 ? get8() : 255);
-               if (target == 4) out[z++] = a;
-            }
-         } else {
-            for (i=0; i < (int) img_x; ++i) {
-               unsigned long v = (bpp == 16 ? get16le() : get32le());
-               int a;
-               out[z++] = shiftsigned(v & mr, rshift, rcount);
-               out[z++] = shiftsigned(v & mg, gshift, gcount);
-               out[z++] = shiftsigned(v & mb, bshift, bcount);
-               a = (ma ? shiftsigned(v & ma, ashift, acount) : 255);
-               if (target == 4) out[z++] = a; 
-            }
-         }
-         skip(pad);
-      }
-   }
-   if (flip_vertically) {
-      stbi_uc t;
-      for (j=0; j < (int) img_y>>1; ++j) {
-         stbi_uc *p1 = out +      j     *img_x*target;
-         stbi_uc *p2 = out + (img_y-1-j)*img_x*target;
-         for (i=0; i < (int) img_x*target; ++i) {
-            t = p1[i], p1[i] = p2[i], p2[i] = t;
-         }
-      }
-   }
-
-   if (req_comp && req_comp != target) {
-      out = convert_format(out, target, req_comp);
-      if (out == NULL) return out; // convert_format frees input on failure
-   }
-
-   *x = img_x;
-   *y = img_y;
-   if (comp) *comp = target;
-   return out;
-}
-
-#ifndef STBI_NO_STDIO
-stbi_uc *stbi_bmp_load             (char *filename,           int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_bmp_load_from_file(f, x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-
-stbi_uc *stbi_bmp_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
-{
-   start_file(f);
-   return bmp_load(x,y,comp,req_comp);
-}
-#endif
-
-stbi_uc *stbi_bmp_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   start_mem(buffer, len);
-   return bmp_load(x,y,comp,req_comp);
-}
-
-// Targa Truevision - TGA
-// by Jonathan Dummer
-
-static int tga_test(void)
-{
-	int sz;
-	get8u();		//	discard Offset
-	sz = get8u();	//	color type
-	if( sz > 1 ) return 0;	//	only RGB or indexed allowed
-	sz = get8u();	//	image type
-	if( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0;	//	only RGB or grey allowed, +/- RLE
-	get16();		//	discard palette start
-	get16();		//	discard palette length
-	get8();			//	discard bits per palette color entry
-	get16();		//	discard x origin
-	get16();		//	discard y origin
-	if( get16() < 1 ) return 0;		//	test width
-	if( get16() < 1 ) return 0;		//	test height
-	sz = get8();	//	bits per pixel
-	if( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) ) return 0;	//	only RGB or RGBA or grey allowed
-	return 1;		//	seems to have passed everything
-}
-
-#ifndef STBI_NO_STDIO
-int      stbi_tga_test_file        (FILE *f)
-{
-   int r,n = ftell(f);
-   start_file(f);
-   r = tga_test();
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int      stbi_tga_test_memory      (stbi_uc *buffer, int len)
-{
-   start_mem(buffer, len);
-   return tga_test();
-}
-
-static stbi_uc *tga_load(int *x, int *y, int *comp, int req_comp)
-{
-	//	read in the TGA header stuff
-	int tga_offset = get8u();
-	int tga_indexed = get8u();
-	int tga_image_type = get8u();
-	int tga_is_RLE = 0;
-	int tga_palette_start = get16le();
-	int tga_palette_len = get16le();
-	int tga_palette_bits = get8u();
-	int tga_x_origin = get16le();
-	int tga_y_origin = get16le();
-	int tga_width = get16le();
-	int tga_height = get16le();
-	int tga_bits_per_pixel = get8u();
-	int tga_inverted = get8u();
-	//	image data
-	unsigned char *tga_data;
-	unsigned char *tga_palette = NULL;
-	int i, j;
-	unsigned char raw_data[4];
-	unsigned char trans_data[4];
-	int RLE_count = 0;
-	int RLE_repeating = 0;
-	int read_next_pixel = 1;
-	//	do a tiny bit of precessing
-	if( tga_image_type >= 8 )
-	{
-		tga_image_type -= 8;
-		tga_is_RLE = 1;
-	}
-	/* int tga_alpha_bits = tga_inverted & 15; */
-	tga_inverted = 1 - ((tga_inverted >> 5) & 1);
-
-	//	error check
-	if( //(tga_indexed) ||
-		(tga_width < 1) || (tga_height < 1) ||
-		(tga_image_type < 1) || (tga_image_type > 3) ||
-		((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) &&
-		(tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32))
-		)
-	{
-		return NULL;
-	}
-
-	//	If I'm paletted, then I'll use the number of bits from the palette
-	if( tga_indexed )
-	{
-		tga_bits_per_pixel = tga_palette_bits;
-	}
-
-	//	tga info
-	*x = tga_width;
-	*y = tga_height;
-	if( (req_comp < 1) || (req_comp > 4) )
-	{
-		//	just use whatever the file was
-		req_comp = tga_bits_per_pixel / 8;
-		*comp = req_comp;
-	} else
-	{
-		//	force a new number of components
-		*comp = tga_bits_per_pixel/8;
-	}
-	tga_data = (unsigned char*)malloc( tga_width * tga_height * req_comp );
-
-	//	skip to the data's starting position (offset usually = 0)
-	skip( tga_offset );
-	//	do I need to load a palette?
-	if( tga_indexed )
-	{
-		//	any data to skip? (offset usually = 0)
-		skip( tga_palette_start );
-		//	load the palette
-		tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 );
-		getn( tga_palette, tga_palette_len * tga_palette_bits / 8 );
-	}
-	//	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 chunk?
-		if( tga_is_RLE )
-		{
-			if( RLE_count == 0 )
-			{
-				//	yep, get the next byte as a RLE command
-				int RLE_cmd = get8u();
-				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 1 byte, then perform the lookup
-				int pal_idx = get8u();
-				if( pal_idx >= tga_palette_len )
-				{
-					//	invalid index
-					pal_idx = 0;
-				}
-				pal_idx *= tga_bits_per_pixel / 8;
-				for( j = 0; j*8 < tga_bits_per_pixel; ++j )
-				{
-					raw_data[j] = tga_palette[pal_idx+j];
-				}
-			} else
-			{
-				//	read in the data raw
-				for( j = 0; j*8 < tga_bits_per_pixel; ++j )
-				{
-					raw_data[j] = get8u();
-				}
-			}
-			//	convert raw to the intermediate format
-			switch( tga_bits_per_pixel )
-			{
-			case 8:
-				//	Luminous => RGBA
-				trans_data[0] = raw_data[0];
-				trans_data[1] = raw_data[0];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = 255;
-				break;
-			case 16:
-				//	Luminous,Alpha => RGBA
-				trans_data[0] = raw_data[0];
-				trans_data[1] = raw_data[0];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = raw_data[1];
-				break;
-			case 24:
-				//	BGR => RGBA
-				trans_data[0] = raw_data[2];
-				trans_data[1] = raw_data[1];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = 255;
-				break;
-			case 32:
-				//	BGRA => RGBA
-				trans_data[0] = raw_data[2];
-				trans_data[1] = raw_data[1];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = raw_data[3];
-				break;
-			}
-			//	clear the reading flag for the next pixel
-			read_next_pixel = 0;
-		} // end of reading a pixel
-		//	convert to final format
-		switch( req_comp )
-		{
-		case 1:
-			//	RGBA => Luminance
-			tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]);
-			break;
-		case 2:
-			//	RGBA => Luminance,Alpha
-			tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]);
-			tga_data[i*req_comp+1] = trans_data[3];
-			break;
-		case 3:
-			//	RGBA => RGB
-			tga_data[i*req_comp+0] = trans_data[0];
-			tga_data[i*req_comp+1] = trans_data[1];
-			tga_data[i*req_comp+2] = trans_data[2];
-			break;
-		case 4:
-			//	RGBA => RGBA
-			tga_data[i*req_comp+0] = trans_data[0];
-			tga_data[i*req_comp+1] = trans_data[1];
-			tga_data[i*req_comp+2] = trans_data[2];
-			tga_data[i*req_comp+3] = trans_data[3];
-			break;
-		}
-		//	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 * req_comp;
-			int index2 = (tga_height - 1 - j) * tga_width * req_comp;
-			for( i = tga_width * req_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 )
-	{
-		free( tga_palette );
-	}
-	//	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;
-}
-
-#ifndef STBI_NO_STDIO
-stbi_uc *stbi_tga_load             (char *filename,           int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_tga_load_from_file(f, x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-
-stbi_uc *stbi_tga_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
-{
-   start_file(f);
-   return tga_load(x,y,comp,req_comp);
-}
-#endif
-
-stbi_uc *stbi_tga_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   start_mem(buffer, len);
-   return tga_load(x,y,comp,req_comp);
-}
-
-
-// *************************************************************************************************
-// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicholas Schulz, tweaked by STB
-
-static int psd_test(void)
-{
-	if (get32() != 0x38425053) return 0;	// "8BPS"
-	else return 1;
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_psd_test_file(FILE *f)
-{
-   int r,n = ftell(f);
-   start_file(f);
-   r = psd_test();
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int stbi_psd_test_memory(stbi_uc *buffer, int len)
-{
-   start_mem(buffer, len);
-   return psd_test();
-}
-
-static stbi_uc *psd_load(int *x, int *y, int *comp, int req_comp)
-{
-	int	pixelCount;
-	int channelCount, compression;
-	int channel, i, count, len;
-   int w,h;
-
-	// Check identifier
-	if (get32() != 0x38425053)	// "8BPS"
-		return epuc("not PSD", "Corrupt PSD image");
-
-	// Check file type version.
-	if (get16() != 1)
-		return epuc("wrong version", "Unsupported version of PSD image");
-
-	// Skip 6 reserved bytes.
-	skip( 6 );
-
-	// Read the number of channels (R, G, B, A, etc).
-	channelCount = get16();
-	if (channelCount < 0 || channelCount > 16)
-		return epuc("wrong channel count", "Unsupported number of channels in PSD image");
-
-	// Read the rows and columns of the image.
-   h = get32();
-   w = get32();
-	
-	// Make sure the depth is 8 bits.
-	if (get16() != 8)
-		return epuc("unsupported bit depth", "PSD bit depth is not 8 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 (get16() != 3)
-		return epuc("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.)
-	skip(get32() );
-
-	// Skip the image resources.  (resolution, pen tool paths, etc)
-	skip( get32() );
-
-	// Skip the reserved data.
-	skip( get32() );
-
-	// Find out if the data is compressed.
-	// Known values:
-	//   0: no compression
-	//   1: RLE compressed
-	compression = get16();
-	if (compression > 1)
-		return epuc("unknown compression type", "PSD has an unknown compression format");
-
-	// Create the destination image.
-	out = (stbi_uc *) malloc(4 * w*h);
-	if (!out) return epuc("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 preceeded by a 2-byte data count for each row in the data,
-		// which we're going to just skip.
-		skip( h * channelCount * 2 );
-
-		// Read the RLE data by channel.
-		for (channel = 0; channel < 4; channel++) {
-			uint8 *p;
-			
-         p = out+channel;
-			if (channel >= channelCount) {
-				// Fill this channel with default data.
-				for (i = 0; i < pixelCount; i++) *p = (channel == 3 ? 255 : 0), p += 4;
-			} else {
-				// Read the RLE data.
-				count = 0;
-				while (count < pixelCount) {
-					len = get8();
-					if (len == 128) {
-						// No-op.
-					} else if (len < 128) {
-						// Copy next len+1 bytes literally.
-						len++;
-						count += len;
-						while (len) {
-							*p = get8();
-                     p += 4;
-							len--;
-						}
-					} else if (len > 128) {
-						uint32	val;
-						// Next -len+1 bytes in the dest are replicated from next source byte.
-						// (Interpret len as a negative 8-bit int.)
-						len ^= 0x0FF;
-						len += 2;
-                  val = get8();
-						count += len;
-						while (len) {
-							*p = val;
-                     p += 4;
-							len--;
-						}
-					}
-				}
-			}
-		}
-		
-	} 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 value for each pixel in the image.
-		
-		// Read the data by channel.
-		for (channel = 0; channel < 4; channel++) {
-			uint8 *p;
-			
-         p = out + channel;
-			if (channel > channelCount) {
-				// Fill this channel with default data.
-				for (i = 0; i < pixelCount; i++) *p = channel == 3 ? 255 : 0, p += 4;
-			} else {
-				// Read the data.
-				count = 0;
-				for (i = 0; i < pixelCount; i++)
-					*p = get8(), p += 4;
-			}
-		}
-	}
-
-	if (req_comp && req_comp != 4) {
-      img_x = w;
-      img_y = h;
-		out = convert_format(out, 4, req_comp);
-		if (out == NULL) return out; // convert_format frees input on failure
-	}
-
-	if (comp) *comp = channelCount;
-	*y = h;
-	*x = w;
-	
-	return out;
-}
-
-#ifndef STBI_NO_STDIO
-stbi_uc *stbi_psd_load(char *filename, int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_psd_load_from_file(f, x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-
-stbi_uc *stbi_psd_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   start_file(f);
-   return psd_load(x,y,comp,req_comp);
-}
-#endif
-
-stbi_uc *stbi_psd_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   start_mem(buffer, len);
-   return psd_load(x,y,comp,req_comp);
-}
-
-
-// *************************************************************************************************
-// Radiance RGBE HDR loader
-// originally by Nicolas Schulz
-#ifndef STBI_NO_HDR
-static int hdr_test(void)
-{
-   char *signature = "#?RADIANCE\n";
-   int i;
-   for (i=0; signature[i]; ++i)
-      if (get8() != signature[i])
-         return 0;
-	return 1;
-}
-
-int stbi_hdr_test_memory(stbi_uc *buffer, int len)
-{
-	start_mem(buffer, len);
-	return hdr_test();
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_hdr_test_file(FILE *f)
-{
-   int r,n = ftell(f);
-   start_file(f);
-   r = hdr_test();
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-#define HDR_BUFLEN  1024
-static char *hdr_gettoken(char *buffer)
-{
-   int len=0;
-	char *s = buffer, c = '\0';
-
-   c = get8();
-
-	while (!at_eof() && c != '\n') {
-		buffer[len++] = c;
-      if (len == HDR_BUFLEN-1) {
-         // flush to end of line
-         while (!at_eof() && get8() != '\n')
-            ;
-         break;
-      }
-      c = get8();
-	}
-
-   buffer[len] = 0;
-	return buffer;
-}
-
-static void 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 *hdr_load(int *x, int *y, int *comp, int req_comp)
-{
-   char buffer[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;
-
-
-	// Check identifier
-	if (strcmp(hdr_gettoken(buffer), "#?RADIANCE") != 0)
-		return epf("not HDR", "Corrupt HDR image");
-	
-	// Parse header
-	while(1) {
-		token = hdr_gettoken(buffer);
-      if (token[0] == 0) break;
-		if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
-   }
-
-	if (!valid)    return epf("unsupported format", "Unsupported HDR format");
-
-   // Parse width and height
-   // can't use sscanf() if we're not using stdio!
-   token = hdr_gettoken(buffer);
-   if (strncmp(token, "-Y ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   height = strtol(token, &token, 10);
-   while (*token == ' ') ++token;
-   if (strncmp(token, "+X ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   width = strtol(token, NULL, 10);
-
-	*x = width;
-	*y = height;
-
-   *comp = 3;
-	if (req_comp == 0) req_comp = 3;
-
-	// Read data
-	hdr_data = (float *) malloc(height * width * req_comp * sizeof(float));
-
-	// 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:
-            getn(rgbe, 4);
-            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 = get8();
-         c2 = get8();
-         len = get8();
-         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] = { c1,c2,len, get8() };
-            hdr_convert(hdr_data, rgbe, req_comp);
-            i = 1;
-            j = 0;
-            free(scanline);
-            goto main_decode_loop; // yes, this is fucking insane; blame the fucking insane format
-         }
-         len <<= 8;
-         len |= get8();
-         if (len != width) { free(hdr_data); free(scanline); return epf("invalid decoded scanline length", "corrupt HDR"); }
-         if (scanline == NULL) scanline = (stbi_uc *) malloc(width * 4);
-				
-			for (k = 0; k < 4; ++k) {
-				i = 0;
-				while (i < width) {
-					count = get8();
-					if (count > 128) {
-						// Run
-						value = get8();
-                  count -= 128;
-						for (z = 0; z < count; ++z)
-							scanline[i++ * 4 + k] = value;
-					} else {
-						// Dump
-						for (z = 0; z < count; ++z)
-							scanline[i++ * 4 + k] = get8();
-					}
-				}
-			}
-         for (i=0; i < width; ++i)
-            hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
-		}
-      free(scanline);
-	}
-
-   return hdr_data;
-}
-
-#ifndef STBI_NO_STDIO
-float *stbi_hdr_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   start_file(f);
-   return hdr_load(x,y,comp,req_comp);
-}
-#endif
-
-float *stbi_hdr_load_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   start_mem(buffer, len);
-   return hdr_load(x,y,comp,req_comp);
-}
-
-#endif // STBI_NO_HDR
-
-/////////////////////// write image ///////////////////////
-
-#ifndef STBI_NO_WRITE
-
-static void write8(FILE *f, int x) { uint8 z = (uint8) x; fwrite(&z,1,1,f); }
-
-static void writefv(FILE *f, char *fmt, va_list v)
-{
-   while (*fmt) {
-      switch (*fmt++) {
-         case ' ': break;
-         case '1': { uint8 x = va_arg(v, int); write8(f,x); break; }
-         case '2': { int16 x = va_arg(v, int); write8(f,x); write8(f,x>>8); break; }
-         case '4': { int32 x = va_arg(v, int); write8(f,x); write8(f,x>>8); write8(f,x>>16); write8(f,x>>24); break; }
-         default:
-            assert(0);
-            va_end(v);
-            return;
-      }
-   }
-}
-
-static void writef(FILE *f, char *fmt, ...)
-{
-   va_list v;
-   va_start(v, fmt);
-   writefv(f,fmt,v);
-   va_end(v);
-}
-
-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)
-{
-   uint8 bg[3] = { 255, 0, 255}, px[3];
-   uint32 zero = 0;
-   int i,j,k, j_end;
-
-   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) {
-         uint8 *d = (uint8 *) data + (j*x+i)*comp;
-         if (write_alpha < 0)
-            fwrite(&d[comp-1], 1, 1, f);
-         switch (comp) {
-            case 1:
-            case 2: writef(f, "111", d[0],d[0],d[0]);
-                    break;
-            case 4:
-               if (!write_alpha) {
-                  for (k=0; k < 3; ++k)
-                     px[k] = bg[k] + ((d[k] - bg[k]) * d[3])/255;
-                  writef(f, "111", px[1-rgb_dir],px[1],px[1+rgb_dir]);
-                  break;
-               }
-               /* FALLTHROUGH */
-            case 3:
-               writef(f, "111", 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 *filename, int rgb_dir, int vdir, int x, int y, int comp, void *data, int alpha, int pad, char *fmt, ...)
-{
-   FILE *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 *filename, int x, int y, int comp, void *data)
-{
-   int pad = (-x*3) & 3;
-   return outfile(filename,-1,-1,x,y,comp,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 *filename, int x, int y, int comp, void *data)
-{
-   int has_alpha = !(comp & 1);
-   return outfile(filename, -1,-1, x, y, comp, 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);
-}
-
-// any other image formats that do interleaved rgb data?
-//    PNG: requires adler32,crc32 -- significant amount of code
-//    PSD: no, channels output separately
-//    TIFF: no, stripwise-interleaved... i think
-
-#endif // STBI_NO_WRITE
diff --git a/4dm.h/soil/original/stb_image-1.16.c b/4dm.h/soil/original/stb_image-1.16.c
deleted file mode 100644
index cfa8dc8..0000000
--- a/4dm.h/soil/original/stb_image-1.16.c
+++ /dev/null
@@ -1,3821 +0,0 @@
-/* stbi-1.16 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
-                      when you control the images you're loading
-
-   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, no oddball channel decimations)
-      PNG non-interlaced
-      BMP non-1bpp, non-RLE
-      TGA (not sure what subset, if a subset)
-      PSD (composited view only, no extra channels)
-      HDR (radiance rgbE format)
-      writes BMP,TGA (define STBI_NO_WRITE to remove code)
-      decoded from memory or through stdio FILE (define STBI_NO_STDIO to remove code)
-      supports installable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
-        
-   TODO:
-      stbi_info_*
-  
-   history:
-      1.16   major bugfix - 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
-*/
-
-
-#ifndef STBI_INCLUDE_STB_IMAGE_H
-#define STBI_INCLUDE_STB_IMAGE_H
-
-////   begin header file  ////////////////////////////////////////////////////
-//
-// Limitations:
-//    - no progressive/interlaced support (jpeg, png)
-//    - 8-bit samples only (jpeg, png)
-//    - not threadsafe
-//    - channel subsampling of at most 2 in each dimension (jpeg)
-//    - no delayed line count (jpeg) -- IJG doesn't support either
-//
-// 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
-//    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 and BMP images are automatically depalettized.
-//
-//
-// ===========================================================================
-//
-// 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);
-
-#ifndef STBI_NO_STDIO
-#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
-
-// WRITING API
-
-#if !defined(STBI_NO_WRITE) && !defined(STBI_NO_STDIO)
-// write a BMP/TGA file given tightly packed 'comp' channels (no padding, nor bmp-stride-padding)
-// (you must include the appropriate extension in the filename).
-// returns TRUE on success, FALSE if couldn't open file, error writing file
-extern int      stbi_write_bmp       (char const *filename,     int x, int y, int comp, void *data);
-extern int      stbi_write_tga       (char const *filename,     int x, int y, int comp, void *data);
-#endif
-
-// PRIMARY API - works on images of any type
-
-// load image by filename, open file, or memory buffer
-#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);
-extern int      stbi_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-#endif
-extern stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-// for stbi_load_from_file, file pointer is left pointing immediately after image
-
-#ifndef STBI_NO_HDR
-#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_memory(stbi_uc const *buffer, int len, 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
-
-// get a VERY brief reason for failure
-// NOT THREADSAFE
-extern 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_is_hdr_from_memory(stbi_uc const *buffer, int len);
-#ifndef STBI_NO_STDIO
-extern int      stbi_info            (char const *filename,     int *x, int *y, int *comp);
-extern int      stbi_is_hdr          (char const *filename);
-extern int      stbi_is_hdr_from_file(FILE *f);
-#endif
-
-// 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);
-
-// TYPE-SPECIFIC ACCESS
-
-// is it a jpeg?
-extern int      stbi_jpeg_test_memory     (stbi_uc const *buffer, int len);
-extern stbi_uc *stbi_jpeg_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-extern int      stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-
-#ifndef STBI_NO_STDIO
-extern stbi_uc *stbi_jpeg_load            (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern int      stbi_jpeg_test_file       (FILE *f);
-extern stbi_uc *stbi_jpeg_load_from_file  (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-
-extern int      stbi_jpeg_info            (char const *filename,     int *x, int *y, int *comp);
-extern int      stbi_jpeg_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-#endif
-
-// is it a png?
-extern int      stbi_png_test_memory      (stbi_uc const *buffer, int len);
-extern stbi_uc *stbi_png_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-extern int      stbi_png_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-
-#ifndef STBI_NO_STDIO
-extern stbi_uc *stbi_png_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern int      stbi_png_info             (char const *filename,     int *x, int *y, int *comp);
-extern int      stbi_png_test_file        (FILE *f);
-extern stbi_uc *stbi_png_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-extern int      stbi_png_info_from_file   (FILE *f,                  int *x, int *y, int *comp);
-#endif
-
-// is it a bmp?
-extern int      stbi_bmp_test_memory      (stbi_uc const *buffer, int len);
-
-extern stbi_uc *stbi_bmp_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_bmp_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_bmp_test_file        (FILE *f);
-extern stbi_uc *stbi_bmp_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// is it a tga?
-extern int      stbi_tga_test_memory      (stbi_uc const *buffer, int len);
-
-extern stbi_uc *stbi_tga_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_tga_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_tga_test_file        (FILE *f);
-extern stbi_uc *stbi_tga_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// is it a psd?
-extern int      stbi_psd_test_memory      (stbi_uc const *buffer, int len);
-
-extern stbi_uc *stbi_psd_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_psd_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_psd_test_file        (FILE *f);
-extern stbi_uc *stbi_psd_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// is it an hdr?
-extern int      stbi_hdr_test_memory      (stbi_uc const *buffer, int len);
-
-extern float *  stbi_hdr_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern float *  stbi_hdr_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_hdr_test_file        (FILE *f);
-extern float *  stbi_hdr_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// define new loaders
-typedef struct
-{
-   int       (*test_memory)(stbi_uc const *buffer, int len);
-   stbi_uc * (*load_from_memory)(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-   #ifndef STBI_NO_STDIO
-   int       (*test_file)(FILE *f);
-   stbi_uc * (*load_from_file)(FILE *f, int *x, int *y, int *comp, int req_comp);
-   #endif
-} stbi_loader;
-
-// register a loader by filling out the above structure (you must defined ALL functions)
-// returns 1 if added or already added, 0 if not added (too many loaders)
-// NOT THREADSAFE
-extern int stbi_register_loader(stbi_loader *loader);
-
-// define faster low-level operations (typically SIMD support)
-#if STBI_SIMD
-typedef void (*stbi_idct_8x8)(uint8 *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)(uint8 *output, uint8 const *y, uint8 const *cb, uint8 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
-
-#ifndef STBI_HEADER_FILE_ONLY
-
-#ifndef STBI_NO_HDR
-#include <math.h>  // ldexp
-#include <string.h> // strcmp
-#endif
-
-#ifndef STBI_NO_STDIO
-#include <stdio.h>
-#endif
-#include <stdlib.h>
-#include <memory.h>
-#include <assert.h>
-#include <stdarg.h>
-
-#ifndef _MSC_VER
-  #ifdef __cplusplus
-  #define __forceinline inline
-  #else
-  #define __forceinline
-  #endif
-#endif
-
-
-// implementation:
-typedef unsigned char uint8;
-typedef unsigned short uint16;
-typedef   signed short  int16;
-typedef unsigned int   uint32;
-typedef   signed int    int32;
-typedef unsigned int   uint;
-
-// should produce compiler error if size is wrong
-typedef unsigned char validate_uint32[sizeof(uint32)==4];
-
-#if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE)
-#define STBI_NO_WRITE
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Generic API that works on all image types
-//
-
-// this is not threadsafe
-static char *failure_reason;
-
-char *stbi_failure_reason(void)
-{
-   return failure_reason;
-}
-
-static int e(char *str)
-{
-   failure_reason = str;
-   return 0;
-}
-
-#ifdef STBI_NO_FAILURE_STRINGS
-   #define e(x,y)  0
-#elif defined(STBI_FAILURE_USERMSG)
-   #define e(x,y)  e(y)
-#else
-   #define e(x,y)  e(x)
-#endif
-
-#define epf(x,y)   ((float *) (e(x,y)?NULL:NULL))
-#define epuc(x,y)  ((unsigned char *) (e(x,y)?NULL:NULL))
-
-void stbi_image_free(void *retval_from_stbi_load)
-{
-   free(retval_from_stbi_load);
-}
-
-#define MAX_LOADERS  32
-stbi_loader *loaders[MAX_LOADERS];
-static int max_loaders = 0;
-
-int stbi_register_loader(stbi_loader *loader)
-{
-   int i;
-   for (i=0; i < MAX_LOADERS; ++i) {
-      // already present?
-      if (loaders[i] == loader)
-         return 1;
-      // end of the list?
-      if (loaders[i] == NULL) {
-         loaders[i] = loader;
-         max_loaders = i+1;
-         return 1;
-      }
-   }
-   // no room for it
-   return 0;
-}
-
-#ifndef STBI_NO_HDR
-static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
-static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp);
-#endif
-
-#ifndef STBI_NO_STDIO
-unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   FILE *f = fopen(filename, "rb");
-   unsigned char *result;
-   if (!f) return epuc("can't fopen", "Unable to open file");
-   result = stbi_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   int i;
-   if (stbi_jpeg_test_file(f))
-      return stbi_jpeg_load_from_file(f,x,y,comp,req_comp);
-   if (stbi_png_test_file(f))
-      return stbi_png_load_from_file(f,x,y,comp,req_comp);
-   if (stbi_bmp_test_file(f))
-      return stbi_bmp_load_from_file(f,x,y,comp,req_comp);
-   if (stbi_psd_test_file(f))
-      return stbi_psd_load_from_file(f,x,y,comp,req_comp);
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_file(f)) {
-      float *hdr = stbi_hdr_load_from_file(f, x,y,comp,req_comp);
-      return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
-   }
-   #endif
-   for (i=0; i < max_loaders; ++i)
-      if (loaders[i]->test_file(f))
-         return loaders[i]->load_from_file(f,x,y,comp,req_comp);
-   // test tga last because it's a crappy test!
-   if (stbi_tga_test_file(f))
-      return stbi_tga_load_from_file(f,x,y,comp,req_comp);
-   return epuc("unknown image type", "Image not of any known type, or corrupt");
-}
-#endif
-
-unsigned char *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   int i;
-   if (stbi_jpeg_test_memory(buffer,len))
-      return stbi_jpeg_load_from_memory(buffer,len,x,y,comp,req_comp);
-   if (stbi_png_test_memory(buffer,len))
-      return stbi_png_load_from_memory(buffer,len,x,y,comp,req_comp);
-   if (stbi_bmp_test_memory(buffer,len))
-      return stbi_bmp_load_from_memory(buffer,len,x,y,comp,req_comp);
-   if (stbi_psd_test_memory(buffer,len))
-      return stbi_psd_load_from_memory(buffer,len,x,y,comp,req_comp);
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_memory(buffer, len)) {
-      float *hdr = stbi_hdr_load_from_memory(buffer, len,x,y,comp,req_comp);
-      return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
-   }
-   #endif
-   for (i=0; i < max_loaders; ++i)
-      if (loaders[i]->test_memory(buffer,len))
-         return loaders[i]->load_from_memory(buffer,len,x,y,comp,req_comp);
-   // test tga last because it's a crappy test!
-   if (stbi_tga_test_memory(buffer,len))
-      return stbi_tga_load_from_memory(buffer,len,x,y,comp,req_comp);
-   return epuc("unknown image type", "Image not of any known type, or corrupt");
-}
-
-#ifndef STBI_NO_HDR
-
-#ifndef STBI_NO_STDIO
-float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   FILE *f = fopen(filename, "rb");
-   float *result;
-   if (!f) return epf("can't fopen", "Unable to open file");
-   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_file(f))
-      return stbi_hdr_load_from_file(f,x,y,comp,req_comp);
-   #endif
-   data = stbi_load_from_file(f, x, y, comp, req_comp);
-   if (data)
-      return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
-   return epf("unknown image type", "Image not of any known type, or corrupt");
-}
-#endif
-
-float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_memory(buffer, len))
-      return stbi_hdr_load_from_memory(buffer, len,x,y,comp,req_comp);
-   #endif
-   data = stbi_load_from_memory(buffer, len, x, y, comp, req_comp);
-   if (data)
-      return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
-   return epf("unknown image type", "Image not of any known type, or corrupt");
-}
-#endif
-
-// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is
-// defined, for API simplicity; if STBI_NO_HDR is defined, it always
-// reports false!
-
-int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
-{
-   #ifndef STBI_NO_HDR
-   return stbi_hdr_test_memory(buffer, len);
-   #else
-   return 0;
-   #endif
-}
-
-#ifndef STBI_NO_STDIO
-extern int      stbi_is_hdr          (char const *filename)
-{
-   FILE *f = fopen(filename, "rb");
-   int result=0;
-   if (f) {
-      result = stbi_is_hdr_from_file(f);
-      fclose(f);
-   }
-   return result;
-}
-
-extern int      stbi_is_hdr_from_file(FILE *f)
-{
-   #ifndef STBI_NO_HDR
-   return stbi_hdr_test_file(f);
-   #else
-   return 0;
-   #endif
-}
-
-#endif
-
-// @TODO: get image dimensions & components without fully decoding
-#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
-extern int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-
-#ifndef STBI_NO_HDR
-static float h2l_gamma_i=1.0f/2.2f, h2l_scale_i=1.0f;
-static float l2h_gamma=2.2f, l2h_scale=1.0f;
-
-void   stbi_hdr_to_ldr_gamma(float gamma) { h2l_gamma_i = 1/gamma; }
-void   stbi_hdr_to_ldr_scale(float scale) { h2l_scale_i = 1/scale; }
-
-void   stbi_ldr_to_hdr_gamma(float gamma) { l2h_gamma = gamma; }
-void   stbi_ldr_to_hdr_scale(float scale) { l2h_scale = scale; }
-#endif
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Common code used by all image loaders
-//
-
-enum
-{
-   SCAN_load=0,
-   SCAN_type,
-   SCAN_header,
-};
-
-typedef struct
-{
-   uint32 img_x, img_y;
-   int img_n, img_out_n;
-
-   #ifndef STBI_NO_STDIO
-   FILE  *img_file;
-   #endif
-   uint8 *img_buffer, *img_buffer_end;
-} stbi;
-
-#ifndef STBI_NO_STDIO
-static void start_file(stbi *s, FILE *f)
-{
-   s->img_file = f;
-}
-#endif
-
-static void start_mem(stbi *s, uint8 const *buffer, int len)
-{
-#ifndef STBI_NO_STDIO
-   s->img_file = NULL;
-#endif
-   s->img_buffer = (uint8 *) buffer;
-   s->img_buffer_end = (uint8 *) buffer+len;
-}
-
-__forceinline static int get8(stbi *s)
-{
-#ifndef STBI_NO_STDIO
-   if (s->img_file) {
-      int c = fgetc(s->img_file);
-      return c == EOF ? 0 : c;
-   }
-#endif
-   if (s->img_buffer < s->img_buffer_end)
-      return *s->img_buffer++;
-   return 0;
-}
-
-__forceinline static int at_eof(stbi *s)
-{
-#ifndef STBI_NO_STDIO
-   if (s->img_file)
-      return feof(s->img_file);
-#endif
-   return s->img_buffer >= s->img_buffer_end;   
-}
-
-__forceinline static uint8 get8u(stbi *s)
-{
-   return (uint8) get8(s);
-}
-
-static void skip(stbi *s, int n)
-{
-#ifndef STBI_NO_STDIO
-   if (s->img_file)
-      fseek(s->img_file, n, SEEK_CUR);
-   else
-#endif
-      s->img_buffer += n;
-}
-
-static int get16(stbi *s)
-{
-   int z = get8(s);
-   return (z << 8) + get8(s);
-}
-
-static uint32 get32(stbi *s)
-{
-   uint32 z = get16(s);
-   return (z << 16) + get16(s);
-}
-
-static int get16le(stbi *s)
-{
-   int z = get8(s);
-   return z + (get8(s) << 8);
-}
-
-static uint32 get32le(stbi *s)
-{
-   uint32 z = get16le(s);
-   return z + (get16le(s) << 16);
-}
-
-static void getn(stbi *s, stbi_uc *buffer, int n)
-{
-#ifndef STBI_NO_STDIO
-   if (s->img_file) {
-      fread(buffer, 1, n, s->img_file);
-      return;
-   }
-#endif
-   memcpy(buffer, s->img_buffer, n);
-   s->img_buffer += n;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//  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 uint8 compute_y(int r, int g, int b)
-{
-   return (uint8) (((r*77) + (g*150) +  (29*b)) >> 8);
-}
-
-static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp, uint x, uint y)
-{
-   int i,j;
-   unsigned char *good;
-
-   if (req_comp == img_n) return data;
-   assert(req_comp >= 1 && req_comp <= 4);
-
-   good = (unsigned char *) malloc(req_comp * x * y);
-   if (good == NULL) {
-      free(data);
-      return epuc("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 COMBO(a,b)  ((a)*8+(b))
-      #define CASE(a,b)   case 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(COMBO(img_n, req_comp)) {
-         CASE(1,2) dest[0]=src[0], dest[1]=255; break;
-         CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break;
-         CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break;
-         CASE(2,1) dest[0]=src[0]; break;
-         CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break;
-         CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break;
-         CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break;
-         CASE(3,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
-         CASE(3,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = 255; break;
-         CASE(4,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
-         CASE(4,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break;
-         CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break;
-         default: assert(0);
-      }
-      #undef CASE
-   }
-
-   free(data);
-   return good;
-}
-
-#ifndef STBI_NO_HDR
-static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
-{
-   int i,k,n;
-   float *output = (float *) malloc(x * y * comp * sizeof(float));
-   if (output == NULL) { free(data); return epf("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, l2h_gamma) * l2h_scale;
-      }
-      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
-   }
-   free(data);
-   return output;
-}
-
-#define float2int(x)   ((int) (x))
-static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp)
-{
-   int i,k,n;
-   stbi_uc *output = (stbi_uc *) malloc(x * y * comp);
-   if (output == NULL) { free(data); return epuc("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]*h2l_scale_i, h2l_gamma_i) * 255 + 0.5f;
-         if (z < 0) z = 0;
-         if (z > 255) z = 255;
-         output[i*comp + k] = 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] = float2int(z);
-      }
-   }
-   free(data);
-   return output;
-}
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//  "baseline" JPEG/JFIF decoder (not actually fully baseline implementation)
-//
-//    simple implementation
-//      - channel subsampling of at most 2 in each dimension
-//      - 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
-//      - uses a lot of intermediate memory, could cache poorly
-//      - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4
-//          stb_jpeg:   1.34 seconds (MSVC6, default release build)
-//          stb_jpeg:   1.06 seconds (MSVC6, processor = Pentium Pro)
-//          IJL11.dll:  1.08 seconds (compiled by intel)
-//          IJG 1998:   0.98 seconds (MSVC6, makefile provided by IJG)
-//          IJG 1998:   0.95 seconds (MSVC6, makefile + proc=PPro)
-
-// huffman decoding acceleration
-#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
-
-typedef struct
-{
-   uint8  fast[1 << FAST_BITS];
-   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
-   uint16 code[256];
-   uint8  values[256];
-   uint8  size[257];
-   unsigned int maxcode[18];
-   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
-} huffman;
-
-typedef struct
-{
-   #if STBI_SIMD
-   unsigned short dequant2[4][64];
-   #endif
-   stbi s;
-   huffman huff_dc[4];
-   huffman huff_ac[4];
-   uint8 dequant[4][64];
-
-// 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;
-      uint8 *data;
-      void *raw_data;
-      uint8 *linebuf;
-   } img_comp[4];
-
-   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 scan_n, order[4];
-   int restart_interval, todo;
-} jpeg;
-
-static int build_huffman(huffman *h, int *count)
-{
-   int i,j,k=0,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++] = (uint8) (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++] = (uint16) (code++);
-         if (code-1 >= (1 << j)) return e("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] = (uint8) i;
-         }
-      }
-   }
-   return 1;
-}
-
-static void grow_buffer_unsafe(jpeg *j)
-{
-   do {
-      int b = j->nomore ? 0 : get8(&j->s);
-      if (b == 0xff) {
-         int c = get8(&j->s);
-         if (c != 0) {
-            j->marker = (unsigned char) c;
-            j->nomore = 1;
-            return;
-         }
-      }
-      j->code_buffer = (j->code_buffer << 8) | b;
-      j->code_bits += 8;
-   } while (j->code_bits <= 24);
-}
-
-// (1 << n) - 1
-static uint32 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
-__forceinline static int decode(jpeg *j, huffman *h)
-{
-   unsigned int temp;
-   int c,k;
-
-   if (j->code_bits < 16) 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 >> (j->code_bits - FAST_BITS)) & ((1 << FAST_BITS)-1);
-   k = h->fast[c];
-   if (k < 255) {
-      if (h->size[k] > j->code_bits)
-         return -1;
-      j->code_bits -= h->size[k];
-      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.
-   if (j->code_bits < 16)
-      temp = (j->code_buffer << (16 - j->code_bits)) & 0xffff;
-   else
-      temp = (j->code_buffer >> (j->code_bits - 16)) & 0xffff;
-   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 >> (j->code_bits - k)) & bmask[k]) + h->delta[k];
-   assert((((j->code_buffer) >> (j->code_bits - h->size[c])) & bmask[h->size[c]]) == h->code[c]);
-
-   // convert the id to a symbol
-   j->code_bits -= k;
-   return h->values[c];
-}
-
-// combined JPEG 'receive' and JPEG 'extend', since baseline
-// always extends everything it receives.
-__forceinline static int extend_receive(jpeg *j, int n)
-{
-   unsigned int m = 1 << (n-1);
-   unsigned int k;
-   if (j->code_bits < n) grow_buffer_unsafe(j);
-   k = (j->code_buffer >> (j->code_bits - n)) & bmask[n];
-   j->code_bits -= n;
-   // the following test is probably a random branch that won't
-   // predict well. I tried to table accelerate it but failed.
-   // maybe it's compiling as a conditional move?
-   if (k < m)
-      return (-1 << n) + k + 1;
-   else
-      return k;
-}
-
-// 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 uint8 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 decode_block(jpeg *j, short data[64], huffman *hdc, huffman *hac, int b)
-{
-   int diff,dc,k;
-   int t = decode(j, hdc);
-   if (t < 0) return e("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 ? extend_receive(j, t) : 0;
-   dc = j->img_comp[b].dc_pred + diff;
-   j->img_comp[b].dc_pred = dc;
-   data[0] = (short) dc;
-
-   // decode AC components, see JPEG spec
-   k = 1;
-   do {
-      int r,s;
-      int rs = decode(j, hac);
-      if (rs < 0) return e("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
-         data[dezigzag[k++]] = (short) extend_receive(j,s);
-      }
-   } while (k < 64);
-   return 1;
-}
-
-// take a -128..127 value and clamp it and convert to 0..255
-__forceinline static uint8 clamp(int x)
-{
-   x += 128;
-   // 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 (uint8) x;
-}
-
-#define f2f(x)  (int) (((x) * 4096 + 0.5))
-#define fsh(x)  ((x) << 12)
-
-// derived from jidctint -- DCT_ISLOW
-#define 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) * f2f(0.5411961f);             \
-   t2 = p1 + p3*f2f(-1.847759065f);            \
-   t3 = p1 + p2*f2f( 0.765366865f);            \
-   p2 = s0;                                    \
-   p3 = s4;                                    \
-   t0 = fsh(p2+p3);                            \
-   t1 = 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)*f2f( 1.175875602f);            \
-   t0 = t0*f2f( 0.298631336f);                 \
-   t1 = t1*f2f( 2.053119869f);                 \
-   t2 = t2*f2f( 3.072711026f);                 \
-   t3 = t3*f2f( 1.501321110f);                 \
-   p1 = p5 + p1*f2f(-0.899976223f);            \
-   p2 = p5 + p2*f2f(-2.562915447f);            \
-   p3 = p3*f2f(-1.961570560f);                 \
-   p4 = p4*f2f(-0.390180644f);                 \
-   t3 += p1+p4;                                \
-   t2 += p2+p3;                                \
-   t1 += p2+p4;                                \
-   t0 += p1+p3;
-
-#if !STBI_SIMD
-// .344 seconds on 3*anemones.jpg
-static void idct_block(uint8 *out, int out_stride, short data[64], uint8 *dequantize)
-{
-   int i,val[64],*v=val;
-   uint8 *o,*dq = dequantize;
-   short *d = data;
-
-   // columns
-   for (i=0; i < 8; ++i,++d,++dq, ++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] * dq[0] << 2;
-         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
-      } else {
-         IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24],
-                 d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[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
-      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.
-      x0 += 65536; x1 += 65536; x2 += 65536; x3 += 65536;
-      o[0] = clamp((x0+t3) >> 17);
-      o[7] = clamp((x0-t3) >> 17);
-      o[1] = clamp((x1+t2) >> 17);
-      o[6] = clamp((x1-t2) >> 17);
-      o[2] = clamp((x2+t1) >> 17);
-      o[5] = clamp((x2-t1) >> 17);
-      o[3] = clamp((x3+t0) >> 17);
-      o[4] = clamp((x3-t0) >> 17);
-   }
-}
-#else
-static void idct_block(uint8 *out, int out_stride, short data[64], unsigned short *dequantize)
-{
-   int i,val[64],*v=val;
-   uint8 *o;
-   unsigned short *dq = dequantize;
-   short *d = data;
-
-   // columns
-   for (i=0; i < 8; ++i,++d,++dq, ++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] * dq[0] << 2;
-         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
-      } else {
-         IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24],
-                 d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[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
-      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.
-      x0 += 65536; x1 += 65536; x2 += 65536; x3 += 65536;
-      o[0] = clamp((x0+t3) >> 17);
-      o[7] = clamp((x0-t3) >> 17);
-      o[1] = clamp((x1+t2) >> 17);
-      o[6] = clamp((x1-t2) >> 17);
-      o[2] = clamp((x2+t1) >> 17);
-      o[5] = clamp((x2-t1) >> 17);
-      o[3] = clamp((x3+t0) >> 17);
-      o[4] = clamp((x3-t0) >> 17);
-   }
-}
-static stbi_idct_8x8 stbi_idct_installed = idct_block;
-
-extern void stbi_install_idct(stbi_idct_8x8 func)
-{
-   stbi_idct_installed = func;
-}
-#endif
-
-#define 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 uint8 get_marker(jpeg *j)
-{
-   uint8 x;
-   if (j->marker != MARKER_none) { x = j->marker; j->marker = MARKER_none; return x; }
-   x = get8u(&j->s);
-   if (x != 0xff) return MARKER_none;
-   while (x == 0xff)
-      x = get8u(&j->s);
-   return x;
-}
-
-// in each scan, we'll have scan_n components, and the order
-// of the components is specified by order[]
-#define RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
-
-// after a restart interval, reset the entropy decoder and
-// the dc prediction
-static void reset(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 = 0;
-   j->marker = MARKER_none;
-   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
-   // 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 parse_entropy_coded_data(jpeg *z)
-{
-   reset(z);
-   if (z->scan_n == 1) {
-      int i,j;
-      #if STBI_SIMD
-      __declspec(align(16))
-      #endif
-      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) {
-            if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
-            #if STBI_SIMD
-            stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
-            #else
-            idct_block(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
-            #endif
-            // every data block is an MCU, so countdown the restart interval
-            if (--z->todo <= 0) {
-               if (z->code_bits < 24) grow_buffer_unsafe(z);
-               // if it's NOT a restart, then just bail, so we get corrupt data
-               // rather than no data
-               if (!RESTART(z->marker)) return 1;
-               reset(z);
-            }
-         }
-      }
-   } else { // interleaved!
-      int i,j,k,x,y;
-      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;
-                     if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
-                     #if STBI_SIMD
-                     stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
-                     #else
-                     idct_block(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
-                     #endif
-                  }
-               }
-            }
-            // 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) grow_buffer_unsafe(z);
-               // if it's NOT a restart, then just bail, so we get corrupt data
-               // rather than no data
-               if (!RESTART(z->marker)) return 1;
-               reset(z);
-            }
-         }
-      }
-   }
-   return 1;
-}
-
-static int process_marker(jpeg *z, int m)
-{
-   int L;
-   switch (m) {
-      case MARKER_none: // no marker found
-         return e("expected marker","Corrupt JPEG");
-
-      case 0xC2: // SOF - progressive
-         return e("progressive jpeg","JPEG format not supported (progressive)");
-
-      case 0xDD: // DRI - specify restart interval
-         if (get16(&z->s) != 4) return e("bad DRI len","Corrupt JPEG");
-         z->restart_interval = get16(&z->s);
-         return 1;
-
-      case 0xDB: // DQT - define quantization table
-         L = get16(&z->s)-2;
-         while (L > 0) {
-            int q = get8(&z->s);
-            int p = q >> 4;
-            int t = q & 15,i;
-            if (p != 0) return e("bad DQT type","Corrupt JPEG");
-            if (t > 3) return e("bad DQT table","Corrupt JPEG");
-            for (i=0; i < 64; ++i)
-               z->dequant[t][dezigzag[i]] = get8u(&z->s);
-            #if STBI_SIMD
-            for (i=0; i < 64; ++i)
-               z->dequant2[t][i] = dequant[t][i];
-            #endif
-            L -= 65;
-         }
-         return L==0;
-
-      case 0xC4: // DHT - define huffman table
-         L = get16(&z->s)-2;
-         while (L > 0) {
-            uint8 *v;
-            int sizes[16],i,m=0;
-            int q = get8(&z->s);
-            int tc = q >> 4;
-            int th = q & 15;
-            if (tc > 1 || th > 3) return e("bad DHT header","Corrupt JPEG");
-            for (i=0; i < 16; ++i) {
-               sizes[i] = get8(&z->s);
-               m += sizes[i];
-            }
-            L -= 17;
-            if (tc == 0) {
-               if (!build_huffman(z->huff_dc+th, sizes)) return 0;
-               v = z->huff_dc[th].values;
-            } else {
-               if (!build_huffman(z->huff_ac+th, sizes)) return 0;
-               v = z->huff_ac[th].values;
-            }
-            for (i=0; i < m; ++i)
-               v[i] = get8u(&z->s);
-            L -= m;
-         }
-         return L==0;
-   }
-   // check for comment block or APP blocks
-   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
-      skip(&z->s, get16(&z->s)-2);
-      return 1;
-   }
-   return 0;
-}
-
-// after we see SOS
-static int process_scan_header(jpeg *z)
-{
-   int i;
-   int Ls = get16(&z->s);
-   z->scan_n = get8(&z->s);
-   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s.img_n) return e("bad SOS component count","Corrupt JPEG");
-   if (Ls != 6+2*z->scan_n) return e("bad SOS len","Corrupt JPEG");
-   for (i=0; i < z->scan_n; ++i) {
-      int id = get8(&z->s), which;
-      int q = 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;
-      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return e("bad DC huff","Corrupt JPEG");
-      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return e("bad AC huff","Corrupt JPEG");
-      z->order[i] = which;
-   }
-   if (get8(&z->s) != 0) return e("bad SOS","Corrupt JPEG");
-   get8(&z->s); // should be 63, but might be 0
-   if (get8(&z->s) != 0) return e("bad SOS","Corrupt JPEG");
-
-   return 1;
-}
-
-static int process_frame_header(jpeg *z, int scan)
-{
-   stbi *s = &z->s;
-   int Lf,p,i,q, h_max=1,v_max=1,c;
-   Lf = get16(s);         if (Lf < 11) return e("bad SOF len","Corrupt JPEG"); // JPEG
-   p  = get8(s);          if (p != 8) return e("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
-   s->img_y = get16(s);   if (s->img_y == 0) return e("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
-   s->img_x = get16(s);   if (s->img_x == 0) return e("0 width","Corrupt JPEG"); // JPEG requires
-   c = get8(s);
-   if (c != 3 && c != 1) return e("bad component count","Corrupt JPEG");    // JFIF requires
-   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 e("bad SOF len","Corrupt JPEG");
-
-   for (i=0; i < s->img_n; ++i) {
-      z->img_comp[i].id = get8(s);
-      if (z->img_comp[i].id != i+1)   // JFIF requires
-         if (z->img_comp[i].id != i)  // some version of jpegtran outputs non-JFIF-compliant files!
-            return e("bad component ID","Corrupt JPEG");
-      q = get8(s);
-      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return e("bad H","Corrupt JPEG");
-      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return e("bad V","Corrupt JPEG");
-      z->img_comp[i].tq = get8(s);  if (z->img_comp[i].tq > 3) return e("bad TQ","Corrupt JPEG");
-   }
-
-   if (scan != SCAN_load) return 1;
-
-   if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("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;
-   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
-      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].raw_data = malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15);
-      if (z->img_comp[i].raw_data == NULL) {
-         for(--i; i >= 0; --i) {
-            free(z->img_comp[i].raw_data);
-            z->img_comp[i].data = NULL;
-         }
-         return e("outofmem", "Out of memory");
-      }
-      // align blocks for installable-idct using mmx/sse
-      z->img_comp[i].data = (uint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
-      z->img_comp[i].linebuf = NULL;
-   }
-
-   return 1;
-}
-
-// use comparisons since in some cases we handle more than one case (e.g. SOF)
-#define DNL(x)         ((x) == 0xdc)
-#define SOI(x)         ((x) == 0xd8)
-#define EOI(x)         ((x) == 0xd9)
-#define SOF(x)         ((x) == 0xc0 || (x) == 0xc1)
-#define SOS(x)         ((x) == 0xda)
-
-static int decode_jpeg_header(jpeg *z, int scan)
-{
-   int m;
-   z->marker = MARKER_none; // initialize cached marker to empty
-   m = get_marker(z);
-   if (!SOI(m)) return e("no SOI","Corrupt JPEG");
-   if (scan == SCAN_type) return 1;
-   m = get_marker(z);
-   while (!SOF(m)) {
-      if (!process_marker(z,m)) return 0;
-      m = get_marker(z);
-      while (m == MARKER_none) {
-         // some files have extra padding after their blocks, so ok, we'll scan
-         if (at_eof(&z->s)) return e("no SOF", "Corrupt JPEG");
-         m = get_marker(z);
-      }
-   }
-   if (!process_frame_header(z, scan)) return 0;
-   return 1;
-}
-
-static int decode_jpeg_image(jpeg *j)
-{
-   int m;
-   j->restart_interval = 0;
-   if (!decode_jpeg_header(j, SCAN_load)) return 0;
-   m = get_marker(j);
-   while (!EOI(m)) {
-      if (SOS(m)) {
-         if (!process_scan_header(j)) return 0;
-         if (!parse_entropy_coded_data(j)) return 0;
-      } else {
-         if (!process_marker(j, m)) return 0;
-      }
-      m = get_marker(j);
-   }
-   return 1;
-}
-
-// static jfif-centered resampling (across block boundaries)
-
-typedef uint8 *(*resample_row_func)(uint8 *out, uint8 *in0, uint8 *in1,
-                                    int w, int hs);
-
-#define div4(x) ((uint8) ((x) >> 2))
-
-static uint8 *resample_row_1(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
-{
-   return in_near;
-}
-
-static uint8* resample_row_v_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
-{
-   // need to generate two samples vertically for every one in input
-   int i;
-   for (i=0; i < w; ++i)
-      out[i] = div4(3*in_near[i] + in_far[i] + 2);
-   return out;
-}
-
-static uint8*  resample_row_h_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
-{
-   // need to generate two samples horizontally for every one in input
-   int i;
-   uint8 *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] = div4(input[0]*3 + input[1] + 2);
-   for (i=1; i < w-1; ++i) {
-      int n = 3*input[i]+2;
-      out[i*2+0] = div4(n+input[i-1]);
-      out[i*2+1] = div4(n+input[i+1]);
-   }
-   out[i*2+0] = div4(input[w-2]*3 + input[w-1] + 2);
-   out[i*2+1] = input[w-1];
-   return out;
-}
-
-#define div16(x) ((uint8) ((x) >> 4))
-
-static uint8 *resample_row_hv_2(uint8 *out, uint8 *in_near, uint8 *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] = div4(3*in_near[0] + in_far[0] + 2);
-      return out;
-   }
-
-   t1 = 3*in_near[0] + in_far[0];
-   out[0] = div4(t1+2);
-   for (i=1; i < w; ++i) {
-      t0 = t1;
-      t1 = 3*in_near[i]+in_far[i];
-      out[i*2-1] = div16(3*t0 + t1 + 8);
-      out[i*2  ] = div16(3*t1 + t0 + 8);
-   }
-   out[w*2-1] = div4(t1+2);
-   return out;
-}
-
-static uint8 *resample_row_generic(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
-{
-   // resample with nearest-neighbor
-   int i,j;
-   for (i=0; i < w; ++i)
-      for (j=0; j < hs; ++j)
-         out[i*hs+j] = in_near[i];
-   return out;
-}
-
-#define float2fixed(x)  ((int) ((x) * 65536 + 0.5))
-
-// 0.38 seconds on 3*anemones.jpg   (0.25 with processor = Pro)
-// VC6 without processor=Pro is generating multiple LEAs per multiply!
-static void YCbCr_to_RGB_row(uint8 *out, uint8 *y, uint8 *pcb, uint8 *pcr, int count, int step)
-{
-   int i;
-   for (i=0; i < count; ++i) {
-      int y_fixed = (y[i] << 16) + 32768; // rounding
-      int r,g,b;
-      int cr = pcr[i] - 128;
-      int cb = pcb[i] - 128;
-      r = y_fixed + cr*float2fixed(1.40200f);
-      g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f);
-      b = y_fixed                            + cb*float2fixed(1.77200f);
-      r >>= 16;
-      g >>= 16;
-      b >>= 16;
-      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] = (uint8)r;
-      out[1] = (uint8)g;
-      out[2] = (uint8)b;
-      out[3] = 255;
-      out += step;
-   }
-}
-
-#if STBI_SIMD
-static stbi_YCbCr_to_RGB_run stbi_YCbCr_installed = YCbCr_to_RGB_row;
-
-void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func)
-{
-   stbi_YCbCr_installed = func;
-}
-#endif
-
-
-// clean up the temporary component buffers
-static void cleanup_jpeg(jpeg *j)
-{
-   int i;
-   for (i=0; i < j->s.img_n; ++i) {
-      if (j->img_comp[i].data) {
-         free(j->img_comp[i].raw_data);
-         j->img_comp[i].data = NULL;
-      }
-      if (j->img_comp[i].linebuf) {
-         free(j->img_comp[i].linebuf);
-         j->img_comp[i].linebuf = NULL;
-      }
-   }
-}
-
-typedef struct
-{
-   resample_row_func resample;
-   uint8 *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;
-
-static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
-{
-   int n, decode_n;
-   // validate req_comp
-   if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
-   z->s.img_n = 0;
-
-   // load a jpeg image from whichever source
-   if (!decode_jpeg_image(z)) { cleanup_jpeg(z); return NULL; }
-
-   // determine actual number of components to generate
-   n = req_comp ? req_comp : z->s.img_n;
-
-   if (z->s.img_n == 3 && n < 3)
-      decode_n = 1;
-   else
-      decode_n = z->s.img_n;
-
-   // resample and color-convert
-   {
-      int k;
-      uint i,j;
-      uint8 *output;
-      uint8 *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 = (uint8 *) malloc(z->s.img_x + 3);
-         if (!z->img_comp[k].linebuf) { cleanup_jpeg(z); return epuc("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 = resample_row_v_2;
-         else if (r->hs == 2 && r->vs == 1) r->resample = resample_row_h_2;
-         else if (r->hs == 2 && r->vs == 2) r->resample = resample_row_hv_2;
-         else                               r->resample = resample_row_generic;
-      }
-
-      // can't error after this so, this is safe
-      output = (uint8 *) malloc(n * z->s.img_x * z->s.img_y + 1);
-      if (!output) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); }
-
-      // now go ahead and resample
-      for (j=0; j < z->s.img_y; ++j) {
-         uint8 *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) {
-            uint8 *y = coutput[0];
-            if (z->s.img_n == 3) {
-               #if STBI_SIMD
-               stbi_YCbCr_installed(out, y, coutput[1], coutput[2], z->s.img_x, n);
-               #else
-               YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s.img_x, n);
-               #endif
-            } 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 {
-            uint8 *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;
-         }
-      }
-      cleanup_jpeg(z);
-      *out_x = z->s.img_x;
-      *out_y = z->s.img_y;
-      if (comp) *comp  = z->s.img_n; // report original components, not output
-      return output;
-   }
-}
-
-#ifndef STBI_NO_STDIO
-unsigned char *stbi_jpeg_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   jpeg j;
-   start_file(&j.s, f);
-   return load_jpeg_image(&j, x,y,comp,req_comp);
-}
-
-unsigned char *stbi_jpeg_load(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_jpeg_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-#endif
-
-unsigned char *stbi_jpeg_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   jpeg j;
-   start_mem(&j.s, buffer,len);
-   return load_jpeg_image(&j, x,y,comp,req_comp);
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_jpeg_test_file(FILE *f)
-{
-   int n,r;
-   jpeg j;
-   n = ftell(f);
-   start_file(&j.s, f);
-   r = decode_jpeg_header(&j, SCAN_type);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int stbi_jpeg_test_memory(stbi_uc const *buffer, int len)
-{
-   jpeg j;
-   start_mem(&j.s, buffer,len);
-   return decode_jpeg_header(&j, SCAN_type);
-}
-
-// @TODO:
-#ifndef STBI_NO_STDIO
-extern int      stbi_jpeg_info            (char const *filename,           int *x, int *y, int *comp);
-extern int      stbi_jpeg_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-#endif
-extern int      stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-
-// 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
-
-// fast-way is faster to check than jpeg huffman, but slow way is slower
-#define ZFAST_BITS  9 // accelerate all cases in default tables
-#define ZFAST_MASK  ((1 << ZFAST_BITS) - 1)
-
-// zlib-style huffman encoding
-// (jpegs packs from left, zlib from right, so can't share code)
-typedef struct
-{
-   uint16 fast[1 << ZFAST_BITS];
-   uint16 firstcode[16];
-   int maxcode[17];
-   uint16 firstsymbol[16];
-   uint8  size[288];
-   uint16 value[288]; 
-} zhuffman;
-
-__forceinline static int 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;
-}
-
-__forceinline static int bit_reverse(int v, int bits)
-{
-   assert(bits <= 16);
-   // to bit reverse n bits, reverse 16 and shift
-   // e.g. 11 bits, bit reverse and shift away 5
-   return bitreverse16(v) >> (16-bits);
-}
-
-static int zbuild_huffman(zhuffman *z, uint8 *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, 255, sizeof(z->fast));
-   for (i=0; i < num; ++i) 
-      ++sizes[sizelist[i]];
-   sizes[0] = 0;
-   for (i=1; i < 16; ++i)
-      assert(sizes[i] <= (1 << i));
-   code = 0;
-   for (i=1; i < 16; ++i) {
-      next_code[i] = code;
-      z->firstcode[i] = (uint16) code;
-      z->firstsymbol[i] = (uint16) k;
-      code = (code + sizes[i]);
-      if (sizes[i])
-         if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG");
-      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];
-         z->size[c] = (uint8)s;
-         z->value[c] = (uint16)i;
-         if (s <= ZFAST_BITS) {
-            int k = bit_reverse(next_code[s],s);
-            while (k < (1 << ZFAST_BITS)) {
-               z->fast[k] = (uint16) c;
-               k += (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
-{
-   uint8 *zbuffer, *zbuffer_end;
-   int num_bits;
-   uint32 code_buffer;
-
-   char *zout;
-   char *zout_start;
-   char *zout_end;
-   int   z_expandable;
-
-   zhuffman z_length, z_distance;
-} zbuf;
-
-__forceinline static int zget8(zbuf *z)
-{
-   if (z->zbuffer >= z->zbuffer_end) return 0;
-   return *z->zbuffer++;
-}
-
-static void fill_bits(zbuf *z)
-{
-   do {
-      assert(z->code_buffer < (1U << z->num_bits));
-      z->code_buffer |= zget8(z) << z->num_bits;
-      z->num_bits += 8;
-   } while (z->num_bits <= 24);
-}
-
-__forceinline static unsigned int zreceive(zbuf *z, int n)
-{
-   unsigned int k;
-   if (z->num_bits < n) fill_bits(z);
-   k = z->code_buffer & ((1 << n) - 1);
-   z->code_buffer >>= n;
-   z->num_bits -= n;
-   return k;   
-}
-
-__forceinline static int zhuffman_decode(zbuf *a, zhuffman *z)
-{
-   int b,s,k;
-   if (a->num_bits < 16) fill_bits(a);
-   b = z->fast[a->code_buffer & ZFAST_MASK];
-   if (b < 0xffff) {
-      s = z->size[b];
-      a->code_buffer >>= s;
-      a->num_bits -= s;
-      return z->value[b];
-   }
-
-   // not resolved by fast table, so compute it the slow way
-   // use jpeg approach, which requires MSbits at top
-   k = bit_reverse(a->code_buffer, 16);
-   for (s=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];
-   assert(z->size[b] == s);
-   a->code_buffer >>= s;
-   a->num_bits -= s;
-   return z->value[b];
-}
-
-static int expand(zbuf *z, int n)  // need to make room for n bytes
-{
-   char *q;
-   int cur, limit;
-   if (!z->z_expandable) return e("output buffer limit","Corrupt PNG");
-   cur   = (int) (z->zout     - z->zout_start);
-   limit = (int) (z->zout_end - z->zout_start);
-   while (cur + n > limit)
-      limit *= 2;
-   q = (char *) realloc(z->zout_start, limit);
-   if (q == NULL) return e("outofmem", "Out of memory");
-   z->zout_start = q;
-   z->zout       = q + cur;
-   z->zout_end   = q + limit;
-   return 1;
-}
-
-static int length_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 int length_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 int dist_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 int dist_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 parse_huffman_block(zbuf *a)
-{
-   for(;;) {
-      int z = zhuffman_decode(a, &a->z_length);
-      if (z < 256) {
-         if (z < 0) return e("bad huffman code","Corrupt PNG"); // error in huffman codes
-         if (a->zout >= a->zout_end) if (!expand(a, 1)) return 0;
-         *a->zout++ = (char) z;
-      } else {
-         uint8 *p;
-         int len,dist;
-         if (z == 256) return 1;
-         z -= 257;
-         len = length_base[z];
-         if (length_extra[z]) len += zreceive(a, length_extra[z]);
-         z = zhuffman_decode(a, &a->z_distance);
-         if (z < 0) return e("bad huffman code","Corrupt PNG");
-         dist = dist_base[z];
-         if (dist_extra[z]) dist += zreceive(a, dist_extra[z]);
-         if (a->zout - a->zout_start < dist) return e("bad dist","Corrupt PNG");
-         if (a->zout + len > a->zout_end) if (!expand(a, len)) return 0;
-         p = (uint8 *) (a->zout - dist);
-         while (len--)
-            *a->zout++ = *p++;
-      }
-   }
-}
-
-static int compute_huffman_codes(zbuf *a)
-{
-   static uint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
-   static zhuffman z_codelength; // static just to save stack space
-   uint8 lencodes[286+32+137];//padding for maximum single op
-   uint8 codelength_sizes[19];
-   int i,n;
-
-   int hlit  = zreceive(a,5) + 257;
-   int hdist = zreceive(a,5) + 1;
-   int hclen = zreceive(a,4) + 4;
-
-   memset(codelength_sizes, 0, sizeof(codelength_sizes));
-   for (i=0; i < hclen; ++i) {
-      int s = zreceive(a,3);
-      codelength_sizes[length_dezigzag[i]] = (uint8) s;
-   }
-   if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
-
-   n = 0;
-   while (n < hlit + hdist) {
-      int c = zhuffman_decode(a, &z_codelength);
-      assert(c >= 0 && c < 19);
-      if (c < 16)
-         lencodes[n++] = (uint8) c;
-      else if (c == 16) {
-         c = zreceive(a,2)+3;
-         memset(lencodes+n, lencodes[n-1], c);
-         n += c;
-      } else if (c == 17) {
-         c = zreceive(a,3)+3;
-         memset(lencodes+n, 0, c);
-         n += c;
-      } else {
-         assert(c == 18);
-         c = zreceive(a,7)+11;
-         memset(lencodes+n, 0, c);
-         n += c;
-      }
-   }
-   if (n != hlit+hdist) return e("bad codelengths","Corrupt PNG");
-   if (!zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
-   if (!zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
-   return 1;
-}
-
-static int parse_uncompressed_block(zbuf *a)
-{
-   uint8 header[4];
-   int len,nlen,k;
-   if (a->num_bits & 7)
-      zreceive(a, a->num_bits & 7); // discard
-   // drain the bit-packed data into header
-   k = 0;
-   while (a->num_bits > 0) {
-      header[k++] = (uint8) (a->code_buffer & 255); // wtf this warns?
-      a->code_buffer >>= 8;
-      a->num_bits -= 8;
-   }
-   assert(a->num_bits == 0);
-   // now fill header the normal way
-   while (k < 4)
-      header[k++] = (uint8) zget8(a);
-   len  = header[1] * 256 + header[0];
-   nlen = header[3] * 256 + header[2];
-   if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG");
-   if (a->zbuffer + len > a->zbuffer_end) return e("read past buffer","Corrupt PNG");
-   if (a->zout + len > a->zout_end)
-      if (!expand(a, len)) return 0;
-   memcpy(a->zout, a->zbuffer, len);
-   a->zbuffer += len;
-   a->zout += len;
-   return 1;
-}
-
-static int parse_zlib_header(zbuf *a)
-{
-   int cmf   = zget8(a);
-   int cm    = cmf & 15;
-   /* int cinfo = cmf >> 4; */
-   int flg   = zget8(a);
-   if ((cmf*256+flg) % 31 != 0) return e("bad zlib header","Corrupt PNG"); // zlib spec
-   if (flg & 32) return e("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
-   if (cm != 8) return e("bad compression","Corrupt PNG"); // DEFLATE required for png
-   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
-   return 1;
-}
-
-// @TODO: should statically initialize these for optimal thread safety
-static uint8 default_length[288], default_distance[32];
-static void init_defaults(void)
-{
-   int i;   // use <= to match clearly with spec
-   for (i=0; i <= 143; ++i)     default_length[i]   = 8;
-   for (   ; i <= 255; ++i)     default_length[i]   = 9;
-   for (   ; i <= 279; ++i)     default_length[i]   = 7;
-   for (   ; i <= 287; ++i)     default_length[i]   = 8;
-
-   for (i=0; i <=  31; ++i)     default_distance[i] = 5;
-}
-
-static int parse_zlib(zbuf *a, int parse_header)
-{
-   int final, type;
-   if (parse_header)
-      if (!parse_zlib_header(a)) return 0;
-   a->num_bits = 0;
-   a->code_buffer = 0;
-   do {
-      final = zreceive(a,1);
-      type = zreceive(a,2);
-      if (type == 0) {
-         if (!parse_uncompressed_block(a)) return 0;
-      } else if (type == 3) {
-         return 0;
-      } else {
-         if (type == 1) {
-            // use fixed code lengths
-            if (!default_distance[31]) init_defaults();
-            if (!zbuild_huffman(&a->z_length  , default_length  , 288)) return 0;
-            if (!zbuild_huffman(&a->z_distance, default_distance,  32)) return 0;
-         } else {
-            if (!compute_huffman_codes(a)) return 0;
-         }
-         if (!parse_huffman_block(a)) return 0;
-      }
-   } while (!final);
-   return 1;
-}
-
-static int do_zlib(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 parse_zlib(a, parse_header);
-}
-
-char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
-{
-   zbuf a;
-   char *p = (char *) malloc(initial_size);
-   if (p == NULL) return NULL;
-   a.zbuffer = (uint8 *) buffer;
-   a.zbuffer_end = (uint8 *) buffer + len;
-   if (do_zlib(&a, p, initial_size, 1, 1)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      free(a.zout_start);
-      return NULL;
-   }
-}
-
-char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
-{
-   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
-}
-
-int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
-{
-   zbuf a;
-   a.zbuffer = (uint8 *) ibuffer;
-   a.zbuffer_end = (uint8 *) ibuffer + ilen;
-   if (do_zlib(&a, obuffer, olen, 0, 1))
-      return (int) (a.zout - a.zout_start);
-   else
-      return -1;
-}
-
-char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
-{
-   zbuf a;
-   char *p = (char *) malloc(16384);
-   if (p == NULL) return NULL;
-   a.zbuffer = (uint8 *) buffer;
-   a.zbuffer_end = (uint8 *) buffer+len;
-   if (do_zlib(&a, p, 16384, 1, 0)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      free(a.zout_start);
-      return NULL;
-   }
-}
-
-int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
-{
-   zbuf a;
-   a.zbuffer = (uint8 *) ibuffer;
-   a.zbuffer_end = (uint8 *) ibuffer + ilen;
-   if (do_zlib(&a, obuffer, olen, 0, 0))
-      return (int) (a.zout - a.zout_start);
-   else
-      return -1;
-}
-
-// 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
-
-
-typedef struct
-{
-   uint32 length;
-   uint32 type;
-} chunk;
-
-#define PNG_TYPE(a,b,c,d)  (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
-
-static chunk get_chunk_header(stbi *s)
-{
-   chunk c;
-   c.length = get32(s);
-   c.type   = get32(s);
-   return c;
-}
-
-static int check_png_header(stbi *s)
-{
-   static uint8 png_sig[8] = { 137,80,78,71,13,10,26,10 };
-   int i;
-   for (i=0; i < 8; ++i)
-      if (get8(s) != png_sig[i]) return e("bad png sig","Not a PNG");
-   return 1;
-}
-
-typedef struct
-{
-   stbi s;
-   uint8 *idata, *expanded, *out;
-} png;
-
-
-enum {
-   F_none=0, F_sub=1, F_up=2, F_avg=3, F_paeth=4,
-   F_avg_first, F_paeth_first,
-};
-
-static uint8 first_row_filter[5] =
-{
-   F_none, F_sub, F_none, F_avg_first, F_paeth_first
-};
-
-static int 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;
-}
-
-// create the png data from post-deflated data
-static int create_png_image(png *a, uint8 *raw, uint32 raw_len, int out_n)
-{
-   stbi *s = &a->s;
-   uint32 i,j,stride = s->img_x*out_n;
-   int k;
-   int img_n = s->img_n; // copy it into a local for later
-   assert(out_n == s->img_n || out_n == s->img_n+1);
-   a->out = (uint8 *) malloc(s->img_x * s->img_y * out_n);
-   if (!a->out) return e("outofmem", "Out of memory");
-   if (raw_len != (img_n * s->img_x + 1) * s->img_y) return e("not enough pixels","Corrupt PNG");
-   for (j=0; j < s->img_y; ++j) {
-      uint8 *cur = a->out + stride*j;
-      uint8 *prior = cur - stride;
-      int filter = *raw++;
-      if (filter > 4) return e("invalid filter","Corrupt PNG");
-      // if first row, use special filter that doesn't sample previous row
-      if (j == 0) filter = first_row_filter[filter];
-      // handle first pixel explicitly
-      for (k=0; k < img_n; ++k) {
-         switch(filter) {
-            case F_none       : cur[k] = raw[k]; break;
-            case F_sub        : cur[k] = raw[k]; break;
-            case F_up         : cur[k] = raw[k] + prior[k]; break;
-            case F_avg        : cur[k] = raw[k] + (prior[k]>>1); break;
-            case F_paeth      : cur[k] = (uint8) (raw[k] + paeth(0,prior[k],0)); break;
-            case F_avg_first  : cur[k] = raw[k]; break;
-            case F_paeth_first: cur[k] = raw[k]; break;
-         }
-      }
-      if (img_n != out_n) cur[img_n] = 255;
-      raw += img_n;
-      cur += out_n;
-      prior += out_n;
-      // this is a little gross, so that we don't switch per-pixel or per-component
-      if (img_n == out_n) {
-         #define CASE(f) \
-             case f:     \
-                for (i=s->img_x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \
-                   for (k=0; k < img_n; ++k)
-         switch(filter) {
-            CASE(F_none)  cur[k] = raw[k]; break;
-            CASE(F_sub)   cur[k] = raw[k] + cur[k-img_n]; break;
-            CASE(F_up)    cur[k] = raw[k] + prior[k]; break;
-            CASE(F_avg)   cur[k] = raw[k] + ((prior[k] + cur[k-img_n])>>1); break;
-            CASE(F_paeth)  cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break;
-            CASE(F_avg_first)    cur[k] = raw[k] + (cur[k-img_n] >> 1); break;
-            CASE(F_paeth_first)  cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],0,0)); break;
-         }
-         #undef CASE
-      } else {
-         assert(img_n+1 == out_n);
-         #define CASE(f) \
-             case f:     \
-                for (i=s->img_x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \
-                   for (k=0; k < img_n; ++k)
-         switch(filter) {
-            CASE(F_none)  cur[k] = raw[k]; break;
-            CASE(F_sub)   cur[k] = raw[k] + cur[k-out_n]; break;
-            CASE(F_up)    cur[k] = raw[k] + prior[k]; break;
-            CASE(F_avg)   cur[k] = raw[k] + ((prior[k] + cur[k-out_n])>>1); break;
-            CASE(F_paeth)  cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break;
-            CASE(F_avg_first)    cur[k] = raw[k] + (cur[k-out_n] >> 1); break;
-            CASE(F_paeth_first)  cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],0,0)); break;
-         }
-         #undef CASE
-      }
-   }
-   return 1;
-}
-
-static int compute_transparency(png *z, uint8 tc[3], int out_n)
-{
-   stbi *s = &z->s;
-   uint32 i, pixel_count = s->img_x * s->img_y;
-   uint8 *p = z->out;
-
-   // compute color-based transparency, assuming we've
-   // already got 255 as the alpha value in the output
-   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 expand_palette(png *a, uint8 *palette, int len, int pal_img_n)
-{
-   uint32 i, pixel_count = a->s.img_x * a->s.img_y;
-   uint8 *p, *temp_out, *orig = a->out;
-
-   p = (uint8 *) malloc(pixel_count * pal_img_n);
-   if (p == NULL) return e("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;
-      }
-   }
-   free(a->out);
-   a->out = temp_out;
-   return 1;
-}
-
-static int parse_png_file(png *z, int scan, int req_comp)
-{
-   uint8 palette[1024], pal_img_n=0;
-   uint8 has_trans=0, tc[3];
-   uint32 ioff=0, idata_limit=0, i, pal_len=0;
-   int first=1,k;
-   stbi *s = &z->s;
-
-   if (!check_png_header(s)) return 0;
-
-   if (scan == SCAN_type) return 1;
-
-   for(;;first=0) {
-      chunk c = get_chunk_header(s);
-      if (first && c.type != PNG_TYPE('I','H','D','R'))
-         return e("first not IHDR","Corrupt PNG");
-      switch (c.type) {
-         case PNG_TYPE('I','H','D','R'): {
-            int depth,color,interlace,comp,filter;
-            if (!first) return e("multiple IHDR","Corrupt PNG");
-            if (c.length != 13) return e("bad IHDR len","Corrupt PNG");
-            s->img_x = get32(s); if (s->img_x > (1 << 24)) return e("too large","Very large image (corrupt?)");
-            s->img_y = get32(s); if (s->img_y > (1 << 24)) return e("too large","Very large image (corrupt?)");
-            depth = get8(s);  if (depth != 8)        return e("8bit only","PNG not supported: 8-bit only");
-            color = get8(s);  if (color > 6)         return e("bad ctype","Corrupt PNG");
-            if (color == 3) pal_img_n = 3; else if (color & 1) return e("bad ctype","Corrupt PNG");
-            comp  = get8(s);  if (comp) return e("bad comp method","Corrupt PNG");
-            filter= get8(s);  if (filter) return e("bad filter method","Corrupt PNG");
-            interlace = get8(s); if (interlace) return e("interlaced","PNG not supported: interlaced mode");
-            if (!s->img_x || !s->img_y) return e("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 e("too large", "Image too large to decode");
-               if (scan == 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 e("too large","Corrupt PNG");
-               // if SCAN_header, have to scan to see if we have a tRNS
-            }
-            break;
-         }
-
-         case PNG_TYPE('P','L','T','E'):  {
-            if (c.length > 256*3) return e("invalid PLTE","Corrupt PNG");
-            pal_len = c.length / 3;
-            if (pal_len * 3 != c.length) return e("invalid PLTE","Corrupt PNG");
-            for (i=0; i < pal_len; ++i) {
-               palette[i*4+0] = get8u(s);
-               palette[i*4+1] = get8u(s);
-               palette[i*4+2] = get8u(s);
-               palette[i*4+3] = 255;
-            }
-            break;
-         }
-
-         case PNG_TYPE('t','R','N','S'): {
-            if (z->idata) return e("tRNS after IDAT","Corrupt PNG");
-            if (pal_img_n) {
-               if (scan == SCAN_header) { s->img_n = 4; return 1; }
-               if (pal_len == 0) return e("tRNS before PLTE","Corrupt PNG");
-               if (c.length > pal_len) return e("bad tRNS len","Corrupt PNG");
-               pal_img_n = 4;
-               for (i=0; i < c.length; ++i)
-                  palette[i*4+3] = get8u(s);
-            } else {
-               if (!(s->img_n & 1)) return e("tRNS with alpha","Corrupt PNG");
-               if (c.length != (uint32) s->img_n*2) return e("bad tRNS len","Corrupt PNG");
-               has_trans = 1;
-               for (k=0; k < s->img_n; ++k)
-                  tc[k] = (uint8) get16(s); // non 8-bit images will be larger
-            }
-            break;
-         }
-
-         case PNG_TYPE('I','D','A','T'): {
-            if (pal_img_n && !pal_len) return e("no PLTE","Corrupt PNG");
-            if (scan == SCAN_header) { s->img_n = pal_img_n; return 1; }
-            if (ioff + c.length > idata_limit) {
-               uint8 *p;
-               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
-               while (ioff + c.length > idata_limit)
-                  idata_limit *= 2;
-               p = (uint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory");
-               z->idata = p;
-            }
-            #ifndef STBI_NO_STDIO
-            if (s->img_file)
-            {
-               if (fread(z->idata+ioff,1,c.length,s->img_file) != c.length) return e("outofdata","Corrupt PNG");
-            }
-            else
-            #endif
-            {
-               memcpy(z->idata+ioff, s->img_buffer, c.length);
-               s->img_buffer += c.length;
-            }
-            ioff += c.length;
-            break;
-         }
-
-         case PNG_TYPE('I','E','N','D'): {
-            uint32 raw_len;
-            if (scan != SCAN_load) return 1;
-            if (z->idata == NULL) return e("no IDAT","Corrupt PNG");
-            z->expanded = (uint8 *) stbi_zlib_decode_malloc((char *) z->idata, ioff, (int *) &raw_len);
-            if (z->expanded == NULL) return 0; // zlib should set error
-            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 (!create_png_image(z, z->expanded, raw_len, s->img_out_n)) return 0;
-            if (has_trans)
-               if (!compute_transparency(z, tc, s->img_out_n)) return 0;
-            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 (!expand_palette(z, palette, pal_len, s->img_out_n))
-                  return 0;
-            }
-            free(z->expanded); z->expanded = NULL;
-            return 1;
-         }
-
-         default:
-            // if critical, fail
-            if ((c.type & (1 << 29)) == 0) {
-               #ifndef STBI_NO_FAILURE_STRINGS
-               // not threadsafe
-               static char invalid_chunk[] = "XXXX chunk not known";
-               invalid_chunk[0] = (uint8) (c.type >> 24);
-               invalid_chunk[1] = (uint8) (c.type >> 16);
-               invalid_chunk[2] = (uint8) (c.type >>  8);
-               invalid_chunk[3] = (uint8) (c.type >>  0);
-               #endif
-               return e(invalid_chunk, "PNG not supported: unknown chunk type");
-            }
-            skip(s, c.length);
-            break;
-      }
-      // end of chunk, read and skip CRC
-      get32(s);
-   }
-}
-
-static unsigned char *do_png(png *p, int *x, int *y, int *n, int req_comp)
-{
-   unsigned char *result=NULL;
-   p->expanded = NULL;
-   p->idata = NULL;
-   p->out = NULL;
-   if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
-   if (parse_png_file(p, SCAN_load, req_comp)) {
-      result = p->out;
-      p->out = NULL;
-      if (req_comp && req_comp != p->s.img_out_n) {
-         result = convert_format(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;
-   }
-   free(p->out);      p->out      = NULL;
-   free(p->expanded); p->expanded = NULL;
-   free(p->idata);    p->idata    = NULL;
-
-   return result;
-}
-
-#ifndef STBI_NO_STDIO
-unsigned char *stbi_png_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   png p;
-   start_file(&p.s, f);
-   return do_png(&p, x,y,comp,req_comp);
-}
-
-unsigned char *stbi_png_load(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_png_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-#endif
-
-unsigned char *stbi_png_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   png p;
-   start_mem(&p.s, buffer,len);
-   return do_png(&p, x,y,comp,req_comp);
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_png_test_file(FILE *f)
-{
-   png p;
-   int n,r;
-   n = ftell(f);
-   start_file(&p.s, f);
-   r = parse_png_file(&p, SCAN_type,STBI_default);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int stbi_png_test_memory(stbi_uc const *buffer, int len)
-{
-   png p;
-   start_mem(&p.s, buffer, len);
-   return parse_png_file(&p, SCAN_type,STBI_default);
-}
-
-// TODO: load header from png
-#ifndef STBI_NO_STDIO
-extern int      stbi_png_info             (char const *filename,           int *x, int *y, int *comp);
-extern int      stbi_png_info_from_file   (FILE *f,                  int *x, int *y, int *comp);
-#endif
-extern int      stbi_png_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-
-// Microsoft/Windows BMP image
-
-static int bmp_test(stbi *s)
-{
-   int sz;
-   if (get8(s) != 'B') return 0;
-   if (get8(s) != 'M') return 0;
-   get32le(s); // discard filesize
-   get16le(s); // discard reserved
-   get16le(s); // discard reserved
-   get32le(s); // discard data offset
-   sz = get32le(s);
-   if (sz == 12 || sz == 40 || sz == 56 || sz == 108) return 1;
-   return 0;
-}
-
-#ifndef STBI_NO_STDIO
-int      stbi_bmp_test_file        (FILE *f)
-{
-   stbi s;
-   int r,n = ftell(f);
-   start_file(&s,f);
-   r = bmp_test(&s);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int      stbi_bmp_test_memory      (stbi_uc const *buffer, int len)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return bmp_test(&s);
-}
-
-// returns 0..31 for the highest set bit
-static int 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 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;
-}
-
-static int shiftsigned(int v, int shift, int bits)
-{
-   int result;
-   int z=0;
-
-   if (shift < 0) v <<= -shift;
-   else v >>= shift;
-   result = v;
-
-   z = bits;
-   while (z < 8) {
-      result += v >> z;
-      z += bits;
-   }
-   return result;
-}
-
-static stbi_uc *bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp)
-{
-   uint8 *out;
-   unsigned int mr=0,mg=0,mb=0,ma=0;
-   stbi_uc pal[256][4];
-   int psize=0,i,j,compress=0,width;
-   int bpp, flip_vertically, pad, target, offset, hsz;
-   if (get8(s) != 'B' || get8(s) != 'M') return epuc("not BMP", "Corrupt BMP");
-   get32le(s); // discard filesize
-   get16le(s); // discard reserved
-   get16le(s); // discard reserved
-   offset = get32le(s);
-   hsz = get32le(s);
-   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) return epuc("unknown BMP", "BMP type not supported: unknown");
-   failure_reason = "bad BMP";
-   if (hsz == 12) {
-      s->img_x = get16le(s);
-      s->img_y = get16le(s);
-   } else {
-      s->img_x = get32le(s);
-      s->img_y = get32le(s);
-   }
-   if (get16le(s) != 1) return 0;
-   bpp = get16le(s);
-   if (bpp == 1) return epuc("monochrome", "BMP type not supported: 1-bit");
-   flip_vertically = ((int) s->img_y) > 0;
-   s->img_y = abs((int) s->img_y);
-   if (hsz == 12) {
-      if (bpp < 24)
-         psize = (offset - 14 - 24) / 3;
-   } else {
-      compress = get32le(s);
-      if (compress == 1 || compress == 2) return epuc("BMP RLE", "BMP type not supported: RLE");
-      get32le(s); // discard sizeof
-      get32le(s); // discard hres
-      get32le(s); // discard vres
-      get32le(s); // discard colorsused
-      get32le(s); // discard max important
-      if (hsz == 40 || hsz == 56) {
-         if (hsz == 56) {
-            get32le(s);
-            get32le(s);
-            get32le(s);
-            get32le(s);
-         }
-         if (bpp == 16 || bpp == 32) {
-            mr = mg = mb = 0;
-            if (compress == 0) {
-               if (bpp == 32) {
-                  mr = 0xff << 16;
-                  mg = 0xff <<  8;
-                  mb = 0xff <<  0;
-               } else {
-                  mr = 31 << 10;
-                  mg = 31 <<  5;
-                  mb = 31 <<  0;
-               }
-            } else if (compress == 3) {
-               mr = get32le(s);
-               mg = get32le(s);
-               mb = get32le(s);
-               // not documented, but generated by photoshop and handled by mspaint
-               if (mr == mg && mg == mb) {
-                  // ?!?!?
-                  return NULL;
-               }
-            } else
-               return NULL;
-         }
-      } else {
-         assert(hsz == 108);
-         mr = get32le(s);
-         mg = get32le(s);
-         mb = get32le(s);
-         ma = get32le(s);
-         get32le(s); // discard color space
-         for (i=0; i < 12; ++i)
-            get32le(s); // discard color space parameters
-      }
-      if (bpp < 16)
-         psize = (offset - 14 - 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
-   out = (stbi_uc *) malloc(target * s->img_x * s->img_y);
-   if (!out) return epuc("outofmem", "Out of memory");
-   if (bpp < 16) {
-      int z=0;
-      if (psize == 0 || psize > 256) { free(out); return epuc("invalid", "Corrupt BMP"); }
-      for (i=0; i < psize; ++i) {
-         pal[i][2] = get8(s);
-         pal[i][1] = get8(s);
-         pal[i][0] = get8(s);
-         if (hsz != 12) get8(s);
-         pal[i][3] = 255;
-      }
-      skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4));
-      if (bpp == 4) width = (s->img_x + 1) >> 1;
-      else if (bpp == 8) width = s->img_x;
-      else { free(out); return epuc("bad bpp", "Corrupt BMP"); }
-      pad = (-width)&3;
-      for (j=0; j < (int) s->img_y; ++j) {
-         for (i=0; i < (int) s->img_x; i += 2) {
-            int v=get8(s),v2=0;
-            if (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 = (bpp == 8) ? get8(s) : v2;
-            out[z++] = pal[v][0];
-            out[z++] = pal[v][1];
-            out[z++] = pal[v][2];
-            if (target == 4) out[z++] = 255;
-         }
-         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;
-      skip(s, offset - 14 - hsz);
-      if (bpp == 24) width = 3 * s->img_x;
-      else if (bpp == 16) width = 2*s->img_x;
-      else /* bpp = 32 and pad = 0 */ width=0;
-      pad = (-width) & 3;
-      if (bpp == 24) {
-         easy = 1;
-      } else if (bpp == 32) {
-         if (mb == 0xff && mg == 0xff00 && mr == 0xff000000 && ma == 0xff000000)
-            easy = 2;
-      }
-      if (!easy) {
-         if (!mr || !mg || !mb) return epuc("bad masks", "Corrupt BMP");
-         // right shift amt to put high bit in position #7
-         rshift = high_bit(mr)-7; rcount = bitcount(mr);
-         gshift = high_bit(mg)-7; gcount = bitcount(mr);
-         bshift = high_bit(mb)-7; bcount = bitcount(mr);
-         ashift = high_bit(ma)-7; acount = bitcount(mr);
-      }
-      for (j=0; j < (int) s->img_y; ++j) {
-         if (easy) {
-            for (i=0; i < (int) s->img_x; ++i) {
-               int a;
-               out[z+2] = get8(s);
-               out[z+1] = get8(s);
-               out[z+0] = get8(s);
-               z += 3;
-               a = (easy == 2 ? get8(s) : 255);
-               if (target == 4) out[z++] = a;
-            }
-         } else {
-            for (i=0; i < (int) s->img_x; ++i) {
-               uint32 v = (bpp == 16 ? get16le(s) : get32le(s));
-               int a;
-               out[z++] = shiftsigned(v & mr, rshift, rcount);
-               out[z++] = shiftsigned(v & mg, gshift, gcount);
-               out[z++] = shiftsigned(v & mb, bshift, bcount);
-               a = (ma ? shiftsigned(v & ma, ashift, acount) : 255);
-               if (target == 4) out[z++] = a; 
-            }
-         }
-         skip(s, pad);
-      }
-   }
-   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 = convert_format(out, target, req_comp, s->img_x, s->img_y);
-      if (out == NULL) return out; // convert_format frees input on failure
-   }
-
-   *x = s->img_x;
-   *y = s->img_y;
-   if (comp) *comp = target;
-   return out;
-}
-
-#ifndef STBI_NO_STDIO
-stbi_uc *stbi_bmp_load             (char const *filename,           int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_bmp_load_from_file(f, x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-
-stbi_uc *stbi_bmp_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_file(&s, f);
-   return bmp_load(&s, x,y,comp,req_comp);
-}
-#endif
-
-stbi_uc *stbi_bmp_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return bmp_load(&s, x,y,comp,req_comp);
-}
-
-// Targa Truevision - TGA
-// by Jonathan Dummer
-
-static int tga_test(stbi *s)
-{
-	int sz;
-	get8u(s);		//	discard Offset
-	sz = get8u(s);	//	color type
-	if( sz > 1 ) return 0;	//	only RGB or indexed allowed
-	sz = get8u(s);	//	image type
-	if( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0;	//	only RGB or grey allowed, +/- RLE
-	get16(s);		//	discard palette start
-	get16(s);		//	discard palette length
-	get8(s);			//	discard bits per palette color entry
-	get16(s);		//	discard x origin
-	get16(s);		//	discard y origin
-	if( get16(s) < 1 ) return 0;		//	test width
-	if( get16(s) < 1 ) return 0;		//	test height
-	sz = get8(s);	//	bits per pixel
-	if( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) ) return 0;	//	only RGB or RGBA or grey allowed
-	return 1;		//	seems to have passed everything
-}
-
-#ifndef STBI_NO_STDIO
-int      stbi_tga_test_file        (FILE *f)
-{
-   stbi s;
-   int r,n = ftell(f);
-   start_file(&s, f);
-   r = tga_test(&s);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int      stbi_tga_test_memory      (stbi_uc const *buffer, int len)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return tga_test(&s);
-}
-
-static stbi_uc *tga_load(stbi *s, int *x, int *y, int *comp, int req_comp)
-{
-	//	read in the TGA header stuff
-	int tga_offset = get8u(s);
-	int tga_indexed = get8u(s);
-	int tga_image_type = get8u(s);
-	int tga_is_RLE = 0;
-	int tga_palette_start = get16le(s);
-	int tga_palette_len = get16le(s);
-	int tga_palette_bits = get8u(s);
-	int tga_x_origin = get16le(s);
-	int tga_y_origin = get16le(s);
-	int tga_width = get16le(s);
-	int tga_height = get16le(s);
-	int tga_bits_per_pixel = get8u(s);
-	int tga_inverted = get8u(s);
-	//	image data
-	unsigned char *tga_data;
-	unsigned char *tga_palette = NULL;
-	int i, j;
-	unsigned char raw_data[4];
-	unsigned char trans_data[4];
-	int RLE_count = 0;
-	int RLE_repeating = 0;
-	int read_next_pixel = 1;
-	//	do a tiny bit of precessing
-	if( tga_image_type >= 8 )
-	{
-		tga_image_type -= 8;
-		tga_is_RLE = 1;
-	}
-	/* int tga_alpha_bits = tga_inverted & 15; */
-	tga_inverted = 1 - ((tga_inverted >> 5) & 1);
-
-	//	error check
-	if( //(tga_indexed) ||
-		(tga_width < 1) || (tga_height < 1) ||
-		(tga_image_type < 1) || (tga_image_type > 3) ||
-		((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) &&
-		(tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32))
-		)
-	{
-		return NULL;
-	}
-
-	//	If I'm paletted, then I'll use the number of bits from the palette
-	if( tga_indexed )
-	{
-		tga_bits_per_pixel = tga_palette_bits;
-	}
-
-	//	tga info
-	*x = tga_width;
-	*y = tga_height;
-	if( (req_comp < 1) || (req_comp > 4) )
-	{
-		//	just use whatever the file was
-		req_comp = tga_bits_per_pixel / 8;
-		*comp = req_comp;
-	} else
-	{
-		//	force a new number of components
-		*comp = tga_bits_per_pixel/8;
-	}
-	tga_data = (unsigned char*)malloc( tga_width * tga_height * req_comp );
-
-	//	skip to the data's starting position (offset usually = 0)
-	skip(s, tga_offset );
-	//	do I need to load a palette?
-	if( tga_indexed )
-	{
-		//	any data to skip? (offset usually = 0)
-		skip(s, tga_palette_start );
-		//	load the palette
-		tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 );
-		getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 );
-	}
-	//	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 chunk?
-		if( tga_is_RLE )
-		{
-			if( RLE_count == 0 )
-			{
-				//	yep, get the next byte as a RLE command
-				int RLE_cmd = get8u(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 1 byte, then perform the lookup
-				int pal_idx = get8u(s);
-				if( pal_idx >= tga_palette_len )
-				{
-					//	invalid index
-					pal_idx = 0;
-				}
-				pal_idx *= tga_bits_per_pixel / 8;
-				for( j = 0; j*8 < tga_bits_per_pixel; ++j )
-				{
-					raw_data[j] = tga_palette[pal_idx+j];
-				}
-			} else
-			{
-				//	read in the data raw
-				for( j = 0; j*8 < tga_bits_per_pixel; ++j )
-				{
-					raw_data[j] = get8u(s);
-				}
-			}
-			//	convert raw to the intermediate format
-			switch( tga_bits_per_pixel )
-			{
-			case 8:
-				//	Luminous => RGBA
-				trans_data[0] = raw_data[0];
-				trans_data[1] = raw_data[0];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = 255;
-				break;
-			case 16:
-				//	Luminous,Alpha => RGBA
-				trans_data[0] = raw_data[0];
-				trans_data[1] = raw_data[0];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = raw_data[1];
-				break;
-			case 24:
-				//	BGR => RGBA
-				trans_data[0] = raw_data[2];
-				trans_data[1] = raw_data[1];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = 255;
-				break;
-			case 32:
-				//	BGRA => RGBA
-				trans_data[0] = raw_data[2];
-				trans_data[1] = raw_data[1];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = raw_data[3];
-				break;
-			}
-			//	clear the reading flag for the next pixel
-			read_next_pixel = 0;
-		} // end of reading a pixel
-		//	convert to final format
-		switch( req_comp )
-		{
-		case 1:
-			//	RGBA => Luminance
-			tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]);
-			break;
-		case 2:
-			//	RGBA => Luminance,Alpha
-			tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]);
-			tga_data[i*req_comp+1] = trans_data[3];
-			break;
-		case 3:
-			//	RGBA => RGB
-			tga_data[i*req_comp+0] = trans_data[0];
-			tga_data[i*req_comp+1] = trans_data[1];
-			tga_data[i*req_comp+2] = trans_data[2];
-			break;
-		case 4:
-			//	RGBA => RGBA
-			tga_data[i*req_comp+0] = trans_data[0];
-			tga_data[i*req_comp+1] = trans_data[1];
-			tga_data[i*req_comp+2] = trans_data[2];
-			tga_data[i*req_comp+3] = trans_data[3];
-			break;
-		}
-		//	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 * req_comp;
-			int index2 = (tga_height - 1 - j) * tga_width * req_comp;
-			for( i = tga_width * req_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 )
-	{
-		free( tga_palette );
-	}
-	//	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;
-}
-
-#ifndef STBI_NO_STDIO
-stbi_uc *stbi_tga_load             (char const *filename,           int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_tga_load_from_file(f, x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-
-stbi_uc *stbi_tga_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_file(&s, f);
-   return tga_load(&s, x,y,comp,req_comp);
-}
-#endif
-
-stbi_uc *stbi_tga_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return tga_load(&s, x,y,comp,req_comp);
-}
-
-
-// *************************************************************************************************
-// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicholas Schulz, tweaked by STB
-
-static int psd_test(stbi *s)
-{
-	if (get32(s) != 0x38425053) return 0;	// "8BPS"
-	else return 1;
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_psd_test_file(FILE *f)
-{
-   stbi s;
-   int r,n = ftell(f);
-   start_file(&s, f);
-   r = psd_test(&s);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int stbi_psd_test_memory(stbi_uc const *buffer, int len)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return psd_test(&s);
-}
-
-static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp)
-{
-	int	pixelCount;
-	int channelCount, compression;
-	int channel, i, count, len;
-   int w,h;
-   uint8 *out;
-
-	// Check identifier
-	if (get32(s) != 0x38425053)	// "8BPS"
-		return epuc("not PSD", "Corrupt PSD image");
-
-	// Check file type version.
-	if (get16(s) != 1)
-		return epuc("wrong version", "Unsupported version of PSD image");
-
-	// Skip 6 reserved bytes.
-	skip(s, 6 );
-
-	// Read the number of channels (R, G, B, A, etc).
-	channelCount = get16(s);
-	if (channelCount < 0 || channelCount > 16)
-		return epuc("wrong channel count", "Unsupported number of channels in PSD image");
-
-	// Read the rows and columns of the image.
-   h = get32(s);
-   w = get32(s);
-	
-	// Make sure the depth is 8 bits.
-	if (get16(s) != 8)
-		return epuc("unsupported bit depth", "PSD bit depth is not 8 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 (get16(s) != 3)
-		return epuc("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.)
-	skip(s,get32(s) );
-
-	// Skip the image resources.  (resolution, pen tool paths, etc)
-	skip(s, get32(s) );
-
-	// Skip the reserved data.
-	skip(s, get32(s) );
-
-	// Find out if the data is compressed.
-	// Known values:
-	//   0: no compression
-	//   1: RLE compressed
-	compression = get16(s);
-	if (compression > 1)
-		return epuc("bad compression", "PSD has an unknown compression format");
-
-	// Create the destination image.
-	out = (stbi_uc *) malloc(4 * w*h);
-	if (!out) return epuc("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 preceeded by a 2-byte data count for each row in the data,
-		// which we're going to just skip.
-		skip(s, h * channelCount * 2 );
-
-		// Read the RLE data by channel.
-		for (channel = 0; channel < 4; channel++) {
-			uint8 *p;
-			
-         p = out+channel;
-			if (channel >= channelCount) {
-				// Fill this channel with default data.
-				for (i = 0; i < pixelCount; i++) *p = (channel == 3 ? 255 : 0), p += 4;
-			} else {
-				// Read the RLE data.
-				count = 0;
-				while (count < pixelCount) {
-					len = get8(s);
-					if (len == 128) {
-						// No-op.
-					} else if (len < 128) {
-						// Copy next len+1 bytes literally.
-						len++;
-						count += len;
-						while (len) {
-							*p = get8(s);
-                     p += 4;
-							len--;
-						}
-					} else if (len > 128) {
-						uint32	val;
-						// Next -len+1 bytes in the dest are replicated from next source byte.
-						// (Interpret len as a negative 8-bit int.)
-						len ^= 0x0FF;
-						len += 2;
-                  val = get8(s);
-						count += len;
-						while (len) {
-							*p = val;
-                     p += 4;
-							len--;
-						}
-					}
-				}
-			}
-		}
-		
-	} 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 value for each pixel in the image.
-		
-		// Read the data by channel.
-		for (channel = 0; channel < 4; channel++) {
-			uint8 *p;
-			
-         p = out + channel;
-			if (channel > channelCount) {
-				// Fill this channel with default data.
-				for (i = 0; i < pixelCount; i++) *p = channel == 3 ? 255 : 0, p += 4;
-			} else {
-				// Read the data.
-				count = 0;
-				for (i = 0; i < pixelCount; i++)
-					*p = get8(s), p += 4;
-			}
-		}
-	}
-
-	if (req_comp && req_comp != 4) {
-		out = convert_format(out, 4, req_comp, w, h);
-		if (out == NULL) return out; // convert_format frees input on failure
-	}
-
-	if (comp) *comp = channelCount;
-	*y = h;
-	*x = w;
-	
-	return out;
-}
-
-#ifndef STBI_NO_STDIO
-stbi_uc *stbi_psd_load(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_psd_load_from_file(f, x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-
-stbi_uc *stbi_psd_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_file(&s, f);
-   return psd_load(&s, x,y,comp,req_comp);
-}
-#endif
-
-stbi_uc *stbi_psd_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return psd_load(&s, x,y,comp,req_comp);
-}
-
-
-// *************************************************************************************************
-// Radiance RGBE HDR loader
-// originally by Nicolas Schulz
-#ifndef STBI_NO_HDR
-static int hdr_test(stbi *s)
-{
-   char *signature = "#?RADIANCE\n";
-   int i;
-   for (i=0; signature[i]; ++i)
-      if (get8(s) != signature[i])
-         return 0;
-	return 1;
-}
-
-int stbi_hdr_test_memory(stbi_uc const *buffer, int len)
-{
-   stbi s;
-	start_mem(&s, buffer, len);
-	return hdr_test(&s);
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_hdr_test_file(FILE *f)
-{
-   stbi s;
-   int r,n = ftell(f);
-   start_file(&s, f);
-   r = hdr_test(&s);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-#define HDR_BUFLEN  1024
-static char *hdr_gettoken(stbi *z, char *buffer)
-{
-   int len=0;
-	char *s = buffer, c = '\0';
-
-   c = get8(z);
-
-	while (!at_eof(z) && c != '\n') {
-		buffer[len++] = c;
-      if (len == HDR_BUFLEN-1) {
-         // flush to end of line
-         while (!at_eof(z) && get8(z) != '\n')
-            ;
-         break;
-      }
-      c = get8(z);
-	}
-
-   buffer[len] = 0;
-	return buffer;
-}
-
-static void 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 *hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp)
-{
-   char buffer[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;
-
-
-	// Check identifier
-	if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0)
-		return epf("not HDR", "Corrupt HDR image");
-	
-	// Parse header
-	while(1) {
-		token = hdr_gettoken(s,buffer);
-      if (token[0] == 0) break;
-		if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
-   }
-
-	if (!valid)    return epf("unsupported format", "Unsupported HDR format");
-
-   // Parse width and height
-   // can't use sscanf() if we're not using stdio!
-   token = hdr_gettoken(s,buffer);
-   if (strncmp(token, "-Y ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   height = strtol(token, &token, 10);
-   while (*token == ' ') ++token;
-   if (strncmp(token, "+X ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   width = strtol(token, NULL, 10);
-
-	*x = width;
-	*y = height;
-
-   *comp = 3;
-	if (req_comp == 0) req_comp = 3;
-
-	// Read data
-	hdr_data = (float *) malloc(height * width * req_comp * sizeof(float));
-
-	// 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:
-            getn(s, rgbe, 4);
-            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 = get8(s);
-         c2 = get8(s);
-         len = 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] = { c1,c2,len, get8(s) };
-            hdr_convert(hdr_data, rgbe, req_comp);
-            i = 1;
-            j = 0;
-            free(scanline);
-            goto main_decode_loop; // yes, this is fucking insane; blame the fucking insane format
-         }
-         len <<= 8;
-         len |= get8(s);
-         if (len != width) { free(hdr_data); free(scanline); return epf("invalid decoded scanline length", "corrupt HDR"); }
-         if (scanline == NULL) scanline = (stbi_uc *) malloc(width * 4);
-				
-			for (k = 0; k < 4; ++k) {
-				i = 0;
-				while (i < width) {
-					count = get8(s);
-					if (count > 128) {
-						// Run
-						value = get8(s);
-                  count -= 128;
-						for (z = 0; z < count; ++z)
-							scanline[i++ * 4 + k] = value;
-					} else {
-						// Dump
-						for (z = 0; z < count; ++z)
-							scanline[i++ * 4 + k] = get8(s);
-					}
-				}
-			}
-         for (i=0; i < width; ++i)
-            hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
-		}
-      free(scanline);
-	}
-
-   return hdr_data;
-}
-
-#ifndef STBI_NO_STDIO
-float *stbi_hdr_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_file(&s,f);
-   return hdr_load(&s,x,y,comp,req_comp);
-}
-#endif
-
-float *stbi_hdr_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_mem(&s,buffer, len);
-   return hdr_load(&s,x,y,comp,req_comp);
-}
-
-#endif // STBI_NO_HDR
-
-/////////////////////// write image ///////////////////////
-
-#ifndef STBI_NO_WRITE
-
-static void write8(FILE *f, int x) { uint8 z = (uint8) x; fwrite(&z,1,1,f); }
-
-static void writefv(FILE *f, char *fmt, va_list v)
-{
-   while (*fmt) {
-      switch (*fmt++) {
-         case ' ': break;
-         case '1': { uint8 x = va_arg(v, int); write8(f,x); break; }
-         case '2': { int16 x = va_arg(v, int); write8(f,x); write8(f,x>>8); break; }
-         case '4': { int32 x = va_arg(v, int); write8(f,x); write8(f,x>>8); write8(f,x>>16); write8(f,x>>24); break; }
-         default:
-            assert(0);
-            va_end(v);
-            return;
-      }
-   }
-}
-
-static void writef(FILE *f, char *fmt, ...)
-{
-   va_list v;
-   va_start(v, fmt);
-   writefv(f,fmt,v);
-   va_end(v);
-}
-
-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)
-{
-   uint8 bg[3] = { 255, 0, 255}, px[3];
-   uint32 zero = 0;
-   int i,j,k, j_end;
-
-   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) {
-         uint8 *d = (uint8 *) data + (j*x+i)*comp;
-         if (write_alpha < 0)
-            fwrite(&d[comp-1], 1, 1, f);
-         switch (comp) {
-            case 1:
-            case 2: writef(f, "111", d[0],d[0],d[0]);
-                    break;
-            case 4:
-               if (!write_alpha) {
-                  for (k=0; k < 3; ++k)
-                     px[k] = bg[k] + ((d[k] - bg[k]) * d[3])/255;
-                  writef(f, "111", px[1-rgb_dir],px[1],px[1+rgb_dir]);
-                  break;
-               }
-               /* FALLTHROUGH */
-            case 3:
-               writef(f, "111", 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, char *fmt, ...)
-{
-   FILE *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, void *data)
-{
-   int pad = (-x*3) & 3;
-   return outfile(filename,-1,-1,x,y,comp,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, void *data)
-{
-   int has_alpha = !(comp & 1);
-   return outfile(filename, -1,-1, x, y, comp, 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);
-}
-
-// any other image formats that do interleaved rgb data?
-//    PNG: requires adler32,crc32 -- significant amount of code
-//    PSD: no, channels output separately
-//    TIFF: no, stripwise-interleaved... i think
-
-#endif // STBI_NO_WRITE
-
-#endif // STBI_HEADER_FILE_ONLY
-
diff --git a/4dm.h/soil/pkm_helper.h b/4dm.h/soil/pkm_helper.h
new file mode 100644
index 0000000..0143e3f
--- /dev/null
+++ b/4dm.h/soil/pkm_helper.h
@@ -0,0 +1,19 @@
+#ifndef PKM_HELPER_H
+#define PKM_HELPER_H
+
+typedef struct {
+	char aName[6];
+	unsigned short iBlank;
+	unsigned char iPaddedWidthMSB;
+	unsigned char iPaddedWidthLSB;
+	unsigned char iPaddedHeightMSB;
+	unsigned char iPaddedHeightLSB;
+	unsigned char iWidthMSB;
+	unsigned char iWidthLSB;
+	unsigned char iHeightMSB;
+	unsigned char iHeightLSB;
+} PKMHeader;
+
+#define PKM_HEADER_SIZE 16
+
+#endif
diff --git a/4dm.h/soil/pvr_helper.h b/4dm.h/soil/pvr_helper.h
new file mode 100644
index 0000000..bace1f3
--- /dev/null
+++ b/4dm.h/soil/pvr_helper.h
@@ -0,0 +1,264 @@
+#ifndef PVR_HELPER_H
+#define PVR_HELPER_H
+
+// Taken from PowerVR SDK
+
+/*!***************************************************************************
+ Describes the header of a PVR header-texture
+ *****************************************************************************/
+typedef struct
+{
+	unsigned int dwHeaderSize;			/*!< size of the structure */
+	unsigned int dwHeight;				/*!< height of surface to be created */
+	unsigned int dwWidth;				/*!< width of input surface */
+	unsigned int dwMipMapCount;			/*!< number of mip-map levels requested */
+	unsigned int dwpfFlags;				/*!< pixel format flags */
+	unsigned int dwTextureDataSize;		/*!< Total size in bytes */
+	unsigned int dwBitCount;			/*!< number of bits per pixel  */
+	unsigned int dwRBitMask;			/*!< mask for red bit */
+	unsigned int dwGBitMask;			/*!< mask for green bits */
+	unsigned int dwBBitMask;			/*!< mask for blue bits */
+	unsigned int dwAlphaBitMask;		/*!< mask for alpha channel */
+	unsigned int dwPVR;					/*!< magic number identifying pvr file */
+	unsigned int dwNumSurfs;			/*!< the number of surfaces present in the pvr */
+} PVR_Texture_Header;
+
+/*****************************************************************************
+ * ENUMS
+ *****************************************************************************/
+
+enum PixelType
+{
+	MGLPT_ARGB_4444 = 0x00,
+	MGLPT_ARGB_1555,
+	MGLPT_RGB_565,
+	MGLPT_RGB_555,
+	MGLPT_RGB_888,
+	MGLPT_ARGB_8888,
+	MGLPT_ARGB_8332,
+	MGLPT_I_8,
+	MGLPT_AI_88,
+	MGLPT_1_BPP,
+	MGLPT_VY1UY0,
+	MGLPT_Y1VY0U,
+	MGLPT_PVRTC2,
+	MGLPT_PVRTC4,
+	MGLPT_PVRTC2_2,
+	MGLPT_PVRTC2_4,
+	
+	OGL_RGBA_4444= 0x10,
+	OGL_RGBA_5551,
+	OGL_RGBA_8888,
+	OGL_RGB_565,
+	OGL_RGB_555,
+	OGL_RGB_888,
+	OGL_I_8,
+	OGL_AI_88,
+	OGL_PVRTC2,
+	OGL_PVRTC4,
+	
+	// OGL_BGRA_8888 extension
+	OGL_BGRA_8888,
+	
+	D3D_DXT1 = 0x20,
+	D3D_DXT2,
+	D3D_DXT3,
+	D3D_DXT4,
+	D3D_DXT5,
+	
+	D3D_RGB_332,
+	D3D_AI_44,
+	D3D_LVU_655,
+	D3D_XLVU_8888,
+	D3D_QWVU_8888,
+	
+	//10 bits per channel
+	D3D_ABGR_2101010,
+	D3D_ARGB_2101010,
+	D3D_AWVU_2101010,
+	
+	//16 bits per channel
+	D3D_GR_1616,
+	D3D_VU_1616,
+	D3D_ABGR_16161616,
+	
+	//HDR formats
+	D3D_R16F,
+	D3D_GR_1616F,
+	D3D_ABGR_16161616F,
+	
+	//32 bits per channel
+	D3D_R32F,
+	D3D_GR_3232F,
+	D3D_ABGR_32323232F,
+	
+	// Ericsson
+	ETC_RGB_4BPP,
+	ETC_RGBA_EXPLICIT,
+	ETC_RGBA_INTERPOLATED,
+	
+	// DX10
+	
+	
+	ePT_DX10_R32G32B32A32_FLOAT= 0x50,
+	ePT_DX10_R32G32B32A32_UINT ,
+	ePT_DX10_R32G32B32A32_SINT,
+	
+	ePT_DX10_R32G32B32_FLOAT,
+	ePT_DX10_R32G32B32_UINT,
+	ePT_DX10_R32G32B32_SINT,
+	
+	ePT_DX10_R16G16B16A16_FLOAT ,
+	ePT_DX10_R16G16B16A16_UNORM,
+	ePT_DX10_R16G16B16A16_UINT ,
+	ePT_DX10_R16G16B16A16_SNORM ,
+	ePT_DX10_R16G16B16A16_SINT ,
+	
+	ePT_DX10_R32G32_FLOAT ,
+	ePT_DX10_R32G32_UINT ,
+	ePT_DX10_R32G32_SINT ,
+	
+	ePT_DX10_R10G10B10A2_UNORM ,
+	ePT_DX10_R10G10B10A2_UINT ,
+	
+	ePT_DX10_R11G11B10_FLOAT ,
+	
+	ePT_DX10_R8G8B8A8_UNORM ,
+	ePT_DX10_R8G8B8A8_UNORM_SRGB ,
+	ePT_DX10_R8G8B8A8_UINT ,
+	ePT_DX10_R8G8B8A8_SNORM ,
+	ePT_DX10_R8G8B8A8_SINT ,
+	
+	ePT_DX10_R16G16_FLOAT ,
+	ePT_DX10_R16G16_UNORM ,
+	ePT_DX10_R16G16_UINT ,
+	ePT_DX10_R16G16_SNORM ,
+	ePT_DX10_R16G16_SINT ,
+	
+	ePT_DX10_R32_FLOAT ,
+	ePT_DX10_R32_UINT ,
+	ePT_DX10_R32_SINT ,
+	
+	ePT_DX10_R8G8_UNORM ,
+	ePT_DX10_R8G8_UINT ,
+	ePT_DX10_R8G8_SNORM ,
+	ePT_DX10_R8G8_SINT ,
+	
+	ePT_DX10_R16_FLOAT ,
+	ePT_DX10_R16_UNORM ,
+	ePT_DX10_R16_UINT ,
+	ePT_DX10_R16_SNORM ,
+	ePT_DX10_R16_SINT ,
+	
+	ePT_DX10_R8_UNORM,
+	ePT_DX10_R8_UINT,
+	ePT_DX10_R8_SNORM,
+	ePT_DX10_R8_SINT,
+	
+	ePT_DX10_A8_UNORM,
+	ePT_DX10_R1_UNORM,
+	ePT_DX10_R9G9B9E5_SHAREDEXP,
+	ePT_DX10_R8G8_B8G8_UNORM,
+	ePT_DX10_G8R8_G8B8_UNORM,
+	
+	ePT_DX10_BC1_UNORM,
+	ePT_DX10_BC1_UNORM_SRGB,
+	
+	ePT_DX10_BC2_UNORM,
+	ePT_DX10_BC2_UNORM_SRGB,
+	
+	ePT_DX10_BC3_UNORM,
+	ePT_DX10_BC3_UNORM_SRGB,
+	
+	ePT_DX10_BC4_UNORM,
+	ePT_DX10_BC4_SNORM,
+	
+	ePT_DX10_BC5_UNORM,
+	ePT_DX10_BC5_SNORM,
+	
+	//ePT_DX10_B5G6R5_UNORM,			// defined but obsolete - won't actually load in DX10
+	//ePT_DX10_B5G5R5A1_UNORM,
+	//ePT_DX10_B8G8R8A8_UNORM,
+	//ePT_DX10_B8G8R8X8_UNORM,
+	
+	// OpenVG
+	
+	/* RGB{A,X} channel ordering */
+	ePT_VG_sRGBX_8888  = 0x90,
+	ePT_VG_sRGBA_8888,
+	ePT_VG_sRGBA_8888_PRE,
+	ePT_VG_sRGB_565,
+	ePT_VG_sRGBA_5551,
+	ePT_VG_sRGBA_4444,
+	ePT_VG_sL_8,
+	ePT_VG_lRGBX_8888,
+	ePT_VG_lRGBA_8888,
+	ePT_VG_lRGBA_8888_PRE,
+	ePT_VG_lL_8,
+	ePT_VG_A_8,
+	ePT_VG_BW_1,
+	
+	/* {A,X}RGB channel ordering */
+	ePT_VG_sXRGB_8888,
+	ePT_VG_sARGB_8888,
+	ePT_VG_sARGB_8888_PRE,
+	ePT_VG_sARGB_1555,
+	ePT_VG_sARGB_4444,
+	ePT_VG_lXRGB_8888,
+	ePT_VG_lARGB_8888,
+	ePT_VG_lARGB_8888_PRE,
+	
+	/* BGR{A,X} channel ordering */
+	ePT_VG_sBGRX_8888,
+	ePT_VG_sBGRA_8888,
+	ePT_VG_sBGRA_8888_PRE,
+	ePT_VG_sBGR_565,
+	ePT_VG_sBGRA_5551,
+	ePT_VG_sBGRA_4444,
+	ePT_VG_lBGRX_8888,
+	ePT_VG_lBGRA_8888,
+	ePT_VG_lBGRA_8888_PRE,
+	
+	/* {A,X}BGR channel ordering */
+	ePT_VG_sXBGR_8888,
+	ePT_VG_sABGR_8888 ,
+	ePT_VG_sABGR_8888_PRE,
+	ePT_VG_sABGR_1555,
+	ePT_VG_sABGR_4444,
+	ePT_VG_lXBGR_8888,
+	ePT_VG_lABGR_8888,
+	ePT_VG_lABGR_8888_PRE,
+	
+	// max cap for iterating
+	END_OF_PIXEL_TYPES,
+	
+	MGLPT_NOTYPE = 0xff
+	
+};
+
+/*****************************************************************************
+ * constants
+ *****************************************************************************/
+
+#define PVRTEX_MIPMAP		(1<<8)		// has mip map levels
+#define PVRTEX_TWIDDLE		(1<<9)		// is twiddled
+#define PVRTEX_BUMPMAP		(1<<10)		// has normals encoded for a bump map
+#define PVRTEX_TILING		(1<<11)		// is bordered for tiled pvr
+#define PVRTEX_CUBEMAP		(1<<12)		// is a cubemap/skybox
+#define PVRTEX_FALSEMIPCOL	(1<<13)		//
+#define PVRTEX_VOLUME		(1<<14)
+#define PVRTEX_PIXELTYPE	0xff			// pixel type is always in the last 16bits of the flags
+#define PVRTEX_IDENTIFIER	0x21525650	// the pvr identifier is the characters 'P','V','R'
+
+#define PVRTEX_V1_HEADER_SIZE 44			// old header size was 44 for identification purposes
+
+#define PVRTC2_MIN_TEXWIDTH		16
+#define PVRTC2_MIN_TEXHEIGHT	8
+#define PVRTC4_MIN_TEXWIDTH		8
+#define PVRTC4_MIN_TEXHEIGHT	8
+#define ETC_MIN_TEXWIDTH		4
+#define ETC_MIN_TEXHEIGHT		4
+#define DXT_MIN_TEXWIDTH		4
+#define DXT_MIN_TEXHEIGHT		4
+
+#endif
diff --git a/4dm.h/soil/soil2.lib b/4dm.h/soil/soil2.lib
new file mode 100644
index 0000000..0bb6325
Binary files /dev/null and b/4dm.h/soil/soil2.lib differ
diff --git a/4dm.h/soil/stb_image.h b/4dm.h/soil/stb_image.h
new file mode 100644
index 0000000..ff142bf
--- /dev/null
+++ b/4dm.h/soil/stb_image.h
@@ -0,0 +1,7718 @@
+/* stb_image - v2.25 - 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.25  (2020-02-02) fix warnings
+      2.24  (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically
+      2.23  (2019-08-11) fix clang static analysis warning
+      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
+    Brad Weinberger         Matvey Cherevko                       github:Michaelangel007
+    Blazej Dariusz Roszkowski                  Alexander Veselov
+*/
+
+#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
+// on most compilers (and ALL modern mainstream compilers) this is 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);
+
+// as above, but only applies to images loaded on the thread that calls the function
+// this function is only available if your compiler supports thread-local variables;
+// calling it will fail to link if your compiler doesn't
+STBIDEF void stbi_set_flip_vertically_on_load_thread(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);
+
+#ifndef STBI_NO_DDS
+#include "stbi_DDS.h"
+#endif
+
+#ifndef STBI_NO_PVR
+#include "stbi_pvr.h"
+#endif
+
+#ifndef STBI_NO_PKM
+#include "stbi_pkm.h"
+#endif
+
+#ifndef STBI_NO_EXT
+#include "stbi_ext.h"
+#endif
+
+#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
+
+#ifndef STBI_NO_THREAD_LOCALS
+   #if defined(__cplusplus) &&  __cplusplus >= 201103L
+      #define STBI_THREAD_LOCAL       thread_local
+   #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+      #define STBI_THREAD_LOCAL       _Thread_local
+   #elif defined(__GNUC__)
+      #define STBI_THREAD_LOCAL       __thread
+   #elif defined(_MSC_VER)
+      #define STBI_THREAD_LOCAL       __declspec(thread)
+#endif
+#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(__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
+
+#ifndef STBI_NO_DDS
+static int      stbi__dds_test(stbi__context *s);
+static void    *stbi__dds_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi__dds_info(stbi__context *s, int *x, int *y, int *comp, int *iscompressed);
+#endif
+
+#ifndef STBI_NO_PVR
+static int      stbi__pvr_test(stbi__context *s);
+static void    *stbi__pvr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi__pvr_info(stbi__context *s, int *x, int *y, int *comp, int * iscompressed);
+#endif
+
+#ifndef STBI_NO_PKM
+static int      stbi__pkm_test(stbi__context *s);
+static void    *stbi__pkm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi__pkm_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+static
+#ifdef STBI_THREAD_LOCAL
+STBI_THREAD_LOCAL
+#endif
+const char *stbi__g_failure_reason;
+
+STBIDEF const char *stbi_failure_reason(void)
+{
+   return stbi__g_failure_reason;
+}
+
+#ifndef STBI_NO_FAILURE_STRINGS
+static int stbi__err(const char *str)
+{
+   stbi__g_failure_reason = str;
+   return 0;
+}
+#endif
+
+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;
+}
+
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
+// 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);
+}
+#endif
+
+// 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
+
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
+// 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);
+}
+#endif
+
+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_global = 0;
+
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
+{
+   stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
+}
+
+#ifndef STBI_THREAD_LOCAL
+#define stbi__vertically_flip_on_load  stbi__vertically_flip_on_load_global
+#else
+static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
+
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
+{
+   stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
+   stbi__vertically_flip_on_load_set = 1;
+}
+
+#define stbi__vertically_flip_on_load  (stbi__vertically_flip_on_load_set       \
+                                         ? stbi__vertically_flip_on_load_local  \
+                                         : stbi__vertically_flip_on_load_global)
+#endif // STBI_THREAD_LOCAL
+
+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);
+   #else
+   STBI_NOTUSED(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_DDS
+   if (stbi__dds_test(s))  return stbi__dds_load(s,x,y,comp,req_comp);
+   #endif
+   #ifndef STBI_NO_PVR
+   if (stbi__pvr_test(s))  return stbi__pvr_load(s,x,y,comp,req_comp);
+   #endif
+   #ifndef STBI_NO_PKM
+   if (stbi__pkm_test(s))  return stbi__pkm_load(s,x,y,comp,req_comp);
+   #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;
+}
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+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;
+}
+#endif
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
+// nothing
+#else
+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;
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
+// nothing
+#else
+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;
+}
+#endif
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
+static int stbi__get16be(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return (z << 8) + stbi__get8(s);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
+static stbi__uint32 stbi__get32be(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16be(s);
+   return (z << 16) + stbi__get16be(s);
+}
+#endif
+
+#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
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+//////////////////////////////////////////////////////////////////////////////
+//
+//  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);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+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;
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
+static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
+{
+   return (stbi__uint16) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
+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;
+}
+#endif
+
+#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;
+            // end of PNG chunk, read and skip CRC
+            stbi__get32be(s);
+            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;/* >>=  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 < 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;
+   int extra_read;
+} 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;
+   info->extra_read = 14;
+
+   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);
+               info->extra_read += 12;
+               // 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 - info.extra_read - 24) / 3;
+   } else {
+      if (info.bpp < 16)
+         psize = (info.offset - info.extra_read - info.hsz) >> 2;
+   }
+   if (psize == 0) {
+      STBI_ASSERT(info.offset == (s->img_buffer - s->buffer_start));
+   }
+
+   if (info.bpp == 24 && ma == 0xff000000)
+      s->img_n = 3;
+   else
+      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 - info.extra_read - 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 - info.extra_read - 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);
+   STBI_NOTUSED(tga_x_origin); // @TODO
+   STBI_NOTUSED(tga_y_origin); // @TODO
+
+   //   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;
+   STBI_NOTUSED(tga_palette_start);
+   //   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) {
+               void *tmp = (stbi_uc*) STBI_REALLOC( out, layers * stride );
+               if (NULL == tmp) {
+                  STBI_FREE(g.out);
+                  STBI_FREE(g.history);
+                  STBI_FREE(g.background);
+                  return stbi__errpuc("outofmem", "Out of memory");
+               }
+               else
+                  out = (stbi_uc*) tmp;
+               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) {
+      if (info.bpp == 24 && info.ma == 0xff000000)
+         *comp = 3;
+      else
+         *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
+
+   #ifndef STBI_NO_DDS
+   if (stbi__dds_info(s, x, y, comp, NULL))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PVR
+   if (stbi__pvr_info(s, x, y, comp, NULL))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PKM
+   if (stbi__pkm_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);
+}
+
+// add in my DDS loading support
+#ifndef STBI_NO_DDS
+#include "stbi_DDS_c.h"
+#endif
+
+// add in my pvr loading support
+#ifndef STBI_NO_PVR
+#include "stbi_pvr_c.h"
+#endif
+
+// add in my pkm ( ETC1 ) loading support
+#ifndef STBI_NO_PKM
+#include "stbi_pkm_c.h"
+#endif
+
+#ifndef STBI_NO_EXT
+#include "stbi_ext_c.h"
+#endif
+
+#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/4dm.h/soil/stb_image_aug.c b/4dm.h/soil/stb_image_aug.c
deleted file mode 100644
index bb088fc..0000000
--- a/4dm.h/soil/stb_image_aug.c
+++ /dev/null
@@ -1,3682 +0,0 @@
-/* stbi-1.16 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
-                      when you control the images you're loading
-
-   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, no oddball channel decimations)
-      PNG non-interlaced
-      BMP non-1bpp, non-RLE
-      TGA (not sure what subset, if a subset)
-      PSD (composited view only, no extra channels)
-      HDR (radiance rgbE format)
-      writes BMP,TGA (define STBI_NO_WRITE to remove code)
-      decoded from memory or through stdio FILE (define STBI_NO_STDIO to remove code)
-      supports installable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
-
-   TODO:
-      stbi_info_*
-
-   history:
-      1.16   major bugfix - 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
-*/
-
-#include "stb_image_aug.h"
-
-#ifndef STBI_NO_HDR
-#include <math.h>  // ldexp
-#include <string.h> // strcmp
-#endif
-
-#ifndef STBI_NO_STDIO
-#include <stdio.h>
-#endif
-#include <stdlib.h>
-#include <memory.h>
-#include <assert.h>
-#include <stdarg.h>
-
-#ifndef _MSC_VER
-  #ifdef __cplusplus
-  #define __forceinline inline
-  #else
-  #define __forceinline
-  #endif
-#endif
-
-
-// implementation:
-typedef unsigned char uint8;
-typedef unsigned short uint16;
-typedef   signed short  int16;
-typedef unsigned int   uint32;
-typedef   signed int    int32;
-typedef unsigned int   uint;
-
-// should produce compiler error if size is wrong
-typedef unsigned char validate_uint32[sizeof(uint32)==4];
-
-#if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE)
-#define STBI_NO_WRITE
-#endif
-
-#ifndef STBI_NO_DDS
-#include "stbi_DDS_aug.h"
-#endif
-
-//	I (JLD) want full messages for SOIL
-#define STBI_FAILURE_USERMSG 1
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Generic API that works on all image types
-//
-
-// this is not threadsafe
-static char *failure_reason;
-
-char *stbi_failure_reason(void)
-{
-   return failure_reason;
-}
-
-static int e(char *str)
-{
-   failure_reason = str;
-   return 0;
-}
-
-#ifdef STBI_NO_FAILURE_STRINGS
-   #define e(x,y)  0
-#elif defined(STBI_FAILURE_USERMSG)
-   #define e(x,y)  e(y)
-#else
-   #define e(x,y)  e(x)
-#endif
-
-#define epf(x,y)   ((float *) (e(x,y)?NULL:NULL))
-#define epuc(x,y)  ((unsigned char *) (e(x,y)?NULL:NULL))
-
-void stbi_image_free(void *retval_from_stbi_load)
-{
-   free(retval_from_stbi_load);
-}
-
-#define MAX_LOADERS  32
-stbi_loader *loaders[MAX_LOADERS];
-static int max_loaders = 0;
-
-int stbi_register_loader(stbi_loader *loader)
-{
-   int i;
-   for (i=0; i < MAX_LOADERS; ++i) {
-      // already present?
-      if (loaders[i] == loader)
-         return 1;
-      // end of the list?
-      if (loaders[i] == NULL) {
-         loaders[i] = loader;
-         max_loaders = i+1;
-         return 1;
-      }
-   }
-   // no room for it
-   return 0;
-}
-
-#ifndef STBI_NO_HDR
-static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
-static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp);
-#endif
-
-#ifndef STBI_NO_STDIO
-unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   FILE *f = fopen(filename, "rb");
-   unsigned char *result;
-   if (!f) return epuc("can't fopen", "Unable to open file");
-   result = stbi_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   int i;
-   if (stbi_jpeg_test_file(f))
-      return stbi_jpeg_load_from_file(f,x,y,comp,req_comp);
-   if (stbi_png_test_file(f))
-      return stbi_png_load_from_file(f,x,y,comp,req_comp);
-   if (stbi_bmp_test_file(f))
-      return stbi_bmp_load_from_file(f,x,y,comp,req_comp);
-   if (stbi_psd_test_file(f))
-      return stbi_psd_load_from_file(f,x,y,comp,req_comp);
-   #ifndef STBI_NO_DDS
-   if (stbi_dds_test_file(f))
-      return stbi_dds_load_from_file(f,x,y,comp,req_comp);
-   #endif
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_file(f)) {
-      float *hdr = stbi_hdr_load_from_file(f, x,y,comp,req_comp);
-      return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
-   }
-   #endif
-   for (i=0; i < max_loaders; ++i)
-      if (loaders[i]->test_file(f))
-         return loaders[i]->load_from_file(f,x,y,comp,req_comp);
-   // test tga last because it's a crappy test!
-   if (stbi_tga_test_file(f))
-      return stbi_tga_load_from_file(f,x,y,comp,req_comp);
-   return epuc("unknown image type", "Image not of any known type, or corrupt");
-}
-#endif
-
-unsigned char *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   int i;
-   if (stbi_jpeg_test_memory(buffer,len))
-      return stbi_jpeg_load_from_memory(buffer,len,x,y,comp,req_comp);
-   if (stbi_png_test_memory(buffer,len))
-      return stbi_png_load_from_memory(buffer,len,x,y,comp,req_comp);
-   if (stbi_bmp_test_memory(buffer,len))
-      return stbi_bmp_load_from_memory(buffer,len,x,y,comp,req_comp);
-   if (stbi_psd_test_memory(buffer,len))
-      return stbi_psd_load_from_memory(buffer,len,x,y,comp,req_comp);
-   #ifndef STBI_NO_DDS
-   if (stbi_dds_test_memory(buffer,len))
-      return stbi_dds_load_from_memory(buffer,len,x,y,comp,req_comp);
-   #endif
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_memory(buffer, len)) {
-      float *hdr = stbi_hdr_load_from_memory(buffer, len,x,y,comp,req_comp);
-      return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
-   }
-   #endif
-   for (i=0; i < max_loaders; ++i)
-      if (loaders[i]->test_memory(buffer,len))
-         return loaders[i]->load_from_memory(buffer,len,x,y,comp,req_comp);
-   // test tga last because it's a crappy test!
-   if (stbi_tga_test_memory(buffer,len))
-      return stbi_tga_load_from_memory(buffer,len,x,y,comp,req_comp);
-   return epuc("unknown image type", "Image not of any known type, or corrupt");
-}
-
-#ifndef STBI_NO_HDR
-
-#ifndef STBI_NO_STDIO
-float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   FILE *f = fopen(filename, "rb");
-   float *result;
-   if (!f) return epf("can't fopen", "Unable to open file");
-   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_file(f))
-      return stbi_hdr_load_from_file(f,x,y,comp,req_comp);
-   #endif
-   data = stbi_load_from_file(f, x, y, comp, req_comp);
-   if (data)
-      return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
-   return epf("unknown image type", "Image not of any known type, or corrupt");
-}
-#endif
-
-float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   #ifndef STBI_NO_HDR
-   if (stbi_hdr_test_memory(buffer, len))
-      return stbi_hdr_load_from_memory(buffer, len,x,y,comp,req_comp);
-   #endif
-   data = stbi_load_from_memory(buffer, len, x, y, comp, req_comp);
-   if (data)
-      return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
-   return epf("unknown image type", "Image not of any known type, or corrupt");
-}
-#endif
-
-// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is
-// defined, for API simplicity; if STBI_NO_HDR is defined, it always
-// reports false!
-
-int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
-{
-   #ifndef STBI_NO_HDR
-   return stbi_hdr_test_memory(buffer, len);
-   #else
-   return 0;
-   #endif
-}
-
-#ifndef STBI_NO_STDIO
-extern int      stbi_is_hdr          (char const *filename)
-{
-   FILE *f = fopen(filename, "rb");
-   int result=0;
-   if (f) {
-      result = stbi_is_hdr_from_file(f);
-      fclose(f);
-   }
-   return result;
-}
-
-extern int      stbi_is_hdr_from_file(FILE *f)
-{
-   #ifndef STBI_NO_HDR
-   return stbi_hdr_test_file(f);
-   #else
-   return 0;
-   #endif
-}
-
-#endif
-
-// @TODO: get image dimensions & components without fully decoding
-#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
-extern int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-
-#ifndef STBI_NO_HDR
-static float h2l_gamma_i=1.0f/2.2f, h2l_scale_i=1.0f;
-static float l2h_gamma=2.2f, l2h_scale=1.0f;
-
-void   stbi_hdr_to_ldr_gamma(float gamma) { h2l_gamma_i = 1/gamma; }
-void   stbi_hdr_to_ldr_scale(float scale) { h2l_scale_i = 1/scale; }
-
-void   stbi_ldr_to_hdr_gamma(float gamma) { l2h_gamma = gamma; }
-void   stbi_ldr_to_hdr_scale(float scale) { l2h_scale = scale; }
-#endif
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Common code used by all image loaders
-//
-
-enum
-{
-   SCAN_load=0,
-   SCAN_type,
-   SCAN_header,
-};
-
-typedef struct
-{
-   uint32 img_x, img_y;
-   int img_n, img_out_n;
-
-   #ifndef STBI_NO_STDIO
-   FILE  *img_file;
-   #endif
-   uint8 *img_buffer, *img_buffer_end;
-} stbi;
-
-#ifndef STBI_NO_STDIO
-static void start_file(stbi *s, FILE *f)
-{
-   s->img_file = f;
-}
-#endif
-
-static void start_mem(stbi *s, uint8 const *buffer, int len)
-{
-#ifndef STBI_NO_STDIO
-   s->img_file = NULL;
-#endif
-   s->img_buffer = (uint8 *) buffer;
-   s->img_buffer_end = (uint8 *) buffer+len;
-}
-
-__forceinline static int get8(stbi *s)
-{
-#ifndef STBI_NO_STDIO
-   if (s->img_file) {
-      int c = fgetc(s->img_file);
-      return c == EOF ? 0 : c;
-   }
-#endif
-   if (s->img_buffer < s->img_buffer_end)
-      return *s->img_buffer++;
-   return 0;
-}
-
-__forceinline static int at_eof(stbi *s)
-{
-#ifndef STBI_NO_STDIO
-   if (s->img_file)
-      return feof(s->img_file);
-#endif
-   return s->img_buffer >= s->img_buffer_end;
-}
-
-__forceinline static uint8 get8u(stbi *s)
-{
-   return (uint8) get8(s);
-}
-
-static void skip(stbi *s, int n)
-{
-#ifndef STBI_NO_STDIO
-   if (s->img_file)
-      fseek(s->img_file, n, SEEK_CUR);
-   else
-#endif
-      s->img_buffer += n;
-}
-
-static int get16(stbi *s)
-{
-   int z = get8(s);
-   return (z << 8) + get8(s);
-}
-
-static uint32 get32(stbi *s)
-{
-   uint32 z = get16(s);
-   return (z << 16) + get16(s);
-}
-
-static int get16le(stbi *s)
-{
-   int z = get8(s);
-   return z + (get8(s) << 8);
-}
-
-static uint32 get32le(stbi *s)
-{
-   uint32 z = get16le(s);
-   return z + (get16le(s) << 16);
-}
-
-static void getn(stbi *s, stbi_uc *buffer, int n)
-{
-#ifndef STBI_NO_STDIO
-   if (s->img_file) {
-      fread(buffer, 1, n, s->img_file);
-      return;
-   }
-#endif
-   memcpy(buffer, s->img_buffer, n);
-   s->img_buffer += n;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//  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 uint8 compute_y(int r, int g, int b)
-{
-   return (uint8) (((r*77) + (g*150) +  (29*b)) >> 8);
-}
-
-static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp, uint x, uint y)
-{
-   int i,j;
-   unsigned char *good;
-
-   if (req_comp == img_n) return data;
-   assert(req_comp >= 1 && req_comp <= 4);
-
-   good = (unsigned char *) malloc(req_comp * x * y);
-   if (good == NULL) {
-      free(data);
-      return epuc("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 COMBO(a,b)  ((a)*8+(b))
-      #define CASE(a,b)   case 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(COMBO(img_n, req_comp)) {
-         CASE(1,2) dest[0]=src[0], dest[1]=255; break;
-         CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break;
-         CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break;
-         CASE(2,1) dest[0]=src[0]; break;
-         CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break;
-         CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break;
-         CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break;
-         CASE(3,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
-         CASE(3,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = 255; break;
-         CASE(4,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
-         CASE(4,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break;
-         CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break;
-         default: assert(0);
-      }
-      #undef CASE
-   }
-
-   free(data);
-   return good;
-}
-
-#ifndef STBI_NO_HDR
-static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
-{
-   int i,k,n;
-   float *output = (float *) malloc(x * y * comp * sizeof(float));
-   if (output == NULL) { free(data); return epf("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, l2h_gamma) * l2h_scale;
-      }
-      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
-   }
-   free(data);
-   return output;
-}
-
-#define float2int(x)   ((int) (x))
-static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp)
-{
-   int i,k,n;
-   stbi_uc *output = (stbi_uc *) malloc(x * y * comp);
-   if (output == NULL) { free(data); return epuc("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]*h2l_scale_i, h2l_gamma_i) * 255 + 0.5f;
-         if (z < 0) z = 0;
-         if (z > 255) z = 255;
-         output[i*comp + k] = 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] = float2int(z);
-      }
-   }
-   free(data);
-   return output;
-}
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//  "baseline" JPEG/JFIF decoder (not actually fully baseline implementation)
-//
-//    simple implementation
-//      - channel subsampling of at most 2 in each dimension
-//      - 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
-//      - uses a lot of intermediate memory, could cache poorly
-//      - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4
-//          stb_jpeg:   1.34 seconds (MSVC6, default release build)
-//          stb_jpeg:   1.06 seconds (MSVC6, processor = Pentium Pro)
-//          IJL11.dll:  1.08 seconds (compiled by intel)
-//          IJG 1998:   0.98 seconds (MSVC6, makefile provided by IJG)
-//          IJG 1998:   0.95 seconds (MSVC6, makefile + proc=PPro)
-
-// huffman decoding acceleration
-#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
-
-typedef struct
-{
-   uint8  fast[1 << FAST_BITS];
-   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
-   uint16 code[256];
-   uint8  values[256];
-   uint8  size[257];
-   unsigned int maxcode[18];
-   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
-} huffman;
-
-typedef struct
-{
-   #if STBI_SIMD
-   unsigned short dequant2[4][64];
-   #endif
-   stbi s;
-   huffman huff_dc[4];
-   huffman huff_ac[4];
-   uint8 dequant[4][64];
-
-// 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;
-      uint8 *data;
-      void *raw_data;
-      uint8 *linebuf;
-   } img_comp[4];
-
-   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 scan_n, order[4];
-   int restart_interval, todo;
-} jpeg;
-
-static int build_huffman(huffman *h, int *count)
-{
-   int i,j,k=0,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++] = (uint8) (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++] = (uint16) (code++);
-         if (code-1 >= (1 << j)) return e("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] = (uint8) i;
-         }
-      }
-   }
-   return 1;
-}
-
-static void grow_buffer_unsafe(jpeg *j)
-{
-   do {
-      int b = j->nomore ? 0 : get8(&j->s);
-      if (b == 0xff) {
-         int c = get8(&j->s);
-         if (c != 0) {
-            j->marker = (unsigned char) c;
-            j->nomore = 1;
-            return;
-         }
-      }
-      j->code_buffer = (j->code_buffer << 8) | b;
-      j->code_bits += 8;
-   } while (j->code_bits <= 24);
-}
-
-// (1 << n) - 1
-static uint32 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
-__forceinline static int decode(jpeg *j, huffman *h)
-{
-   unsigned int temp;
-   int c,k;
-
-   if (j->code_bits < 16) 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 >> (j->code_bits - FAST_BITS)) & ((1 << FAST_BITS)-1);
-   k = h->fast[c];
-   if (k < 255) {
-      if (h->size[k] > j->code_bits)
-         return -1;
-      j->code_bits -= h->size[k];
-      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.
-   if (j->code_bits < 16)
-      temp = (j->code_buffer << (16 - j->code_bits)) & 0xffff;
-   else
-      temp = (j->code_buffer >> (j->code_bits - 16)) & 0xffff;
-   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 >> (j->code_bits - k)) & bmask[k]) + h->delta[k];
-   assert((((j->code_buffer) >> (j->code_bits - h->size[c])) & bmask[h->size[c]]) == h->code[c]);
-
-   // convert the id to a symbol
-   j->code_bits -= k;
-   return h->values[c];
-}
-
-// combined JPEG 'receive' and JPEG 'extend', since baseline
-// always extends everything it receives.
-__forceinline static int extend_receive(jpeg *j, int n)
-{
-   unsigned int m = 1 << (n-1);
-   unsigned int k;
-   if (j->code_bits < n) grow_buffer_unsafe(j);
-   k = (j->code_buffer >> (j->code_bits - n)) & bmask[n];
-   j->code_bits -= n;
-   // the following test is probably a random branch that won't
-   // predict well. I tried to table accelerate it but failed.
-   // maybe it's compiling as a conditional move?
-   if (k < m)
-      return (-1 << n) + k + 1;
-   else
-      return k;
-}
-
-// 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 uint8 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 decode_block(jpeg *j, short data[64], huffman *hdc, huffman *hac, int b)
-{
-   int diff,dc,k;
-   int t = decode(j, hdc);
-   if (t < 0) return e("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 ? extend_receive(j, t) : 0;
-   dc = j->img_comp[b].dc_pred + diff;
-   j->img_comp[b].dc_pred = dc;
-   data[0] = (short) dc;
-
-   // decode AC components, see JPEG spec
-   k = 1;
-   do {
-      int r,s;
-      int rs = decode(j, hac);
-      if (rs < 0) return e("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
-         data[dezigzag[k++]] = (short) extend_receive(j,s);
-      }
-   } while (k < 64);
-   return 1;
-}
-
-// take a -128..127 value and clamp it and convert to 0..255
-__forceinline static uint8 clamp(int x)
-{
-   x += 128;
-   // 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 (uint8) x;
-}
-
-#define f2f(x)  (int) (((x) * 4096 + 0.5))
-#define fsh(x)  ((x) << 12)
-
-// derived from jidctint -- DCT_ISLOW
-#define 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) * f2f(0.5411961f);             \
-   t2 = p1 + p3*f2f(-1.847759065f);            \
-   t3 = p1 + p2*f2f( 0.765366865f);            \
-   p2 = s0;                                    \
-   p3 = s4;                                    \
-   t0 = fsh(p2+p3);                            \
-   t1 = 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)*f2f( 1.175875602f);            \
-   t0 = t0*f2f( 0.298631336f);                 \
-   t1 = t1*f2f( 2.053119869f);                 \
-   t2 = t2*f2f( 3.072711026f);                 \
-   t3 = t3*f2f( 1.501321110f);                 \
-   p1 = p5 + p1*f2f(-0.899976223f);            \
-   p2 = p5 + p2*f2f(-2.562915447f);            \
-   p3 = p3*f2f(-1.961570560f);                 \
-   p4 = p4*f2f(-0.390180644f);                 \
-   t3 += p1+p4;                                \
-   t2 += p2+p3;                                \
-   t1 += p2+p4;                                \
-   t0 += p1+p3;
-
-#if !STBI_SIMD
-// .344 seconds on 3*anemones.jpg
-static void idct_block(uint8 *out, int out_stride, short data[64], uint8 *dequantize)
-{
-   int i,val[64],*v=val;
-   uint8 *o,*dq = dequantize;
-   short *d = data;
-
-   // columns
-   for (i=0; i < 8; ++i,++d,++dq, ++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] * dq[0] << 2;
-         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
-      } else {
-         IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24],
-                 d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[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
-      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.
-      x0 += 65536; x1 += 65536; x2 += 65536; x3 += 65536;
-      o[0] = clamp((x0+t3) >> 17);
-      o[7] = clamp((x0-t3) >> 17);
-      o[1] = clamp((x1+t2) >> 17);
-      o[6] = clamp((x1-t2) >> 17);
-      o[2] = clamp((x2+t1) >> 17);
-      o[5] = clamp((x2-t1) >> 17);
-      o[3] = clamp((x3+t0) >> 17);
-      o[4] = clamp((x3-t0) >> 17);
-   }
-}
-#else
-static void idct_block(uint8 *out, int out_stride, short data[64], unsigned short *dequantize)
-{
-   int i,val[64],*v=val;
-   uint8 *o;
-   unsigned short *dq = dequantize;
-   short *d = data;
-
-   // columns
-   for (i=0; i < 8; ++i,++d,++dq, ++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] * dq[0] << 2;
-         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
-      } else {
-         IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24],
-                 d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[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
-      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.
-      x0 += 65536; x1 += 65536; x2 += 65536; x3 += 65536;
-      o[0] = clamp((x0+t3) >> 17);
-      o[7] = clamp((x0-t3) >> 17);
-      o[1] = clamp((x1+t2) >> 17);
-      o[6] = clamp((x1-t2) >> 17);
-      o[2] = clamp((x2+t1) >> 17);
-      o[5] = clamp((x2-t1) >> 17);
-      o[3] = clamp((x3+t0) >> 17);
-      o[4] = clamp((x3-t0) >> 17);
-   }
-}
-static stbi_idct_8x8 stbi_idct_installed = idct_block;
-
-extern void stbi_install_idct(stbi_idct_8x8 func)
-{
-   stbi_idct_installed = func;
-}
-#endif
-
-#define 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 uint8 get_marker(jpeg *j)
-{
-   uint8 x;
-   if (j->marker != MARKER_none) { x = j->marker; j->marker = MARKER_none; return x; }
-   x = get8u(&j->s);
-   if (x != 0xff) return MARKER_none;
-   while (x == 0xff)
-      x = get8u(&j->s);
-   return x;
-}
-
-// in each scan, we'll have scan_n components, and the order
-// of the components is specified by order[]
-#define RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
-
-// after a restart interval, reset the entropy decoder and
-// the dc prediction
-static void reset(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 = 0;
-   j->marker = MARKER_none;
-   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
-   // 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 parse_entropy_coded_data(jpeg *z)
-{
-   reset(z);
-   if (z->scan_n == 1) {
-      int i,j;
-      #if STBI_SIMD
-      __declspec(align(16))
-      #endif
-      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) {
-            if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
-            #if STBI_SIMD
-            stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
-            #else
-            idct_block(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
-            #endif
-            // every data block is an MCU, so countdown the restart interval
-            if (--z->todo <= 0) {
-               if (z->code_bits < 24) grow_buffer_unsafe(z);
-               // if it's NOT a restart, then just bail, so we get corrupt data
-               // rather than no data
-               if (!RESTART(z->marker)) return 1;
-               reset(z);
-            }
-         }
-      }
-   } else { // interleaved!
-      int i,j,k,x,y;
-      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;
-                     if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
-                     #if STBI_SIMD
-                     stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
-                     #else
-                     idct_block(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
-                     #endif
-                  }
-               }
-            }
-            // 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) grow_buffer_unsafe(z);
-               // if it's NOT a restart, then just bail, so we get corrupt data
-               // rather than no data
-               if (!RESTART(z->marker)) return 1;
-               reset(z);
-            }
-         }
-      }
-   }
-   return 1;
-}
-
-static int process_marker(jpeg *z, int m)
-{
-   int L;
-   switch (m) {
-      case MARKER_none: // no marker found
-         return e("expected marker","Corrupt JPEG");
-
-      case 0xC2: // SOF - progressive
-         return e("progressive jpeg","JPEG format not supported (progressive)");
-
-      case 0xDD: // DRI - specify restart interval
-         if (get16(&z->s) != 4) return e("bad DRI len","Corrupt JPEG");
-         z->restart_interval = get16(&z->s);
-         return 1;
-
-      case 0xDB: // DQT - define quantization table
-         L = get16(&z->s)-2;
-         while (L > 0) {
-            int q = get8(&z->s);
-            int p = q >> 4;
-            int t = q & 15,i;
-            if (p != 0) return e("bad DQT type","Corrupt JPEG");
-            if (t > 3) return e("bad DQT table","Corrupt JPEG");
-            for (i=0; i < 64; ++i)
-               z->dequant[t][dezigzag[i]] = get8u(&z->s);
-            #if STBI_SIMD
-            for (i=0; i < 64; ++i)
-               z->dequant2[t][i] = dequant[t][i];
-            #endif
-            L -= 65;
-         }
-         return L==0;
-
-      case 0xC4: // DHT - define huffman table
-         L = get16(&z->s)-2;
-         while (L > 0) {
-            uint8 *v;
-            int sizes[16],i,m=0;
-            int q = get8(&z->s);
-            int tc = q >> 4;
-            int th = q & 15;
-            if (tc > 1 || th > 3) return e("bad DHT header","Corrupt JPEG");
-            for (i=0; i < 16; ++i) {
-               sizes[i] = get8(&z->s);
-               m += sizes[i];
-            }
-            L -= 17;
-            if (tc == 0) {
-               if (!build_huffman(z->huff_dc+th, sizes)) return 0;
-               v = z->huff_dc[th].values;
-            } else {
-               if (!build_huffman(z->huff_ac+th, sizes)) return 0;
-               v = z->huff_ac[th].values;
-            }
-            for (i=0; i < m; ++i)
-               v[i] = get8u(&z->s);
-            L -= m;
-         }
-         return L==0;
-   }
-   // check for comment block or APP blocks
-   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
-      skip(&z->s, get16(&z->s)-2);
-      return 1;
-   }
-   return 0;
-}
-
-// after we see SOS
-static int process_scan_header(jpeg *z)
-{
-   int i;
-   int Ls = get16(&z->s);
-   z->scan_n = get8(&z->s);
-   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s.img_n) return e("bad SOS component count","Corrupt JPEG");
-   if (Ls != 6+2*z->scan_n) return e("bad SOS len","Corrupt JPEG");
-   for (i=0; i < z->scan_n; ++i) {
-      int id = get8(&z->s), which;
-      int q = 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;
-      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return e("bad DC huff","Corrupt JPEG");
-      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return e("bad AC huff","Corrupt JPEG");
-      z->order[i] = which;
-   }
-   if (get8(&z->s) != 0) return e("bad SOS","Corrupt JPEG");
-   get8(&z->s); // should be 63, but might be 0
-   if (get8(&z->s) != 0) return e("bad SOS","Corrupt JPEG");
-
-   return 1;
-}
-
-static int process_frame_header(jpeg *z, int scan)
-{
-   stbi *s = &z->s;
-   int Lf,p,i,q, h_max=1,v_max=1,c;
-   Lf = get16(s);         if (Lf < 11) return e("bad SOF len","Corrupt JPEG"); // JPEG
-   p  = get8(s);          if (p != 8) return e("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
-   s->img_y = get16(s);   if (s->img_y == 0) return e("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
-   s->img_x = get16(s);   if (s->img_x == 0) return e("0 width","Corrupt JPEG"); // JPEG requires
-   c = get8(s);
-   if (c != 3 && c != 1) return e("bad component count","Corrupt JPEG");    // JFIF requires
-   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 e("bad SOF len","Corrupt JPEG");
-
-   for (i=0; i < s->img_n; ++i) {
-      z->img_comp[i].id = get8(s);
-      if (z->img_comp[i].id != i+1)   // JFIF requires
-         if (z->img_comp[i].id != i)  // some version of jpegtran outputs non-JFIF-compliant files!
-            return e("bad component ID","Corrupt JPEG");
-      q = get8(s);
-      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return e("bad H","Corrupt JPEG");
-      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return e("bad V","Corrupt JPEG");
-      z->img_comp[i].tq = get8(s);  if (z->img_comp[i].tq > 3) return e("bad TQ","Corrupt JPEG");
-   }
-
-   if (scan != SCAN_load) return 1;
-
-   if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("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;
-   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
-      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].raw_data = malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15);
-      if (z->img_comp[i].raw_data == NULL) {
-         for(--i; i >= 0; --i) {
-            free(z->img_comp[i].raw_data);
-            z->img_comp[i].data = NULL;
-         }
-         return e("outofmem", "Out of memory");
-      }
-      // align blocks for installable-idct using mmx/sse
-      z->img_comp[i].data = (uint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
-      z->img_comp[i].linebuf = NULL;
-   }
-
-   return 1;
-}
-
-// use comparisons since in some cases we handle more than one case (e.g. SOF)
-#define DNL(x)         ((x) == 0xdc)
-#define SOI(x)         ((x) == 0xd8)
-#define EOI(x)         ((x) == 0xd9)
-#define SOF(x)         ((x) == 0xc0 || (x) == 0xc1)
-#define SOS(x)         ((x) == 0xda)
-
-static int decode_jpeg_header(jpeg *z, int scan)
-{
-   int m;
-   z->marker = MARKER_none; // initialize cached marker to empty
-   m = get_marker(z);
-   if (!SOI(m)) return e("no SOI","Corrupt JPEG");
-   if (scan == SCAN_type) return 1;
-   m = get_marker(z);
-   while (!SOF(m)) {
-      if (!process_marker(z,m)) return 0;
-      m = get_marker(z);
-      while (m == MARKER_none) {
-         // some files have extra padding after their blocks, so ok, we'll scan
-         if (at_eof(&z->s)) return e("no SOF", "Corrupt JPEG");
-         m = get_marker(z);
-      }
-   }
-   if (!process_frame_header(z, scan)) return 0;
-   return 1;
-}
-
-static int decode_jpeg_image(jpeg *j)
-{
-   int m;
-   j->restart_interval = 0;
-   if (!decode_jpeg_header(j, SCAN_load)) return 0;
-   m = get_marker(j);
-   while (!EOI(m)) {
-      if (SOS(m)) {
-         if (!process_scan_header(j)) return 0;
-         if (!parse_entropy_coded_data(j)) return 0;
-      } else {
-         if (!process_marker(j, m)) return 0;
-      }
-      m = get_marker(j);
-   }
-   return 1;
-}
-
-// static jfif-centered resampling (across block boundaries)
-
-typedef uint8 *(*resample_row_func)(uint8 *out, uint8 *in0, uint8 *in1,
-                                    int w, int hs);
-
-#define div4(x) ((uint8) ((x) >> 2))
-
-static uint8 *resample_row_1(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
-{
-   return in_near;
-}
-
-static uint8* resample_row_v_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
-{
-   // need to generate two samples vertically for every one in input
-   int i;
-   for (i=0; i < w; ++i)
-      out[i] = div4(3*in_near[i] + in_far[i] + 2);
-   return out;
-}
-
-static uint8*  resample_row_h_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
-{
-   // need to generate two samples horizontally for every one in input
-   int i;
-   uint8 *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] = div4(input[0]*3 + input[1] + 2);
-   for (i=1; i < w-1; ++i) {
-      int n = 3*input[i]+2;
-      out[i*2+0] = div4(n+input[i-1]);
-      out[i*2+1] = div4(n+input[i+1]);
-   }
-   out[i*2+0] = div4(input[w-2]*3 + input[w-1] + 2);
-   out[i*2+1] = input[w-1];
-   return out;
-}
-
-#define div16(x) ((uint8) ((x) >> 4))
-
-static uint8 *resample_row_hv_2(uint8 *out, uint8 *in_near, uint8 *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] = div4(3*in_near[0] + in_far[0] + 2);
-      return out;
-   }
-
-   t1 = 3*in_near[0] + in_far[0];
-   out[0] = div4(t1+2);
-   for (i=1; i < w; ++i) {
-      t0 = t1;
-      t1 = 3*in_near[i]+in_far[i];
-      out[i*2-1] = div16(3*t0 + t1 + 8);
-      out[i*2  ] = div16(3*t1 + t0 + 8);
-   }
-   out[w*2-1] = div4(t1+2);
-   return out;
-}
-
-static uint8 *resample_row_generic(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
-{
-   // resample with nearest-neighbor
-   int i,j;
-   for (i=0; i < w; ++i)
-      for (j=0; j < hs; ++j)
-         out[i*hs+j] = in_near[i];
-   return out;
-}
-
-#define float2fixed(x)  ((int) ((x) * 65536 + 0.5))
-
-// 0.38 seconds on 3*anemones.jpg   (0.25 with processor = Pro)
-// VC6 without processor=Pro is generating multiple LEAs per multiply!
-static void YCbCr_to_RGB_row(uint8 *out, uint8 *y, uint8 *pcb, uint8 *pcr, int count, int step)
-{
-   int i;
-   for (i=0; i < count; ++i) {
-      int y_fixed = (y[i] << 16) + 32768; // rounding
-      int r,g,b;
-      int cr = pcr[i] - 128;
-      int cb = pcb[i] - 128;
-      r = y_fixed + cr*float2fixed(1.40200f);
-      g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f);
-      b = y_fixed                            + cb*float2fixed(1.77200f);
-      r >>= 16;
-      g >>= 16;
-      b >>= 16;
-      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] = (uint8)r;
-      out[1] = (uint8)g;
-      out[2] = (uint8)b;
-      out[3] = 255;
-      out += step;
-   }
-}
-
-#if STBI_SIMD
-static stbi_YCbCr_to_RGB_run stbi_YCbCr_installed = YCbCr_to_RGB_row;
-
-void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func)
-{
-   stbi_YCbCr_installed = func;
-}
-#endif
-
-
-// clean up the temporary component buffers
-static void cleanup_jpeg(jpeg *j)
-{
-   int i;
-   for (i=0; i < j->s.img_n; ++i) {
-      if (j->img_comp[i].data) {
-         free(j->img_comp[i].raw_data);
-         j->img_comp[i].data = NULL;
-      }
-      if (j->img_comp[i].linebuf) {
-         free(j->img_comp[i].linebuf);
-         j->img_comp[i].linebuf = NULL;
-      }
-   }
-}
-
-typedef struct
-{
-   resample_row_func resample;
-   uint8 *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;
-
-static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
-{
-   int n, decode_n;
-   // validate req_comp
-   if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
-   z->s.img_n = 0;
-
-   // load a jpeg image from whichever source
-   if (!decode_jpeg_image(z)) { cleanup_jpeg(z); return NULL; }
-
-   // determine actual number of components to generate
-   n = req_comp ? req_comp : z->s.img_n;
-
-   if (z->s.img_n == 3 && n < 3)
-      decode_n = 1;
-   else
-      decode_n = z->s.img_n;
-
-   // resample and color-convert
-   {
-      int k;
-      uint i,j;
-      uint8 *output;
-      uint8 *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 = (uint8 *) malloc(z->s.img_x + 3);
-         if (!z->img_comp[k].linebuf) { cleanup_jpeg(z); return epuc("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 = resample_row_v_2;
-         else if (r->hs == 2 && r->vs == 1) r->resample = resample_row_h_2;
-         else if (r->hs == 2 && r->vs == 2) r->resample = resample_row_hv_2;
-         else                               r->resample = resample_row_generic;
-      }
-
-      // can't error after this so, this is safe
-      output = (uint8 *) malloc(n * z->s.img_x * z->s.img_y + 1);
-      if (!output) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); }
-
-      // now go ahead and resample
-      for (j=0; j < z->s.img_y; ++j) {
-         uint8 *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) {
-            uint8 *y = coutput[0];
-            if (z->s.img_n == 3) {
-               #if STBI_SIMD
-               stbi_YCbCr_installed(out, y, coutput[1], coutput[2], z->s.img_x, n);
-               #else
-               YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s.img_x, n);
-               #endif
-            } 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 {
-            uint8 *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;
-         }
-      }
-      cleanup_jpeg(z);
-      *out_x = z->s.img_x;
-      *out_y = z->s.img_y;
-      if (comp) *comp  = z->s.img_n; // report original components, not output
-      return output;
-   }
-}
-
-#ifndef STBI_NO_STDIO
-unsigned char *stbi_jpeg_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   jpeg j;
-   start_file(&j.s, f);
-   return load_jpeg_image(&j, x,y,comp,req_comp);
-}
-
-unsigned char *stbi_jpeg_load(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_jpeg_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-#endif
-
-unsigned char *stbi_jpeg_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   jpeg j;
-   start_mem(&j.s, buffer,len);
-   return load_jpeg_image(&j, x,y,comp,req_comp);
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_jpeg_test_file(FILE *f)
-{
-   int n,r;
-   jpeg j;
-   n = ftell(f);
-   start_file(&j.s, f);
-   r = decode_jpeg_header(&j, SCAN_type);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int stbi_jpeg_test_memory(stbi_uc const *buffer, int len)
-{
-   jpeg j;
-   start_mem(&j.s, buffer,len);
-   return decode_jpeg_header(&j, SCAN_type);
-}
-
-// @TODO:
-#ifndef STBI_NO_STDIO
-extern int      stbi_jpeg_info            (char const *filename,           int *x, int *y, int *comp);
-extern int      stbi_jpeg_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-#endif
-extern int      stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-
-// 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
-
-// fast-way is faster to check than jpeg huffman, but slow way is slower
-#define ZFAST_BITS  9 // accelerate all cases in default tables
-#define ZFAST_MASK  ((1 << ZFAST_BITS) - 1)
-
-// zlib-style huffman encoding
-// (jpegs packs from left, zlib from right, so can't share code)
-typedef struct
-{
-   uint16 fast[1 << ZFAST_BITS];
-   uint16 firstcode[16];
-   int maxcode[17];
-   uint16 firstsymbol[16];
-   uint8  size[288];
-   uint16 value[288];
-} zhuffman;
-
-__forceinline static int 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;
-}
-
-__forceinline static int bit_reverse(int v, int bits)
-{
-   assert(bits <= 16);
-   // to bit reverse n bits, reverse 16 and shift
-   // e.g. 11 bits, bit reverse and shift away 5
-   return bitreverse16(v) >> (16-bits);
-}
-
-static int zbuild_huffman(zhuffman *z, uint8 *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, 255, sizeof(z->fast));
-   for (i=0; i < num; ++i)
-      ++sizes[sizelist[i]];
-   sizes[0] = 0;
-   for (i=1; i < 16; ++i)
-      assert(sizes[i] <= (1 << i));
-   code = 0;
-   for (i=1; i < 16; ++i) {
-      next_code[i] = code;
-      z->firstcode[i] = (uint16) code;
-      z->firstsymbol[i] = (uint16) k;
-      code = (code + sizes[i]);
-      if (sizes[i])
-         if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG");
-      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];
-         z->size[c] = (uint8)s;
-         z->value[c] = (uint16)i;
-         if (s <= ZFAST_BITS) {
-            int k = bit_reverse(next_code[s],s);
-            while (k < (1 << ZFAST_BITS)) {
-               z->fast[k] = (uint16) c;
-               k += (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
-{
-   uint8 *zbuffer, *zbuffer_end;
-   int num_bits;
-   uint32 code_buffer;
-
-   char *zout;
-   char *zout_start;
-   char *zout_end;
-   int   z_expandable;
-
-   zhuffman z_length, z_distance;
-} zbuf;
-
-__forceinline static int zget8(zbuf *z)
-{
-   if (z->zbuffer >= z->zbuffer_end) return 0;
-   return *z->zbuffer++;
-}
-
-static void fill_bits(zbuf *z)
-{
-   do {
-      assert(z->code_buffer < (1U << z->num_bits));
-      z->code_buffer |= zget8(z) << z->num_bits;
-      z->num_bits += 8;
-   } while (z->num_bits <= 24);
-}
-
-__forceinline static unsigned int zreceive(zbuf *z, int n)
-{
-   unsigned int k;
-   if (z->num_bits < n) fill_bits(z);
-   k = z->code_buffer & ((1 << n) - 1);
-   z->code_buffer >>= n;
-   z->num_bits -= n;
-   return k;
-}
-
-__forceinline static int zhuffman_decode(zbuf *a, zhuffman *z)
-{
-   int b,s,k;
-   if (a->num_bits < 16) fill_bits(a);
-   b = z->fast[a->code_buffer & ZFAST_MASK];
-   if (b < 0xffff) {
-      s = z->size[b];
-      a->code_buffer >>= s;
-      a->num_bits -= s;
-      return z->value[b];
-   }
-
-   // not resolved by fast table, so compute it the slow way
-   // use jpeg approach, which requires MSbits at top
-   k = bit_reverse(a->code_buffer, 16);
-   for (s=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];
-   assert(z->size[b] == s);
-   a->code_buffer >>= s;
-   a->num_bits -= s;
-   return z->value[b];
-}
-
-static int expand(zbuf *z, int n)  // need to make room for n bytes
-{
-   char *q;
-   int cur, limit;
-   if (!z->z_expandable) return e("output buffer limit","Corrupt PNG");
-   cur   = (int) (z->zout     - z->zout_start);
-   limit = (int) (z->zout_end - z->zout_start);
-   while (cur + n > limit)
-      limit *= 2;
-   q = (char *) realloc(z->zout_start, limit);
-   if (q == NULL) return e("outofmem", "Out of memory");
-   z->zout_start = q;
-   z->zout       = q + cur;
-   z->zout_end   = q + limit;
-   return 1;
-}
-
-static int length_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 int length_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 int dist_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 int dist_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 parse_huffman_block(zbuf *a)
-{
-   for(;;) {
-      int z = zhuffman_decode(a, &a->z_length);
-      if (z < 256) {
-         if (z < 0) return e("bad huffman code","Corrupt PNG"); // error in huffman codes
-         if (a->zout >= a->zout_end) if (!expand(a, 1)) return 0;
-         *a->zout++ = (char) z;
-      } else {
-         uint8 *p;
-         int len,dist;
-         if (z == 256) return 1;
-         z -= 257;
-         len = length_base[z];
-         if (length_extra[z]) len += zreceive(a, length_extra[z]);
-         z = zhuffman_decode(a, &a->z_distance);
-         if (z < 0) return e("bad huffman code","Corrupt PNG");
-         dist = dist_base[z];
-         if (dist_extra[z]) dist += zreceive(a, dist_extra[z]);
-         if (a->zout - a->zout_start < dist) return e("bad dist","Corrupt PNG");
-         if (a->zout + len > a->zout_end) if (!expand(a, len)) return 0;
-         p = (uint8 *) (a->zout - dist);
-         while (len--)
-            *a->zout++ = *p++;
-      }
-   }
-}
-
-static int compute_huffman_codes(zbuf *a)
-{
-   static uint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
-   static zhuffman z_codelength; // static just to save stack space
-   uint8 lencodes[286+32+137];//padding for maximum single op
-   uint8 codelength_sizes[19];
-   int i,n;
-
-   int hlit  = zreceive(a,5) + 257;
-   int hdist = zreceive(a,5) + 1;
-   int hclen = zreceive(a,4) + 4;
-
-   memset(codelength_sizes, 0, sizeof(codelength_sizes));
-   for (i=0; i < hclen; ++i) {
-      int s = zreceive(a,3);
-      codelength_sizes[length_dezigzag[i]] = (uint8) s;
-   }
-   if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
-
-   n = 0;
-   while (n < hlit + hdist) {
-      int c = zhuffman_decode(a, &z_codelength);
-      assert(c >= 0 && c < 19);
-      if (c < 16)
-         lencodes[n++] = (uint8) c;
-      else if (c == 16) {
-         c = zreceive(a,2)+3;
-         memset(lencodes+n, lencodes[n-1], c);
-         n += c;
-      } else if (c == 17) {
-         c = zreceive(a,3)+3;
-         memset(lencodes+n, 0, c);
-         n += c;
-      } else {
-         assert(c == 18);
-         c = zreceive(a,7)+11;
-         memset(lencodes+n, 0, c);
-         n += c;
-      }
-   }
-   if (n != hlit+hdist) return e("bad codelengths","Corrupt PNG");
-   if (!zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
-   if (!zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
-   return 1;
-}
-
-static int parse_uncompressed_block(zbuf *a)
-{
-   uint8 header[4];
-   int len,nlen,k;
-   if (a->num_bits & 7)
-      zreceive(a, a->num_bits & 7); // discard
-   // drain the bit-packed data into header
-   k = 0;
-   while (a->num_bits > 0) {
-      header[k++] = (uint8) (a->code_buffer & 255); // wtf this warns?
-      a->code_buffer >>= 8;
-      a->num_bits -= 8;
-   }
-   assert(a->num_bits == 0);
-   // now fill header the normal way
-   while (k < 4)
-      header[k++] = (uint8) zget8(a);
-   len  = header[1] * 256 + header[0];
-   nlen = header[3] * 256 + header[2];
-   if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG");
-   if (a->zbuffer + len > a->zbuffer_end) return e("read past buffer","Corrupt PNG");
-   if (a->zout + len > a->zout_end)
-      if (!expand(a, len)) return 0;
-   memcpy(a->zout, a->zbuffer, len);
-   a->zbuffer += len;
-   a->zout += len;
-   return 1;
-}
-
-static int parse_zlib_header(zbuf *a)
-{
-   int cmf   = zget8(a);
-   int cm    = cmf & 15;
-   /* int cinfo = cmf >> 4; */
-   int flg   = zget8(a);
-   if ((cmf*256+flg) % 31 != 0) return e("bad zlib header","Corrupt PNG"); // zlib spec
-   if (flg & 32) return e("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
-   if (cm != 8) return e("bad compression","Corrupt PNG"); // DEFLATE required for png
-   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
-   return 1;
-}
-
-// @TODO: should statically initialize these for optimal thread safety
-static uint8 default_length[288], default_distance[32];
-static void init_defaults(void)
-{
-   int i;   // use <= to match clearly with spec
-   for (i=0; i <= 143; ++i)     default_length[i]   = 8;
-   for (   ; i <= 255; ++i)     default_length[i]   = 9;
-   for (   ; i <= 279; ++i)     default_length[i]   = 7;
-   for (   ; i <= 287; ++i)     default_length[i]   = 8;
-
-   for (i=0; i <=  31; ++i)     default_distance[i] = 5;
-}
-
-static int parse_zlib(zbuf *a, int parse_header)
-{
-   int final, type;
-   if (parse_header)
-      if (!parse_zlib_header(a)) return 0;
-   a->num_bits = 0;
-   a->code_buffer = 0;
-   do {
-      final = zreceive(a,1);
-      type = zreceive(a,2);
-      if (type == 0) {
-         if (!parse_uncompressed_block(a)) return 0;
-      } else if (type == 3) {
-         return 0;
-      } else {
-         if (type == 1) {
-            // use fixed code lengths
-            if (!default_distance[31]) init_defaults();
-            if (!zbuild_huffman(&a->z_length  , default_length  , 288)) return 0;
-            if (!zbuild_huffman(&a->z_distance, default_distance,  32)) return 0;
-         } else {
-            if (!compute_huffman_codes(a)) return 0;
-         }
-         if (!parse_huffman_block(a)) return 0;
-      }
-   } while (!final);
-   return 1;
-}
-
-static int do_zlib(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 parse_zlib(a, parse_header);
-}
-
-char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
-{
-   zbuf a;
-   char *p = (char *) malloc(initial_size);
-   if (p == NULL) return NULL;
-   a.zbuffer = (uint8 *) buffer;
-   a.zbuffer_end = (uint8 *) buffer + len;
-   if (do_zlib(&a, p, initial_size, 1, 1)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      free(a.zout_start);
-      return NULL;
-   }
-}
-
-char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
-{
-   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
-}
-
-int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
-{
-   zbuf a;
-   a.zbuffer = (uint8 *) ibuffer;
-   a.zbuffer_end = (uint8 *) ibuffer + ilen;
-   if (do_zlib(&a, obuffer, olen, 0, 1))
-      return (int) (a.zout - a.zout_start);
-   else
-      return -1;
-}
-
-char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
-{
-   zbuf a;
-   char *p = (char *) malloc(16384);
-   if (p == NULL) return NULL;
-   a.zbuffer = (uint8 *) buffer;
-   a.zbuffer_end = (uint8 *) buffer+len;
-   if (do_zlib(&a, p, 16384, 1, 0)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      free(a.zout_start);
-      return NULL;
-   }
-}
-
-int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
-{
-   zbuf a;
-   a.zbuffer = (uint8 *) ibuffer;
-   a.zbuffer_end = (uint8 *) ibuffer + ilen;
-   if (do_zlib(&a, obuffer, olen, 0, 0))
-      return (int) (a.zout - a.zout_start);
-   else
-      return -1;
-}
-
-// 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
-
-
-typedef struct
-{
-   uint32 length;
-   uint32 type;
-} chunk;
-
-#define PNG_TYPE(a,b,c,d)  (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
-
-static chunk get_chunk_header(stbi *s)
-{
-   chunk c;
-   c.length = get32(s);
-   c.type   = get32(s);
-   return c;
-}
-
-static int check_png_header(stbi *s)
-{
-   static uint8 png_sig[8] = { 137,80,78,71,13,10,26,10 };
-   int i;
-   for (i=0; i < 8; ++i)
-      if (get8(s) != png_sig[i]) return e("bad png sig","Not a PNG");
-   return 1;
-}
-
-typedef struct
-{
-   stbi s;
-   uint8 *idata, *expanded, *out;
-} png;
-
-
-enum {
-   F_none=0, F_sub=1, F_up=2, F_avg=3, F_paeth=4,
-   F_avg_first, F_paeth_first,
-};
-
-static uint8 first_row_filter[5] =
-{
-   F_none, F_sub, F_none, F_avg_first, F_paeth_first
-};
-
-static int 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;
-}
-
-// create the png data from post-deflated data
-static int create_png_image(png *a, uint8 *raw, uint32 raw_len, int out_n)
-{
-   stbi *s = &a->s;
-   uint32 i,j,stride = s->img_x*out_n;
-   int k;
-   int img_n = s->img_n; // copy it into a local for later
-   assert(out_n == s->img_n || out_n == s->img_n+1);
-   a->out = (uint8 *) malloc(s->img_x * s->img_y * out_n);
-   if (!a->out) return e("outofmem", "Out of memory");
-   if (raw_len != (img_n * s->img_x + 1) * s->img_y) return e("not enough pixels","Corrupt PNG");
-   for (j=0; j < s->img_y; ++j) {
-      uint8 *cur = a->out + stride*j;
-      uint8 *prior = cur - stride;
-      int filter = *raw++;
-      if (filter > 4) return e("invalid filter","Corrupt PNG");
-      // if first row, use special filter that doesn't sample previous row
-      if (j == 0) filter = first_row_filter[filter];
-      // handle first pixel explicitly
-      for (k=0; k < img_n; ++k) {
-         switch(filter) {
-            case F_none       : cur[k] = raw[k]; break;
-            case F_sub        : cur[k] = raw[k]; break;
-            case F_up         : cur[k] = raw[k] + prior[k]; break;
-            case F_avg        : cur[k] = raw[k] + (prior[k]>>1); break;
-            case F_paeth      : cur[k] = (uint8) (raw[k] + paeth(0,prior[k],0)); break;
-            case F_avg_first  : cur[k] = raw[k]; break;
-            case F_paeth_first: cur[k] = raw[k]; break;
-         }
-      }
-      if (img_n != out_n) cur[img_n] = 255;
-      raw += img_n;
-      cur += out_n;
-      prior += out_n;
-      // this is a little gross, so that we don't switch per-pixel or per-component
-      if (img_n == out_n) {
-         #define CASE(f) \
-             case f:     \
-                for (i=s->img_x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \
-                   for (k=0; k < img_n; ++k)
-         switch(filter) {
-            CASE(F_none)  cur[k] = raw[k]; break;
-            CASE(F_sub)   cur[k] = raw[k] + cur[k-img_n]; break;
-            CASE(F_up)    cur[k] = raw[k] + prior[k]; break;
-            CASE(F_avg)   cur[k] = raw[k] + ((prior[k] + cur[k-img_n])>>1); break;
-            CASE(F_paeth)  cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break;
-            CASE(F_avg_first)    cur[k] = raw[k] + (cur[k-img_n] >> 1); break;
-            CASE(F_paeth_first)  cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],0,0)); break;
-         }
-         #undef CASE
-      } else {
-         assert(img_n+1 == out_n);
-         #define CASE(f) \
-             case f:     \
-                for (i=s->img_x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \
-                   for (k=0; k < img_n; ++k)
-         switch(filter) {
-            CASE(F_none)  cur[k] = raw[k]; break;
-            CASE(F_sub)   cur[k] = raw[k] + cur[k-out_n]; break;
-            CASE(F_up)    cur[k] = raw[k] + prior[k]; break;
-            CASE(F_avg)   cur[k] = raw[k] + ((prior[k] + cur[k-out_n])>>1); break;
-            CASE(F_paeth)  cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break;
-            CASE(F_avg_first)    cur[k] = raw[k] + (cur[k-out_n] >> 1); break;
-            CASE(F_paeth_first)  cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],0,0)); break;
-         }
-         #undef CASE
-      }
-   }
-   return 1;
-}
-
-static int compute_transparency(png *z, uint8 tc[3], int out_n)
-{
-   stbi *s = &z->s;
-   uint32 i, pixel_count = s->img_x * s->img_y;
-   uint8 *p = z->out;
-
-   // compute color-based transparency, assuming we've
-   // already got 255 as the alpha value in the output
-   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 expand_palette(png *a, uint8 *palette, int len, int pal_img_n)
-{
-   uint32 i, pixel_count = a->s.img_x * a->s.img_y;
-   uint8 *p, *temp_out, *orig = a->out;
-
-   p = (uint8 *) malloc(pixel_count * pal_img_n);
-   if (p == NULL) return e("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;
-      }
-   }
-   free(a->out);
-   a->out = temp_out;
-   return 1;
-}
-
-static int parse_png_file(png *z, int scan, int req_comp)
-{
-   uint8 palette[1024], pal_img_n=0;
-   uint8 has_trans=0, tc[3];
-   uint32 ioff=0, idata_limit=0, i, pal_len=0;
-   int first=1,k;
-   stbi *s = &z->s;
-
-   if (!check_png_header(s)) return 0;
-
-   if (scan == SCAN_type) return 1;
-
-   for(;;first=0) {
-      chunk c = get_chunk_header(s);
-      if (first && c.type != PNG_TYPE('I','H','D','R'))
-         return e("first not IHDR","Corrupt PNG");
-      switch (c.type) {
-         case PNG_TYPE('I','H','D','R'): {
-            int depth,color,interlace,comp,filter;
-            if (!first) return e("multiple IHDR","Corrupt PNG");
-            if (c.length != 13) return e("bad IHDR len","Corrupt PNG");
-            s->img_x = get32(s); if (s->img_x > (1 << 24)) return e("too large","Very large image (corrupt?)");
-            s->img_y = get32(s); if (s->img_y > (1 << 24)) return e("too large","Very large image (corrupt?)");
-            depth = get8(s);  if (depth != 8)        return e("8bit only","PNG not supported: 8-bit only");
-            color = get8(s);  if (color > 6)         return e("bad ctype","Corrupt PNG");
-            if (color == 3) pal_img_n = 3; else if (color & 1) return e("bad ctype","Corrupt PNG");
-            comp  = get8(s);  if (comp) return e("bad comp method","Corrupt PNG");
-            filter= get8(s);  if (filter) return e("bad filter method","Corrupt PNG");
-            interlace = get8(s); if (interlace) return e("interlaced","PNG not supported: interlaced mode");
-            if (!s->img_x || !s->img_y) return e("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 e("too large", "Image too large to decode");
-               if (scan == 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 e("too large","Corrupt PNG");
-               // if SCAN_header, have to scan to see if we have a tRNS
-            }
-            break;
-         }
-
-         case PNG_TYPE('P','L','T','E'):  {
-            if (c.length > 256*3) return e("invalid PLTE","Corrupt PNG");
-            pal_len = c.length / 3;
-            if (pal_len * 3 != c.length) return e("invalid PLTE","Corrupt PNG");
-            for (i=0; i < pal_len; ++i) {
-               palette[i*4+0] = get8u(s);
-               palette[i*4+1] = get8u(s);
-               palette[i*4+2] = get8u(s);
-               palette[i*4+3] = 255;
-            }
-            break;
-         }
-
-         case PNG_TYPE('t','R','N','S'): {
-            if (z->idata) return e("tRNS after IDAT","Corrupt PNG");
-            if (pal_img_n) {
-               if (scan == SCAN_header) { s->img_n = 4; return 1; }
-               if (pal_len == 0) return e("tRNS before PLTE","Corrupt PNG");
-               if (c.length > pal_len) return e("bad tRNS len","Corrupt PNG");
-               pal_img_n = 4;
-               for (i=0; i < c.length; ++i)
-                  palette[i*4+3] = get8u(s);
-            } else {
-               if (!(s->img_n & 1)) return e("tRNS with alpha","Corrupt PNG");
-               if (c.length != (uint32) s->img_n*2) return e("bad tRNS len","Corrupt PNG");
-               has_trans = 1;
-               for (k=0; k < s->img_n; ++k)
-                  tc[k] = (uint8) get16(s); // non 8-bit images will be larger
-            }
-            break;
-         }
-
-         case PNG_TYPE('I','D','A','T'): {
-            if (pal_img_n && !pal_len) return e("no PLTE","Corrupt PNG");
-            if (scan == SCAN_header) { s->img_n = pal_img_n; return 1; }
-            if (ioff + c.length > idata_limit) {
-               uint8 *p;
-               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
-               while (ioff + c.length > idata_limit)
-                  idata_limit *= 2;
-               p = (uint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory");
-               z->idata = p;
-            }
-            #ifndef STBI_NO_STDIO
-            if (s->img_file)
-            {
-               if (fread(z->idata+ioff,1,c.length,s->img_file) != c.length) return e("outofdata","Corrupt PNG");
-            }
-            else
-            #endif
-            {
-               memcpy(z->idata+ioff, s->img_buffer, c.length);
-               s->img_buffer += c.length;
-            }
-            ioff += c.length;
-            break;
-         }
-
-         case PNG_TYPE('I','E','N','D'): {
-            uint32 raw_len;
-            if (scan != SCAN_load) return 1;
-            if (z->idata == NULL) return e("no IDAT","Corrupt PNG");
-            z->expanded = (uint8 *) stbi_zlib_decode_malloc((char *) z->idata, ioff, (int *) &raw_len);
-            if (z->expanded == NULL) return 0; // zlib should set error
-            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 (!create_png_image(z, z->expanded, raw_len, s->img_out_n)) return 0;
-            if (has_trans)
-               if (!compute_transparency(z, tc, s->img_out_n)) return 0;
-            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 (!expand_palette(z, palette, pal_len, s->img_out_n))
-                  return 0;
-            }
-            free(z->expanded); z->expanded = NULL;
-            return 1;
-         }
-
-         default:
-            // if critical, fail
-            if ((c.type & (1 << 29)) == 0) {
-               #ifndef STBI_NO_FAILURE_STRINGS
-               // not threadsafe
-               static char invalid_chunk[] = "XXXX chunk not known";
-               invalid_chunk[0] = (uint8) (c.type >> 24);
-               invalid_chunk[1] = (uint8) (c.type >> 16);
-               invalid_chunk[2] = (uint8) (c.type >>  8);
-               invalid_chunk[3] = (uint8) (c.type >>  0);
-               #endif
-               return e(invalid_chunk, "PNG not supported: unknown chunk type");
-            }
-            skip(s, c.length);
-            break;
-      }
-      // end of chunk, read and skip CRC
-      get32(s);
-   }
-}
-
-static unsigned char *do_png(png *p, int *x, int *y, int *n, int req_comp)
-{
-   unsigned char *result=NULL;
-   p->expanded = NULL;
-   p->idata = NULL;
-   p->out = NULL;
-   if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
-   if (parse_png_file(p, SCAN_load, req_comp)) {
-      result = p->out;
-      p->out = NULL;
-      if (req_comp && req_comp != p->s.img_out_n) {
-         result = convert_format(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;
-   }
-   free(p->out);      p->out      = NULL;
-   free(p->expanded); p->expanded = NULL;
-   free(p->idata);    p->idata    = NULL;
-
-   return result;
-}
-
-#ifndef STBI_NO_STDIO
-unsigned char *stbi_png_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   png p;
-   start_file(&p.s, f);
-   return do_png(&p, x,y,comp,req_comp);
-}
-
-unsigned char *stbi_png_load(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_png_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-#endif
-
-unsigned char *stbi_png_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   png p;
-   start_mem(&p.s, buffer,len);
-   return do_png(&p, x,y,comp,req_comp);
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_png_test_file(FILE *f)
-{
-   png p;
-   int n,r;
-   n = ftell(f);
-   start_file(&p.s, f);
-   r = parse_png_file(&p, SCAN_type,STBI_default);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int stbi_png_test_memory(stbi_uc const *buffer, int len)
-{
-   png p;
-   start_mem(&p.s, buffer, len);
-   return parse_png_file(&p, SCAN_type,STBI_default);
-}
-
-// TODO: load header from png
-#ifndef STBI_NO_STDIO
-extern int      stbi_png_info             (char const *filename,           int *x, int *y, int *comp);
-extern int      stbi_png_info_from_file   (FILE *f,                  int *x, int *y, int *comp);
-#endif
-extern int      stbi_png_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-
-// Microsoft/Windows BMP image
-
-static int bmp_test(stbi *s)
-{
-   int sz;
-   if (get8(s) != 'B') return 0;
-   if (get8(s) != 'M') return 0;
-   get32le(s); // discard filesize
-   get16le(s); // discard reserved
-   get16le(s); // discard reserved
-   get32le(s); // discard data offset
-   sz = get32le(s);
-   if (sz == 12 || sz == 40 || sz == 56 || sz == 108) return 1;
-   return 0;
-}
-
-#ifndef STBI_NO_STDIO
-int      stbi_bmp_test_file        (FILE *f)
-{
-   stbi s;
-   int r,n = ftell(f);
-   start_file(&s,f);
-   r = bmp_test(&s);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int      stbi_bmp_test_memory      (stbi_uc const *buffer, int len)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return bmp_test(&s);
-}
-
-// returns 0..31 for the highest set bit
-static int 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 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;
-}
-
-static int shiftsigned(int v, int shift, int bits)
-{
-   int result;
-   int z=0;
-
-   if (shift < 0) v <<= -shift;
-   else v >>= shift;
-   result = v;
-
-   z = bits;
-   while (z < 8) {
-      result += v >> z;
-      z += bits;
-   }
-   return result;
-}
-
-static stbi_uc *bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp)
-{
-   uint8 *out;
-   unsigned int mr=0,mg=0,mb=0,ma=0;
-   stbi_uc pal[256][4];
-   int psize=0,i,j,compress=0,width;
-   int bpp, flip_vertically, pad, target, offset, hsz;
-   if (get8(s) != 'B' || get8(s) != 'M') return epuc("not BMP", "Corrupt BMP");
-   get32le(s); // discard filesize
-   get16le(s); // discard reserved
-   get16le(s); // discard reserved
-   offset = get32le(s);
-   hsz = get32le(s);
-   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) return epuc("unknown BMP", "BMP type not supported: unknown");
-   failure_reason = "bad BMP";
-   if (hsz == 12) {
-      s->img_x = get16le(s);
-      s->img_y = get16le(s);
-   } else {
-      s->img_x = get32le(s);
-      s->img_y = get32le(s);
-   }
-   if (get16le(s) != 1) return 0;
-   bpp = get16le(s);
-   if (bpp == 1) return epuc("monochrome", "BMP type not supported: 1-bit");
-   flip_vertically = ((int) s->img_y) > 0;
-   s->img_y = abs((int) s->img_y);
-   if (hsz == 12) {
-      if (bpp < 24)
-         psize = (offset - 14 - 24) / 3;
-   } else {
-      compress = get32le(s);
-      if (compress == 1 || compress == 2) return epuc("BMP RLE", "BMP type not supported: RLE");
-      get32le(s); // discard sizeof
-      get32le(s); // discard hres
-      get32le(s); // discard vres
-      get32le(s); // discard colorsused
-      get32le(s); // discard max important
-      if (hsz == 40 || hsz == 56) {
-         if (hsz == 56) {
-            get32le(s);
-            get32le(s);
-            get32le(s);
-            get32le(s);
-         }
-         if (bpp == 16 || bpp == 32) {
-            mr = mg = mb = 0;
-            if (compress == 0) {
-               if (bpp == 32) {
-                  mr = 0xff << 16;
-                  mg = 0xff <<  8;
-                  mb = 0xff <<  0;
-               } else {
-                  mr = 31 << 10;
-                  mg = 31 <<  5;
-                  mb = 31 <<  0;
-               }
-            } else if (compress == 3) {
-               mr = get32le(s);
-               mg = get32le(s);
-               mb = get32le(s);
-               // not documented, but generated by photoshop and handled by mspaint
-               if (mr == mg && mg == mb) {
-                  // ?!?!?
-                  return NULL;
-               }
-            } else
-               return NULL;
-         }
-      } else {
-         assert(hsz == 108);
-         mr = get32le(s);
-         mg = get32le(s);
-         mb = get32le(s);
-         ma = get32le(s);
-         get32le(s); // discard color space
-         for (i=0; i < 12; ++i)
-            get32le(s); // discard color space parameters
-      }
-      if (bpp < 16)
-         psize = (offset - 14 - 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
-   out = (stbi_uc *) malloc(target * s->img_x * s->img_y);
-   if (!out) return epuc("outofmem", "Out of memory");
-   if (bpp < 16) {
-      int z=0;
-      if (psize == 0 || psize > 256) { free(out); return epuc("invalid", "Corrupt BMP"); }
-      for (i=0; i < psize; ++i) {
-         pal[i][2] = get8(s);
-         pal[i][1] = get8(s);
-         pal[i][0] = get8(s);
-         if (hsz != 12) get8(s);
-         pal[i][3] = 255;
-      }
-      skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4));
-      if (bpp == 4) width = (s->img_x + 1) >> 1;
-      else if (bpp == 8) width = s->img_x;
-      else { free(out); return epuc("bad bpp", "Corrupt BMP"); }
-      pad = (-width)&3;
-      for (j=0; j < (int) s->img_y; ++j) {
-         for (i=0; i < (int) s->img_x; i += 2) {
-            int v=get8(s),v2=0;
-            if (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 = (bpp == 8) ? get8(s) : v2;
-            out[z++] = pal[v][0];
-            out[z++] = pal[v][1];
-            out[z++] = pal[v][2];
-            if (target == 4) out[z++] = 255;
-         }
-         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;
-      skip(s, offset - 14 - hsz);
-      if (bpp == 24) width = 3 * s->img_x;
-      else if (bpp == 16) width = 2*s->img_x;
-      else /* bpp = 32 and pad = 0 */ width=0;
-      pad = (-width) & 3;
-      if (bpp == 24) {
-         easy = 1;
-      } else if (bpp == 32) {
-         if (mb == 0xff && mg == 0xff00 && mr == 0xff000000 && ma == 0xff000000)
-            easy = 2;
-      }
-      if (!easy) {
-         if (!mr || !mg || !mb) return epuc("bad masks", "Corrupt BMP");
-         // right shift amt to put high bit in position #7
-         rshift = high_bit(mr)-7; rcount = bitcount(mr);
-         gshift = high_bit(mg)-7; gcount = bitcount(mr);
-         bshift = high_bit(mb)-7; bcount = bitcount(mr);
-         ashift = high_bit(ma)-7; acount = bitcount(mr);
-      }
-      for (j=0; j < (int) s->img_y; ++j) {
-         if (easy) {
-            for (i=0; i < (int) s->img_x; ++i) {
-               int a;
-               out[z+2] = get8(s);
-               out[z+1] = get8(s);
-               out[z+0] = get8(s);
-               z += 3;
-               a = (easy == 2 ? get8(s) : 255);
-               if (target == 4) out[z++] = a;
-            }
-         } else {
-            for (i=0; i < (int) s->img_x; ++i) {
-               uint32 v = (bpp == 16 ? get16le(s) : get32le(s));
-               int a;
-               out[z++] = shiftsigned(v & mr, rshift, rcount);
-               out[z++] = shiftsigned(v & mg, gshift, gcount);
-               out[z++] = shiftsigned(v & mb, bshift, bcount);
-               a = (ma ? shiftsigned(v & ma, ashift, acount) : 255);
-               if (target == 4) out[z++] = a;
-            }
-         }
-         skip(s, pad);
-      }
-   }
-   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 = convert_format(out, target, req_comp, s->img_x, s->img_y);
-      if (out == NULL) return out; // convert_format frees input on failure
-   }
-
-   *x = s->img_x;
-   *y = s->img_y;
-   if (comp) *comp = target;
-   return out;
-}
-
-#ifndef STBI_NO_STDIO
-stbi_uc *stbi_bmp_load             (char const *filename,           int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_bmp_load_from_file(f, x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-
-stbi_uc *stbi_bmp_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_file(&s, f);
-   return bmp_load(&s, x,y,comp,req_comp);
-}
-#endif
-
-stbi_uc *stbi_bmp_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return bmp_load(&s, x,y,comp,req_comp);
-}
-
-// Targa Truevision - TGA
-// by Jonathan Dummer
-
-static int tga_test(stbi *s)
-{
-	int sz;
-	get8u(s);		//	discard Offset
-	sz = get8u(s);	//	color type
-	if( sz > 1 ) return 0;	//	only RGB or indexed allowed
-	sz = get8u(s);	//	image type
-	if( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0;	//	only RGB or grey allowed, +/- RLE
-	get16(s);		//	discard palette start
-	get16(s);		//	discard palette length
-	get8(s);			//	discard bits per palette color entry
-	get16(s);		//	discard x origin
-	get16(s);		//	discard y origin
-	if( get16(s) < 1 ) return 0;		//	test width
-	if( get16(s) < 1 ) return 0;		//	test height
-	sz = get8(s);	//	bits per pixel
-	if( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) ) return 0;	//	only RGB or RGBA or grey allowed
-	return 1;		//	seems to have passed everything
-}
-
-#ifndef STBI_NO_STDIO
-int      stbi_tga_test_file        (FILE *f)
-{
-   stbi s;
-   int r,n = ftell(f);
-   start_file(&s, f);
-   r = tga_test(&s);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int      stbi_tga_test_memory      (stbi_uc const *buffer, int len)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return tga_test(&s);
-}
-
-static stbi_uc *tga_load(stbi *s, int *x, int *y, int *comp, int req_comp)
-{
-	//	read in the TGA header stuff
-	int tga_offset = get8u(s);
-	int tga_indexed = get8u(s);
-	int tga_image_type = get8u(s);
-	int tga_is_RLE = 0;
-	int tga_palette_start = get16le(s);
-	int tga_palette_len = get16le(s);
-	int tga_palette_bits = get8u(s);
-	int tga_x_origin = get16le(s);
-	int tga_y_origin = get16le(s);
-	int tga_width = get16le(s);
-	int tga_height = get16le(s);
-	int tga_bits_per_pixel = get8u(s);
-	int tga_inverted = get8u(s);
-	//	image data
-	unsigned char *tga_data;
-	unsigned char *tga_palette = NULL;
-	int i, j;
-	unsigned char raw_data[4];
-	unsigned char trans_data[] = { 0,0,0,0 };
-	int RLE_count = 0;
-	int RLE_repeating = 0;
-	int read_next_pixel = 1;
-	//	do a tiny bit of precessing
-	if( tga_image_type >= 8 )
-	{
-		tga_image_type -= 8;
-		tga_is_RLE = 1;
-	}
-	/* int tga_alpha_bits = tga_inverted & 15; */
-	tga_inverted = 1 - ((tga_inverted >> 5) & 1);
-
-	//	error check
-	if( //(tga_indexed) ||
-		(tga_width < 1) || (tga_height < 1) ||
-		(tga_image_type < 1) || (tga_image_type > 3) ||
-		((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) &&
-		(tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32))
-		)
-	{
-		return NULL;
-	}
-
-	//	If I'm paletted, then I'll use the number of bits from the palette
-	if( tga_indexed )
-	{
-		tga_bits_per_pixel = tga_palette_bits;
-	}
-
-	//	tga info
-	*x = tga_width;
-	*y = tga_height;
-	if( (req_comp < 1) || (req_comp > 4) )
-	{
-		//	just use whatever the file was
-		req_comp = tga_bits_per_pixel / 8;
-		*comp = req_comp;
-	} else
-	{
-		//	force a new number of components
-		*comp = tga_bits_per_pixel/8;
-	}
-	tga_data = (unsigned char*)malloc( tga_width * tga_height * req_comp );
-
-	//	skip to the data's starting position (offset usually = 0)
-	skip(s, tga_offset );
-	//	do I need to load a palette?
-	if( tga_indexed )
-	{
-		//	any data to skip? (offset usually = 0)
-		skip(s, tga_palette_start );
-		//	load the palette
-		tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 );
-		getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 );
-	}
-	//	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 chunk?
-		if( tga_is_RLE )
-		{
-			if( RLE_count == 0 )
-			{
-				//	yep, get the next byte as a RLE command
-				int RLE_cmd = get8u(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 1 byte, then perform the lookup
-				int pal_idx = get8u(s);
-				if( pal_idx >= tga_palette_len )
-				{
-					//	invalid index
-					pal_idx = 0;
-				}
-				pal_idx *= tga_bits_per_pixel / 8;
-				for( j = 0; j*8 < tga_bits_per_pixel; ++j )
-				{
-					raw_data[j] = tga_palette[pal_idx+j];
-				}
-			} else
-			{
-				//	read in the data raw
-				for( j = 0; j*8 < tga_bits_per_pixel; ++j )
-				{
-					raw_data[j] = get8u(s);
-				}
-			}
-			//	convert raw to the intermediate format
-			switch( tga_bits_per_pixel )
-			{
-			case 8:
-				//	Luminous => RGBA
-				trans_data[0] = raw_data[0];
-				trans_data[1] = raw_data[0];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = 255;
-				break;
-			case 16:
-				//	Luminous,Alpha => RGBA
-				trans_data[0] = raw_data[0];
-				trans_data[1] = raw_data[0];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = raw_data[1];
-				break;
-			case 24:
-				//	BGR => RGBA
-				trans_data[0] = raw_data[2];
-				trans_data[1] = raw_data[1];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = 255;
-				break;
-			case 32:
-				//	BGRA => RGBA
-				trans_data[0] = raw_data[2];
-				trans_data[1] = raw_data[1];
-				trans_data[2] = raw_data[0];
-				trans_data[3] = raw_data[3];
-				break;
-			}
-			//	clear the reading flag for the next pixel
-			read_next_pixel = 0;
-		} // end of reading a pixel
-		//	convert to final format
-		switch( req_comp )
-		{
-		case 1:
-			//	RGBA => Luminance
-			tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]);
-			break;
-		case 2:
-			//	RGBA => Luminance,Alpha
-			tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]);
-			tga_data[i*req_comp+1] = trans_data[3];
-			break;
-		case 3:
-			//	RGBA => RGB
-			tga_data[i*req_comp+0] = trans_data[0];
-			tga_data[i*req_comp+1] = trans_data[1];
-			tga_data[i*req_comp+2] = trans_data[2];
-			break;
-		case 4:
-			//	RGBA => RGBA
-			tga_data[i*req_comp+0] = trans_data[0];
-			tga_data[i*req_comp+1] = trans_data[1];
-			tga_data[i*req_comp+2] = trans_data[2];
-			tga_data[i*req_comp+3] = trans_data[3];
-			break;
-		}
-		//	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 * req_comp;
-			int index2 = (tga_height - 1 - j) * tga_width * req_comp;
-			for( i = tga_width * req_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 )
-	{
-		free( tga_palette );
-	}
-	//	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;
-}
-
-#ifndef STBI_NO_STDIO
-stbi_uc *stbi_tga_load             (char const *filename,           int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_tga_load_from_file(f, x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-
-stbi_uc *stbi_tga_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_file(&s, f);
-   return tga_load(&s, x,y,comp,req_comp);
-}
-#endif
-
-stbi_uc *stbi_tga_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return tga_load(&s, x,y,comp,req_comp);
-}
-
-
-// *************************************************************************************************
-// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicholas Schulz, tweaked by STB
-
-static int psd_test(stbi *s)
-{
-	if (get32(s) != 0x38425053) return 0;	// "8BPS"
-	else return 1;
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_psd_test_file(FILE *f)
-{
-   stbi s;
-   int r,n = ftell(f);
-   start_file(&s, f);
-   r = psd_test(&s);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-int stbi_psd_test_memory(stbi_uc const *buffer, int len)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return psd_test(&s);
-}
-
-static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp)
-{
-	int	pixelCount;
-	int channelCount, compression;
-	int channel, i, count, len;
-   int w,h;
-   uint8 *out;
-
-	// Check identifier
-	if (get32(s) != 0x38425053)	// "8BPS"
-		return epuc("not PSD", "Corrupt PSD image");
-
-	// Check file type version.
-	if (get16(s) != 1)
-		return epuc("wrong version", "Unsupported version of PSD image");
-
-	// Skip 6 reserved bytes.
-	skip(s, 6 );
-
-	// Read the number of channels (R, G, B, A, etc).
-	channelCount = get16(s);
-	if (channelCount < 0 || channelCount > 16)
-		return epuc("wrong channel count", "Unsupported number of channels in PSD image");
-
-	// Read the rows and columns of the image.
-   h = get32(s);
-   w = get32(s);
-
-	// Make sure the depth is 8 bits.
-	if (get16(s) != 8)
-		return epuc("unsupported bit depth", "PSD bit depth is not 8 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 (get16(s) != 3)
-		return epuc("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.)
-	skip(s,get32(s) );
-
-	// Skip the image resources.  (resolution, pen tool paths, etc)
-	skip(s, get32(s) );
-
-	// Skip the reserved data.
-	skip(s, get32(s) );
-
-	// Find out if the data is compressed.
-	// Known values:
-	//   0: no compression
-	//   1: RLE compressed
-	compression = get16(s);
-	if (compression > 1)
-		return epuc("bad compression", "PSD has an unknown compression format");
-
-	// Create the destination image.
-	out = (stbi_uc *) malloc(4 * w*h);
-	if (!out) return epuc("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 preceeded by a 2-byte data count for each row in the data,
-		// which we're going to just skip.
-		skip(s, h * channelCount * 2 );
-
-		// Read the RLE data by channel.
-		for (channel = 0; channel < 4; channel++) {
-			uint8 *p;
-
-         p = out+channel;
-			if (channel >= channelCount) {
-				// Fill this channel with default data.
-				for (i = 0; i < pixelCount; i++) *p = (channel == 3 ? 255 : 0), p += 4;
-			} else {
-				// Read the RLE data.
-				count = 0;
-				while (count < pixelCount) {
-					len = get8(s);
-					if (len == 128) {
-						// No-op.
-					} else if (len < 128) {
-						// Copy next len+1 bytes literally.
-						len++;
-						count += len;
-						while (len) {
-							*p = get8(s);
-                     p += 4;
-							len--;
-						}
-					} else if (len > 128) {
-						uint32	val;
-						// Next -len+1 bytes in the dest are replicated from next source byte.
-						// (Interpret len as a negative 8-bit int.)
-						len ^= 0x0FF;
-						len += 2;
-                  val = get8(s);
-						count += len;
-						while (len) {
-							*p = val;
-                     p += 4;
-							len--;
-						}
-					}
-				}
-			}
-		}
-
-	} 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 value for each pixel in the image.
-
-		// Read the data by channel.
-		for (channel = 0; channel < 4; channel++) {
-			uint8 *p;
-
-         p = out + channel;
-			if (channel > channelCount) {
-				// Fill this channel with default data.
-				for (i = 0; i < pixelCount; i++) *p = channel == 3 ? 255 : 0, p += 4;
-			} else {
-				// Read the data.
-				count = 0;
-				for (i = 0; i < pixelCount; i++)
-					*p = get8(s), p += 4;
-			}
-		}
-	}
-
-	if (req_comp && req_comp != 4) {
-		out = convert_format(out, 4, req_comp, w, h);
-		if (out == NULL) return out; // convert_format frees input on failure
-	}
-
-	if (comp) *comp = channelCount;
-	*y = h;
-	*x = w;
-
-	return out;
-}
-
-#ifndef STBI_NO_STDIO
-stbi_uc *stbi_psd_load(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *data;
-   FILE *f = fopen(filename, "rb");
-   if (!f) return NULL;
-   data = stbi_psd_load_from_file(f, x,y,comp,req_comp);
-   fclose(f);
-   return data;
-}
-
-stbi_uc *stbi_psd_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_file(&s, f);
-   return psd_load(&s, x,y,comp,req_comp);
-}
-#endif
-
-stbi_uc *stbi_psd_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_mem(&s, buffer, len);
-   return psd_load(&s, x,y,comp,req_comp);
-}
-
-
-// *************************************************************************************************
-// Radiance RGBE HDR loader
-// originally by Nicolas Schulz
-#ifndef STBI_NO_HDR
-static int hdr_test(stbi *s)
-{
-   char *signature = "#?RADIANCE\n";
-   int i;
-   for (i=0; signature[i]; ++i)
-      if (get8(s) != signature[i])
-         return 0;
-	return 1;
-}
-
-int stbi_hdr_test_memory(stbi_uc const *buffer, int len)
-{
-   stbi s;
-	start_mem(&s, buffer, len);
-	return hdr_test(&s);
-}
-
-#ifndef STBI_NO_STDIO
-int stbi_hdr_test_file(FILE *f)
-{
-   stbi s;
-   int r,n = ftell(f);
-   start_file(&s, f);
-   r = hdr_test(&s);
-   fseek(f,n,SEEK_SET);
-   return r;
-}
-#endif
-
-#define HDR_BUFLEN  1024
-static char *hdr_gettoken(stbi *z, char *buffer)
-{
-   int len=0;
-	//char *s = buffer,
-	char c = '\0';
-
-   c = get8(z);
-
-	while (!at_eof(z) && c != '\n') {
-		buffer[len++] = c;
-      if (len == HDR_BUFLEN-1) {
-         // flush to end of line
-         while (!at_eof(z) && get8(z) != '\n')
-            ;
-         break;
-      }
-      c = get8(z);
-	}
-
-   buffer[len] = 0;
-	return buffer;
-}
-
-static void 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 *hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp)
-{
-   char buffer[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;
-
-
-	// Check identifier
-	if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0)
-		return epf("not HDR", "Corrupt HDR image");
-
-	// Parse header
-	while(1) {
-		token = hdr_gettoken(s,buffer);
-      if (token[0] == 0) break;
-		if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
-   }
-
-	if (!valid)    return epf("unsupported format", "Unsupported HDR format");
-
-   // Parse width and height
-   // can't use sscanf() if we're not using stdio!
-   token = hdr_gettoken(s,buffer);
-   if (strncmp(token, "-Y ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   height = strtol(token, &token, 10);
-   while (*token == ' ') ++token;
-   if (strncmp(token, "+X ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   width = strtol(token, NULL, 10);
-
-	*x = width;
-	*y = height;
-
-   *comp = 3;
-	if (req_comp == 0) req_comp = 3;
-
-	// Read data
-	hdr_data = (float *) malloc(height * width * req_comp * sizeof(float));
-
-	// 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:
-            getn(s, rgbe, 4);
-            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 = get8(s);
-         c2 = get8(s);
-         len = 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] = { c1,c2,len, get8(s) };
-            hdr_convert(hdr_data, rgbe, req_comp);
-            i = 1;
-            j = 0;
-            free(scanline);
-            goto main_decode_loop; // yes, this is fucking insane; blame the fucking insane format
-         }
-         len <<= 8;
-         len |= get8(s);
-         if (len != width) { free(hdr_data); free(scanline); return epf("invalid decoded scanline length", "corrupt HDR"); }
-         if (scanline == NULL) scanline = (stbi_uc *) malloc(width * 4);
-
-			for (k = 0; k < 4; ++k) {
-				i = 0;
-				while (i < width) {
-					count = get8(s);
-					if (count > 128) {
-						// Run
-						value = get8(s);
-                  count -= 128;
-						for (z = 0; z < count; ++z)
-							scanline[i++ * 4 + k] = value;
-					} else {
-						// Dump
-						for (z = 0; z < count; ++z)
-							scanline[i++ * 4 + k] = get8(s);
-					}
-				}
-			}
-         for (i=0; i < width; ++i)
-            hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
-		}
-      free(scanline);
-	}
-
-   return hdr_data;
-}
-
-static stbi_uc *hdr_load_rgbe(stbi *s, int *x, int *y, int *comp, int req_comp)
-{
-   char buffer[HDR_BUFLEN];
-	char *token;
-	int valid = 0;
-	int width, height;
-   stbi_uc *scanline;
-	stbi_uc *rgbe_data;
-	int len;
-	unsigned char count, value;
-	int i, j, k, c1,c2, z;
-
-
-	// Check identifier
-	if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0)
-		return epuc("not HDR", "Corrupt HDR image");
-
-	// Parse header
-	while(1) {
-		token = hdr_gettoken(s,buffer);
-      if (token[0] == 0) break;
-		if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
-   }
-
-	if (!valid)    return epuc("unsupported format", "Unsupported HDR format");
-
-   // Parse width and height
-   // can't use sscanf() if we're not using stdio!
-   token = hdr_gettoken(s,buffer);
-   if (strncmp(token, "-Y ", 3))  return epuc("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   height = strtol(token, &token, 10);
-   while (*token == ' ') ++token;
-   if (strncmp(token, "+X ", 3))  return epuc("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   width = strtol(token, NULL, 10);
-
-	*x = width;
-	*y = height;
-
-	// RGBE _MUST_ come out as 4 components
-   *comp = 4;
-	req_comp = 4;
-
-	// Read data
-	rgbe_data = (stbi_uc *) malloc(height * width * req_comp * sizeof(stbi_uc));
-	//	point to the beginning
-	scanline = rgbe_data;
-
-	// Load image data
-   // image data is stored as some number of scan lines
-	if( width < 8 || width >= 32768) {
-		// Read flat data
-      for (j=0; j < height; ++j) {
-         for (i=0; i < width; ++i) {
-           main_decode_loop:
-            //getn(rgbe, 4);
-            getn(s,scanline, 4);
-			scanline += 4;
-         }
-      }
-	} else {
-		// Read RLE-encoded data
-		for (j = 0; j < height; ++j) {
-         c1 = get8(s);
-         c2 = get8(s);
-         len = 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)
-            scanline[0] = c1;
-            scanline[1] = c2;
-            scanline[2] = len;
-            scanline[3] = get8(s);
-            scanline += 4;
-            i = 1;
-            j = 0;
-            goto main_decode_loop; // yes, this is insane; blame the insane format
-         }
-         len <<= 8;
-         len |= get8(s);
-         if (len != width) { free(rgbe_data); return epuc("invalid decoded scanline length", "corrupt HDR"); }
-			for (k = 0; k < 4; ++k) {
-				i = 0;
-				while (i < width) {
-					count = get8(s);
-					if (count > 128) {
-						// Run
-						value = get8(s);
-                  count -= 128;
-						for (z = 0; z < count; ++z)
-							scanline[i++ * 4 + k] = value;
-					} else {
-						// Dump
-						for (z = 0; z < count; ++z)
-							scanline[i++ * 4 + k] = get8(s);
-					}
-				}
-			}
-			//	move the scanline on
-			scanline += 4 * width;
-		}
-	}
-
-   return rgbe_data;
-}
-
-#ifndef STBI_NO_STDIO
-float *stbi_hdr_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_file(&s,f);
-   return hdr_load(&s,x,y,comp,req_comp);
-}
-
-stbi_uc *stbi_hdr_load_rgbe_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_file(&s,f);
-   return hdr_load_rgbe(&s,x,y,comp,req_comp);
-}
-
-stbi_uc *stbi_hdr_load_rgbe        (char const *filename,           int *x, int *y, int *comp, int req_comp)
-{
-   FILE *f = fopen(filename, "rb");
-   unsigned char *result;
-   if (!f) return epuc("can't fopen", "Unable to open file");
-   result = stbi_hdr_load_rgbe_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-#endif
-
-float *stbi_hdr_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_mem(&s,buffer, len);
-   return hdr_load(&s,x,y,comp,req_comp);
-}
-
-stbi_uc *stbi_hdr_load_rgbe_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi s;
-   start_mem(&s,buffer, len);
-   return hdr_load_rgbe(&s,x,y,comp,req_comp);
-}
-
-#endif // STBI_NO_HDR
-
-/////////////////////// write image ///////////////////////
-
-#ifndef STBI_NO_WRITE
-
-static void write8(FILE *f, int x) { uint8 z = (uint8) x; fwrite(&z,1,1,f); }
-
-static void writefv(FILE *f, char *fmt, va_list v)
-{
-   while (*fmt) {
-      switch (*fmt++) {
-         case ' ': break;
-         case '1': { uint8 x = va_arg(v, int); write8(f,x); break; }
-         case '2': { int16 x = va_arg(v, int); write8(f,x); write8(f,x>>8); break; }
-         case '4': { int32 x = va_arg(v, int); write8(f,x); write8(f,x>>8); write8(f,x>>16); write8(f,x>>24); break; }
-         default:
-            assert(0);
-            va_end(v);
-            return;
-      }
-   }
-}
-
-static void writef(FILE *f, char *fmt, ...)
-{
-   va_list v;
-   va_start(v, fmt);
-   writefv(f,fmt,v);
-   va_end(v);
-}
-
-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)
-{
-   uint8 bg[3] = { 255, 0, 255}, px[3];
-   uint32 zero = 0;
-   int i,j,k, j_end;
-
-   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) {
-         uint8 *d = (uint8 *) data + (j*x+i)*comp;
-         if (write_alpha < 0)
-            fwrite(&d[comp-1], 1, 1, f);
-         switch (comp) {
-            case 1:
-            case 2: writef(f, "111", d[0],d[0],d[0]);
-                    break;
-            case 4:
-               if (!write_alpha) {
-                  for (k=0; k < 3; ++k)
-                     px[k] = bg[k] + ((d[k] - bg[k]) * d[3])/255;
-                  writef(f, "111", px[1-rgb_dir],px[1],px[1+rgb_dir]);
-                  break;
-               }
-               /* FALLTHROUGH */
-            case 3:
-               writef(f, "111", 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, char *fmt, ...)
-{
-   FILE *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, void *data)
-{
-   int pad = (-x*3) & 3;
-   return outfile(filename,-1,-1,x,y,comp,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, void *data)
-{
-   int has_alpha = !(comp & 1);
-   return outfile(filename, -1,-1, x, y, comp, 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);
-}
-
-// any other image formats that do interleaved rgb data?
-//    PNG: requires adler32,crc32 -- significant amount of code
-//    PSD: no, channels output separately
-//    TIFF: no, stripwise-interleaved... i think
-
-#endif // STBI_NO_WRITE
-
-//	add in my DDS loading support
-#ifndef STBI_NO_DDS
-#include "stbi_DDS_aug_c.h"
-#endif
diff --git a/4dm.h/soil/stb_image_aug.h b/4dm.h/soil/stb_image_aug.h
deleted file mode 100644
index e59f2eb..0000000
--- a/4dm.h/soil/stb_image_aug.h
+++ /dev/null
@@ -1,354 +0,0 @@
-/* stbi-1.16 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
-                      when you control the images you're loading
-
-   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, no oddball channel decimations)
-      PNG non-interlaced
-      BMP non-1bpp, non-RLE
-      TGA (not sure what subset, if a subset)
-      PSD (composited view only, no extra channels)
-      HDR (radiance rgbE format)
-      writes BMP,TGA (define STBI_NO_WRITE to remove code)
-      decoded from memory or through stdio FILE (define STBI_NO_STDIO to remove code)
-      supports installable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
-        
-   TODO:
-      stbi_info_*
-  
-   history:
-      1.16   major bugfix - 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
-*/
-
-#ifndef HEADER_STB_IMAGE_AUGMENTED
-#define HEADER_STB_IMAGE_AUGMENTED
-
-////   begin header file  ////////////////////////////////////////////////////
-//
-// Limitations:
-//    - no progressive/interlaced support (jpeg, png)
-//    - 8-bit samples only (jpeg, png)
-//    - not threadsafe
-//    - channel subsampling of at most 2 in each dimension (jpeg)
-//    - no delayed line count (jpeg) -- IJG doesn't support either
-//
-// 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
-//    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 and BMP images are automatically depalettized.
-//
-//
-// ===========================================================================
-//
-// 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);
-
-#ifndef STBI_NO_STDIO
-#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
-
-// WRITING API
-
-#if !defined(STBI_NO_WRITE) && !defined(STBI_NO_STDIO)
-// write a BMP/TGA file given tightly packed 'comp' channels (no padding, nor bmp-stride-padding)
-// (you must include the appropriate extension in the filename).
-// returns TRUE on success, FALSE if couldn't open file, error writing file
-extern int      stbi_write_bmp       (char const *filename,     int x, int y, int comp, void *data);
-extern int      stbi_write_tga       (char const *filename,     int x, int y, int comp, void *data);
-#endif
-
-// PRIMARY API - works on images of any type
-
-// load image by filename, open file, or memory buffer
-#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);
-extern int      stbi_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-#endif
-extern stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-// for stbi_load_from_file, file pointer is left pointing immediately after image
-
-#ifndef STBI_NO_HDR
-#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_memory(stbi_uc const *buffer, int len, 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
-
-// get a VERY brief reason for failure
-// NOT THREADSAFE
-extern 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_is_hdr_from_memory(stbi_uc const *buffer, int len);
-#ifndef STBI_NO_STDIO
-extern int      stbi_info            (char const *filename,     int *x, int *y, int *comp);
-extern int      stbi_is_hdr          (char const *filename);
-extern int      stbi_is_hdr_from_file(FILE *f);
-#endif
-
-// 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);
-
-// TYPE-SPECIFIC ACCESS
-
-// is it a jpeg?
-extern int      stbi_jpeg_test_memory     (stbi_uc const *buffer, int len);
-extern stbi_uc *stbi_jpeg_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-extern int      stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-
-#ifndef STBI_NO_STDIO
-extern stbi_uc *stbi_jpeg_load            (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern int      stbi_jpeg_test_file       (FILE *f);
-extern stbi_uc *stbi_jpeg_load_from_file  (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-
-extern int      stbi_jpeg_info            (char const *filename,     int *x, int *y, int *comp);
-extern int      stbi_jpeg_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-#endif
-
-// is it a png?
-extern int      stbi_png_test_memory      (stbi_uc const *buffer, int len);
-extern stbi_uc *stbi_png_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-extern int      stbi_png_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-
-#ifndef STBI_NO_STDIO
-extern stbi_uc *stbi_png_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern int      stbi_png_info             (char const *filename,     int *x, int *y, int *comp);
-extern int      stbi_png_test_file        (FILE *f);
-extern stbi_uc *stbi_png_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-extern int      stbi_png_info_from_file   (FILE *f,                  int *x, int *y, int *comp);
-#endif
-
-// is it a bmp?
-extern int      stbi_bmp_test_memory      (stbi_uc const *buffer, int len);
-
-extern stbi_uc *stbi_bmp_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_bmp_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_bmp_test_file        (FILE *f);
-extern stbi_uc *stbi_bmp_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// is it a tga?
-extern int      stbi_tga_test_memory      (stbi_uc const *buffer, int len);
-
-extern stbi_uc *stbi_tga_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_tga_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_tga_test_file        (FILE *f);
-extern stbi_uc *stbi_tga_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// is it a psd?
-extern int      stbi_psd_test_memory      (stbi_uc const *buffer, int len);
-
-extern stbi_uc *stbi_psd_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_psd_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_psd_test_file        (FILE *f);
-extern stbi_uc *stbi_psd_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// is it an hdr?
-extern int      stbi_hdr_test_memory      (stbi_uc const *buffer, int len);
-
-extern float *  stbi_hdr_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
-extern float *  stbi_hdr_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_hdr_load_rgbe        (char const *filename,           int *x, int *y, int *comp, int req_comp);
-extern float *  stbi_hdr_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_hdr_test_file        (FILE *f);
-extern float *  stbi_hdr_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_hdr_load_rgbe_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-// define new loaders
-typedef struct
-{
-   int       (*test_memory)(stbi_uc const *buffer, int len);
-   stbi_uc * (*load_from_memory)(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-   #ifndef STBI_NO_STDIO
-   int       (*test_file)(FILE *f);
-   stbi_uc * (*load_from_file)(FILE *f, int *x, int *y, int *comp, int req_comp);
-   #endif
-} stbi_loader;
-
-// register a loader by filling out the above structure (you must defined ALL functions)
-// returns 1 if added or already added, 0 if not added (too many loaders)
-// NOT THREADSAFE
-extern int stbi_register_loader(stbi_loader *loader);
-
-// define faster low-level operations (typically SIMD support)
-#if STBI_SIMD
-typedef void (*stbi_idct_8x8)(uint8 *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)(uint8 *output, uint8 const *y, uint8 const *cb, uint8 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/4dm.h/soil/stb_image_write.h b/4dm.h/soil/stb_image_write.h
new file mode 100644
index 0000000..df62339
--- /dev/null
+++ b/4dm.h/soil/stb_image_write.h
@@ -0,0 +1,1092 @@
+/* stb_image_write - v1.05 - public domain - http://nothings.org/stb/stb_image_write.h
+   writes out PNG/BMP/TGA 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.
+
+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 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()
+
+USAGE:
+
+   There are four 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_hdr(char const *filename, int w, int h, int comp, const float *data);
+
+   There are also four 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);
+
+   where the callback is:
+      void stbi_write_func(void *context, void *data, int size);
+
+   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.)
+
+   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.
+
+CREDITS:
+
+   PNG/BMP/TGA
+      Sean Barrett
+   HDR
+      Baldur Karlsson
+   TGA monochrome:
+      Jean-Sebastien Guay
+   misc enhancements:
+      Tim Kelsey
+   TGA RLE
+      Alan Hickman
+   initial file IO callback implementation
+      Emmanuel Julien
+   bugfixes:
+      github:Chribba
+      Guillaume Chereau
+      github:jry2
+      github:romigrou
+      Sergio Gonzalez
+      Jonas Karlsson
+      Filip Wasil
+      Thatcher Ulrich
+      github:poppolopoppo
+      Patrick Boettcher
+      
+LICENSE
+
+  See end of file for license information.
+
+*/
+
+#ifndef INCLUDE_STB_IMAGE_WRITE_H
+#define INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef STB_IMAGE_WRITE_STATIC
+#define STBIWDEF static
+#else
+#define STBIWDEF extern
+extern int stbi_write_tga_with_rle;
+#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);
+#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);
+
+#ifdef __cplusplus
+}
+#endif
+
+#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)
+
+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);
+}
+
+static int stbi__start_write_file(stbi__write_context *s, const char *filename)
+{
+   FILE *f = 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];
+
+#ifdef STB_IMAGE_WRITE_STATIC
+static int stbi_write_tga_with_rle = 1;
+#else
+int stbi_write_tga_with_rle = 1;
+#endif
+
+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__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 (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;
+
+      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);
+
+      for (j = y - 1; j >= 0; --j) {
+          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;
+}
+
+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
+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))
+
+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);
+   }
+}
+
+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);
+}
+
+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);
+}
+
+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);
+
+      len = sprintf(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
+      s->func(s->context, buffer, len);
+
+      for(i=0; i < y; i++)
+         stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*i*x);
+      STBIW_FREE(scratch);
+      return 1;
+   }
+}
+
+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
+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
+//
+
+// 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
+
+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 = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(char**));
+   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);
+}
+
+static unsigned int stbiw__crc32(unsigned char *buffer, int len)
+{
+   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;
+}
+
+#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
+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 *) 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) {
+      static int mapping[] = { 0,1,2,3,4 };
+      static int firstmap[] = { 0,1,0,5,6 };
+      int *mymap = (j != 0) ? mapping : firstmap;
+      int best = 0, bestval = 0x7fffffff;
+      for (p=0; p < 2; ++p) {
+         for (k= p?best:0; k < 5; ++k) { // @TODO: clarity: rewrite this to go 0..5, and 'continue' the unwanted ones during 2nd pass
+            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] - stbiw__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] - stbiw__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] - stbiw__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;
+      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, 8); // increase 8 to get smaller but use more memory
+   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((unsigned char *) data, stride_bytes, x, y, comp, &len);
+   if (png == NULL) return 0;
+   f = 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((unsigned char *) data, stride_bytes, x, y, comp, &len);
+   if (png == NULL) return 0;
+   func(context, png, len);
+   STBIW_FREE(png);
+   return 1;
+}
+
+#endif // STB_IMAGE_WRITE_IMPLEMENTATION
+
+/* Revision history
+      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/4dm.h/soil/stbi_DDS.h b/4dm.h/soil/stbi_DDS.h
new file mode 100644
index 0000000..fbf8193
--- /dev/null
+++ b/4dm.h/soil/stbi_DDS.h
@@ -0,0 +1,34 @@
+/*
+	adding DDS loading support to stbi
+*/
+
+#ifndef HEADER_STB_IMAGE_DDS_AUGMENTATION
+#define HEADER_STB_IMAGE_DDS_AUGMENTATION
+
+/*	is it a DDS file? */
+extern int      stbi__dds_test_memory      (stbi_uc const *buffer, int len);
+extern int      stbi__dds_test_callbacks   (stbi_io_callbacks const *clbk, void *user);
+
+extern void    *stbi__dds_load_from_path   (const char *filename,           int *x, int *y, int *comp, int req_comp);
+extern void    *stbi__dds_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+extern void    *stbi__dds_load_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_STDIO
+extern int      stbi__dds_test_filename    (char const *filename);
+extern int      stbi__dds_test_file        (FILE *f);
+extern void    *stbi__dds_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+#endif
+
+extern int      stbi__dds_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int *iscompressed);
+extern int      stbi__dds_info_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int *iscompressed);
+
+
+#ifndef STBI_NO_STDIO
+extern int      stbi__dds_info_from_path   (char const *filename,     int *x, int *y, int *comp, int *iscompressed);
+extern int      stbi__dds_info_from_file   (FILE *f,                  int *x, int *y, int *comp, int *iscompressed);
+#endif
+
+/*
+//
+////   end header file   /////////////////////////////////////////////////////*/
+#endif /* HEADER_STB_IMAGE_DDS_AUGMENTATION */
diff --git a/4dm.h/soil/stbi_DDS_aug.h b/4dm.h/soil/stbi_DDS_aug.h
deleted file mode 100644
index c7da9f7..0000000
--- a/4dm.h/soil/stbi_DDS_aug.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-	adding DDS loading support to stbi
-*/
-
-#ifndef HEADER_STB_IMAGE_DDS_AUGMENTATION
-#define HEADER_STB_IMAGE_DDS_AUGMENTATION
-
-//	is it a DDS file?
-extern int      stbi_dds_test_memory      (stbi_uc const *buffer, int len);
-
-extern stbi_uc *stbi_dds_load             (char *filename,           int *x, int *y, int *comp, int req_comp);
-extern stbi_uc *stbi_dds_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-#ifndef STBI_NO_STDIO
-extern int      stbi_dds_test_file        (FILE *f);
-extern stbi_uc *stbi_dds_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-#endif
-
-//
-//
-////   end header file   /////////////////////////////////////////////////////
-#endif // HEADER_STB_IMAGE_DDS_AUGMENTATION
diff --git a/4dm.h/soil/stbi_DDS_aug_c.h b/4dm.h/soil/stbi_DDS_c.h
similarity index 67%
rename from 4dm.h/soil/stbi_DDS_aug_c.h
rename to 4dm.h/soil/stbi_DDS_c.h
index f49407a..392065b 100644
--- a/4dm.h/soil/stbi_DDS_aug_c.h
+++ b/4dm.h/soil/stbi_DDS_c.h
@@ -2,103 +2,77 @@
 ///	DDS file support, does decoding, _not_ direct uploading
 ///	(use SOIL for that ;-)
 
-///	A bunch of DirectDraw Surface structures and flags
-typedef struct {
-    unsigned int    dwMagic;
-    unsigned int    dwSize;
-    unsigned int    dwFlags;
-    unsigned int    dwHeight;
-    unsigned int    dwWidth;
-    unsigned int    dwPitchOrLinearSize;
-    unsigned int    dwDepth;
-    unsigned int    dwMipMapCount;
-    unsigned int    dwReserved1[ 11 ];
-
-    //  DDPIXELFORMAT
-    struct {
-      unsigned int    dwSize;
-      unsigned int    dwFlags;
-      unsigned int    dwFourCC;
-      unsigned int    dwRGBBitCount;
-      unsigned int    dwRBitMask;
-      unsigned int    dwGBitMask;
-      unsigned int    dwBBitMask;
-      unsigned int    dwAlphaBitMask;
-    }               sPixelFormat;
-
-    //  DDCAPS2
-    struct {
-      unsigned int    dwCaps1;
-      unsigned int    dwCaps2;
-      unsigned int    dwDDSX;
-      unsigned int    dwReserved;
-    }               sCaps;
-    unsigned int    dwReserved2;
-} DDS_header ;
-
-//	the following constants were copied directly off the MSDN website
-
-//	The dwFlags member of the original DDSURFACEDESC2 structure
-//	can be set to one or more of the following values.
-#define DDSD_CAPS	0x00000001
-#define DDSD_HEIGHT	0x00000002
-#define DDSD_WIDTH	0x00000004
-#define DDSD_PITCH	0x00000008
-#define DDSD_PIXELFORMAT	0x00001000
-#define DDSD_MIPMAPCOUNT	0x00020000
-#define DDSD_LINEARSIZE	0x00080000
-#define DDSD_DEPTH	0x00800000
-
-//	DirectDraw Pixel Format
-#define DDPF_ALPHAPIXELS	0x00000001
-#define DDPF_FOURCC	0x00000004
-#define DDPF_RGB	0x00000040
-
-//	The dwCaps1 member of the DDSCAPS2 structure can be
-//	set to one or more of the following values.
-#define DDSCAPS_COMPLEX	0x00000008
-#define DDSCAPS_TEXTURE	0x00001000
-#define DDSCAPS_MIPMAP	0x00400000
-
-//	The dwCaps2 member of the DDSCAPS2 structure can be
-//	set to one or more of the following values.
-#define DDSCAPS2_CUBEMAP	0x00000200
-#define DDSCAPS2_CUBEMAP_POSITIVEX	0x00000400
-#define DDSCAPS2_CUBEMAP_NEGATIVEX	0x00000800
-#define DDSCAPS2_CUBEMAP_POSITIVEY	0x00001000
-#define DDSCAPS2_CUBEMAP_NEGATIVEY	0x00002000
-#define DDSCAPS2_CUBEMAP_POSITIVEZ	0x00004000
-#define DDSCAPS2_CUBEMAP_NEGATIVEZ	0x00008000
-#define DDSCAPS2_VOLUME	0x00200000
-
-static int dds_test(stbi *s)
+#include "image_DXT.h"
+
+static int stbi__dds_test(stbi__context *s)
 {
 	//	check the magic number
-	if (get8(s) != 'D') return 0;
-	if (get8(s) != 'D') return 0;
-	if (get8(s) != 'S') return 0;
-	if (get8(s) != ' ') return 0;
+	if (stbi__get8(s) != 'D') {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	if (stbi__get8(s) != 'D') {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	if (stbi__get8(s) != 'S') {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	if (stbi__get8(s) != ' ') {
+		stbi__rewind(s);
+		return 0;
+	}
+
 	//	check header size
-	if (get32le(s) != 124) return 0;
+	if (stbi__get32le(s) != 124) {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	// Also rewind because the loader needs to read the header
+	stbi__rewind(s);
+
 	return 1;
 }
 #ifndef STBI_NO_STDIO
-int      stbi_dds_test_file        (FILE *f)
+
+int      stbi__dds_test_filename        		(char const *filename)
+{
+   int r;
+   FILE *f = fopen(filename, "rb");
+   if (!f) return 0;
+   r = stbi__dds_test_file(f);
+   fclose(f);
+   return r;
+}
+
+int      stbi__dds_test_file        (FILE *f)
 {
-   stbi s;
+   stbi__context s;
    int r,n = ftell(f);
-   start_file(&s,f);
-   r = dds_test(&s);
+   stbi__start_file(&s,f);
+   r = stbi__dds_test(&s);
    fseek(f,n,SEEK_SET);
    return r;
 }
 #endif
 
-int      stbi_dds_test_memory      (stbi_uc const *buffer, int len)
+int      stbi__dds_test_memory      (stbi_uc const *buffer, int len)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer, len);
+   return stbi__dds_test(&s);
+}
+
+int      stbi__dds_test_callbacks      (stbi_io_callbacks const *clbk, void *user)
 {
-   stbi s;
-   start_mem(&s,buffer, len);
-   return dds_test(&s);
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__dds_test(&s);
 }
 
 //	helper functions
@@ -265,7 +239,104 @@ void stbi_decode_DXT_color_block(
 	}
 	//	done
 }
-static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+
+static int stbi__dds_info( stbi__context *s, int *x, int *y, int *comp, int *iscompressed ) {
+	int flags,is_compressed,has_alpha;
+	DDS_header header={0};
+
+	if( sizeof( DDS_header ) != 128 )
+	{
+		return 0;
+	}
+
+	stbi__getn( s, (stbi_uc*)(&header), 128 );
+
+	if( header.dwMagic != (('D' << 0) | ('D' << 8) | ('S' << 16) | (' ' << 24)) ) {
+	   stbi__rewind( s );
+	   return 0;
+	}
+	if( header.dwSize != 124 ) {
+	   stbi__rewind( s );
+	   return 0;
+	}
+	flags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
+	if( (header.dwFlags & flags) != flags ) {
+	   stbi__rewind( s );
+	   return 0;
+	}
+	if( header.sPixelFormat.dwSize != 32 ) {
+	   stbi__rewind( s );
+	   return 0;
+	}
+	flags = DDPF_FOURCC | DDPF_RGB;
+	if( (header.sPixelFormat.dwFlags & flags) == 0 ) {
+	   stbi__rewind( s );
+	   return 0;
+	}
+	if( (header.sCaps.dwCaps1 & DDSCAPS_TEXTURE) == 0 ) {
+	   stbi__rewind( s );
+	   return 0;
+	}
+
+	is_compressed = (header.sPixelFormat.dwFlags & DDPF_FOURCC) / DDPF_FOURCC;
+	has_alpha = (header.sPixelFormat.dwFlags & DDPF_ALPHAPIXELS) / DDPF_ALPHAPIXELS;
+
+	*x = header.dwWidth;
+	*y = header.dwHeight;
+
+	if ( !is_compressed ) {
+		*comp = 3;
+
+		if ( has_alpha )
+			*comp = 4;
+	}
+	else
+		*comp = 4;
+
+	if ( iscompressed )
+		*iscompressed = is_compressed;
+
+	return 1;
+}
+
+int stbi__dds_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int *iscompressed)
+{
+	stbi__context s;
+	stbi__start_mem(&s,buffer, len);
+	return stbi__dds_info( &s, x, y, comp, iscompressed );
+}
+
+int stbi__dds_info_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int *iscompressed)
+{
+	stbi__context s;
+	stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+	return stbi__dds_info( &s, x, y, comp, iscompressed );
+}
+
+#ifndef STBI_NO_STDIO
+int stbi__dds_info_from_path(char const *filename,     int *x, int *y, int *comp, int *iscompressed)
+{
+   int res;
+   FILE *f = fopen(filename, "rb");
+   if (!f) return 0;
+   res = stbi__dds_info_from_file( f, x, y, comp, iscompressed );
+   fclose(f);
+   return res;
+}
+
+int stbi__dds_info_from_file(FILE *f,                  int *x, int *y, int *comp, int *iscompressed)
+{
+   stbi__context s;
+   int res;
+   long n = ftell(f);
+   stbi__start_file(&s, f);
+   res = stbi__dds_info(&s, x, y, comp, iscompressed);
+   fseek(f, n, SEEK_SET);
+   return res;
+}
+#endif
+
+static void * stbi__dds_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
 {
 	//	all variables go up front
 	stbi_uc *dds_data = NULL;
@@ -275,14 +346,14 @@ static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
 	int has_alpha, has_mipmap;
 	int is_compressed, cubemap_faces;
 	int block_pitch, num_blocks;
-	DDS_header header;
+	DDS_header header={0};
 	int i, sz, cf;
 	//	load the header
 	if( sizeof( DDS_header ) != 128 )
 	{
 		return NULL;
 	}
-	getn( s, (stbi_uc*)(&header), 128 );
+	stbi__getn( s, (stbi_uc*)(&header), 128 );
 	//	and do some checking
 	if( header.dwMagic != (('D' << 0) | ('D' << 8) | ('S' << 16) | (' ' << 24)) ) return NULL;
 	if( header.dwSize != 124 ) return NULL;
@@ -341,29 +412,29 @@ static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
 				if( DXT_family == 1 )
 				{
 					//	DXT1
-					getn( s, compressed, 8 );
+					stbi__getn( s, compressed, 8 );
 					stbi_decode_DXT1_block( block, compressed );
 				} else if( DXT_family < 4 )
 				{
 					//	DXT2/3
-					getn( s, compressed, 8 );
+					stbi__getn( s, compressed, 8 );
 					stbi_decode_DXT23_alpha_block ( block, compressed );
-					getn( s, compressed, 8 );
+					stbi__getn( s, compressed, 8 );
 					stbi_decode_DXT_color_block ( block, compressed );
 				} else
 				{
 					//	DXT4/5
-					getn( s, compressed, 8 );
+					stbi__getn( s, compressed, 8 );
 					stbi_decode_DXT45_alpha_block ( block, compressed );
-					getn( s, compressed, 8 );
+					stbi__getn( s, compressed, 8 );
 					stbi_decode_DXT_color_block ( block, compressed );
 				}
 				//	is this a partial block?
-				if( ref_x + 4 > s->img_x )
+				if( ref_x + 4 > (int)s->img_x )
 				{
 					bw = s->img_x - ref_x;
 				}
-				if( ref_y + 4 > s->img_y )
+				if( ref_y + 4 > (int)s->img_y )
 				{
 					bh = s->img_y - ref_y;
 				}
@@ -379,7 +450,7 @@ static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
 				}
 			}
 			/*	done reading and decoding the main image...
-				skip MIPmaps if present	*/
+				stbi__skip MIPmaps if present	*/
 			if( has_mipmap )
 			{
 				int block_size = 16;
@@ -387,7 +458,7 @@ static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
 				{
 					block_size = 8;
 				}
-				for( i = 1; i < header.dwMipMapCount; ++i )
+				for( i = 1; i < (int)header.dwMipMapCount; ++i )
 				{
 					int mx = s->img_x >> (i + 2);
 					int my = s->img_y >> (i + 2);
@@ -399,7 +470,7 @@ static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
 					{
 						my = 1;
 					}
-					skip( s, mx*my*block_size );
+					stbi__skip( s, mx*my*block_size );
 				}
 			}
 		}/* per cubemap face */
@@ -419,12 +490,12 @@ static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
 		for( cf = 0; cf < cubemap_faces; ++ cf )
 		{
 			/*	read the main image for this face	*/
-			getn( s, &dds_data[cf*s->img_x*s->img_y*s->img_n], s->img_x*s->img_y*s->img_n );
+			stbi__getn( s, &dds_data[cf*s->img_x*s->img_y*s->img_n], s->img_x*s->img_y*s->img_n );
 			/*	done reading and decoding the main image...
-				skip MIPmaps if present	*/
+				stbi__skip MIPmaps if present	*/
 			if( has_mipmap )
 			{
-				for( i = 1; i < header.dwMipMapCount; ++i )
+				for( i = 1; i < (int)header.dwMipMapCount; ++i )
 				{
 					int mx = s->img_x >> i;
 					int my = s->img_y >> i;
@@ -436,7 +507,7 @@ static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
 					{
 						my = 1;
 					}
-					skip( s, mx*my*s->img_n );
+					stbi__skip( s, mx*my*s->img_n );
 				}
 			}
 		}
@@ -468,15 +539,15 @@ static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
 		//	user has some requirements, meet them
 		if( req_comp != s->img_n )
 		{
-			dds_data = convert_format( dds_data, s->img_n, req_comp, s->img_x, s->img_y );
-			*comp = s->img_n;
+			dds_data = stbi__convert_format( dds_data, s->img_n, req_comp, s->img_x, s->img_y );
+			*comp = req_comp;
 		}
 	} else
 	{
 		//	user had no requirements, only drop to RGB is no alpha
 		if( (has_alpha == 0) && (s->img_n == 4) )
 		{
-			dds_data = convert_format( dds_data, 4, 3, s->img_x, s->img_y );
+			dds_data = stbi__convert_format( dds_data, 4, 3, s->img_x, s->img_y );
 			*comp = 3;
 		}
 	}
@@ -485,27 +556,34 @@ static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
 }
 
 #ifndef STBI_NO_STDIO
-stbi_uc *stbi_dds_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
+void *stbi__dds_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
 {
-	stbi s;
-   start_file(&s,f);
-   return dds_load(&s,x,y,comp,req_comp);
+	stbi__context s;
+	stbi__start_file(&s,f);
+	return stbi__dds_load(&s,x,y,comp,req_comp);
 }
 
-stbi_uc *stbi_dds_load             (char *filename,           int *x, int *y, int *comp, int req_comp)
+void *stbi__dds_load_from_path             (const char *filename,           int *x, int *y, int *comp, int req_comp)
 {
-   stbi_uc *data;
+   void *data;
    FILE *f = fopen(filename, "rb");
    if (!f) return NULL;
-   data = stbi_dds_load_from_file(f,x,y,comp,req_comp);
+   data = stbi__dds_load_from_file(f,x,y,comp,req_comp);
    fclose(f);
    return data;
 }
 #endif
 
-stbi_uc *stbi_dds_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+void *stbi__dds_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__dds_load(&s,x,y,comp,req_comp);
+}
+
+void *stbi__dds_load_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
 {
-	stbi s;
-   start_mem(&s,buffer, len);
-   return dds_load(&s,x,y,comp,req_comp);
+	stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__dds_load(&s,x,y,comp,req_comp);
 }
diff --git a/4dm.h/soil/stbi_ext.h b/4dm.h/soil/stbi_ext.h
new file mode 100644
index 0000000..de0ecc8
--- /dev/null
+++ b/4dm.h/soil/stbi_ext.h
@@ -0,0 +1,28 @@
+#ifndef HEADER_STB_IMAGE_EXT
+#define HEADER_STB_IMAGE_EXT
+
+enum {
+	STBI_unknown= 0,
+	STBI_jpeg	= 1,
+	STBI_png	= 2,
+	STBI_bmp	= 3,
+	STBI_gif	= 4,
+	STBI_tga	= 5,
+	STBI_psd	= 6,
+	STBI_pic	= 7,
+	STBI_pnm	= 8,
+	STBI_dds	= 9,
+	STBI_pvr	= 10,
+	STBI_pkm	= 11,
+	STBI_hdr	= 12
+};
+
+extern int      stbi_test_from_memory      (stbi_uc const *buffer, int len);
+extern int      stbi_test_from_callbacks   (stbi_io_callbacks const *clbk, void *user);
+
+#ifndef STBI_NO_STDIO
+extern int      stbi_test					(char const *filename);
+extern int      stbi_test_from_file        (FILE *f);
+#endif
+
+#endif /* HEADER_STB_IMAGE_EXT */
diff --git a/4dm.h/soil/stbi_ext_c.h b/4dm.h/soil/stbi_ext_c.h
new file mode 100644
index 0000000..224f436
--- /dev/null
+++ b/4dm.h/soil/stbi_ext_c.h
@@ -0,0 +1,74 @@
+
+static int stbi_test_main(stbi__context *s)
+{
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_test(s)) return STBI_jpeg;
+   #endif
+   #ifndef STBI_NO_PNG
+   if (stbi__png_test(s))  return STBI_png;
+   #endif
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_test(s))  return STBI_bmp;
+   #endif
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_test(s))  return STBI_gif;
+   #endif
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_test(s))  return STBI_psd;
+   #endif
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_test(s))  return STBI_pic;
+   #endif
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_test(s))  return STBI_pnm;
+   #endif
+   #ifndef STBI_NO_DDS
+   if (stbi__dds_test(s))  return STBI_dds;
+   #endif
+   #ifndef STBI_NO_PVR
+   if (stbi__pvr_test(s))  return STBI_pvr;
+   #endif
+   #ifndef STBI_NO_PKM
+   if (stbi__pkm_test(s))  return STBI_pkm;
+   #endif
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s))  return STBI_hdr;
+   #endif
+   #ifndef STBI_NO_TGA
+   if (stbi__tga_test(s))  return STBI_tga;
+   #endif
+   return STBI_unknown;
+}
+
+#ifndef STBI_NO_STDIO
+int stbi_test_from_file(FILE *f)
+{
+   stbi__context s;
+   stbi__start_file(&s,f);
+   return stbi_test_main(&s);
+}
+
+int stbi_test(char const *filename)
+{
+   FILE *f = fopen(filename, "rb");
+   int result;
+   if (!f) return STBI_unknown;
+   result = stbi_test_from_file(f);
+   fclose(f);
+   return result;
+}
+#endif //!STBI_NO_STDIO
+
+int stbi_test_from_memory(stbi_uc const *buffer, int len)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi_test_main(&s);
+}
+
+int stbi_test_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi_test_main(&s);
+}
diff --git a/4dm.h/soil/stbi_pkm.h b/4dm.h/soil/stbi_pkm.h
new file mode 100644
index 0000000..92f0640
--- /dev/null
+++ b/4dm.h/soil/stbi_pkm.h
@@ -0,0 +1,34 @@
+/*
+	adding PKM loading support to stbi
+*/
+
+#ifndef HEADER_STB_IMAGE_PKM_AUGMENTATION
+#define HEADER_STB_IMAGE_PKM_AUGMENTATION
+
+/*	is it a PKM file? */
+extern int      stbi__pkm_test_memory      (stbi_uc const *buffer, int len);
+extern int      stbi__pkm_test_callbacks   (stbi_io_callbacks const *clbk, void *user);
+
+extern void    *stbi__pkm_load_from_path   (char const *filename,           int *x, int *y, int *comp, int req_comp);
+extern void    *stbi__pkm_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+extern void    *stbi__pkm_load_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_STDIO
+extern int      stbi__pkm_test_filename    (char const *filename);
+extern int      stbi__pkm_test_file        (FILE *f);
+extern void    *stbi__pkm_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+#endif
+
+extern int      stbi__pkm_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+extern int      stbi__pkm_info_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+
+
+#ifndef STBI_NO_STDIO
+extern int      stbi__pkm_info_from_path   (char const *filename,     int *x, int *y, int *comp);
+extern int      stbi__pkm_info_from_file   (FILE *f,                  int *x, int *y, int *comp);
+#endif
+
+/*
+//
+////   end header file   /////////////////////////////////////////////////////*/
+#endif /* HEADER_STB_IMAGE_PKM_AUGMENTATION */
diff --git a/4dm.h/soil/stbi_pkm_c.h b/4dm.h/soil/stbi_pkm_c.h
new file mode 100644
index 0000000..b47c1f9
--- /dev/null
+++ b/4dm.h/soil/stbi_pkm_c.h
@@ -0,0 +1,220 @@
+#include "pkm_helper.h"
+#include "wfETC.h"
+
+static int stbi__pkm_test(stbi__context *s)
+{
+	//	check the magic number
+	if (stbi__get8(s) != 'P') {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	if (stbi__get8(s) != 'K') {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	if (stbi__get8(s) != 'M') {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	if (stbi__get8(s) != ' ') {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	if (stbi__get8(s) != '1') {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	if (stbi__get8(s) != '0') {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	stbi__rewind(s);
+	return 1;
+}
+
+#ifndef STBI_NO_STDIO
+
+int      stbi__pkm_test_filename        		(char const *filename)
+{
+   int r;
+   FILE *f = fopen(filename, "rb");
+   if (!f) return 0;
+   r = stbi__pkm_test_file(f);
+   fclose(f);
+   return r;
+}
+
+int      stbi__pkm_test_file        (FILE *f)
+{
+   stbi__context s;
+   int r,n = ftell(f);
+   stbi__start_file(&s,f);
+   r = stbi__pkm_test(&s);
+   fseek(f,n,SEEK_SET);
+   return r;
+}
+#endif
+
+int      stbi__pkm_test_memory      (stbi_uc const *buffer, int len)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer, len);
+   return stbi__pkm_test(&s);
+}
+
+int      stbi__pkm_test_callbacks      (stbi_io_callbacks const *clbk, void *user)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__pkm_test(&s);
+}
+
+static int stbi__pkm_info(stbi__context *s, int *x, int *y, int *comp )
+{
+	PKMHeader header;
+	unsigned int width, height;
+
+	stbi__getn( s, (stbi_uc*)(&header), sizeof(PKMHeader) );
+
+	if ( 0 != strcmp( header.aName, "PKM 10" ) ) {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	width = (header.iWidthMSB << 8) | header.iWidthLSB;
+	height = (header.iHeightMSB << 8) | header.iHeightLSB;
+
+	*x = s->img_x = width;
+	*y = s->img_y = height;
+	*comp = s->img_n = 3;
+
+	stbi__rewind(s);
+
+	return 1;
+}
+
+int stbi__pkm_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__pkm_info( &s, x, y, comp );
+}
+
+int stbi__pkm_info_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp)
+{
+	stbi__context s;
+	stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+	return stbi__pkm_info( &s, x, y, comp );
+}
+
+#ifndef STBI_NO_STDIO
+int stbi__pkm_info_from_path(char const *filename,     int *x, int *y, int *comp)
+{
+   int res;
+   FILE *f = fopen(filename, "rb");
+   if (!f) return 0;
+   res = stbi__pkm_info_from_file( f, x, y, comp );
+   fclose(f);
+   return res;
+}
+
+int stbi__pkm_info_from_file(FILE *f,                  int *x, int *y, int *comp)
+{
+   stbi__context s;
+   int res;
+   long n = ftell(f);
+   stbi__start_file(&s, f);
+   res = stbi__pkm_info(&s, x, y, comp);
+   fseek(f, n, SEEK_SET);
+   return res;
+}
+#endif
+
+static void * stbi__pkm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+	stbi_uc *pkm_data = NULL;
+	stbi_uc *pkm_res_data = NULL;
+	PKMHeader header;
+	unsigned int width;
+	unsigned int height;
+	unsigned int compressed_size;
+
+	stbi__getn( s, (stbi_uc*)(&header), sizeof(PKMHeader) );
+
+	if ( 0 != strcmp( header.aName, "PKM 10" ) ) {
+		return NULL;
+	}
+
+	width = (header.iWidthMSB << 8) | header.iWidthLSB;
+	height = (header.iHeightMSB << 8) | header.iHeightLSB;
+
+	*x = s->img_x = width;
+	*y = s->img_y = height;
+	*comp = s->img_n = 4;
+
+	compressed_size = (((width + 3) & ~3) * ((height + 3) & ~3)) >> 1;
+
+	pkm_data = (stbi_uc *)malloc(compressed_size);
+	stbi__getn( s, pkm_data, compressed_size );
+
+	pkm_res_data = (stbi_uc *)malloc(width * height * s->img_n);
+
+	wfETC1_DecodeImage(pkm_data, pkm_res_data, width, height);
+
+	free( pkm_data );
+
+	if ( NULL != pkm_res_data ) {
+		if( (req_comp < 4) && (req_comp >= 1) ) {
+			//	user has some requirements, meet them
+			if( req_comp != s->img_n ) {
+				pkm_res_data = stbi__convert_format( pkm_res_data, s->img_n, req_comp, s->img_x, s->img_y );
+				*comp = req_comp;
+			}
+		}
+
+		return (stbi_uc *)pkm_res_data;
+	} else {
+		free( pkm_res_data );
+	}
+
+	return NULL;
+}
+
+#ifndef STBI_NO_STDIO
+void *stbi__pkm_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
+{
+	stbi__context s;
+	stbi__start_file(&s,f);
+	return stbi__pkm_load(&s,x,y,comp,req_comp);
+}
+
+void *stbi__pkm_load_from_path             (char const*filename,           int *x, int *y, int *comp, int req_comp)
+{
+   void *data;
+   FILE *f = fopen(filename, "rb");
+   if (!f) return NULL;
+   data = stbi__pkm_load_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return data;
+}
+#endif
+
+void *stbi__pkm_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__pkm_load(&s,x,y,comp,req_comp);
+}
+
+void *stbi__pkm_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__pkm_load(&s,x,y,comp,req_comp);
+}
diff --git a/4dm.h/soil/stbi_pvr.h b/4dm.h/soil/stbi_pvr.h
new file mode 100644
index 0000000..e982715
--- /dev/null
+++ b/4dm.h/soil/stbi_pvr.h
@@ -0,0 +1,34 @@
+/*
+	adding PVR loading support to stbi
+*/
+
+#ifndef HEADER_STB_IMAGE_PVR_AUGMENTATION
+#define HEADER_STB_IMAGE_PVR_AUGMENTATION
+
+/*	is it a PVR file? */
+extern int      stbi__pvr_test_memory      (stbi_uc const *buffer, int len);
+extern int      stbi__pvr_test_callbacks   (stbi_io_callbacks const *clbk, void *user);
+
+extern void    *stbi__pvr_load_from_path   (char const *filename,           int *x, int *y, int *comp, int req_comp);
+extern void    *stbi__pvr_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+extern void    *stbi__pvr_load_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_STDIO
+extern int      stbi__pvr_test_filename    (char const *filename);
+extern int      stbi__pvr_test_file        (FILE *f);
+extern void    *stbi__pvr_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+#endif
+
+extern int      stbi__pvr_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int *iscompressed);
+extern int      stbi__pvr_info_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int *iscompressed);
+
+
+#ifndef STBI_NO_STDIO
+extern int      stbi__pvr_info_from_path   (char const *filename,     int *x, int *y, int *comp, int *iscompressed);
+extern int      stbi__pvr_info_from_file   (FILE *f,                  int *x, int *y, int *comp, int *iscompressed);
+#endif
+
+/*
+//
+////   end header file   /////////////////////////////////////////////////////*/
+#endif /* HEADER_STB_IMAGE_PVR_AUGMENTATION */
diff --git a/4dm.h/soil/stbi_pvr_c.h b/4dm.h/soil/stbi_pvr_c.h
new file mode 100644
index 0000000..9917465
--- /dev/null
+++ b/4dm.h/soil/stbi_pvr_c.h
@@ -0,0 +1,1001 @@
+#include "pvr_helper.h"
+
+static int stbi__pvr_test(stbi__context *s)
+{
+	//	check header size
+	if (stbi__get32le(s) != sizeof(PVR_Texture_Header)) {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	// stbi__skip until the magic number
+	stbi__skip(s, 10*4);
+
+	// check the magic number
+	if ( stbi__get32le(s) != PVRTEX_IDENTIFIER ) {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	// Also rewind because the loader needs to read the header
+	stbi__rewind(s);
+
+	return 1;
+}
+
+#ifndef STBI_NO_STDIO
+
+int      stbi__pvr_test_filename        		(char const *filename)
+{
+   int r;
+   FILE *f = fopen(filename, "rb");
+   if (!f) return 0;
+   r = stbi__pvr_test_file(f);
+   fclose(f);
+   return r;
+}
+
+int      stbi__pvr_test_file        (FILE *f)
+{
+   stbi__context s;
+   int r,n = ftell(f);
+   stbi__start_file(&s,f);
+   r = stbi__pvr_test(&s);
+   fseek(f,n,SEEK_SET);
+   return r;
+}
+#endif
+
+int      stbi__pvr_test_memory      (stbi_uc const *buffer, int len)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer, len);
+   return stbi__pvr_test(&s);
+}
+
+int      stbi__pvr_test_callbacks      (stbi_io_callbacks const *clbk, void *user)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__pvr_test(&s);
+}
+
+static int stbi__pvr_info(stbi__context *s, int *x, int *y, int *comp, int * iscompressed )
+{
+	PVR_Texture_Header header={0};
+
+	stbi__getn( s, (stbi_uc*)(&header), sizeof(PVR_Texture_Header) );
+
+	// Check the header size
+	if ( header.dwHeaderSize != sizeof(PVR_Texture_Header) ) {
+		stbi__rewind( s );
+		return 0;
+	}
+
+	// Check the magic identifier
+	if ( header.dwPVR != PVRTEX_IDENTIFIER ) {
+		stbi__rewind(s);
+		return 0;
+	}
+
+	*x = s->img_x = header.dwWidth;
+	*y = s->img_y = header.dwHeight;
+	*comp = s->img_n = ( header.dwBitCount + 7 ) / 8;
+
+	if ( iscompressed )
+		*iscompressed = 0;
+
+	switch ( header.dwpfFlags & PVRTEX_PIXELTYPE )
+	{
+		case OGL_RGBA_4444:
+			s->img_n = 2;
+			break;
+		case OGL_RGBA_5551:
+			s->img_n = 2;
+			break;
+		case OGL_RGBA_8888:
+			s->img_n = 4;
+			break;
+		case OGL_RGB_565:
+			s->img_n = 2;
+			break;
+		case OGL_RGB_888:
+			s->img_n = 3;
+			break;
+		case OGL_I_8:
+			s->img_n = 1;
+			break;
+		case OGL_AI_88:
+			s->img_n = 2;
+			break;
+		case OGL_PVRTC2:
+			s->img_n = 4;
+			if ( iscompressed )
+				*iscompressed = 1;
+			break;
+		case OGL_PVRTC4:
+			s->img_n = 4;
+			if ( iscompressed )
+				*iscompressed = 1;
+			break;
+		case OGL_RGB_555:
+		default:
+			stbi__rewind(s);
+			return 0;
+	}
+
+	*comp = s->img_n;
+
+	return 1;
+}
+
+int stbi__pvr_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int * iscompressed )
+{
+	stbi__context s;
+	stbi__start_mem(&s,buffer, len);
+	return stbi__pvr_info( &s, x, y, comp, iscompressed );
+}
+
+int stbi__pvr_info_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int * iscompressed)
+{
+	stbi__context s;
+	stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+	return stbi__pvr_info( &s, x, y, comp, iscompressed );
+}
+
+#ifndef STBI_NO_STDIO
+int stbi__pvr_info_from_path(char const *filename,     int *x, int *y, int *comp, int * iscompressed)
+{
+   int res;
+   FILE *f = fopen(filename, "rb");
+   if (!f) return 0;
+   res = stbi__pvr_info_from_file( f, x, y, comp, iscompressed );
+   fclose(f);
+   return res;
+}
+
+int stbi__pvr_info_from_file(FILE *f,                  int *x, int *y, int *comp, int * iscompressed)
+{
+   stbi__context s;
+   int res;
+   long n = ftell(f);
+   stbi__start_file(&s, f);
+   res = stbi__pvr_info(&s, x, y, comp, iscompressed);
+   fseek(f, n, SEEK_SET);
+   return res;
+}
+#endif
+
+/******************************************************************************
+ Taken from:
+ @File         PVRTDecompress.cpp
+ @Title        PVRTDecompress
+ @Copyright    Copyright (C)  Imagination Technologies Limited.
+ @Platform     ANSI compatible
+ @Description  PVRTC Texture Decompression.
+******************************************************************************/
+
+typedef unsigned char      PVRTuint8;
+typedef unsigned short     PVRTuint16;
+typedef unsigned int       PVRTuint32;
+
+/*****************************************************************************
+ * defines and consts
+ *****************************************************************************/
+#define PT_INDEX (2)	// The Punch-through index
+
+#define BLK_Y_SIZE 	(4) // always 4 for all 2D block types
+
+#define BLK_X_MAX	(8)	// Max X dimension for blocks
+
+#define BLK_X_2BPP	(8) // dimensions for the two formats
+#define BLK_X_4BPP	(4)
+
+#define WRAP_COORD(Val, Size) ((Val) & ((Size)-1))
+
+#define POWER_OF_2(X)   util_number_is_power_2(X)
+
+/*
+	Define an expression to either wrap or clamp large or small vals to the
+	legal coordinate range
+*/
+#define PVRT_MIN(a,b)            (((a) < (b)) ? (a) : (b))
+#define PVRT_MAX(a,b)            (((a) > (b)) ? (a) : (b))
+#define PVRT_CLAMP(x, l, h)      (PVRT_MIN((h), PVRT_MAX((x), (l))))
+
+#define LIMIT_COORD(Val, Size, AssumeImageTiles) \
+	  ((AssumeImageTiles)? WRAP_COORD((Val), (Size)): PVRT_CLAMP((Val), 0, (Size)-1))
+
+/*****************************************************************************
+ * Useful typedefs
+ *****************************************************************************/
+typedef PVRTuint32 U32;
+typedef PVRTuint8 U8;
+
+/***********************************************************
+				DECOMPRESSION ROUTINES
+************************************************************/
+
+/*!***********************************************************************
+ @Struct	AMTC_BLOCK_STRUCT
+ @Brief
+*************************************************************************/
+typedef struct
+{
+	// Uses 64 bits pre block
+	U32 PackedData[2];
+}AMTC_BLOCK_STRUCT;
+
+ /*!***********************************************************************
+  @Function		util_number_is_power_2
+  @Input		input A number
+  @Returns		TRUE if the number is an integer power of two, else FALSE.
+  @Description	Check that a number is an integer power of two, i.e.
+				1, 2, 4, 8, ... etc.
+				Returns FALSE for zero.
+*************************************************************************/
+int util_number_is_power_2( unsigned  input )
+{
+  unsigned minus1;
+
+  if( !input ) return 0;
+
+  minus1 = input - 1;
+  return ( (input | minus1) == (input ^ minus1) ) ? 1 : 0;
+}
+
+/*!***********************************************************************
+ @Function		Unpack5554Colour
+ @Input			pBlock
+ @Input			ABColours
+ @Description	Given a block, extract the colour information and convert
+				to 5554 formats
+*************************************************************************/
+static void Unpack5554Colour(const AMTC_BLOCK_STRUCT *pBlock,
+							 int   ABColours[2][4])
+{
+	U32 RawBits[2];
+
+	int i;
+
+	// Extract A and B
+	RawBits[0] = pBlock->PackedData[1] & (0xFFFE); // 15 bits (shifted up by one)
+	RawBits[1] = pBlock->PackedData[1] >> 16;	   // 16 bits
+
+	// step through both colours
+	for(i = 0; i < 2; i++)
+	{
+		// If completely opaque
+		if(RawBits[i] & (1<<15))
+		{
+			// Extract R and G (both 5 bit)
+			ABColours[i][0] = (RawBits[i] >> 10) & 0x1F;
+			ABColours[i][1] = (RawBits[i] >>  5) & 0x1F;
+
+			/*
+				The precision of Blue depends on  A or B. If A then we need to
+				replicate the top bit to get 5 bits in total
+			*/
+			ABColours[i][2] = RawBits[i] & 0x1F;
+			if(i==0)
+			{
+				ABColours[0][2] |= ABColours[0][2] >> 4;
+			}
+
+			// set 4bit alpha fully on...
+			ABColours[i][3] = 0xF;
+		}
+		else // Else if colour has variable translucency
+		{
+			/*
+				Extract R and G (both 4 bit).
+				(Leave a space on the end for the replication of bits
+			*/
+			ABColours[i][0] = (RawBits[i] >>  (8-1)) & 0x1E;
+			ABColours[i][1] = (RawBits[i] >>  (4-1)) & 0x1E;
+
+			// replicate bits to truly expand to 5 bits
+			ABColours[i][0] |= ABColours[i][0] >> 4;
+			ABColours[i][1] |= ABColours[i][1] >> 4;
+
+			// grab the 3(+padding) or 4 bits of blue and add an extra padding bit
+			ABColours[i][2] = (RawBits[i] & 0xF) << 1;
+
+			/*
+				expand from 3 to 5 bits if this is from colour A, or 4 to 5 bits if from
+				colour B
+			*/
+			if(i==0)
+			{
+				ABColours[0][2] |= ABColours[0][2] >> 3;
+			}
+			else
+			{
+				ABColours[0][2] |= ABColours[0][2] >> 4;
+			}
+
+			// Set the alpha bits to be 3 + a zero on the end
+			ABColours[i][3] = (RawBits[i] >> 11) & 0xE;
+		}
+	}
+}
+
+/*!***********************************************************************
+ @Function		UnpackModulations
+ @Input			pBlock
+ @Input			Do2bitMode
+ @Input			ModulationVals
+ @Input			ModulationModes
+ @Input			StartX
+ @Input			StartY
+ @Description	Given the block and the texture type and it's relative
+				position in the 2x2 group of blocks, extract the bit
+				patterns for the fully defined pixels.
+*************************************************************************/
+static void	UnpackModulations(const AMTC_BLOCK_STRUCT *pBlock,
+							  const int Do2bitMode,
+							  int ModulationVals[8][16],
+							  int ModulationModes[8][16],
+							  int StartX,
+							  int StartY)
+{
+	int BlockModMode;
+	U32 ModulationBits;
+
+	int x, y;
+
+	BlockModMode= pBlock->PackedData[1] & 1;
+	ModulationBits	= pBlock->PackedData[0];
+
+	// if it's in an interpolated mode
+	if(Do2bitMode && BlockModMode)
+	{
+		/*
+			run through all the pixels in the block. Note we can now treat all the
+			"stored" values as if they have 2bits (even when they didn't!)
+		*/
+		for(y = 0; y < BLK_Y_SIZE; y++)
+		{
+			for(x = 0; x < BLK_X_2BPP; x++)
+			{
+				ModulationModes[y+StartY][x+StartX] = BlockModMode;
+
+				// if this is a stored value...
+				if(((x^y)&1) == 0)
+				{
+					ModulationVals[y+StartY][x+StartX] = ModulationBits & 3;
+					ModulationBits >>= 2;
+				}
+			}
+		}
+	}
+	else if(Do2bitMode) // else if direct encoded 2bit mode - i.e. 1 mode bit per pixel
+	{
+		for(y = 0; y < BLK_Y_SIZE; y++)
+		{
+			for(x = 0; x < BLK_X_2BPP; x++)
+			{
+				ModulationModes[y+StartY][x+StartX] = BlockModMode;
+
+				// double the bits so 0=> 00, and 1=>11
+				if(ModulationBits & 1)
+				{
+					ModulationVals[y+StartY][x+StartX] = 0x3;
+				}
+				else
+				{
+					ModulationVals[y+StartY][x+StartX] = 0x0;
+				}
+				ModulationBits >>= 1;
+			}
+		}
+	}
+	else // else its the 4bpp mode so each value has 2 bits
+	{
+		for(y = 0; y < BLK_Y_SIZE; y++)
+		{
+			for(x = 0; x < BLK_X_4BPP; x++)
+			{
+				ModulationModes[y+StartY][x+StartX] = BlockModMode;
+
+				ModulationVals[y+StartY][x+StartX] = ModulationBits & 3;
+				ModulationBits >>= 2;
+			}
+		}
+	}
+
+	// make sure nothing is left over
+	assert(ModulationBits==0);
+}
+
+/*!***********************************************************************
+ @Function		InterpolateColours
+ @Input			ColourP
+ @Input			ColourQ
+ @Input			ColourR
+ @Input			ColourS
+ @Input			Do2bitMode
+ @Input			x
+ @Input			y
+ @Modified		Result
+ @Description	This performs a HW bit accurate interpolation of either the
+				A or B colours for a particular pixel.
+
+				NOTE: It is assumed that the source colours are in ARGB 5554
+				format - This means that some "preparation" of the values will
+				be necessary.
+*************************************************************************/
+static void InterpolateColours(const int ColourP[4],
+						  const int ColourQ[4],
+						  const int ColourR[4],
+						  const int ColourS[4],
+						  const int Do2bitMode,
+						  const int x,
+						  const int y,
+						  int Result[4])
+{
+	int u, v, uscale;
+	int k;
+
+	int tmp1, tmp2;
+
+	int P[4], Q[4], R[4], S[4];
+
+	// Copy the colours
+	for(k = 0; k < 4; k++)
+	{
+		P[k] = ColourP[k];
+		Q[k] = ColourQ[k];
+		R[k] = ColourR[k];
+		S[k] = ColourS[k];
+	}
+
+	// put the x and y values into the right range
+	v = (y & 0x3) | ((~y & 0x2) << 1);
+
+	if(Do2bitMode)
+		u = (x & 0x7) | ((~x & 0x4) << 1);
+	else
+		u = (x & 0x3) | ((~x & 0x2) << 1);
+
+	// get the u and v scale amounts
+	v  = v - BLK_Y_SIZE/2;
+
+	if(Do2bitMode)
+	{
+		u = u - BLK_X_2BPP/2;
+		uscale = 8;
+	}
+	else
+	{
+		u = u - BLK_X_4BPP/2;
+		uscale = 4;
+	}
+
+	for(k = 0; k < 4; k++)
+	{
+		tmp1 = P[k] * uscale + u * (Q[k] - P[k]);
+		tmp2 = R[k] * uscale + u * (S[k] - R[k]);
+
+		tmp1 = tmp1 * 4 + v * (tmp2 - tmp1);
+
+		Result[k] = tmp1;
+	}
+
+	// Lop off the appropriate number of bits to get us to 8 bit precision
+	if(Do2bitMode)
+	{
+		// do RGB
+		for(k = 0; k < 3; k++)
+		{
+			Result[k] >>= 2;
+		}
+
+		Result[3] >>= 1;
+	}
+	else
+	{
+		// do RGB  (A is ok)
+		for(k = 0; k < 3; k++)
+		{
+			Result[k] >>= 1;
+		}
+	}
+
+	// sanity check
+	for(k = 0; k < 4; k++)
+	{
+		assert(Result[k] < 256);
+	}
+
+
+	/*
+		Convert from 5554 to 8888
+
+		do RGB 5.3 => 8
+	*/
+	for(k = 0; k < 3; k++)
+	{
+		Result[k] += Result[k] >> 5;
+	}
+
+	Result[3] += Result[3] >> 4;
+
+	// 2nd sanity check
+	for(k = 0; k < 4; k++)
+	{
+		assert(Result[k] < 256);
+	}
+
+}
+
+/*!***********************************************************************
+ @Function		GetModulationValue
+ @Input			x
+ @Input			y
+ @Input			Do2bitMode
+ @Input			ModulationVals
+ @Input			ModulationModes
+ @Input			Mod
+ @Input			DoPT
+ @Description	Get the modulation value as a numerator of a fraction of 8ths
+*************************************************************************/
+static void GetModulationValue(int x,
+							   int y,
+							   const int Do2bitMode,
+							   const int ModulationVals[8][16],
+							   const int ModulationModes[8][16],
+							   int *Mod,
+							   int *DoPT)
+{
+	static const int RepVals0[4] = {0, 3, 5, 8};
+	static const int RepVals1[4] = {0, 4, 4, 8};
+
+	int ModVal;
+
+	// Map X and Y into the local 2x2 block
+	y = (y & 0x3) | ((~y & 0x2) << 1);
+
+	if(Do2bitMode)
+		x = (x & 0x7) | ((~x & 0x4) << 1);
+	else
+		x = (x & 0x3) | ((~x & 0x2) << 1);
+
+	// assume no PT for now
+	*DoPT = 0;
+
+	// extract the modulation value. If a simple encoding
+	if(ModulationModes[y][x]==0)
+	{
+		ModVal = RepVals0[ModulationVals[y][x]];
+	}
+	else if(Do2bitMode)
+	{
+		// if this is a stored value
+		if(((x^y)&1)==0)
+			ModVal = RepVals0[ModulationVals[y][x]];
+		else if(ModulationModes[y][x] == 1) // else average from the neighbours if H&V interpolation..
+		{
+			ModVal = (RepVals0[ModulationVals[y-1][x]] +
+					  RepVals0[ModulationVals[y+1][x]] +
+					  RepVals0[ModulationVals[y][x-1]] +
+					  RepVals0[ModulationVals[y][x+1]] + 2) / 4;
+		}
+		else if(ModulationModes[y][x] == 2) // else if H-Only
+		{
+			ModVal = (RepVals0[ModulationVals[y][x-1]] +
+					  RepVals0[ModulationVals[y][x+1]] + 1) / 2;
+		}
+		else // else it's V-Only
+		{
+			ModVal = (RepVals0[ModulationVals[y-1][x]] +
+					  RepVals0[ModulationVals[y+1][x]] + 1) / 2;
+		}
+	}
+	else // else it's 4BPP and PT encoding
+	{
+		ModVal = RepVals1[ModulationVals[y][x]];
+
+		*DoPT = ModulationVals[y][x] == PT_INDEX;
+	}
+
+	*Mod =ModVal;
+}
+
+/*!***********************************************************************
+ @Function		TwiddleUV
+ @Input			YSize	Y dimension of the texture in pixels
+ @Input			XSize	X dimension of the texture in pixels
+ @Input			YPos	Pixel Y position
+ @Input			XPos	Pixel X position
+ @Returns		The twiddled offset of the pixel
+ @Description	Given the Block (or pixel) coordinates and the dimension of
+				the texture in blocks (or pixels) this returns the twiddled
+				offset of the block (or pixel) from the start of the map.
+
+				NOTE the dimensions of the texture must be a power of 2
+*************************************************************************/
+static int DisableTwiddlingRoutine = 0;
+
+static U32 TwiddleUV(U32 YSize, U32 XSize, U32 YPos, U32 XPos)
+{
+	U32 Twiddled;
+
+	U32 MinDimension;
+	U32 MaxValue;
+
+	U32 SrcBitPos;
+	U32 DstBitPos;
+
+	int ShiftCount;
+
+	assert(YPos < YSize);
+	assert(XPos < XSize);
+
+	assert(POWER_OF_2(YSize));
+	assert(POWER_OF_2(XSize));
+
+	if(YSize < XSize)
+	{
+		MinDimension = YSize;
+		MaxValue	 = XPos;
+	}
+	else
+	{
+		MinDimension = XSize;
+		MaxValue	 = YPos;
+	}
+
+	// Nasty hack to disable twiddling
+	if(DisableTwiddlingRoutine)
+		return (YPos* XSize + XPos);
+
+	// Step through all the bits in the "minimum" dimension
+	SrcBitPos = 1;
+	DstBitPos = 1;
+	Twiddled  = 0;
+	ShiftCount = 0;
+
+	while(SrcBitPos < MinDimension)
+	{
+		if(YPos & SrcBitPos)
+		{
+			Twiddled |= DstBitPos;
+		}
+
+		if(XPos & SrcBitPos)
+		{
+			Twiddled |= (DstBitPos << 1);
+		}
+
+
+		SrcBitPos <<= 1;
+		DstBitPos <<= 2;
+		ShiftCount += 1;
+
+	}
+
+	// prepend any unused bits
+	MaxValue >>= ShiftCount;
+
+	Twiddled |=  (MaxValue << (2*ShiftCount));
+
+	return Twiddled;
+}
+
+/***********************************************************/
+/*
+// Decompress
+//
+// Takes the compressed input data and outputs the equivalent decompressed
+// image.
+*/
+/***********************************************************/
+
+static void Decompress(AMTC_BLOCK_STRUCT *pCompressedData,
+					   const int Do2bitMode,
+					   const int XDim,
+					   const int YDim,
+					   const int AssumeImageTiles,
+					   unsigned char* pResultImage)
+{
+	int x, y;
+	int i, j;
+
+	int BlkX, BlkY;
+	int BlkXp1, BlkYp1;
+	int XBlockSize;
+	int BlkXDim, BlkYDim;
+
+	int StartX, StartY;
+
+	int ModulationVals[8][16];
+	int ModulationModes[8][16];
+
+	int Mod, DoPT;
+
+	unsigned int uPosition;
+
+	/*
+	// local neighbourhood of blocks
+	*/
+	AMTC_BLOCK_STRUCT *pBlocks[2][2];
+
+	AMTC_BLOCK_STRUCT *pPrevious[2][2] = {{NULL, NULL}, {NULL, NULL}};
+
+	/*
+	// Low precision colours extracted from the blocks
+	*/
+	struct
+	{
+		int Reps[2][4];
+	}Colours5554[2][2];
+
+	/*
+	// Interpolated A and B colours for the pixel
+	*/
+	int ASig[4], BSig[4];
+
+	int Result[4];
+
+	if(Do2bitMode)
+	{
+		XBlockSize = BLK_X_2BPP;
+	}
+	else
+	{
+		XBlockSize = BLK_X_4BPP;
+	}
+
+
+	/*
+	// For MBX don't allow the sizes to get too small
+	*/
+	BlkXDim = PVRT_MAX(2, XDim / XBlockSize);
+	BlkYDim = PVRT_MAX(2, YDim / BLK_Y_SIZE);
+
+	/*
+	// Step through the pixels of the image decompressing each one in turn
+	//
+	// Note that this is a hideously inefficient way to do this!
+	*/
+	for(y = 0; y < YDim; y++)
+	{
+		for(x = 0; x < XDim; x++)
+		{
+			/*
+			// map this pixel to the top left neighbourhood of blocks
+			*/
+			BlkX = (x - XBlockSize/2);
+			BlkY = (y - BLK_Y_SIZE/2);
+
+			BlkX = LIMIT_COORD(BlkX, XDim, AssumeImageTiles);
+			BlkY = LIMIT_COORD(BlkY, YDim, AssumeImageTiles);
+
+
+			BlkX /= XBlockSize;
+			BlkY /= BLK_Y_SIZE;
+
+			//BlkX = LIMIT_COORD(BlkX, BlkXDim, AssumeImageTiles);
+			//BlkY = LIMIT_COORD(BlkY, BlkYDim, AssumeImageTiles);
+
+
+			/*
+			// compute the positions of the other 3 blocks
+			*/
+			BlkXp1 = LIMIT_COORD(BlkX+1, BlkXDim, AssumeImageTiles);
+			BlkYp1 = LIMIT_COORD(BlkY+1, BlkYDim, AssumeImageTiles);
+
+			/*
+			// Map to block memory locations
+			*/
+			pBlocks[0][0] = pCompressedData +TwiddleUV(BlkYDim, BlkXDim, BlkY, BlkX);
+			pBlocks[0][1] = pCompressedData +TwiddleUV(BlkYDim, BlkXDim, BlkY, BlkXp1);
+			pBlocks[1][0] = pCompressedData +TwiddleUV(BlkYDim, BlkXDim, BlkYp1, BlkX);
+			pBlocks[1][1] = pCompressedData +TwiddleUV(BlkYDim, BlkXDim, BlkYp1, BlkXp1);
+
+
+			/*
+			// extract the colours and the modulation information IF the previous values
+			// have changed.
+			*/
+			if(memcmp(pPrevious, pBlocks, 4*sizeof(void*)) != 0)
+			{
+				StartY = 0;
+				for(i = 0; i < 2; i++)
+				{
+					StartX = 0;
+					for(j = 0; j < 2; j++)
+					{
+						Unpack5554Colour(pBlocks[i][j], Colours5554[i][j].Reps);
+
+						UnpackModulations(pBlocks[i][j],
+							Do2bitMode,
+							ModulationVals,
+							ModulationModes,
+							StartX, StartY);
+
+						StartX += XBlockSize;
+					}/*end for j*/
+
+					StartY += BLK_Y_SIZE;
+				}/*end for i*/
+
+				/*
+				// make a copy of the new pointers
+				*/
+				memcpy(pPrevious, pBlocks, 4*sizeof(void*));
+			}/*end if the blocks have changed*/
+
+
+			/*
+			// decompress the pixel.  First compute the interpolated A and B signals
+			*/
+			InterpolateColours(Colours5554[0][0].Reps[0],
+				Colours5554[0][1].Reps[0],
+				Colours5554[1][0].Reps[0],
+				Colours5554[1][1].Reps[0],
+				Do2bitMode, x, y,
+				ASig);
+
+			InterpolateColours(Colours5554[0][0].Reps[1],
+				Colours5554[0][1].Reps[1],
+				Colours5554[1][0].Reps[1],
+				Colours5554[1][1].Reps[1],
+				Do2bitMode, x, y,
+				BSig);
+
+			GetModulationValue(x,y, Do2bitMode, (const int (*)[16])ModulationVals, (const int (*)[16])ModulationModes,
+				&Mod, &DoPT);
+
+			/*
+			// compute the modulated colour
+			*/
+			for(i = 0; i < 4; i++)
+			{
+				Result[i] = ASig[i] * 8 + Mod * (BSig[i] - ASig[i]);
+				Result[i] >>= 3;
+			}
+			if(DoPT)
+			{
+				Result[3] = 0;
+			}
+
+			/*
+			// Store the result in the output image
+			*/
+			uPosition = (x+y*XDim)<<2;
+			pResultImage[uPosition+0] = (unsigned char)Result[0];
+			pResultImage[uPosition+1] = (unsigned char)Result[1];
+			pResultImage[uPosition+2] = (unsigned char)Result[2];
+			pResultImage[uPosition+3] = (unsigned char)Result[3];
+
+		}/*end for x*/
+	}/*end for y*/
+
+}
+
+static void * stbi__pvr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+	stbi_uc *pvr_data = NULL;
+	stbi_uc *pvr_res_data = NULL;
+	PVR_Texture_Header header={0};
+	int iscompressed = 0;
+	int bitmode = 0;
+	unsigned int levelSize = 0;
+
+	stbi__getn( s, (stbi_uc*)(&header), sizeof(PVR_Texture_Header) );
+
+	// Check the header size
+	if ( header.dwHeaderSize != sizeof(PVR_Texture_Header) ) {
+		return NULL;
+	}
+
+	// Check the magic identifier
+	if ( header.dwPVR != PVRTEX_IDENTIFIER ) {
+		return NULL;
+	}
+
+	*x = s->img_x = header.dwWidth;
+	*y = s->img_y = header.dwHeight;
+
+	/* Get if the texture is compressed and the texture mode ( 2bpp or 4bpp ) */
+	switch ( header.dwpfFlags & PVRTEX_PIXELTYPE )
+	{
+		case OGL_RGBA_4444:
+			s->img_n = 2;
+			break;
+		case OGL_RGBA_5551:
+			s->img_n = 2;
+			break;
+		case OGL_RGBA_8888:
+			s->img_n = 4;
+			break;
+		case OGL_RGB_565:
+			s->img_n = 2;
+			break;
+		case OGL_RGB_888:
+			s->img_n = 3;
+			break;
+		case OGL_I_8:
+			s->img_n = 1;
+			break;
+		case OGL_AI_88:
+			s->img_n = 2;
+			break;
+		case OGL_PVRTC2:
+			bitmode = 1;
+			s->img_n = 4;
+			iscompressed = 1;
+			break;
+		case OGL_PVRTC4:
+			s->img_n = 4;
+			iscompressed = 1;
+			break;
+		case OGL_RGB_555:
+		default:
+			return NULL;
+	}
+
+	*comp = s->img_n;
+
+	// Load only the first mip map level
+	levelSize = (s->img_x * s->img_y * header.dwBitCount + 7) / 8;
+
+	// get the raw data
+	pvr_data = (stbi_uc *)malloc( levelSize );
+	stbi__getn( s, pvr_data, levelSize );
+
+	// if compressed decompress as RGBA
+	if ( iscompressed ) {
+		pvr_res_data = (stbi_uc *)malloc( s->img_x * s->img_y * 4 );
+		Decompress( (AMTC_BLOCK_STRUCT*)pvr_data, bitmode, s->img_x, s->img_y, 1, (unsigned char*)pvr_res_data );
+		free( pvr_data );
+	} else {
+		// otherwise use the raw data
+		pvr_res_data = pvr_data;
+	}
+
+	if( (req_comp <= 4) && (req_comp >= 1) ) {
+		//	user has some requirements, meet them
+		if( req_comp != s->img_n ) {
+			pvr_res_data = stbi__convert_format( pvr_res_data, s->img_n, req_comp, s->img_x, s->img_y );
+			*comp = req_comp;
+		}
+	}
+
+	return pvr_res_data;
+}
+
+#ifndef STBI_NO_STDIO
+void *stbi__pvr_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
+{
+	stbi__context s;
+	stbi__start_file(&s,f);
+	return stbi__pvr_load(&s,x,y,comp,req_comp);
+}
+
+void *stbi__pvr_load_from_path             (char const*filename,           int *x, int *y, int *comp, int req_comp)
+{
+   void *data;
+   FILE *f = fopen(filename, "rb");
+   if (!f) return NULL;
+   data = stbi__pvr_load_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return data;
+}
+#endif
+
+void *stbi__pvr_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__pvr_load(&s,x,y,comp,req_comp);
+}
+
+void *stbi__pvr_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__pvr_load(&s,x,y,comp,req_comp);
+}
diff --git a/4dm.h/soil/test_SOIL.cpp b/4dm.h/soil/test_SOIL.cpp
deleted file mode 100644
index 44775c5..0000000
--- a/4dm.h/soil/test_SOIL.cpp
+++ /dev/null
@@ -1,379 +0,0 @@
-#include <string>
-#include <iostream>
-
-#include <windows.h>
-#include <shellapi.h>
-#include <gl/gl.h>
-#include <gl/glext.h>
-
-#include "SOIL.h"
-
-LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);
-void EnableOpenGL(HWND hwnd, HDC*, HGLRC*);
-void DisableOpenGL(HWND, HDC, HGLRC);
-
-int WINAPI WinMain(HINSTANCE hInstance,
-                   HINSTANCE hPrevInstance,
-                   LPSTR lpCmdLine,
-                   int nCmdShow)
-{
-    WNDCLASSEX wcex;
-    HWND hwnd;
-    HDC hDC;
-    HGLRC hRC;
-    MSG msg;
-    BOOL bQuit = FALSE;
-    float theta = 0.0f;
-
-    // register window class
-    wcex.cbSize = sizeof(WNDCLASSEX);
-    wcex.style = CS_OWNDC;
-    wcex.lpfnWndProc = WindowProc;
-    wcex.cbClsExtra = 0;
-    wcex.cbWndExtra = 0;
-    wcex.hInstance = hInstance;
-    wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
-    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
-    wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
-    wcex.lpszMenuName = NULL;
-    wcex.lpszClassName = "GLSample";
-    wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
-
-
-    if (!RegisterClassEx(&wcex))
-        return 0;
-
-    // create main window
-    hwnd = CreateWindowEx(0,
-                          "GLSample",
-                          "SOIL Sample",
-                          WS_OVERLAPPEDWINDOW,
-                          CW_USEDEFAULT,
-                          CW_USEDEFAULT,
-                          512,
-                          512,
-                          NULL,
-                          NULL,
-                          hInstance,
-                          NULL);
-
-    ShowWindow(hwnd, nCmdShow);
-
-    //	check my error handling
-    /*
-    SOIL_load_OGL_texture( "img_test.png", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, 0 );
-    std::cout << "'" << SOIL_last_result() << "'" << std::endl;
-    */
-
-
-    // enable OpenGL for the window
-    EnableOpenGL(hwnd, &hDC, &hRC);
-
-    glEnable( GL_BLEND );
-    //glDisable( GL_BLEND );
-    //	straight alpha
-    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
-    //	premultiplied alpha (remember to do the same in glColor!!)
-    //glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
-
-    //	do I want alpha thresholding?
-    glEnable( GL_ALPHA_TEST );
-    glAlphaFunc( GL_GREATER, 0.5f );
-
-    //	log what the use is asking us to load
-    std::string load_me = lpCmdLine;
-    if( load_me.length() > 2 )
-    {
-		//load_me = load_me.substr( 1, load_me.length() - 2 );
-		load_me = load_me.substr( 0, load_me.length() - 0 );
-    } else
-    {
-    	//load_me = "img_test_uncompressed.dds";
-    	//load_me = "img_test_indexed.tga";
-    	//load_me = "img_test.dds";
-    	load_me = "img_test.png";
-    	//load_me = "odd_size.jpg";
-    	//load_me = "img_cheryl.jpg";
-    	//load_me = "oak_odd.png";
-    	//load_me = "field_128_cube.dds";
-    	//load_me = "field_128_cube_nomip.dds";
-    	//load_me = "field_128_cube_uc.dds";
-    	//load_me = "field_128_cube_uc_nomip.dds";
-    	//load_me = "Goblin.dds";
-    	//load_me = "parquet.dds";
-    	//load_me = "stpeters_probe.hdr";
-    	//load_me = "VeraMoBI_sdf.png";
-
-    	//	for testing the texture rectangle code
-    	//load_me = "test_rect.png";
-    }
-	std::cout << "'" << load_me << "'" << std::endl;
-
-	//	1st try to load it as a single-image-cubemap
-	//	(note, need DDS ordered faces: "EWUDNS")
-	GLuint tex_ID;
-    int time_me;
-
-    std::cout << "Attempting to load as a cubemap" << std::endl;
-    time_me = clock();
-	tex_ID = SOIL_load_OGL_single_cubemap(
-			load_me.c_str(),
-			SOIL_DDS_CUBEMAP_FACE_ORDER,
-			SOIL_LOAD_AUTO,
-			SOIL_CREATE_NEW_ID,
-			SOIL_FLAG_POWER_OF_TWO
-			| SOIL_FLAG_MIPMAPS
-			//| SOIL_FLAG_COMPRESS_TO_DXT
-			//| SOIL_FLAG_TEXTURE_REPEATS
-			//| SOIL_FLAG_INVERT_Y
-			| SOIL_FLAG_DDS_LOAD_DIRECT
-			);
-	time_me = clock() - time_me;
-	std::cout << "the load time was " << 0.001f * time_me << " seconds (warning: low resolution timer)" << std::endl;
-    if( tex_ID > 0 )
-    {
-    	glEnable( GL_TEXTURE_CUBE_MAP );
-		glEnable( GL_TEXTURE_GEN_S );
-		glEnable( GL_TEXTURE_GEN_T );
-		glEnable( GL_TEXTURE_GEN_R );
-		glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
-		glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
-		glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
-		glBindTexture( GL_TEXTURE_CUBE_MAP, tex_ID );
-		//	report
-		std::cout << "the loaded single cube map ID was " << tex_ID << std::endl;
-		//std::cout << "the load time was " << 0.001f * time_me << " seconds (warning: low resolution timer)" << std::endl;
-    } else
-    {
-    	std::cout << "Attempting to load as a HDR texture" << std::endl;
-		time_me = clock();
-		tex_ID = SOIL_load_OGL_HDR_texture(
-				load_me.c_str(),
-				//SOIL_HDR_RGBE,
-				//SOIL_HDR_RGBdivA,
-				SOIL_HDR_RGBdivA2,
-				0,
-				SOIL_CREATE_NEW_ID,
-				SOIL_FLAG_POWER_OF_TWO
-				| SOIL_FLAG_MIPMAPS
-				//| SOIL_FLAG_COMPRESS_TO_DXT
-				);
-		time_me = clock() - time_me;
-		std::cout << "the load time was " << 0.001f * time_me << " seconds (warning: low resolution timer)" << std::endl;
-
-		//	did I fail?
-		if( tex_ID < 1 )
-		{
-			//	loading of the single-image-cubemap failed, try it as a simple texture
-			std::cout << "Attempting to load as a simple 2D texture" << std::endl;
-			//	load the texture, if specified
-			time_me = clock();
-			tex_ID = SOIL_load_OGL_texture(
-					load_me.c_str(),
-					SOIL_LOAD_AUTO,
-					SOIL_CREATE_NEW_ID,
-					SOIL_FLAG_POWER_OF_TWO
-					| SOIL_FLAG_MIPMAPS
-					//| SOIL_FLAG_MULTIPLY_ALPHA
-					//| SOIL_FLAG_COMPRESS_TO_DXT
-					| SOIL_FLAG_DDS_LOAD_DIRECT
-					//| SOIL_FLAG_NTSC_SAFE_RGB
-					//| SOIL_FLAG_CoCg_Y
-					//| SOIL_FLAG_TEXTURE_RECTANGLE
-					);
-			time_me = clock() - time_me;
-			std::cout << "the load time was " << 0.001f * time_me << " seconds (warning: low resolution timer)" << std::endl;
-		}
-
-		if( tex_ID > 0 )
-		{
-			//	enable texturing
-			glEnable( GL_TEXTURE_2D );
-			//glEnable( 0x84F5 );// enables texture rectangle
-			//  bind an OpenGL texture ID
-			glBindTexture( GL_TEXTURE_2D, tex_ID );
-			//	report
-			std::cout << "the loaded texture ID was " << tex_ID << std::endl;
-			//std::cout << "the load time was " << 0.001f * time_me << " seconds (warning: low resolution timer)" << std::endl;
-		} else
-		{
-			//	loading of the texture failed...why?
-			glDisable( GL_TEXTURE_2D );
-			std::cout << "Texture loading failed: '" << SOIL_last_result() << "'" << std::endl;
-		}
-    }
-
-    // program main loop
-    const float ref_mag = 0.1f;
-    while (!bQuit)
-    {
-        // check for messages
-        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
-        {
-            // handle or dispatch messages
-            if (msg.message == WM_QUIT)
-            {
-                bQuit = TRUE;
-            }
-            else
-            {
-                TranslateMessage(&msg);
-                DispatchMessage(&msg);
-            }
-        }
-        else
-        {
-            // OpenGL animation code goes here
-            theta = clock() * 0.1;
-
-            float tex_u_max = 1.0f;//0.2f;
-            float tex_v_max = 1.0f;//0.2f;
-
-            glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-            glClear(GL_COLOR_BUFFER_BIT);
-
-            glPushMatrix();
-            glScalef( 0.8f, 0.8f, 0.8f );
-            //glRotatef(-0.314159f*theta, 0.0f, 0.0f, 1.0f);
-			glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
-			glNormal3f( 0.0f, 0.0f, 1.0f );
-            glBegin(GL_QUADS);
-				glNormal3f( -ref_mag, -ref_mag, 1.0f );
-                glTexCoord2f( 0.0f, tex_v_max );
-                glVertex3f( -1.0f, -1.0f, -0.1f );
-
-                glNormal3f( ref_mag, -ref_mag, 1.0f );
-                glTexCoord2f( tex_u_max, tex_v_max );
-                glVertex3f( 1.0f, -1.0f, -0.1f );
-
-                glNormal3f( ref_mag, ref_mag, 1.0f );
-                glTexCoord2f( tex_u_max, 0.0f );
-                glVertex3f( 1.0f, 1.0f, -0.1f );
-
-                glNormal3f( -ref_mag, ref_mag, 1.0f );
-                glTexCoord2f( 0.0f, 0.0f );
-                glVertex3f( -1.0f, 1.0f, -0.1f );
-            glEnd();
-            glPopMatrix();
-
-			tex_u_max = 1.0f;
-            tex_v_max = 1.0f;
-            glPushMatrix();
-            glScalef( 0.8f, 0.8f, 0.8f );
-            glRotatef(theta, 0.0f, 0.0f, 1.0f);
-			glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
-			glNormal3f( 0.0f, 0.0f, 1.0f );
-            glBegin(GL_QUADS);
-                glTexCoord2f( 0.0f, tex_v_max );		glVertex3f( 0.0f, 0.0f, 0.1f );
-                glTexCoord2f( tex_u_max, tex_v_max );		glVertex3f( 1.0f, 0.0f, 0.1f );
-                glTexCoord2f( tex_u_max, 0.0f );		glVertex3f( 1.0f, 1.0f, 0.1f );
-                glTexCoord2f( 0.0f, 0.0f );		glVertex3f( 0.0f, 1.0f, 0.1f );
-            glEnd();
-            glPopMatrix();
-
-            {
-				/*	check for errors	*/
-				GLenum err_code = glGetError();
-				while( GL_NO_ERROR != err_code )
-				{
-					printf( "OpenGL Error @ %s: %i", "drawing loop", err_code );
-					err_code = glGetError();
-				}
-			}
-
-            SwapBuffers(hDC);
-
-            Sleep (1);
-        }
-    }
-
-    //	and show off the screenshot capability
-    /*
-    load_me += "-screenshot.tga";
-    SOIL_save_screenshot( load_me.c_str(), SOIL_SAVE_TYPE_TGA, 0, 0, 512, 512 );
-    //*/
-    //*
-    load_me += "-screenshot.bmp";
-    SOIL_save_screenshot( load_me.c_str(), SOIL_SAVE_TYPE_BMP, 0, 0, 512, 512 );
-    //*/
-    /*
-    load_me += "-screenshot.dds";
-    SOIL_save_screenshot( load_me.c_str(), SOIL_SAVE_TYPE_DDS, 0, 0, 512, 512 );
-    //*/
-
-    // shutdown OpenGL
-    DisableOpenGL(hwnd, hDC, hRC);
-
-    // destroy the window explicitly
-    DestroyWindow(hwnd);
-
-    return msg.wParam;
-}
-
-LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
-{
-    switch (uMsg)
-    {
-        case WM_CLOSE:
-            PostQuitMessage(0);
-        break;
-
-        case WM_DESTROY:
-            return 0;
-
-        case WM_KEYDOWN:
-        {
-            switch (wParam)
-            {
-                case VK_ESCAPE:
-                    PostQuitMessage(0);
-                break;
-            }
-        }
-        break;
-
-        default:
-            return DefWindowProc(hwnd, uMsg, wParam, lParam);
-    }
-
-    return 0;
-}
-
-void EnableOpenGL(HWND hwnd, HDC* hDC, HGLRC* hRC)
-{
-    PIXELFORMATDESCRIPTOR pfd;
-
-    int iFormat;
-
-    /* get the device context (DC) */
-    *hDC = GetDC(hwnd);
-
-    /* set the pixel format for the DC */
-    ZeroMemory(&pfd, sizeof(pfd));
-
-    pfd.nSize = sizeof(pfd);
-    pfd.nVersion = 1;
-    pfd.dwFlags = PFD_DRAW_TO_WINDOW |
-                  PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
-    pfd.iPixelType = PFD_TYPE_RGBA;
-    pfd.cColorBits = 24;
-    pfd.cDepthBits = 16;
-    pfd.iLayerType = PFD_MAIN_PLANE;
-
-    iFormat = ChoosePixelFormat(*hDC, &pfd);
-
-    SetPixelFormat(*hDC, iFormat, &pfd);
-
-    /* create and enable the render context (RC) */
-    *hRC = wglCreateContext(*hDC);
-
-    wglMakeCurrent(*hDC, *hRC);
-}
-
-void DisableOpenGL (HWND hwnd, HDC hDC, HGLRC hRC)
-{
-    wglMakeCurrent(NULL, NULL);
-    wglDeleteContext(hRC);
-    ReleaseDC(hwnd, hDC);
-}
-
diff --git a/4dm.h/soil/wfETC.c b/4dm.h/soil/wfETC.c
new file mode 100644
index 0000000..70d6ab2
--- /dev/null
+++ b/4dm.h/soil/wfETC.c
@@ -0,0 +1,228 @@
+
+#include "wfETC.h"
+
+// specification: http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_RGB8_texture.txt
+
+#ifdef WF_LITTLE_ENDIAN
+	#define WF_ETC1_COLOR_OFFSET( offset ) ( (64-(offset)) - (4-((offset)%8))*2 )
+	#define WF_ETC1_PIXEL_OFFSET( offset ) ( (32-(offset)) - (4-((offset)%8))*2 )
+#else
+	#define WF_ETC1_COLOR_OFFSET( offset ) (offset-32)
+	#define WF_ETC1_PIXEL_OFFSET( offset ) offset
+#endif
+
+#define WF_INLINE
+#define WF_ASSUME( expr )
+
+#ifndef WF_EXPECT
+	#if defined __GNUC__ && __GNUC__
+		#define WF_EXPECT( expr, val ) __builtin_expect( expr, val )
+	#else
+		#define WF_EXPECT( expr, val ) expr
+	#endif
+#endif
+
+// this table is rearranged from the specification so we do not have to add any logic to index into it
+const int32_t wfETC_IntensityTables[8][4] = 
+{
+	{  2,   8,  -2, -8   },
+	{  5,  17,  -5, -17  },
+	{  9,  29,  -9, -29  },
+	{ 13,  42, -13, -42  },
+	{ 18,  60, -18, -60  },
+	{ 24,  80, -24, -80  },
+	{ 33, 106, -33, -106 },
+	{ 47, 183, -47, -183 }
+};
+
+WF_INLINE
+int32_t wfETC_ClampColor( const int32_t x )
+{
+	if( x < 0   ) { return 0; }
+	if( x > 255 ) { return 255; }
+	return x;
+}
+
+#define WF_ETC1_BUILD_COLOR( dst, blockIdx, colorIdx, intensityTable, baseColor ) \
+	dst[ blockIdx ][ colorIdx ] = WF_ETC_RGBA( \
+		wfETC_ClampColor( intensityTable[ blockIdx ][ colorIdx ] + baseColor[ blockIdx ][ 0 ] ), \
+		wfETC_ClampColor( intensityTable[ blockIdx ][ colorIdx ] + baseColor[ blockIdx ][ 1 ] ), \
+		wfETC_ClampColor( intensityTable[ blockIdx ][ colorIdx ] + baseColor[ blockIdx ][ 2 ] ), \
+		255 \
+	);
+
+typedef struct _wfETC1_Block
+{
+	int32_t baseColorsAndFlags;
+	int32_t pixels;
+} wfETC1_Block;
+
+#define WF_ETC1_CHECK_DIFF_BIT( block ) ( block->baseColorsAndFlags & (1<<WF_ETC1_COLOR_OFFSET(33)) )
+#define WF_ETC1_CHECK_FLIP_BIT( block ) ( block->baseColorsAndFlags & (1<<WF_ETC1_COLOR_OFFSET(32)) )
+
+WF_INLINE
+int32_t wfETC1_ReadColor4( const wfETC1_Block* block, const uint32_t offset )
+{
+	const uint32_t bitOffset = WF_ETC1_COLOR_OFFSET(offset);
+	const int32_t color = ( block->baseColorsAndFlags >> bitOffset ) & 0xf;
+	return color | (color<<4);
+}
+
+const int32_t wfETC1_Color3IdxLUT[] = { 0, 1, 2, 3, -4, -3, -2, -1 };
+
+WF_INLINE
+void wfETC1_ReadColor53( const wfETC1_Block* block, const uint32_t offset3, int32_t* WF_RESTRICT dst5, int32_t* WF_RESTRICT dst3 )
+{
+	// read the 5 bit color and expand to 8 bit
+	{
+		const uint32_t bitOffset = WF_ETC1_COLOR_OFFSET((offset3+3));
+		const int32_t color = ( block->baseColorsAndFlags >> (bitOffset-3) ) & 0xf8;
+		*dst5 = color | (color>>5);
+	}
+
+	// read the 3 bit color and expand to 8 bit
+	{
+		const uint32_t bitOffset = WF_ETC1_COLOR_OFFSET(offset3);
+		const int32_t offset = wfETC1_Color3IdxLUT[ ( block->baseColorsAndFlags >> bitOffset ) & 0x7 ];
+		int32_t color = (*dst5>>3) + offset;
+		color <<= 3;
+		color |= (color>>5) & 0x7;
+		*dst3 = color;
+	}
+}
+
+WF_INLINE
+int32_t wfETC1_ReadPixel( const wfETC1_Block* block, const uint32_t offset )
+{
+	return
+		(  (block->pixels>>WF_ETC1_PIXEL_OFFSET(offset)) & 0x1  )
+		|
+		(  ( (block->pixels>>WF_ETC1_PIXEL_OFFSET(16+offset)) & 0x1 ) << 1 )
+	;
+}
+
+void wfETC1_DecodeBlock( const void* WF_RESTRICT src, void* WF_RESTRICT pDst, const uint32_t dstStride )
+{
+	const wfETC1_Block* WF_RESTRICT block = ( wfETC1_Block* )src;
+	int32_t* WF_RESTRICT dst = (int32_t*)pDst;
+
+	int32_t baseColors[2][3]; // [sub-block][r,g,b]
+	int32_t colors[2][4]; // [sub-block][colorIdx]
+
+	// individual mode
+	if( WF_ETC1_CHECK_DIFF_BIT( block ) == 0 )
+	{
+		baseColors[0][0] = wfETC1_ReadColor4( block, 60 );
+		baseColors[0][1] = wfETC1_ReadColor4( block, 52 );
+		baseColors[0][2] = wfETC1_ReadColor4( block, 44 );
+		baseColors[1][0] = wfETC1_ReadColor4( block, 56 );
+		baseColors[1][1] = wfETC1_ReadColor4( block, 48 );
+		baseColors[1][2] = wfETC1_ReadColor4( block, 40 );
+	}
+	// differential mode
+	else
+	{
+		wfETC1_ReadColor53( block, 56, &baseColors[0][0], &baseColors[1][0] );
+		wfETC1_ReadColor53( block, 48, &baseColors[0][1], &baseColors[1][1] );
+		wfETC1_ReadColor53( block, 40, &baseColors[0][2], &baseColors[1][2] );
+	}
+
+	// build color tables
+	{
+		const int32_t* intensityTable[2] = // [sub-block]
+		{
+			wfETC_IntensityTables[ ( block->baseColorsAndFlags >> WF_ETC1_COLOR_OFFSET(37) ) & 0x7 ],
+			wfETC_IntensityTables[ ( block->baseColorsAndFlags >> WF_ETC1_COLOR_OFFSET(34) ) & 0x7 ]
+		};
+		WF_ETC1_BUILD_COLOR( colors, 0, 0, intensityTable, baseColors );
+		WF_ETC1_BUILD_COLOR( colors, 0, 1, intensityTable, baseColors );
+		WF_ETC1_BUILD_COLOR( colors, 0, 2, intensityTable, baseColors );
+		WF_ETC1_BUILD_COLOR( colors, 0, 3, intensityTable, baseColors );
+		WF_ETC1_BUILD_COLOR( colors, 1, 0, intensityTable, baseColors );
+		WF_ETC1_BUILD_COLOR( colors, 1, 1, intensityTable, baseColors );
+		WF_ETC1_BUILD_COLOR( colors, 1, 2, intensityTable, baseColors );
+		WF_ETC1_BUILD_COLOR( colors, 1, 3, intensityTable, baseColors );
+	}
+
+	// vertical split
+	if( WF_ETC1_CHECK_FLIP_BIT( block ) == 0 )
+	{
+		// row 0
+		dst[0] = colors[0][ wfETC1_ReadPixel( block, 0  ) ];
+		dst[1] = colors[0][ wfETC1_ReadPixel( block, 4  ) ];
+		dst[2] = colors[1][ wfETC1_ReadPixel( block, 8  ) ];
+		dst[3] = colors[1][ wfETC1_ReadPixel( block, 12 ) ];
+		dst += dstStride;
+
+		// row 1
+		dst[0] = colors[0][ wfETC1_ReadPixel( block, 1  ) ];
+		dst[1] = colors[0][ wfETC1_ReadPixel( block, 5  ) ];
+		dst[2] = colors[1][ wfETC1_ReadPixel( block, 9  ) ];
+		dst[3] = colors[1][ wfETC1_ReadPixel( block, 13 ) ];
+		dst += dstStride;
+
+		// row 2
+		dst[0] = colors[0][ wfETC1_ReadPixel( block, 2  ) ];
+		dst[1] = colors[0][ wfETC1_ReadPixel( block, 6  ) ];
+		dst[2] = colors[1][ wfETC1_ReadPixel( block, 10 ) ];
+		dst[3] = colors[1][ wfETC1_ReadPixel( block, 14 ) ];
+		dst += dstStride;
+
+		// row 3
+		dst[0] = colors[0][ wfETC1_ReadPixel( block, 3  ) ];
+		dst[1] = colors[0][ wfETC1_ReadPixel( block, 7  ) ];
+		dst[2] = colors[1][ wfETC1_ReadPixel( block, 11 ) ];
+		dst[3] = colors[1][ wfETC1_ReadPixel( block, 15 ) ];
+		//dst += dstStride;
+	}
+	// horizontal split
+	else
+	{
+		// row 0
+		dst[0] = colors[0][ wfETC1_ReadPixel( block, 0  ) ];
+		dst[1] = colors[0][ wfETC1_ReadPixel( block, 4  ) ];
+		dst[2] = colors[0][ wfETC1_ReadPixel( block, 8  ) ];
+		dst[3] = colors[0][ wfETC1_ReadPixel( block, 12 ) ];
+		dst += dstStride;
+
+		// row 1
+		dst[0] = colors[0][ wfETC1_ReadPixel( block, 1  ) ];
+		dst[1] = colors[0][ wfETC1_ReadPixel( block, 5  ) ];
+		dst[2] = colors[0][ wfETC1_ReadPixel( block, 9  ) ];
+		dst[3] = colors[0][ wfETC1_ReadPixel( block, 13 ) ];
+		dst += dstStride;
+
+		// row 2
+		dst[0] = colors[1][ wfETC1_ReadPixel( block, 2  ) ];
+		dst[1] = colors[1][ wfETC1_ReadPixel( block, 6  ) ];
+		dst[2] = colors[1][ wfETC1_ReadPixel( block, 10 ) ];
+		dst[3] = colors[1][ wfETC1_ReadPixel( block, 14 ) ];
+		dst += dstStride;
+
+		// row 3
+		dst[0] = colors[1][ wfETC1_ReadPixel( block, 3  ) ];
+		dst[1] = colors[1][ wfETC1_ReadPixel( block, 7  ) ];
+		dst[2] = colors[1][ wfETC1_ReadPixel( block, 11 ) ];
+		dst[3] = colors[1][ wfETC1_ReadPixel( block, 15 ) ];
+		//dst += dstStride;
+	}
+}
+
+void wfETC1_DecodeImage( const void* WF_RESTRICT pSrc, void* WF_RESTRICT pDst, const uint32_t width, const uint32_t height )
+{
+	const uint8_t* WF_RESTRICT src = (uint8_t*)pSrc;
+	uint8_t* WF_RESTRICT dst = (uint8_t*)pDst;
+	const uint32_t widthBlocks  = width/4;
+	const uint32_t heightBlocks = height/4;
+	uint32_t x, y;
+	for( y = 0; y != heightBlocks; ++y )
+	{
+		for( x = 0; x != widthBlocks; ++x )
+		{
+			wfETC1_DecodeBlock( src, dst, width );
+			src += 8;
+			dst += 16;
+		}
+		dst += width*4*3;
+	}
+}
diff --git a/4dm.h/soil/wfETC.h b/4dm.h/soil/wfETC.h
new file mode 100644
index 0000000..fde1a5d
--- /dev/null
+++ b/4dm.h/soil/wfETC.h
@@ -0,0 +1,53 @@
+#ifndef WF_ETC_H
+#define WF_ETC_H
+
+#define WF_LITTLE_ENDIAN
+
+// Qt ordering
+#define WF_ETC_RGBA( r, g, b, a ) ( ((a)<<24) | ((r)<<16) | ((g)<<8) | (b) ) // colors have been clamped by the time we hit here, so there should be no need to mask
+
+#ifdef _MSC_VER
+	#if _MSC_VER < 1300
+	   typedef signed   char  int8_t;
+	   typedef unsigned char  uint8_t;
+	   typedef signed   short int16_t;
+	   typedef unsigned short uint16_t;
+	   typedef signed   int   int32_t;
+	   typedef unsigned int   uint32_t;
+	#else
+	   typedef signed   __int8  int8_t;
+	   typedef unsigned __int8  uint8_t;
+	   typedef signed   __int16 int16_t;
+	   typedef unsigned __int16 uint16_t;
+	   typedef signed   __int32 int32_t;
+	   typedef unsigned __int32 uint32_t;
+	#endif
+	typedef signed   __int64 int64_t;
+	typedef unsigned __int64 uint64_t;
+#else
+	#include <stdint.h>
+#endif
+
+#ifndef WF_RESTRICT
+	#if defined MSC_VER
+		#define WF_RESTRICT __restrict
+	#elif defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
+		#define WF_RESTRICT restrict
+	#else
+		#define WF_RESTRICT
+	#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void wfETC1_DecodeBlock( const void* WF_RESTRICT src, void* WF_RESTRICT dst, const uint32_t dstStride /*=4*/ ); //!< stride in pixels; must be a multiple of four
+
+extern void wfETC1_DecodeImage( const void* WF_RESTRICT src, void* WF_RESTRICT dst, const uint32_t width, const uint32_t height ); //!< width/height in pixels; must be multiples of four
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // WF_ETC_H
diff --git a/Makefile b/Makefile
index 9c10cee..ece4019 100755
--- a/Makefile
+++ b/Makefile
@@ -1,29 +1,31 @@
 # get the mod name from main.cpp
-MOD_NAME := $(shell grep -Po '(?<=#define MOD_NAME ")[^"]*' main.cpp)
+#MOD_NAME := $(shell grep -Po '(?<=#define MOD_NAME ")[^"]*' main.cpp)
+MOD_NAME := $(shell grep -Po 'name\s*:\s*"[^"]*' info.json5 | grep -Po '(?<=")[^"]*')
 
 # configure mingw as the compiler
 CC=x86_64-w64-mingw32-g++
 
 # 4dm.h will spam your compiler output otherwise
-HIDE_SOME_WARNINGS=-Wno-return-type -Wno-conversion-null
-CFLAGS=-std=c++20 -mwindows $(HIDE_SOME_WARNINGS) -s
+# HIDE_SOME_WARNINGS=-Wno-return-type -Wno-conversion-null
+HIDE_SOME_WARNINGS=-Wno-return-type -Wno-conversion-null -Wno-return-local-addr
+CFLAGS=-std=c++20 -mwindows $(HIDE_SOME_WARNINGS) -s -O3 -flto=auto
 
 
 INCLUDE=-I 4dm.h/ -I 4dm.h/networking/include/
 
 # ./4dm.h/networking/lib/*;./4dm.h/soil/SOIL.lib;opengl32.lib;glew32.lib;glfw3.lib
 NETLIBS=$(shell find 4dm.h/networking/lib/*.lib -not -name steamwebrtc.lib -not -name webrtc-lite.lib)
-CLIBS=-L. $(patsubst %.lib,-l %,$(NETLIBS)) -L 4dm.h/soil -l SOIL -L. -l opengl32   -Wl,-Bdynamic  -l glew32 -l glfw3  -Wl,-Bstatic
+CLIBS=-L. $(patsubst %.lib,-l %,$(NETLIBS)) -L. -l opengl32   -Wl,-Bdynamic  -l glew32 -l glfw3  -Wl,-Bstatic
 # CLIBS=-L. $(patsubst %.lib,-l %,$(wildcard 4dm.h/networking/lib/*.lib)) -L 4dm.h/soil -l SOIL -L. -l opengl32   -Wl,-Bdynamic  -l glew32 -l glfw3  -Wl,-Bstatic
 
 
 default: compile
 compile:
-	$(CC) $(CFLAGS) -O3 -flto $(INCLUDE)   main.cpp   -shared -static $(CLIBS)   -o "$(MOD_NAME).dll"
+	$(CC) $(CFLAGS) $(INCLUDE)   main.cpp   -shared -static $(CLIBS)   -o "$(MOD_NAME).dll"
 
 install:
 	cd ~/.steamapps/4D\ Miner/4D\ Miner\ 0.2.1.4/mods/ && mkdir -p "$(MOD_NAME)"
-	cp "$(MOD_NAME).dll" ~/.steamapps/4D\ Miner/4D\ Miner\ 0.2.1.4/mods/"$(MOD_NAME)"/
+	cp "$(MOD_NAME).dll" info.json5 icon.png ~/.steamapps/4D\ Miner/4D\ Miner\ 0.2.1.4/mods/"$(MOD_NAME)"/ ;true
 
 clean:
 	rm "$(MOD_NAME).dll"
diff --git a/README.md b/README.md
index 5fe2df6..ae9f4bd 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # 4D UUID Obuscator
 
-A mod for [4D Miner by Mashpoe](https://mashpoe.com/4d-miner), based on [Tr1NgleDrs 4dm.h modding framework](https://github.com/4D-Modding/4dm.h).
+A mod for [4D Miner by Mashpoe](https://mashpoe.com/4d-miner), based on [Tr1NgleDev's 4dm.h modding framework](https://github.com/4D-Modding/4dm.h).
 
 The UUID is the string your account on a server is tied to, if anyone knows your UUID they can access all accounts on all servers you visited. If you join a server, the admin can see your UUID.
 
-This mod changes the UUID based on the server address, so the owner of a server sees a UUID that is only used on their server.
\ No newline at end of file
+This mod changes the UUID based on the server address, so the owner of a server sees a UUID that is only used on their server.
diff --git a/icon.png b/icon.png
new file mode 100644
index 0000000..314cb28
Binary files /dev/null and b/icon.png differ
diff --git a/info.json5 b/info.json5
new file mode 100644
index 0000000..fee7ba8
--- /dev/null
+++ b/info.json5
@@ -0,0 +1,11 @@
+{
+  id: "redjard.uuid_obfuscator",
+  name: "4D UUID obfuscator",
+  author: "Redjard",
+  description: "This mod changes the UUID based on the server address, so the owner of a server doesn't see your true UUID and can't steal your accounts.",
+  version: "1.2",
+  gameVersion: "0.2.1.4",
+  modDLL: "4D UUID obfuscator.dll",
+  externalDLLs: [],
+  dependencies: {},
+}
diff --git a/main.cpp b/main.cpp
index 1234e46..8f64226 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,7 +1,3 @@
-
-#define MOD_NAME "4D UUID obfuscator"
-#define MOD_VER "1.1"
-
 #include <4dm.h>
 #include <openssl/evp.h>
 using namespace fdm;
@@ -57,44 +53,22 @@ void updateUUID() {
 	return updateGame(mp,uuidstr,uuidlbl,uuid_hidden);
 }
 
-void(__thiscall* stateMultiplayer_joinButtonCallback)(void* self);
-void stateMultiplayer_joinButtonCallback_H(void* _nullptr) {
-	stateMultiplayer_joinButtonCallback(_nullptr);
+$hook(void, StateMultiplayer, joinButtonCallback) {
+	original(self);
 	updateUUID();
 }
 
-void(__thiscall* stateMultiplayer_keyInput)(StateMultiplayer* self, StateManager& s, int key, int scancode, int action, int mods);
-void stateMultiplayer_keyInput_H(StateMultiplayer* self, StateManager& s, int key, int scancode, int action, int mods) {
-	stateMultiplayer_keyInput(self,s,key,scancode,action,mods);
+$hook(void, StateMultiplayer, keyInput, StateManager& s, int key, int scancode, int action, int mods ) {
+	original(self,s,key,scancode,action,mods);
 	updateUUID();
 }
 
-void(__thiscall* stateMultiplayer_init)(StateMultiplayer* self, StateManager& s, uint32_t codepoint);
-void stateMultiplayer_init_H(StateMultiplayer* self, StateManager& s, uint32_t codepoint) {
-	stateMultiplayer_init(self,s,codepoint);
+$hook(void, StateMultiplayer, init, StateManager& s, uint32_t codepoint) {
+	original(self,s,codepoint);
 	updateUUID();
 }
 
-void(__thiscall* stateMultiplayer_update)(StateMultiplayer* self, StateManager& s, double dt);
-void stateMultiplayer_update_H(StateMultiplayer* self, StateManager& s, double dt) {
-	stateMultiplayer_update(self,s,dt);
+$hook(void, StateMultiplayer, update, StateManager& s, double dt) {
+	original(self,s,dt);
 	updateUUID();
 }
-
-
-DWORD WINAPI Main_Thread(void* hModule) {
-	
-	Hook( FUNC_STATEMULTIPLAYER_JOINBUTTONCALLBACK, &stateMultiplayer_joinButtonCallback_H, &stateMultiplayer_joinButtonCallback );
-	Hook( FUNC_STATEMULTIPLAYER_KEYINPUT, &stateMultiplayer_keyInput_H, &stateMultiplayer_keyInput );
-	Hook( FUNC_STATEMULTIPLAYER_INIT, &stateMultiplayer_init_H, &stateMultiplayer_init );
-	Hook( FUNC_STATEMULTIPLAYER_UPDATE, &stateMultiplayer_update_H, &stateMultiplayer_update );
-	
-	EnableHook(nullptr);
-	return true;
-}
-
-BOOL APIENTRY DllMain(HMODULE hModule, DWORD _reason, LPVOID lpReserved) {
-	if (_reason == DLL_PROCESS_ATTACH)
-		CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Main_Thread, hModule, 0, NULL);
-	return true;
-}