WIP F3DEX Support, Bug Fixes, Game definable in XML (#75)

* WIP F3DEX support * Additional work on F3DEX support, fixed bug with actorlist * Fixed crash bug * Adds ZFile attribute "Game" to be able to change the game mode for ZAPD. * Additional changes to support F3DEX * Fixed bug with cullDL and with dlist type selection * F3DEX Opcode fix * Fixed up a few bugs * Cleaned up some code and fixed bug with directory creation. * ZAPD now supports correct bitpacking for gsSPSetOtherMode on F3DEX * Fixes syntax error in ZDisplayList.h * Updates Actor and Object Lists * Updated actor and object list * G_MTX updated for F3DEX * Fixed bug with transition actor list * Updated G_Texture for F3DEX * SW97 maps: Removes actor 0x22, and shifts actors 0x23 and above down by one to match retail enum. * Fixes issue in reuse of actorCount variable in SetActorList::GetActorListArraySize. Co-authored-by: Kenix3
author: Nicholas Estelami <NEstelami@users.noreply.github.com> 2021-01-23 14:23:51 -0500
committer: GitHub <noreply@github.com> 2021-01-23 14:23:51 -0500
commit: ee42172389c0aebfbc0c2d5bbabab4ec858bc8cd (patch)
tree: 3c6afd903bb9983602f6f79a1333106fe2306745 /ZAPD
parent: 2e1174063f3ed6bcf929bc7093cd2d1b05f8518b (diff)
17 files changed, 2087 insertions, 1629 deletions
diff --git a/ZAPD/Directory.h b/ZAPD/Directory.h
index ab68297..bddec9d 100644
--- a/ZAPD/Directory.h
+++ b/ZAPD/Directory.h
@@ -26,6 +26,17 @@ public:
 
 	static void CreateDirectory(const std::string& path)
 	{
-		fs::create_directory(path);
+		std::string curPath = "";
+		std::vector<std::string> split = StringHelper::Split(path, "/");
+
+		for (std::string s : split)
+		{
+			curPath += s + "/";
+
+			if (!Exists(curPath))
+				fs::create_directory(curPath);
+		}
+
+		//fs::create_directory(path);
 	}
 };
diff --git a/ZAPD/Globals.cpp b/ZAPD/Globals.cpp
index 16ecd4b..572ce2e 100644
--- a/ZAPD/Globals.cpp
+++ b/ZAPD/Globals.cpp
@@ -17,6 +17,7 @@ Globals::Globals()
 	symbolMap = std::map <uint32_t, std::string>();
 	segmentRefs = map<int, string>();
 	segmentRefFiles = map<int, ZFile*>();
+	game = ZGame::OOT_RETAIL;
 	genSourceFile = true;
 	testMode = false;
 	profile = false;
@@ -117,3 +118,12 @@ bool Globals::HasSegment(int segment)
 {
 	return std::find(segments.begin(), segments.end(), segment) != segments.end();
 }
+
+GameConfig::GameConfig()
+{
+	segmentRefs = map<int, string>();
+	segmentRefFiles = map<int, ZFile*>();
+	symbolMap = std::map<uint32_t, std::string>();
+	actorList = std::vector<std::string>();
+	objectList = std::vector<std::string>();
+}
diff --git a/ZAPD/Globals.h b/ZAPD/Globals.h
index 8b68291..7b034de 100644
--- a/ZAPD/Globals.h
+++ b/ZAPD/Globals.h
@@ -13,6 +13,8 @@ typedef enum VerbosityLevel {
 	VERBOSITY_DEBUG
 } VerbosityLevel;
 
+class GameConfig;
+
 class Globals
 {
 public:
@@ -27,6 +29,7 @@ public:
 	ZFileMode fileMode;
 	std::string baseRomPath, inputPath, outputPath, cfgPath;
 	TextureType texType;
+	ZGame game;
 
 	std::vector<ZFile*> files;
 	std::vector<int> segments;
@@ -43,6 +46,21 @@ public:
 	bool HasSegment(int segment);
 };
 
+class GameConfig
+{
+public:
+	std::map<int, std::string> segmentRefs;
+	std::map<int, ZFile*> segmentRefFiles;
+	std::map<uint32_t, std::string> symbolMap;
+	std::vector<std::string> actorList;
+	std::vector<std::string> objectList;
+
+	GameConfig();
+
+private:
+
+};
+
 /*
  * Note: In being able to track references across files, there are a few major files that make use of segments...
  * Segment 1: nintendo_rogo_static/title_static
diff --git a/ZAPD/Main.cpp b/ZAPD/Main.cpp
index 8d53c97..4ae1174 100644
--- a/ZAPD/Main.cpp
+++ b/ZAPD/Main.cpp
@@ -7,6 +7,7 @@
 #include "Overlays/ZOverlay.h"
 #include "Path.h"
 #include "File.h"
+#include "Directory.h"
 #include "Globals.h"
 
 #if !defined(_MSC_VER) && !defined(__CYGWIN__)
diff --git a/ZAPD/ZAPD.vcxproj.filters b/ZAPD/ZAPD.vcxproj.filters
index aee2be9..8f784fd 100644
--- a/ZAPD/ZAPD.vcxproj.filters
+++ b/ZAPD/ZAPD.vcxproj.filters
@@ -199,7 +199,7 @@
       <Filter>Source Files\Z64</Filter>
     </ClCompile>
     <ClCompile Include="ZVtx.cpp">
-      <Filter>Source Files</Filter>
+      <Filter>Source Files\Z64</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
diff --git a/ZAPD/ZDisplayList.cpp b/ZAPD/ZDisplayList.cpp
index f1f1eb3..aeae3ec 100644
--- a/ZAPD/ZDisplayList.cpp
+++ b/ZAPD/ZDisplayList.cpp
@@ -26,6 +26,7 @@ ZDisplayList::ZDisplayList() : ZResource()
 	lastTexIsPalette = false;
 	name = "";
 	scene = nullptr;
+	dListType = Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX;
 
 	fileData = vector<uint8_t>();
 	instructions = vector<uint64_t>();
@@ -83,16 +84,387 @@ void ZDisplayList::ParseRawData()
 		instructions.push_back(BitConverter::ToUInt64BE(rawDataArr, (i * 8)));
 }
 
-int ZDisplayList::GetDListLength(vector<uint8_t> rawData, int rawDataIndex)
+void ZDisplayList::ParseF3DZEX(F3DZEXOpcode opcode, uint64_t data, int i, std::string prefix, char* line)
+{
+	switch (opcode)
+	{
+	case F3DZEXOpcode::G_NOOP:
+		sprintf(line, "gsDPNoOpTag(0x%08lX),", data & 0xFFFFFFFF);
+		break;
+	case F3DZEXOpcode::G_DL:
+	{
+		Opcode_G_DL(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_MODIFYVTX:
+	{
+		Opcode_G_MODIFYVTX(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_CULLDL:
+	{
+		Opcode_G_CULLDL(data, i, prefix, line);
+	}
+	break;
+	/*case F3DZEXOpcode::G_BRANCH_Z:
+	{
+		int aaa = (data & 0x00FFF00000000000) >> 44;
+		int bbb = (data & 0x00000FFF00000000) >> 32;
+		int zzzzzzzz = (data & 0x00000000FFFFFFFF);
+
+		sprintf(line, "gsSPBranchLessZraw(%i, %i, %i),", );
+	}
+	break;*/
+	case F3DZEXOpcode::G_TRI1:
+	{
+		Opcode_G_TRI1(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_TRI2:
+	{
+		Opcode_G_TRI2(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_QUAD:
+	{
+		int aa = ((data & 0x00FF000000000000ULL) >> 48) / 2;
+		int bb = ((data & 0x0000FF0000000000ULL) >> 40) / 2;
+		int cc = ((data & 0x000000FF00000000ULL) >> 32) / 2;
+		int dd = ((data & 0x000000000000FFULL)) / 2;
+		sprintf(line, "gsSP1Quadrangle(%i, %i, %i, %i, 0),", aa, bb, cc, dd);
+	}
+	break;
+	case F3DZEXOpcode::G_VTX:
+	{
+		Opcode_G_VTX(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_SETTIMG: // HOTSPOT
+	{
+		Opcode_G_SETTIMG(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_GEOMETRYMODE:
+	{
+		int cccccc = (data & 0x00FFFFFF00000000) >> 32;
+		int ssssssss = (data & 0xFFFFFFFF);
+		string geoModeStr = "G_TEXTURE_ENABLE";
+
+		int geoModeParam = ~cccccc;
+
+		if (ssssssss != 0)
+			geoModeParam = ssssssss;
+
+		if (geoModeParam & 0x00000001)
+			geoModeStr += " | G_ZBUFFER";
+
+		if (geoModeParam & 0x00000004)
+			geoModeStr += " | G_SHADE";
+
+		if (geoModeParam & 0x00000200)
+			geoModeStr += " | G_CULL_FRONT";
+
+		if (geoModeParam & 0x00000400)
+			geoModeStr += " | G_CULL_BACK";
+
+		if (geoModeParam & 0x00010000)
+			geoModeStr += " | G_FOG";
+
+		if (geoModeParam & 0x00020000)
+			geoModeStr += " | G_LIGHTING";
+
+		if (geoModeParam & 0x00040000)
+			geoModeStr += " | G_TEXTURE_GEN";
+
+		if (geoModeParam & 0x00080000)
+			geoModeStr += " | G_TEXTURE_GEN_LINEAR";
+
+		if (geoModeParam & 0x00200000)
+			geoModeStr += " | G_SHADING_SMOOTH";
+
+		if (geoModeParam & 0x00800000)
+			geoModeStr += " | G_CLIPPING";
+
+		if (ssssssss != 0)
+		{
+			if ((~cccccc & 0xFF000000) != 0)
+				sprintf(line, "gsSPSetGeometryMode(%s),", geoModeStr.c_str());
+			else
+				sprintf(line, "gsSPLoadGeometryMode(%s),", geoModeStr.c_str());
+		}
+		else
+			sprintf(line, "gsSPClearGeometryMode(%s),", geoModeStr.c_str());
+
+		//sprintf(line, "gsSPGeometryMode(0x%08X, 0x%08X),", ~cccccc, ssssssss);
+	}
+	break;
+	case F3DZEXOpcode::G_SETPRIMCOLOR:
+	{
+		Opcode_G_SETPRIMCOLOR(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_SETOTHERMODE_L:
+	{
+		Opcode_G_SETOTHERMODE_L(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_SETOTHERMODE_H:
+	{
+		Opcode_G_SETOTHERMODE_H(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_SETTILE:
+	{
+		Opcode_G_SETTILE(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_SETTILESIZE:
+	{
+		Opcode_G_SETTILESIZE(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_LOADBLOCK:
+	{
+		Opcode_G_LOADBLOCK(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_TEXTURE:
+	{
+		Opcode_G_TEXTURE(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_RDPSETOTHERMODE:
+	{
+		int hhhhhh = (data & 0x00FFFFFF00000000) >> 32;
+		int llllllll = (data & 0x00000000FFFFFFFF);
+
+		sprintf(line, "gsDPSetOtherMode(%i, %i),", hhhhhh, llllllll);
+	}
+	break;
+	case F3DZEXOpcode::G_POPMTX:
+	{
+		sprintf(line, "gsSPPopMatrix(%li),", data);
+	}
+	break;
+	case F3DZEXOpcode::G_LOADTLUT:
+		Opcode_G_LOADTLUT(data, i, prefix, line);
+	break;
+	case F3DZEXOpcode::G_SETENVCOLOR:
+	{
+		uint8_t r = (uint8_t)((data & 0xFF000000) >> 24);
+		uint8_t g = (uint8_t)((data & 0x00FF0000) >> 16);
+		uint8_t b = (uint8_t)((data & 0xFF00FF00) >> 8);
+		uint8_t a = (uint8_t)((data & 0x000000FF) >> 0);
+
+		sprintf(line, "gsDPSetEnvColor(%i, %i, %i, %i),", r, g, b, a);
+	}
+	break;
+	case F3DZEXOpcode::G_SETCOMBINE:
+	{
+		Opcode_G_SETCOMBINE(data, i, prefix, line);
+	}
+	break;
+	case F3DZEXOpcode::G_RDPLOADSYNC:
+		sprintf(line, "gsDPLoadSync(),");
+		break;
+	case F3DZEXOpcode::G_RDPPIPESYNC:
+		sprintf(line, "gsDPPipeSync(),");
+		break;
+	case F3DZEXOpcode::G_RDPTILESYNC:
+		sprintf(line, "gsDPTileSync(),");
+		break;
+	case F3DZEXOpcode::G_RDPFULLSYNC:
+		sprintf(line, "gsDPFullSync(),");
+		break;
+	case F3DZEXOpcode::G_ENDDL:
+		Opcode_G_ENDDL(data, i, prefix, line);
+		break;
+	case F3DZEXOpcode::G_RDPHALF_1:
+	{
+		uint64_t data2 = instructions[i + 1];
+		uint32_t h = (data & 0xFFFFFFFF);
+		F3DZEXOpcode opcode2 = (F3DZEXOpcode)(instructions[i + 1] >> 56);
+
+		if (opcode2 == F3DZEXOpcode::G_BRANCH_Z)
+		{
+			uint32_t a = (data2 & 0x00FFF00000000000) >> 44;
+			uint32_t b = (data2 & 0x00000FFF00000000) >> 32;
+			uint32_t z = (data2 & 0x00000000FFFFFFFF) >> 0;
+
+			//sprintf(line, "gsDPWord(%i, 0),", h);
+			sprintf(line, "gsSPBranchLessZraw(%sDlist0x%06X, 0x%02X, 0x%02X),", prefix.c_str(), h & 0x00FFFFFF, (a / 5) | (b / 2), z);
+
+			ZDisplayList* nList = new ZDisplayList(fileData, h & 0x00FFFFFF, GetDListLength(fileData, h & 0x00FFFFFF, dListType));
+			nList->scene = scene;
+			nList->parent = parent;
+			otherDLists.push_back(nList);
+
+			i++;
+		}
+	}
+	break;
+	/*case F3DZEXOpcode::G_BRANCH_Z:
+	{
+		uint8_t h = (data & 0xFFFFFFFF);
+
+		sprintf(line, "gsSPBranchLessZraw(%i, %i, %i),", h);
+	}
+		break;*/
+	case F3DZEXOpcode::G_MTX:
+	{
+		Opcode_G_MTX(data, i, prefix, line);
+	}
+	break;
+	default:
+		sprintf(line, "// Opcode 0x%02X unimplemented!", (uint32_t)opcode);
+		break;
+	}
+}
+
+void ZDisplayList::ParseF3DEX(F3DEXOpcode opcode, uint64_t data, int i, std::string prefix, char* line)
+{
+	switch (opcode)
+	{
+	case F3DEXOpcode::G_NOOP:
+		sprintf(line, "gsDPNoOpTag(0x%08lX),", data & 0xFFFFFFFF);
+		break;
+	case F3DEXOpcode::G_VTX:
+		Opcode_G_VTX(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_DL:
+		Opcode_G_DL(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_CULLDL:
+		Opcode_G_CULLDL(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_MODIFYVTX:
+		Opcode_G_MODIFYVTX(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_MTX:
+		Opcode_G_MTX(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_TRI1:
+		Opcode_G_TRI1(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_TRI2:
+		Opcode_G_TRI2(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_ENDDL:
+		Opcode_G_ENDDL(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_RDPLOADSYNC:
+		sprintf(line, "gsDPLoadSync(),");
+		break;
+	case F3DEXOpcode::G_RDPPIPESYNC:
+		sprintf(line, "gsDPPipeSync(),");
+		break;
+	case F3DEXOpcode::G_RDPTILESYNC:
+		sprintf(line, "gsDPTileSync(),");
+		break;
+	case F3DEXOpcode::G_RDPFULLSYNC:
+		sprintf(line, "gsDPFullSync(),");
+		break;
+	case F3DEXOpcode::G_TEXTURE:
+		Opcode_G_TEXTURE(data, i, prefix, line);
+	break;
+	case F3DEXOpcode::G_SETTIMG:
+		Opcode_G_SETTIMG(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_SETTILE:
+		Opcode_G_SETTILE(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_SETTILESIZE:
+		Opcode_G_SETTILESIZE(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_LOADBLOCK:
+		Opcode_G_LOADBLOCK(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_SETCOMBINE:
+		Opcode_G_SETCOMBINE(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_SETPRIMCOLOR:
+		Opcode_G_SETPRIMCOLOR(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_SETOTHERMODE_L:
+		Opcode_F3DEX_G_SETOTHERMODE_L(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_SETOTHERMODE_H:
+		Opcode_G_SETOTHERMODE_H(data, i, prefix, line);
+		break;
+	case F3DEXOpcode::G_LOADTLUT:
+		Opcode_G_LOADTLUT(data, i, prefix, line);
+	break;
+	case F3DEXOpcode::G_CLEARGEOMETRYMODE:
+	case F3DEXOpcode::G_SETGEOMETRYMODE:
+	{
+		int cccccc = (data & 0x00FFFFFF00000000) >> 32;
+		int ssssssss = (data & 0xFFFFFFFF);
+		string geoModeStr = "G_TEXTURE_ENABLE";
+
+		int geoModeParam = ~cccccc;
+
+		if (ssssssss != 0)
+			geoModeParam = ssssssss;
+
+		if (geoModeParam & 0x00000001)
+			geoModeStr += " | G_ZBUFFER";
+
+		if (geoModeParam & 0x00000004)
+			geoModeStr += " | G_SHADE";
+
+		if (geoModeParam & 0x00000200)
+			geoModeStr += " | G_CULL_FRONT";
+
+		if (geoModeParam & 0x00000400)
+			geoModeStr += " | G_CULL_BACK";
+
+		if (geoModeParam & 0x00010000)
+			geoModeStr += " | G_FOG";
+
+		if (geoModeParam & 0x00020000)
+			geoModeStr += " | G_LIGHTING";
+
+		if (geoModeParam & 0x00040000)
+			geoModeStr += " | G_TEXTURE_GEN";
+
+		if (geoModeParam & 0x00080000)
+			geoModeStr += " | G_TEXTURE_GEN_LINEAR";
+
+		if (geoModeParam & 0x00200000)
+			geoModeStr += " | G_SHADING_SMOOTH";
+
+		if (geoModeParam & 0x00800000)
+			geoModeStr += " | G_CLIPPING";
+
+		if (opcode == F3DEXOpcode::G_SETGEOMETRYMODE)
+			sprintf(line, "gsSPSetGeometryMode(%s),", geoModeStr.c_str());
+		else
+			sprintf(line, "gsSPClearGeometryMode(%s),", geoModeStr.c_str());
+	}
+		break;
+	default:
+		sprintf(line, "// Opcode 0x%02X unimplemented!", (uint32_t)opcode);
+		break;
+	}
+}
+
+int ZDisplayList::GetDListLength(vector<uint8_t> rawData, int rawDataIndex, DListType dListType)
 {
 	int i = 0;
 
+	uint8_t endDLOpcode;
+
+	if (dListType == DListType::F3DZEX)
+		endDLOpcode = (uint8_t)F3DZEXOpcode::G_ENDDL;
+	else
+		endDLOpcode = (uint8_t)F3DEXOpcode::G_ENDDL;
+
 	while (true)
 	{
-		F3DZEXOpcode opcode = (F3DZEXOpcode)rawData[rawDataIndex + (i * 8)];
+		uint8_t opcode = (uint8_t)rawData[rawDataIndex + (i * 8)];
 		i++;
 
-		if (opcode == F3DZEXOpcode::G_ENDDL)
+		if (opcode == endDLOpcode)
 			return i * 8;
 	}
 }
@@ -132,6 +504,11 @@ int ZDisplayList::OptimizationChecks(int startIndex, string& output, string pref
 
 int ZDisplayList::OptimizationCheck_LoadTextureBlock(int startIndex, string& output, string prefix)
 {
+	if (scene == nullptr)
+	{
+		return -1;
+	}
+
 	std::vector<F3DZEXOpcode> sequence = { F3DZEXOpcode::G_SETTIMG, F3DZEXOpcode::G_SETTILE, F3DZEXOpcode::G_RDPLOADSYNC, F3DZEXOpcode::G_LOADBLOCK, F3DZEXOpcode::G_RDPPIPESYNC, F3DZEXOpcode::G_SETTILE, F3DZEXOpcode::G_SETTILESIZE };
 
 	bool seqRes = SequenceCheck(sequence, startIndex);
@@ -303,770 +680,669 @@ int ZDisplayList::OptimizationCheck_LoadTextureBlock(int startIndex, string& out
 	return -1;
 }
 
-string ZDisplayList::GetSourceOutputHeader(const std::string& prefix)
+void ZDisplayList::Opcode_G_DL(uint64_t data, int i, std::string prefix, char* line)
 {
-	return "";
-}
+	int pp = (data & 0x00FF000000000000) >> 56;
+	int segNum = (data & 0xFF000000) >> 24;
 
-string ZDisplayList::GetSourceOutputCode(const std::string& prefix)
-{
-	char line[4096];
-	string sourceOutput = "";
+	Declaration* dListDecl = nullptr;
 
-	for (int i = 0; i < instructions.size(); i++)
-	{
-		F3DZEXOpcode opcode = (F3DZEXOpcode)(instructions[i] >> 56);
-		uint64_t data = instructions[i];
-		sourceOutput += "    ";
+	if (parent != nullptr)
+		dListDecl = parent->GetDeclaration(SEG2FILESPACE(data));
 
-		auto start = chrono::steady_clock::now();
+	if (pp != 0)
+	{
+		if (!Globals::Instance->HasSegment(segNum))
+			sprintf(line, "gsSPBranchList(0x%08lX),", data & 0xFFFFFFFF);
+		else if (dListDecl != nullptr)
+			sprintf(line, "gsSPBranchList(%s),", dListDecl->varName.c_str());
+		else
+			sprintf(line, "gsSPBranchList(%sDlist0x%06lX),", prefix.c_str(), SEG2FILESPACE(data));
+	}
+	else
+	{
+		if (!Globals::Instance->HasSegment(segNum))
+			sprintf(line, "gsSPDisplayList(0x%08lX),", data & 0xFFFFFFFF);
+		else if (dListDecl != nullptr)
+			sprintf(line, "gsSPDisplayList(%s),", dListDecl->varName.c_str());
+		else
+			sprintf(line, "gsSPDisplayList(%sDlist0x%06lX),", prefix.c_str(), SEG2FILESPACE(data));
+	}
 
-		int optimizationResult = OptimizationChecks(i, sourceOutput, prefix);
+	int segmentNumber = (data & 0xFF000000) >> 24;
 
-		if (optimizationResult != -1)
-		{
-			i += optimizationResult - 1;
-			line[0] = '\0';
-		}
+	if (segmentNumber == 8 || segmentNumber == 9 || segmentNumber == 10 || segmentNumber == 11 || segmentNumber == 12 || segmentNumber == 13) // Used for runtime-generated display lists
+	{
+		if (pp != 0)
+			sprintf(line, "gsSPBranchList(0x%08lX),", data & 0xFFFFFFFF);
 		else
-		{
-			switch (opcode)
-			{
-			case F3DZEXOpcode::G_NOOP:
-				sprintf(line, "gsDPNoOpTag(0x%08lX),", data & 0xFFFFFFFF);
-				break;
-			case F3DZEXOpcode::G_DL:
-			{
-				int pp = (data & 0x00FF000000000000) >> 56;
-				int segNum = (data & 0xFF000000) >> 24;
+			sprintf(line, "gsSPDisplayList(0x%08lX),", data & 0xFFFFFFFF);
+	}
+	else
+	{
+		ZDisplayList* nList = new ZDisplayList(fileData, data & 0x00FFFFFF, GetDListLength(fileData, data & 0x00FFFFFF, dListType));
+		nList->scene = scene;
+		nList->parent = parent;
+		otherDLists.push_back(nList);
+	}
+}
 
-				Declaration* dListDecl = nullptr;
+void ZDisplayList::Opcode_G_MODIFYVTX(uint64_t data, int i, std::string prefix, char* line)
+{
+	int ww = (data & 0x00FF000000000000ULL) >> 48;
+	int nnnn = (data & 0x0000FFFF00000000ULL) >> 32;
+	int vvvvvvvv = (data & 0x00000000FFFFFFFFULL);
 
-				if (parent != nullptr)
-					dListDecl = parent->GetDeclaration(SEG2FILESPACE(data));
+	sprintf(line, "gsSPModifyVertex(%i, %i, %i),", nnnn / 2, ww, vvvvvvvv);
+}
 
-				if (pp != 0)
-				{
-					if (!Globals::Instance->HasSegment(segNum))
-						sprintf(line, "gsSPBranchList(0x%08lX),", data & 0xFFFFFFFF);
-					else if (dListDecl != nullptr)
-						sprintf(line, "gsSPBranchList(%s),", dListDecl->varName.c_str());
-					else
-						sprintf(line, "gsSPBranchList(%sDlist0x%06lX),", prefix.c_str(), SEG2FILESPACE(data));
-				}
-				else
-				{
-					if (!Globals::Instance->HasSegment(segNum))
-						sprintf(line, "gsSPDisplayList(0x%08lX),", data & 0xFFFFFFFF);
-					else if (dListDecl != nullptr)
-						sprintf(line, "gsSPDisplayList(%s),", dListDecl->varName.c_str());
-					else
-						sprintf(line, "gsSPDisplayList(%sDlist0x%06lX),", prefix.c_str(), SEG2FILESPACE(data));
-				}
+void ZDisplayList::Opcode_G_CULLDL(uint64_t data, int i, std::string prefix, char* line)
+{
+	int vvvv = (data & 0xFFFF00000000) >> 32;
+	int wwww = (data & 0x0000FFFF);
 
-				int segmentNumber = (data & 0xFF000000) >> 24;
+	sprintf(line, "gsSPCullDisplayList(%i, %i),", vvvv / 2, wwww / 2);
+}
 
-				if (segmentNumber == 8 || segmentNumber == 9 || segmentNumber == 10 || segmentNumber == 11 || segmentNumber == 12 || segmentNumber == 13) // Used for runtime-generated display lists
-				{
-					if (pp != 0)
-						sprintf(line, "gsSPBranchList(0x%08lX),", data & 0xFFFFFFFF);
-					else
-						sprintf(line, "gsSPDisplayList(0x%08lX),", data & 0xFFFFFFFF);
-				}
-				else
-				{
-					ZDisplayList* nList = new ZDisplayList(fileData, data & 0x00FFFFFF, GetDListLength(fileData, data & 0x00FFFFFF));
-					nList->scene = scene;
-					nList->parent = parent;
-					otherDLists.push_back(nList);
-				}
-			}
-			break;
-			case F3DZEXOpcode::G_MODIFYVTX:
-			{
-				int ww = (data & 0x00FF000000000000ULL) >> 48;
-				int nnnn = (data & 0x0000FFFF00000000ULL) >> 32;
-				int vvvvvvvv = (data & 0x00000000FFFFFFFFULL);
+void ZDisplayList::Opcode_G_TRI1(uint64_t data, int i, std::string prefix, char* line)
+{
+	if (dListType == DListType::F3DZEX)
+	{
+		int aa = ((data & 0x00FF000000000000ULL) >> 48) / 2;
+		int bb = ((data & 0x0000FF0000000000ULL) >> 40) / 2;
+		int cc = ((data & 0x000000FF00000000ULL) >> 32) / 2;
+		sprintf(line, "gsSP1Triangle(%i, %i, %i, 0),", aa, bb, cc);
+	}
+	else
+	{
+		int aa = ((data & 0x0000000000FF0000ULL) >> 16) / 2;
+		int bb = ((data & 0x000000000000FF00ULL) >> 8) / 2;
+		int cc = ((data & 0x00000000000000FFULL) >> 0) / 2;
+		sprintf(line, "gsSP1Triangle(%i, %i, %i, 0),", aa, bb, cc);
+	}
+}
 
-				sprintf(line, "gsSPModifyVertex(%i, %i, %i),", nnnn / 2, ww, vvvvvvvv);
-			}
-			break;
-			case F3DZEXOpcode::G_CULLDL:
-			{
-				int vvvv = (data & 0xFFFF00000000) >> 32;
-				int wwww = (data & 0x0000FFFF);
+void ZDisplayList::Opcode_G_TRI2(uint64_t data, int i, std::string prefix, char* line)
+{
+	int aa = ((data & 0x00FF000000000000ULL) >> 48) / 2;
+	int bb = ((data & 0x0000FF0000000000ULL) >> 40) / 2;
+	int cc = ((data & 0x000000FF00000000ULL) >> 32) / 2;
+	int dd = ((data & 0x00000000FF0000ULL) >> 16) / 2;
+	int ee = ((data & 0x0000000000FF00ULL) >> 8) / 2;
+	int ff = ((data & 0x000000000000FFULL) >> 0) / 2;
+	sprintf(line, "gsSP2Triangles(%i, %i, %i, 0, %i, %i, %i, 0),", aa, bb, cc, dd, ee, ff);
+}
 
-				sprintf(line, "gsSPCullDisplayList(%i, %i),", vvvv / 2, wwww / 2);
-			}
-			break;
-			/*case F3DZEXOpcode::G_BRANCH_Z:
-			{
-				int aaa = (data & 0x00FFF00000000000) >> 44;
-				int bbb = (data & 0x00000FFF00000000) >> 32;
-				int zzzzzzzz = (data & 0x00000000FFFFFFFF);
+void ZDisplayList::Opcode_G_MTX(uint64_t data, int i, std::string prefix, char* line)
+{
+	// TODO: FINISH THIS
+	uint32_t pp = 0;
+	uint32_t mm = (data & 0x00000000FFFFFFFF);
 
-				sprintf(line, "gsSPBranchLessZraw(%i, %i, %i),", );
-			}
-			break;*/
-			case F3DZEXOpcode::G_TRI1:
-			{
-				int aa = ((data & 0x00FF000000000000ULL) >> 48) / 2;
-				int bb = ((data & 0x0000FF0000000000ULL) >> 40) / 2;
-				int cc = ((data & 0x000000FF00000000ULL) >> 32) / 2;
-				sprintf(line, "gsSP1Triangle(%i, %i, %i, 0),", aa, bb, cc);
-			}
-			break;
-			case F3DZEXOpcode::G_TRI2:
-			{
-				int aa = ((data & 0x00FF000000000000ULL) >> 48) / 2;
-				int bb = ((data & 0x0000FF0000000000ULL) >> 40) / 2;
-				int cc = ((data & 0x000000FF00000000ULL) >> 32) / 2;
-				int dd = ((data & 0x00000000FF0000ULL) >> 16) / 2;
-				int ee = ((data & 0x0000000000FF00ULL) >> 8) / 2;
-				int ff = ((data & 0x000000000000FFULL) >> 0) / 2;
-				sprintf(line, "gsSP2Triangles(%i, %i, %i, 0, %i, %i, %i, 0),", aa, bb, cc, dd, ee, ff);
-			}
-			break;
-			case F3DZEXOpcode::G_QUAD:
-			{
-				int aa = ((data & 0x00FF000000000000ULL) >> 48) / 2;
-				int bb = ((data & 0x0000FF0000000000ULL) >> 40) / 2;
-				int cc = ((data & 0x000000FF00000000ULL) >> 32) / 2;
-				int dd = ((data & 0x000000000000FFULL)) / 2;
-				sprintf(line, "gsSP1Quadrangle(%i, %i, %i, %i, 0),", aa, bb, cc, dd);
-			}
-			break;
-			case F3DZEXOpcode::G_VTX:
-			{
-				int nn = (data & 0x000FF00000000000ULL) >> 44;
-				int aa = (data & 0x000000FF00000000ULL) >> 32;
-				uint32_t vtxAddr = SEG2FILESPACE(data);
+	if (dListType == DListType::F3DEX)
+		pp = (data & 0x00FF000000000000) >> 48;
+	else
+		pp = (data & 0x000000FF00000000) >> 32;
 
-				if (GETSEGNUM(data) == 0x80) // Are these vertices defined in code?
-					vtxAddr -= SEG2FILESPACE(parent->baseAddress);
+	std::string matrixRef = "";
 
-				//sprintf(line, "gsSPVertex(%sVtx_%06X, %i, %i),", prefix.c_str(), vtxAddr, nn, ((aa >> 1) - nn));
-				sprintf(line, "gsSPVertex(@r, %i, %i),", nn, ((aa >> 1) - nn));
-				references.push_back(vtxAddr);
+	if (Globals::Instance->symbolMap.find(mm) != Globals::Instance->symbolMap.end())
+		matrixRef = StringHelper::Sprintf("&%s", Globals::Instance->symbolMap[mm].c_str());
+	else
+		matrixRef = StringHelper::Sprintf("0x%08X", mm);
 
-				{
-					uint32_t currentPtr = SEG2FILESPACE(data);
+	sprintf(line, "gsSPMatrix(%s, 0x%02X),", matrixRef.c_str(), pp ^ 0x01);
+}
 
-					if (GETSEGNUM(data) == 0x80) // Are these vertices defined in code?
-						currentPtr -= SEG2FILESPACE(parent->baseAddress);
+void ZDisplayList::Opcode_G_VTX(uint64_t data, int i, std::string prefix, char* line)
+{
+	int nn = (data & 0x000FF00000000000ULL) >> 44;
+	int aa = (data & 0x000000FF00000000ULL) >> 32;
 
-					// Check for vertex intersections from other display lists
-					// TODO: These two could probably be condenced to one...
-					if (parent->GetDeclarationRanged(vtxAddr + (nn * 16)) != nullptr)
-					{
-						Declaration* decl = parent->GetDeclarationRanged(vtxAddr + (nn * 16));
-						uint32_t addr = parent->GetDeclarationRangedAddress(vtxAddr + (nn * 16));
-						int diff = addr - vtxAddr;
-						if (diff > 0)
-							nn = diff / 16;
-						else
-							nn = 0;
-					}
+	uint32_t vtxAddr = SEG2FILESPACE(data);
 
-					if (parent->GetDeclarationRanged(vtxAddr) != nullptr)
-					{
-						Declaration* decl = parent->GetDeclarationRanged(vtxAddr);
-						uint32_t addr = parent->GetDeclarationRangedAddress(vtxAddr);
-						int diff = addr - vtxAddr;
-						if (diff > 0)
-							nn = diff / 16;
-						else
-							nn = 0;
-					}
+	if (GETSEGNUM(data) == 0x80) // Are these vertices defined in code?
+		vtxAddr -= SEG2FILESPACE(parent->baseAddress);
 
-					if (nn > 0)
-					{
-						vector<Vertex> vtxList = vector<Vertex>();
-						vtxList.reserve(nn);
-
-						for (int i = 0; i < nn; i++)
-						{
-							Vertex vtx = Vertex(fileData, currentPtr);
-							vtxList.push_back(vtx);
+	if (dListType == DListType::F3DZEX)
+		sprintf(line, "gsSPVertex(@r, %i, %i),", nn, ((aa >> 1) - nn));
+	else
+	{
+		uint32_t hi = data >> 32;
 
-							currentPtr += 16;
-						}
+		#define _SHIFTR( v, s, w )	\
+			(((uint32_t)v >> s) & ((0x01 << w) - 1))
 
-						vertices[vtxAddr] = vtxList;
-					}
-				}
+		nn = _SHIFTR(hi, 10, 6);
 
-			}
-			break;
-			case F3DZEXOpcode::G_SETTIMG: // HOTSPOT
-			{
-				int __ = (data & 0x00FF000000000000) >> 48;
-				int www = (data & 0x00000FFF00000000) >> 32;
-				string fmtTbl[] = { "G_IM_FMT_RGBA", "G_IM_FMT_YUV", "G_IM_FMT_CI", "G_IM_FMT_IA", "G_IM_FMT_I" };
-				string sizTbl[] = { "G_IM_SIZ_4b", "G_IM_SIZ_8b", "G_IM_SIZ_16b", "G_IM_SIZ_32b" };
+		sprintf(line, "gsSPVertex(@r, %i, %i),", nn, _SHIFTR(hi, 17, 7));
+	}
 
-				uint32_t fmt = (__ & 0xE0) >> 5;
-				uint32_t siz = (__ & 0x18) >> 3;
+	references.push_back(vtxAddr);
 
-				if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
-					printf("TextureGenCheck G_SETTIMG\n");
+	{
+		uint32_t currentPtr = SEG2FILESPACE(data);
 
-				TextureGenCheck(prefix); // HOTSPOT
+		if (GETSEGNUM(data) == 0x80) // Are these vertices defined in code?
+			currentPtr -= SEG2FILESPACE(parent->baseAddress);
 
-				lastTexFmt = (F3DZEXTexFormats)fmt;
-				lastTexSiz = (F3DZEXTexSizes)siz;
-				lastTexSeg = data;
-				lastTexAddr = data & 0x00FFFFFF;
+		// Check for vertex intersections from other display lists
+		// TODO: These two could probably be condenced to one...
+		if (parent->GetDeclarationRanged(vtxAddr + (nn * 16)) != nullptr)
+		{
+			Declaration* decl = parent->GetDeclarationRanged(vtxAddr + (nn * 16));
+			uint32_t addr = parent->GetDeclarationRangedAddress(vtxAddr + (nn * 16));
+			int diff = addr - vtxAddr;
+			if (diff > 0)
+				nn = diff / 16;
+			else
+				nn = 0;
+		}
 
-				if (GETSEGNUM(lastTexSeg) == 0x80) // Is this texture defined in code?
-					lastTexAddr -= SEG2FILESPACE(parent->baseAddress);
+		if (parent->GetDeclarationRanged(vtxAddr) != nullptr)
+		{
+			Declaration* decl = parent->GetDeclarationRanged(vtxAddr);
+			uint32_t addr = parent->GetDeclarationRangedAddress(vtxAddr);
+			int diff = addr - vtxAddr;
+			if (diff > 0)
+				nn = diff / 16;
+			else
+				nn = 0;
+		}
 
-				int segmentNumber = (data >> 24) & 0xFF;
+		if (nn > 0)
+		{
+			vector<Vertex> vtxList = vector<Vertex>();
+			vtxList.reserve(nn);
 
-				if (segmentNumber != 2)
-				{
-					char texStr[2048];
-					int32_t texAddress = SEG2FILESPACE(data);
-					Declaration* texDecl = nullptr;
+			for (int i = 0; i < nn; i++)
+			{
+				Vertex vtx = Vertex(fileData, currentPtr);
+				vtxList.push_back(vtx);
 
-					if (segmentNumber == 0x80) // Is this texture defined in code?
-						texAddress -= SEG2FILESPACE(parent->baseAddress);
+				currentPtr += 16;
+			}
 
-					if (parent != nullptr)
-					{
-						if (Globals::Instance->HasSegment(segmentNumber))
-							texDecl = parent->GetDeclaration(texAddress);
-						else
-							texDecl = parent->GetDeclaration(data);
-					}
+			vertices[vtxAddr] = vtxList;
+		}
+	}
+}
 
-					if (texDecl != nullptr)
-						sprintf(texStr, "%s", texDecl->varName.c_str());
-					else if (data != 0 && Globals::Instance->HasSegment(segmentNumber))
-						sprintf(texStr, "%sTex_%06X", prefix.c_str(), texAddress);
-					else
-					{
-						// TEST: CHECK OTHER FILES FOR REF
-						//if (segmentNumber == 4)
-						//{
-							//Globals::Instance->FindSymbolSegRef(segmentNumber, texAddress);
-						//}
-						//else
-						{
-							sprintf(texStr, "0x%08lX", data & 0xFFFFFFFF);
-						}
-					}
+void ZDisplayList::Opcode_G_TEXTURE(uint64_t data, int i, std::string prefix, char* line)
+{
+	int ____ = (data & 0x0000FFFF00000000) >> 32;
+	int ssss = (data & 0x00000000FFFF0000) >> 16;
+	int tttt = (data & 0x000000000000FFFF);
+	int lll = (____ & 0x3800) >> 11;
+	int ddd = (____ & 0x700) >> 8;
+	int nnnnnnn = 0;
+
+	if (dListType == DListType::F3DEX)
+		nnnnnnn = (____ & 0xFF);
+	else
+		nnnnnnn = (____ & 0xFE) >> 1;
+
+	sprintf(line, "gsSPTexture(%i, %i, %i, %i, %s),", ssss, tttt, lll, ddd, nnnnnnn == 1 ? "G_ON" : "G_OFF");
+}
 
-					sprintf(line, "gsDPSetTextureImage(%s, %s, %i, %s),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1, texStr);
-					//sprintf(line, "gsDPSetTextureImage(%s, %s, %i, @r),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1);
-					//references.push_back(data & 0x00FFFFFF);
-				}
-				else
-				{
-					//sprintf(line, "gsDPSetTextureImage(%s, %s, %i, 0x%08X),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1, data & 0xFFFFFFFF);
-					sprintf(line, "gsDPSetTextureImage(%s, %s, %i, %sTex_%06lX),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1, scene->GetName().c_str(), SEG2FILESPACE(data));
-				}
-			}
-			break;
-			case F3DZEXOpcode::G_GEOMETRYMODE:
-			{
-				int cccccc = (data & 0x00FFFFFF00000000) >> 32;
-				int ssssssss = (data & 0xFFFFFFFF);
-				string geoModeStr = "G_TEXTURE_ENABLE";
+void ZDisplayList::Opcode_G_SETTIMG(uint64_t data, int i, std::string prefix, char* line)
+{
+	int __ = (data & 0x00FF000000000000) >> 48;
+	int www = (data & 0x00000FFF00000000) >> 32;
+	string fmtTbl[] = { "G_IM_FMT_RGBA", "G_IM_FMT_YUV", "G_IM_FMT_CI", "G_IM_FMT_IA", "G_IM_FMT_I" };
+	string sizTbl[] = { "G_IM_SIZ_4b", "G_IM_SIZ_8b", "G_IM_SIZ_16b", "G_IM_SIZ_32b" };
 
-				int geoModeParam = ~cccccc;
+	uint32_t fmt = (__ & 0xE0) >> 5;
+	uint32_t siz = (__ & 0x18) >> 3;
 
-				if (ssssssss != 0)
-					geoModeParam = ssssssss;
+	if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
+		printf("TextureGenCheck G_SETTIMG\n");
 
-				if (geoModeParam & 0x00000001)
-					geoModeStr += " | G_ZBUFFER";
+	TextureGenCheck(prefix); // HOTSPOT
 
-				if (geoModeParam & 0x00000004)
-					geoModeStr += " | G_SHADE";
+	lastTexFmt = (F3DZEXTexFormats)fmt;
+	lastTexSiz = (F3DZEXTexSizes)siz;
+	lastTexSeg = data;
+	lastTexAddr = data & 0x00FFFFFF;
 
-				if (geoModeParam & 0x00000200)
-					geoModeStr += " | G_CULL_FRONT";
+	if (GETSEGNUM(lastTexSeg) == 0x80) // Is this texture defined in code?
+		lastTexAddr -= SEG2FILESPACE(parent->baseAddress);
 
-				if (geoModeParam & 0x00000400)
-					geoModeStr += " | G_CULL_BACK";
+	int segmentNumber = (data >> 24) & 0xFF;
 
-				if (geoModeParam & 0x00010000)
-					geoModeStr += " | G_FOG";
+	if (segmentNumber != 2)
+	{
+		char texStr[2048];
+		int32_t texAddress = SEG2FILESPACE(data);
+		Declaration* texDecl = nullptr;
 
-				if (geoModeParam & 0x00020000)
-					geoModeStr += " | G_LIGHTING";
+		if (segmentNumber == 0x80) // Is this texture defined in code?
+			texAddress -= SEG2FILESPACE(parent->baseAddress);
 
-				if (geoModeParam & 0x00040000)
-					geoModeStr += " | G_TEXTURE_GEN";
+		if (parent != nullptr)
+		{
+			if (Globals::Instance->HasSegment(segmentNumber))
+				texDecl = parent->GetDeclaration(texAddress);
+			else
+				texDecl = parent->GetDeclaration(data);
+		}
 
-				if (geoModeParam & 0x00080000)
-					geoModeStr += " | G_TEXTURE_GEN_LINEAR";
+		if (texDecl != nullptr)
+			sprintf(texStr, "%s", texDecl->varName.c_str());
+		else if (data != 0 && Globals::Instance->HasSegment(segmentNumber))
+			sprintf(texStr, "%sTex_%06X", prefix.c_str(), texAddress);
+		else
+		{
+			// TEST: CHECK OTHER FILES FOR REF
+			//if (segmentNumber == 4)
+			//{
+				//Globals::Instance->FindSymbolSegRef(segmentNumber, texAddress);
+			//}
+			//else
+			{
+				sprintf(texStr, "0x%08lX", data & 0xFFFFFFFF);
+			}
+		}
 
-				if (geoModeParam & 0x00200000)
-					geoModeStr += " | G_SHADING_SMOOTH";
+		sprintf(line, "gsDPSetTextureImage(%s, %s, %i, %s),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1, texStr);
+		//sprintf(line, "gsDPSetTextureImage(%s, %s, %i, @r),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1);
+		//references.push_back(data & 0x00FFFFFF);
+	}
+	else
+	{
+		//sprintf(line, "gsDPSetTextureImage(%s, %s, %i, 0x%08X),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1, data & 0xFFFFFFFF);
+		sprintf(line, "gsDPSetTextureImage(%s, %s, %i, %sTex_%06lX),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1, scene->GetName().c_str(), SEG2FILESPACE(data));
+	}
+}
 
-				if (geoModeParam & 0x00800000)
-					geoModeStr += " | G_CLIPPING";
+void ZDisplayList::Opcode_G_SETTILE(uint64_t data, int i, std::string prefix, char* line)
+{
+	int fff = (data & 0b0000000011100000000000000000000000000000000000000000000000000000) >> 53;
+	int ii = (data & 0b0000000000011000000000000000000000000000000000000000000000000000) >> 51;
+	int nnnnnnnnn = (data & 0b0000000000000011111111100000000000000000000000000000000000000000) >> 41;
+	int mmmmmmmmm = (data & 0b0000000000000000000000011111111100000000000000000000000000000000) >> 32;
+	int ttt = (data & 0b0000000000000000000000000000000000000111000000000000000000000000) >> 24;
+	int pppp = (data & 0b0000000000000000000000000000000000000000111100000000000000000000) >> 20;
+	int cc = (data & 0b0000000000000000000000000000000000000000000011000000000000000000) >> 18;
+	int aaaa = (data & 0b0000000000000000000000000000000000000000000000111100000000000000) >> 14;
+	int ssss = (data & 0b0000000000000000000000000000000000000000000000000011110000000000) >> 10;
+	int dd = (data & 0b0000000000000000000000000000000000000000000000000000001100000000) >> 8;
+	int bbbb = (data & 0b0000000000000000000000000000000000000000000000000000000011110000) >> 4;
+	int uuuu = (data & 0b0000000000000000000000000000000000000000000000000000000000001111);
+
+	string fmtTbl[] = { "G_IM_FMT_RGBA", "G_IM_FMT_YUV", "G_IM_FMT_CI", "G_IM_FMT_IA", "G_IM_FMT_I" };
+	string sizTbl[] = { "G_IM_SIZ_4b", "G_IM_SIZ_8b", "G_IM_SIZ_16b", "G_IM_SIZ_32b" };
+
+	if (fff == (int)F3DZEXTexFormats::G_IM_FMT_CI)
+		lastCISiz = (F3DZEXTexSizes)ii;
+
+	lastTexSizTest = (F3DZEXTexSizes)ii;
+
+	sprintf(line, "gsDPSetTile(%s, %s, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),", fmtTbl[fff].c_str(), sizTbl[ii].c_str(), nnnnnnnnn, mmmmmmmmm, ttt, pppp, cc, aaaa, ssss, dd, bbbb, uuuu);
+}
 
-				if (ssssssss != 0)
-				{
-					if ((~cccccc & 0xFF000000) != 0)
-						sprintf(line, "gsSPSetGeometryMode(%s),", geoModeStr.c_str());
-					else
-						sprintf(line, "gsSPLoadGeometryMode(%s),", geoModeStr.c_str());
-				}
-				else
-					sprintf(line, "gsSPClearGeometryMode(%s),", geoModeStr.c_str());
+void ZDisplayList::Opcode_G_SETTILESIZE(uint64_t data, int index, std::string prefix, char* line)
+{
+	int sss = (data & 0x00FFF00000000000) >> 44;
+	int ttt = (data & 0x00000FFF00000000) >> 32;
+	int uuu = (data & 0x0000000000FFF000) >> 12;
+	int vvv = (data & 0x0000000000000FFF);
+	int i = (data & 0x000000000F000000) >> 24;
 
-				//sprintf(line, "gsSPGeometryMode(0x%08X, 0x%08X),", ~cccccc, ssssssss);
-			}
-			break;
-			case F3DZEXOpcode::G_SETPRIMCOLOR:
-			{
-				int mm = (data & 0x0000FF0000000000) >> 40;
-				int ff = (data & 0x000000FF00000000) >> 32;
-				int rr = (data & 0x00000000FF000000) >> 24;
-				int gg = (data & 0x0000000000FF0000) >> 16;
-				int bb = (data & 0x000000000000FF00) >> 8;
-				int aa = (data & 0x00000000000000FF) >> 0;
-				sprintf(line, "gsDPSetPrimColor(%i, %i, %i, %i, %i, %i),", mm, ff, rr, gg, bb, aa);
-			}
-			break;
-			case F3DZEXOpcode::G_SETOTHERMODE_L:
-			{
-				int ss = (data & 0x0000FF0000000000) >> 40;
-				int nn = (data & 0x000000FF00000000) >> 32;
-				int dd = (data & 0xFFFFFFFF);
+	int shiftAmtW = 2;
+	int shiftAmtH = 2;
 
-				int sft = 32 - (nn + 1) - ss;
+	if (lastTexSizTest == F3DZEXTexSizes::G_IM_SIZ_8b && lastTexFmt == F3DZEXTexFormats::G_IM_FMT_IA)
+		shiftAmtW = 3;
 
-				//if (sft == 3)
-				if (false)
-				{
-					int mode1 = (dd & 0xCCCC0000) >> 0;
-					int mode2 = (dd & 0x33330000) >> 0;
+	//if (lastTexFmt == F3DZEXTexFormats::G_IM_FMT_I || lastTexFmt == F3DZEXTexFormats::G_IM_FMT_CI)
+	if (lastTexSizTest == F3DZEXTexSizes::G_IM_SIZ_4b)
+		shiftAmtW = 3;
 
-					// TODO: Jesus Christ This is Messy
+	if (lastTexSizTest == F3DZEXTexSizes::G_IM_SIZ_4b && lastTexFmt == F3DZEXTexFormats::G_IM_FMT_IA)
+		shiftAmtH = 3;
 
-					uint32_t tblA[] =
-					{
-						G_RM_FOG_SHADE_A, G_RM_FOG_PRIM_A, G_RM_PASS, G_RM_AA_ZB_OPA_SURF,
-						G_RM_AA_ZB_XLU_SURF, G_RM_AA_ZB_OPA_DECAL, G_RM_AA_ZB_XLU_DECAL,
-						G_RM_AA_ZB_OPA_INTER, G_RM_AA_ZB_XLU_INTER, G_RM_AA_ZB_XLU_LINE,
-						G_RM_AA_ZB_DEC_LINE, G_RM_AA_ZB_TEX_EDGE, G_RM_AA_ZB_TEX_INTER,
-						G_RM_AA_ZB_SUB_SURF, G_RM_AA_ZB_PCL_SURF, G_RM_AA_ZB_OPA_TERR,
-						G_RM_AA_ZB_TEX_TERR, G_RM_AA_ZB_SUB_TERR, G_RM_RA_ZB_OPA_SURF,
-						G_RM_RA_ZB_OPA_DECAL, G_RM_RA_ZB_OPA_INTER, G_RM_AA_OPA_SURF,
-						G_RM_AA_XLU_SURF, G_RM_AA_XLU_LINE, G_RM_AA_DEC_LINE,
-						G_RM_AA_TEX_EDGE, G_RM_AA_SUB_SURF, G_RM_AA_PCL_SURF,
-						G_RM_AA_OPA_TERR, G_RM_AA_TEX_TERR, G_RM_AA_SUB_TERR,
-						G_RM_RA_OPA_SURF, G_RM_ZB_OPA_SURF, G_RM_ZB_XLU_SURF,
-						G_RM_ZB_OPA_DECAL, G_RM_ZB_XLU_DECAL, G_RM_ZB_CLD_SURF,
-						G_RM_ZB_OVL_SURF, G_RM_ZB_PCL_SURF, G_RM_OPA_SURF,
-						G_RM_XLU_SURF, G_RM_CLD_SURF, G_RM_TEX_EDGE, G_RM_PCL_SURF,
-						G_RM_ADD, G_RM_NOOP, G_RM_VISCVG, G_RM_OPA_CI
-					};
-
-					uint32_t tblB[] =
-					{
-						G_RM_AA_ZB_OPA_SURF2,
-						G_RM_AA_ZB_XLU_SURF2, G_RM_AA_ZB_OPA_DECAL2, G_RM_AA_ZB_XLU_DECAL2,
-						G_RM_AA_ZB_OPA_INTER2, G_RM_AA_ZB_XLU_INTER2, G_RM_AA_ZB_XLU_LINE2,
-						G_RM_AA_ZB_DEC_LINE2, G_RM_AA_ZB_TEX_EDGE2, G_RM_AA_ZB_TEX_INTER2,
-						G_RM_AA_ZB_SUB_SURF2, G_RM_AA_ZB_PCL_SURF2, G_RM_AA_ZB_OPA_TERR2,
-						G_RM_AA_ZB_TEX_TERR2, G_RM_AA_ZB_SUB_TERR2, G_RM_RA_ZB_OPA_SURF2,
-						G_RM_RA_ZB_OPA_DECAL2, G_RM_RA_ZB_OPA_INTER2, G_RM_AA_OPA_SURF2,
-						G_RM_AA_XLU_SURF2, G_RM_AA_XLU_LINE2, G_RM_AA_DEC_LINE2,
-						G_RM_AA_TEX_EDGE2, G_RM_AA_SUB_SURF2, G_RM_AA_PCL_SURF2,
-						G_RM_AA_OPA_TERR2, G_RM_AA_TEX_TERR2, G_RM_AA_SUB_TERR2,
-						G_RM_RA_OPA_SURF2, G_RM_ZB_OPA_SURF2, G_RM_ZB_XLU_SURF2,
-						G_RM_ZB_OPA_DECAL2, G_RM_ZB_XLU_DECAL2, G_RM_ZB_CLD_SURF2,
-						G_RM_ZB_OVL_SURF2, G_RM_ZB_PCL_SURF2, G_RM_OPA_SURF2,
-						G_RM_XLU_SURF2, G_RM_CLD_SURF2, G_RM_TEX_EDGE2, G_RM_PCL_SURF2,
-						G_RM_ADD2, G_RM_NOOP2,G_RM_VISCVG2, G_RM_OPA_CI2
-					};
-
-					map<uint32_t, string> str =
-					{
-						{ G_RM_FOG_SHADE_A, "G_RM_FOG_SHADE_A" },
-						{ G_RM_FOG_PRIM_A, "G_RM_FOG_PRIM_A" },
-						{ G_RM_PASS, "G_RM_PASS" },
-						{ G_RM_AA_ZB_OPA_SURF, "G_RM_AA_ZB_OPA_SURF" },
-						{ G_RM_AA_ZB_OPA_SURF2, "G_RM_AA_ZB_OPA_SURF2" },
-						{ G_RM_AA_ZB_XLU_SURF, "G_RM_AA_ZB_XLU_SURF" },
-						{ G_RM_AA_ZB_XLU_SURF2, "G_RM_AA_ZB_XLU_SURF2" },
-						{ G_RM_AA_ZB_OPA_DECAL, "G_RM_AA_ZB_OPA_DECAL" },
-						{ G_RM_AA_ZB_OPA_DECAL2, "G_RM_AA_ZB_OPA_DECAL2" },
-						{ G_RM_AA_ZB_XLU_DECAL, "G_RM_AA_ZB_XLU_DECAL" },
-						{ G_RM_AA_ZB_XLU_DECAL2, "G_RM_AA_ZB_XLU_DECAL2" },
-						{ G_RM_AA_ZB_OPA_INTER, "G_RM_AA_ZB_OPA_INTER" },
-						{ G_RM_AA_ZB_OPA_INTER2, "G_RM_AA_ZB_OPA_INTER2" },
-						{ G_RM_AA_ZB_XLU_INTER, "G_RM_AA_ZB_XLU_INTER" },
-						{ G_RM_AA_ZB_XLU_INTER2, "G_RM_AA_ZB_XLU_INTER2" },
-						{ G_RM_AA_ZB_XLU_LINE, "G_RM_AA_ZB_XLU_LINE" },
-						{ G_RM_AA_ZB_XLU_LINE2, "G_RM_AA_ZB_XLU_LINE2" },
-						{ G_RM_AA_ZB_DEC_LINE, "G_RM_AA_ZB_DEC_LINE" },
-						{ G_RM_AA_ZB_DEC_LINE2, "G_RM_AA_ZB_DEC_LINE2" },
-						{ G_RM_AA_ZB_TEX_EDGE, "G_RM_AA_ZB_TEX_EDGE" },
-						{ G_RM_AA_ZB_TEX_EDGE2, "G_RM_AA_ZB_TEX_EDGE2" },
-						{ G_RM_AA_ZB_TEX_INTER, "G_RM_AA_ZB_TEX_INTER" },
-						{ G_RM_AA_ZB_TEX_INTER2, "G_RM_AA_ZB_TEX_INTER2" },
-						{ G_RM_AA_ZB_SUB_SURF, "G_RM_AA_ZB_SUB_SURF" },
-						{ G_RM_AA_ZB_SUB_SURF2, "G_RM_AA_ZB_SUB_SURF2" },
-						{ G_RM_AA_ZB_PCL_SURF, "G_RM_AA_ZB_PCL_SURF" },
-						{ G_RM_AA_ZB_PCL_SURF2, "G_RM_AA_ZB_PCL_SURF2" },
-						{ G_RM_AA_ZB_OPA_TERR, "G_RM_AA_ZB_OPA_TERR" },
-						{ G_RM_AA_ZB_OPA_TERR2, "G_RM_AA_ZB_OPA_TERR2" },
-						{ G_RM_AA_ZB_TEX_TERR, "G_RM_AA_ZB_TEX_TERR" },
-						{ G_RM_AA_ZB_TEX_TERR2, "G_RM_AA_ZB_TEX_TERR2" },
-						{ G_RM_AA_ZB_SUB_TERR, "G_RM_AA_ZB_SUB_TERR" },
-						{ G_RM_AA_ZB_SUB_TERR2, "G_RM_AA_ZB_SUB_TERR2" },
-						{ G_RM_RA_ZB_OPA_SURF, "G_RM_RA_ZB_OPA_SURF" },
-						{ G_RM_RA_ZB_OPA_SURF2, "G_RM_RA_ZB_OPA_SURF2" },
-						{ G_RM_RA_ZB_OPA_DECAL, "G_RM_RA_ZB_OPA_DECAL" },
-						{ G_RM_RA_ZB_OPA_DECAL2, "G_RM_RA_ZB_OPA_DECAL2" },
-						{ G_RM_RA_ZB_OPA_INTER, "G_RM_RA_ZB_OPA_INTER" },
-						{ G_RM_RA_ZB_OPA_INTER2, "G_RM_RA_ZB_OPA_INTER2" },
-						{ G_RM_AA_OPA_SURF, "G_RM_AA_OPA_SURF" },
-						{ G_RM_AA_OPA_SURF2, "G_RM_AA_OPA_SURF2" },
-						{ G_RM_AA_XLU_SURF, "G_RM_AA_XLU_SURF" },
-						{ G_RM_AA_XLU_SURF2, "G_RM_AA_XLU_SURF2" },
-						{ G_RM_AA_XLU_LINE, "G_RM_AA_XLU_LINE" },
-						{ G_RM_AA_XLU_LINE2, "G_RM_AA_XLU_LINE2" },
-						{ G_RM_AA_DEC_LINE, "G_RM_AA_DEC_LINE" },
-						{ G_RM_AA_DEC_LINE2, "G_RM_AA_DEC_LINE2" },
-						{ G_RM_AA_TEX_EDGE, "G_RM_AA_TEX_EDGE" },
-						{ G_RM_AA_TEX_EDGE2, "G_RM_AA_TEX_EDGE2" },
-						{ G_RM_AA_SUB_SURF, "G_RM_AA_SUB_SURF" },
-						{ G_RM_AA_SUB_SURF2, "G_RM_AA_SUB_SURF2" },
-						{ G_RM_AA_PCL_SURF, "G_RM_AA_PCL_SURF" },
-						{ G_RM_AA_PCL_SURF2, "G_RM_AA_PCL_SURF2" },
-						{ G_RM_AA_OPA_TERR, "G_RM_AA_OPA_TERR" },
-						{ G_RM_AA_OPA_TERR2, "G_RM_AA_OPA_TERR2" },
-						{ G_RM_AA_TEX_TERR, "G_RM_AA_TEX_TERR" },
-						{ G_RM_AA_TEX_TERR2, "G_RM_AA_TEX_TERR2" },
-						{ G_RM_AA_TEX_TERR, "G_RM_AA_TEX_TERR" },
-						{ G_RM_AA_TEX_TERR2, "G_RM_AA_TEX_TERR2" },
-						{ G_RM_AA_SUB_TERR, "G_RM_AA_SUB_TERR" },
-						{ G_RM_AA_SUB_TERR2, "G_RM_AA_SUB_TERR2" },
-						{ G_RM_RA_OPA_SURF, "G_RM_RA_OPA_SURF" },
-						{ G_RM_RA_OPA_SURF2, "G_RM_RA_OPA_SURF2" },
-						{ G_RM_ZB_OPA_SURF, "G_RM_ZB_OPA_SURF" },
-						{ G_RM_ZB_OPA_SURF2, "G_RM_ZB_OPA_SURF2" },
-						{ G_RM_ZB_XLU_SURF, "G_RM_ZB_XLU_SURF" },
-						{ G_RM_ZB_XLU_SURF2, "G_RM_ZB_XLU_SURF2" },
-						{ G_RM_ZB_OPA_DECAL, "G_RM_ZB_OPA_DECAL" },
-						{ G_RM_ZB_OPA_DECAL2, "G_RM_ZB_OPA_DECAL2" },
-						{ G_RM_ZB_XLU_DECAL, "G_RM_ZB_XLU_DECAL" },
-						{ G_RM_ZB_XLU_DECAL2, "G_RM_ZB_XLU_DECAL2" },
-						{ G_RM_ZB_CLD_SURF, "G_RM_ZB_CLD_SURF" },
-						{ G_RM_ZB_CLD_SURF2, "G_RM_ZB_CLD_SURF2" },
-						{ G_RM_ZB_OVL_SURF, "G_RM_ZB_OVL_SURF" },
-						{ G_RM_ZB_OVL_SURF2, "G_RM_ZB_OVL_SURF2" },
-						{ G_RM_ZB_PCL_SURF, "G_RM_ZB_PCL_SURF" },
-						{ G_RM_ZB_PCL_SURF2, "G_RM_ZB_PCL_SURF2" },
-						{ G_RM_OPA_SURF, "G_RM_OPA_SURF" },
-						{ G_RM_OPA_SURF2, "G_RM_OPA_SURF2" },
-						{ G_RM_XLU_SURF, "G_RM_XLU_SURF" },
-						{ G_RM_XLU_SURF2, "G_RM_XLU_SURF2" },
-						{ G_RM_CLD_SURF, "G_RM_CLD_SURF" },
-						{ G_RM_CLD_SURF2, "G_RM_CLD_SURF2" },
-						{ G_RM_TEX_EDGE, "G_RM_TEX_EDGE" },
-						{ G_RM_TEX_EDGE2, "G_RM_TEX_EDGE2" },
-						{ G_RM_PCL_SURF, "G_RM_PCL_SURF" },
-						{ G_RM_PCL_SURF2, "G_RM_PCL_SURF2" },
-						{ G_RM_ADD, "G_RM_ADD" },
-						{ G_RM_ADD2, "G_RM_ADD2" },
-						{ G_RM_NOOP, "G_RM_NOOP" },
-						{ G_RM_NOOP2, "G_RM_NOOP2" },
-						{ G_RM_VISCVG, "G_RM_VISCVG" },
-						{ G_RM_VISCVG2, "G_RM_VISCVG2" },
-						{ G_RM_OPA_CI, "G_RM_OPA_CI" },
-						{ G_RM_OPA_CI2, "G_RM_OPA_CI2" },
-					};
-
-					for (int k = 0; k < sizeof(tblA) / 4; k++)
-					{
-						if ((dd & tblA[k]) == tblA[k])
-						{
-							if (tblA[k] > mode1)
-								mode1 = tblA[k];
 
-							int bp = 0;
-						}
-					}
+	lastTexWidth = (uuu >> shiftAmtW) + 1;
+	lastTexHeight = (vvv >> shiftAmtH) + 1;
 
-					for (int k = 0; k < sizeof(tblB) / 4; k++)
-					{
-						if ((dd & tblB[k]) == tblB[k])
-						{
-							if (tblB[k] > mode2)
-								mode2 = tblB[k];
+	if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
+		printf("lastTexWidth: %i lastTexHeight: %i, lastTexSizTest: 0x%x, lastTexFmt: 0x%x\n", lastTexWidth, lastTexHeight, (uint32_t)lastTexSizTest, (uint32_t)lastTexFmt);
 
-							int bp = 0;
-						}
-					}
+	if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
+		printf("TextureGenCheck G_SETTILESIZE\n");
 
-					sprintf(line, "gsDPSetRenderMode(%s, %s),", str[mode1].c_str(), str[mode2].c_str());
-				}
-				else
-					sprintf(line, "gsSPSetOtherMode(0xE2, %i, %i, 0x%08X),", sft, nn + 1, dd);
-			}
-			break;
-			case F3DZEXOpcode::G_SETOTHERMODE_H:
-			{
-				int ss = (data & 0x0000FF0000000000) >> 40;
-				int nn = (data & 0x000000FF00000000) >> 32;
-				int dd = (data & 0xFFFFFFFF);
+	TextureGenCheck(prefix);
 
-				int sft = 32 - (nn + 1) - ss;
+	sprintf(line, "gsDPSetTileSize(%i, %i, %i, %i, %i),", i, sss, ttt, uuu, vvv);
+}
 
-				if (sft == 14) // G_MDSFT_TEXTLUT
-				{
-					string types[] = { "G_TT_NONE", "G_TT_NONE", "G_TT_RGBA16", "G_TT_IA16" };
-					sprintf(line, "gsDPSetTextureLUT(%s),", types[dd >> 14].c_str());
-				}
-				else
-					sprintf(line, "gsSPSetOtherMode(0xE3, %i, %i, 0x%08X),", sft, nn + 1, dd);
-			}
-			break;
-			case F3DZEXOpcode::G_SETTILE:
-			{
-				int fff = (data & 0b0000000011100000000000000000000000000000000000000000000000000000) >> 53;
-				int ii = (data & 0b0000000000011000000000000000000000000000000000000000000000000000) >> 51;
-				int nnnnnnnnn = (data & 0b0000000000000011111111100000000000000000000000000000000000000000) >> 41;
-				int mmmmmmmmm = (data & 0b0000000000000000000000011111111100000000000000000000000000000000) >> 32;
-				int ttt = (data & 0b0000000000000000000000000000000000000111000000000000000000000000) >> 24;
-				int pppp = (data & 0b0000000000000000000000000000000000000000111100000000000000000000) >> 20;
-				int cc = (data & 0b0000000000000000000000000000000000000000000011000000000000000000) >> 18;
-				int aaaa = (data & 0b0000000000000000000000000000000000000000000000111100000000000000) >> 14;
-				int ssss = (data & 0b0000000000000000000000000000000000000000000000000011110000000000) >> 10;
-				int dd = (data & 0b0000000000000000000000000000000000000000000000000000001100000000) >> 8;
-				int bbbb = (data & 0b0000000000000000000000000000000000000000000000000000000011110000) >> 4;
-				int uuuu = (data & 0b0000000000000000000000000000000000000000000000000000000000001111);
-
-				string fmtTbl[] = { "G_IM_FMT_RGBA", "G_IM_FMT_YUV", "G_IM_FMT_CI", "G_IM_FMT_IA", "G_IM_FMT_I" };
-				string sizTbl[] = { "G_IM_SIZ_4b", "G_IM_SIZ_8b", "G_IM_SIZ_16b", "G_IM_SIZ_32b" };
-
-				if (fff == (int)F3DZEXTexFormats::G_IM_FMT_CI)
-					lastCISiz = (F3DZEXTexSizes)ii;
-
-				lastTexSizTest = (F3DZEXTexSizes)ii;
-
-				sprintf(line, "gsDPSetTile(%s, %s, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),", fmtTbl[fff].c_str(), sizTbl[ii].c_str(), nnnnnnnnn, mmmmmmmmm, ttt, pppp, cc, aaaa, ssss, dd, bbbb, uuuu);
-			}
-			break;
-			case F3DZEXOpcode::G_SETTILESIZE:
-			{
-				int sss = (data & 0x00FFF00000000000) >> 44;
-				int ttt = (data & 0x00000FFF00000000) >> 32;
-				int uuu = (data & 0x0000000000FFF000) >> 12;
-				int vvv = (data & 0x0000000000000FFF);
-				int i = (data & 0x000000000F000000) >> 24;
+void ZDisplayList::Opcode_G_LOADBLOCK(uint64_t data, int index, std::string prefix, char* line)
+{
+	int sss = (data & 0x00FFF00000000000) >> 48;
+	int ttt = (data & 0x00000FFF00000000) >> 36;
+	int i = (data & 0x000000000F000000) >> 24;
+	int xxx = (data & 0x0000000000FFF000) >> 12;
+	int ddd = (data & 0x0000000000000FFF);
 
-				int shiftAmtW = 2;
-				int shiftAmtH = 2;
+	//lastTexHeight = (ddd + 1) / 16;
 
-				if (lastTexSizTest == F3DZEXTexSizes::G_IM_SIZ_8b && lastTexFmt == F3DZEXTexFormats::G_IM_FMT_IA)
-					shiftAmtW = 3;
+	lastTexLoaded = true;
 
-				//if (lastTexFmt == F3DZEXTexFormats::G_IM_FMT_I || lastTexFmt == F3DZEXTexFormats::G_IM_FMT_CI)
-				if (lastTexSizTest == F3DZEXTexSizes::G_IM_SIZ_4b)
-					shiftAmtW = 3;
+	//TextureGenCheck(prefix);
 
-				if (lastTexSizTest == F3DZEXTexSizes::G_IM_SIZ_4b && lastTexFmt == F3DZEXTexFormats::G_IM_FMT_IA)
-					shiftAmtH = 3;
+	sprintf(line, "gsDPLoadBlock(%i, %i, %i, %i, %i),", i, sss, ttt, xxx, ddd);
+}
 
+void ZDisplayList::Opcode_G_SETCOMBINE(uint64_t data, int i, std::string prefix, char* line)
+{
+	int a0 = (data & 0b000000011110000000000000000000000000000000000000000000000000000) >> 52;
+	int c0 = (data & 0b000000000001111100000000000000000000000000000000000000000000000) >> 47;
+	int aa0 = (data & 0b00000000000000011100000000000000000000000000000000000000000000) >> 44;
+	int ac0 = (data & 0b00000000000000000011100000000000000000000000000000000000000000) >> 41;
+	int a1 = (data & 0b000000000000000000000011110000000000000000000000000000000000000) >> 37;
+	int c1 = (data & 0b000000000000000000000000001111100000000000000000000000000000000) >> 32;
+	int b0 = (data & 0b000000000000000000000000000000011110000000000000000000000000000) >> 28;
+	int b1 = (data & 0b000000000000000000000000000000000001111000000000000000000000000) >> 24;
+	int aa1 = (data & 0b00000000000000000000000000000000000000111000000000000000000000) >> 21;
+	int ac1 = (data & 0b00000000000000000000000000000000000000000111000000000000000000) >> 18;
+	int d0 = (data & 0b000000000000000000000000000000000000000000000111000000000000000) >> 15;
+	int ab0 = (data & 0b00000000000000000000000000000000000000000000000111000000000000) >> 12;
+	int ad0 = (data & 0b00000000000000000000000000000000000000000000000000111000000000) >> 9;
+	int d1 = (data & 0b000000000000000000000000000000000000000000000000000000111000000) >> 6;
+	int ab1 = (data & 0b00000000000000000000000000000000000000000000000000000000111000) >> 3;
+	int ad1 = (data & 0b00000000000000000000000000000000000000000000000000000000000111) >> 0;
+
+	string modes[] = { "COMBINED", "TEXEL0", "TEXEL1", "PRIMITIVE", "SHADE", "ENVIRONMENT", "1", "COMBINED_ALPHA",
+		"TEXEL0_ALPHA", "TEXEL1_ALPHA", "PRIMITIVE_ALPHA", "SHADE_ALPHA", "ENV_ALPHA", "LOD_FRACTION", "PRIM_LOD_FRAC", "K5",
+		"17", "18", "19", "20", "21", "22", "23", "24",
+		"25", "26", "27", "28", "29", "30", "31", "0" };
+
+	string modes2[] = { "COMBINED", "TEXEL0", "TEXEL1", "PRIMITIVE", "SHADE", "ENVIRONMENT", "1", "0" };
+
+	sprintf(line, "gsDPSetCombineLERP(%s, %s, %s, %s, %s, %s, %s, %s,\n                       %s, %s, %s, %s, %s, %s, %s, %s),",
+		modes[a0].c_str(), modes[b0].c_str(), modes[c0].c_str(), modes[d0].c_str(),
+		modes2[aa0].c_str(), modes2[ab0].c_str(), modes2[ac0].c_str(), modes2[ad0].c_str(),
+		modes[a1].c_str(), modes[b1].c_str(), modes[c1].c_str(), modes[d1].c_str(),
+		modes2[aa1].c_str(), modes2[ab1].c_str(), modes2[ac1].c_str(), modes2[ad1].c_str());
+}
 
-				lastTexWidth = (uuu >> shiftAmtW) + 1;
-				lastTexHeight = (vvv >> shiftAmtH) + 1;
+void ZDisplayList::Opcode_G_SETPRIMCOLOR(uint64_t data, int i, std::string prefix, char* line)
+{
+	int mm = (data & 0x0000FF0000000000) >> 40;
+	int ff = (data & 0x000000FF00000000) >> 32;
+	int rr = (data & 0x00000000FF000000) >> 24;
+	int gg = (data & 0x0000000000FF0000) >> 16;
+	int bb = (data & 0x000000000000FF00) >> 8;
+	int aa = (data & 0x00000000000000FF) >> 0;
+	sprintf(line, "gsDPSetPrimColor(%i, %i, %i, %i, %i, %i),", mm, ff, rr, gg, bb, aa);
+}
 
-				if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
-					printf("lastTexWidth: %i lastTexHeight: %i, lastTexSizTest: 0x%x, lastTexFmt: 0x%x\n", lastTexWidth, lastTexHeight, (uint32_t)lastTexSizTest, (uint32_t)lastTexFmt);
+void ZDisplayList::Opcode_F3DEX_G_SETOTHERMODE_L(uint64_t data, int i, std::string prefix, char* line)
+{
+	int sft = (data & 0x0000FF0000000000) >> 40;
+	int len = (data & 0x000000FF00000000) >> 32;
+	int dat = (data & 0xFFFFFFFF);
 
-				if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
-					printf("TextureGenCheck G_SETTILESIZE\n");
+	// TODO: Output the correct render modes in data
 
-				TextureGenCheck(prefix);
+	sprintf(line, "gsSPSetOtherMode(0xE2, %i, %i, 0x%08X),", sft, len, dat);
+}
 
-				sprintf(line, "gsDPSetTileSize(%i, %i, %i, %i, %i),", i, sss, ttt, uuu, vvv);
-			}
-			break;
-			case F3DZEXOpcode::G_LOADBLOCK:
-			{
-				int sss = (data & 0x00FFF00000000000) >> 48;
-				int ttt = (data & 0x00000FFF00000000) >> 36;
-				int i	= (data & 0x000000000F000000) >> 24;
-				int xxx = (data & 0x0000000000FFF000) >> 12;
-				int ddd = (data & 0x0000000000000FFF);
+void ZDisplayList::Opcode_G_SETOTHERMODE_L(uint64_t data, int i, std::string prefix, char* line)
+{
+	int ss = (data & 0x0000FF0000000000) >> 40;
+	int nn = (data & 0x000000FF00000000) >> 32;
+	int dd = (data & 0xFFFFFFFF);
 
-				//lastTexHeight = (ddd + 1) / 16;
+	int sft = 32 - (nn + 1) - ss;
 
-				lastTexLoaded = true;
+	//if (sft == 3)
+	if (false)
+	{
+		int mode1 = (dd & 0xCCCC0000) >> 0;
+		int mode2 = (dd & 0x33330000) >> 0;
 
-				//TextureGenCheck(prefix);
+		// TODO: Jesus Christ This is Messy
 
-				sprintf(line, "gsDPLoadBlock(%i, %i, %i, %i, %i),", i, sss, ttt, xxx, ddd);
-			}
-			break;
-			case F3DZEXOpcode::G_TEXTURE:
+		uint32_t tblA[] =
+		{
+			G_RM_FOG_SHADE_A, G_RM_FOG_PRIM_A, G_RM_PASS, G_RM_AA_ZB_OPA_SURF,
+			G_RM_AA_ZB_XLU_SURF, G_RM_AA_ZB_OPA_DECAL, G_RM_AA_ZB_XLU_DECAL,
+			G_RM_AA_ZB_OPA_INTER, G_RM_AA_ZB_XLU_INTER, G_RM_AA_ZB_XLU_LINE,
+			G_RM_AA_ZB_DEC_LINE, G_RM_AA_ZB_TEX_EDGE, G_RM_AA_ZB_TEX_INTER,
+			G_RM_AA_ZB_SUB_SURF, G_RM_AA_ZB_PCL_SURF, G_RM_AA_ZB_OPA_TERR,
+			G_RM_AA_ZB_TEX_TERR, G_RM_AA_ZB_SUB_TERR, G_RM_RA_ZB_OPA_SURF,
+			G_RM_RA_ZB_OPA_DECAL, G_RM_RA_ZB_OPA_INTER, G_RM_AA_OPA_SURF,
+			G_RM_AA_XLU_SURF, G_RM_AA_XLU_LINE, G_RM_AA_DEC_LINE,
+			G_RM_AA_TEX_EDGE, G_RM_AA_SUB_SURF, G_RM_AA_PCL_SURF,
+			G_RM_AA_OPA_TERR, G_RM_AA_TEX_TERR, G_RM_AA_SUB_TERR,
+			G_RM_RA_OPA_SURF, G_RM_ZB_OPA_SURF, G_RM_ZB_XLU_SURF,
+			G_RM_ZB_OPA_DECAL, G_RM_ZB_XLU_DECAL, G_RM_ZB_CLD_SURF,
+			G_RM_ZB_OVL_SURF, G_RM_ZB_PCL_SURF, G_RM_OPA_SURF,
+			G_RM_XLU_SURF, G_RM_CLD_SURF, G_RM_TEX_EDGE, G_RM_PCL_SURF,
+			G_RM_ADD, G_RM_NOOP, G_RM_VISCVG, G_RM_OPA_CI
+		};
+
+		uint32_t tblB[] =
+		{
+			G_RM_AA_ZB_OPA_SURF2,
+			G_RM_AA_ZB_XLU_SURF2, G_RM_AA_ZB_OPA_DECAL2, G_RM_AA_ZB_XLU_DECAL2,
+			G_RM_AA_ZB_OPA_INTER2, G_RM_AA_ZB_XLU_INTER2, G_RM_AA_ZB_XLU_LINE2,
+			G_RM_AA_ZB_DEC_LINE2, G_RM_AA_ZB_TEX_EDGE2, G_RM_AA_ZB_TEX_INTER2,
+			G_RM_AA_ZB_SUB_SURF2, G_RM_AA_ZB_PCL_SURF2, G_RM_AA_ZB_OPA_TERR2,
+			G_RM_AA_ZB_TEX_TERR2, G_RM_AA_ZB_SUB_TERR2, G_RM_RA_ZB_OPA_SURF2,
+			G_RM_RA_ZB_OPA_DECAL2, G_RM_RA_ZB_OPA_INTER2, G_RM_AA_OPA_SURF2,
+			G_RM_AA_XLU_SURF2, G_RM_AA_XLU_LINE2, G_RM_AA_DEC_LINE2,
+			G_RM_AA_TEX_EDGE2, G_RM_AA_SUB_SURF2, G_RM_AA_PCL_SURF2,
+			G_RM_AA_OPA_TERR2, G_RM_AA_TEX_TERR2, G_RM_AA_SUB_TERR2,
+			G_RM_RA_OPA_SURF2, G_RM_ZB_OPA_SURF2, G_RM_ZB_XLU_SURF2,
+			G_RM_ZB_OPA_DECAL2, G_RM_ZB_XLU_DECAL2, G_RM_ZB_CLD_SURF2,
+			G_RM_ZB_OVL_SURF2, G_RM_ZB_PCL_SURF2, G_RM_OPA_SURF2,
+			G_RM_XLU_SURF2, G_RM_CLD_SURF2, G_RM_TEX_EDGE2, G_RM_PCL_SURF2,
+			G_RM_ADD2, G_RM_NOOP2,G_RM_VISCVG2, G_RM_OPA_CI2
+		};
+
+		map<uint32_t, string> str =
+		{
+			{ G_RM_FOG_SHADE_A, "G_RM_FOG_SHADE_A" },
+			{ G_RM_FOG_PRIM_A, "G_RM_FOG_PRIM_A" },
+			{ G_RM_PASS, "G_RM_PASS" },
+			{ G_RM_AA_ZB_OPA_SURF, "G_RM_AA_ZB_OPA_SURF" },
+			{ G_RM_AA_ZB_OPA_SURF2, "G_RM_AA_ZB_OPA_SURF2" },
+			{ G_RM_AA_ZB_XLU_SURF, "G_RM_AA_ZB_XLU_SURF" },
+			{ G_RM_AA_ZB_XLU_SURF2, "G_RM_AA_ZB_XLU_SURF2" },
+			{ G_RM_AA_ZB_OPA_DECAL, "G_RM_AA_ZB_OPA_DECAL" },
+			{ G_RM_AA_ZB_OPA_DECAL2, "G_RM_AA_ZB_OPA_DECAL2" },
+			{ G_RM_AA_ZB_XLU_DECAL, "G_RM_AA_ZB_XLU_DECAL" },
+			{ G_RM_AA_ZB_XLU_DECAL2, "G_RM_AA_ZB_XLU_DECAL2" },
+			{ G_RM_AA_ZB_OPA_INTER, "G_RM_AA_ZB_OPA_INTER" },
+			{ G_RM_AA_ZB_OPA_INTER2, "G_RM_AA_ZB_OPA_INTER2" },
+			{ G_RM_AA_ZB_XLU_INTER, "G_RM_AA_ZB_XLU_INTER" },
+			{ G_RM_AA_ZB_XLU_INTER2, "G_RM_AA_ZB_XLU_INTER2" },
+			{ G_RM_AA_ZB_XLU_LINE, "G_RM_AA_ZB_XLU_LINE" },
+			{ G_RM_AA_ZB_XLU_LINE2, "G_RM_AA_ZB_XLU_LINE2" },
+			{ G_RM_AA_ZB_DEC_LINE, "G_RM_AA_ZB_DEC_LINE" },
+			{ G_RM_AA_ZB_DEC_LINE2, "G_RM_AA_ZB_DEC_LINE2" },
+			{ G_RM_AA_ZB_TEX_EDGE, "G_RM_AA_ZB_TEX_EDGE" },
+			{ G_RM_AA_ZB_TEX_EDGE2, "G_RM_AA_ZB_TEX_EDGE2" },
+			{ G_RM_AA_ZB_TEX_INTER, "G_RM_AA_ZB_TEX_INTER" },
+			{ G_RM_AA_ZB_TEX_INTER2, "G_RM_AA_ZB_TEX_INTER2" },
+			{ G_RM_AA_ZB_SUB_SURF, "G_RM_AA_ZB_SUB_SURF" },
+			{ G_RM_AA_ZB_SUB_SURF2, "G_RM_AA_ZB_SUB_SURF2" },
+			{ G_RM_AA_ZB_PCL_SURF, "G_RM_AA_ZB_PCL_SURF" },
+			{ G_RM_AA_ZB_PCL_SURF2, "G_RM_AA_ZB_PCL_SURF2" },
+			{ G_RM_AA_ZB_OPA_TERR, "G_RM_AA_ZB_OPA_TERR" },
+			{ G_RM_AA_ZB_OPA_TERR2, "G_RM_AA_ZB_OPA_TERR2" },
+			{ G_RM_AA_ZB_TEX_TERR, "G_RM_AA_ZB_TEX_TERR" },
+			{ G_RM_AA_ZB_TEX_TERR2, "G_RM_AA_ZB_TEX_TERR2" },
+			{ G_RM_AA_ZB_SUB_TERR, "G_RM_AA_ZB_SUB_TERR" },
+			{ G_RM_AA_ZB_SUB_TERR2, "G_RM_AA_ZB_SUB_TERR2" },
+			{ G_RM_RA_ZB_OPA_SURF, "G_RM_RA_ZB_OPA_SURF" },
+			{ G_RM_RA_ZB_OPA_SURF2, "G_RM_RA_ZB_OPA_SURF2" },
+			{ G_RM_RA_ZB_OPA_DECAL, "G_RM_RA_ZB_OPA_DECAL" },
+			{ G_RM_RA_ZB_OPA_DECAL2, "G_RM_RA_ZB_OPA_DECAL2" },
+			{ G_RM_RA_ZB_OPA_INTER, "G_RM_RA_ZB_OPA_INTER" },
+			{ G_RM_RA_ZB_OPA_INTER2, "G_RM_RA_ZB_OPA_INTER2" },
+			{ G_RM_AA_OPA_SURF, "G_RM_AA_OPA_SURF" },
+			{ G_RM_AA_OPA_SURF2, "G_RM_AA_OPA_SURF2" },
+			{ G_RM_AA_XLU_SURF, "G_RM_AA_XLU_SURF" },
+			{ G_RM_AA_XLU_SURF2, "G_RM_AA_XLU_SURF2" },
+			{ G_RM_AA_XLU_LINE, "G_RM_AA_XLU_LINE" },
+			{ G_RM_AA_XLU_LINE2, "G_RM_AA_XLU_LINE2" },
+			{ G_RM_AA_DEC_LINE, "G_RM_AA_DEC_LINE" },
+			{ G_RM_AA_DEC_LINE2, "G_RM_AA_DEC_LINE2" },
+			{ G_RM_AA_TEX_EDGE, "G_RM_AA_TEX_EDGE" },
+			{ G_RM_AA_TEX_EDGE2, "G_RM_AA_TEX_EDGE2" },
+			{ G_RM_AA_SUB_SURF, "G_RM_AA_SUB_SURF" },
+			{ G_RM_AA_SUB_SURF2, "G_RM_AA_SUB_SURF2" },
+			{ G_RM_AA_PCL_SURF, "G_RM_AA_PCL_SURF" },
+			{ G_RM_AA_PCL_SURF2, "G_RM_AA_PCL_SURF2" },
+			{ G_RM_AA_OPA_TERR, "G_RM_AA_OPA_TERR" },
+			{ G_RM_AA_OPA_TERR2, "G_RM_AA_OPA_TERR2" },
+			{ G_RM_AA_TEX_TERR, "G_RM_AA_TEX_TERR" },
+			{ G_RM_AA_TEX_TERR2, "G_RM_AA_TEX_TERR2" },
+			{ G_RM_AA_TEX_TERR, "G_RM_AA_TEX_TERR" },
+			{ G_RM_AA_TEX_TERR2, "G_RM_AA_TEX_TERR2" },
+			{ G_RM_AA_SUB_TERR, "G_RM_AA_SUB_TERR" },
+			{ G_RM_AA_SUB_TERR2, "G_RM_AA_SUB_TERR2" },
+			{ G_RM_RA_OPA_SURF, "G_RM_RA_OPA_SURF" },
+			{ G_RM_RA_OPA_SURF2, "G_RM_RA_OPA_SURF2" },
+			{ G_RM_ZB_OPA_SURF, "G_RM_ZB_OPA_SURF" },
+			{ G_RM_ZB_OPA_SURF2, "G_RM_ZB_OPA_SURF2" },
+			{ G_RM_ZB_XLU_SURF, "G_RM_ZB_XLU_SURF" },
+			{ G_RM_ZB_XLU_SURF2, "G_RM_ZB_XLU_SURF2" },
+			{ G_RM_ZB_OPA_DECAL, "G_RM_ZB_OPA_DECAL" },
+			{ G_RM_ZB_OPA_DECAL2, "G_RM_ZB_OPA_DECAL2" },
+			{ G_RM_ZB_XLU_DECAL, "G_RM_ZB_XLU_DECAL" },
+			{ G_RM_ZB_XLU_DECAL2, "G_RM_ZB_XLU_DECAL2" },
+			{ G_RM_ZB_CLD_SURF, "G_RM_ZB_CLD_SURF" },
+			{ G_RM_ZB_CLD_SURF2, "G_RM_ZB_CLD_SURF2" },
+			{ G_RM_ZB_OVL_SURF, "G_RM_ZB_OVL_SURF" },
+			{ G_RM_ZB_OVL_SURF2, "G_RM_ZB_OVL_SURF2" },
+			{ G_RM_ZB_PCL_SURF, "G_RM_ZB_PCL_SURF" },
+			{ G_RM_ZB_PCL_SURF2, "G_RM_ZB_PCL_SURF2" },
+			{ G_RM_OPA_SURF, "G_RM_OPA_SURF" },
+			{ G_RM_OPA_SURF2, "G_RM_OPA_SURF2" },
+			{ G_RM_XLU_SURF, "G_RM_XLU_SURF" },
+			{ G_RM_XLU_SURF2, "G_RM_XLU_SURF2" },
+			{ G_RM_CLD_SURF, "G_RM_CLD_SURF" },
+			{ G_RM_CLD_SURF2, "G_RM_CLD_SURF2" },
+			{ G_RM_TEX_EDGE, "G_RM_TEX_EDGE" },
+			{ G_RM_TEX_EDGE2, "G_RM_TEX_EDGE2" },
+			{ G_RM_PCL_SURF, "G_RM_PCL_SURF" },
+			{ G_RM_PCL_SURF2, "G_RM_PCL_SURF2" },
+			{ G_RM_ADD, "G_RM_ADD" },
+			{ G_RM_ADD2, "G_RM_ADD2" },
+			{ G_RM_NOOP, "G_RM_NOOP" },
+			{ G_RM_NOOP2, "G_RM_NOOP2" },
+			{ G_RM_VISCVG, "G_RM_VISCVG" },
+			{ G_RM_VISCVG2, "G_RM_VISCVG2" },
+			{ G_RM_OPA_CI, "G_RM_OPA_CI" },
+			{ G_RM_OPA_CI2, "G_RM_OPA_CI2" },
+		};
+
+		for (int k = 0; k < sizeof(tblA) / 4; k++)
+		{
+			if ((dd & tblA[k]) == tblA[k])
 			{
-				int ____ = (data & 0x0000FFFF00000000) >> 32;
-				int ssss = (data & 0x00000000FFFF0000) >> 16;
-				int tttt = (data & 0x000000000000FFFF);
-				int lll = (____ & 0x3800) >> 11;
-				int ddd = (____ & 0x700) >> 8;
-				int nnnnnnn = (____ & 0xFE) >> 1;
-
-				sprintf(line, "gsSPTexture(%i, %i, %i, %i, %s),", ssss, tttt, lll, ddd, nnnnnnn == 1 ? "G_ON" : "G_OFF");
+				if (tblA[k] > mode1)
+					mode1 = tblA[k];
 			}
-			break;
-			case F3DZEXOpcode::G_RDPSETOTHERMODE:
-			{
-				int hhhhhh = (data & 0x00FFFFFF00000000) >> 32;
-				int llllllll = (data & 0x00000000FFFFFFFF);
+		}
 
-				sprintf(line, "gsDPSetOtherMode(%i, %i),", hhhhhh, llllllll);
-			}
-			break;
-			case F3DZEXOpcode::G_POPMTX:
+		for (int k = 0; k < sizeof(tblB) / 4; k++)
+		{
+			if ((dd & tblB[k]) == tblB[k])
 			{
-				sprintf(line, "gsSPPopMatrix(%li),", data);
+				if (tblB[k] > mode2)
+					mode2 = tblB[k];
 			}
-			break;
-			case F3DZEXOpcode::G_LOADTLUT:
-			{
-				int t = (data & 0x0000000007000000) >> 24;
-				int ccc = (data & 0x00000000003FF000) >> 14;
+		}
 
-				lastTexWidth = sqrt(ccc + 1);
-				lastTexHeight = sqrt(ccc + 1);
+		sprintf(line, "gsDPSetRenderMode(%s, %s),", str[mode1].c_str(), str[mode2].c_str());
+	}
+	else
+		sprintf(line, "gsSPSetOtherMode(0xE2, %i, %i, 0x%08X),", sft, nn + 1, dd);
+}
 
-				lastTexLoaded = true;
-				lastTexIsPalette = true;
+void ZDisplayList::Opcode_G_SETOTHERMODE_H(uint64_t data, int i, std::string prefix, char* line)
+{
+	int ss = (data & 0x0000FF0000000000) >> 40;
+	int nn = (data & 0x000000FF00000000) >> 32;
+	int dd = (data & 0xFFFFFFFF);
 
-				if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
-					printf("TextureGenCheck G_LOADTLUT (lastCISiz: %i)\n", (uint32_t)lastCISiz);
+	int sft = 32 - (nn + 1) - ss;
 
-				TextureGenCheck(prefix);
+	if (sft == 14) // G_MDSFT_TEXTLUT
+	{
+		string types[] = { "G_TT_NONE", "G_TT_NONE", "G_TT_RGBA16", "G_TT_IA16" };
+		sprintf(line, "gsDPSetTextureLUT(%s),", types[dd >> 14].c_str());
+	}
+	else
+		sprintf(line, "gsSPSetOtherMode(0xE3, %i, %i, 0x%08X),", sft, nn + 1, dd);
+}
 
-				sprintf(line, "gsDPLoadTLUTCmd(%i, %i),", t, ccc);
-			}
-			break;
-			case F3DZEXOpcode::G_SETENVCOLOR:
-			{
-				uint8_t r = (uint8_t)((data & 0xFF000000) >> 24);
-				uint8_t g = (uint8_t)((data & 0x00FF0000) >> 16);
-				uint8_t b = (uint8_t)((data & 0xFF00FF00) >> 8);
-				uint8_t a = (uint8_t)((data & 0x000000FF) >> 0);
+void ZDisplayList::Opcode_G_LOADTLUT(uint64_t data, int i, std::string prefix, char* line)
+{
+	int t = (data & 0x0000000007000000) >> 24;
+	int ccc = (data & 0x00000000003FF000) >> 14;
 
-				sprintf(line, "gsDPSetEnvColor(%i, %i, %i, %i),", r, g, b, a);
-			}
-			break;
-			case F3DZEXOpcode::G_SETCOMBINE:
-			{
-				int a0 = (data & 0b000000011110000000000000000000000000000000000000000000000000000) >> 52;
-				int c0 = (data & 0b000000000001111100000000000000000000000000000000000000000000000) >> 47;
-				int aa0 = (data & 0b00000000000000011100000000000000000000000000000000000000000000) >> 44;
-				int ac0 = (data & 0b00000000000000000011100000000000000000000000000000000000000000) >> 41;
-				int a1 = (data & 0b000000000000000000000011110000000000000000000000000000000000000) >> 37;
-				int c1 = (data & 0b000000000000000000000000001111100000000000000000000000000000000) >> 32;
-				int b0 = (data & 0b000000000000000000000000000000011110000000000000000000000000000) >> 28;
-				int b1 = (data & 0b000000000000000000000000000000000001111000000000000000000000000) >> 24;
-				int aa1 = (data & 0b00000000000000000000000000000000000000111000000000000000000000) >> 21;
-				int ac1 = (data & 0b00000000000000000000000000000000000000000111000000000000000000) >> 18;
-				int d0 = (data & 0b000000000000000000000000000000000000000000000111000000000000000) >> 15;
-				int ab0 = (data & 0b00000000000000000000000000000000000000000000000111000000000000) >> 12;
-				int ad0 = (data & 0b00000000000000000000000000000000000000000000000000111000000000) >> 9;
-				int d1 = (data & 0b000000000000000000000000000000000000000000000000000000111000000) >> 6;
-				int ab1 = (data & 0b00000000000000000000000000000000000000000000000000000000111000) >> 3;
-				int ad1 = (data & 0b00000000000000000000000000000000000000000000000000000000000111) >> 0;
-
-				string modes[] = { "COMBINED", "TEXEL0", "TEXEL1", "PRIMITIVE", "SHADE", "ENVIRONMENT", "1", "COMBINED_ALPHA",
-					"TEXEL0_ALPHA", "TEXEL1_ALPHA", "PRIMITIVE_ALPHA", "SHADE_ALPHA", "ENV_ALPHA", "LOD_FRACTION", "PRIM_LOD_FRAC", "K5",
-					"17", "18", "19", "20", "21", "22", "23", "24",
-					"25", "26", "27", "28", "29", "30", "31", "0" };
-
-				string modes2[] = { "COMBINED", "TEXEL0", "TEXEL1", "PRIMITIVE", "SHADE", "ENVIRONMENT", "1", "0" };
-
-				sprintf(line, "gsDPSetCombineLERP(%s, %s, %s, %s, %s, %s, %s, %s,\n                       %s, %s, %s, %s, %s, %s, %s, %s),",
-					modes[a0].c_str(), modes[b0].c_str(), modes[c0].c_str(), modes[d0].c_str(),
-					modes2[aa0].c_str(), modes2[ab0].c_str(), modes2[ac0].c_str(), modes2[ad0].c_str(),
-					modes[a1].c_str(), modes[b1].c_str(), modes[c1].c_str(), modes[d1].c_str(),
-					modes2[aa1].c_str(), modes2[ab1].c_str(), modes2[ac1].c_str(), modes2[ad1].c_str());
-			}
-			break;
-			case F3DZEXOpcode::G_RDPLOADSYNC:
-				sprintf(line, "gsDPLoadSync(),");
-				break;
-			case F3DZEXOpcode::G_RDPPIPESYNC:
-				sprintf(line, "gsDPPipeSync(),");
-				break;
-			case F3DZEXOpcode::G_RDPTILESYNC:
-				sprintf(line, "gsDPTileSync(),");
-				break;
-			case F3DZEXOpcode::G_RDPFULLSYNC:
-				sprintf(line, "gsDPFullSync(),");
-				break;
-			case F3DZEXOpcode::G_ENDDL:
-				sprintf(line, "gsSPEndDisplayList(),");
-
-				if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
-					printf("TextureGenCheck G_ENDDL\n");
+	lastTexWidth = sqrt(ccc + 1);
+	lastTexHeight = sqrt(ccc + 1);
 
-				TextureGenCheck(prefix);
-				break;
-			case F3DZEXOpcode::G_RDPHALF_1:
-			{
-				uint64_t data2 = instructions[i + 1];
-				uint32_t h = (data & 0xFFFFFFFF);
-				F3DZEXOpcode opcode2 = (F3DZEXOpcode)(instructions[i + 1] >> 56);
+	lastTexLoaded = true;
+	lastTexIsPalette = true;
 
-				if (opcode2 == F3DZEXOpcode::G_BRANCH_Z)
-				{
-					uint32_t a = (data2 & 0x00FFF00000000000) >> 44;
-					uint32_t b = (data2 & 0x00000FFF00000000) >> 32;
-					uint32_t z = (data2 & 0x00000000FFFFFFFF) >> 0;
+	if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
+		printf("TextureGenCheck G_LOADTLUT (lastCISiz: %i)\n", (uint32_t)lastCISiz);
 
-					//sprintf(line, "gsDPWord(%i, 0),", h);
-					sprintf(line, "gsSPBranchLessZraw(%sDlist0x%06X, 0x%02X, 0x%02X),", prefix.c_str(), h & 0x00FFFFFF, (a / 5) | (b / 2), z);
+	TextureGenCheck(prefix);
 
-					ZDisplayList* nList = new ZDisplayList(fileData, h & 0x00FFFFFF, GetDListLength(fileData, h & 0x00FFFFFF));
-					nList->scene = scene;
-					nList->parent = parent;
-					otherDLists.push_back(nList);
+	sprintf(line, "gsDPLoadTLUTCmd(%i, %i),", t, ccc);
+}
 
-					i++;
-				}
-			}
-			break;
-			/*case F3DZEXOpcode::G_BRANCH_Z:
-			{
-				uint8_t h = (data & 0xFFFFFFFF);
+void ZDisplayList::Opcode_G_ENDDL(uint64_t data, int i, std::string prefix, char* line)
+{
+	sprintf(line, "gsSPEndDisplayList(),");
 
-				sprintf(line, "gsSPBranchLessZraw(%i, %i, %i),", h);
-			}
-				break;*/
-			case F3DZEXOpcode::G_MTX:
-			{
-				// TODO: FINISH THIS
-				uint32_t pp = (data & 0x000000FF00000000) >> 32;
-				uint32_t mm = (data & 0x00000000FFFFFFFF);
-				std::string matrixRef = "";
+	if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
+		printf("TextureGenCheck G_ENDDL\n");
 
-				if (Globals::Instance->symbolMap.find(mm) != Globals::Instance->symbolMap.end())
-					matrixRef = StringHelper::Sprintf("&%s", Globals::Instance->symbolMap[mm].c_str());
-				else
-					matrixRef = StringHelper::Sprintf("0x%08X", mm);
+	TextureGenCheck(prefix);
+}
 
-				sprintf(line, "gsSPMatrix(%s, 0x%02X),", matrixRef.c_str(), pp ^ 0x01);
-			}
-			break;
-			default:
-				sprintf(line, "// Opcode 0x%02X unimplemented!", (uint32_t)opcode);
-				break;
-			}
+string ZDisplayList::GetSourceOutputHeader(const std::string& prefix)
+{
+	return "";
+}
+
+string ZDisplayList::GetSourceOutputCode(const std::string& prefix)
+{
+	char line[4096];
+	string sourceOutput = "";
+
+	for (int i = 0; i < instructions.size(); i++)
+	{
+		uint8_t opcode = (uint8_t)(instructions[i] >> 56);
+		uint64_t data = instructions[i];
+		sourceOutput += "    ";
+
+		auto start = chrono::steady_clock::now();
+
+		int optimizationResult = OptimizationChecks(i, sourceOutput, prefix);
+
+		if (optimizationResult != -1)
+		{
+			i += optimizationResult - 1;
+			line[0] = '\0';
+		}
+		else
+		{
+			if (dListType == DListType::F3DZEX)
+				ParseF3DZEX((F3DZEXOpcode)opcode, data, i, prefix, line);
+			else
+				ParseF3DEX((F3DEXOpcode)opcode, data, i, prefix, line);
 		}
 
 		auto end = chrono::steady_clock::now();
diff --git a/ZAPD/ZDisplayList.h b/ZAPD/ZDisplayList.h
index dcfe6bb..06b34a8 100644
--- a/ZAPD/ZDisplayList.h
+++ b/ZAPD/ZDisplayList.h
@@ -9,6 +9,60 @@
 #include <map>
 #include <string>
 
+enum class F3DEXOpcode
+{
+	G_SPNOOP = 0x00,
+	G_MTX = 0x01,
+	G_MOVEMEM = 0x03,
+	G_VTX = 0x04,
+	G_DL = 0x06,
+	G_LOAD_UCODE = 0xAF,
+	G_BRANCH_Z = 0xB0,
+	G_TRI2 = 0xB1,
+	G_MODIFYVTX = 0xB2,
+	G_RDPHALF_2 = 0xB3,
+	G_RDPHALF_1 = 0xB4,
+	G_QUAD = 0xB5,
+	G_CLEARGEOMETRYMODE = 0xB6,
+	G_SETGEOMETRYMODE = 0xB7,
+	G_ENDDL = 0xB8,
+	G_SETOTHERMODE_L = 0xB9,
+	G_SETOTHERMODE_H = 0xBA,
+	G_TEXTURE = 0xBB,
+	G_MOVEWORD = 0xBC,
+	G_POPMTX = 0xBD,
+	G_CULLDL = 0xBE,
+	G_TRI1 = 0xBF,
+	G_NOOP = 0xC0,
+	G_TEXRECT = 0xE4,
+	G_TEXRECTFLIP = 0xE5,
+	G_RDPLOADSYNC = 0xE6,
+	G_RDPPIPESYNC = 0xE7,
+	G_RDPTILESYNC = 0xE8,
+	G_RDPFULLSYNC = 0xE9,
+	G_SETKEYGB = 0xEA,
+	G_SETKEYR = 0xEB,
+	G_SETCONVERT = 0xEC,
+	G_SETSCISSOR = 0xED,
+	G_SETPRIMDEPTH = 0xEE,
+	G_RDPSETOTHERMODE = 0xEF,
+	G_LOADTLUT = 0xF0,
+	G_SETTILESIZE = 0xF2,
+	G_LOADBLOCK = 0xF3,
+	G_LOADTILE = 0xF4,
+	G_SETTILE = 0xF5,
+	G_FILLRECT = 0xF6,
+	G_SETFILLCOLOR = 0xF7,
+	G_SETFOGCOLOR = 0xF8,
+	G_SETBLENDCOLOR = 0xF9,
+	G_SETPRIMCOLOR = 0xFA,
+	G_SETENVCOLOR = 0xFB,
+	G_SETCOMBINE = 0xFC,
+	G_SETTIMG = 0xFD,
+	G_SETZIMG = 0xFE,
+	G_SETCIMG = 0xFF
+};
+
 enum class F3DZEXOpcode
 {
 	G_NOOP = 0x00,
@@ -83,6 +137,12 @@ enum class F3DZEXTexSizes
 	G_IM_SIZ_32b
 };
 
+enum class DListType
+{
+	F3DZEX,
+	F3DEX,
+};
+
 enum class OoTSegments
 {
 	DirectReference = 0,
@@ -223,16 +283,44 @@ protected:
 	static TextureType TexFormatToTexType(F3DZEXTexFormats fmt, F3DZEXTexSizes siz);
 	void ParseRawData();
 
+	void ParseF3DZEX(F3DZEXOpcode opcode, uint64_t data, int i, std::string prefix, char* line);
+	void ParseF3DEX(F3DEXOpcode opcode, uint64_t data, int i, std::string prefix, char* line);
+
 	// Various Instruction Optimizations
 	bool SequenceCheck(std::vector<F3DZEXOpcode> sequence, int startIndex);
 	int OptimizationChecks(int startIndex, std::string& output, std::string prefix);
 	int OptimizationCheck_LoadTextureBlock(int startIndex, std::string& output, std::string prefix);
 	int OptimizationCheck_LoadMultiBlock(int startIndex, std::string& output, std::string prefix);
+
+	// F3DEX Specific Opcode Values
+	void Opcode_F3DEX_G_SETOTHERMODE_L(uint64_t data, int i, std::string prefix, char* line);
+
+	// Shared Opcodes between F3DZEX and F3DEX
+	void Opcode_G_DL(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_MODIFYVTX(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_CULLDL(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_TRI1(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_TRI2(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_MTX(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_VTX(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_TEXTURE(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_SETTIMG(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_SETTILE(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_SETTILESIZE(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_LOADBLOCK(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_SETCOMBINE(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_SETPRIMCOLOR(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_SETOTHERMODE_L(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_SETOTHERMODE_H(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_LOADTLUT(uint64_t data, int i, std::string prefix, char* line);
+	void Opcode_G_ENDDL(uint64_t data, int i, std::string prefix, char* line);
 public:
 	std::string sceneSegName;
 	ZRoom* scene;
 	std::vector<uint64_t> instructions;
 
+	DListType dListType;
+
 	//int dListAddress;
 
 	std::map<uint32_t, std::vector<Vertex>> vertices;
@@ -255,7 +343,7 @@ public:
 
 	void TextureGenCheck(std::string prefix);
 	static bool TextureGenCheck(std::vector<uint8_t> fileData, std::map<uint32_t, ZTexture*>& textures, ZRoom* scene, ZFile* parent, std::string prefix, uint32_t texWidth, uint32_t texHeight, uint32_t texAddr, uint32_t texSeg, F3DZEXTexFormats texFmt, F3DZEXTexSizes texSiz, bool texLoaded, bool texIsPalette);
-	static int GetDListLength(std::vector<uint8_t> rawData, int rawDataIndex);
+	static int GetDListLength(std::vector<uint8_t> rawData, int rawDataIndex, DListType dListType);
 
 	std::vector<uint8_t> GetRawData();
 	int GetRawDataSize() override;
diff --git a/ZAPD/ZFile.cpp b/ZAPD/ZFile.cpp
index aaee5b6..55a5066 100644
--- a/ZAPD/ZFile.cpp
+++ b/ZAPD/ZFile.cpp
@@ -70,6 +70,24 @@ void ZFile::ParseXML(ZFileMode mode, XMLElement* reader, std::string filename, b
 
 	int segment = -1;
 
+	// TODO: This should be a variable on the ZFile, but it is a large change in order to force all ZResource types to have a parent ZFile.
+	const char* gameStr = reader->Attribute("Game");
+	if (reader->Attribute("Game") != nullptr)
+	{
+		if (string(gameStr) == "MM")
+		{
+			Globals::Instance->game = ZGame::MM_RETAIL;
+		}
+		else if (string(gameStr) == "SW97" || string(gameStr) == "OOTSW97")
+		{
+			Globals::Instance->game = ZGame::OOT_SW97;
+		}
+		else
+		{
+			// TODO: Error here.
+		}
+	}
+
 	if (reader->Attribute("BaseAddress") != NULL)
 		baseAddress = (uint32_t)strtoul(StringHelper::Split(reader->Attribute("BaseAddress"), "0x")[1].c_str(), NULL, 16);
 
@@ -144,7 +162,7 @@ void ZFile::ParseXML(ZFileMode mode, XMLElement* reader, std::string filename, b
 			ZResource* dList = nullptr;
 
 			if (mode == ZFileMode::Extract)
-				dList = ZDisplayList::ExtractFromXML(child, rawData, rawDataIndex, ZDisplayList::GetDListLength(rawData, rawDataIndex), folderName);
+				dList = ZDisplayList::ExtractFromXML(child, rawData, rawDataIndex, ZDisplayList::GetDListLength(rawData, rawDataIndex, Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX), folderName);
 			//else
 				//dList = ZDisplayList::BuildFromXML(child, folderName, mode == ZFileMode::Build);
 			else
@@ -1014,6 +1032,9 @@ void ZFile::ProcessDeclarationText(Declaration* decl)
 
 			if (c == '@' && c2 == 'r')
 			{
+				if (refIndex >= decl->references.size())
+					break;
+
 				Declaration* refDecl = GetDeclarationRanged(decl->references[refIndex]);
 				uint32_t refDeclAddr = GetDeclarationRangedAddress(decl->references[refIndex]);
 
@@ -1021,10 +1042,17 @@ void ZFile::ProcessDeclarationText(Declaration* decl)
 				{
 					if (refDecl->isArray)
 					{
-						int itemSize = refDecl->size / refDecl->arrayItemCnt;
-						int itemIndex = (decl->references[refIndex] - refDeclAddr) / itemSize;
-
-						decl->text.replace(i, 2, StringHelper::Sprintf("&%s[%i]", refDecl->varName.c_str(), itemIndex));
+						if (refDecl->arrayItemCnt != 0)
+						{
+							int itemSize = refDecl->size / refDecl->arrayItemCnt;
+							int itemIndex = (decl->references[refIndex] - refDeclAddr) / itemSize;
+
+							decl->text.replace(i, 2, StringHelper::Sprintf("&%s[%i]", refDecl->varName.c_str(), itemIndex));
+						}
+						else
+						{
+							decl->text.replace(i, 2, StringHelper::Sprintf("ERROR ARRAYITEMCNT = 0"));
+						}
 					}
 					else
 					{
diff --git a/ZAPD/ZFile.h b/ZAPD/ZFile.h
index 89cb02c..ca1c0ca 100644
--- a/ZAPD/ZFile.h
+++ b/ZAPD/ZFile.h
@@ -18,6 +18,13 @@ enum class ZFileMode
 	Invalid
 };
 
+enum class ZGame
+{
+	OOT_RETAIL,
+	OOT_SW97,
+	MM_RETAIL
+};
+
 class ZFile
 {
 public:
diff --git a/ZAPD/ZRoom/ActorList.h b/ZAPD/ZRoom/ActorList.h
index a5c88aa..742adc8 100644
--- a/ZAPD/ZRoom/ActorList.h
+++ b/ZAPD/ZRoom/ActorList.h
@@ -4,475 +4,476 @@
 
 static const std::string ActorList[] =
 {
-	"ACTOR_PLAYER",
-	"ACTOR_UNSET_1",
-	"ACTOR_EN_TEST",
-	"ACTOR_UNSET_3",
-	"ACTOR_EN_GIRLA",
-	"ACTOR_UNSET_5",
-	"ACTOR_UNSET_6",
-	"ACTOR_EN_PART",
-	"ACTOR_EN_LIGHT",
-	"ACTOR_EN_DOOR",
-	"ACTOR_EN_BOX",
-	"ACTOR_BG_DY_YOSEIZO",
-	"ACTOR_BG_HIDAN_FIREWALL",
-	"ACTOR_EN_POH",
-	"ACTOR_EN_OKUTA",
-	"ACTOR_BG_YDAN_SP",
-	"ACTOR_EN_BOM",
-	"ACTOR_EN_WALLMAS",
-	"ACTOR_EN_DODONGO",
-	"ACTOR_EN_FIREFLY",
-	"ACTOR_EN_HORSE",
-	"ACTOR_EN_ITEM00",
-	"ACTOR_EN_ARROW",
-	"ACTOR_UNSET_17",
-	"ACTOR_EN_ELF",
-	"ACTOR_EN_NIW",
-	"ACTOR_UNSET_1A",
-	"ACTOR_EN_TITE",
-	"ACTOR_EN_REEBA",
-	"ACTOR_EN_PEEHAT",
-	"ACTOR_EN_BUTTE",
-	"ACTOR_UNSET_1F",
-	"ACTOR_EN_INSECT",
-	"ACTOR_EN_FISH",
-	"ACTOR_UNSET_22",
-	"ACTOR_EN_HOLL",
-	"ACTOR_EN_SCENE_CHANGE",
-	"ACTOR_EN_ZF",
-	"ACTOR_EN_HATA",
-	"ACTOR_BOSS_DODONGO",
-	"ACTOR_BOSS_GOMA",
-	"ACTOR_EN_ZL1",
-	"ACTOR_EN_VIEWER",
-	"ACTOR_EN_GOMA",
-	"ACTOR_BG_PUSHBOX",
-	"ACTOR_EN_BUBBLE",
-	"ACTOR_DOOR_SHUTTER",
-	"ACTOR_EN_DODOJR",
-	"ACTOR_EN_BDFIRE",
-	"ACTOR_UNSET_31",
-	"ACTOR_EN_BOOM",
-	"ACTOR_EN_TORCH2",
-	"ACTOR_EN_BILI",
-	"ACTOR_EN_TP",
-	"ACTOR_UNSET_36",
-	"ACTOR_EN_ST",
-	"ACTOR_EN_BW",
-	"ACTOR_EN_A_OBJ",
-	"ACTOR_EN_EIYER",
-	"ACTOR_EN_RIVER_SOUND",
-	"ACTOR_EN_HORSE_NORMAL",
-	"ACTOR_EN_OSSAN",
-	"ACTOR_BG_TREEMOUTH",
-	"ACTOR_BG_DODOAGO",
-	"ACTOR_BG_HIDAN_DALM",
-	"ACTOR_BG_HIDAN_HROCK",
-	"ACTOR_EN_HORSE_GANON",
-	"ACTOR_BG_HIDAN_ROCK",
-	"ACTOR_BG_HIDAN_RSEKIZOU",
-	"ACTOR_BG_HIDAN_SEKIZOU",
-	"ACTOR_BG_HIDAN_SIMA",
-	"ACTOR_BG_HIDAN_SYOKU",
-	"ACTOR_EN_XC",
-	"ACTOR_BG_HIDAN_CURTAIN",
-	"ACTOR_BG_SPOT00_HANEBASI",
-	"ACTOR_EN_MB",
-	"ACTOR_EN_BOMBF",
-	"ACTOR_EN_ZL2",
-	"ACTOR_BG_HIDAN_FSLIFT",
-	"ACTOR_EN_OE2",
-	"ACTOR_BG_YDAN_HASI",
-	"ACTOR_BG_YDAN_MARUTA",
-	"ACTOR_BOSS_GANONDROF",
-	"ACTOR_UNSET_53",
-	"ACTOR_EN_AM",
-	"ACTOR_EN_DEKUBABA",
-	"ACTOR_EN_M_FIRE1",
-	"ACTOR_EN_M_THUNDER",
-	"ACTOR_BG_DDAN_JD",
-	"ACTOR_BG_BREAKWALL",
-	"ACTOR_EN_JJ",
-	"ACTOR_EN_HORSE_ZELDA",
-	"ACTOR_BG_DDAN_KD",
-	"ACTOR_DOOR_WARP1",
-	"ACTOR_OBJ_SYOKUDAI",
-	"ACTOR_ITEM_B_HEART",
-	"ACTOR_EN_DEKUNUTS",
-	"ACTOR_BG_MENKURI_KAITEN",
-	"ACTOR_BG_MENKURI_EYE",
-	"ACTOR_EN_VALI",
-	"ACTOR_BG_MIZU_MOVEBG",
-	"ACTOR_BG_MIZU_WATER",
-	"ACTOR_ARMS_HOOK",
-	"ACTOR_EN_FHG",
-	"ACTOR_BG_MORI_HINERI",
-	"ACTOR_EN_BB",
-	"ACTOR_BG_TOKI_HIKARI",
-	"ACTOR_EN_YUKABYUN",
-	"ACTOR_BG_TOKI_SWD",
-	"ACTOR_EN_FHG_FIRE",
-	"ACTOR_BG_MJIN",
-	"ACTOR_BG_HIDAN_KOUSI",
-	"ACTOR_DOOR_TOKI",
-	"ACTOR_BG_HIDAN_HAMSTEP",
-	"ACTOR_EN_BIRD",
-	"ACTOR_UNSET_73",
-	"ACTOR_UNSET_74",
-	"ACTOR_UNSET_75",
-	"ACTOR_UNSET_76",
-	"ACTOR_EN_WOOD02",
-	"ACTOR_UNSET_78",
-	"ACTOR_UNSET_79",
-	"ACTOR_UNSET_7A",
-	"ACTOR_UNSET_7B",
-	"ACTOR_EN_LIGHTBOX",
-	"ACTOR_EN_PU_BOX",
-	"ACTOR_UNSET_7E",
-	"ACTOR_UNSET_7F",
-	"ACTOR_EN_TRAP",
-	"ACTOR_EN_AROW_TRAP",
-	"ACTOR_EN_VASE",
-	"ACTOR_UNSET_83",
-	"ACTOR_EN_TA",
-	"ACTOR_EN_TK",
-	"ACTOR_BG_MORI_BIGST",
-	"ACTOR_BG_MORI_ELEVATOR",
-	"ACTOR_BG_MORI_KAITENKABE",
-	"ACTOR_BG_MORI_RAKKATENJO",
-	"ACTOR_EN_VM",
-	"ACTOR_DEMO_EFFECT",
-	"ACTOR_DEMO_KANKYO",
-	"ACTOR_BG_HIDAN_FWBIG",
-	"ACTOR_EN_FLOORMAS",
-	"ACTOR_EN_HEISHI1",
-	"ACTOR_EN_RD",
-	"ACTOR_EN_PO_SISTERS",
-	"ACTOR_BG_HEAVY_BLOCK",
-	"ACTOR_BG_PO_EVENT",
-	"ACTOR_OBJ_MURE",
-	"ACTOR_EN_SW",
-	"ACTOR_BOSS_FD",
-	"ACTOR_OBJECT_KANKYO",
-	"ACTOR_EN_DU",
-	"ACTOR_EN_FD",
-	"ACTOR_EN_HORSE_LINK_CHILD",
-	"ACTOR_DOOR_ANA",
-	"ACTOR_BG_SPOT02_OBJECTS",
-	"ACTOR_BG_HAKA",
-	"ACTOR_MAGIC_WIND",
-	"ACTOR_MAGIC_FIRE",
-	"ACTOR_UNSET_A0",
-	"ACTOR_EN_RU1",
-	"ACTOR_BOSS_FD2",
-	"ACTOR_EN_FD_FIRE",
-	"ACTOR_EN_DH",
-	"ACTOR_EN_DHA",
-	"ACTOR_EN_RL",
-	"ACTOR_EN_ENCOUNT1",
-	"ACTOR_DEMO_DU",
-	"ACTOR_DEMO_IM",
-	"ACTOR_DEMO_TRE_LGT",
-	"ACTOR_EN_FW",
-	"ACTOR_BG_VB_SIMA",
-	"ACTOR_EN_VB_BALL",
-	"ACTOR_BG_HAKA_MEGANE",
-	"ACTOR_BG_HAKA_MEGANEBG",
-	"ACTOR_BG_HAKA_SHIP",
-	"ACTOR_BG_HAKA_SGAMI",
-	"ACTOR_UNSET_B2",
-	"ACTOR_EN_HEISHI2",
-	"ACTOR_EN_ENCOUNT2",
-	"ACTOR_EN_FIRE_ROCK",
-	"ACTOR_EN_BROB",
-	"ACTOR_MIR_RAY",
-	"ACTOR_BG_SPOT09_OBJ",
-	"ACTOR_BG_SPOT18_OBJ",
-	"ACTOR_BOSS_VA",
-	"ACTOR_BG_HAKA_TUBO",
-	"ACTOR_BG_HAKA_TRAP",
-	"ACTOR_BG_HAKA_HUTA",
-	"ACTOR_BG_HAKA_ZOU",
-	"ACTOR_BG_SPOT17_FUNEN",
-	"ACTOR_EN_SYATEKI_ITM",
-	"ACTOR_EN_SYATEKI_MAN",
-	"ACTOR_EN_TANA",
-	"ACTOR_EN_NB",
-	"ACTOR_BOSS_MO",
-	"ACTOR_EN_SB",
-	"ACTOR_EN_BIGOKUTA",
-	"ACTOR_EN_KAREBABA",
-	"ACTOR_BG_BDAN_OBJECTS",
-	"ACTOR_DEMO_SA",
-	"ACTOR_DEMO_GO",
-	"ACTOR_EN_IN",
-	"ACTOR_EN_TR",
-	"ACTOR_BG_SPOT16_BOMBSTONE",
-	"ACTOR_UNSET_CE",
-	"ACTOR_BG_HIDAN_KOWARERUKABE",
-	"ACTOR_BG_BOMBWALL",
-	"ACTOR_BG_SPOT08_ICEBLOCK",
-	"ACTOR_EN_RU2",
-	"ACTOR_OBJ_DEKUJR",
-	"ACTOR_BG_MIZU_UZU",
-	"ACTOR_BG_SPOT06_OBJECTS",
-	"ACTOR_BG_ICE_OBJECTS",
-	"ACTOR_BG_HAKA_WATER",
-	"ACTOR_UNSET_D8",
-	"ACTOR_EN_MA2",
-	"ACTOR_EN_BOM_CHU",
-	"ACTOR_EN_HORSE_GAME_CHECK",
-	"ACTOR_BOSS_TW",
-	"ACTOR_EN_RR",
-	"ACTOR_EN_BA",
-	"ACTOR_EN_BX",
-	"ACTOR_EN_ANUBICE",
-	"ACTOR_EN_ANUBICE_FIRE",
-	"ACTOR_BG_MORI_HASHIGO",
-	"ACTOR_BG_MORI_HASHIRA4",
-	"ACTOR_BG_MORI_IDOMIZU",
-	"ACTOR_BG_SPOT16_DOUGHNUT",
-	"ACTOR_BG_BDAN_SWITCH",
-	"ACTOR_EN_MA1",
-	"ACTOR_BOSS_GANON",
-	"ACTOR_BOSS_SST",
-	"ACTOR_UNSET_EA",
-	"ACTOR_UNSET_EB",
-	"ACTOR_EN_NY",
-	"ACTOR_EN_FR",
-	"ACTOR_ITEM_SHIELD",
-	"ACTOR_BG_ICE_SHELTER",
-	"ACTOR_EN_ICE_HONO",
-	"ACTOR_ITEM_OCARINA",
-	"ACTOR_UNSET_F2",
-	"ACTOR_UNSET_F3",
-	"ACTOR_MAGIC_DARK",
-	"ACTOR_DEMO_6K",
-	"ACTOR_EN_ANUBICE_TAG",
-	"ACTOR_BG_HAKA_GATE",
-	"ACTOR_BG_SPOT15_SAKU",
-	"ACTOR_BG_JYA_GOROIWA",
-	"ACTOR_BG_JYA_ZURERUKABE",
-	"ACTOR_UNSET_FB",
-	"ACTOR_BG_JYA_COBRA",
-	"ACTOR_BG_JYA_KANAAMI",
-	"ACTOR_FISHING",
-	"ACTOR_OBJ_OSHIHIKI",
-	"ACTOR_BG_GATE_SHUTTER",
-	"ACTOR_EFF_DUST",
-	"ACTOR_BG_SPOT01_FUSYA",
-	"ACTOR_BG_SPOT01_IDOHASHIRA",
-	"ACTOR_BG_SPOT01_IDOMIZU",
-	"ACTOR_BG_PO_SYOKUDAI",
-	"ACTOR_BG_GANON_OTYUKA",
-	"ACTOR_BG_SPOT15_RRBOX",
-	"ACTOR_BG_UMAJUMP",
-	"ACTOR_UNSET_0109",
-	"ACTOR_ARROW_FIRE",
-	"ACTOR_ARROW_ICE",
-	"ACTOR_ARROW_LIGHT",
-	"ACTOR_UNSET_010D",
-	"ACTOR_UNSET_010E",
-	"ACTOR_ITEM_ETCETERA",
-	"ACTOR_OBJ_KIBAKO",
-	"ACTOR_OBJ_TSUBO",
-	"ACTOR_EN_WONDER_ITEM",
-	"ACTOR_EN_IK",
-	"ACTOR_DEMO_IK",
-	"ACTOR_EN_SKJ",
-	"ACTOR_EN_SKJNEEDLE",
-	"ACTOR_EN_G_SWITCH",
-	"ACTOR_DEMO_EXT",
-	"ACTOR_DEMO_SHD",
-	"ACTOR_EN_DNS",
-	"ACTOR_ELF_MSG",
-	"ACTOR_EN_HONOTRAP",
-	"ACTOR_EN_TUBO_TRAP",
-	"ACTOR_OBJ_ICE_POLY",
-	"ACTOR_BG_SPOT03_TAKI",
-	"ACTOR_BG_SPOT07_TAKI",
-	"ACTOR_EN_FZ",
-	"ACTOR_EN_PO_RELAY",
-	"ACTOR_BG_RELAY_OBJECTS",
-	"ACTOR_EN_DIVING_GAME",
-	"ACTOR_EN_KUSA",
-	"ACTOR_OBJ_BEAN",
-	"ACTOR_OBJ_BOMBIWA",
-	"ACTOR_UNSET_0128",
-	"ACTOR_UNSET_0129",
-	"ACTOR_OBJ_SWITCH",
-	"ACTOR_OBJ_ELEVATOR",
-	"ACTOR_OBJ_LIFT",
-	"ACTOR_OBJ_HSBLOCK",
-	"ACTOR_EN_OKARINA_TAG",
-	"ACTOR_EN_YABUSAME_MARK",
-	"ACTOR_EN_GOROIWA",
-	"ACTOR_EN_EX_RUPPY",
-	"ACTOR_EN_TORYO",
-	"ACTOR_EN_DAIKU",
-	"ACTOR_UNSET_0134",
-	"ACTOR_EN_NWC",
-	"ACTOR_EN_BLKOBJ",
-	"ACTOR_ITEM_INBOX",
-	"ACTOR_EN_GE1",
-	"ACTOR_OBJ_BLOCKSTOP",
-	"ACTOR_EN_SDA",
-	"ACTOR_EN_CLEAR_TAG",
-	"ACTOR_EN_NIW_LADY",
-	"ACTOR_EN_GM",
-	"ACTOR_EN_MS",
-	"ACTOR_EN_HS",
-	"ACTOR_BG_INGATE",
-	"ACTOR_EN_KANBAN",
-	"ACTOR_EN_HEISHI3",
-	"ACTOR_EN_SYATEKI_NIW",
-	"ACTOR_EN_ATTACK_NIW",
-	"ACTOR_BG_SPOT01_IDOSOKO",
-	"ACTOR_EN_SA",
-	"ACTOR_EN_WONDER_TALK",
-	"ACTOR_BG_GJYO_BRIDGE",
-	"ACTOR_EN_DS",
-	"ACTOR_EN_MK",
-	"ACTOR_EN_BOM_BOWL_MAN",
-	"ACTOR_EN_BOM_BOWL_PIT",
-	"ACTOR_EN_OWL",
-	"ACTOR_EN_ISHI",
-	"ACTOR_OBJ_HANA",
-	"ACTOR_OBJ_LIGHTSWITCH",
-	"ACTOR_OBJ_MURE2",
-	"ACTOR_EN_GO",
-	"ACTOR_EN_FU",
-	"ACTOR_UNSET_0154",
-	"ACTOR_EN_CHANGER",
-	"ACTOR_BG_JYA_MEGAMI",
-	"ACTOR_BG_JYA_LIFT",
-	"ACTOR_BG_JYA_BIGMIRROR",
-	"ACTOR_BG_JYA_BOMBCHUIWA",
-	"ACTOR_BG_JYA_AMISHUTTER",
-	"ACTOR_BG_JYA_BOMBIWA",
-	"ACTOR_BG_SPOT18_BASKET",
-	"ACTOR_UNSET_015D",
-	"ACTOR_EN_GANON_ORGAN",
-	"ACTOR_EN_SIOFUKI",
-	"ACTOR_EN_STREAM",
-	"ACTOR_UNSET_0161",
-	"ACTOR_EN_MM",
-	"ACTOR_EN_KO",
-	"ACTOR_EN_KZ",
-	"ACTOR_EN_WEATHER_TAG",
-	"ACTOR_BG_SST_FLOOR",
-	"ACTOR_EN_ANI",
-	"ACTOR_EN_EX_ITEM",
-	"ACTOR_BG_JYA_IRONOBJ",
-	"ACTOR_EN_JS",
-	"ACTOR_EN_JSJUTAN",
-	"ACTOR_EN_CS",
-	"ACTOR_EN_MD",
-	"ACTOR_EN_HY",
-	"ACTOR_EN_GANON_MANT",
-	"ACTOR_EN_OKARINA_EFFECT",
-	"ACTOR_EN_MAG",
-	"ACTOR_DOOR_GERUDO",
-	"ACTOR_ELF_MSG2",
-	"ACTOR_DEMO_GT",
-	"ACTOR_EN_PO_FIELD",
-	"ACTOR_EFC_ERUPC",
-	"ACTOR_BG_ZG",
-	"ACTOR_EN_HEISHI4",
-	"ACTOR_EN_ZL3",
-	"ACTOR_BOSS_GANON2",
-	"ACTOR_EN_KAKASI",
-	"ACTOR_EN_TAKARA_MAN",
-	"ACTOR_OBJ_MAKEOSHIHIKI",
-	"ACTOR_OCEFF_SPOT",
-	"ACTOR_END_TITLE",
-	"ACTOR_UNSET_0180",
-	"ACTOR_EN_TORCH",
-	"ACTOR_DEMO_EC",
-	"ACTOR_SHOT_SUN",
-	"ACTOR_EN_DY_EXTRA",
-	"ACTOR_EN_WONDER_TALK2",
-	"ACTOR_EN_GE2",
-	"ACTOR_OBJ_ROOMTIMER",
-	"ACTOR_EN_SSH",
-	"ACTOR_EN_STH",
-	"ACTOR_OCEFF_WIPE",
-	"ACTOR_OCEFF_STORM",
-	"ACTOR_EN_WEIYER",
-	"ACTOR_BG_SPOT05_SOKO",
-	"ACTOR_BG_JYA_1FLIFT",
-	"ACTOR_BG_JYA_HAHENIRON",
-	"ACTOR_BG_SPOT12_GATE",
-	"ACTOR_BG_SPOT12_SAKU",
-	"ACTOR_EN_HINTNUTS",
-	"ACTOR_EN_NUTSBALL",
-	"ACTOR_BG_SPOT00_BREAK",
-	"ACTOR_EN_SHOPNUTS",
-	"ACTOR_EN_IT",
-	"ACTOR_EN_GELDB",
-	"ACTOR_OCEFF_WIPE2",
-	"ACTOR_OCEFF_WIPE3",
-	"ACTOR_EN_NIW_GIRL",
-	"ACTOR_EN_DOG",
-	"ACTOR_EN_SI",
-	"ACTOR_BG_SPOT01_OBJECTS2",
-	"ACTOR_OBJ_COMB",
-	"ACTOR_BG_SPOT11_BAKUDANKABE",
-	"ACTOR_OBJ_KIBAKO2",
-	"ACTOR_EN_DNT_DEMO",
-	"ACTOR_EN_DNT_JIJI",
-	"ACTOR_EN_DNT_NOMAL",
-	"ACTOR_EN_GUEST",
-	"ACTOR_BG_BOM_GUARD",
-	"ACTOR_EN_HS2",
-	"ACTOR_DEMO_KEKKAI",
-	"ACTOR_BG_SPOT08_BAKUDANKABE",
-	"ACTOR_BG_SPOT17_BAKUDANKABE",
-	"ACTOR_UNSET_01A9",
-	"ACTOR_OBJ_MURE3",
-	"ACTOR_EN_TG",
-	"ACTOR_EN_MU",
-	"ACTOR_EN_GO2",
-	"ACTOR_EN_WF",
-	"ACTOR_EN_SKB",
-	"ACTOR_DEMO_GJ",
-	"ACTOR_DEMO_GEFF",
-	"ACTOR_BG_GND_FIREMEIRO",
-	"ACTOR_BG_GND_DARKMEIRO",
-	"ACTOR_BG_GND_SOULMEIRO",
-	"ACTOR_BG_GND_NISEKABE",
-	"ACTOR_BG_GND_ICEBLOCK",
-	"ACTOR_EN_GB",
-	"ACTOR_EN_GS",
-	"ACTOR_BG_MIZU_BWALL",
-	"ACTOR_BG_MIZU_SHUTTER",
-	"ACTOR_EN_DAIKU_KAKARIKO",
-	"ACTOR_BG_BOWL_WALL",
-	"ACTOR_EN_WALL_TUBO",
-	"ACTOR_EN_PO_DESERT",
-	"ACTOR_EN_CROW",
-	"ACTOR_DOOR_KILLER",
-	"ACTOR_BG_SPOT11_OASIS",
-	"ACTOR_BG_SPOT18_FUTA",
-	"ACTOR_BG_SPOT18_SHUTTER",
-	"ACTOR_EN_MA3",
-	"ACTOR_EN_COW",
-	"ACTOR_BG_ICE_TURARA",
-	"ACTOR_BG_ICE_SHUTTER",
-	"ACTOR_EN_KAKASI2",
-	"ACTOR_EN_KAKASI3",
-	"ACTOR_OCEFF_WIPE4",
-	"ACTOR_EN_EG",
-	"ACTOR_BG_MENKURI_NISEKABE",
-	"ACTOR_EN_ZO",
-	"ACTOR_OBJ_MAKEKINSUTA",
-	"ACTOR_EN_GE3",
-	"ACTOR_OBJ_TIMEBLOCK",
-	"ACTOR_OBJ_HAMISHI",
-	"ACTOR_EN_ZL4",
-	"ACTOR_EN_MM2",
-	"ACTOR_BG_JYA_BLOCK",
-	"ACTOR_OBJ_WARP2BLOCK",
+    /* 0x0000 */ "ACTOR_PLAYER",
+    /* 0x0001 */ "ACTOR_UNSET_1",
+    /* 0x0002 */ "ACTOR_EN_TEST",
+    /* 0x0003 */ "ACTOR_UNSET_3",
+    /* 0x0004 */ "ACTOR_EN_GIRLA",
+    /* 0x0005 */ "ACTOR_UNSET_5",
+    /* 0x0006 */ "ACTOR_UNSET_6",
+    /* 0x0007 */ "ACTOR_EN_PART",
+    /* 0x0008 */ "ACTOR_EN_LIGHT",
+    /* 0x0009 */ "ACTOR_EN_DOOR",
+    /* 0x000A */ "ACTOR_EN_BOX", // Treasure Chest
+    /* 0x000B */ "ACTOR_BG_DY_YOSEIZO",
+    /* 0x000C */ "ACTOR_BG_HIDAN_FIREWALL",
+    /* 0x000D */ "ACTOR_EN_POH",
+    /* 0x000E */ "ACTOR_EN_OKUTA",
+    /* 0x000F */ "ACTOR_BG_YDAN_SP",
+    /* 0x0010 */ "ACTOR_EN_BOM",
+    /* 0x0011 */ "ACTOR_EN_WALLMAS",
+    /* 0x0012 */ "ACTOR_EN_DODONGO",
+    /* 0x0013 */ "ACTOR_EN_FIREFLY",
+    /* 0x0014 */ "ACTOR_EN_HORSE",
+    /* 0x0015 */ "ACTOR_EN_ITEM00",
+    /* 0x0016 */ "ACTOR_EN_ARROW",
+    /* 0x0017 */ "ACTOR_UNSET_17",
+    /* 0x0018 */ "ACTOR_EN_ELF",
+    /* 0x0019 */ "ACTOR_EN_NIW",
+    /* 0x001A */ "ACTOR_UNSET_1A",
+    /* 0x001B */ "ACTOR_EN_TITE",
+    /* 0x001C */ "ACTOR_EN_REEBA",
+    /* 0x001D */ "ACTOR_EN_PEEHAT",
+    /* 0x001E */ "ACTOR_EN_BUTTE",
+    /* 0x001F */ "ACTOR_UNSET_1F",
+    /* 0x0020 */ "ACTOR_EN_INSECT",
+    /* 0x0021 */ "ACTOR_EN_FISH",
+    /* 0x0022 */ "ACTOR_UNSET_22",
+    /* 0x0023 */ "ACTOR_EN_HOLL",
+    /* 0x0024 */ "ACTOR_EN_SCENE_CHANGE",
+    /* 0x0025 */ "ACTOR_EN_ZF",
+    /* 0x0026 */ "ACTOR_EN_HATA",
+    /* 0x0027 */ "ACTOR_BOSS_DODONGO",
+    /* 0x0028 */ "ACTOR_BOSS_GOMA",
+    /* 0x0029 */ "ACTOR_EN_ZL1",
+    /* 0x002A */ "ACTOR_EN_VIEWER",
+    /* 0x002B */ "ACTOR_EN_GOMA",
+    /* 0x002C */ "ACTOR_BG_PUSHBOX",
+    /* 0x002D */ "ACTOR_EN_BUBBLE",
+    /* 0x002E */ "ACTOR_DOOR_SHUTTER",
+    /* 0x002F */ "ACTOR_EN_DODOJR",
+    /* 0x0030 */ "ACTOR_EN_BDFIRE",
+    /* 0x0031 */ "ACTOR_UNSET_31",
+    /* 0x0032 */ "ACTOR_EN_BOOM",
+    /* 0x0033 */ "ACTOR_EN_TORCH2",
+    /* 0x0034 */ "ACTOR_EN_BILI",
+    /* 0x0035 */ "ACTOR_EN_TP",
+    /* 0x0036 */ "ACTOR_UNSET_36",
+    /* 0x0037 */ "ACTOR_EN_ST",
+    /* 0x0038 */ "ACTOR_EN_BW",
+    /* 0x0039 */ "ACTOR_EN_A_OBJ",
+    /* 0x003A */ "ACTOR_EN_EIYER",
+    /* 0x003B */ "ACTOR_EN_RIVER_SOUND",
+    /* 0x003C */ "ACTOR_EN_HORSE_NORMAL",
+    /* 0x003D */ "ACTOR_EN_OSSAN",
+    /* 0x003E */ "ACTOR_BG_TREEMOUTH",
+    /* 0x003F */ "ACTOR_BG_DODOAGO",
+    /* 0x0040 */ "ACTOR_BG_HIDAN_DALM",
+    /* 0x0041 */ "ACTOR_BG_HIDAN_HROCK",
+    /* 0x0042 */ "ACTOR_EN_HORSE_GANON",
+    /* 0x0043 */ "ACTOR_BG_HIDAN_ROCK",
+    /* 0x0044 */ "ACTOR_BG_HIDAN_RSEKIZOU",
+    /* 0x0045 */ "ACTOR_BG_HIDAN_SEKIZOU",
+    /* 0x0046 */ "ACTOR_BG_HIDAN_SIMA",
+    /* 0x0047 */ "ACTOR_BG_HIDAN_SYOKU",
+    /* 0x0048 */ "ACTOR_EN_XC",
+    /* 0x0049 */ "ACTOR_BG_HIDAN_CURTAIN",
+    /* 0x004A */ "ACTOR_BG_SPOT00_HANEBASI",
+    /* 0x004B */ "ACTOR_EN_MB",
+    /* 0x004C */ "ACTOR_EN_BOMBF",
+    /* 0x004D */ "ACTOR_EN_ZL2",
+    /* 0x004E */ "ACTOR_BG_HIDAN_FSLIFT",
+    /* 0x004F */ "ACTOR_EN_OE2",
+    /* 0x0050 */ "ACTOR_BG_YDAN_HASI",
+    /* 0x0051 */ "ACTOR_BG_YDAN_MARUTA",
+    /* 0x0052 */ "ACTOR_BOSS_GANONDROF",
+    /* 0x0053 */ "ACTOR_UNSET_53",
+    /* 0x0054 */ "ACTOR_EN_AM",
+    /* 0x0055 */ "ACTOR_EN_DEKUBABA",
+    /* 0x0056 */ "ACTOR_EN_M_FIRE1",
+    /* 0x0057 */ "ACTOR_EN_M_THUNDER",
+    /* 0x0058 */ "ACTOR_BG_DDAN_JD",
+    /* 0x0059 */ "ACTOR_BG_BREAKWALL",
+    /* 0x005A */ "ACTOR_EN_JJ",
+    /* 0x005B */ "ACTOR_EN_HORSE_ZELDA",
+    /* 0x005C */ "ACTOR_BG_DDAN_KD",
+    /* 0x005D */ "ACTOR_DOOR_WARP1",
+    /* 0x005E */ "ACTOR_OBJ_SYOKUDAI",
+    /* 0x005F */ "ACTOR_ITEM_B_HEART",
+    /* 0x0060 */ "ACTOR_EN_DEKUNUTS",
+    /* 0x0061 */ "ACTOR_BG_MENKURI_KAITEN",
+    /* 0x0062 */ "ACTOR_BG_MENKURI_EYE",
+    /* 0x0063 */ "ACTOR_EN_VALI",
+    /* 0x0064 */ "ACTOR_BG_MIZU_MOVEBG",
+    /* 0x0065 */ "ACTOR_BG_MIZU_WATER",
+    /* 0x0066 */ "ACTOR_ARMS_HOOK",
+    /* 0x0067 */ "ACTOR_EN_FHG",
+    /* 0x0068 */ "ACTOR_BG_MORI_HINERI",
+    /* 0x0069 */ "ACTOR_EN_BB",
+    /* 0x006A */ "ACTOR_BG_TOKI_HIKARI",
+    /* 0x006B */ "ACTOR_EN_YUKABYUN",
+    /* 0x006C */ "ACTOR_BG_TOKI_SWD",
+    /* 0x006D */ "ACTOR_EN_FHG_FIRE",
+    /* 0x006E */ "ACTOR_BG_MJIN",
+    /* 0x006F */ "ACTOR_BG_HIDAN_KOUSI",
+    /* 0x0070 */ "ACTOR_DOOR_TOKI",
+    /* 0x0071 */ "ACTOR_BG_HIDAN_HAMSTEP",
+    /* 0x0072 */ "ACTOR_EN_BIRD",
+    /* 0x0073 */ "ACTOR_UNSET_73",
+    /* 0x0074 */ "ACTOR_UNSET_74",
+    /* 0x0075 */ "ACTOR_UNSET_75",
+    /* 0x0076 */ "ACTOR_UNSET_76",
+    /* 0x0077 */ "ACTOR_EN_WOOD02",
+    /* 0x0078 */ "ACTOR_UNSET_78",
+    /* 0x0079 */ "ACTOR_UNSET_79",
+    /* 0x007A */ "ACTOR_UNSET_7A",
+    /* 0x007B */ "ACTOR_UNSET_7B",
+    /* 0x007C */ "ACTOR_EN_LIGHTBOX",
+    /* 0x007D */ "ACTOR_EN_PU_BOX",
+    /* 0x007E */ "ACTOR_UNSET_7E",
+    /* 0x007F */ "ACTOR_UNSET_7F",
+    /* 0x0080 */ "ACTOR_EN_TRAP",
+    /* 0x0081 */ "ACTOR_EN_AROW_TRAP",
+    /* 0x0082 */ "ACTOR_EN_VASE",
+    /* 0x0083 */ "ACTOR_UNSET_83",
+    /* 0x0084 */ "ACTOR_EN_TA",
+    /* 0x0085 */ "ACTOR_EN_TK",
+    /* 0x0086 */ "ACTOR_BG_MORI_BIGST",
+    /* 0x0087 */ "ACTOR_BG_MORI_ELEVATOR",
+    /* 0x0088 */ "ACTOR_BG_MORI_KAITENKABE",
+    /* 0x0089 */ "ACTOR_BG_MORI_RAKKATENJO",
+    /* 0x008A */ "ACTOR_EN_VM",
+    /* 0x008B */ "ACTOR_DEMO_EFFECT",
+    /* 0x008C */ "ACTOR_DEMO_KANKYO",
+    /* 0x008D */ "ACTOR_BG_HIDAN_FWBIG",
+    /* 0x008E */ "ACTOR_EN_FLOORMAS",
+    /* 0x008F */ "ACTOR_EN_HEISHI1",
+    /* 0x0090 */ "ACTOR_EN_RD",
+    /* 0x0091 */ "ACTOR_EN_PO_SISTERS",
+    /* 0x0092 */ "ACTOR_BG_HEAVY_BLOCK",
+    /* 0x0093 */ "ACTOR_BG_PO_EVENT",
+    /* 0x0094 */ "ACTOR_OBJ_MURE",
+    /* 0x0095 */ "ACTOR_EN_SW",
+    /* 0x0096 */ "ACTOR_BOSS_FD",
+    /* 0x0097 */ "ACTOR_OBJECT_KANKYO",
+    /* 0x0098 */ "ACTOR_EN_DU",
+    /* 0x0099 */ "ACTOR_EN_FD",
+    /* 0x009A */ "ACTOR_EN_HORSE_LINK_CHILD",
+    /* 0x009B */ "ACTOR_DOOR_ANA",
+    /* 0x009C */ "ACTOR_BG_SPOT02_OBJECTS",
+    /* 0x009D */ "ACTOR_BG_HAKA",
+    /* 0x009E */ "ACTOR_MAGIC_WIND",
+    /* 0x009F */ "ACTOR_MAGIC_FIRE",
+    /* 0x00A0 */ "ACTOR_UNSET_A0",
+    /* 0x00A1 */ "ACTOR_EN_RU1",
+    /* 0x00A2 */ "ACTOR_BOSS_FD2",
+    /* 0x00A3 */ "ACTOR_EN_FD_FIRE",
+    /* 0x00A4 */ "ACTOR_EN_DH",
+    /* 0x00A5 */ "ACTOR_EN_DHA",
+    /* 0x00A6 */ "ACTOR_EN_RL",
+    /* 0x00A7 */ "ACTOR_EN_ENCOUNT1",
+    /* 0x00A8 */ "ACTOR_DEMO_DU",
+    /* 0x00A9 */ "ACTOR_DEMO_IM",
+    /* 0x00AA */ "ACTOR_DEMO_TRE_LGT",
+    /* 0x00AB */ "ACTOR_EN_FW",
+    /* 0x00AC */ "ACTOR_BG_VB_SIMA",
+    /* 0x00AD */ "ACTOR_EN_VB_BALL",
+    /* 0x00AE */ "ACTOR_BG_HAKA_MEGANE",
+    /* 0x00AF */ "ACTOR_BG_HAKA_MEGANEBG",
+    /* 0x00B0 */ "ACTOR_BG_HAKA_SHIP",
+    /* 0x00B1 */ "ACTOR_BG_HAKA_SGAMI",
+    /* 0x00B2 */ "ACTOR_UNSET_B2",
+    /* 0x00B3 */ "ACTOR_EN_HEISHI2",
+    /* 0x00B4 */ "ACTOR_EN_ENCOUNT2",
+    /* 0x00B5 */ "ACTOR_EN_FIRE_ROCK",
+    /* 0x00B6 */ "ACTOR_EN_BROB",
+    /* 0x00B7 */ "ACTOR_MIR_RAY",
+    /* 0x00B8 */ "ACTOR_BG_SPOT09_OBJ",
+    /* 0x00B9 */ "ACTOR_BG_SPOT18_OBJ",
+    /* 0x00BA */ "ACTOR_BOSS_VA",
+    /* 0x00BB */ "ACTOR_BG_HAKA_TUBO",
+    /* 0x00BC */ "ACTOR_BG_HAKA_TRAP",
+    /* 0x00BD */ "ACTOR_BG_HAKA_HUTA",
+    /* 0x00BE */ "ACTOR_BG_HAKA_ZOU",
+    /* 0x00BF */ "ACTOR_BG_SPOT17_FUNEN",
+    /* 0x00C0 */ "ACTOR_EN_SYATEKI_ITM",
+    /* 0x00C1 */ "ACTOR_EN_SYATEKI_MAN",
+    /* 0x00C2 */ "ACTOR_EN_TANA",
+    /* 0x00C3 */ "ACTOR_EN_NB",
+    /* 0x00C4 */ "ACTOR_BOSS_MO",
+    /* 0x00C5 */ "ACTOR_EN_SB",
+    /* 0x00C6 */ "ACTOR_EN_BIGOKUTA",
+    /* 0x00C7 */ "ACTOR_EN_KAREBABA",
+    /* 0x00C8 */ "ACTOR_BG_BDAN_OBJECTS",
+    /* 0x00C9 */ "ACTOR_DEMO_SA",
+    /* 0x00CA */ "ACTOR_DEMO_GO",
+    /* 0x00CB */ "ACTOR_EN_IN",
+    /* 0x00CC */ "ACTOR_EN_TR",
+    /* 0x00CD */ "ACTOR_BG_SPOT16_BOMBSTONE",
+    /* 0x00CE */ "ACTOR_UNSET_CE",
+    /* 0x00CF */ "ACTOR_BG_HIDAN_KOWARERUKABE",
+    /* 0x00D0 */ "ACTOR_BG_BOMBWALL",
+    /* 0x00D1 */ "ACTOR_BG_SPOT08_ICEBLOCK",
+    /* 0x00D2 */ "ACTOR_EN_RU2",
+    /* 0x00D3 */ "ACTOR_OBJ_DEKUJR",
+    /* 0x00D4 */ "ACTOR_BG_MIZU_UZU",
+    /* 0x00D5 */ "ACTOR_BG_SPOT06_OBJECTS",
+    /* 0x00D6 */ "ACTOR_BG_ICE_OBJECTS",
+    /* 0x00D7 */ "ACTOR_BG_HAKA_WATER",
+    /* 0x00D8 */ "ACTOR_UNSET_D8",
+    /* 0x00D9 */ "ACTOR_EN_MA2",
+    /* 0x00DA */ "ACTOR_EN_BOM_CHU",
+    /* 0x00DB */ "ACTOR_EN_HORSE_GAME_CHECK",
+    /* 0x00DC */ "ACTOR_BOSS_TW",
+    /* 0x00DD */ "ACTOR_EN_RR",
+    /* 0x00DE */ "ACTOR_EN_BA",
+    /* 0x00DF */ "ACTOR_EN_BX",
+    /* 0x00E0 */ "ACTOR_EN_ANUBICE",
+    /* 0x00E1 */ "ACTOR_EN_ANUBICE_FIRE",
+    /* 0x00E2 */ "ACTOR_BG_MORI_HASHIGO",
+    /* 0x00E3 */ "ACTOR_BG_MORI_HASHIRA4",
+    /* 0x00E4 */ "ACTOR_BG_MORI_IDOMIZU",
+    /* 0x00E5 */ "ACTOR_BG_SPOT16_DOUGHNUT",
+    /* 0x00E6 */ "ACTOR_BG_BDAN_SWITCH",
+    /* 0x00E7 */ "ACTOR_EN_MA1",
+    /* 0x00E8 */ "ACTOR_BOSS_GANON",
+    /* 0x00E9 */ "ACTOR_BOSS_SST",
+    /* 0x00EA */ "ACTOR_UNSET_EA",
+    /* 0x00EB */ "ACTOR_UNSET_EB",
+    /* 0x00EC */ "ACTOR_EN_NY",
+    /* 0x00ED */ "ACTOR_EN_FR",
+    /* 0x00EE */ "ACTOR_ITEM_SHIELD",
+    /* 0x00EF */ "ACTOR_BG_ICE_SHELTER",
+    /* 0x00F0 */ "ACTOR_EN_ICE_HONO",
+    /* 0x00F1 */ "ACTOR_ITEM_OCARINA",
+    /* 0x00F2 */ "ACTOR_UNSET_F2",
+    /* 0x00F3 */ "ACTOR_UNSET_F3",
+    /* 0x00F4 */ "ACTOR_MAGIC_DARK",
+    /* 0x00F5 */ "ACTOR_DEMO_6K",
+    /* 0x00F6 */ "ACTOR_EN_ANUBICE_TAG",
+    /* 0x00F7 */ "ACTOR_BG_HAKA_GATE",
+    /* 0x00F8 */ "ACTOR_BG_SPOT15_SAKU",
+    /* 0x00F9 */ "ACTOR_BG_JYA_GOROIWA",
+    /* 0x00FA */ "ACTOR_BG_JYA_ZURERUKABE",
+    /* 0x00FB */ "ACTOR_UNSET_FB",
+    /* 0x00FC */ "ACTOR_BG_JYA_COBRA",
+    /* 0x00FD */ "ACTOR_BG_JYA_KANAAMI",
+    /* 0x00FE */ "ACTOR_FISHING",
+    /* 0x00FF */ "ACTOR_OBJ_OSHIHIKI",
+    /* 0x0100 */ "ACTOR_BG_GATE_SHUTTER",
+    /* 0x0101 */ "ACTOR_EFF_DUST",
+    /* 0x0102 */ "ACTOR_BG_SPOT01_FUSYA",
+    /* 0x0103 */ "ACTOR_BG_SPOT01_IDOHASHIRA",
+    /* 0x0104 */ "ACTOR_BG_SPOT01_IDOMIZU",
+    /* 0x0105 */ "ACTOR_BG_PO_SYOKUDAI",
+    /* 0x0106 */ "ACTOR_BG_GANON_OTYUKA",
+    /* 0x0107 */ "ACTOR_BG_SPOT15_RRBOX",
+    /* 0x0108 */ "ACTOR_BG_UMAJUMP",
+    /* 0x0109 */ "ACTOR_UNSET_109",
+    /* 0x010A */ "ACTOR_ARROW_FIRE",
+    /* 0x010B */ "ACTOR_ARROW_ICE",
+    /* 0x010C */ "ACTOR_ARROW_LIGHT",
+    /* 0x010D */ "ACTOR_UNSET_10D",
+    /* 0x010E */ "ACTOR_UNSET_10E",
+    /* 0x010F */ "ACTOR_ITEM_ETCETERA",
+    /* 0x0110 */ "ACTOR_OBJ_KIBAKO",
+    /* 0x0111 */ "ACTOR_OBJ_TSUBO",
+    /* 0x0112 */ "ACTOR_EN_WONDER_ITEM",
+    /* 0x0113 */ "ACTOR_EN_IK",
+    /* 0x0114 */ "ACTOR_DEMO_IK",
+    /* 0x0115 */ "ACTOR_EN_SKJ",
+    /* 0x0116 */ "ACTOR_EN_SKJNEEDLE",
+    /* 0x0117 */ "ACTOR_EN_G_SWITCH",
+    /* 0x0118 */ "ACTOR_DEMO_EXT",
+    /* 0x0119 */ "ACTOR_DEMO_SHD",
+    /* 0x011A */ "ACTOR_EN_DNS",
+    /* 0x011B */ "ACTOR_ELF_MSG",
+    /* 0x011C */ "ACTOR_EN_HONOTRAP",
+    /* 0x011D */ "ACTOR_EN_TUBO_TRAP",
+    /* 0x011E */ "ACTOR_OBJ_ICE_POLY",
+    /* 0x011F */ "ACTOR_BG_SPOT03_TAKI",
+    /* 0x0120 */ "ACTOR_BG_SPOT07_TAKI",
+    /* 0x0121 */ "ACTOR_EN_FZ",
+    /* 0x0122 */ "ACTOR_EN_PO_RELAY",
+    /* 0x0123 */ "ACTOR_BG_RELAY_OBJECTS",
+    /* 0x0124 */ "ACTOR_EN_DIVING_GAME",
+    /* 0x0125 */ "ACTOR_EN_KUSA",
+    /* 0x0126 */ "ACTOR_OBJ_BEAN",
+    /* 0x0127 */ "ACTOR_OBJ_BOMBIWA",
+    /* 0x0128 */ "ACTOR_UNSET_128",
+    /* 0x0129 */ "ACTOR_UNSET_129",
+    /* 0x012A */ "ACTOR_OBJ_SWITCH",
+    /* 0x012B */ "ACTOR_OBJ_ELEVATOR",
+    /* 0x012C */ "ACTOR_OBJ_LIFT",
+    /* 0x012D */ "ACTOR_OBJ_HSBLOCK",
+    /* 0x012E */ "ACTOR_EN_OKARINA_TAG",
+    /* 0x012F */ "ACTOR_EN_YABUSAME_MARK",
+    /* 0x0130 */ "ACTOR_EN_GOROIWA",
+    /* 0x0131 */ "ACTOR_EN_EX_RUPPY",
+    /* 0x0132 */ "ACTOR_EN_TORYO",
+    /* 0x0133 */ "ACTOR_EN_DAIKU",
+    /* 0x0134 */ "ACTOR_UNSET_134",
+    /* 0x0135 */ "ACTOR_EN_NWC",
+    /* 0x0136 */ "ACTOR_EN_BLKOBJ",
+    /* 0x0137 */ "ACTOR_ITEM_INBOX",
+    /* 0x0138 */ "ACTOR_EN_GE1",
+    /* 0x0139 */ "ACTOR_OBJ_BLOCKSTOP",
+    /* 0x013A */ "ACTOR_EN_SDA",
+    /* 0x013B */ "ACTOR_EN_CLEAR_TAG",
+    /* 0x013C */ "ACTOR_EN_NIW_LADY",
+    /* 0x013D */ "ACTOR_EN_GM",
+    /* 0x013E */ "ACTOR_EN_MS",
+    /* 0x013F */ "ACTOR_EN_HS",
+    /* 0x0140 */ "ACTOR_BG_INGATE",
+    /* 0x0141 */ "ACTOR_EN_KANBAN",
+    /* 0x0142 */ "ACTOR_EN_HEISHI3",
+    /* 0x0143 */ "ACTOR_EN_SYATEKI_NIW",
+    /* 0x0144 */ "ACTOR_EN_ATTACK_NIW",
+    /* 0x0145 */ "ACTOR_BG_SPOT01_IDOSOKO",
+    /* 0x0146 */ "ACTOR_EN_SA",
+    /* 0x0147 */ "ACTOR_EN_WONDER_TALK",
+    /* 0x0148 */ "ACTOR_BG_GJYO_BRIDGE",
+    /* 0x0149 */ "ACTOR_EN_DS",
+    /* 0x014A */ "ACTOR_EN_MK",
+    /* 0x014B */ "ACTOR_EN_BOM_BOWL_MAN",
+    /* 0x014C */ "ACTOR_EN_BOM_BOWL_PIT",
+    /* 0x014D */ "ACTOR_EN_OWL",
+    /* 0x014E */ "ACTOR_EN_ISHI",
+    /* 0x014F */ "ACTOR_OBJ_HANA",
+    /* 0x0150 */ "ACTOR_OBJ_LIGHTSWITCH",
+    /* 0x0151 */ "ACTOR_OBJ_MURE2",
+    /* 0x0152 */ "ACTOR_EN_GO",
+    /* 0x0153 */ "ACTOR_EN_FU",
+    /* 0x0154 */ "ACTOR_UNSET_154",
+    /* 0x0155 */ "ACTOR_EN_CHANGER",
+    /* 0x0156 */ "ACTOR_BG_JYA_MEGAMI",
+    /* 0x0157 */ "ACTOR_BG_JYA_LIFT",
+    /* 0x0158 */ "ACTOR_BG_JYA_BIGMIRROR",
+    /* 0x0159 */ "ACTOR_BG_JYA_BOMBCHUIWA",
+    /* 0x015A */ "ACTOR_BG_JYA_AMISHUTTER",
+    /* 0x015B */ "ACTOR_BG_JYA_BOMBIWA",
+    /* 0x015C */ "ACTOR_BG_SPOT18_BASKET",
+    /* 0x015D */ "ACTOR_UNSET_15D",
+    /* 0x015E */ "ACTOR_EN_GANON_ORGAN",
+    /* 0x015F */ "ACTOR_EN_SIOFUKI",
+    /* 0x0160 */ "ACTOR_EN_STREAM",
+    /* 0x0161 */ "ACTOR_UNSET_161",
+    /* 0x0162 */ "ACTOR_EN_MM",
+    /* 0x0163 */ "ACTOR_EN_KO",
+    /* 0x0164 */ "ACTOR_EN_KZ",
+    /* 0x0165 */ "ACTOR_EN_WEATHER_TAG",
+    /* 0x0166 */ "ACTOR_BG_SST_FLOOR",
+    /* 0x0167 */ "ACTOR_EN_ANI",
+    /* 0x0168 */ "ACTOR_EN_EX_ITEM",
+    /* 0x0169 */ "ACTOR_BG_JYA_IRONOBJ",
+    /* 0x016A */ "ACTOR_EN_JS",
+    /* 0x016B */ "ACTOR_EN_JSJUTAN",
+    /* 0x016C */ "ACTOR_EN_CS",
+    /* 0x016D */ "ACTOR_EN_MD",
+    /* 0x016E */ "ACTOR_EN_HY",
+    /* 0x016F */ "ACTOR_EN_GANON_MANT",
+    /* 0x0170 */ "ACTOR_EN_OKARINA_EFFECT",
+    /* 0x0171 */ "ACTOR_EN_MAG",
+    /* 0x0172 */ "ACTOR_DOOR_GERUDO",
+    /* 0x0173 */ "ACTOR_ELF_MSG2",
+    /* 0x0174 */ "ACTOR_DEMO_GT",
+    /* 0x0175 */ "ACTOR_EN_PO_FIELD",
+    /* 0x0176 */ "ACTOR_EFC_ERUPC",
+    /* 0x0177 */ "ACTOR_BG_ZG",
+    /* 0x0178 */ "ACTOR_EN_HEISHI4",
+    /* 0x0179 */ "ACTOR_EN_ZL3",
+    /* 0x017A */ "ACTOR_BOSS_GANON2",
+    /* 0x017B */ "ACTOR_EN_KAKASI",
+    /* 0x017C */ "ACTOR_EN_TAKARA_MAN",
+    /* 0x017D */ "ACTOR_OBJ_MAKEOSHIHIKI",
+    /* 0x017E */ "ACTOR_OCEFF_SPOT",
+    /* 0x017F */ "ACTOR_END_TITLE",
+    /* 0x0180 */ "ACTOR_UNSET_180",
+    /* 0x0181 */ "ACTOR_EN_TORCH",
+    /* 0x0182 */ "ACTOR_DEMO_EC",
+    /* 0x0183 */ "ACTOR_SHOT_SUN",
+    /* 0x0184 */ "ACTOR_EN_DY_EXTRA",
+    /* 0x0185 */ "ACTOR_EN_WONDER_TALK2",
+    /* 0x0186 */ "ACTOR_EN_GE2",
+    /* 0x0187 */ "ACTOR_OBJ_ROOMTIMER",
+    /* 0x0188 */ "ACTOR_EN_SSH",
+    /* 0x0189 */ "ACTOR_EN_STH",
+    /* 0x018A */ "ACTOR_OCEFF_WIPE",
+    /* 0x018B */ "ACTOR_OCEFF_STORM",
+    /* 0x018C */ "ACTOR_EN_WEIYER",
+    /* 0x018D */ "ACTOR_BG_SPOT05_SOKO",
+    /* 0x018E */ "ACTOR_BG_JYA_1FLIFT",
+    /* 0x018F */ "ACTOR_BG_JYA_HAHENIRON",
+    /* 0x0190 */ "ACTOR_BG_SPOT12_GATE",
+    /* 0x0191 */ "ACTOR_BG_SPOT12_SAKU",
+    /* 0x0192 */ "ACTOR_EN_HINTNUTS",
+    /* 0x0193 */ "ACTOR_EN_NUTSBALL",
+    /* 0x0194 */ "ACTOR_BG_SPOT00_BREAK",
+    /* 0x0195 */ "ACTOR_EN_SHOPNUTS",
+    /* 0x0196 */ "ACTOR_EN_IT",
+    /* 0x0197 */ "ACTOR_EN_GELDB",
+    /* 0x0198 */ "ACTOR_OCEFF_WIPE2",
+    /* 0x0199 */ "ACTOR_OCEFF_WIPE3",
+    /* 0x019A */ "ACTOR_EN_NIW_GIRL",
+    /* 0x019B */ "ACTOR_EN_DOG",
+    /* 0x019C */ "ACTOR_EN_SI",
+    /* 0x019D */ "ACTOR_BG_SPOT01_OBJECTS2",
+    /* 0x019E */ "ACTOR_OBJ_COMB",
+    /* 0x019F */ "ACTOR_BG_SPOT11_BAKUDANKABE",
+    /* 0x01A0 */ "ACTOR_OBJ_KIBAKO2",
+    /* 0x01A1 */ "ACTOR_EN_DNT_DEMO",
+    /* 0x01A2 */ "ACTOR_EN_DNT_JIJI",
+    /* 0x01A3 */ "ACTOR_EN_DNT_NOMAL",
+    /* 0x01A4 */ "ACTOR_EN_GUEST",
+    /* 0x01A5 */ "ACTOR_BG_BOM_GUARD",
+    /* 0x01A6 */ "ACTOR_EN_HS2",
+    /* 0x01A7 */ "ACTOR_DEMO_KEKKAI",
+    /* 0x01A8 */ "ACTOR_BG_SPOT08_BAKUDANKABE",
+    /* 0x01A9 */ "ACTOR_BG_SPOT17_BAKUDANKABE",
+    /* 0x01AA */ "ACTOR_UNSET_1AA",
+    /* 0x01AB */ "ACTOR_OBJ_MURE3",
+    /* 0x01AC */ "ACTOR_EN_TG",
+    /* 0x01AD */ "ACTOR_EN_MU",
+    /* 0x01AE */ "ACTOR_EN_GO2",
+    /* 0x01AF */ "ACTOR_EN_WF",
+    /* 0x01B0 */ "ACTOR_EN_SKB",
+    /* 0x01B1 */ "ACTOR_DEMO_GJ",
+    /* 0x01B2 */ "ACTOR_DEMO_GEFF",
+    /* 0x01B3 */ "ACTOR_BG_GND_FIREMEIRO",
+    /* 0x01B4 */ "ACTOR_BG_GND_DARKMEIRO",
+    /* 0x01B5 */ "ACTOR_BG_GND_SOULMEIRO",
+    /* 0x01B6 */ "ACTOR_BG_GND_NISEKABE",
+    /* 0x01B7 */ "ACTOR_BG_GND_ICEBLOCK",
+    /* 0x01B8 */ "ACTOR_EN_GB",
+    /* 0x01B9 */ "ACTOR_EN_GS",
+    /* 0x01BA */ "ACTOR_BG_MIZU_BWALL",
+    /* 0x01BB */ "ACTOR_BG_MIZU_SHUTTER",
+    /* 0x01BC */ "ACTOR_EN_DAIKU_KAKARIKO",
+    /* 0x01BD */ "ACTOR_BG_BOWL_WALL",
+    /* 0x01BE */ "ACTOR_EN_WALL_TUBO",
+    /* 0x01BF */ "ACTOR_EN_PO_DESERT",
+    /* 0x01C0 */ "ACTOR_EN_CROW",
+    /* 0x01C1 */ "ACTOR_DOOR_KILLER",
+    /* 0x01C2 */ "ACTOR_BG_SPOT11_OASIS",
+    /* 0x01C3 */ "ACTOR_BG_SPOT18_FUTA",
+    /* 0x01C4 */ "ACTOR_BG_SPOT18_SHUTTER",
+    /* 0x01C5 */ "ACTOR_EN_MA3",
+    /* 0x01C6 */ "ACTOR_EN_COW",
+    /* 0x01C7 */ "ACTOR_BG_ICE_TURARA",
+    /* 0x01C8 */ "ACTOR_BG_ICE_SHUTTER",
+    /* 0x01C9 */ "ACTOR_EN_KAKASI2",
+    /* 0x01CA */ "ACTOR_EN_KAKASI3",
+    /* 0x01CB */ "ACTOR_OCEFF_WIPE4",
+    /* 0x01CC */ "ACTOR_EN_EG",
+    /* 0x01CD */ "ACTOR_BG_MENKURI_NISEKABE",
+    /* 0x01CE */ "ACTOR_EN_ZO",
+    /* 0x01CF */ "ACTOR_OBJ_MAKEKINSUTA",
+    /* 0x01D0 */ "ACTOR_EN_GE3",
+    /* 0x01D1 */ "ACTOR_OBJ_TIMEBLOCK",
+    /* 0x01D2 */ "ACTOR_OBJ_HAMISHI",
+    /* 0x01D3 */ "ACTOR_EN_ZL4",
+    /* 0x01D4 */ "ACTOR_EN_MM2",
+    /* 0x01D5 */ "ACTOR_BG_JYA_BLOCK",
+    /* 0x01D6 */ "ACTOR_OBJ_WARP2BLOCK",
+    /* 0x01D7 */ "ACTOR_ID_MAX" // originally "ACTOR_DLF_MAX"
 };
 \ No newline at end of file
diff --git a/ZAPD/ZRoom/Commands/SetActorList.cpp b/ZAPD/ZRoom/Commands/SetActorList.cpp
index 7404f18..35c2af5 100644
--- a/ZAPD/ZRoom/Commands/SetActorList.cpp
+++ b/ZAPD/ZRoom/Commands/SetActorList.cpp
@@ -4,6 +4,7 @@
 #include "../ActorList.h"
 #include "../../BitConverter.h"
 #include "../../StringHelper.h"
+#include "../../Globals.h"
 
 using namespace std;
 
@@ -63,19 +64,32 @@ string SetActorList::GenerateSourceCodePass2(string roomName, int baseAddress)
 	int index = 0;
 	for (ActorSpawnEntry* entry : actors)
 	{
-		if (entry->actorNum < sizeof(ActorList) / sizeof(ActorList[0]))
-			declaration += StringHelper::Sprintf("\t{ %s, %i, %i, %i, %i, %i, %i, 0x%04X }, //0x%06X", ActorList[entry->actorNum].c_str(), entry->posX, entry->posY, entry->posZ, entry->rotX, entry->rotY, entry->rotZ, (uint16_t)entry->initVar, segmentOffset + (index * 16));
+		uint16_t actorNum = entry->actorNum;
+
+		// SW97 Actor 0x22 was removed, so we want to not output a working actor.
+		if (actorNum == 0x22 && Globals::Instance->game == ZGame::OOT_SW97)
+			declaration += StringHelper::Sprintf("\t//{ %s, %i, %i, %i, %i, %i, %i, 0x%04X }, //0x%06X", StringHelper::Sprintf("SW_REMOVED_0x%04X", actorNum), entry->posX, entry->posY, entry->posZ, entry->rotX, entry->rotY, entry->rotZ, (uint16_t)entry->initVar, segmentOffset + (index * 16));
 		else
-			declaration += StringHelper::Sprintf("\t{ 0x%04X, %i, %i, %i, %i, %i, %i, 0x%04X }, //0x%06X", entry->actorNum, entry->posX, entry->posY, entry->posZ, entry->rotX, entry->rotY, entry->rotZ, (uint16_t)entry->initVar, segmentOffset + (index * 16));
+		{
+			// SW97 Actor 0x23 and above are shifted up by one because 0x22 was removed between SW97 and retail.
+			// We need to shift down by one
+			if (Globals::Instance->game == ZGame::OOT_SW97 && actorNum >= 0x23)
+				actorNum--;
+
+			if (actorNum < sizeof(ActorList) / sizeof(ActorList[0]))
+				declaration += StringHelper::Sprintf("\t{ %s, %i, %i, %i, %i, %i, %i, 0x%04X }, //0x%06X", ActorList[actorNum].c_str(), entry->posX, entry->posY, entry->posZ, entry->rotX, entry->rotY, entry->rotZ, (uint16_t)entry->initVar, segmentOffset + (index * 16));
+			else
+				declaration += StringHelper::Sprintf("\t{ 0x%04X, %i, %i, %i, %i, %i, %i, 0x%04X }, //0x%06X", actorNum, entry->posX, entry->posY, entry->posZ, entry->rotX, entry->rotY, entry->rotZ, (uint16_t)entry->initVar, segmentOffset + (index * 16));
 
-		if (index < actors.size() - 1)
-			declaration += "\n";
+			if (index < actors.size() - 1)
+				declaration += "\n";
+		}
 
 		index++;
 	}
 
 	zRoom->parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::None, DeclarationPadding::Pad16, actors.size() * 16,
-		"ActorEntry", StringHelper::Sprintf("%sActorList0x%06X", roomName.c_str(), segmentOffset), actors.size(), declaration);
+		"ActorEntry", StringHelper::Sprintf("%sActorList0x%06X", roomName.c_str(), segmentOffset), GetActorListArraySize(), declaration);
 
 	return sourceOutput;
 }
@@ -85,9 +99,31 @@ int32_t SetActorList::GetRawDataSize()
 	return ZRoomCommand::GetRawDataSize() + ((int)actors.size() * 16);
 }
 
+int SetActorList::GetActorListArraySize()
+{
+	int actorCount = 0;
+
+	// Doing an else-if here so we only do the loop when the game is SW97.
+	// Actor 0x22 is removed from SW97, so we need to ensure that we don't increment the actor count for it.
+	if (Globals::Instance->game == ZGame::OOT_SW97)
+	{
+		actorCount = 0;
+
+		for (ActorSpawnEntry* entry : actors)
+			if (entry->actorNum != 0x22)
+				actorCount++;
+	}
+	else
+	{
+		actorCount = (int)actors.size();
+	}
+
+	return actorCount;
+}
+
 string SetActorList::GenerateExterns()
 {
-	return StringHelper::Sprintf("extern ActorEntry %sActorList0x%06X[%i];\n", zRoom->GetName().c_str(), segmentOffset, (int)actors.size());
+	return StringHelper::Sprintf("extern ActorEntry %sActorList0x%06X[%i];\n", zRoom->GetName().c_str(), segmentOffset, GetActorListArraySize());
 }
 
 string SetActorList::GetCommandCName()
diff --git a/ZAPD/ZRoom/Commands/SetActorList.h b/ZAPD/ZRoom/Commands/SetActorList.h
index 750a7de..3f59494 100644
--- a/ZAPD/ZRoom/Commands/SetActorList.h
+++ b/ZAPD/ZRoom/Commands/SetActorList.h
@@ -32,6 +32,7 @@ public:
 	virtual std::string GenerateExterns();
 
 private:
+	int GetActorListArraySize();
 	int numActors;
 	std::vector<ActorSpawnEntry*> actors;
 	uint32_t segmentOffset;
diff --git a/ZAPD/ZRoom/Commands/SetMesh.cpp b/ZAPD/ZRoom/Commands/SetMesh.cpp
index 1f343c6..7b1c6cb 100644
--- a/ZAPD/ZRoom/Commands/SetMesh.cpp
+++ b/ZAPD/ZRoom/Commands/SetMesh.cpp
@@ -14,8 +14,6 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
 	segmentOffset = SEG2FILESPACE(BitConverter::ToInt32BE(rawData, rawDataIndex + 4));
 
 	string declaration = "";
-	char line[2048];
-
 	int8_t meshHeaderType = rawData[segmentOffset + 0];
 
 	if (meshHeaderType == 0)
@@ -24,8 +22,8 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
 		meshHeader0->headerType = 0;
 		meshHeader0->entries = vector<MeshEntry0*>();
 
-		meshHeader0->dListStart = BitConverter::ToInt32BE(rawData, segmentOffset + 4) & 0x00FFFFFF;
-		meshHeader0->dListEnd = BitConverter::ToInt32BE(rawData, segmentOffset + 8) & 0x00FFFFFF;
+		meshHeader0->dListStart = SEG2FILESPACE(BitConverter::ToInt32BE(rawData, segmentOffset + 4));
+		meshHeader0->dListEnd = SEG2FILESPACE(BitConverter::ToInt32BE(rawData, segmentOffset + 8));
 
 		int8_t numEntries = rawData[segmentOffset + 1];
 		uint32_t currentPtr = meshHeader0->dListStart;
@@ -40,12 +38,12 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
 		for (int i = 0; i < numEntries; i++)
 		{
 			MeshEntry0* entry = new MeshEntry0();
-			entry->opaqueDListAddr = BitConverter::ToInt32BE(rawData, currentPtr + 0) & 0x00FFFFFF;
-			entry->translucentDListAddr = BitConverter::ToInt32BE(rawData, currentPtr + 4) & 0x00FFFFFF;
+			entry->opaqueDListAddr = SEG2FILESPACE(BitConverter::ToInt32BE(rawData, currentPtr + 0));
+			entry->translucentDListAddr = SEG2FILESPACE(BitConverter::ToInt32BE(rawData, currentPtr + 4));
 
 			if (entry->opaqueDListAddr != 0)
 			{
-				entry->opaqueDList = new ZDisplayList(rawData, entry->opaqueDListAddr, ZDisplayList::GetDListLength(rawData, entry->opaqueDListAddr));
+				entry->opaqueDList = new ZDisplayList(rawData, entry->opaqueDListAddr, ZDisplayList::GetDListLength(rawData, entry->opaqueDListAddr, Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX));
 				entry->opaqueDList->scene = zRoom->scene;
 				entry->opaqueDList->parent = zRoom->parent;
 				GenDListDeclarations(rawData, entry->opaqueDList);
@@ -53,7 +51,7 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
 
 			if (entry->translucentDListAddr != 0)
 			{
-				entry->translucentDList = new ZDisplayList(rawData, entry->translucentDListAddr, ZDisplayList::GetDListLength(rawData, entry->translucentDListAddr));
+				entry->translucentDList = new ZDisplayList(rawData, entry->translucentDListAddr, ZDisplayList::GetDListLength(rawData, entry->translucentDListAddr, Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX));
 				entry->translucentDList->scene = zRoom->scene;
 				entry->translucentDList->parent = zRoom->parent;
 				GenDListDeclarations(rawData, entry->translucentDList);
@@ -64,22 +62,17 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
 			currentPtr += 8;
 		}
 
-		//declaration += StringHelper::Sprintf("MeshHeader0 %sMeshHeade0x%06X = { { 0 }, 0x%02X, ", zRoom->GetName().c_str(), segmentOffset, meshHeader0->entries.size());
 		declaration += StringHelper::Sprintf("{ 0 }, 0x%02X, ", meshHeader0->entries.size());
 
 		if (meshHeader0->dListStart != 0)
-			sprintf(line, "(u32)&%sMeshDListEntry0x%06X, ", zRoom->GetName().c_str(), meshHeader0->dListStart);
+			declaration += StringHelper::Sprintf("(u32)&%sMeshDListEntry0x%06X, ", zRoom->GetName().c_str(), meshHeader0->dListStart);
 		else
-			sprintf(line, "0, ");
-
-		declaration += line;
+			declaration += "0, ";
 
 		if (meshHeader0->dListEnd != 0)
-			sprintf(line, "(u32)&(%sMeshDListEntry0x%06X) + sizeof(%sMeshDListEntry0x%06X)", zRoom->GetName().c_str(), meshHeader0->dListStart, zRoom->GetName().c_str(), meshHeader0->dListStart);
+			declaration += StringHelper::Sprintf("(u32)&(%sMeshDListEntry0x%06X) + sizeof(%sMeshDListEntry0x%06X)", zRoom->GetName().c_str(), meshHeader0->dListStart, zRoom->GetName().c_str(), meshHeader0->dListStart);
 		else
-			sprintf(line, "0");
-
-		declaration += line;
+			declaration += "0";
 
 		zRoom->parent->AddDeclaration(segmentOffset, DeclarationAlignment::Align16, 12, "MeshHeader0", StringHelper::Sprintf("%sMeshHeader0x%06X", zRoom->GetName().c_str(), segmentOffset),
 			declaration);
@@ -89,22 +82,16 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
 		for (int i = 0; i < meshHeader0->entries.size(); i++)
 		{
 			if (meshHeader0->entries[i]->opaqueDListAddr != 0)
-				sprintf(line, "\t{ (u32)%sDlist0x%06X, ", zRoom->GetName().c_str(), meshHeader0->entries[i]->opaqueDListAddr);
+				declaration += StringHelper::Sprintf("\t{ (u32)%sDlist0x%06X, ", zRoom->GetName().c_str(), meshHeader0->entries[i]->opaqueDListAddr);
 			else
-				sprintf(line, "\t{ 0, ");
-
-			declaration += line;
+				declaration += "\t{ 0, ";
 
 			if (meshHeader0->entries[i]->translucentDListAddr != 0)
-				sprintf(line, "(u32)%sDlist0x%06X },\n", zRoom->GetName().c_str(), meshHeader0->entries[i]->translucentDListAddr);
+				declaration += StringHelper::Sprintf("(u32)%sDlist0x%06X },\n", zRoom->GetName().c_str(), meshHeader0->entries[i]->translucentDListAddr);
 			else
-				sprintf(line, "0 },\n");
-
-			declaration += line;
+				declaration += "0 },\n";
 		}
 
-		//declaration += "static u32 terminatorMaybe = 0x01000000; // This always appears after the mesh entries. Its purpose is not clear.\n";
-
 		zRoom->parent->AddDeclarationArray(meshHeader0->dListStart, DeclarationAlignment::None, DeclarationPadding::None, (meshHeader0->entries.size() * 8) + 0, "MeshEntry0",
 			StringHelper::Sprintf("%sMeshDListEntry0x%06X", zRoom->GetName().c_str(), meshHeader0->dListStart), meshHeader0->entries.size(), declaration);
 
@@ -186,8 +173,8 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
 		meshHeader2->headerType = 2;
 		
 		meshHeader2->entries = vector<MeshEntry2*>();
-		meshHeader2->dListStart = BitConverter::ToInt32BE(rawData, segmentOffset + 4) & 0x00FFFFFF;
-		meshHeader2->dListEnd = BitConverter::ToInt32BE(rawData, segmentOffset + 8) & 0x00FFFFFF;
+		meshHeader2->dListStart = SEG2FILESPACE(BitConverter::ToInt32BE(rawData, segmentOffset + 4));
+		meshHeader2->dListEnd = SEG2FILESPACE(BitConverter::ToInt32BE(rawData, segmentOffset + 8));
 
 		int8_t numEntries = rawData[segmentOffset + 1];
 		uint32_t currentPtr = meshHeader2->dListStart;
@@ -206,7 +193,7 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
 
 			if (entry->opaqueDListAddr != 0)
 			{
-				entry->opaqueDList = new ZDisplayList(rawData, entry->opaqueDListAddr, ZDisplayList::GetDListLength(rawData, entry->opaqueDListAddr));
+				entry->opaqueDList = new ZDisplayList(rawData, entry->opaqueDListAddr, ZDisplayList::GetDListLength(rawData, entry->opaqueDListAddr, Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX));
 				entry->opaqueDList->scene = zRoom->scene;
 				entry->opaqueDList->parent = zRoom->parent;
 				GenDListDeclarations(rawData, entry->opaqueDList); // HOTSPOT
@@ -214,7 +201,7 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
 
 			if (entry->translucentDListAddr != 0)
 			{
-				entry->translucentDList = new ZDisplayList(rawData, entry->translucentDListAddr, ZDisplayList::GetDListLength(rawData, entry->translucentDListAddr));
+				entry->translucentDList = new ZDisplayList(rawData, entry->translucentDListAddr, ZDisplayList::GetDListLength(rawData, entry->translucentDListAddr, Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX));
 				entry->translucentDList->scene = zRoom->scene;
 				entry->translucentDList->parent = zRoom->parent;
 				GenDListDeclarations(rawData, entry->translucentDList); // HOTSPOT
@@ -225,55 +212,38 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
 			currentPtr += 16;
 		}
 
-		sprintf(line, "{ 2 }, 0x%02lX, ", meshHeader2->entries.size());
-		declaration += line;
+		declaration += StringHelper::Sprintf("{ 2 }, 0x%02lX, ", meshHeader2->entries.size());
 
 		if (meshHeader2->dListStart != 0)
-			sprintf(line, "(u32)&%sMeshDListEntry0x%06X, ", zRoom->GetName().c_str(), meshHeader2->dListStart);
+			declaration += StringHelper::Sprintf("(u32)&%sMeshDListEntry0x%06X, ", zRoom->GetName().c_str(), meshHeader2->dListStart);
 		else
-			sprintf(line, "0, ");
-
-		declaration += line;
+			declaration += "0, ";
 
 		if (meshHeader2->dListEnd != 0)
-			sprintf(line, "(u32)&(%sMeshDListEntry0x%06X) + sizeof(%sMeshDListEntry0x%06X)", zRoom->GetName().c_str(), meshHeader2->dListStart, zRoom->GetName().c_str(), meshHeader2->dListStart);
+			declaration += StringHelper::Sprintf("(u32)&(%sMeshDListEntry0x%06X) + sizeof(%sMeshDListEntry0x%06X)", zRoom->GetName().c_str(), meshHeader2->dListStart, zRoom->GetName().c_str(), meshHeader2->dListStart);
 		else
-			sprintf(line, "0");
-
-		declaration += line;
+			declaration += "0";
 
 		zRoom->parent->AddDeclaration(segmentOffset, DeclarationAlignment::None, 12, "MeshHeader2",
 			StringHelper::Sprintf("%sMeshHeader0x%06X", zRoom->GetName().c_str(), segmentOffset), declaration);
 
 		declaration = "";
 
-		//sprintf(line, "MeshEntry2 %sMeshDListEntry0x%06X[%i] = \n{\n", zRoom->GetName().c_str(), meshHeader2->dListStart, meshHeader2->entries.size());
-		//declaration += line;
-
 		for (int i = 0; i < meshHeader2->entries.size(); i++)
 		{
-			sprintf(line, "\t{ %i, %i, %i, %i, ", meshHeader2->entries[i]->playerXMax, meshHeader2->entries[i]->playerZMax, meshHeader2->entries[i]->playerXMin, meshHeader2->entries[i]->playerZMin);
-
-			declaration += line;
+			declaration += StringHelper::Sprintf("\t{ %i, %i, %i, %i, ", meshHeader2->entries[i]->playerXMax, meshHeader2->entries[i]->playerZMax, meshHeader2->entries[i]->playerXMin, meshHeader2->entries[i]->playerZMin);
 
 			if (meshHeader2->entries[i]->opaqueDListAddr != 0)
-				sprintf(line, "(u32)%sDlist0x%06X, ", zRoom->GetName().c_str(), meshHeader2->entries[i]->opaqueDListAddr);
+				declaration += StringHelper::Sprintf("(u32)%sDlist0x%06X, ", zRoom->GetName().c_str(), meshHeader2->entries[i]->opaqueDListAddr);
 			else
-				sprintf(line, "0, ");
-
-			declaration += line;
+				declaration += "0, ";
 
 			if (meshHeader2->entries[i]->translucentDListAddr != 0)
-				sprintf(line, "(u32)%sDlist0x%06X },\n", zRoom->GetName().c_str(), meshHeader2->entries[i]->translucentDListAddr);
+				declaration += StringHelper::Sprintf("(u32)%sDlist0x%06X },\n", zRoom->GetName().c_str(), meshHeader2->entries[i]->translucentDListAddr);
 			else
-				sprintf(line, "0 },\n");
-
-			declaration += line;
+				declaration += "0 },\n";
 		}
 
-		//declaration += "};\n\n";
-		//declaration += "static u32 terminatorMaybe = 0x01000000; // This always appears after the mesh entries. Its purpose is not clear.\n";
-
 		zRoom->parent->AddDeclarationArray(meshHeader2->dListStart, DeclarationAlignment::None, DeclarationPadding::None, (meshHeader2->entries.size() * 16) + 0, 
 			"MeshEntry2", StringHelper::Sprintf("%sMeshDListEntry0x%06X", zRoom->GetName().c_str(), meshHeader2->dListStart, meshHeader2->entries.size()), meshHeader2->entries.size(), declaration);
 
@@ -314,8 +284,6 @@ void SetMesh::GenDListDeclarations(std::vector<uint8_t> rawData, ZDisplayList* d
 	{
 		zRoom->parent->AddDeclarationArray(vtxEntry.first, DeclarationAlignment::Align8, dList->vertices[vtxEntry.first].size() * 16, "static Vtx",
 			StringHelper::Sprintf("%sVtx_%06X", zRoom->GetName().c_str(), vtxEntry.first), dList->vertices[vtxEntry.first].size(), vtxEntry.second);
-
-		//zRoom->parent->declarations[vtxEntry.first] = new Declaration(DeclarationAlignment::Align8, dList->vertices[vtxEntry.first].size() * 16, vtxEntry.second);
 	}
 
 	for (pair<uint32_t, string> texEntry : dList->texDeclarations)
@@ -345,9 +313,6 @@ std::string SetMesh::GenDListExterns(ZDisplayList* dList)
 	for (ZDisplayList* otherDList : dList->otherDLists)
 		sourceOutput += GenDListExterns(otherDList);
 
-	//for (pair<uint32_t, string> vtxEntry : dList->vtxDeclarations)
-		//sourceOutput += StringHelper::Sprintf("extern Vtx %sVtx_%06X[%i];\n", zRoom->GetName().c_str(), vtxEntry.first, dList->vertices[vtxEntry.first].size());
-
 	for (pair<uint32_t, string> texEntry : dList->texDeclarations)
 		sourceOutput += StringHelper::Sprintf("extern u64 %sTex_%06X[];\n", zRoom->GetName().c_str(), texEntry.first);
 
diff --git a/ZAPD/ZRoom/Commands/SetTransitionActorList.cpp b/ZAPD/ZRoom/Commands/SetTransitionActorList.cpp
index 78fc564..fb0c299 100644
--- a/ZAPD/ZRoom/Commands/SetTransitionActorList.cpp
+++ b/ZAPD/ZRoom/Commands/SetTransitionActorList.cpp
@@ -42,7 +42,16 @@ string SetTransitionActorList::GenerateSourceCodePass1(string roomName, int base
 	string declaration = "";
 
 	for (TransitionActorEntry* entry : transitionActors)
-		declaration += StringHelper::Sprintf("\t{ %i, %i, %i, %i, %s, %i, %i, %i, %i, 0x%04X }, \n", entry->frontObjectRoom, entry->frontTransitionReaction, entry->backObjectRoom, entry->backTransitionReaction, ActorList[entry->actorNum].c_str(), entry->posX, entry->posY, entry->posZ, entry->rotY, (uint16_t)entry->initVar);
+	{
+		string actorStr = "";
+
+		if (entry->actorNum < sizeof(ActorList) / sizeof(ActorList[0]))
+			actorStr = ActorList[entry->actorNum];
+		else
+			actorStr = StringHelper::Sprintf("0x%04X", entry->actorNum);
+
+		declaration += StringHelper::Sprintf("\t{ %i, %i, %i, %i, %s, %i, %i, %i, %i, 0x%04X }, \n", entry->frontObjectRoom, entry->frontTransitionReaction, entry->backObjectRoom, entry->backTransitionReaction, actorStr.c_str(), entry->posX, entry->posY, entry->posZ, entry->rotY, (uint16_t)entry->initVar);
+	}
 
 	zRoom->parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::None, transitionActors.size() * 16, "TransitionActorEntry",
 		StringHelper::Sprintf("%sTransitionActorList0x%06X", roomName.c_str(), segmentOffset), 0, declaration);
diff --git a/ZAPD/ZRoom/ObjectList.h b/ZAPD/ZRoom/ObjectList.h
index 4265f1d..57d908d 100644
--- a/ZAPD/ZRoom/ObjectList.h
+++ b/ZAPD/ZRoom/ObjectList.h
@@ -4,406 +4,406 @@
 
 static const std::string ObjectList[] =
 {
-	"OBJ_0000",
-	"GAMEPLAY_KEEP",
-	"GAMEPLAY_FIELD_KEEP",
-	"GAMEPLAY_DANGEON_KEEP",
-	"OBJ_0004",
-	"OBJ_0005",
-	"OBJECT_HUMAN",
-	"OBJECT_OKUTA",
-	"OBJECT_CROW",
-	"OBJECT_POH",
-	"OBJECT_DY_OBJ",
-	"OBJECT_WALLMASTER",
-	"OBJECT_DODONGO",
-	"OBJECT_FIREFLY",
-	"OBJECT_BOX",
-	"OBJECT_FIRE",
-	"OBJ_0010",
-	"OBJ_0011",
-	"OBJECT_BUBBLE",
-	"OBJECT_NIW",
-	"OBJECT_LINK_BOY",
-	"OBJECT_LINK_CHILD",
-	"OBJECT_TITE",
-	"OBJECT_REEBA",
-	"OBJECT_PEEHAT",
-	"OBJECT_KINGDODONGO",
-	"OBJECT_HORSE",
-	"OBJECT_ZF",
-	"OBJECT_GOMA",
-	"OBJECT_ZL1",
-	"OBJECT_GOL",
-	"OBJECT_DODOJR",
-	"OBJECT_TORCH2",
-	"OBJECT_BL",
-	"OBJECT_TP",
-	"OBJECT_OA1",
-	"OBJECT_ST",
-	"OBJECT_BW",
-	"OBJECT_EI",
-	"OBJECT_HORSE_NORMAL",
-	"OBJECT_OB1",
-	"OBJECT_O_ANIME",
-	"OBJECT_SPOT04_OBJECTS",
-	"OBJECT_DDAN_OBJECTS",
-	"OBJECT_HIDAN_OBJECTS",
-	"OBJECT_HORSE_GANON",
-	"OBJECT_OA2",
-	"OBJECT_SPOT00_OBJECTS",
-	"OBJECT_MB",
-	"OBJECT_BOMBF",
-	"OBJECT_SK2",
-	"OBJECT_OE1",
-	"OBJECT_OE_ANIME",
-	"OBJECT_OE2",
-	"OBJECT_YDAN_OBJECTS",
-	"OBJECT_GND",
-	"OBJECT_AM",
-	"OBJECT_DEKUBABA",
-	"OBJECT_003A",
-	"OBJECT_OA3",
-	"OBJECT_OA4",
-	"OBJECT_OA5",
-	"OBJECT_OA6",
-	"OBJECT_OA7",
-	"OBJECT_JJ",
-	"OBJECT_OA8",
-	"OBJECT_OA9",
-	"OBJECT_OB2",
-	"OBJECT_OB3",
-	"OBJECT_OB4",
-	"OBJECT_HORSE_ZELDA",
-	"OBJECT_OPENING_DEMO1",
-	"OBJECT_WARP1",
-	"OBJECT_B_HEART",
-	"OBJECT_DEKUNUTS",
-	"OBJECT_OE3",
-	"OBJECT_OE4",
-	"OBJECT_MENKURI_OBJECTS",
-	"OBJECT_OE5",
-	"OBJECT_OE6",
-	"OBJECT_OE7",
-	"OBJECT_OE8",
-	"OBJECT_OE9",
-	"OBJECT_OE10",
-	"OBJECT_OE11",
-	"OBJECT_OE12",
-	"OBJECT_VALI",
-	"OBJECT_OA10",
-	"OBJECT_OA11",
-	"OBJECT_MIZU_OBJECTS",
-	"OBJECT_FHG",
-	"OBJECT_OSSAN",
-	"OBJECT_MORI_HINERI1",
-	"OBJECT_BB",
-	"OBJECT_TOKI_OBJECTS",
-	"OBJECT_YUKABYUN",
-	"OBJECT_ZL2",
-	"OBJECT_MJIN",
-	"OBJECT_MJIN_FLASH",
-	"OBJECT_MJIN_DARK",
-	"OBJECT_MJIN_FLAME",
-	"OBJECT_MJIN_ICE",
-	"OBJECT_MJIN_SOUL",
-	"OBJECT_MJIN_WIND",
-	"OBJECT_MJIN_OKA",
-	"OBJECT_HAKA_OBJECTS",
-	"OBJECT_SPOT06_OBJECTS",
-	"OBJECT_ICE_OBJECTS",
-	"OBJECT_RELAY_OBJECTS",
-	"OBJECT_PO_FIELD",
-	"OBJECT_PO_COMPOSER",
-	"OBJECT_MORI_HINERI1A",
-	"OBJECT_MORI_HINERI2",
-	"OBJECT_MORI_HINERI2A",
-	"OBJECT_MORI_OBJECTS",
-	"OBJECT_MORI_TEX",
-	"OBJECT_SPOT08_OBJ",
-	"OBJECT_WARP2",
-	"OBJECT_HATA",
-	"OBJECT_BIRD",
-	"OBJ_0078",
-	"OBJ_0079",
-	"OBJ_007A",
-	"OBJ_007B",
-	"OBJECT_WOOD02",
-	"OBJ_007D",
-	"OBJ_007E",
-	"OBJ_007F",
-	"OBJ_0080",
-	"OBJECT_LIGHTBOX",
-	"OBJECT_PU_BOX",
-	"OBJ_0083",
-	"OBJ_0084",
-	"OBJECT_TRAP",
-	"OBJECT_VASE",
-	"OBJECT_IM",
-	"OBJECT_TA",
-	"OBJECT_TK",
-	"OBJECT_XC",
-	"OBJECT_VM",
-	"OBJECT_BV",
-	"OBJECT_HAKACH_OBJECTS",
-	"OBJECT_EFC_CRYSTAL_LIGHT",
-	"OBJECT_EFC_FIRE_BALL",
-	"OBJECT_EFC_FLASH",
-	"OBJECT_EFC_LGT_SHOWER",
-	"OBJECT_EFC_STAR_FIELD",
-	"OBJECT_GOD_LGT",
-	"OBJECT_LIGHT_RING",
-	"OBJECT_TRIFORCE_SPOT",
-	"OBJECT_BDAN_OBJECTS",
-	"OBJECT_SD",
-	"OBJECT_RD",
-	"OBJECT_PO_SISTERS",
-	"OBJECT_HEAVY_OBJECT",
-	"OBJECT_GNDD",
-	"OBJECT_FD",
-	"OBJECT_DU",
-	"OBJECT_FW",
-	"OBJECT_MEDAL",
-	"OBJECT_HORSE_LINK_CHILD",
-	"OBJECT_SPOT02_OBJECTS",
-	"OBJECT_HAKA",
-	"OBJECT_RU1",
-	"OBJECT_SYOKUDAI",
-	"OBJECT_FD2",
-	"OBJECT_DH",
-	"OBJECT_RL",
-	"OBJECT_EFC_TW",
-	"OBJECT_DEMO_TRE_LGT",
-	"OBJECT_GI_KEY",
-	"OBJECT_MIR_RAY",
-	"OBJECT_BROB",
-	"OBJECT_GI_JEWEL",
-	"OBJECT_SPOT09_OBJ",
-	"OBJECT_SPOT18_OBJ",
-	"OBJECT_BDOOR",
-	"OBJECT_SPOT17_OBJ",
-	"OBJECT_SHOP_DUNGEN",
-	"OBJECT_NB",
-	"OBJECT_MO",
-	"OBJECT_SB",
-	"OBJECT_GI_MELODY",
-	"OBJECT_GI_HEART",
-	"OBJECT_GI_COMPASS",
-	"OBJECT_GI_BOSSKEY",
-	"OBJECT_GI_MEDAL",
-	"OBJECT_GI_NUTS",
-	"OBJECT_SA",
-	"OBJECT_GI_HEARTS",
-	"OBJECT_GI_ARROWCASE",
-	"OBJECT_GI_BOMBPOUCH",
-	"OBJECT_IN",
-	"OBJECT_TR",
-	"OBJECT_SPOT16_OBJ",
-	"OBJECT_OE1S",
-	"OBJECT_OE4S",
-	"OBJECT_OS_ANIME",
-	"OBJECT_GI_BOTTLE",
-	"OBJECT_GI_STICK",
-	"OBJECT_GI_MAP",
-	"OBJECT_OF1D_MAP",
-	"OBJECT_RU2",
-	"OBJECT_GI_SHIELD_1",
-	"OBJECT_DEKUJR",
-	"OBJECT_GI_MAGICPOT",
-	"OBJECT_GI_BOMB_1",
-	"OBJECT_OF1S",
-	"OBJECT_MA2",
-	"OBJECT_GI_PURSE",
-	"OBJECT_HNI",
-	"OBJECT_TW",
-	"OBJECT_RR",
-	"OBJECT_BXA",
-	"OBJECT_ANUBICE",
-	"OBJECT_GI_GERUDO",
-	"OBJECT_GI_ARROW",
-	"OBJECT_GI_BOMB_2",
-	"OBJECT_GI_EGG",
-	"OBJECT_GI_SCALE",
-	"OBJECT_GI_SHIELD_2",
-	"OBJEFCT_GI_HOOKSHOT",
-	"OBJECT_GI_OCARINA",
-	"OBJECT_GI_MILK",
-	"OBJECT_MA1",
-	"OBJECT_GANON",
-	"OBJECT_SST",
-	"OBJECT_NY",
-	"OBJ_00E4",
-	"OBJECT_NY",
-	"OBJECT_FR",
-	"OBJECT_GI_PACHINKO",
-	"OBJECT_GI_BOOMERANG",
-	"OBJECT_GI_BOW",
-	"OBJECT_GI_GLASSES",
-	"OBJECT_GI_LIQUID",
-	"OBJECT_ANI",
-	"OBJECT_DEMO_6K",
-	"OBJECT_GI_SHIELD_3",
-	"OBJECT_GI_LETTER",
-	"OBJECT_SPOT15_OBJ",
-	"OBJECT_JYA_OBJ",
-	"OBJECT_GI_CLOTHES",
-	"OBJECT_GI_BEAN",
-	"OBJECT_GI_FISH",
-	"OBJECT_GI_SAW",
-	"OBJECT_GI_HAMMER",
-	"OBJECT_GI_GRASS",
-	"OBJECT_GI_LONGSWORD",
-	"OBJECT_SPOT01_OBJECTS",
-	"OBJECT_MD",
-	"OBJECT_MD",
-	"OBJECT_KM1",
-	"OBJECT_KW1",
-	"OBJECT_ZO",
-	"OBJECT_KZ",
-	"OBJECT_UMAJUMP",
-	"OBJECT_MASTERKOKIRI",
-	"OBJECT_MASTERKOKIRIHEAD",
-	"OBJECT_MASTERGOLON",
-	"OBJECT_MASTERZOORA",
-	"OBJECT_AOB",
-	"OBJECT_IK",
-	"OBJECT_AHG",
-	"OBJECT_CNE",
-	"OBJECT_GI_NIWATORI",
-	"OBJECT_SKJ",
-	"OBJECT_GI_BOTTLE_LETTER",
-	"OBJECT_BJI",
-	"OBJECT_BBA",
-	"OBJECT_GI_OCARINA_0",
-	"OBJECT_DS",
-	"OBJECT_ANE",
-	"OBJECT_BOJ",
-	"OBJECT_SPOT03_OBJECT",
-	"OBJECT_SPOT07_OBJECT",
-	"OBJECT_FZ",
-	"OBJECT_BOB",
-	"OBJECT_GE1",
-	"OBJECT_YABUSAME_POINT",
-	"OBJECT_GI_BOOTS_2",
-	"OBJECT_GI_SEED",
-	"OBJECT_GND_MAGIC",
-	"OBJECT_D_ELEVATOR",
-	"OBJECT_D_HSBLOCK",
-	"OBJECT_D_LIFT",
-	"OBJECT_MAMENOKI",
-	"OBJECT_GOROIWA",
-	"OBJ_0120",
-	"OBJECT_TORYO",
-	"OBJECT_DAIKU",
-	"OBJ_0123",
-	"OBJECT_NWC",
-	"OBJECT_BLKOBJ",
-	"OBJECT_GM",
-	"OBJECT_MS",
-	"OBJECT_HS",
-	"OBJECT_INGATE",
-	"OBJECT_LIGHTSWITCH",
-	"OBJECT_KUSA",
-	"OBJECT_TSUBO",
-	"OBJECT_GI_GLOVES",
-	"OBJECT_GI_COIN",
-	"OBJECT_KANBAN",
-	"OBJECT_GJYO_OBJECTS",
-	"OBJECT_OWL",
-	"OBJECT_MK",
-	"OBJECT_FU",
-	"OBJECT_GI_KI_TAN_MASK",
-	"OBJECT_GI_REDEAD_MASK",
-	"OBJECT_GI_SKJ_MASK",
-	"OBJECT_GI_RABIT_MASK",
-	"OBJECT_GI_TRUTH_MASK",
-	"OBJECT_GANON_OBJECTS",
-	"OBJECT_SIOFUKI",
-	"OBJECT_STREAM",
-	"OBJECT_MM",
-	"OBJECT_FA",
-	"OBJECT_OS",
-	"OBJECT_GI_EYE_LOTION",
-	"OBJECT_GI_POWDER",
-	"OBJECT_GI_MUSHROOM",
-	"OBJECT_GI_TICKETSTONE",
-	"OBJECT_GI_BROKENSWORD",
-	"OBJECT_JS",
-	"OBJECT_CS",
-	"OBJECT_GI_PRESCRIPTION",
-	"OBJECT_GI_BRACELET",
-	"OBJECT_GI_SOLDOUT",
-	"OBJECT_GI_FROG",
-	"OBJECT_MAG",
-	"OBJECT_DOOR_GERUDO",
-	"OBJECT_GT",
-	"OBJECT_EFC_ERUPC",
-	"OBJECT_ZL2_ANIME1",
-	"OBJECT_ZL2_ANIME2",
-	"OBJECT_GI_GOLONMASK",
-	"OBJECT_GI_ZORAMASK",
-	"OBJECT_GI_GERUDOMASK",
-	"OBJECT_GANON2",
-	"OBJECT_KA",
-	"OBJECT_TS",
-	"OBJECT_ZG",
-	"OBJECT_GI_HOVERBOOTS",
-	"OBJECT_GI_M_ARROW",
-	"OBJECT_DS2",
-	"OBJECT_EC",
-	"OBJECT_FISH",
-	"OBJECT_GI_SUTARU",
-	"OBJECT_GI_GODDESS",
-	"OBJECT_SSH",
-	"OBJECT_BIGOKUTA",
-	"OBJECT_BG",
-	"OBJECT_SPOT05_OBJECTS",
-	"OBJECT_SPOT12_OBJ",
-	"OBJECT_BOMBIWA",
-	"OBJECT_HINTNUTS",
-	"OBJECT_RS",
-	"OBJECT_SPOT00_BREAK",
-	"OBJECT_GLA",
-	"OBJECT_SHOPNUTS",
-	"OBJECT_GELDB",
-	"OBJECT_GR",
-	"OBJECT_DOG",
-	"OBJECT_JYA_IRON",
-	"OBJECT_JYA_DOOR",
-	"OBJ_016E",
-	"OBJECT_SPOT11_OBJ",
-	"OBJECT_KIBAKO2",
-	"OBJECT_DNS",
-	"OBJECT_DNK",
-	"OBJECT_GI_FIRE",
-	"OBJECT_GI_INSECT",
-	"OBJECT_GI_BUTTERFLY",
-	"OBJECT_GI_GHOST",
-	"OBJECT_GI_SOUL",
-	"OBJECT_BOWL",
-	"OBJECT_DEMO_KEKKAI",
-	"OBJECT_EFC_DOUGHNUT",
-	"OBJECT_GI_DEKUPOUCH",
-	"OBJECT_GANON_ANIME1",
-	"OBJECT_GANON_ANIME2",
-	"OBJECT_GANON_ANIME3",
-	"OBJECT_GI_RUPY",
-	"OBJECT_SPOT01_MATOYA",
-	"OBJECT_SPOT01_MATOYAB",
-	"OBJECT_MU",
-	"OBJECT_WF",
-	"OBJECT_SKB",
-	"OBJECT_GJ",
-	"OBJECT_GEFF",
-	"OBJECT_HAKA_DOOR",
-	"OBJECT_GS",
-	"OBJECT_PS",
-	"OBJECT_BWALL",
-	"OBJECT_COW",
-	"OBJECT_COB",
-	"OBJECT_GI_SWORD_1",
-	"OBJECT_DOOR_KILLER",
-	"OBJECT_OUKE_HAKA",
-	"OBJECT_TIMEBLOCK",
-	"OBJECT_ZL4",
+    /* 0x0000 */ "OBJECT_UNSET_0",
+    /* 0x0001 */ "OBJECT_GAMEPLAY_KEEP",
+    /* 0x0002 */ "OBJECT_GAMEPLAY_FIELD_KEEP",
+    /* 0x0003 */ "OBJECT_GAMEPLAY_DANGEON_KEEP",
+    /* 0x0004 */ "OBJECT_UNSET_4",
+    /* 0x0005 */ "OBJECT_UNSET_5",
+    /* 0x0006 */ "OBJECT_HUMAN",
+    /* 0x0007 */ "OBJECT_OKUTA",
+    /* 0x0008 */ "OBJECT_CROW",
+    /* 0x0009 */ "OBJECT_POH",
+    /* 0x000A */ "OBJECT_DY_OBJ",
+    /* 0x000B */ "OBJECT_WALLMASTER",
+    /* 0x000C */ "OBJECT_DODONGO",
+    /* 0x000D */ "OBJECT_FIREFLY",
+    /* 0x000E */ "OBJECT_BOX",
+    /* 0x000F */ "OBJECT_FIRE",
+    /* 0x0010 */ "OBJECT_UNSET_10",
+    /* 0x0011 */ "OBJECT_UNSET_11",
+    /* 0x0012 */ "OBJECT_BUBBLE",
+    /* 0x0013 */ "OBJECT_NIW",
+    /* 0x0014 */ "OBJECT_LINK_BOY",
+    /* 0x0015 */ "OBJECT_LINK_CHILD",
+    /* 0x0016 */ "OBJECT_TITE",
+    /* 0x0017 */ "OBJECT_REEBA",
+    /* 0x0018 */ "OBJECT_PEEHAT",
+    /* 0x0019 */ "OBJECT_KINGDODONGO",
+    /* 0x001A */ "OBJECT_HORSE",
+    /* 0x001B */ "OBJECT_ZF",
+    /* 0x001C */ "OBJECT_GOMA",
+    /* 0x001D */ "OBJECT_ZL1",
+    /* 0x001E */ "OBJECT_GOL",
+    /* 0x001F */ "OBJECT_DODOJR",
+    /* 0x0020 */ "OBJECT_TORCH2",
+    /* 0x0021 */ "OBJECT_BL",
+    /* 0x0022 */ "OBJECT_TP",
+    /* 0x0023 */ "OBJECT_OA1",
+    /* 0x0024 */ "OBJECT_ST",
+    /* 0x0025 */ "OBJECT_BW",
+    /* 0x0026 */ "OBJECT_EI",
+    /* 0x0027 */ "OBJECT_HORSE_NORMAL",
+    /* 0x0028 */ "OBJECT_OB1",
+    /* 0x0029 */ "OBJECT_O_ANIME",
+    /* 0x002A */ "OBJECT_SPOT04_OBJECTS",
+    /* 0x002B */ "OBJECT_DDAN_OBJECTS",
+    /* 0x002C */ "OBJECT_HIDAN_OBJECTS",
+    /* 0x002D */ "OBJECT_HORSE_GANON",
+    /* 0x002E */ "OBJECT_OA2",
+    /* 0x002F */ "OBJECT_SPOT00_OBJECTS",
+    /* 0x0030 */ "OBJECT_MB",
+    /* 0x0031 */ "OBJECT_BOMBF",
+    /* 0x0032 */ "OBJECT_SK2",
+    /* 0x0033 */ "OBJECT_OE1",
+    /* 0x0034 */ "OBJECT_OE_ANIME",
+    /* 0x0035 */ "OBJECT_OE2",
+    /* 0x0036 */ "OBJECT_YDAN_OBJECTS",
+    /* 0x0037 */ "OBJECT_GND",
+    /* 0x0038 */ "OBJECT_AM",
+    /* 0x0039 */ "OBJECT_DEKUBABA",
+    /* 0x003A */ "OBJECT_UNSET_3A",
+    /* 0x003B */ "OBJECT_OA3",
+    /* 0x003C */ "OBJECT_OA4",
+    /* 0x003D */ "OBJECT_OA5",
+    /* 0x003E */ "OBJECT_OA6",
+    /* 0x003F */ "OBJECT_OA7",
+    /* 0x0040 */ "OBJECT_JJ",
+    /* 0x0041 */ "OBJECT_OA8",
+    /* 0x0042 */ "OBJECT_OA9",
+    /* 0x0043 */ "OBJECT_OB2",
+    /* 0x0044 */ "OBJECT_OB3",
+    /* 0x0045 */ "OBJECT_OB4",
+    /* 0x0046 */ "OBJECT_HORSE_ZELDA",
+    /* 0x0047 */ "OBJECT_OPENING_DEMO1",
+    /* 0x0048 */ "OBJECT_WARP1",
+    /* 0x0049 */ "OBJECT_B_HEART",
+    /* 0x004A */ "OBJECT_DEKUNUTS",
+    /* 0x004B */ "OBJECT_OE3",
+    /* 0x004C */ "OBJECT_OE4",
+    /* 0x004D */ "OBJECT_MENKURI_OBJECTS",
+    /* 0x004E */ "OBJECT_OE5",
+    /* 0x004F */ "OBJECT_OE6",
+    /* 0x0050 */ "OBJECT_OE7",
+    /* 0x0051 */ "OBJECT_OE8",
+    /* 0x0052 */ "OBJECT_OE9",
+    /* 0x0053 */ "OBJECT_OE10",
+    /* 0x0054 */ "OBJECT_OE11",
+    /* 0x0055 */ "OBJECT_OE12",
+    /* 0x0056 */ "OBJECT_VALI",
+    /* 0x0057 */ "OBJECT_OA10",
+    /* 0x0058 */ "OBJECT_OA11",
+    /* 0x0059 */ "OBJECT_MIZU_OBJECTS",
+    /* 0x005A */ "OBJECT_FHG",
+    /* 0x005B */ "OBJECT_OSSAN",
+    /* 0x005C */ "OBJECT_MORI_HINERI1",
+    /* 0x005D */ "OBJECT_BB",
+    /* 0x005E */ "OBJECT_TOKI_OBJECTS",
+    /* 0x005F */ "OBJECT_YUKABYUN",
+    /* 0x0060 */ "OBJECT_ZL2",
+    /* 0x0061 */ "OBJECT_MJIN",
+    /* 0x0062 */ "OBJECT_MJIN_FLASH",
+    /* 0x0063 */ "OBJECT_MJIN_DARK",
+    /* 0x0064 */ "OBJECT_MJIN_FLAME",
+    /* 0x0065 */ "OBJECT_MJIN_ICE",
+    /* 0x0066 */ "OBJECT_MJIN_SOUL",
+    /* 0x0067 */ "OBJECT_MJIN_WIND",
+    /* 0x0068 */ "OBJECT_MJIN_OKA",
+    /* 0x0069 */ "OBJECT_HAKA_OBJECTS",
+    /* 0x006A */ "OBJECT_SPOT06_OBJECTS",
+    /* 0x006B */ "OBJECT_ICE_OBJECTS",
+    /* 0x006C */ "OBJECT_RELAY_OBJECTS",
+    /* 0x006D */ "OBJECT_PO_FIELD",
+    /* 0x006E */ "OBJECT_PO_COMPOSER",
+    /* 0x006F */ "OBJECT_MORI_HINERI1A",
+    /* 0x0070 */ "OBJECT_MORI_HINERI2",
+    /* 0x0071 */ "OBJECT_MORI_HINERI2A",
+    /* 0x0072 */ "OBJECT_MORI_OBJECTS",
+    /* 0x0073 */ "OBJECT_MORI_TEX",
+    /* 0x0074 */ "OBJECT_SPOT08_OBJ",
+    /* 0x0075 */ "OBJECT_WARP2",
+    /* 0x0076 */ "OBJECT_HATA",
+    /* 0x0077 */ "OBJECT_BIRD",
+    /* 0x0078 */ "OBJECT_UNSET_78",
+    /* 0x0079 */ "OBJECT_UNSET_79",
+    /* 0x007A */ "OBJECT_UNSET_7A",
+    /* 0x007B */ "OBJECT_UNSET_7B",
+    /* 0x007C */ "OBJECT_WOOD02",
+    /* 0x007D */ "OBJECT_UNSET_7D",
+    /* 0x007E */ "OBJECT_UNSET_7E",
+    /* 0x007F */ "OBJECT_UNSET_7F",
+    /* 0x0080 */ "OBJECT_UNSET_80",
+    /* 0x0081 */ "OBJECT_LIGHTBOX",
+    /* 0x0082 */ "OBJECT_PU_BOX",
+    /* 0x0083 */ "OBJECT_UNSET_83",
+    /* 0x0084 */ "OBJECT_UNSET_84",
+    /* 0x0085 */ "OBJECT_TRAP",
+    /* 0x0086 */ "OBJECT_VASE",
+    /* 0x0087 */ "OBJECT_IM",
+    /* 0x0088 */ "OBJECT_TA",
+    /* 0x0089 */ "OBJECT_TK",
+    /* 0x008A */ "OBJECT_XC",
+    /* 0x008B */ "OBJECT_VM",
+    /* 0x008C */ "OBJECT_BV",
+    /* 0x008D */ "OBJECT_HAKACH_OBJECTS",
+    /* 0x008E */ "OBJECT_EFC_CRYSTAL_LIGHT",
+    /* 0x008F */ "OBJECT_EFC_FIRE_BALL",
+    /* 0x0090 */ "OBJECT_EFC_FLASH",
+    /* 0x0091 */ "OBJECT_EFC_LGT_SHOWER",
+    /* 0x0092 */ "OBJECT_EFC_STAR_FIELD",
+    /* 0x0093 */ "OBJECT_GOD_LGT",
+    /* 0x0094 */ "OBJECT_LIGHT_RING",
+    /* 0x0095 */ "OBJECT_TRIFORCE_SPOT",
+    /* 0x0096 */ "OBJECT_BDAN_OBJECTS",
+    /* 0x0097 */ "OBJECT_SD",
+    /* 0x0098 */ "OBJECT_RD",
+    /* 0x0099 */ "OBJECT_PO_SISTERS",
+    /* 0x009A */ "OBJECT_HEAVY_OBJECT",
+    /* 0x009B */ "OBJECT_GNDD",
+    /* 0x009C */ "OBJECT_FD",
+    /* 0x009D */ "OBJECT_DU",
+    /* 0x009E */ "OBJECT_FW",
+    /* 0x009F */ "OBJECT_MEDAL",
+    /* 0x00A0 */ "OBJECT_HORSE_LINK_CHILD",
+    /* 0x00A1 */ "OBJECT_SPOT02_OBJECTS",
+    /* 0x00A2 */ "OBJECT_HAKA",
+    /* 0x00A3 */ "OBJECT_RU1",
+    /* 0x00A4 */ "OBJECT_SYOKUDAI",
+    /* 0x00A5 */ "OBJECT_FD2",
+    /* 0x00A6 */ "OBJECT_DH",
+    /* 0x00A7 */ "OBJECT_RL",
+    /* 0x00A8 */ "OBJECT_EFC_TW",
+    /* 0x00A9 */ "OBJECT_DEMO_TRE_LGT",
+    /* 0x00AA */ "OBJECT_GI_KEY",
+    /* 0x00AB */ "OBJECT_MIR_RAY",
+    /* 0x00AC */ "OBJECT_BROB",
+    /* 0x00AD */ "OBJECT_GI_JEWEL",
+    /* 0x00AE */ "OBJECT_SPOT09_OBJ",
+    /* 0x00AF */ "OBJECT_SPOT18_OBJ",
+    /* 0x00B0 */ "OBJECT_BDOOR",
+    /* 0x00B1 */ "OBJECT_SPOT17_OBJ",
+    /* 0x00B2 */ "OBJECT_SHOP_DUNGEN",
+    /* 0x00B3 */ "OBJECT_NB",
+    /* 0x00B4 */ "OBJECT_MO",
+    /* 0x00B5 */ "OBJECT_SB",
+    /* 0x00B6 */ "OBJECT_GI_MELODY",
+    /* 0x00B7 */ "OBJECT_GI_HEART",
+    /* 0x00B8 */ "OBJECT_GI_COMPASS",
+    /* 0x00B9 */ "OBJECT_GI_BOSSKEY",
+    /* 0x00BA */ "OBJECT_GI_MEDAL",
+    /* 0x00BB */ "OBJECT_GI_NUTS",
+    /* 0x00BC */ "OBJECT_SA",
+    /* 0x00BD */ "OBJECT_GI_HEARTS",
+    /* 0x00BE */ "OBJECT_GI_ARROWCASE",
+    /* 0x00BF */ "OBJECT_GI_BOMBPOUCH",
+    /* 0x00C0 */ "OBJECT_IN",
+    /* 0x00C1 */ "OBJECT_TR",
+    /* 0x00C2 */ "OBJECT_SPOT16_OBJ",
+    /* 0x00C3 */ "OBJECT_OE1S",
+    /* 0x00C4 */ "OBJECT_OE4S",
+    /* 0x00C5 */ "OBJECT_OS_ANIME",
+    /* 0x00C6 */ "OBJECT_GI_BOTTLE",
+    /* 0x00C7 */ "OBJECT_GI_STICK",
+    /* 0x00C8 */ "OBJECT_GI_MAP",
+    /* 0x00C9 */ "OBJECT_OF1D_MAP",
+    /* 0x00CA */ "OBJECT_RU2",
+    /* 0x00CB */ "OBJECT_GI_SHIELD_1",
+    /* 0x00CC */ "OBJECT_DEKUJR",
+    /* 0x00CD */ "OBJECT_GI_MAGICPOT",
+    /* 0x00CE */ "OBJECT_GI_BOMB_1",
+    /* 0x00CF */ "OBJECT_OF1S",
+    /* 0x00D0 */ "OBJECT_MA2",
+    /* 0x00D1 */ "OBJECT_GI_PURSE",
+    /* 0x00D2 */ "OBJECT_HNI",
+    /* 0x00D3 */ "OBJECT_TW",
+    /* 0x00D4 */ "OBJECT_RR",
+    /* 0x00D5 */ "OBJECT_BXA",
+    /* 0x00D6 */ "OBJECT_ANUBICE",
+    /* 0x00D7 */ "OBJECT_GI_GERUDO",
+    /* 0x00D8 */ "OBJECT_GI_ARROW",
+    /* 0x00D9 */ "OBJECT_GI_BOMB_2",
+    /* 0x00DA */ "OBJECT_GI_EGG",
+    /* 0x00DB */ "OBJECT_GI_SCALE",
+    /* 0x00DC */ "OBJECT_GI_SHIELD_2",
+    /* 0x00DD */ "OBJECT_GI_HOOKSHOT",
+    /* 0x00DE */ "OBJECT_GI_OCARINA",
+    /* 0x00DF */ "OBJECT_GI_MILK",
+    /* 0x00E0 */ "OBJECT_MA1",
+    /* 0x00E1 */ "OBJECT_GANON",
+    /* 0x00E2 */ "OBJECT_SST",
+    /* 0x00E3 */ "OBJECT_NY_UNUSED",
+    /* 0x00E4 */ "OBJECT_UNSET_E4",
+    /* 0x00E5 */ "OBJECT_NY",
+    /* 0x00E6 */ "OBJECT_FR",
+    /* 0x00E7 */ "OBJECT_GI_PACHINKO",
+    /* 0x00E8 */ "OBJECT_GI_BOOMERANG",
+    /* 0x00E9 */ "OBJECT_GI_BOW",
+    /* 0x00EA */ "OBJECT_GI_GLASSES",
+    /* 0x00EB */ "OBJECT_GI_LIQUID",
+    /* 0x00EC */ "OBJECT_ANI",
+    /* 0x00ED */ "OBJECT_DEMO_6K",
+    /* 0x00EE */ "OBJECT_GI_SHIELD_3",
+    /* 0x00EF */ "OBJECT_GI_LETTER",
+    /* 0x00F0 */ "OBJECT_SPOT15_OBJ",
+    /* 0x00F1 */ "OBJECT_JYA_OBJ",
+    /* 0x00F2 */ "OBJECT_GI_CLOTHES",
+    /* 0x00F3 */ "OBJECT_GI_BEAN",
+    /* 0x00F4 */ "OBJECT_GI_FISH",
+    /* 0x00F5 */ "OBJECT_GI_SAW",
+    /* 0x00F6 */ "OBJECT_GI_HAMMER",
+    /* 0x00F7 */ "OBJECT_GI_GRASS",
+    /* 0x00F8 */ "OBJECT_GI_LONGSWORD",
+    /* 0x00F9 */ "OBJECT_SPOT01_OBJECTS",
+    /* 0x00FA */ "OBJECT_MD_UNUSED",
+    /* 0x00FB */ "OBJECT_MD",
+    /* 0x00FC */ "OBJECT_KM1",
+    /* 0x00FD */ "OBJECT_KW1",
+    /* 0x00FE */ "OBJECT_ZO",
+    /* 0x00FF */ "OBJECT_KZ",
+    /* 0x0100 */ "OBJECT_UMAJUMP",
+    /* 0x0101 */ "OBJECT_MASTERKOKIRI",
+    /* 0x0102 */ "OBJECT_MASTERKOKIRIHEAD",
+    /* 0x0103 */ "OBJECT_MASTERGOLON",
+    /* 0x0104 */ "OBJECT_MASTERZOORA",
+    /* 0x0105 */ "OBJECT_AOB",
+    /* 0x0106 */ "OBJECT_IK",
+    /* 0x0107 */ "OBJECT_AHG",
+    /* 0x0108 */ "OBJECT_CNE",
+    /* 0x0109 */ "OBJECT_GI_NIWATORI",
+    /* 0x010A */ "OBJECT_SKJ",
+    /* 0x010B */ "OBJECT_GI_BOTTLE_LETTER",
+    /* 0x010C */ "OBJECT_BJI",
+    /* 0x010D */ "OBJECT_BBA",
+    /* 0x010E */ "OBJECT_GI_OCARINA_0",
+    /* 0x010F */ "OBJECT_DS",
+    /* 0x0110 */ "OBJECT_ANE",
+    /* 0x0111 */ "OBJECT_BOJ",
+    /* 0x0112 */ "OBJECT_SPOT03_OBJECT",
+    /* 0x0113 */ "OBJECT_SPOT07_OBJECT",
+    /* 0x0114 */ "OBJECT_FZ",
+    /* 0x0115 */ "OBJECT_BOB",
+    /* 0x0116 */ "OBJECT_GE1",
+    /* 0x0117 */ "OBJECT_YABUSAME_POINT",
+    /* 0x0118 */ "OBJECT_GI_BOOTS_2",
+    /* 0x0119 */ "OBJECT_GI_SEED",
+    /* 0x011A */ "OBJECT_GND_MAGIC",
+    /* 0x011B */ "OBJECT_D_ELEVATOR",
+    /* 0x011C */ "OBJECT_D_HSBLOCK",
+    /* 0x011D */ "OBJECT_D_LIFT",
+    /* 0x011E */ "OBJECT_MAMENOKI",
+    /* 0x011F */ "OBJECT_GOROIWA",
+    /* 0x0120 */ "OBJECT_UNSET_120",
+    /* 0x0121 */ "OBJECT_TORYO",
+    /* 0x0122 */ "OBJECT_DAIKU",
+    /* 0x0123 */ "OBJECT_UNSET_123",
+    /* 0x0124 */ "OBJECT_NWC",
+    /* 0x0125 */ "OBJECT_BLKOBJ",
+    /* 0x0126 */ "OBJECT_GM",
+    /* 0x0127 */ "OBJECT_MS",
+    /* 0x0128 */ "OBJECT_HS",
+    /* 0x0129 */ "OBJECT_INGATE",
+    /* 0x012A */ "OBJECT_LIGHTSWITCH",
+    /* 0x012B */ "OBJECT_KUSA",
+    /* 0x012C */ "OBJECT_TSUBO",
+    /* 0x012D */ "OBJECT_GI_GLOVES",
+    /* 0x012E */ "OBJECT_GI_COIN",
+    /* 0x012F */ "OBJECT_KANBAN",
+    /* 0x0130 */ "OBJECT_GJYO_OBJECTS",
+    /* 0x0131 */ "OBJECT_OWL",
+    /* 0x0132 */ "OBJECT_MK",
+    /* 0x0133 */ "OBJECT_FU",
+    /* 0x0134 */ "OBJECT_GI_KI_TAN_MASK",
+    /* 0x0135 */ "OBJECT_GI_REDEAD_MASK",
+    /* 0x0136 */ "OBJECT_GI_SKJ_MASK",
+    /* 0x0137 */ "OBJECT_GI_RABIT_MASK",
+    /* 0x0138 */ "OBJECT_GI_TRUTH_MASK",
+    /* 0x0139 */ "OBJECT_GANON_OBJECTS",
+    /* 0x013A */ "OBJECT_SIOFUKI",
+    /* 0x013B */ "OBJECT_STREAM",
+    /* 0x013C */ "OBJECT_MM",
+    /* 0x013D */ "OBJECT_FA",
+    /* 0x013E */ "OBJECT_OS",
+    /* 0x013F */ "OBJECT_GI_EYE_LOTION",
+    /* 0x0140 */ "OBJECT_GI_POWDER",
+    /* 0x0141 */ "OBJECT_GI_MUSHROOM",
+    /* 0x0142 */ "OBJECT_GI_TICKETSTONE",
+    /* 0x0143 */ "OBJECT_GI_BROKENSWORD",
+    /* 0x0144 */ "OBJECT_JS",
+    /* 0x0145 */ "OBJECT_CS",
+    /* 0x0146 */ "OBJECT_GI_PRESCRIPTION",
+    /* 0x0147 */ "OBJECT_GI_BRACELET",
+    /* 0x0148 */ "OBJECT_GI_SOLDOUT",
+    /* 0x0149 */ "OBJECT_GI_FROG",
+    /* 0x014A */ "OBJECT_MAG",
+    /* 0x014B */ "OBJECT_DOOR_GERUDO",
+    /* 0x014C */ "OBJECT_GT",
+    /* 0x014D */ "OBJECT_EFC_ERUPC",
+    /* 0x014E */ "OBJECT_ZL2_ANIME1",
+    /* 0x014F */ "OBJECT_ZL2_ANIME2",
+    /* 0x0150 */ "OBJECT_GI_GOLONMASK",
+    /* 0x0151 */ "OBJECT_GI_ZORAMASK",
+    /* 0x0152 */ "OBJECT_GI_GERUDOMASK",
+    /* 0x0153 */ "OBJECT_GANON2",
+    /* 0x0154 */ "OBJECT_KA",
+    /* 0x0155 */ "OBJECT_TS",
+    /* 0x0156 */ "OBJECT_ZG",
+    /* 0x0157 */ "OBJECT_GI_HOVERBOOTS",
+    /* 0x0158 */ "OBJECT_GI_M_ARROW",
+    /* 0x0159 */ "OBJECT_DS2",
+    /* 0x015A */ "OBJECT_EC",
+    /* 0x015B */ "OBJECT_FISH",
+    /* 0x015C */ "OBJECT_GI_SUTARU",
+    /* 0x015D */ "OBJECT_GI_GODDESS",
+    /* 0x015E */ "OBJECT_SSH",
+    /* 0x015F */ "OBJECT_BIGOKUTA",
+    /* 0x0160 */ "OBJECT_BG",
+    /* 0x0161 */ "OBJECT_SPOT05_OBJECTS",
+    /* 0x0162 */ "OBJECT_SPOT12_OBJ",
+    /* 0x0163 */ "OBJECT_BOMBIWA",
+    /* 0x0164 */ "OBJECT_HINTNUTS",
+    /* 0x0165 */ "OBJECT_RS",
+    /* 0x0166 */ "OBJECT_SPOT00_BREAK",
+    /* 0x0167 */ "OBJECT_GLA",
+    /* 0x0168 */ "OBJECT_SHOPNUTS",
+    /* 0x0169 */ "OBJECT_GELDB",
+    /* 0x016A */ "OBJECT_GR",
+    /* 0x016B */ "OBJECT_DOG",
+    /* 0x016C */ "OBJECT_JYA_IRON",
+    /* 0x016D */ "OBJECT_JYA_DOOR",
+    /* 0x016E */ "OBJECT_UNSET_16E",
+    /* 0x016F */ "OBJECT_SPOT11_OBJ",
+    /* 0x0170 */ "OBJECT_KIBAKO2",
+    /* 0x0171 */ "OBJECT_DNS",
+    /* 0x0172 */ "OBJECT_DNK",
+    /* 0x0173 */ "OBJECT_GI_FIRE",
+    /* 0x0174 */ "OBJECT_GI_INSECT",
+    /* 0x0175 */ "OBJECT_GI_BUTTERFLY",
+    /* 0x0176 */ "OBJECT_GI_GHOST",
+    /* 0x0177 */ "OBJECT_GI_SOUL",
+    /* 0x0178 */ "OBJECT_BOWL",
+    /* 0x0179 */ "OBJECT_DEMO_KEKKAI",
+    /* 0x017A */ "OBJECT_EFC_DOUGHNUT",
+    /* 0x017B */ "OBJECT_GI_DEKUPOUCH",
+    /* 0x017C */ "OBJECT_GANON_ANIME1",
+    /* 0x017D */ "OBJECT_GANON_ANIME2",
+    /* 0x017E */ "OBJECT_GANON_ANIME3",
+    /* 0x017F */ "OBJECT_GI_RUPY",
+    /* 0x0180 */ "OBJECT_SPOT01_MATOYA",
+    /* 0x0181 */ "OBJECT_SPOT01_MATOYAB",
+    /* 0x0182 */ "OBJECT_MU",
+    /* 0x0183 */ "OBJECT_WF",
+    /* 0x0184 */ "OBJECT_SKB",
+    /* 0x0185 */ "OBJECT_GJ",
+    /* 0x0186 */ "OBJECT_GEFF",
+    /* 0x0187 */ "OBJECT_HAKA_DOOR",
+    /* 0x0188 */ "OBJECT_GS",
+    /* 0x0189 */ "OBJECT_PS",
+    /* 0x018A */ "OBJECT_BWALL",
+    /* 0x018B */ "OBJECT_COW",
+    /* 0x018C */ "OBJECT_COB",
+    /* 0x018D */ "OBJECT_GI_SWORD_1",
+    /* 0x018E */ "OBJECT_DOOR_KILLER",
+    /* 0x018F */ "OBJECT_OUKE_HAKA",
+    /* 0x0190 */ "OBJECT_TIMEBLOCK",
+    /* 0x0191 */ "OBJECT_ZL4",
 };
 \ No newline at end of file
diff --git a/ZAPD/ZRoom/ZRoom.cpp b/ZAPD/ZRoom/ZRoom.cpp
index dafc810..aa94723 100644
--- a/ZAPD/ZRoom/ZRoom.cpp
+++ b/ZAPD/ZRoom/ZRoom.cpp
@@ -66,6 +66,12 @@ ZRoom* ZRoom::ExtractFromXML(XMLElement* reader, vector<uint8_t> nRawData, int r
 
 	room->scene = nScene;
 
+	if (string(reader->Name()) == "Scene")
+	{
+		room->scene = room;
+		Globals::Instance->lastScene = room;
+	}
+
 	Globals::Instance->AddSegment(SEGMENT_ROOM);
 	Globals::Instance->AddSegment(SEGMENT_SCENE);
 
@@ -93,7 +99,7 @@ ZRoom* ZRoom::ExtractFromXML(XMLElement* reader, vector<uint8_t> nRawData, int r
 			string addressStr = child->Attribute("Offset");
 			int address = strtol(StringHelper::Split(addressStr, "0x")[1].c_str(), NULL, 16);
 
-			ZDisplayList* dList = new ZDisplayList(room->rawData, address, ZDisplayList::GetDListLength(room->rawData, address));
+			ZDisplayList* dList = new ZDisplayList(room->rawData, address, ZDisplayList::GetDListLength(room->rawData, address, Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX));
 
 			if (child->Attribute("Name") != NULL)
 				name = string(child->Attribute("Name"));
diff --git a/ZAPD/ZSkeleton.cpp b/ZAPD/ZSkeleton.cpp
index f09198f..485c5a7 100644
--- a/ZAPD/ZSkeleton.cpp
+++ b/ZAPD/ZSkeleton.cpp
@@ -1,6 +1,7 @@
 #include "ZSkeleton.h"
 #include "BitConverter.h"
 #include "StringHelper.h"
+#include "Globals.h"
 #include "HighLevel/HLModelIntermediette.h"
 #include <typeinfo>
 
@@ -170,7 +171,7 @@ std::string ZSkeleton::GetSourceOutputCode(const std::string& prefix)
 
 			if (limb->dListPtr != 0 && parent->GetDeclaration(limb->dListPtr) == nullptr)
 			{
-				ZDisplayList* dList = new ZDisplayList(rawData, limb->dListPtr, ZDisplayList::GetDListLength(rawData, limb->dListPtr));
+				ZDisplayList* dList = new ZDisplayList(rawData, limb->dListPtr, ZDisplayList::GetDListLength(rawData, limb->dListPtr, Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX));
 				dList->parent = parent;
 				dList->SetName(StringHelper::Sprintf("%sLimbDL_%06X", defaultPrefix.c_str(), limb->dListPtr));
 				dList->GetSourceOutputCode(defaultPrefix);
@@ -187,7 +188,7 @@ std::string ZSkeleton::GetSourceOutputCode(const std::string& prefix)
 
 				if (limbLOD->farDListPtr != 0 && parent->GetDeclaration(limbLOD->farDListPtr) == nullptr)
 				{
-					ZDisplayList* dList = new ZDisplayList(rawData, limbLOD->farDListPtr, ZDisplayList::GetDListLength(rawData, limbLOD->farDListPtr));
+					ZDisplayList* dList = new ZDisplayList(rawData, limbLOD->farDListPtr, ZDisplayList::GetDListLength(rawData, limbLOD->farDListPtr, Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX));
 					dList->parent = parent;
 					dList->SetName(StringHelper::Sprintf("%s_farLimbDlist_%06X", defaultPrefix.c_str(), limbLOD->farDListPtr));
 					dList->GetSourceOutputCode(defaultPrefix);
author	Nicholas Estelami <NEstelami@users.noreply.github.com>	2021-01-23 14:23:51 -0500
committer	GitHub <noreply@github.com>	2021-01-23 14:23:51 -0500
commit	ee42172389c0aebfbc0c2d5bbabab4ec858bc8cd (patch)
tree	3c6afd903bb9983602f6f79a1333106fe2306745 /ZAPD
parent	2e1174063f3ed6bcf929bc7093cd2d1b05f8518b (diff)