#pragma once
#include "common.h"
#include "enums.h"

#define EUD_MINERALS 0x0057F0F0
#define EUD_GAS 0x0057F120

#define EUD_COUNTDOWN_TIMER 0x0058D6F4

#define EUD_ALL_UNITS_COUNTS_TABLE 0x00582324

#define EUD_CONDITIONS_PTR 0x00515A98
#define EUD_ACTIONS_PTR 0x00512800

#define EUD_DEATHS 0x0058A364

#define EUD_TRIGP1 0x0051A280
#define EUD_TRIGP2 0x0051A28C
#define EUD_TRIGP3 0x0051A298
#define EUD_TRIGP4 0x0051A2A4
#define EUD_TRIGP5 0x0051A2B0
#define EUD_TRIGP6 0x0051A2BC
#define EUD_TRIGP7 0x0051A2C8
#define EUD_TRIGP8 0x0051A2D4

#define EUD_PLAYERINFO 0x0057EEE0
#define EUD_GAMEDATA 0x0057F0F0
#define EUD_LOCATION_TABLE 0x0058DC60

#define EUD_CURRENTPLAYER 0x0051267C
#define EUD_CURRENTTRIGGERWITHHEADER 0x6509AC
#define EUD_CURRENTPLAYER_TRIGGER 0x006509B0

#define EUD_STR 0x005993D4


typedef int(__fastcall *condF)(void*);
typedef int(__fastcall *actF)(void*);

class Section_STR_Impl;
	
class EUDStarcraft {

	friend class Section_STR_Impl;

public:
	EUDStarcraft();

	virtual ~EUDStarcraft();

	bool isAllocated(unsigned int address, unsigned int size) {
		if (address == 4) { return false; }
		//return !IsBadReadPtr((void*)address, size);
		return true;
	}

	virtual unsigned int readInt(unsigned int address, bool* readFail) = 0;

	virtual unsigned char readByte(unsigned int address, bool* readFail) = 0;

	virtual unsigned short readShort(unsigned int address, bool* readFail) = 0;

	virtual bool read(char* buffer, unsigned int address, unsigned int length, bool* readFail) = 0;

	virtual bool writeInt(unsigned int address, unsigned int value, bool* readFail) = 0;

	unsigned int getPlayerResource(unsigned int playerIndex, unsigned int resourceType) {
		return readInt((resourceType == Resources::Ore ? EUD_MINERALS : EUD_GAS) + (playerIndex * 4), nullptr);
	}
	
	unsigned int getCountdownTimer() {
		return readInt(EUD_COUNTDOWN_TIMER, nullptr);
	}

	unsigned int getUnitsCountForPlayer(unsigned int playerID, unsigned int unitID) {
		int units[228];
		if (playerID == Players::CurrentPlayer) {
			playerID = readInt(EUD_CURRENTPLAYER_TRIGGER, nullptr);
		}
		if (playerID < 8) { // Regular players
			read((char*)units, EUD_ALL_UNITS_COUNTS_TABLE + (playerID * 228 * sizeof(int)), 228 * sizeof(int), nullptr);
		} else { // Unsupported
			return 0;
		}

		switch (unitID) {
		case 228: // None
			return 0;
		case 229: // Any unit
		{
			unsigned int sum = 0;
			for (int i = 0; i < 228; i++) {
				sum += units[i];
			}
			return sum;
		}
		case 230: // Men
			return 0;
		case 231: // Building
			return 0;
		case 232: // Factories
			return 0;
		default: // Single unit type
			return units[unitID];
		}
		

	}

	unsigned int getDeathsForPlayer(unsigned int playerID, unsigned int unitID, WriteBuffer* wb, bool* segFault) {
		if (playerID == Players::CurrentPlayer) {
			playerID = readInt(replacePointer(EUD_CURRENTPLAYER_TRIGGER), segFault);
		}

		unsigned int offset = EUD_DEATHS + ((unitID * 12 * sizeof(int)) + (playerID * sizeof(int)));
		unsigned int originalOffset = offset;

		offset = replacePointer(offset);

		if (originalOffset >= EUD_DEATHS && originalOffset <= EUD_DEATHS + (4 * 2736)) { // Native deaths
			return readInt(offset, segFault);
		}

		bool error = false;
		char* offsetName = getAddressDescription(originalOffset, segFault);
		wb->writeFixedLengthString((unsigned char*)"[", &error);
		wb->writeFixedLengthString((unsigned char*)offsetName, &error);
		wb->writeFixedLengthString((unsigned char*)"] ", &error);

		char buffer[512];
		if (offset == originalOffset) {
			sprintf_s(buffer, "Reading int at 0x%X: ", offset);
		} else {
			sprintf_s(buffer, "Reading int at 0x%X (original 0x%X): ", offset, originalOffset);
		}
		
		if (wb != nullptr) {
			wb->writeFixedLengthString((unsigned char*)buffer, &error);
		}

		unsigned int value = readInt(offset, segFault);

		sprintf_s(buffer, "%d", value);
		if (wb != nullptr) {
			wb->writeFixedLengthString((unsigned char*)buffer, &error);
		}
		return value;
	}

	unsigned int setDeathsForPlayer(unsigned int playerID, unsigned int unitID, unsigned int value, WriteBuffer* wb, bool* segFault) {
		if (playerID == Players::CurrentPlayer) {
			playerID = readInt(replacePointer(EUD_CURRENTPLAYER_TRIGGER), segFault);
		}

		unsigned int offset = EUD_DEATHS + ((unitID * 12 * sizeof(int)) + (playerID * sizeof(int)));
		unsigned int originalOffset = offset;
		offset = replacePointer(offset);

		if (originalOffset >= EUD_DEATHS && originalOffset <= EUD_DEATHS + (12 * 228)) { // Native deaths
			return writeInt(offset, value, segFault);
		}
		bool error = false;
		
		char* offsetName = getAddressDescription(originalOffset, segFault);
		wb->writeFixedLengthString((unsigned char*)"[", &error);
		wb->writeFixedLengthString((unsigned char*)offsetName, &error);
		wb->writeFixedLengthString((unsigned char*)"] ", &error);

		unsigned int previousValue = readInt(offset, segFault);
		char buffer[512];
		if (offset == originalOffset) {
			sprintf_s(buffer, "Writing int %d to 0x%X (previous value: %d)", value, offset, previousValue);
		} else {
			sprintf_s(buffer, "Writing int %d to 0x%X (original 0x%X) (previous value: %d)", value, offset, originalOffset, previousValue);
		}
		if (wb != nullptr) {
			wb->writeFixedLengthString((unsigned char*)buffer, &error);
		}
		return writeInt(offset, value, segFault);
	}

	unsigned int getCondResult(ConditionData* condition) {
		if (condition->ConditionType < 20) {
			return cf[condition->ConditionType](condition);
		} else {
			return 0;
		}
	}

	unsigned int getActionResult(ActionData* action) {
		if (action->ActionType < 60) {
			return af[action->ActionType](action);
		} else {
			return 0;
		}
	}

	TriggerList PlayersTriggerList[8];

	char* getTriggerOrigin(TriggerNode* node, unsigned int* offsetPtr, bool* segFault) {
		unsigned int nodePtr = (unsigned int)node;

		// Could be game data stuff
		if (nodePtr >= EUD_GAMEDATA && nodePtr <= EUD_GAMEDATA + sizeof(BWGame)) {
			*offsetPtr = nodePtr - EUD_GAMEDATA;
			return "GAME DATA TRIGGER";
		}

		// Could be MRGN
		if (nodePtr >= EUD_LOCATION_TABLE && nodePtr <= EUD_LOCATION_TABLE + (20 * 255)) {
			*offsetPtr = nodePtr - EUD_LOCATION_TABLE;
			return "MRGN TRIGGER";
		}

		// Could be STR
		unsigned int STRPTR = getSTR(segFault);
		if (nodePtr >= STRPTR) {
			*offsetPtr = nodePtr - STRPTR;
			return "PERHAPS STR TRIGGER";
		}
		return "UNKNOWN TRIGGER LOCATION";
	}

protected:

	virtual unsigned int replacePointer(unsigned int ptr) {

#define CASE_EUD_TRIGP(index, offset)\
	case offset + 0:\
	case offset + 4:\
	case offset + 8:\
		return (unsigned int)(&(PlayersTriggerList[index])) + (ptr - offset);

		switch (ptr) {
			CASE_EUD_TRIGP(0, EUD_TRIGP1);
			CASE_EUD_TRIGP(1, EUD_TRIGP2);
			CASE_EUD_TRIGP(2, EUD_TRIGP3);
			CASE_EUD_TRIGP(3, EUD_TRIGP4);
			CASE_EUD_TRIGP(4, EUD_TRIGP5);
			CASE_EUD_TRIGP(5, EUD_TRIGP6);
			CASE_EUD_TRIGP(6, EUD_TRIGP7);
			CASE_EUD_TRIGP(7, EUD_TRIGP8);

		case EUD_CURRENTTRIGGERWITHHEADER:
			return (unsigned int)(&this->currentTriggerNode);

		case EUD_CURRENTPLAYER_TRIGGER:
			return (unsigned int)&(this->currentPlayerIndexForTriggers);
		}
		return ptr;
	}

private:

	char* getGamedataDescription(unsigned int offset) {
		offset -= EUD_GAMEDATA;
		char* fmt = "Unknown offset %d";
		unsigned int outVal = offset;
#define IN_RANGE(from, to) offset >= from && offset < to
		if (IN_RANGE(0, 48)) {outVal = (offset - 0); fmt = "gameData.minerals[%d]";}
		else if (IN_RANGE(48, 96)) {outVal = (offset - 48); fmt = "gameData.gas[%d]";}
		else if (IN_RANGE(96, 144)) {outVal = (offset - 96); fmt = "gameData.cumulativeGas[%d]";}
		else if (IN_RANGE(144, 192)) {outVal = (offset - 144); fmt = "gameData.cumulativeMinerals[%d]";}
		else if (IN_RANGE(192, 196)) {outVal = (offset - 192); fmt = "gameData.startingPlayerLocalId[%d]";}
		else if (IN_RANGE(196, 208)) {outVal = (offset - 196); fmt = "gameData.playerSlotTypes[%d]";}
		else if (IN_RANGE(208, 220)) {outVal = (offset - 208); fmt = "gameData.playerSlotRaces[%d]";}
		else if (IN_RANGE(220, 224)) {outVal = (offset - 220); fmt = "gameData.teamGameMainPlayer[%d]";}
		else if (IN_RANGE(224, 228)) {outVal = (offset - 224); fmt = "gameData.screenTilePosition[%d]";}
		else if (IN_RANGE(228, 232)) {outVal = (offset - 228); fmt = "gameData.mapTileSize[%d]";}
		else if (IN_RANGE(232, 234)) {outVal = (offset - 232); fmt = "gameData.messageSendToFilter[%d]";}
		else if (IN_RANGE(234, 236)) {outVal = (offset - 234); fmt = "gameData.messagePlayerFilter[%d]";}
		else if (IN_RANGE(236, 238)) {outVal = (offset - 236); fmt = "gameData.mapTileset[%d]";}
		else if (IN_RANGE(238, 240)) {outVal = (offset - 238); fmt = "gameData.currentMusic[%d]";}
		else if (IN_RANGE(240, 241)) {outVal = (offset - 240); fmt = "gameData.__unk_f0[%d]";}
		else if (IN_RANGE(241, 242)) {outVal = (offset - 241); fmt = "gameData.activePlayerCount[%d]";}
		else if (IN_RANGE(242, 243)) {outVal = (offset - 242); fmt = "gameData.consoleIndex[%d]";}
		else if (IN_RANGE(243, 244)) {outVal = (offset - 243); fmt = "gameData.isCustomSinglePlayer[%d]";}
		else if (IN_RANGE(244, 248)) {outVal = (offset - 244); fmt = "gameData.__unk_f4[%d]";}
		else if (IN_RANGE(248, 252)) {outVal = (offset - 248); fmt = "gameData.__unk_f8[%d]";}
		else if (IN_RANGE(252, 300)) {outVal = (offset - 252); fmt = "gameData.playerVision[%d]";}
		else if (IN_RANGE(300, 332)) {outVal = (offset - 300); fmt = "gameData.playerRandomizerMap[%d]";}
		else if (IN_RANGE(332, 336)) {outVal = (offset - 332); fmt = "gameData.frameCount[%d]";}
		else if (IN_RANGE(336, 340)) {outVal = (offset - 336); fmt = "gameData.savedElapsedSeconds[%d]";}
		else if (IN_RANGE(340, 342)) {outVal = (offset - 340); fmt = "gameData.campaignIndex[%d]";}
		else if (IN_RANGE(342, 374)) {outVal = (offset - 342); fmt = "gameData.nextScenario[%d]";}
		else if (IN_RANGE(374, 375)) {outVal = (offset - 374); fmt = "gameData.singlePlayerRace[%d]";}
		else if (IN_RANGE(375, 383)) {outVal = (offset - 375); fmt = "gameData.singlePlayerComputerRaces[%d]";}
		else if (IN_RANGE(383, 384)) {outVal = (offset - 383); fmt = "gameData.__unk_17f[%d]";}
		else if (IN_RANGE(384, 396)) {outVal = (offset - 384); fmt = "gameData.savedScreenPositions[%d]";}
		else if (IN_RANGE(396, 3132)) {outVal = (offset - 396); fmt = "gameData.unitAvailability[%d]";}
		else if (IN_RANGE(3132, 3140)) {outVal = (offset - 3132); fmt = "gameData.__unk_c3c[%d]";}
		else if (IN_RANGE(3140, 3148)) {outVal = (offset - 3140); fmt = "gameData.lastEventPosition[%d]";}
		else if (IN_RANGE(3148, 3408)) {outVal = (offset - 3148); fmt = "gameData.mapFileName[%d]";}
		else if (IN_RANGE(3408, 3440)) {outVal = (offset - 3408); fmt = "gameData.mapTitle[%d]";}
		else if (IN_RANGE(3440, 10352)) {outVal = (offset - 3440); fmt = "gameData.savedPlayerSelections[%d]";}
		else if (IN_RANGE(10352, 11376)) {outVal = (offset - 10352); fmt = "gameData.__unk_2870[%d]";}
		else if (IN_RANGE(11376, 11377)) {outVal = (offset - 11376); fmt = "gameData.defaultMessageFilter[%d]";}
		else if (IN_RANGE(11377, 11378)) {outVal = (offset - 11377); fmt = "gameData.playerLoseType[%d]";}
		else if (IN_RANGE(11378, 11386)) {outVal = (offset - 11378); fmt = "gameData.playerLeft[%d]";}
		else if (IN_RANGE(11386, 11398)) {outVal = (offset - 11386); fmt = "gameData.selectionCircleColor[%d]";}
		else if (IN_RANGE(11398, 11494)) {outVal = (offset - 11398); fmt = "gameData.tunitImagePalette[%d]";}
		else if (IN_RANGE(11494, 11506)) {outVal = (offset - 11494); fmt = "gameData.playerColorIndex[%d]";}
		else if (IN_RANGE(11506, 11508)) {outVal = (offset - 11506); fmt = "gameData.__unk_2cf2[%d]";}
		else if (IN_RANGE(11508, 11556)) {outVal = (offset - 11508); fmt = "gameData.allUnitsTotal[%d]";}
		else if (IN_RANGE(11556, 11604)) {outVal = (offset - 11556); fmt = "gameData.allUnitsProduced[%d]";}
		else if (IN_RANGE(11604, 11652)) {outVal = (offset - 11604); fmt = "gameData.allUnitsOwned[%d]";}
		else if (IN_RANGE(11652, 11700)) {outVal = (offset - 11652); fmt = "gameData.allUnitsLost[%d]";}
		else if (IN_RANGE(11700, 11748)) {outVal = (offset - 11700); fmt = "gameData.allUnitsKilled[%d]";}
		else if (IN_RANGE(11748, 11796)) {outVal = (offset - 11748); fmt = "gameData.allUnitScore[%d]";}
		else if (IN_RANGE(11796, 11844)) {outVal = (offset - 11796); fmt = "gameData.allKillScore[%d]";}
		else if (IN_RANGE(11844, 11892)) {outVal = (offset - 11844); fmt = "gameData.allBuildingsTotal[%d]";}
		else if (IN_RANGE(11892, 11940)) {outVal = (offset - 11892); fmt = "gameData.allBuildingsConstructed[%d]";}
		else if (IN_RANGE(11940, 11988)) {outVal = (offset - 11940); fmt = "gameData.allBuildingsOwned[%d]";}
		else if (IN_RANGE(11988, 12036)) {outVal = (offset - 11988); fmt = "gameData.allBuildingsLost[%d]";}
		else if (IN_RANGE(12036, 12084)) {outVal = (offset - 12036); fmt = "gameData.allBuildingsRazed[%d]";}
		else if (IN_RANGE(12084, 12132)) {outVal = (offset - 12084); fmt = "gameData.allBuildingScore[%d]";}
		else if (IN_RANGE(12132, 12180)) {outVal = (offset - 12132); fmt = "gameData.allRazingScore[%d]";}
		else if (IN_RANGE(12180, 12228)) {outVal = (offset - 12180); fmt = "gameData.allFactoriesConstructed[%d]";}
		else if (IN_RANGE(12228, 12276)) {outVal = (offset - 12228); fmt = "gameData.allFactoriesOwned[%d]";}
		else if (IN_RANGE(12276, 12324)) {outVal = (offset - 12276); fmt = "gameData.allFactoriesLost[%d]";}
		else if (IN_RANGE(12324, 12372)) {outVal = (offset - 12324); fmt = "gameData.allFactoriesRazed[%d]";}
		else if (IN_RANGE(12372, 12804)) {outVal = (offset - 12372); fmt = "gameData.supplies[%d]";}
		else if (IN_RANGE(12804, 12852)) {outVal = (offset - 12804); fmt = "gameData.customScore[%d]";}
		else if (IN_RANGE(12852, 56628)) {outVal = (offset - 12852); fmt = "gameData.unitCounts[%d]";}
		else if (IN_RANGE(56628, 56916)) {outVal = (offset - 56628); fmt = "gameData.techAvailableSC[%d]";}
		else if (IN_RANGE(56916, 57204)) {outVal = (offset - 56916); fmt = "gameData.techResearchedSC[%d]";}
		else if (IN_RANGE(57204, 57240)) {outVal = (offset - 57204); fmt = "gameData.techResearchInProgressSC[%d]";}
		else if (IN_RANGE(57240, 57792)) {outVal = (offset - 57240); fmt = "gameData.maxUpgradeLevelSC[%d]";}
		else if (IN_RANGE(57792, 58344)) {outVal = (offset - 57792); fmt = "gameData.currentUpgradeLevelSC[%d]";}
		else if (IN_RANGE(58344, 58416)) {outVal = (offset - 58344); fmt = "gameData.upgradeInProgressLvl1SC[%d]";}
		else if (IN_RANGE(58416, 58488)) {outVal = (offset - 58416); fmt = "gameData.upgradeInProgressLvl2SC[%d]";}
		else if (IN_RANGE(58488, 58560)) {outVal = (offset - 58488); fmt = "gameData.upgradeInProgressLvl3SC[%d]";}
		else if (IN_RANGE(58560, 58568)) {outVal = (offset - 58560); fmt = "gameData.playerForceId[%d]";}
		else if (IN_RANGE(58568, 58572)) {outVal = (offset - 58568); fmt = "gameData.forceFlags[%d]";}
		else if (IN_RANGE(58572, 58692)) {outVal = (offset - 58572); fmt = "gameData.forceNames[%d]";}
		else if (IN_RANGE(58692, 58836)) {outVal = (offset - 58692); fmt = "gameData.playerAlliances[%d]";}
		else if (IN_RANGE(58836, 58884)) {outVal = (offset - 58836); fmt = "gameData.missionObjectiveStringIndices[%d]";}
		else if (IN_RANGE(58884, 58888)) {outVal = (offset - 58884); fmt = "gameData.countdownTimer[%d]";}
		else if (IN_RANGE(58888, 58892)) {outVal = (offset - 58888); fmt = "gameData.elapsedTime[%d]";}
		else if (IN_RANGE(58892, 58896)) {outVal = (offset - 58892); fmt = "gameData.switchStatesSC[%d]";}
		else if (IN_RANGE(58896, 58904)) {outVal = (offset - 58896); fmt = "gameData.playerVictoryStatus[%d]";}
		else if (IN_RANGE(58904, 58908)) {outVal = (offset - 58904); fmt = "gameData.leaderboardHasComputerPlayers[%d]";}
		else if (IN_RANGE(58908, 58909)) {outVal = (offset - 58908); fmt = "gameData.leaderboardType[%d]";}
		else if (IN_RANGE(58909, 58910)) {outVal = (offset - 58909); fmt = "gameData.leaderboardCondition[%d]";}
		else if (IN_RANGE(58910, 58912)) {outVal = (offset - 58910); fmt = "gameData.leaderboardSubtype[%d]";}
		else if (IN_RANGE(58912, 58916)) {outVal = (offset - 58912); fmt = "gameData.leaderboardGoal[%d]";}
		else if (IN_RANGE(58916, 58920)) {outVal = (offset - 58916); fmt = "gameData.leaderboardStringIndex[%d]";}
		else if (IN_RANGE(58920, 58928)) {outVal = (offset - 58920); fmt = "gameData.remainingGamePauses[%d]";}
		else if (IN_RANGE(58928, 58960)) {outVal = (offset - 58928); fmt = "gameData.startPositions[%d]";}
		else if (IN_RANGE(58960, 60240)) {outVal = (offset - 58960); fmt = "gameData.triggerLocationsSC[%d]";}
		else if (IN_RANGE(60240, 60272)) {outVal = (offset - 60240); fmt = "gameData.switchStatesBW[%d]";}
		else if (IN_RANGE(60272, 65372)) {outVal = (offset - 60272); fmt = "gameData.triggerLocationsBW[%d]";}
		else if (IN_RANGE(65372, 65376)) {outVal = (offset - 65372); fmt = "gameData.timerPauseState[%d]";}
		else if (IN_RANGE(65376, 65616)) {outVal = (offset - 65376); fmt = "gameData.techAvailableBW[%d]";}
		else if (IN_RANGE(65616, 65856)) {outVal = (offset - 65616); fmt = "gameData.techResearchedBW[%d]";}
		else if (IN_RANGE(65856, 65928)) {outVal = (offset - 65856); fmt = "gameData.techResearchInProgressBW[%d]";}
		else if (IN_RANGE(65928, 66108)) {outVal = (offset - 65928); fmt = "gameData.maxUpgradeLevelBW[%d]";}
		else if (IN_RANGE(66108, 66288)) {outVal = (offset - 66108); fmt = "gameData.currentUpgradeLevelBW[%d]";}
		else if (IN_RANGE(66288, 66384)) {outVal = (offset - 66288); fmt = "gameData.upgradeInProgressBW[%d]";}
		else if (IN_RANGE(66384, 66385)) {outVal = (offset - 66384); fmt = "gameData.isExpansion[%d]";}
		else if (IN_RANGE(66385, 66386)) {outVal = (offset - 66385); fmt = "gameData.__unk_10351[%d]";}
		else if (IN_RANGE(66386, 66394)) {outVal = (offset - 66386); fmt = "gameData.unkPlayerColorSomething[%d]";}
		else if (IN_RANGE(66394, 96000)) {outVal = (offset - 66394); fmt = "gameData.__unk_1035a[%d]";}
#undef IN_RANGE
		sprintf_s(__GameDataOutputBuffer, fmt, outVal);
		return __GameDataOutputBuffer;
	}

	char* getPlayerTriggerDataDescription(unsigned int offset) {
#define LBL_TRIGP(pNum, off)\
	case off:\
		return "TrigP" pNum  ".unknown1";\
	case off + 4:\
		return "TrigP" pNum ".last";\
	case off + 8:\
		return "TrigP" pNum  ".first";

		switch (offset) {
			LBL_TRIGP("1", EUD_TRIGP1);
			LBL_TRIGP("2", EUD_TRIGP2);
			LBL_TRIGP("3", EUD_TRIGP3);
			LBL_TRIGP("4", EUD_TRIGP4);
			LBL_TRIGP("5", EUD_TRIGP5);
			LBL_TRIGP("6", EUD_TRIGP6);
			LBL_TRIGP("7", EUD_TRIGP7);
			LBL_TRIGP("8", EUD_TRIGP8);
		}
		return "Unknown player trigger offset";
	}

	char* getActionLabel(unsigned int offset) {
		if (offset == 0) { return "SourceLocation"; }
		if (offset == 1) { return "SourceLocation+1"; }
		if (offset == 2) { return "SourceLocation+2"; }
		if (offset == 3) { return "SourceLocation+3"; }

		if (offset == 4) { return "TriggerText"; }
		if (offset == 5) { return "TriggerText+1"; }
		if (offset == 6) { return "TriggerText+2"; }
		if (offset == 7) { return "TriggerText+3"; }

		if (offset == 8) { return "WAVStringNumber"; }
		if (offset == 9) { return "WAVStringNumber+1"; }
		if (offset == 10) { return "WAVStringNumber+2"; }
		if (offset == 11) { return "WAVStringNumber+3"; }

		if (offset == 12) { return "Time"; }
		if (offset == 13) { return "Time+1"; }
		if (offset == 14) { return "Time+2"; }
		if (offset == 15) { return "Time+3"; }

		if (offset == 16) { return "Player"; }
		if (offset == 17) { return "Player+1"; }
		if (offset == 18) { return "Player+2"; }
		if (offset == 19) { return "Player+3"; }

		if (offset == 20) { return "Group"; }
		if (offset == 21) { return "Group+1"; }
		if (offset == 22) { return "Group+2"; }
		if (offset == 23) { return "Group+3"; }

		if (offset == 24) { return "UnitType"; }
		if (offset == 25) { return "UnitType+1"; }

		if (offset == 26) {return "ActionType";}
		if (offset == 27) {return "UnitsNumber";}
		if (offset == 28) {return "flags";}

		if (offset == 29) {return "Unused[3]";}
		if (offset == 30) { return "Unused[3]+1"; }
		if (offset == 31) { return "Unused[3]+2"; }
		return ".Unknown";
	}

	char* getConditionLabel(unsigned int offset) {
		if (offset == 0) { return "locationNumber"; }
		if (offset == 1) { return "locationNumber+1"; }
		if (offset == 2) { return "locationNumber+2"; }
		if (offset == 3) { return "locationNumber+3"; }

		if (offset == 4) { return "groupNumber"; }
		if (offset == 5) { return "groupNumber+1"; }
		if (offset == 6) { return "groupNumber+2"; }
		if (offset == 7) { return "groupNumber+3"; }

		if (offset == 8) { return "Quantifier"; }
		if (offset == 9) { return "Quantifier+1"; }
		if (offset == 10) { return "Quantifier+2"; }
		if (offset == 11) { return "Quantifier+3"; }

		if (offset == 12) { return "UnitID"; }
		if (offset == 13) { return "UnitID+1"; }
		if (offset == 14) { return "UnitID+2"; }
		if (offset == 15) { return "UnitID+3"; }

		if (offset == 14) { return "Comparision"; }
		if (offset == 15) { return "Comparision+1"; }

		if (offset == 15) { return "ConditionType"; }
		if (offset == 16) { return "Resource"; }
		if (offset == 17) { return "flags"; }
		
		if (offset == 18) { return "Unused"; }
		if (offset == 19) { return "Unused+1"; }
		return ".Unknown";
	}

	char* getTriggerNodeOffsetDescription(unsigned int offset, char** printOffset) {
		const unsigned int conditionSize = sizeof(ConditionData);
		const unsigned int actionSize = sizeof(ActionData);

		*printOffset = "";
		offset %= sizeof(TriggerNode);

		const unsigned int conditionsCount = 16;
		const unsigned int actionsCount = 64;

		if (offset < conditionsCount * conditionSize) { // Condition
			if (offset <= 1 * conditionSize) { *printOffset = getConditionLabel(offset - (0 * conditionSize)); return "Condition[1].%s"; }
			if (offset <= 2 * conditionSize) { *printOffset = getConditionLabel(offset - (1 * conditionSize)); return "Condition[2].%s"; }
			if (offset <= 3 * conditionSize) { *printOffset = getConditionLabel(offset - (2 * conditionSize)); return "Condition[3].%s"; }
			if (offset <= 4 * conditionSize) { *printOffset = getConditionLabel(offset - (3 * conditionSize)); return "Condition[4].%s"; }
			if (offset <= 5 * conditionSize) { *printOffset = getConditionLabel(offset - (4 * conditionSize)); return "Condition[5].%s"; }
			if (offset <= 6 * conditionSize) { *printOffset = getConditionLabel(offset - (5 * conditionSize)); return "Condition[6].%s"; }
			if (offset <= 7 * conditionSize) { *printOffset = getConditionLabel(offset - (6 * conditionSize)); return "Condition[7].%s"; }
			if (offset <= 8 * conditionSize) { *printOffset = getConditionLabel(offset - (7 * conditionSize)); return "Condition[8].%s"; }
			if (offset <= 9 * conditionSize) { *printOffset = getConditionLabel(offset - (8 * conditionSize)); return "Condition[9].%s"; }
			if (offset <= 10 * conditionSize) { *printOffset = getConditionLabel(offset - (9 * conditionSize)); return "Condition[10].%s"; }
			if (offset <= 11 * conditionSize) { *printOffset = getConditionLabel(offset - (10 * conditionSize)); return "Condition[11].%s"; }
			if (offset <= 12 * conditionSize) { *printOffset = getConditionLabel(offset - (11 * conditionSize)); return "Condition[12].%s"; }
			if (offset <= 13 * conditionSize) { *printOffset = getConditionLabel(offset - (12 * conditionSize)); return "Condition[13].%s"; }
			if (offset <= 14 * conditionSize) { *printOffset = getConditionLabel(offset - (13 * conditionSize)); return "Condition[14].%s"; }
			if (offset <= 15 * conditionSize) { *printOffset = getConditionLabel(offset - (14 * conditionSize)); return "Condition[15].%s"; }
			if (offset <= 16 * conditionSize) { *printOffset = getConditionLabel(offset - (15 * conditionSize)); return "Condition[16].%s"; }
			return "Unknown condition";
		}
		offset -= conditionsCount * conditionSize;


		if (offset < actionsCount * actionSize) { // Action
			if (offset <= 1 * actionSize) { *printOffset = getActionLabel(offset - (0 * actionSize)); return "Action[1].%s"; }
			if (offset <= 2 * actionSize) { *printOffset = getActionLabel(offset - (1 * actionSize)); return "Action[2].%s"; }
			if (offset <= 3 * actionSize) { *printOffset = getActionLabel(offset - (2 * actionSize)); return "Action[3].%s"; }
			if (offset <= 4 * actionSize) { *printOffset = getActionLabel(offset - (3 * actionSize)); return "Action[4].%s"; }
			if (offset <= 5 * actionSize) { *printOffset = getActionLabel(offset - (4 * actionSize)); return "Action[5].%s"; }
			if (offset <= 6 * actionSize) { *printOffset = getActionLabel(offset - (5 * actionSize)); return "Action[6].%s"; }
			if (offset <= 7 * actionSize) { *printOffset = getActionLabel(offset - (6 * actionSize)); return "Action[7].%s"; }
			if (offset <= 8 * actionSize) { *printOffset = getActionLabel(offset - (7 * actionSize)); return "Action[8].%s"; }
			if (offset <= 9 * actionSize) { *printOffset = getActionLabel(offset - (8 * actionSize)); return "Action[9].%s"; }
			if (offset <= 10 * actionSize) { *printOffset = getActionLabel(offset - (9 * actionSize)); return "Action[10].%s"; }
			if (offset <= 11 * actionSize) { *printOffset = getActionLabel(offset - (10 * actionSize)); return "Action[11].%s"; }
			if (offset <= 12 * actionSize) { *printOffset = getActionLabel(offset - (11 * actionSize)); return "Action[12].%s"; }
			if (offset <= 13 * actionSize) { *printOffset = getActionLabel(offset - (12 * actionSize)); return "Action[13].%s"; }
			if (offset <= 14 * actionSize) { *printOffset = getActionLabel(offset - (13 * actionSize)); return "Action[14].%s"; }
			if (offset <= 15 * actionSize) { *printOffset = getActionLabel(offset - (14 * actionSize)); return "Action[15].%s"; }
			if (offset <= 16 * actionSize) { *printOffset = getActionLabel(offset - (15 * actionSize)); return "Action[16].%s"; }
			if (offset <= 17 * actionSize) { *printOffset = getActionLabel(offset - (16 * actionSize)); return "Action[17].%s"; }
			if (offset <= 18 * actionSize) { *printOffset = getActionLabel(offset - (17 * actionSize)); return "Action[18].%s"; }
			if (offset <= 19 * actionSize) { *printOffset = getActionLabel(offset - (18 * actionSize)); return "Action[19].%s"; }
			if (offset <= 20 * actionSize) { *printOffset = getActionLabel(offset - (19 * actionSize)); return "Action[20].%s"; }
			if (offset <= 21 * actionSize) { *printOffset = getActionLabel(offset - (20 * actionSize)); return "Action[21].%s"; }
			if (offset <= 22 * actionSize) { *printOffset = getActionLabel(offset - (21 * actionSize)); return "Action[22].%s"; }
			if (offset <= 23 * actionSize) { *printOffset = getActionLabel(offset - (22 * actionSize)); return "Action[23].%s"; }
			if (offset <= 24 * actionSize) { *printOffset = getActionLabel(offset - (23 * actionSize)); return "Action[24].%s"; }
			if (offset <= 25 * actionSize) { *printOffset = getActionLabel(offset - (24 * actionSize)); return "Action[25].%s"; }
			if (offset <= 26 * actionSize) { *printOffset = getActionLabel(offset - (25 * actionSize)); return "Action[26].%s"; }
			if (offset <= 27 * actionSize) { *printOffset = getActionLabel(offset - (26 * actionSize)); return "Action[27].%s"; }
			if (offset <= 28 * actionSize) { *printOffset = getActionLabel(offset - (27 * actionSize)); return "Action[28].%s"; }
			if (offset <= 29 * actionSize) { *printOffset = getActionLabel(offset - (28 * actionSize)); return "Action[29].%s"; }
			if (offset <= 30 * actionSize) { *printOffset = getActionLabel(offset - (29 * actionSize)); return "Action[30].%s"; }
			if (offset <= 31 * actionSize) { *printOffset = getActionLabel(offset - (30 * actionSize)); return "Action[31].%s"; }
			if (offset <= 32 * actionSize) { *printOffset = getActionLabel(offset - (31 * actionSize)); return "Action[32].%s"; }
			if (offset <= 33 * actionSize) { *printOffset = getActionLabel(offset - (32 * actionSize)); return "Action[33].%s"; }
			if (offset <= 34 * actionSize) { *printOffset = getActionLabel(offset - (33 * actionSize)); return "Action[34].%s"; }
			if (offset <= 35 * actionSize) { *printOffset = getActionLabel(offset - (34 * actionSize)); return "Action[35].%s"; }
			if (offset <= 36 * actionSize) { *printOffset = getActionLabel(offset - (35 * actionSize)); return "Action[36].%s"; }
			if (offset <= 37 * actionSize) { *printOffset = getActionLabel(offset - (36 * actionSize)); return "Action[37].%s"; }
			if (offset <= 38 * actionSize) { *printOffset = getActionLabel(offset - (37 * actionSize)); return "Action[38].%s"; }
			if (offset <= 39 * actionSize) { *printOffset = getActionLabel(offset - (38 * actionSize)); return "Action[39].%s"; }
			if (offset <= 40 * actionSize) { *printOffset = getActionLabel(offset - (39 * actionSize)); return "Action[40].%s"; }
			if (offset <= 41 * actionSize) { *printOffset = getActionLabel(offset - (40 * actionSize)); return "Action[41].%s"; }
			if (offset <= 42 * actionSize) { *printOffset = getActionLabel(offset - (41 * actionSize)); return "Action[42].%s"; }
			if (offset <= 43 * actionSize) { *printOffset = getActionLabel(offset - (42 * actionSize)); return "Action[43].%s"; }
			if (offset <= 44 * actionSize) { *printOffset = getActionLabel(offset - (43 * actionSize)); return "Action[44].%s"; }
			if (offset <= 45 * actionSize) { *printOffset = getActionLabel(offset - (44 * actionSize)); return "Action[45].%s"; }
			if (offset <= 46 * actionSize) { *printOffset = getActionLabel(offset - (45 * actionSize)); return "Action[46].%s"; }
			if (offset <= 47 * actionSize) { *printOffset = getActionLabel(offset - (46 * actionSize)); return "Action[47].%s"; }
			if (offset <= 48 * actionSize) { *printOffset = getActionLabel(offset - (47 * actionSize)); return "Action[48].%s"; }
			if (offset <= 49 * actionSize) { *printOffset = getActionLabel(offset - (48 * actionSize)); return "Action[49].%s"; }
			if (offset <= 50 * actionSize) { *printOffset = getActionLabel(offset - (49 * actionSize)); return "Action[50].%s"; }
			if (offset <= 51 * actionSize) { *printOffset = getActionLabel(offset - (50 * actionSize)); return "Action[51].%s"; }
			if (offset <= 52 * actionSize) { *printOffset = getActionLabel(offset - (51 * actionSize)); return "Action[52].%s"; }
			if (offset <= 53 * actionSize) { *printOffset = getActionLabel(offset - (52 * actionSize)); return "Action[53].%s"; }
			if (offset <= 54 * actionSize) { *printOffset = getActionLabel(offset - (53 * actionSize)); return "Action[54].%s"; }
			if (offset <= 55 * actionSize) { *printOffset = getActionLabel(offset - (54 * actionSize)); return "Action[55].%s"; }
			if (offset <= 56 * actionSize) { *printOffset = getActionLabel(offset - (55 * actionSize)); return "Action[56].%s"; }
			if (offset <= 57 * actionSize) { *printOffset = getActionLabel(offset - (56 * actionSize)); return "Action[57].%s"; }
			if (offset <= 58 * actionSize) { *printOffset = getActionLabel(offset - (57 * actionSize)); return "Action[58].%s"; }
			if (offset <= 59 * actionSize) { *printOffset = getActionLabel(offset - (58 * actionSize)); return "Action[59].%s"; }
			if (offset <= 60 * actionSize) { *printOffset = getActionLabel(offset - (59 * actionSize)); return "Action[60].%s"; }
			if (offset <= 61 * actionSize) { *printOffset = getActionLabel(offset - (60 * actionSize)); return "Action[61].%s"; }
			if (offset <= 62 * actionSize) { *printOffset = getActionLabel(offset - (61 * actionSize)); return "Action[62].%s"; }
			if (offset <= 63 * actionSize) { *printOffset = getActionLabel(offset - (62 * actionSize)); return "Action[63].%s"; }
			return "Unknown action";
		}
		offset -= actionsCount * actionSize;
		if (offset == 0) { // Flags
			return "Flags";
		} else { // Players
			offset -= 4;
			if (offset == 0) { return "Execution.P0-P4"; }
			if (offset == 1) { return "Execution.P1-P5"; }
			if (offset == 2) { return "Execution.P2-P6"; }
			if (offset == 3) { return "Execution.P3-P7"; }
			if (offset == 4) { return "Execution.P4-P8"; }
			if (offset == 5) { return "Execution.P5-P9"; }
			if (offset == 6) { return "Execution.P6-P10"; }
			if (offset == 7) { return "Execution.P7-P11"; }
			if (offset == 8) { return "Execution.P8-P12"; }
			if (offset == 9) { return "Execution.P9-P13"; }
			if (offset == 10) { return "Execution.P10-P15"; }
			if (offset == 11) { return "Execution.P11-P16"; }
			if (offset == 12) { return "Execution.P12-P17"; }
			if (offset == 13) { return "Execution.P13-P18"; }
			if (offset == 14) { return "Execution.P14-P19"; }
			if (offset == 15) { return "Execution.P15-P20"; }
			if (offset == 16) { return "Execution.P16-P21"; }
			if (offset == 17) { return "Execution.P17-P22"; }
			if (offset == 18) { return "Execution.P18-P23"; }
			if (offset == 19) { return "Execution.P19-P24"; }
			if (offset == 20) { return "Execution.P20-P25"; }
			if (offset == 21) { return "Execution.P21-P26"; }
			if (offset == 22) { return "Execution.P22-P27"; }
			if (offset == 23) { return "Execution.P23-P28"; }
			if (offset == 24) { return "Execution.P24-XXX"; }
			if (offset == 25) { return "Execution.P25-XXX"; }
			if (offset == 26) { return "Execution.P26-XXX"; }
			if (offset == 27) { return "Execution.P27-XXX"; }
		}

		return "Unknown";
	}

	char* getAddressDescription(unsigned int offset, unsigned int* from, unsigned int* to, bool expand, bool* segFault) {
#define IN_RANGE(from, to) offset >= from && offset <= to
		int tmp = 5;
		tmp++;
		if (IN_RANGE(0x0050CDC0, 0x0050CEC1)) { *from = 0x0050CDC0; *to = 0x0050CEC1; return "imgDrawPaletteIndex"; }
		if (IN_RANGE(0x0050E064, 0x0050E068)) { *from = 0x0050E064; *to = 0x0050E068; return "glMenuPalette"; }
		if (IN_RANGE(0x005124D8, 0x005124F4)) { *from = 0x005124D8; *to = 0x005124F4; return "GameSpeedModifiers"; }
		if (IN_RANGE(0x00512678, 0x0051267C)) { *from = 0x00512678; *to = 0x0051267C; return "g_ActiveNationID"; }
		if (IN_RANGE(0x0051267C, 0x00512680)) { *from = 0x0051267C; *to = 0x00512680; return "g_ActiveHumanID"; }
		if (IN_RANGE(0x00512684, 0x00512688)) { *from = 0x00512684; *to = 0x00512688; return "g_LocalNationID"; }
		if (IN_RANGE(0x00512688, 0x0051268C)) { *from = 0x00512688; *to = 0x0051268C; return "g_LocalHumanID"; }
		if (IN_RANGE(0x00512708, 0x00512754)) { *from = 0x00512708; *to = 0x00512754; return "cursorFileArray"; }
		if (IN_RANGE(0x005128F8, 0x00512998)) { *from = 0x005128F8; *to = 0x00512998; return "gColorShifts"; }
		if (IN_RANGE(0x00513B68, 0x00513B99)) { *from = 0x00513B68; *to = 0x00513B99; return "scrollSpeeds"; }
		if (IN_RANGE(0x00514178, 0x005145BA)) { *from = 0x00514178; *to = 0x005145BA; return "sgTree"; }
		if (IN_RANGE(0x005145BC, 0x005145C0)) { *from = 0x005145BC; *to = 0x005145C0; return "scratch"; }
		if (IN_RANGE(0x005145C0, 0x00514906)) { *from = 0x005145C0; *to = 0x00514906; return "sgUpgradeTree"; }
		if (IN_RANGE(0x00514908, 0x00514A46)) { *from = 0x00514908; *to = 0x00514A46; return "sgResearchTree"; }
		if (IN_RANGE(0x00514A48, 0x00514CF8)) { *from = 0x00514A48; *to = 0x00514CF8; return "sgTechUseTree"; }
		if (IN_RANGE(0x00514CF8, 0x0051521C)) { *from = 0x00514CF8; *to = 0x0051521C; return "sgOrderTree"; }
		if (IN_RANGE(0x0051521C, 0x00515224)) { *from = 0x0051521C; *to = 0x00515224; return "advisorPortraitsIndex"; }
		if (IN_RANGE(0x005152A8, 0x005152FC)) { *from = 0x005152A8; *to = 0x005152FC; return "??"; }
		if (IN_RANGE(0x005152FC, 0x00515300)) { *from = 0x005152FC; *to = 0x00515300; return "scratch"; }
		if (IN_RANGE(0x00515300, 0x00515348)) { *from = 0x00515300; *to = 0x00515348; return "??"; }
		if (IN_RANGE(0x00515348, 0x00515384)) { *from = 0x00515348; *to = 0x00515384; return "??"; }
		if (IN_RANGE(0x00515384, 0x00515388)) { *from = 0x00515384; *to = 0x00515388; return "scratch"; }
		if (IN_RANGE(0x00515388, 0x005153E8)) { *from = 0x00515388; *to = 0x005153E8; return "??"; }
		if (IN_RANGE(0x00515AF8, 0x00515B08)) { *from = 0x00515AF8; *to = 0x00515B08; return "???"; }
		if (IN_RANGE(0x00515B08, 0x00515B18)) { *from = 0x00515B08; *to = 0x00515B18; return "???"; }
		if (IN_RANGE(0x00515B18, 0x00515B38)) { *from = 0x00515B18; *to = 0x00515B38; return "???"; }
		if (IN_RANGE(0x00515B38, 0x00515B58)) { *from = 0x00515B38; *to = 0x00515B58; return "???"; }
		if (IN_RANGE(0x00515B58, 0x00515B60)) { *from = 0x00515B58; *to = 0x00515B60; return "???"; }
		if (IN_RANGE(0x00515B60, 0x00515B68)) { *from = 0x00515B60; *to = 0x00515B68; return "???"; }
		if (IN_RANGE(0x00515B68, 0x00515B70)) { *from = 0x00515B68; *to = 0x00515B70; return "???"; }
		if (IN_RANGE(0x00515B70, 0x00515BE8)) { *from = 0x00515B70; *to = 0x00515BE8; return "wpnDamageMultiplier"; }
		if (IN_RANGE(0x00515BE8, 0x00515BEC)) { *from = 0x00515BE8; *to = 0x00515BEC; return "Buttonset Info"; }
		if (IN_RANGE(0x00515BE8, 0x00515C24)) { *from = 0x00515BE8; *to = 0x00515C24; return "Buttonset Info"; }
		if (IN_RANGE(0x00515C24, 0x00515C28)) { *from = 0x00515C24; *to = 0x00515C28; return "Buttonset Info"; }
		if (IN_RANGE(0x00515C24, 0x00515C60)) { *from = 0x00515C24; *to = 0x00515C60; return "Buttonset Info"; }
		if (IN_RANGE(0x00515C60, 0x00515C64)) { *from = 0x00515C60; *to = 0x00515C64; return "Buttonset Info"; }
		if (IN_RANGE(0x00515C60, 0x00515C74)) { *from = 0x00515C60; *to = 0x00515C74; return "Buttonset Info"; }
		if (IN_RANGE(0x00515C74, 0x00515C78)) { *from = 0x00515C74; *to = 0x00515C78; return "Buttonset Info"; }
		if (IN_RANGE(0x00515C74, 0x00515C88)) { *from = 0x00515C74; *to = 0x00515C88; return "Buttonset Info"; }
		if (IN_RANGE(0x00515C88, 0x00515C8C)) { *from = 0x00515C88; *to = 0x00515C8C; return "Buttonset Info"; }
		if (IN_RANGE(0x00515C88, 0x00515C9C)) { *from = 0x00515C88; *to = 0x00515C9C; return "Buttonset Info"; }
		if (IN_RANGE(0x00515C9C, 0x00515CA0)) { *from = 0x00515C9C; *to = 0x00515CA0; return "Buttonset Info"; }
		if (IN_RANGE(0x00515C9C, 0x00515CC4)) { *from = 0x00515C9C; *to = 0x00515CC4; return "Buttonset Info"; }
		if (IN_RANGE(0x00515CC4, 0x00515CC8)) { *from = 0x00515CC4; *to = 0x00515CC8; return "Buttonset Info"; }
		if (IN_RANGE(0x00515CC4, 0x00515CD8)) { *from = 0x00515CC4; *to = 0x00515CD8; return "Buttonset Info"; }
		if (IN_RANGE(0x00515CD8, 0x00515CDC)) { *from = 0x00515CD8; *to = 0x00515CDC; return "Buttonset Info"; }
		if (IN_RANGE(0x00515CD8, 0x00515D00)) { *from = 0x00515CD8; *to = 0x00515D00; return "Buttonset Info"; }
		if (IN_RANGE(0x00515D00, 0x00515D04)) { *from = 0x00515D00; *to = 0x00515D04; return "Buttonset Info"; }
		if (IN_RANGE(0x00515D00, 0x00515D14)) { *from = 0x00515D00; *to = 0x00515D14; return "Buttonset Info"; }
		if (IN_RANGE(0x00515D14, 0x00515D18)) { *from = 0x00515D14; *to = 0x00515D18; return "Buttonset Info"; }
		if (IN_RANGE(0x00515D14, 0x00515D50)) { *from = 0x00515D14; *to = 0x00515D50; return "Buttonset Info"; }
		if (IN_RANGE(0x00515D50, 0x00515D54)) { *from = 0x00515D50; *to = 0x00515D54; return "Buttonset Info"; }
		if (IN_RANGE(0x00515D50, 0x00515D64)) { *from = 0x00515D50; *to = 0x00515D64; return "Buttonset Info"; }
		if (IN_RANGE(0x00515D64, 0x00515D68)) { *from = 0x00515D64; *to = 0x00515D68; return "scratch"; }
		if (IN_RANGE(0x00515D68, 0x00515D6C)) { *from = 0x00515D68; *to = 0x00515D6C; return "Buttonset Info"; }
		if (IN_RANGE(0x00515D68, 0x00515DCC)) { *from = 0x00515D68; *to = 0x00515DCC; return "Buttonset Info"; }
		if (IN_RANGE(0x00515DD0, 0x00515DD4)) { *from = 0x00515DD0; *to = 0x00515DD4; return "BTNS_Military"; }
		if (IN_RANGE(0x00515DD0, 0x00515E34)) { *from = 0x00515DD0; *to = 0x00515E34; return "BTNS_Military"; }
		if (IN_RANGE(0x00515E34, 0x00515E38)) { *from = 0x00515E34; *to = 0x00515E38; return "scratch"; }
		if (IN_RANGE(0x00515E38, 0x00515E3C)) { *from = 0x00515E38; *to = 0x00515E3C; return "Buttonset Info"; }
		if (IN_RANGE(0x00515E38, 0x00515E9C)) { *from = 0x00515E38; *to = 0x00515E9C; return "Buttonset Info"; }
		if (IN_RANGE(0x00515E9C, 0x00515EA0)) { *from = 0x00515E9C; *to = 0x00515EA0; return "scratch"; }
		if (IN_RANGE(0x00515EA0, 0x00515EA4)) { *from = 0x00515EA0; *to = 0x00515EA4; return "BTNS_Transport"; }
		if (IN_RANGE(0x00515EA0, 0x00515F2C)) { *from = 0x00515EA0; *to = 0x00515F2C; return "BTNS_Transport"; }
		if (IN_RANGE(0x00515F2C, 0x00515F30)) { *from = 0x00515F2C; *to = 0x00515F30; return "BTNS_Turret"; }
		if (IN_RANGE(0x00515F2C, 0x00515F54)) { *from = 0x00515F2C; *to = 0x00515F54; return "BTNS_Turret"; }
		if (IN_RANGE(0x00515F54, 0x00515F58)) { *from = 0x00515F54; *to = 0x00515F58; return "scratch"; }
		if (IN_RANGE(0x00515F58, 0x00515F5C)) { *from = 0x00515F58; *to = 0x00515F5C; return "BTNS_Larva"; }
		if (IN_RANGE(0x00515F58, 0x0051600C)) { *from = 0x00515F58; *to = 0x0051600C; return "BTNS_Larva"; }
		if (IN_RANGE(0x0051600C, 0x00516010)) { *from = 0x0051600C; *to = 0x00516010; return "BTNS_UnitMorphing"; }
		if (IN_RANGE(0x0051600C, 0x00516020)) { *from = 0x0051600C; *to = 0x00516020; return "BTNS_UnitMorphing"; }
		if (IN_RANGE(0x00516020, 0x00516024)) { *from = 0x00516020; *to = 0x00516024; return "BTNS_Drone"; }
		if (IN_RANGE(0x00516020, 0x005160D4)) { *from = 0x00516020; *to = 0x005160D4; return "BTNS_Drone"; }
		if (IN_RANGE(0x005160D4, 0x005160D8)) { *from = 0x005160D4; *to = 0x005160D8; return "scratch"; }
		if (IN_RANGE(0x005160D8, 0x005160DC)) { *from = 0x005160D8; *to = 0x005160DC; return "Buttonset Info"; }
		if (IN_RANGE(0x005160D8, 0x00516164)) { *from = 0x005160D8; *to = 0x00516164; return "Buttonset Info"; }
		if (IN_RANGE(0x00516164, 0x00516168)) { *from = 0x00516164; *to = 0x00516168; return "scratch"; }
		if (IN_RANGE(0x00516168, 0x0051616C)) { *from = 0x00516168; *to = 0x0051616C; return "Buttonset Info"; }
		if (IN_RANGE(0x00516168, 0x005161E0)) { *from = 0x00516168; *to = 0x005161E0; return "Buttonset Info"; }
		if (IN_RANGE(0x005161E0, 0x005161E4)) { *from = 0x005161E0; *to = 0x005161E4; return "BTNS_MilitaryBurrow"; }
		if (IN_RANGE(0x005161E0, 0x0051626C)) { *from = 0x005161E0; *to = 0x0051626C; return "BTNS_MilitaryBurrow"; }
		if (IN_RANGE(0x0051626C, 0x00516270)) { *from = 0x0051626C; *to = 0x00516270; return "scratch"; }
		if (IN_RANGE(0x00516270, 0x00516274)) { *from = 0x00516270; *to = 0x00516274; return "BTNS_Hydralisk"; }
		if (IN_RANGE(0x00516270, 0x00516310)) { *from = 0x00516270; *to = 0x00516310; return "BTNS_Hydralisk"; }
		if (IN_RANGE(0x00516310, 0x00516314)) { *from = 0x00516310; *to = 0x00516314; return "BTNS_Mutalisk"; }
		if (IN_RANGE(0x00516310, 0x0051639C)) { *from = 0x00516310; *to = 0x0051639C; return "BTNS_Mutalisk"; }
		if (IN_RANGE(0x0051639C, 0x005163A0)) { *from = 0x0051639C; *to = 0x005163A0; return "scratch"; }
		if (IN_RANGE(0x005163A0, 0x005163A4)) { *from = 0x005163A0; *to = 0x005163A4; return "BTNS_Lurker"; }
		if (IN_RANGE(0x005163A0, 0x0051642C)) { *from = 0x005163A0; *to = 0x0051642C; return "BTNS_Lurker"; }
		if (IN_RANGE(0x0051642C, 0x00516430)) { *from = 0x0051642C; *to = 0x00516430; return "scratch"; }
		if (IN_RANGE(0x00516430, 0x00516434)) { *from = 0x00516430; *to = 0x00516434; return "BTNS_FlyingBuilding"; }
		if (IN_RANGE(0x00516430, 0x005164E4)) { *from = 0x00516430; *to = 0x005164E4; return "BTNS_FlyingBuilding"; }
		if (IN_RANGE(0x005164E4, 0x005164E8)) { *from = 0x005164E4; *to = 0x005164E8; return "scratch"; }
		if (IN_RANGE(0x005164E8, 0x005164EC)) { *from = 0x005164E8; *to = 0x005164EC; return "BTNS_Defiler"; }
		if (IN_RANGE(0x005164E8, 0x0051659C)) { *from = 0x005164E8; *to = 0x0051659C; return "BTNS_Defiler"; }
		if (IN_RANGE(0x0051659C, 0x005165A0)) { *from = 0x0051659C; *to = 0x005165A0; return "scratch"; }
		if (IN_RANGE(0x005165A0, 0x005165A4)) { *from = 0x005165A0; *to = 0x005165A4; return "BTNS_InfestedTerran"; }
		if (IN_RANGE(0x005165A0, 0x0051662C)) { *from = 0x005165A0; *to = 0x0051662C; return "BTNS_InfestedTerran"; }
		if (IN_RANGE(0x0051662C, 0x00516630)) { *from = 0x0051662C; *to = 0x00516630; return "scratch"; }
		if (IN_RANGE(0x00516630, 0x00516634)) { *from = 0x00516630; *to = 0x00516634; return "BTNS_InfestedKerrigan"; }
		if (IN_RANGE(0x00516630, 0x005166F8)) { *from = 0x00516630; *to = 0x005166F8; return "BTNS_InfestedKerrigan"; }
		if (IN_RANGE(0x005166F8, 0x005166FC)) { *from = 0x005166F8; *to = 0x005166FC; return "BTNS_InfestedDuran"; }
		if (IN_RANGE(0x005166F8, 0x005167AC)) { *from = 0x005166F8; *to = 0x005167AC; return "BTNS_InfestedDuran"; }
		if (IN_RANGE(0x005167AC, 0x005167B0)) { *from = 0x005167AC; *to = 0x005167B0; return "scratch"; }
		if (IN_RANGE(0x005167B0, 0x005167B4)) { *from = 0x005167B0; *to = 0x005167B4; return "BTNS_Hatchery"; }
		if (IN_RANGE(0x005167B0, 0x00516814)) { *from = 0x005167B0; *to = 0x00516814; return "BTNS_Hatchery"; }
		if (IN_RANGE(0x00516814, 0x00516818)) { *from = 0x00516814; *to = 0x00516818; return "scratch"; }
		if (IN_RANGE(0x00516818, 0x0051681C)) { *from = 0x00516818; *to = 0x0051681C; return "BTNS_Lair"; }
		if (IN_RANGE(0x00516818, 0x005168CC)) { *from = 0x00516818; *to = 0x005168CC; return "BTNS_Lair"; }
		if (IN_RANGE(0x005168CC, 0x005168D0)) { *from = 0x005168CC; *to = 0x005168D0; return "scratch"; }
		if (IN_RANGE(0x005168D0, 0x005168D4)) { *from = 0x005168D0; *to = 0x005168D4; return "BTNS_Hive"; }
		if (IN_RANGE(0x005168D0, 0x00516970)) { *from = 0x005168D0; *to = 0x00516970; return "BTNS_Hive"; }
		if (IN_RANGE(0x00516970, 0x00516974)) { *from = 0x00516970; *to = 0x00516974; return "BTNS_NydusCanal"; }
		if (IN_RANGE(0x00516970, 0x00516984)) { *from = 0x00516970; *to = 0x00516984; return "BTNS_NydusCanal"; }
		if (IN_RANGE(0x00516984, 0x00516988)) { *from = 0x00516984; *to = 0x00516988; return "scratch"; }
		if (IN_RANGE(0x00516988, 0x0051698C)) { *from = 0x00516988; *to = 0x0051698C; return "BTNS_Spire"; }
		if (IN_RANGE(0x00516988, 0x005169D8)) { *from = 0x00516988; *to = 0x005169D8; return "BTNS_Spire"; }
		if (IN_RANGE(0x005169D8, 0x005169DC)) { *from = 0x005169D8; *to = 0x005169DC; return "BTNS_GreaterSpire"; }
		if (IN_RANGE(0x005169D8, 0x00516A14)) { *from = 0x005169D8; *to = 0x00516A14; return "BTNS_GreaterSpire"; }
		if (IN_RANGE(0x00516A14, 0x00516A18)) { *from = 0x00516A14; *to = 0x00516A18; return "BTNS_SpawningPool"; }
		if (IN_RANGE(0x00516A14, 0x00516A50)) { *from = 0x00516A14; *to = 0x00516A50; return "BTNS_SpawningPool"; }
		if (IN_RANGE(0x00516A50, 0x00516A54)) { *from = 0x00516A50; *to = 0x00516A54; return "BTNS_CreepColony"; }
		if (IN_RANGE(0x00516A50, 0x00516A78)) { *from = 0x00516A50; *to = 0x00516A78; return "BTNS_CreepColony"; }
		if (IN_RANGE(0x00516A78, 0x00516A7C)) { *from = 0x00516A78; *to = 0x00516A7C; return "BTNS_HydraliskDen"; }
		if (IN_RANGE(0x00516A78, 0x00516ADC)) { *from = 0x00516A78; *to = 0x00516ADC; return "BTNS_HydraliskDen"; }
		if (IN_RANGE(0x00516ADC, 0x00516AE0)) { *from = 0x00516ADC; *to = 0x00516AE0; return "scratch"; }
		if (IN_RANGE(0x00516AE0, 0x00516AE4)) { *from = 0x00516AE0; *to = 0x00516AE4; return "BTNS_QueensNest"; }
		if (IN_RANGE(0x00516AE0, 0x00516B44)) { *from = 0x00516AE0; *to = 0x00516B44; return "BTNS_QueensNest"; }
		if (IN_RANGE(0x00516B44, 0x00516B48)) { *from = 0x00516B44; *to = 0x00516B48; return "scratch"; }
		if (IN_RANGE(0x00516B48, 0x00516B4C)) { *from = 0x00516B48; *to = 0x00516B4C; return "BTNS_DefilerMound"; }
		if (IN_RANGE(0x00516B48, 0x00516BAC)) { *from = 0x00516B48; *to = 0x00516BAC; return "BTNS_DefilerMound"; }
		if (IN_RANGE(0x00516BAC, 0x00516BB0)) { *from = 0x00516BAC; *to = 0x00516BB0; return "scratch"; }
		if (IN_RANGE(0x00516BB0, 0x00516BB4)) { *from = 0x00516BB0; *to = 0x00516BB4; return "BTNS_EvolutionChamber"; }
		if (IN_RANGE(0x00516BB0, 0x00516C00)) { *from = 0x00516BB0; *to = 0x00516C00; return "BTNS_EvolutionChamber"; }
		if (IN_RANGE(0x00516C00, 0x00516C04)) { *from = 0x00516C00; *to = 0x00516C04; return "BTNS_UltraliskCavern"; }
		if (IN_RANGE(0x00516C00, 0x00516C3C)) { *from = 0x00516C00; *to = 0x00516C3C; return "BTNS_UltraliskCavern"; }
		if (IN_RANGE(0x00516C3C, 0x00516C40)) { *from = 0x00516C3C; *to = 0x00516C40; return "BTNS_Nexus"; }
		if (IN_RANGE(0x00516C3C, 0x00516C78)) { *from = 0x00516C3C; *to = 0x00516C78; return "BTNS_Nexus"; }
		if (IN_RANGE(0x00516C78, 0x00516C7C)) { *from = 0x00516C78; *to = 0x00516C7C; return "BTNS_Probe"; }
		if (IN_RANGE(0x00516C78, 0x00516D04)) { *from = 0x00516C78; *to = 0x00516D04; return "BTNS_Probe"; }
		if (IN_RANGE(0x00516D04, 0x00516D08)) { *from = 0x00516D04; *to = 0x00516D08; return "scratch"; }
		if (IN_RANGE(0x00516D08, 0x00516D0C)) { *from = 0x00516D08; *to = 0x00516D0C; return "Buttonset Info"; }
		if (IN_RANGE(0x00516D08, 0x00516DBC)) { *from = 0x00516D08; *to = 0x00516DBC; return "Buttonset Info"; }
		if (IN_RANGE(0x00516DBC, 0x00516DC0)) { *from = 0x00516DBC; *to = 0x00516DC0; return "scratch"; }
		if (IN_RANGE(0x00516DC0, 0x00516DC4)) { *from = 0x00516DC0; *to = 0x00516DC4; return "Buttonset Info"; }
		if (IN_RANGE(0x00516DC0, 0x00516E74)) { *from = 0x00516DC0; *to = 0x00516E74; return "Buttonset Info"; }
		if (IN_RANGE(0x00516E74, 0x00516E78)) { *from = 0x00516E74; *to = 0x00516E78; return "scratch"; }
		if (IN_RANGE(0x00516E78, 0x00516E7C)) { *from = 0x00516E78; *to = 0x00516E7C; return "BTNS_HighTemplar"; }
		if (IN_RANGE(0x00516E78, 0x00516F18)) { *from = 0x00516E78; *to = 0x00516F18; return "BTNS_HighTemplar"; }
		if (IN_RANGE(0x00516F18, 0x00516F1C)) { *from = 0x00516F18; *to = 0x00516F1C; return "BTNS_DarkTemplar"; }
		if (IN_RANGE(0x00516F18, 0x00516FA4)) { *from = 0x00516F18; *to = 0x00516FA4; return "BTNS_DarkTemplar"; }
		if (IN_RANGE(0x00516FA4, 0x00516FA8)) { *from = 0x00516FA4; *to = 0x00516FA8; return "scratch"; }
		if (IN_RANGE(0x00516FA8, 0x00516FAC)) { *from = 0x00516FA8; *to = 0x00516FAC; return "BTNS_Carrier"; }
		if (IN_RANGE(0x00516FA8, 0x00517034)) { *from = 0x00516FA8; *to = 0x00517034; return "BTNS_Carrier"; }
		if (IN_RANGE(0x00517034, 0x00517038)) { *from = 0x00517034; *to = 0x00517038; return "scratch"; }
		if (IN_RANGE(0x00517038, 0x0051703C)) { *from = 0x00517038; *to = 0x0051703C; return "BTNS_Reaver"; }
		if (IN_RANGE(0x00517038, 0x005170C4)) { *from = 0x00517038; *to = 0x005170C4; return "BTNS_Reaver"; }
		if (IN_RANGE(0x005170C4, 0x005170C8)) { *from = 0x005170C4; *to = 0x005170C8; return "scratch"; }
		if (IN_RANGE(0x005170C8, 0x005170CC)) { *from = 0x005170C8; *to = 0x005170CC; return "BTNS_Arbiter"; }
		if (IN_RANGE(0x005170C8, 0x00517154)) { *from = 0x005170C8; *to = 0x00517154; return "BTNS_Arbiter"; }
		if (IN_RANGE(0x00517154, 0x00517158)) { *from = 0x00517154; *to = 0x00517158; return "scratch"; }
		if (IN_RANGE(0x00517158, 0x0051715C)) { *from = 0x00517158; *to = 0x0051715C; return "BTNS_HeroTemplar"; }
		if (IN_RANGE(0x00517158, 0x005171E4)) { *from = 0x00517158; *to = 0x005171E4; return "BTNS_HeroTemplar"; }
		if (IN_RANGE(0x005171E4, 0x005171E8)) { *from = 0x005171E4; *to = 0x005171E8; return "scratch"; }
		if (IN_RANGE(0x005171E8, 0x005171EC)) { *from = 0x005171E8; *to = 0x005171EC; return "BTNS_Corsair"; }
		if (IN_RANGE(0x005171E8, 0x00517260)) { *from = 0x005171E8; *to = 0x00517260; return "BTNS_Corsair"; }
		if (IN_RANGE(0x00517260, 0x00517264)) { *from = 0x00517260; *to = 0x00517264; return "BTNS_DarkArchon"; }
		if (IN_RANGE(0x00517260, 0x005172EC)) { *from = 0x00517260; *to = 0x005172EC; return "BTNS_DarkArchon"; }
		if (IN_RANGE(0x005172EC, 0x005172F0)) { *from = 0x005172EC; *to = 0x005172F0; return "scratch"; }
		if (IN_RANGE(0x005172F0, 0x005172F4)) { *from = 0x005172F0; *to = 0x005172F4; return "BTNS_RoboticsFacility"; }
		if (IN_RANGE(0x005172F0, 0x00517354)) { *from = 0x005172F0; *to = 0x00517354; return "BTNS_RoboticsFacility"; }
		if (IN_RANGE(0x00517354, 0x00517358)) { *from = 0x00517354; *to = 0x00517358; return "scratch"; }
		if (IN_RANGE(0x00517358, 0x0051735C)) { *from = 0x00517358; *to = 0x0051735C; return "BTNS_Gateway"; }
		if (IN_RANGE(0x00517358, 0x005173D0)) { *from = 0x00517358; *to = 0x005173D0; return "BTNS_Gateway"; }
		if (IN_RANGE(0x005173D0, 0x005173D4)) { *from = 0x005173D0; *to = 0x005173D4; return "BTNS_Stargate"; }
		if (IN_RANGE(0x005173D0, 0x00517448)) { *from = 0x005173D0; *to = 0x00517448; return "BTNS_Stargate"; }
		if (IN_RANGE(0x00517448, 0x0051744C)) { *from = 0x00517448; *to = 0x0051744C; return "BTNS_CitadelOfAdun"; }
		if (IN_RANGE(0x00517448, 0x00517470)) { *from = 0x00517448; *to = 0x00517470; return "BTNS_CitadelOfAdun"; }
		if (IN_RANGE(0x00517470, 0x00517474)) { *from = 0x00517470; *to = 0x00517474; return "BTNS_CyberneticsCore"; }
		if (IN_RANGE(0x00517470, 0x005174C0)) { *from = 0x00517470; *to = 0x005174C0; return "BTNS_CyberneticsCore"; }
		if (IN_RANGE(0x005174C0, 0x005174C4)) { *from = 0x005174C0; *to = 0x005174C4; return "BTNS_TemplarArchives"; }
		if (IN_RANGE(0x005174C0, 0x00517560)) { *from = 0x005174C0; *to = 0x00517560; return "BTNS_TemplarArchives"; }
		if (IN_RANGE(0x00517560, 0x00517564)) { *from = 0x00517560; *to = 0x00517564; return "BTNS_Forge"; }
		if (IN_RANGE(0x00517560, 0x005175B0)) { *from = 0x00517560; *to = 0x005175B0; return "BTNS_Forge"; }
		if (IN_RANGE(0x005175B0, 0x005175B4)) { *from = 0x005175B0; *to = 0x005175B4; return "BTNS_FleetBeacon"; }
		if (IN_RANGE(0x005175B0, 0x0051763C)) { *from = 0x005175B0; *to = 0x0051763C; return "BTNS_FleetBeacon"; }
		if (IN_RANGE(0x0051763C, 0x00517640)) { *from = 0x0051763C; *to = 0x00517640; return "scratch"; }
		if (IN_RANGE(0x00517640, 0x00517644)) { *from = 0x00517640; *to = 0x00517644; return "BTNS_ArbiterTribunal"; }
		if (IN_RANGE(0x00517640, 0x005176A4)) { *from = 0x00517640; *to = 0x005176A4; return "BTNS_ArbiterTribunal"; }
		if (IN_RANGE(0x005176A4, 0x005176A8)) { *from = 0x005176A4; *to = 0x005176A8; return "scratch"; }
		if (IN_RANGE(0x005176A8, 0x005176AC)) { *from = 0x005176A8; *to = 0x005176AC; return "BTNS_RoboticsSupportBay"; }
		if (IN_RANGE(0x005176A8, 0x005176F8)) { *from = 0x005176A8; *to = 0x005176F8; return "BTNS_RoboticsSupportBay"; }
		if (IN_RANGE(0x005176F8, 0x005176FC)) { *from = 0x005176F8; *to = 0x005176FC; return "BTNS_ShieldBattery"; }
		if (IN_RANGE(0x005176F8, 0x0051770C)) { *from = 0x005176F8; *to = 0x0051770C; return "BTNS_ShieldBattery"; }
		if (IN_RANGE(0x0051770C, 0x00517710)) { *from = 0x0051770C; *to = 0x00517710; return "BTNS_Observatory"; }
		if (IN_RANGE(0x0051770C, 0x00517748)) { *from = 0x0051770C; *to = 0x00517748; return "BTNS_Observatory"; }
		if (IN_RANGE(0x00517748, 0x0051774C)) { *from = 0x00517748; *to = 0x0051774C; return "Buttonset Info"; }
		if (IN_RANGE(0x00517748, 0x005177D4)) { *from = 0x00517748; *to = 0x005177D4; return "Buttonset Info"; }
		if (IN_RANGE(0x005177D4, 0x005177D8)) { *from = 0x005177D4; *to = 0x005177D8; return "scratch"; }
		if (IN_RANGE(0x005177D8, 0x005177DC)) { *from = 0x005177D8; *to = 0x005177DC; return "BTNS_Stimpack"; }
		if (IN_RANGE(0x005177D8, 0x00517850)) { *from = 0x005177D8; *to = 0x00517850; return "BTNS_Stimpack"; }
		if (IN_RANGE(0x00517850, 0x00517854)) { *from = 0x00517850; *to = 0x00517854; return "BTNS_Medic"; }
		if (IN_RANGE(0x00517850, 0x005178DC)) { *from = 0x00517850; *to = 0x005178DC; return "BTNS_Medic"; }
		if (IN_RANGE(0x005178DC, 0x005178E0)) { *from = 0x005178DC; *to = 0x005178E0; return "scratch"; }
		if (IN_RANGE(0x005178E0, 0x005178E4)) { *from = 0x005178E0; *to = 0x005178E4; return "BTNS_SCV"; }
		if (IN_RANGE(0x005178E0, 0x00517994)) { *from = 0x005178E0; *to = 0x00517994; return "BTNS_SCV"; }
		if (IN_RANGE(0x00517994, 0x00517998)) { *from = 0x00517994; *to = 0x00517998; return "scratch"; }
		if (IN_RANGE(0x00517998, 0x0051799C)) { *from = 0x00517998; *to = 0x0051799C; return "Buttonset Info"; }
		if (IN_RANGE(0x00517998, 0x00517A4C)) { *from = 0x00517998; *to = 0x00517A4C; return "Buttonset Info"; }
		if (IN_RANGE(0x00517A4C, 0x00517A50)) { *from = 0x00517A4C; *to = 0x00517A50; return "scratch"; }
		if (IN_RANGE(0x00517A50, 0x00517A54)) { *from = 0x00517A50; *to = 0x00517A54; return "Buttonset Info"; }
		if (IN_RANGE(0x00517A50, 0x00517AB4)) { *from = 0x00517A50; *to = 0x00517AB4; return "Buttonset Info"; }
		if (IN_RANGE(0x00517AB4, 0x00517AB8)) { *from = 0x00517AB4; *to = 0x00517AB8; return "scratch"; }
		if (IN_RANGE(0x00517AB8, 0x00517ABC)) { *from = 0x00517AB8; *to = 0x00517ABC; return "BTNS_Ghost"; }
		if (IN_RANGE(0x00517AB8, 0x00517B6C)) { *from = 0x00517AB8; *to = 0x00517B6C; return "BTNS_Ghost"; }
		if (IN_RANGE(0x00517B6C, 0x00517B70)) { *from = 0x00517B6C; *to = 0x00517B70; return "scratch"; }
		if (IN_RANGE(0x00517B70, 0x00517B74)) { *from = 0x00517B70; *to = 0x00517B74; return "BTNS_HeroGhost"; }
		if (IN_RANGE(0x00517B70, 0x00517C10)) { *from = 0x00517B70; *to = 0x00517C10; return "BTNS_HeroGhost"; }
		if (IN_RANGE(0x00517C10, 0x00517C14)) { *from = 0x00517C10; *to = 0x00517C14; return "BTNS_Vulture"; }
		if (IN_RANGE(0x00517C10, 0x00517C88)) { *from = 0x00517C10; *to = 0x00517C88; return "BTNS_Vulture"; }
		if (IN_RANGE(0x00517C88, 0x00517C8C)) { *from = 0x00517C88; *to = 0x00517C8C; return "BTNS_SiegeTank"; }
		if (IN_RANGE(0x00517C88, 0x00517D14)) { *from = 0x00517C88; *to = 0x00517D14; return "BTNS_SiegeTank"; }
		if (IN_RANGE(0x00517D14, 0x00517D18)) { *from = 0x00517D14; *to = 0x00517D18; return "unused"; }
		if (IN_RANGE(0x00517D18, 0x00517D1C)) { *from = 0x00517D18; *to = 0x00517D1C; return "BTNS_Wraith"; }
		if (IN_RANGE(0x00517D18, 0x00517DA4)) { *from = 0x00517D18; *to = 0x00517DA4; return "BTNS_Wraith"; }
		if (IN_RANGE(0x00517DA4, 0x00517DA8)) { *from = 0x00517DA4; *to = 0x00517DA8; return "scratch"; }
		if (IN_RANGE(0x00517DA8, 0x00517DAC)) { *from = 0x00517DA8; *to = 0x00517DAC; return "BTNS_ScienceVessel"; }
		if (IN_RANGE(0x00517DA8, 0x00517E48)) { *from = 0x00517DA8; *to = 0x00517E48; return "BTNS_ScienceVessel"; }
		if (IN_RANGE(0x00517E48, 0x00517E4C)) { *from = 0x00517E48; *to = 0x00517E4C; return "BTNS_Battlecruiser"; }
		if (IN_RANGE(0x00517E48, 0x00517EC0)) { *from = 0x00517E48; *to = 0x00517EC0; return "BTNS_Battlecruiser"; }
		if (IN_RANGE(0x00517EC0, 0x00517EC4)) { *from = 0x00517EC0; *to = 0x00517EC4; return "BTNS_RaynorVulture"; }
		if (IN_RANGE(0x00517EC0, 0x00517F38)) { *from = 0x00517EC0; *to = 0x00517F38; return "BTNS_RaynorVulture"; }
		if (IN_RANGE(0x00517F38, 0x00517F3C)) { *from = 0x00517F38; *to = 0x00517F3C; return "BTNS_CommandCenter"; }
		if (IN_RANGE(0x00517F38, 0x00518000)) { *from = 0x00517F38; *to = 0x00518000; return "BTNS_CommandCenter"; }
		if (IN_RANGE(0x00518000, 0x00518004)) { *from = 0x00518000; *to = 0x00518004; return "BTNS_ComsatStation"; }
		if (IN_RANGE(0x00518000, 0x00518014)) { *from = 0x00518000; *to = 0x00518014; return "BTNS_ComsatStation"; }
		if (IN_RANGE(0x00518014, 0x00518018)) { *from = 0x00518014; *to = 0x00518018; return "BTNS_NuclearSilo"; }
		if (IN_RANGE(0x00518014, 0x0051803C)) { *from = 0x00518014; *to = 0x0051803C; return "BTNS_NuclearSilo"; }
		if (IN_RANGE(0x0051803C, 0x00518040)) { *from = 0x0051803C; *to = 0x00518040; return "BTNS_Bunker"; }
		if (IN_RANGE(0x0051803C, 0x00518064)) { *from = 0x0051803C; *to = 0x00518064; return "BTNS_Bunker"; }
		if (IN_RANGE(0x00518068, 0x0051806C)) { *from = 0x00518068; *to = 0x0051806C; return "BTNS_Barracks"; }
		if (IN_RANGE(0x00518068, 0x00518144)) { *from = 0x00518068; *to = 0x00518144; return "BTNS_Barracks"; }
		if (IN_RANGE(0x00518144, 0x00518148)) { *from = 0x00518144; *to = 0x00518148; return "scratch"; }
		if (IN_RANGE(0x00518148, 0x0051814C)) { *from = 0x00518148; *to = 0x0051814C; return "BTNS_Factory"; }
		if (IN_RANGE(0x00518148, 0x00518238)) { *from = 0x00518148; *to = 0x00518238; return "BTNS_Factory"; }
		if (IN_RANGE(0x00518238, 0x0051823C)) { *from = 0x00518238; *to = 0x0051823C; return "BTNS_ScienceFacility"; }
		if (IN_RANGE(0x00518238, 0x00518328)) { *from = 0x00518238; *to = 0x00518328; return "BTNS_ScienceFacility"; }
		if (IN_RANGE(0x00518328, 0x0051832C)) { *from = 0x00518328; *to = 0x0051832C; return "BTNS_Starport"; }
		if (IN_RANGE(0x00518328, 0x0051842C)) { *from = 0x00518328; *to = 0x0051842C; return "BTNS_Starport"; }
		if (IN_RANGE(0x0051842C, 0x00518430)) { *from = 0x0051842C; *to = 0x00518430; return "scratch"; }
		if (IN_RANGE(0x00518430, 0x00518434)) { *from = 0x00518430; *to = 0x00518434; return "BTNS_ControlTower"; }
		if (IN_RANGE(0x00518430, 0x00518480)) { *from = 0x00518430; *to = 0x00518480; return "BTNS_ControlTower"; }
		if (IN_RANGE(0x00518480, 0x00518484)) { *from = 0x00518480; *to = 0x00518484; return "BTNS_EngineeringBay"; }
		if (IN_RANGE(0x00518480, 0x0051850C)) { *from = 0x00518480; *to = 0x0051850C; return "BTNS_EngineeringBay"; }
		if (IN_RANGE(0x0051850C, 0x00518510)) { *from = 0x0051850C; *to = 0x00518510; return "scratch"; }
		if (IN_RANGE(0x00518510, 0x00518514)) { *from = 0x00518510; *to = 0x00518514; return "BTNS_CovertOps"; }
		if (IN_RANGE(0x00518510, 0x00518588)) { *from = 0x00518510; *to = 0x00518588; return "BTNS_CovertOps"; }
		if (IN_RANGE(0x00518588, 0x0051858C)) { *from = 0x00518588; *to = 0x0051858C; return "BTNS_PhysicsLab"; }
		if (IN_RANGE(0x00518588, 0x005185D8)) { *from = 0x00518588; *to = 0x005185D8; return "BTNS_PhysicsLab"; }
		if (IN_RANGE(0x005185D8, 0x005185DC)) { *from = 0x005185D8; *to = 0x005185DC; return "BTNS_Armory"; }
		if (IN_RANGE(0x005185D8, 0x0051863C)) { *from = 0x005185D8; *to = 0x0051863C; return "BTNS_Armory"; }
		if (IN_RANGE(0x0051863C, 0x00518640)) { *from = 0x0051863C; *to = 0x00518640; return "scratch"; }
		if (IN_RANGE(0x00518640, 0x00518644)) { *from = 0x00518640; *to = 0x00518644; return "BTNS_Academy"; }
		if (IN_RANGE(0x00518640, 0x005186CC)) { *from = 0x00518640; *to = 0x005186CC; return "BTNS_Academy"; }
		if (IN_RANGE(0x005186CC, 0x005186D0)) { *from = 0x005186CC; *to = 0x005186D0; return "scratch"; }
		if (IN_RANGE(0x005186D0, 0x005186D4)) { *from = 0x005186D0; *to = 0x005186D4; return "BTNS_MachineSHop"; }
		if (IN_RANGE(0x005186D0, 0x00518748)) { *from = 0x005186D0; *to = 0x00518748; return "BTNS_MachineSHop"; }
		if (IN_RANGE(0x00518748, 0x0051874C)) { *from = 0x00518748; *to = 0x0051874C; return "BTNS_InfestedCommandCenter"; }
		if (IN_RANGE(0x00518748, 0x005187D4)) { *from = 0x00518748; *to = 0x005187D4; return "BTNS_InfestedCommandCenter"; }
		if (IN_RANGE(0x005187D4, 0x005187D8)) { *from = 0x005187D4; *to = 0x005187D8; return "BTNS_FlagBeacon"; }
		if (IN_RANGE(0x005187D4, 0x005187E8)) { *from = 0x005187D4; *to = 0x005187E8; return "BTNS_FlagBeacon"; }
		if (IN_RANGE(0x005187E8, 0x005193A0)) { *from = 0x005187E8; *to = 0x005193A0; return "Unit buttonpage map"; }
		if (IN_RANGE(0x005193A0, 0x00519E50)) { *from = 0x005193A0; *to = 0x00519E50; return "Unit status card/HUD info"; }
		if (IN_RANGE(0x0051A280, 0x0051A28C)) { *from = 0x0051A280; *to = 0x0051A28C; return expand ? getPlayerTriggerDataDescription(offset) : "Player 1 TriggerList"; }
		if (IN_RANGE(0x0051A28C, 0x0051A298)) { *from = 0x0051A28C; *to = 0x0051A298; return expand ? getPlayerTriggerDataDescription(offset) : "Player 2 TriggerList"; }
		if (IN_RANGE(0x0051A298, 0x0051A2A4)) { *from = 0x0051A298; *to = 0x0051A2A4; return expand ? getPlayerTriggerDataDescription(offset) : "Player 3 TriggerList"; }
		if (IN_RANGE(0x0051A2A4, 0x0051A2B0)) { *from = 0x0051A2A4; *to = 0x0051A2B0; return expand ? getPlayerTriggerDataDescription(offset) : "Player 4 TriggerList"; }
		if (IN_RANGE(0x0051A2B0, 0x0051A2BC)) { *from = 0x0051A2B0; *to = 0x0051A2BC; return expand ? getPlayerTriggerDataDescription(offset) : "Player 5 TriggerList"; }
		if (IN_RANGE(0x0051A2BC, 0x0051A2C8)) { *from = 0x0051A2BC; *to = 0x0051A2C8; return expand ? getPlayerTriggerDataDescription(offset) : "Player 6 TriggerList"; }
		if (IN_RANGE(0x0051A2C8, 0x0051A2D4)) { *from = 0x0051A2C8; *to = 0x0051A2D4; return expand ? getPlayerTriggerDataDescription(offset) : "Player 7 TriggerList"; }
		if (IN_RANGE(0x0051A2D4, 0x0051A2E0)) { *from = 0x0051A2D4; *to = 0x0051A2E0; return expand ? getPlayerTriggerDataDescription(offset) : "Player 8 TriggerList"; }
		if (IN_RANGE(0x0051A424, 0x0051A43A)) { *from = 0x0051A424; *to = 0x0051A43A; return "scratch"; }
		if (IN_RANGE(0x0051A440, 0x0051A457)) { *from = 0x0051A440; *to = 0x0051A457; return "scratch"; }
		if (IN_RANGE(0x0051AAB0, 0x0051AAC7)) { *from = 0x0051AAB0; *to = 0x0051AAC7; return "scratch"; }
		if (IN_RANGE(0x0051AAC8, 0x0051AADF)) { *from = 0x0051AAC8; *to = 0x0051AADF; return "scratch"; }
		if (IN_RANGE(0x0051AAE0, 0x0051AAF7)) { *from = 0x0051AAE0; *to = 0x0051AAF7; return "scratch"; }
		if (IN_RANGE(0x0051AB94, 0x0051ABAD)) { *from = 0x0051AB94; *to = 0x0051ABAD; return "scratch"; }
		if (IN_RANGE(0x0051ABB0, 0x0051ABC0)) { *from = 0x0051ABB0; *to = 0x0051ABC0; return "speedSettingsCallbacks"; }
		if (IN_RANGE(0x0051ABC0, 0x0051ABD4)) { *from = 0x0051ABC0; *to = 0x0051ABD4; return "videoSettingsCallbacks"; }
		if (IN_RANGE(0x0051ABD4, 0x0051ABEE)) { *from = 0x0051ABD4; *to = 0x0051ABEE; return "scratch"; }
		if (IN_RANGE(0x0051ABF0, 0x0051ABFC)) { *from = 0x0051ABF0; *to = 0x0051ABFC; return "tipsDialogCallbacks"; }
		if (IN_RANGE(0x0051ABFC, 0x0051AC10)) { *from = 0x0051ABFC; *to = 0x0051AC10; return "AI distance checking?"; }
		if (IN_RANGE(0x0051AC10, 0x0051AC29)) { *from = 0x0051AC10; *to = 0x0051AC29; return "scratch"; }
		if (IN_RANGE(0x0051AC2C, 0x0051AC44)) { *from = 0x0051AC2C; *to = 0x0051AC44; return "scratch"; }
		if (IN_RANGE(0x0051AC48, 0x0051AC5A)) { *from = 0x0051AC48; *to = 0x0051AC5A; return "scratch"; }
		if (IN_RANGE(0x0051AC5C, 0x0051AC73)) { *from = 0x0051AC5C; *to = 0x0051AC73; return "scratch"; }
		if (IN_RANGE(0x0051AC74, 0x0051AC84)) { *from = 0x0051AC74; *to = 0x0051AC84; return "loadSaveDialogCallbacks"; }
		if (IN_RANGE(0x0051AD18, 0x0051AD2E)) { *from = 0x0051AD18; *to = 0x0051AD2E; return "scratch"; }
		if (IN_RANGE(0x0051BAF8, 0x0051BBF8)) { *from = 0x0051BAF8; *to = 0x0051BBF8; return "scratch"; }
		if (IN_RANGE(0x0051CA14, 0x0051CA18)) { *from = 0x0051CA14; *to = 0x0051CA18; return "lastRandomNumber"; }
		if (IN_RANGE(0x0051CE70, 0x0051CE8C)) { *from = 0x0051CE70; *to = 0x0051CE8C; return "latencyFrameCount"; }
		if (IN_RANGE(0x0051CE8C, 0x0051CE90)) { *from = 0x0051CE8C; *to = 0x0051CE90; return "lastInputTickCount"; }
		if (IN_RANGE(0x0051CE98, 0x0051CE9C)) { *from = 0x0051CE98; *to = 0x0051CE9C; return "fowUpdateCounter"; }
		if (IN_RANGE(0x0051CEA0, 0x0051CEA4)) { *from = 0x0051CEA0; *to = 0x0051CEA4; return "currentSpeedLatFrameCount"; }
		if (IN_RANGE(0x0051CED0, 0x0051DE6C)) { *from = 0x0051CED0; *to = 0x0051DE6C; return "imagesGRPGraphic"; }
		if (IN_RANGE(0x0051F2A8, 0x005240B4)) { *from = 0x0051F2A8; *to = 0x005240B4; return "imagesAttackOverlayGraphic"; }
		if (IN_RANGE(0x005240D0, 0x005244B7)) { *from = 0x005240D0; *to = 0x005244B7; return "imagesDamageOverlayFrame"; }
		if (IN_RANGE(0x0052E4C0, 0x0052E4C4)) { *from = 0x0052E4C0; *to = 0x0052E4C4; return "pFirstSelectionCircleImage"; }
		if (IN_RANGE(0x0052E5C8, 0x0052F564)) { *from = 0x0052E5C8; *to = 0x0052F564; return "imagesShieldOverlayGraphic"; }
		if (IN_RANGE(0x0052F568, 0x0057D768)) { *from = 0x0052F568; *to = 0x0057D768; return "images"; }
		if (IN_RANGE(0x0057EB68, 0x0057EB6C)) { *from = 0x0057EB68; *to = 0x0057EB6C; return "pFirstImage"; }
		if (IN_RANGE(0x0057EB70, 0x0057EB74)) { *from = 0x0057EB70; *to = 0x0057EB74; return "pLastImage"; }
		if (IN_RANGE(0x0057EEE0, 0x0057F090)) { *from = 0x0057EEE0; *to = 0x0057F090; return "playerInfo"; }
		if (IN_RANGE(0x0057F090, 0x0057F094)) { *from = 0x0057F090; *to = 0x0057F094; return "provider_LatencyCalls"; }
		if (IN_RANGE(0x0057F0B4, 0x0057F0B5)) { *from = 0x0057F0B4; *to = 0x0057F0B5; return "gbMultiPlayerMode"; }
		if (IN_RANGE(0x0057F0D8, 0x0057F0DC)) { *from = 0x0057F0D8; *to = 0x0057F0DC; return "provider_maxBufferSize"; }
		if (IN_RANGE(0x0057F0F0, 0x005967F0)) { *from = 0x0057F0F0; *to = 0x005967F0; return expand ? getGamedataDescription(offset) : "gameData"; }
		if (IN_RANGE(0x005967F8, 0x00596885)) { *from = 0x005967F8; *to = 0x00596885; return "netMakeGameData"; }
		if (IN_RANGE(0x00596A18, 0x00596B17)) { *from = 0x00596A18; *to = 0x00596B17; return "VK_Array"; }
		if (IN_RANGE(0x00597208, 0x0059723C)) { *from = 0x00597208; *to = 0x0059723C; return "localSelectionGroup"; }
		if (IN_RANGE(0x00597238, 0x0059723C)) { *from = 0x00597238; *to = 0x0059723C; return "pGameScreenInfo"; }
		if (IN_RANGE(0x0059723C, 0x0059723D)) { *from = 0x0059723C; *to = 0x0059723D; return "bUnitSelectionNeedsUpdate"; }
		if (IN_RANGE(0x005973A0, 0x005993A0)) { *from = 0x005973A0; *to = 0x005993A0; return "dark_pcx_imageBuffer"; }
		if (IN_RANGE(0x005993C4, 0x005993C8)) { *from = 0x005993C4; *to = 0x005993C8; return "gfpMIMap"; }
		if (IN_RANGE(0x005993D4, 0x005993D8)) { *from = 0x005993D4; *to = 0x005993D8; return "pChkStrings"; }
		if (IN_RANGE(0x0059C6C0, 0x0059CAC0)) { *from = 0x0059C6C0; *to = 0x0059CAC0; return "picturePalette_Copy"; }
		if (IN_RANGE(0x0059CB5C, 0x0059CB60)) { *from = 0x0059CB5C; *to = 0x0059CB60; return "minimap something"; }
		if (IN_RANGE(0x0059CB60, 0x0059CC60)) { *from = 0x0059CB60; *to = 0x0059CC60; return "Some kind of minimap buffer (256 bytes)"; }
		if (IN_RANGE(0x0059CC78, 0x0059CC7C)) { *from = 0x0059CC78; *to = 0x0059CC7C; return "countdownTimeRemaining"; }
		if (IN_RANGE(0x0059CC80, 0x0059CC84)) { *from = 0x0059CC80; *to = 0x0059CC84; return "dropTimer"; }
		if (IN_RANGE(0x0059CCA8, 0x006283E8)) { *from = 0x0059CCA8; *to = 0x006283E8; return "units"; }
		if (IN_RANGE(0x006283F0, 0x006283F4)) { *from = 0x006283F0; *to = 0x006283F4; return "usedUnitCount"; }
		if (IN_RANGE(0x006283F8, 0x00628428)) { *from = 0x006283F8; *to = 0x00628428; return "playerUnitPointers"; }
		if (IN_RANGE(0x00628428, 0x0062842C)) { *from = 0x00628428; *to = 0x0062842C; return "LastHiddenUnitPointer"; }
		if (IN_RANGE(0x0062842C, 0x00628430)) { *from = 0x0062842C; *to = 0x00628430; return "unknownPointer?"; }
		if (IN_RANGE(0x00628430, 0x00628434)) { *from = 0x00628430; *to = 0x00628434; return "FirstUnitPointer"; }
		if (IN_RANGE(0x00628434, 0x00628438)) { *from = 0x00628434; *to = 0x00628438; return "LastScannerSweepPointer"; }
		if (IN_RANGE(0x00628438, 0x0062843C)) { *from = 0x00628438; *to = 0x0062843C; return "pFirstEmptyUnit"; }
		if (IN_RANGE(0x0062843C, 0x00628440)) { *from = 0x0062843C; *to = 0x00628440; return "pLastEmptyUnit"; }
		if (IN_RANGE(0x00628444, 0x00628448)) { *from = 0x00628444; *to = 0x00628448; return "vr4FileHandle"; }
		if (IN_RANGE(0x00628448, 0x0062844C)) { *from = 0x00628448; *to = 0x0062844C; return "screenX"; }
		if (IN_RANGE(0x00628454, 0x00628458)) { *from = 0x00628454; *to = 0x00628458; return "terrainCacheBitmap"; }
		if (IN_RANGE(0x00628458, 0x0062845C)) { *from = 0x00628458; *to = 0x0062845C; return "vx4FileHandle"; }
		if (IN_RANGE(0x00628470, 0x00628474)) { *from = 0x00628470; *to = 0x00628474; return "screenY"; }
		if (IN_RANGE(0x0062848C, 0x00628490)) { *from = 0x0062848C; *to = 0x00628490; return "glScrollPixelX"; }
		if (IN_RANGE(0x00628494, 0x00628498)) { *from = 0x00628494; *to = 0x00628498; return "gfpCellMap"; }
		if (IN_RANGE(0x00628498, 0x0062849A)) { *from = 0x00628498; *to = 0x0062849A; return "__scrMoveX"; }
		if (IN_RANGE(0x006284A8, 0x006284AC)) { *from = 0x006284A8; *to = 0x006284AC; return "glScrollPixelY"; }
		if (IN_RANGE(0x006284AC, 0x006284AE)) { *from = 0x006284AC; *to = 0x006284AE; return "__scrMoveY"; }
		if (IN_RANGE(0x006284B8, 0x006284E8)) { *from = 0x006284B8; *to = 0x006284E8; return "CurrentUnitSelection"; }
		if (IN_RANGE(0x006284E8, 0x00628668)) { *from = 0x006284E8; *to = 0x00628668; return "AllPlayerSelectionGroups"; }
		if (IN_RANGE(0x00629C90, 0x00629D90)) { *from = 0x00629C90; *to = 0x00629D90; return "regionVisionFilter"; }
		if (IN_RANGE(0x00629D98, 0x0063FD28)) { *from = 0x00629D98; *to = 0x0063FD28; return "Sprites"; }
		if (IN_RANGE(0x0063FE30, 0x0063FE34)) { *from = 0x0063FE30; *to = 0x0063FE34; return "pFirstEmptySprite"; }
		if (IN_RANGE(0x0063FE34, 0x0063FE38)) { *from = 0x0063FE34; *to = 0x0063FE38; return "pLastEmptySprite"; }
		if (IN_RANGE(0x0063FED8, 0x0063FEDC)) { *from = 0x0063FED8; *to = 0x0063FEDC; return "path something"; }
		if (IN_RANGE(0x0063FF40, 0x0063FF44)) { *from = 0x0063FF40; *to = 0x0063FF44; return "path something"; }
		if (IN_RANGE(0x0063FF78, 0x006402B4)) { *from = 0x0063FF78; *to = 0x006402B4; return "TerranSoundList"; }
		if (IN_RANGE(0x006402B8, 0x00640548)) { *from = 0x006402B8; *to = 0x00640548; return "zergSoundList"; }
		if (IN_RANGE(0x00640550, 0x0064086A)) { *from = 0x00640550; *to = 0x0064086A; return "ProtossSoundList"; }
		if (IN_RANGE(0x0064086C, 0x00640870)) { *from = 0x0064086C; *to = 0x00640870; return "useQuietSounds"; }
		if (IN_RANGE(0x00640B58, 0x00640B59)) { *from = 0x00640B58; *to = 0x00640B59; return "nextDisplayTextLine"; }
		if (IN_RANGE(0x00640B5C, 0x00640B60)) { *from = 0x00640B5C; *to = 0x00640B60; return "scratch"; }
		if (IN_RANGE(0x00640B60, 0x00641672)) { *from = 0x00640B60; *to = 0x00641672; return "gameText"; }
		if (IN_RANGE(0x0064169C, 0x006416A0)) { *from = 0x0064169C; *to = 0x006416A0; return "scratch"; }
		if (IN_RANGE(0x0064DEBC, 0x0064DEC0)) { *from = 0x0064DEBC; *to = 0x0064DEC0; return "bulletCount"; }
		if (IN_RANGE(0x0064EED8, 0x0064EEDC)) { *from = 0x0064EED8; *to = 0x0064EEDC; return "pFirstUnusedBullet"; }
		if (IN_RANGE(0x0064EEDC, 0x0064EEE0)) { *from = 0x0064EEDC; *to = 0x0064EEE0; return "pLastUnusedBullet"; }
		if (IN_RANGE(0x006509A0, 0x006509A2)) { *from = 0x006509A0; *to = 0x006509A2; return "triggerTimer"; }
		if (IN_RANGE(0x006509B0, 0x006509B4)) { *from = 0x006509B0; *to = 0x006509B4; return "currentTrigPlayerID"; }
		if (IN_RANGE(0x00654880, 0x00654A80)) { *from = 0x00654880; *to = 0x00654A80; return "TurnBuffer"; }
		if (IN_RANGE(0x00654AA0, 0x00654AA4)) { *from = 0x00654AA0; *to = 0x00654AA4; return "sgdwBytesInCmdQueue"; }
		if (IN_RANGE(0x006556E4, 0x006556E8)) { *from = 0x006556E4; *to = 0x006556E8; return "gdwLatency"; }
		if (IN_RANGE(0x00655700, 0x0065573D)) { *from = 0x00655700; *to = 0x0065573D; return "upgrades_repeats"; }
		if (IN_RANGE(0x00655740, 0x006557BA)) { *from = 0x00655740; *to = 0x006557BA; return "upgrades_OreCostBase"; }
		if (IN_RANGE(0x006557BC, 0x006557C0)) { *from = 0x006557BC; *to = 0x006557C0; return "scratch"; }
		if (IN_RANGE(0x006557C0, 0x0065583A)) { *from = 0x006557C0; *to = 0x0065583A; return "upgrades_GasCostFactor"; }
		if (IN_RANGE(0x0065583C, 0x00655840)) { *from = 0x0065583C; *to = 0x00655840; return "scratch"; }
		if (IN_RANGE(0x00655840, 0x006558BA)) { *from = 0x00655840; *to = 0x006558BA; return "upgrades_GasCostBase"; }
		if (IN_RANGE(0x006558C0, 0x0065593A)) { *from = 0x006558C0; *to = 0x0065593A; return "guwUpgradeDepIndex"; }
		if (IN_RANGE(0x00655940, 0x006559BA)) { *from = 0x00655940; *to = 0x006559BA; return "upgrades_TimeCostFactor"; }
		if (IN_RANGE(0x006559BC, 0x006559C0)) { *from = 0x006559BC; *to = 0x006559C0; return "scratch"; }
		if (IN_RANGE(0x006559C0, 0x00655A3A)) { *from = 0x006559C0; *to = 0x00655A3A; return "upgrades_OreCostFactor"; }
		if (IN_RANGE(0x00655A40, 0x00655ABA)) { *from = 0x00655A40; *to = 0x00655ABA; return "upgrades_label"; }
		if (IN_RANGE(0x00655AC0, 0x00655B3A)) { *from = 0x00655AC0; *to = 0x00655B3A; return "upgrades_Icon"; }
		if (IN_RANGE(0x00655B3C, 0x00655B79)) { *from = 0x00655B3C; *to = 0x00655B79; return "upgrades_isBroodwar"; }
		if (IN_RANGE(0x00655B7C, 0x00655B80)) { *from = 0x00655B7C; *to = 0x00655B80; return "scratch"; }
		if (IN_RANGE(0x00655B80, 0x00655BFA)) { *from = 0x00655B80; *to = 0x00655BFA; return "upgrades_TimeCostBase"; }
		if (IN_RANGE(0x00655BFC, 0x00655C39)) { *from = 0x00655BFC; *to = 0x00655C39; return "upgrades_race"; }
		if (IN_RANGE(0x00655C58, 0x00655E10)) { *from = 0x00655C58; *to = 0x00655E10; return "portdata_IdleDir"; }
		if (IN_RANGE(0x00655E80, 0x00656038)) { *from = 0x00655E80; *to = 0x00656038; return "portdata_TalkingDir"; }
		if (IN_RANGE(0x00656198, 0x006561F0)) { *from = 0x00656198; *to = 0x006561F0; return "guwTechDepIndex"; }
		if (IN_RANGE(0x006561F0, 0x00656248)) { *from = 0x006561F0; *to = 0x00656248; return "techdata_GasCost"; }
		if (IN_RANGE(0x00656248, 0x006562A0)) { *from = 0x00656248; *to = 0x006562A0; return "techdata_oreCost"; }
		if (IN_RANGE(0x006562A0, 0x006562F8)) { *from = 0x006562A0; *to = 0x006562F8; return "techdata_label"; }
		if (IN_RANGE(0x006562F8, 0x00656350)) { *from = 0x006562F8; *to = 0x00656350; return "guwTechUseDepIndex"; }
		if (IN_RANGE(0x00656350, 0x0065637C)) { *from = 0x00656350; *to = 0x0065637C; return "techdata_DefaultResearched"; }
		if (IN_RANGE(0x0065637C, 0x00656380)) { *from = 0x0065637C; *to = 0x00656380; return "scratch"; }
		if (IN_RANGE(0x00656380, 0x006563D8)) { *from = 0x00656380; *to = 0x006563D8; return "techdata_EnergyCost"; }
		if (IN_RANGE(0x006563D8, 0x00656430)) { *from = 0x006563D8; *to = 0x00656430; return "techdata_TimeCost"; }
		if (IN_RANGE(0x00656430, 0x00656488)) { *from = 0x00656430; *to = 0x00656488; return "techdata_Icon"; }
		if (IN_RANGE(0x00656488, 0x006564B4)) { *from = 0x00656488; *to = 0x006564B4; return "techdata_race"; }
		if (IN_RANGE(0x006564B4, 0x006564E0)) { *from = 0x006564B4; *to = 0x006564E0; return "techdata_isBroodwar"; }
		if (IN_RANGE(0x006564E0, 0x00656562)) { *from = 0x006564E0; *to = 0x00656562; return "weaponsdat_dmgFactor"; }
		if (IN_RANGE(0x00656568, 0x0065666C)) { *from = 0x00656568; *to = 0x0065666C; return "weaponsdat_targetErrorStr"; }
		if (IN_RANGE(0x00656670, 0x006566F2)) { *from = 0x00656670; *to = 0x006566F2; return "gubWeapFireType"; }
		if (IN_RANGE(0x006566F4, 0x006566F8)) { *from = 0x006566F4; *to = 0x006566F8; return "scratch"; }
		if (IN_RANGE(0x006566F8, 0x0065677A)) { *from = 0x006566F8; *to = 0x0065677A; return "gubWeapDamageType"; }
		if (IN_RANGE(0x0065677C, 0x00656780)) { *from = 0x0065677C; *to = 0x00656780; return "scratch"; }
		if (IN_RANGE(0x00656780, 0x00656884)) { *from = 0x00656780; *to = 0x00656884; return "weaponsdat_icon"; }
		if (IN_RANGE(0x00656884, 0x00656888)) { *from = 0x00656884; *to = 0x00656888; return "scratch"; }
		if (IN_RANGE(0x00656888, 0x0065698C)) { *from = 0x00656888; *to = 0x0065698C; return "weaponsdat_innerSplash"; }
		if (IN_RANGE(0x0065698C, 0x00656990)) { *from = 0x0065698C; *to = 0x00656990; return "scratch"; }
		if (IN_RANGE(0x00656990, 0x00656A12)) { *from = 0x00656990; *to = 0x00656A12; return "weaponsdat_AttackAngle"; }
		if (IN_RANGE(0x00656A14, 0x00656A18)) { *from = 0x00656A14; *to = 0x00656A18; return "scratch"; }
		if (IN_RANGE(0x00656A18, 0x00656C20)) { *from = 0x00656A18; *to = 0x00656C20; return "weaponsdat_minRange"; }
		if (IN_RANGE(0x00656C20, 0x00656CA2)) { *from = 0x00656C20; *to = 0x00656CA2; return "weaponsdat_upwardOffset"; }
		if (IN_RANGE(0x00656CA4, 0x00656CA8)) { *from = 0x00656CA4; *to = 0x00656CA8; return "scratch"; }
		if (IN_RANGE(0x00656CA8, 0x00656EB0)) { *from = 0x00656CA8; *to = 0x00656EB0; return "weaponsdat_graphics"; }
		if (IN_RANGE(0x00656EB0, 0x00656FB4)) { *from = 0x00656EB0; *to = 0x00656FB4; return "weaponsdat_dmgAmount"; }
		if (IN_RANGE(0x00656FB4, 0x00656FB8)) { *from = 0x00656FB4; *to = 0x00656FB8; return "scratch"; }
		if (IN_RANGE(0x00656FB8, 0x0065703A)) { *from = 0x00656FB8; *to = 0x0065703A; return "gnWeapCooldown"; }
		if (IN_RANGE(0x0065703C, 0x00657040)) { *from = 0x0065703C; *to = 0x00657040; return "scratch"; }
		if (IN_RANGE(0x00657040, 0x006570C2)) { *from = 0x00657040; *to = 0x006570C2; return "weaponsdat_removeAfter"; }
		if (IN_RANGE(0x006570C4, 0x006570C8)) { *from = 0x006570C4; *to = 0x006570C8; return "scratch"; }
		if (IN_RANGE(0x006570C8, 0x006571CC)) { *from = 0x006570C8; *to = 0x006571CC; return "weaponsdat_middleSplash"; }
		if (IN_RANGE(0x006571CC, 0x006571D0)) { *from = 0x006571CC; *to = 0x006571D0; return "scratch"; }
		if (IN_RANGE(0x006571D0, 0x00657252)) { *from = 0x006571D0; *to = 0x00657252; return "weaponsdat_damageUpgrade"; }
		if (IN_RANGE(0x00657254, 0x00657258)) { *from = 0x00657254; *to = 0x00657258; return "scratch"; }
		if (IN_RANGE(0x00657258, 0x006572DA)) { *from = 0x00657258; *to = 0x006572DA; return "weaponsdat_wpnType"; }
		if (IN_RANGE(0x006572DC, 0x006572E0)) { *from = 0x006572DC; *to = 0x006572E0; return "scratch"; }
		if (IN_RANGE(0x006572E0, 0x006573E4)) { *from = 0x006572E0; *to = 0x006573E4; return "weaponsdat_label"; }
		if (IN_RANGE(0x006573E4, 0x006573E8)) { *from = 0x006573E4; *to = 0x006573E8; return "scratch"; }
		if (IN_RANGE(0x006573E8, 0x0065746A)) { *from = 0x006573E8; *to = 0x0065746A; return "weaponsdat_technology"; }
		if (IN_RANGE(0x0065746C, 0x00657470)) { *from = 0x0065746C; *to = 0x00657470; return "scratch"; }
		if (IN_RANGE(0x00657470, 0x00657678)) { *from = 0x00657470; *to = 0x00657678; return "weaponsdat_maxRange"; }
		if (IN_RANGE(0x00657678, 0x0065777C)) { *from = 0x00657678; *to = 0x0065777C; return "weaponsdat_dmgBonus"; }
		if (IN_RANGE(0x00657780, 0x00657884)) { *from = 0x00657780; *to = 0x00657884; return "weaponsdat_outerSplash"; }
		if (IN_RANGE(0x00657888, 0x0065790A)) { *from = 0x00657888; *to = 0x0065790A; return "weaponsdat_LaunchSpin"; }
		if (IN_RANGE(0x0065790C, 0x00657910)) { *from = 0x0065790C; *to = 0x00657910; return "scratch"; }
		if (IN_RANGE(0x00657910, 0x00657992)) { *from = 0x00657910; *to = 0x00657992; return "weaponsdat_ForwardOffset"; }
		if (IN_RANGE(0x00657998, 0x00657A9C)) { *from = 0x00657998; *to = 0x00657A9C; return "weaponsdat_targetFlags"; }
		if (IN_RANGE(0x00657A9C, 0x00657A9D)) { *from = 0x00657A9C; *to = 0x00657A9D; return "Fog of war mask for revealed areas"; }
		if (IN_RANGE(0x00657AA0, 0x00658AA0)) { *from = 0x00657AA0; *to = 0x00658AA0; return "4096-byte array of something (fog related) (does nothing?)"; }
		if (IN_RANGE(0x0065FC18, 0x0065FCFC)) { *from = 0x0065FC18; *to = 0x0065FCFC; return "unitsdat_MaxAirHits"; }
		if (IN_RANGE(0x0065FD00, 0x0065FEC8)) { *from = 0x0065FD00; *to = 0x0065FEC8; return "unitsdat_GasCost"; }
		if (IN_RANGE(0x0065FEC8, 0x0065FFAC)) { *from = 0x0065FEC8; *to = 0x0065FFAC; return "unitsdat_Armor"; }
		if (IN_RANGE(0x0065FFB0, 0x00660178)) { *from = 0x0065FFB0; *to = 0x00660178; return "unitsdat_WhatSoundStart"; }
		if (IN_RANGE(0x00660178, 0x0066025C)) { *from = 0x00660178; *to = 0x0066025C; return "unitsdat_AIInternal"; }
		if (IN_RANGE(0x00660260, 0x00660428)) { *from = 0x00660260; *to = 0x00660428; return "unitsdat_UnitMapString"; }
		if (IN_RANGE(0x00660428, 0x006605F0)) { *from = 0x00660428; *to = 0x006605F0; return "unitsdat_TimeCost"; }
		if (IN_RANGE(0x006605F0, 0x006606D4)) { *from = 0x006605F0; *to = 0x006606D4; return "unitsdat_UnitDirection"; }
		if (IN_RANGE(0x006606D8, 0x006607BC)) { *from = 0x006606D8; *to = 0x006607BC; return "unitsdat_isBroodwarUnit"; }
		if (IN_RANGE(0x006607C0, 0x00660988)) { *from = 0x006607C0; *to = 0x00660988; return "unitsdat_Subunit1"; }
		if (IN_RANGE(0x00660988, 0x00660A6C)) { *from = 0x00660988; *to = 0x00660A6C; return "unitsdat_SpaceProvided"; }
		if (IN_RANGE(0x00660A70, 0x00660C38)) { *from = 0x00660A70; *to = 0x00660C38; return "guwUnitDepIndex"; }
		if (IN_RANGE(0x00660C38, 0x00660E00)) { *from = 0x00660C38; *to = 0x00660E00; return "unitsdat_Subunit2"; }
		if (IN_RANGE(0x00660E00, 0x00660FC8)) { *from = 0x00660E00; *to = 0x00660FC8; return "guwUnitShields"; }
		if (IN_RANGE(0x00660FC8, 0x006610AC)) { *from = 0x00660FC8; *to = 0x006610AC; return "unitsdat_movementflags"; }
		if (IN_RANGE(0x006610AC, 0x006610B0)) { *from = 0x006610AC; *to = 0x006610B0; return "scratch"; }
		if (IN_RANGE(0x006610B0, 0x00661440)) { *from = 0x006610B0; *to = 0x00661440; return "unitsdat_ConstructionAnimationGfx"; }
		if (IN_RANGE(0x00661440, 0x00661514)) { *from = 0x00661440; *to = 0x00661514; return "unitsdat_YesSoundEnd"; }
		if (IN_RANGE(0x00661514, 0x00661518)) { *from = 0x00661514; *to = 0x00661518; return "scratch"; }
		if (IN_RANGE(0x00661518, 0x006616E0)) { *from = 0x00661518; *to = 0x006616E0; return "unitsdat_StareditAvailabilityFlags"; }
		if (IN_RANGE(0x006616E0, 0x006617C4)) { *from = 0x006616E0; *to = 0x006617C4; return "unitsdat_AirWeapon"; }
		if (IN_RANGE(0x006617C4, 0x006617C8)) { *from = 0x006617C4; *to = 0x006617C8; return "scratch"; }
		if (IN_RANGE(0x006617C8, 0x00661EE8)) { *from = 0x006617C8; *to = 0x00661EE8; return "unitsdat_UnitSize"; }
		if (IN_RANGE(0x00661EE8, 0x00661FBC)) { *from = 0x00661EE8; *to = 0x00661FBC; return "unitsdat_PissSoundEnd"; }
		if (IN_RANGE(0x00661FBC, 0x00661FC0)) { *from = 0x00661FBC; *to = 0x00661FC0; return "scratch"; }
		if (IN_RANGE(0x00661FC0, 0x00662094)) { *from = 0x00661FC0; *to = 0x00662094; return "unitsdat_ReadySound"; }
		if (IN_RANGE(0x00662094, 0x00662098)) { *from = 0x00662094; *to = 0x00662098; return "scratch"; }
		if (IN_RANGE(0x00662098, 0x0066217C)) { *from = 0x00662098; *to = 0x0066217C; return "unitsdat_RightclickActionOrder"; }
		if (IN_RANGE(0x0066217C, 0x00662180)) { *from = 0x0066217C; *to = 0x00662180; return "scratch"; }
		if (IN_RANGE(0x00662180, 0x00662264)) { *from = 0x00662180; *to = 0x00662264; return "unitsdat_UnitSizeType"; }
		if (IN_RANGE(0x00662264, 0x00662268)) { *from = 0x00662264; *to = 0x00662268; return "scratch"; }
		if (IN_RANGE(0x00662268, 0x0066234C)) { *from = 0x00662268; *to = 0x0066234C; return "unitsdat_HumanAIIdleOrder"; }
		if (IN_RANGE(0x00662350, 0x006626E0)) { *from = 0x00662350; *to = 0x006626E0; return "gxUnitLife"; }
		if (IN_RANGE(0x006626E0, 0x00662860)) { *from = 0x006626E0; *to = 0x00662860; return "unitsdat_AddonPosition"; }
		if (IN_RANGE(0x00662860, 0x00662BF0)) { *from = 0x00662860; *to = 0x00662BF0; return "unitsdat_PlacementBoxSize"; }
		if (IN_RANGE(0x00662BF0, 0x00662DB8)) { *from = 0x00662BF0; *to = 0x00662DB8; return "unitsdat_WhatSoundEnd"; }
		if (IN_RANGE(0x00662DB8, 0x00662E9C)) { *from = 0x00662DB8; *to = 0x00662E9C; return "unitsdat_TargetAcquisitionRange"; }
		if (IN_RANGE(0x00662E9C, 0x00662EA0)) { *from = 0x00662E9C; *to = 0x00662EA0; return "scratch"; }
		if (IN_RANGE(0x00662EA0, 0x00662F84)) { *from = 0x00662EA0; *to = 0x00662F84; return "unitsdat_CompAIIdleOrder"; }
		if (IN_RANGE(0x00662F84, 0x00662F88)) { *from = 0x00662F84; *to = 0x00662F88; return "scratch"; }
		if (IN_RANGE(0x00662F88, 0x00663150)) { *from = 0x00662F88; *to = 0x00663150; return "unitsdat_portrait"; }
		if (IN_RANGE(0x00663150, 0x00663234)) { *from = 0x00663150; *to = 0x00663234; return "unitsdat_ElevationLevel"; }
		if (IN_RANGE(0x00663234, 0x00663238)) { *from = 0x00663234; *to = 0x00663238; return "scratch"; }
		if (IN_RANGE(0x00663238, 0x0066331C)) { *from = 0x00663238; *to = 0x0066331C; return "unitsdat_SightRange"; }
		if (IN_RANGE(0x0066331C, 0x00663320)) { *from = 0x0066331C; *to = 0x00663320; return "scratch"; }
		if (IN_RANGE(0x00663320, 0x00663404)) { *from = 0x00663320; *to = 0x00663404; return "unitsdat_AttackUnitOrder"; }
		if (IN_RANGE(0x00663404, 0x00663408)) { *from = 0x00663404; *to = 0x00663408; return "scratch"; }
		if (IN_RANGE(0x00663408, 0x006635D0)) { *from = 0x00663408; *to = 0x006635D0; return "unitsdat_BuildScore"; }
		if (IN_RANGE(0x006635D0, 0x006636B4)) { *from = 0x006635D0; *to = 0x006636B4; return "unitsdat_ArmorUpgrade"; }
		if (IN_RANGE(0x006636B4, 0x006636B8)) { *from = 0x006636B4; *to = 0x006636B8; return "scratch"; }
		if (IN_RANGE(0x006636B8, 0x0066379C)) { *from = 0x006636B8; *to = 0x0066379C; return "unitsdat_GroundWeapon"; }
		if (IN_RANGE(0x0066379C, 0x006637A0)) { *from = 0x0066379C; *to = 0x006637A0; return "scratch"; }
		if (IN_RANGE(0x006637A0, 0x00663884)) { *from = 0x006637A0; *to = 0x00663884; return "unitsdat_StareditGroupFlags"; }
		if (IN_RANGE(0x00663884, 0x00663888)) { *from = 0x00663884; *to = 0x00663888; return "scratch"; }
		if (IN_RANGE(0x00663888, 0x00663A50)) { *from = 0x00663888; *to = 0x00663A50; return "unitsdat_OreCost"; }
		if (IN_RANGE(0x00663A50, 0x00663B34)) { *from = 0x00663A50; *to = 0x00663B34; return "unitsdat_AttackMoveOrder"; }
		if (IN_RANGE(0x00663B38, 0x00663C0C)) { *from = 0x00663B38; *to = 0x00663C0C; return "unitsdat_PissSoundStart"; }
		if (IN_RANGE(0x00663C0C, 0x00663C10)) { *from = 0x00663C0C; *to = 0x00663C10; return "scratch"; }
		if (IN_RANGE(0x00663C10, 0x00663CE4)) { *from = 0x00663C10; *to = 0x00663CE4; return "unitsdat_YesSoundStart"; }
		if (IN_RANGE(0x00663CE4, 0x00663CE8)) { *from = 0x00663CE4; *to = 0x00663CE8; return "scratch"; }
		if (IN_RANGE(0x00663CE8, 0x00663DCC)) { *from = 0x00663CE8; *to = 0x00663DCC; return "unitsdat_SupplyRequired"; }
		if (IN_RANGE(0x00663DCC, 0x00663DD0)) { *from = 0x00663DCC; *to = 0x00663DD0; return "scratch"; }
		if (IN_RANGE(0x00663DD0, 0x00663EB4)) { *from = 0x00663DD0; *to = 0x00663EB4; return "unitsdat_sublabelRank"; }
		if (IN_RANGE(0x00663EB8, 0x00664080)) { *from = 0x00663EB8; *to = 0x00664080; return "unitsdat_DestroyScore"; }
		if (IN_RANGE(0x00664080, 0x00664410)) { *from = 0x00664080; *to = 0x00664410; return "unitsdat_SpecialAbilityFlags"; }
		if (IN_RANGE(0x00664410, 0x006644F4)) { *from = 0x00664410; *to = 0x006644F4; return "unitsdat_SpaceRequired"; }
		if (IN_RANGE(0x006644F4, 0x006644F8)) { *from = 0x006644F4; *to = 0x006644F8; return "scratch"; }
		if (IN_RANGE(0x006644F8, 0x006645DC)) { *from = 0x006644F8; *to = 0x006645DC; return "unitsdat_Graphics"; }
		if (IN_RANGE(0x006645DC, 0x006645E0)) { *from = 0x006645DC; *to = 0x006645E0; return "scratch"; }
		if (IN_RANGE(0x006645E0, 0x006646C4)) { *from = 0x006645E0; *to = 0x006646C4; return "unitsdat_MaxGroundHits"; }
		if (IN_RANGE(0x006646C4, 0x006646C8)) { *from = 0x006646C4; *to = 0x006646C8; return "scratch"; }
		if (IN_RANGE(0x006646C8, 0x006647AC)) { *from = 0x006646C8; *to = 0x006647AC; return "unitsdat_SupplyProvided"; }
		if (IN_RANGE(0x006647AC, 0x006647B0)) { *from = 0x006647AC; *to = 0x006647B0; return "scratch"; }
		if (IN_RANGE(0x006647B0, 0x00664894)) { *from = 0x006647B0; *to = 0x00664894; return "unitsdat_ShieldEnable"; }
		if (IN_RANGE(0x00664894, 0x00664898)) { *from = 0x00664894; *to = 0x00664898; return "scratch"; }
		if (IN_RANGE(0x00664898, 0x0066497C)) { *from = 0x00664898; *to = 0x0066497C; return "unitsdat_ReturntoIdleOrder"; }
		if (IN_RANGE(0x0066497C, 0x00664980)) { *from = 0x0066497C; *to = 0x00664980; return "scratch"; }
		if (IN_RANGE(0x00664980, 0x00664A40)) { *from = 0x00664980; *to = 0x00664A40; return "unitsdat_InfestationUnit"; }
		if (IN_RANGE(0x00664A40, 0x00664AFD)) { *from = 0x00664A40; *to = 0x00664AFD; return "ordersdat_Unknown4"; }
		if (IN_RANGE(0x00664B00, 0x00664BBD)) { *from = 0x00664B00; *to = 0x00664BBD; return "ordersdat_useWeaponTargetting"; }
		if (IN_RANGE(0x00664BC0, 0x00664C7D)) { *from = 0x00664BC0; *to = 0x00664C7D; return "ordersdat_Unused12"; }
		if (IN_RANGE(0x00664C80, 0x00664D3D)) { *from = 0x00664C80; *to = 0x00664D3D; return "scratch"; }
		if (IN_RANGE(0x00664D40, 0x00664DFD)) { *from = 0x00664D40; *to = 0x00664DFD; return "gubOrderSeq"; }
		if (IN_RANGE(0x00664E00, 0x00664EBD)) { *from = 0x00664E00; *to = 0x00664EBD; return "ordersdat_TechType"; }
		if (IN_RANGE(0x00664EC0, 0x0066503A)) { *from = 0x00664EC0; *to = 0x0066503A; return "ordersdat_Highlight"; }
		if (IN_RANGE(0x00665040, 0x006650FD)) { *from = 0x00665040; *to = 0x006650FD; return "ordersdat_CanBeInterrupted"; }
		if (IN_RANGE(0x00665100, 0x006651BD)) { *from = 0x00665100; *to = 0x006651BD; return "ordersdat_Unknown7"; }
		if (IN_RANGE(0x006651C0, 0x0066527D)) { *from = 0x006651C0; *to = 0x0066527D; return "ordersdat_Unknown9"; }
		if (IN_RANGE(0x00665280, 0x006653FA)) { *from = 0x00665280; *to = 0x006653FA; return "ordersdat_label"; }
		if (IN_RANGE(0x00665400, 0x006654BD)) { *from = 0x00665400; *to = 0x006654BD; return "ordersdat_Obscured"; }
		if (IN_RANGE(0x006654C0, 0x0066557D)) { *from = 0x006654C0; *to = 0x0066557D; return "ordersdat_CanBeObstructed"; }
		if (IN_RANGE(0x00665580, 0x006656FA)) { *from = 0x00665580; *to = 0x006656FA; return "guwOrdDepIndex"; }
		if (IN_RANGE(0x00665700, 0x006657BD)) { *from = 0x00665700; *to = 0x006657BD; return "ordersdat_CanBeQueued"; }
		if (IN_RANGE(0x006657C0, 0x0066587D)) { *from = 0x006657C0; *to = 0x0066587D; return "ordersdat_Unused5"; }
		if (IN_RANGE(0x00665880, 0x0066593D)) { *from = 0x00665880; *to = 0x0066593D; return "gubOrderWeapon"; }
		if (IN_RANGE(0x00665940, 0x006659FD)) { *from = 0x00665940; *to = 0x006659FD; return "gubOrderBackground"; }
		if (IN_RANGE(0x00665A00, 0x00665ABD)) { *from = 0x00665A00; *to = 0x00665ABD; return "ordersdat_Unused3"; }
		if (IN_RANGE(0x00665AC0, 0x00665C43)) { *from = 0x00665AC0; *to = 0x00665C43; return "SpritesDAT_SelCircleImage"; }
		if (IN_RANGE(0x00665C48, 0x00665E4D)) { *from = 0x00665C48; *to = 0x00665E4D; return "SpritesDAT_IsVisible"; }
		if (IN_RANGE(0x00665E50, 0x00665FD3)) { *from = 0x00665E50; *to = 0x00665FD3; return "spritesDAT_HealthBarSize"; }
		if (IN_RANGE(0x00665FD8, 0x0066615B)) { *from = 0x00665FD8; *to = 0x0066615B; return "SpritesDAT_SelCircleOffset"; }
		if (IN_RANGE(0x00666160, 0x0066656A)) { *from = 0x00666160; *to = 0x0066656A; return "SpritesDAT_ImageID"; }
		if (IN_RANGE(0x00666570, 0x00666775)) { *from = 0x00666570; *to = 0x00666775; return "SpritesDAT_Unknown2"; }
		if (IN_RANGE(0x00666778, 0x00667714)) { *from = 0x00666778; *to = 0x00667714; return "ImagesLandingDustOverlay"; }
		if (IN_RANGE(0x00667718, 0x00667AFF)) { *from = 0x00667718; *to = 0x00667AFF; return "imagesDrawifCloaked"; }
		if (IN_RANGE(0x00667B00, 0x00668A9C)) { *from = 0x00667B00; *to = 0x00668A9C; return "imagesSpecialOverlay"; }
		if (IN_RANGE(0x00668AA0, 0x00669A3C)) { *from = 0x00668AA0; *to = 0x00669A3C; return "imagesGRP"; }
		if (IN_RANGE(0x00669A40, 0x00669E27)) { *from = 0x00669A40; *to = 0x00669E27; return "gubImageColorShift"; }
		if (IN_RANGE(0x00669E28, 0x0066A20F)) { *from = 0x00669E28; *to = 0x0066A20F; return "gubImageRLE"; }
		if (IN_RANGE(0x0066A210, 0x0066B1AC)) { *from = 0x0066A210; *to = 0x0066B1AC; return "imagesDamageOverlay"; }
		if (IN_RANGE(0x0066B1B0, 0x0066C14C)) { *from = 0x0066B1B0; *to = 0x0066C14C; return "imagesAttackOverlay"; }
		if (IN_RANGE(0x0066C150, 0x0066C537)) { *from = 0x0066C150; *to = 0x0066C537; return "imagesClickable"; }
		if (IN_RANGE(0x0066C538, 0x0066D4D4)) { *from = 0x0066C538; *to = 0x0066D4D4; return "imagesShieldOverlay"; }
		if (IN_RANGE(0x0066D4D8, 0x0066D8BF)) { *from = 0x0066D4D8; *to = 0x0066D8BF; return "gubImageUseScript"; }
		if (IN_RANGE(0x0066D8C0, 0x0066E85C)) { *from = 0x0066D8C0; *to = 0x0066E85C; return "ImagesLiftoffOverlay"; }
		if (IN_RANGE(0x0066E860, 0x0066EC47)) { *from = 0x0066E860; *to = 0x0066EC47; return "imagesGFXTurns"; }
		if (IN_RANGE(0x0066EC48, 0x0066FBE4)) { *from = 0x0066EC48; *to = 0x0066FBE4; return "imagesIscriptID"; }
		if (IN_RANGE(0x0066FD0C, 0x0066FD10)) { *from = 0x0066FD0C; *to = 0x0066FD10; return "scratch"; }
		if (IN_RANGE(0x0066FF78, 0x006769B8)) { *from = 0x0066FF78; *to = 0x006769B8; return "unitFinderX"; }
		if (IN_RANGE(0x0068AC74, 0x0068AC75)) { *from = 0x0068AC74; *to = 0x0068AC75; return "needsUnitPortraitUpdate"; }
		if (IN_RANGE(0x0068AC8C, 0x0068AC90)) { *from = 0x0068AC8C; *to = 0x0068AC90; return "pStatPortDlg"; }
		if (IN_RANGE(0x0068C104, 0x0068C108)) { *from = 0x0068C104; *to = 0x0068C108; return "hAIScript"; }
		if (IN_RANGE(0x0068C108, 0x0068C10C)) { *from = 0x0068C108; *to = 0x0068C10C; return "hBWScript"; }
		if (IN_RANGE(0x0068C10C, 0x0068C13E)) { *from = 0x0068C10C; *to = 0x0068C13E; return "textBoxMessage?"; }
		if (IN_RANGE(0x0068C140, 0x0068C144)) { *from = 0x0068C140; *to = 0x0068C144; return "pTextBoxDlg"; }
		if (IN_RANGE(0x0068C144, 0x0068C145)) { *from = 0x0068C144; *to = 0x0068C145; return "sendMessageType"; }
		if (IN_RANGE(0x0068C148, 0x0068C14C)) { *from = 0x0068C148; *to = 0x0068C14C; return "pStatBtnDialog_0"; }
		if (IN_RANGE(0x0068C14C, 0x0068C14E)) { *from = 0x0068C14C; *to = 0x0068C14E; return "current buttonset?"; }
		if (IN_RANGE(0x0068C1E0, 0x0068C1E4)) { *from = 0x0068C1E0; *to = 0x0068C1E4; return "cmdiconsHandle"; }
		if (IN_RANGE(0x0068C1F0, 0x0068C1F4)) { *from = 0x0068C1F0; *to = 0x0068C1F4; return "pStatDataDialog"; }
		if (IN_RANGE(0x0068C1F4, 0x0068C1F8)) { *from = 0x0068C1F4; *to = 0x0068C1F8; return "hTranWireGrp"; }
		if (IN_RANGE(0x0068C1FC, 0x0068C200)) { *from = 0x0068C1FC; *to = 0x0068C200; return "hGrpWireGrp"; }
		if (IN_RANGE(0x0068C204, 0x0068C208)) { *from = 0x0068C204; *to = 0x0068C208; return "hWireframGrp"; }
		if (IN_RANGE(0x0068C208, 0x0068C220)) { *from = 0x0068C208; *to = 0x0068C220; return "twirePcxPalette"; }
		if (IN_RANGE(0x0068C224, 0x0068C228)) { *from = 0x0068C224; *to = 0x0068C228; return "statF10_Dialog"; }
		if (IN_RANGE(0x0068C234, 0x0068C238)) { *from = 0x0068C234; *to = 0x0068C238; return "sgpStatResDlg"; }
		if (IN_RANGE(0x0068C238, 0x0068C23C)) { *from = 0x0068C238; *to = 0x0068C23C; return "gpIconsGrp"; }
		if (IN_RANGE(0x006BB210, 0x006BB930)) { *from = 0x006BB210; *to = 0x006BB930; return "unitTypeAIStrength"; }
		if (IN_RANGE(0x006BD3D0, 0x006BEE64)) { *from = 0x006BD3D0; *to = 0x006BEE64; return "unitFinderFlags"; }
		if (IN_RANGE(0x006C9858, 0x006C9929)) { *from = 0x006C9858; *to = 0x006C9929; return "Flingy_MoveControl"; }
		if (IN_RANGE(0x006C9930, 0x006C9C74)) { *from = 0x006C9930; *to = 0x006C9C74; return "Flingy_HaltDistance"; }
		if (IN_RANGE(0x006C9C78, 0x006C9E1A)) { *from = 0x006C9C78; *to = 0x006C9E1A; return "Flingy_Acceleration"; }
		if (IN_RANGE(0x006C9E20, 0x006C9EF1)) { *from = 0x006C9E20; *to = 0x006C9EF1; return "Flingy_TurnRadius"; }
		if (IN_RANGE(0x006C9EF8, 0x006CA23C)) { *from = 0x006C9EF8; *to = 0x006CA23C; return "Flingy_TopSpeed"; }
		if (IN_RANGE(0x006CA240, 0x006CA311)) { *from = 0x006CA240; *to = 0x006CA311; return "Flingy_Unused"; }
		if (IN_RANGE(0x006CA318, 0x006CA4BA)) { *from = 0x006CA318; *to = 0x006CA4BA; return "Flingy_SpriteID"; }
		if (IN_RANGE(0x006CA4BC, 0x006CA4EC)) { *from = 0x006CA4BC; *to = 0x006CA4EC; return "AISuppliesReserve"; }
		if (IN_RANGE(0x006CA4EC, 0x006CA51C)) { *from = 0x006CA4EC; *to = 0x006CA51C; return "AIGasReserve"; }
		if (IN_RANGE(0x006CA51C, 0x006CA54C)) { *from = 0x006CA51C; *to = 0x006CA54C; return "AIOreReserve"; }
		if (IN_RANGE(0x006CA550, 0x006CA64C)) { *from = 0x006CA550; *to = 0x006CA64C; return "MD5_ctx"; }
		if (IN_RANGE(0x006CA64C, 0x006CA664)) { *from = 0x006CA64C; *to = 0x006CA664; return "MD5 stuff"; }
		if (IN_RANGE(0x006CA94C, 0x006CA97C)) { *from = 0x006CA94C; *to = 0x006CA97C; return "selGroupHp"; }
		if (IN_RANGE(0x006CAF98, 0x006CAF9C)) { *from = 0x006CAF98; *to = 0x006CAF9C; return "path something"; }
		if (IN_RANGE(0x006CAFA0, 0x006CD9A0)) { *from = 0x006CAFA0; *to = 0x006CD9A0; return "path something"; }
		if (IN_RANGE(0x006CD9A0, 0x006CDBA4)) { *from = 0x006CD9A0; *to = 0x006CDBA4; return "path something"; }
		if (IN_RANGE(0x006CDBA8, 0x006CDDAC)) { *from = 0x006CDBA8; *to = 0x006CDDAC; return "path something"; }
		if (IN_RANGE(0x006CDDC0, 0x006CDDC2)) { *from = 0x006CDDC0; *to = 0x006CDDC2; return "keyMod"; }
		if (IN_RANGE(0x006CDDC4, 0x006CDDCC)) { *from = 0x006CDDC4; *to = 0x006CDDCC; return "MousePointer"; }
		if (IN_RANGE(0x006CDFD4, 0x006CDFF8)) { *from = 0x006CDFD4; *to = 0x006CDFF8; return "optionList"; }
		if (IN_RANGE(0x006CE000, 0x006CE0C0)) { *from = 0x006CE000; *to = 0x006CE0C0; return "tFontGame_ImageData"; }
		if (IN_RANGE(0x006CE320, 0x006CE720)) { *from = 0x006CE320; *to = 0x006CE720; return "unknown Palette"; }
		if (IN_RANGE(0x006CE720, 0x006CEB20)) { *from = 0x006CE720; *to = 0x006CEB20; return "unknown Palette"; }
		if (IN_RANGE(0x006CEB20, 0x006CEB3A)) { *from = 0x006CEB20; *to = 0x006CEB3A; return "uiPaletteIndices"; }
		if (IN_RANGE(0x006CEFF0, 0x006CEFF8)) { *from = 0x006CEFF0; *to = 0x006CEFF8; return "_img_draw_buf"; }
		if (IN_RANGE(0x006CEFF8, 0x006CF4A8)) { *from = 0x006CEFF8; *to = 0x006CF4A8; return "refreshWindowBoxes"; }
		if (IN_RANGE(0x006D0F14, 0x006D0F18)) { *from = 0x006D0F14; *to = 0x006D0F18; return "gbInReplay"; }
		if (IN_RANGE(0x006D0F24, 0x006D0F28)) { *from = 0x006D0F24; *to = 0x006D0F28; return "pChkFile"; }
		if (IN_RANGE(0x006D0F30, 0x006D11A9)) { *from = 0x006D0F30; *to = 0x006D11A9; return "replayHeader"; }
		if (IN_RANGE(0x006D1200, 0x006D1204)) { *from = 0x006D1200; *to = 0x006D1204; return "pIScriptData"; }
		if (IN_RANGE(0x006D1234, 0x006D1238)) { *from = 0x006D1234; *to = 0x006D1238; return "lastBINDLGMenuFXN"; }
		if (IN_RANGE(0x006D1260, 0x006D1264)) { *from = 0x006D1260; *to = 0x006D1264; return "activeTileHandle"; }
		if (IN_RANGE(0x006D5A6C, 0x006D5A70)) { *from = 0x006D5A6C; *to = 0x006D5A70; return "gameCheatFlags"; }
		if (IN_RANGE(0x006D5CD8, 0x006D5CDC)) { *from = 0x006D5CD8; *to = 0x006D5CDC; return "repulseHandle"; }
		if (IN_RANGE(0x006D5E14, 0x006D5E18)) { *from = 0x006D5E14; *to = 0x006D5E18; return "ghTrans"; }
		if (IN_RANGE(0x006D5E1C, 0x006D5E20)) { *from = 0x006D5E1C; *to = 0x006D5E20; return "wantNewPalette"; }
		if (IN_RANGE(0x006D5EC8, 0x006D5ECC)) { *from = 0x006D5EC8; *to = 0x006D5ECC; return "cv5FileHandle"; }
		if (IN_RANGE(0x006D6394, 0x006D63AC)) { *from = 0x006D6394; *to = 0x006D63AC; return "szGamePassword"; }
		if (IN_RANGE(0x1505E670, 0x1505EA70)) { *from = 0x1505E670; *to = 0x1505EA70; return "Storm graphics palette"; }
		if (IN_RANGE(0x19018F38, 0x19018F3C)) { *from = 0x19018F38; *to = 0x19018F3C; return "Unknown battle.snp code hook"; }
		if (IN_RANGE(0x190452C8, 0x19045348)) { *from = 0x190452C8; *to = 0x19045348; return "Unknown text"; }
		if (IN_RANGE(0x19046134, 0x19046138)) { *from = 0x19046134; *to = 0x19046138; return "??"; }
		if (IN_RANGE(0x19046138, 0x19046238)) { *from = 0x19046138; *to = 0x19046238; return "??"; }
		if (IN_RANGE(0x190913D8, 0x190913DC)) { *from = 0x190913D8; *to = 0x190913DC; return "Invalid memory location???"; }

		if (IN_RANGE((unsigned int)firstNode, ((unsigned int)lastNode))) { // Our trigger
			char buffer[512];
			char* tmp;
			char* fmt = getTriggerNodeOffsetDescription(offset -(unsigned int) firstNode, (char**) &tmp);
			sprintf_s(buffer, fmt, tmp);
			sprintf_s(__GameDataOutputBuffer, "Trigger[%d].%s", ((TriggerNode*)offset)->data.flags >> 16, buffer);
			*from = 0;
			*to = 0;
			return __GameDataOutputBuffer; 
		}
		
		unsigned int STR = this->getSTR(segFault);
		if (IN_RANGE(STR, STR + STRSIZE)) {sprintf_s(__GameDataOutputBuffer, "STR[%d]", offset - STR); *from = STR; *to = STR + STRSIZE; return expand ? __GameDataOutputBuffer : "STR"; }

		*from = 0; *to = 0;
		return "Undocumented";
	}

	inline char* getAddressDescription(unsigned int offset, bool* segFault) {
		unsigned int a = 0;
		return getAddressDescription(offset, &a, &a, true, segFault);
	}

public:

	inline void getAddressSpace(unsigned int offset, unsigned int* begin, unsigned int* end, char** description, bool* segFault) {
		*description = getAddressDescription(offset, begin, end, false, segFault);
	}

	void load() {
		if (!loaded) {

			// Function pointers
			for (unsigned int i = 0; i < 24; i++) {
				cf[i] = (condF)this->readInt(EUD_CONDITIONS_PTR + (sizeof(int)*i), nullptr);
			}
			for (unsigned int i = 0; i < 60; i++) {
				af[i] = (actF)this->readInt(EUD_ACTIONS_PTR + (sizeof(int)*i), nullptr);
			}

			// Player info
			this->read((char*) players, EUD_PLAYERINFO, 8 * sizeof(PlayerInfo), nullptr);
			for (unsigned int playerIndex = 0; playerIndex < 8; playerIndex++) {
				executePlayerLoop[playerIndex] = players[playerIndex].type == Slots::Player || players[playerIndex].type == Slots::Computer;
				playerForces[playerIndex] = players[playerIndex].force;
			}

			// Current player index
			currentPlayerIndex = readInt(EUD_CURRENTPLAYER, nullptr);
		}
	}
private:

	char __GameDataOutputBuffer[1024];

	bool loaded = false;
	condF cf[20];
	actF af[60];
	PlayerInfo players[8];
	unsigned int STR = 0;

	unsigned int getSTR(bool* segFault) {
		if (STR == 0) {
			STR = this->readInt(EUD_STR, segFault);
		}
		return STR;
	}

public:

	bool executePlayerLoop[8] = { false, false, false, false, false, false, false, false };
	unsigned char playerForces[8];
	unsigned int currentPlayerIndex;
	unsigned int currentPlayerIndexForTriggers = 0;
	TriggerNode* currentTriggerNode = nullptr;
	TriggerNode* firstNode;
	TriggerNode* lastNode;

	unsigned int STRSIZE = 537556;
};

class Section_STR_Impl : public Section_STR_ {

public:
	Section_STR_Impl(EUDStarcraft* sc) {
		this->sc = sc;
	}
	char* getRawString(unsigned int index, bool* segFault) {
		return "Invalid String";
		int STRPTR = sc->getSTR(segFault);
		unsigned short* offsets = (unsigned short*)(STRPTR + 2);
		char* data = (char*)(offsets + offsets[index - 1]);
		return data;
	}

private:
	EUDStarcraft* sc;
};