From ac684b6c6b64d093b65069d2692c38b42fbdc0c1 Mon Sep 17 00:00:00 2001
From: megazig <megazig@megazig-desktop.(none)>
Date: Sun, 20 Sep 2009 14:16:12 -0500
Subject: added lots of cleanup and changed vtx to color pieces and cleaned up
 main

---
 brlyt.c | 4775 ++++++++++++++++++++++++++++++++-------------------------------
 1 file changed, 2406 insertions(+), 2369 deletions(-)

(limited to 'brlyt.c')

diff --git a/brlyt.c b/brlyt.c
index b7b3758..6a6fdb9 100644
--- a/brlyt.c
+++ b/brlyt.c
@@ -18,12 +18,12 @@
 #include "endian.h"
 
 #ifdef DEBUGBRLYT
-#define dbgprintf    printf
+#define dbgprintf	printf
 #else
-#define dbgprintf    //
+#define dbgprintf	//
 #endif //DEBUGBRLYT
 
-#define MAXIMUM_TAGS_SIZE        (0x1000)
+#define MAXIMUM_TAGS_SIZE		(0x1000)
 
 char pic1_magic[] = "pic1";
 char pan1_magic[] = "pan1";
@@ -51,124 +51,124 @@ int lengthOfTextures;
 
 static int FourCCsMatch(fourcc cc1, fourcc cc2)
 {
-    int ret[4];
-    ret[0] = (cc1[0] == cc2[0]);
-    ret[1] = (cc1[1] == cc2[1]);
-    ret[2] = (cc1[2] == cc2[2]);
-    ret[3] = (cc1[3] == cc2[3]);
-    int retval;
-    if(ret[0] && ret[1] && ret[2] && ret[3])
-        retval = 1;
-    else
-        retval = 0;
-    return retval;
+	int ret[4];
+	ret[0] = (cc1[0] == cc2[0]);
+	ret[1] = (cc1[1] == cc2[1]);
+	ret[2] = (cc1[2] == cc2[2]);
+	ret[3] = (cc1[3] == cc2[3]);
+	int retval;
+	if(ret[0] && ret[1] && ret[2] && ret[3])
+		retval = 1;
+	else
+		retval = 0;
+	return retval;
 }
 
 static void BRLYT_ReadDataFromMemoryX(void* destination, void* input, size_t size)
 {
-    u8* out = (u8*)destination;
-    u8* in = ((u8*)input) + BRLYT_fileoffset;
-    memcpy(out, in, size);
+	u8* out = (u8*)destination;
+	u8* in = ((u8*)input) + BRLYT_fileoffset;
+	memcpy(out, in, size);
 }
 
 static void BRLYT_ReadDataFromMemory(void* destination, void* input, size_t size)
 {
-    BRLYT_ReadDataFromMemoryX(destination, input, size);
-    BRLYT_fileoffset += size;
+	BRLYT_ReadDataFromMemoryX(destination, input, size);
+	BRLYT_fileoffset += size;
 }
 
 float float_swap_bytes(float float1)
 {
-    u8 *float1c; float1c = (u8*)&float1;
+	u8 *float1c; float1c = (u8*)&float1;
 
-    u8 charTemp = 0x00;
-    charTemp = float1c[0]; float1c[0] = float1c[3]; float1c[3] = charTemp;
-    charTemp = 0x00;
-    charTemp = float1c[1]; float1c[1] = float1c[2]; float1c[2] = charTemp;
+	u8 charTemp = 0x00;
+	charTemp = float1c[0]; float1c[0] = float1c[3]; float1c[3] = charTemp;
+	charTemp = 0x00;
+	charTemp = float1c[1]; float1c[1] = float1c[2]; float1c[2] = charTemp;
 
-    float *newFloat; newFloat = (float*)float1c;
-    return *newFloat;
+	float *newFloat; newFloat = (float*)float1c;
+	return *newFloat;
 }
 
 u32 bit_extract(u32 num, u32 start, u32 end)
 {
-    if (end == 100) end = start;
-    u32 mask;
-    int first;
-    int firstMask = 1;
-    for (first=0;first<31-start+1;first++)
-    {
-        firstMask *= 2;
-    }
-    firstMask -= 1;
-    int secondMask = 1;
-
-    for (first=0;first< 31-end;first++)
-    {
-        secondMask *=2;
-    }
-    secondMask -= 1;
-    mask = firstMask - secondMask;
-    int ret = (num & mask) >> (31 - end);
-    return ret;
+	if (end == 100) end = start;
+	u32 mask;
+	int first;
+	int firstMask = 1;
+	for (first=0;first<31-start+1;first++)
+	{
+		firstMask *= 2;
+	}
+	firstMask -= 1;
+	int secondMask = 1;
+
+	for (first=0;first< 31-end;first++)
+	{
+		secondMask *=2;
+	}
+	secondMask -= 1;
+	mask = firstMask - secondMask;
+	int ret = (num & mask) >> (31 - end);
+	return ret;
 }
 
 char* getMaterial(u16 offset)
 {
 
-    if (offset == 0) return materials;
-    char *mat = materials + strlen(materials) + 1;
+	if (offset == 0) return materials;
+	char *mat = materials + strlen(materials) + 1;
 
-    if (offset > 1)
-    {
-        int n;
-        for (n=1; n<offset;n++)
-            mat = mat + strlen(mat) + 1;
-    }
-    return mat;
+	if (offset > 1)
+	{
+		int n;
+		for (n=1; n<offset;n++)
+			mat = mat + strlen(mat) + 1;
+	}
+	return mat;
 }
 
 char* getTexture(u16 offset)
 {
 
-    if (offset == 0) return textures;
-    char *tex = textures + strlen(textures) + 1;
+	if (offset == 0) return textures;
+	char *tex = textures + strlen(textures) + 1;
 
-    if (offset > 1)
-    {
-        int n;
-        for (n=1; n<offset;n++)
-            tex = tex + strlen(tex) + 1;
-    }
-    return tex;
+	if (offset > 1)
+	{
+		int n;
+		for (n=1; n<offset;n++)
+			tex = tex + strlen(tex) + 1;
+	}
+	return tex;
 }
 
 u16 findMatOffset(char *mats)
 {
-    int isEqual = 1;
-    char* mat = materials;
-    int i;
-    for (i = 0; isEqual != 0; )
-    {
-        isEqual = strcmp(mats, mat);
-        if (isEqual != 0) i++;
-        mat = mat + strlen(mat) + 1;
-    }
-    return i;
+	int isEqual = 1;
+	char* mat = materials;
+	int i;
+	for (i = 0; isEqual != 0; )
+	{
+		isEqual = strcmp(mats, mat);
+		if (isEqual != 0) i++;
+		mat = mat + strlen(mat) + 1;
+	}
+	return i;
 }
 
 u16 findTexOffset(char *tex)
 {
-    int isEqual = 1;
-    char* texs = textures;
-    int i;
-    for (i = 0; isEqual != 0; )
-    {
-        isEqual = strcmp(tex, texs);
-        if (isEqual != 0) i++;
-        texs = texs + strlen(texs) + 1;
-    }
-    return i;
+	int isEqual = 1;
+	char* texs = textures;
+	int i;
+	for (i = 0; isEqual != 0; )
+	{
+		isEqual = strcmp(tex, texs);
+		if (isEqual != 0) i++;
+		texs = texs + strlen(texs) + 1;
+	}
+	return i;
 }
 
 int BRLYT_ReadEntries(u8* brlyt_file, size_t file_size, brlyt_header header, brlyt_entry* entries)
@@ -178,128 +178,128 @@ int BRLYT_ReadEntries(u8* brlyt_file, size_t file_size, brlyt_header header, brl
 
 void BRLYT_CheckHeaderSanity(brlyt_header header, size_t filesize)
 {
-    if((header.magic[0] != 'R') || (header.magic[1] != 'L') || (header.magic[2] != 'Y') || (header.magic[3] != 'T')) {
-        printf("BRLYT magic doesn't match! %.4s\n", header.magic);
+	if((header.magic[0] != 'R') || (header.magic[1] != 'L') || (header.magic[2] != 'Y') || (header.magic[3] != 'T')) {
+		printf("BRLYT magic doesn't match! %.4s\n", header.magic);
 		printf("magic: %.4s\n", header.magic);
-        exit(1);
-    }
+		exit(1);
+	}
 	if(header.version != be32(0xfeff0008) ){
 		printf("BRLYT version not right\n");
 		printf("version: %08x\n", be32(header.version) );
 		exit(1);
 	}
-    if(filesize != be32(header.filesize)) {
-        printf("BRLYT filesize doesn't match!\n");
-        exit(1);
-    }
+	if(filesize != be32(header.filesize)) {
+		printf("BRLYT filesize doesn't match!\n");
+		exit(1);
+	}
 }
 
 void PrintBRLYTEntry_lyt1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 {
-    mxml_node_t *a;
-    mxml_node_t *size;
-    mxml_node_t *width;
-    mxml_node_t *height;
-    brlyt_lytheader_chunk data;
-    BRLYT_fileoffset = entry.data_location;
-    BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_lytheader_chunk));
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
-    a = mxmlNewElement(tag, "drawnFromMiddle"); mxmlNewTextf(a, 0, "%02x", data.drawnFromMiddle);
-    size = mxmlNewElement(tag, "size");
-    width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%f", float_swap_bytes(data.width));
-    height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0,"%f", float_swap_bytes(data.height));
+	mxml_node_t *a;
+	mxml_node_t *size;
+	mxml_node_t *width;
+	mxml_node_t *height;
+	brlyt_lytheader_chunk data;
+	BRLYT_fileoffset = entry.data_location;
+	BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_lytheader_chunk));
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	a = mxmlNewElement(tag, "drawnFromMiddle"); mxmlNewTextf(a, 0, "%02x", data.drawnFromMiddle);
+	size = mxmlNewElement(tag, "size");
+	width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%f", float_swap_bytes(data.width));
+	height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0,"%f", float_swap_bytes(data.height));
 }
 
 void PrintBRLYTEntry_grp1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 {
-    mxml_node_t *subs, *sub;
-    brlyt_group_chunk data;
-    BRLYT_fileoffset = entry.data_location;
-    BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_group_chunk));
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
-    mxmlElementSetAttrf(tag, "name", "%s", data.name);
-
-    if (short_swap_bytes(data.numsubs) > 0) subs = mxmlNewElement(tag, "subs");
-
-    int n;
-    for (n=0;n<short_swap_bytes(data.numsubs);n++)
-    {
-        char subb[16];
-	memset(subb, 0x00, 16);
-        BRLYT_ReadDataFromMemory(subb, brlyt_file, sizeof(subb));
-        sub = mxmlNewElement(subs, "sub"); mxmlNewTextf(sub, 0, "%.16s", subb);
-    }
+	mxml_node_t *subs, *sub;
+	brlyt_group_chunk data;
+	BRLYT_fileoffset = entry.data_location;
+	BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_group_chunk));
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	mxmlElementSetAttrf(tag, "name", "%s", data.name);
+
+	if (short_swap_bytes(data.numsubs) > 0) subs = mxmlNewElement(tag, "subs");
+
+	int i;
+	for (i=0;i<short_swap_bytes(data.numsubs);i++)
+	{
+		char subb[16];
+		memset(subb, 0x00, 16);
+		BRLYT_ReadDataFromMemory(subb, brlyt_file, sizeof(subb));
+		sub = mxmlNewElement(subs, "sub"); mxmlNewTextf(sub, 0, "%.16s", subb);
+	}
 }
 
 void PrintBRLYTEntry_txl1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 {
-    mxml_node_t *entries;
-    mxml_node_t *naame;
-    brlyt_numoffs_chunk data;
-    BRLYT_fileoffset = entry.data_location;
-    BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_numoffs_chunk));
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
-    entries = mxmlNewElement(tag, "entries");
-    int pos = 4;
-    pos += data.offs;
-    int bpos = pos;
-    int n;
-    for (n=0;n<short_swap_bytes(data.num);n++)
-    {
-        brlyt_offsunk_chunk data2;
-        BRLYT_ReadDataFromMemory(&data2, brlyt_file, sizeof(brlyt_offsunk_chunk));
-        int tempLocation = BRLYT_fileoffset;
-        BRLYT_fileoffset = entry.data_location + bpos + be32(data2.offset);
-        int toRead = (be32(entry.length) + entry.data_location - 8) - BRLYT_fileoffset;
-        char nameRead[toRead];
-        BRLYT_ReadDataFromMemory(nameRead, brlyt_file, sizeof(nameRead));
-
-        char tpl = 0;
-        char *ending = memchr(nameRead, tpl, toRead);
-        int end = ending - nameRead;
-        char name[end+1];
-        memcpy(name, nameRead, sizeof(name));
-        naame = mxmlNewElement(entries, "name"); mxmlNewTextf(naame, 0, "%s", name);
-        BRLYT_fileoffset = tempLocation;
-        int newSize = lengthOfTextures+sizeof(name);
-        textures = realloc(textures, newSize);
-        numberOfTextures += 1;
-        memcpy(textures+lengthOfTextures, name, sizeof(name));
-        lengthOfTextures = newSize;
-    }
+	mxml_node_t *entries;
+	mxml_node_t *naame;
+	brlyt_numoffs_chunk data;
+	BRLYT_fileoffset = entry.data_location;
+	BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_numoffs_chunk));
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	entries = mxmlNewElement(tag, "entries");
+	int pos = 4;
+	pos += data.offs;
+	int bpos = pos;
+	int n;
+	for (n=0;n<short_swap_bytes(data.num);n++)
+	{
+		brlyt_offsunk_chunk data2;
+		BRLYT_ReadDataFromMemory(&data2, brlyt_file, sizeof(brlyt_offsunk_chunk));
+		int tempLocation = BRLYT_fileoffset;
+		BRLYT_fileoffset = entry.data_location + bpos + be32(data2.offset);
+		int toRead = (be32(entry.length) + entry.data_location - 8) - BRLYT_fileoffset;
+		char nameRead[toRead];
+		BRLYT_ReadDataFromMemory(nameRead, brlyt_file, sizeof(nameRead));
+
+		char tpl = 0;
+		char *ending = memchr(nameRead, tpl, toRead);
+		int end = ending - nameRead;
+		char name[end+1];
+		memcpy(name, nameRead, sizeof(name));
+		naame = mxmlNewElement(entries, "name"); mxmlNewTextf(naame, 0, "%s", name);
+		BRLYT_fileoffset = tempLocation;
+		int newSize = lengthOfTextures+sizeof(name);
+		textures = realloc(textures, newSize);
+		numberOfTextures += 1;
+		memcpy(textures+lengthOfTextures, name, sizeof(name));
+		lengthOfTextures = newSize;
+	}
 }
 
 void PrintBRLYTEntry_fnl1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 {
-    mxml_node_t *entries;
-    mxml_node_t *naame;
-    brlyt_numoffs_chunk data;
-    BRLYT_fileoffset = entry.data_location;
-    BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_numoffs_chunk));
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
-    entries = mxmlNewElement(tag, "entries");
-    int pos = 4;
-    pos += data.offs;
-    int bpos = pos;
-    int n;
-    for (n=0;n<short_swap_bytes(data.num);n++)
-    {
-        brlyt_offsunk_chunk data2;
-        BRLYT_ReadDataFromMemory(&data2, brlyt_file, sizeof(brlyt_offsunk_chunk));
-        int tempLocation = BRLYT_fileoffset;
-        BRLYT_fileoffset = entry.data_location + bpos + be32(data2.offset);
-        int toRead = (be32(entry.length) + entry.data_location - 8) - BRLYT_fileoffset;
-        char nameRead[toRead];
-        BRLYT_ReadDataFromMemory(nameRead, brlyt_file, sizeof(nameRead));
-
-        char tpl = 0;
-        char *ending = memchr(nameRead, tpl, toRead);
-        int end = ending - nameRead;
-        char name[end+1];
-        memcpy(name, nameRead, sizeof(name));
-        naame = mxmlNewElement(entries, "name"); mxmlNewTextf(naame, 0, "%s", name);
-        BRLYT_fileoffset = tempLocation;
-    }
+	mxml_node_t *entries;
+	mxml_node_t *naame;
+	brlyt_numoffs_chunk data;
+	BRLYT_fileoffset = entry.data_location;
+	BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_numoffs_chunk));
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	entries = mxmlNewElement(tag, "entries");
+	int pos = 4;
+	pos += data.offs;
+	int bpos = pos;
+	int n;
+	for (n=0;n<short_swap_bytes(data.num);n++)
+	{
+		brlyt_offsunk_chunk data2;
+		BRLYT_ReadDataFromMemory(&data2, brlyt_file, sizeof(brlyt_offsunk_chunk));
+		int tempLocation = BRLYT_fileoffset;
+		BRLYT_fileoffset = entry.data_location + bpos + be32(data2.offset);
+		int toRead = (be32(entry.length) + entry.data_location - 8) - BRLYT_fileoffset;
+		char nameRead[toRead];
+		BRLYT_ReadDataFromMemory(nameRead, brlyt_file, sizeof(nameRead));
+
+		char tpl = 0;
+		char *ending = memchr(nameRead, tpl, toRead);
+		int end = ending - nameRead;
+		char name[end+1];
+		memcpy(name, nameRead, sizeof(name));
+		naame = mxmlNewElement(entries, "name"); mxmlNewTextf(naame, 0, "%s", name);
+		BRLYT_fileoffset = tempLocation;
+	}
 }
 
 void PrintBRLYTEntry_pan1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
@@ -316,36 +316,36 @@ void PrintBRLYTEntry_pan1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 	strcpy( origins[7] , "BOTTOM CENTER" );
 	strcpy( origins[8] , "BOTTOM RIGHT" );
 
-    mxml_node_t *flags, *origin, *alpha, *padding;
-    mxml_node_t *translate, *x, *y, *z;
-    mxml_node_t *rotate, *scale;
-    mxml_node_t *size, *width, *height;
-    brlyt_pane_chunk data;
-    BRLYT_fileoffset = entry.data_location;
-    BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pane_chunk));
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
-    mxmlElementSetAttrf(tag, "name", "%s", data.name);
-    mxmlElementSetAttrf(tag, "userdata", "%s", data.userdata);
-    flags = mxmlNewElement(tag, "visible"); mxmlNewTextf(flags, 0, "%02x", data.flag1 & 0x1);
-    flags = mxmlNewElement(tag, "WidescreenAffected"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x2)>>1);
-    flags = mxmlNewElement(tag, "flag"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x4)>>2);
+	mxml_node_t *flags, *origin, *alpha, *padding;
+	mxml_node_t *translate, *x, *y, *z;
+	mxml_node_t *rotate, *scale;
+	mxml_node_t *size, *width, *height;
+	brlyt_pane_chunk data;
+	BRLYT_fileoffset = entry.data_location;
+	BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pane_chunk));
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	mxmlElementSetAttrf(tag, "name", "%s", data.name);
+	mxmlElementSetAttrf(tag, "userdata", "%s", data.userdata);
+	flags = mxmlNewElement(tag, "visible"); mxmlNewTextf(flags, 0, "%02x", data.flag1 & 0x1);
+	flags = mxmlNewElement(tag, "WidescreenAffected"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x2)>>1);
+	flags = mxmlNewElement(tag, "flag"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x4)>>2);
 	origin  = mxmlNewElement(tag, "origin");  mxmlNewTextf(origin,0,"%s",origins[data.origin%9]);
-    alpha   = mxmlNewElement(tag, "alpha");   mxmlNewTextf(alpha, 0, "%02x", data.alpha);
+	alpha   = mxmlNewElement(tag, "alpha");   mxmlNewTextf(alpha, 0, "%02x", data.alpha);
 	padding = mxmlNewElement(tag, "padding"); mxmlNewTextf(padding, 0, "%02x", data.pad);
-    translate = mxmlNewElement(tag, "translate");
-    x = mxmlNewElement(translate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XTrans));
-    y = mxmlNewElement(translate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YTrans));
-    z = mxmlNewElement(translate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZTrans));
-    rotate = mxmlNewElement(tag, "rotate");
+	translate = mxmlNewElement(tag, "translate");
+	x = mxmlNewElement(translate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XTrans));
+	y = mxmlNewElement(translate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YTrans));
+	z = mxmlNewElement(translate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZTrans));
+	rotate = mxmlNewElement(tag, "rotate");
 	x = mxmlNewElement(rotate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XRotate));
 	y = mxmlNewElement(rotate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YRotate));
 	z = mxmlNewElement(rotate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZRotate));
-    scale = mxmlNewElement(tag, "scale");
-    x = mxmlNewElement(scale, "x"); mxmlNewTextf(x, 0, "%.10f", float_swap_bytes(data.XScale));
-    y = mxmlNewElement(scale, "y"); mxmlNewTextf(y, 0, "%.10f", float_swap_bytes(data.YScale));
-    size = mxmlNewElement(tag, "size");
-    width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%f", float_swap_bytes(data.width));
-    height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0, "%f", float_swap_bytes(data.height));
+	scale = mxmlNewElement(tag, "scale");
+	x = mxmlNewElement(scale, "x"); mxmlNewTextf(x, 0, "%.10f", float_swap_bytes(data.XScale));
+	y = mxmlNewElement(scale, "y"); mxmlNewTextf(y, 0, "%.10f", float_swap_bytes(data.YScale));
+	size = mxmlNewElement(tag, "size");
+	width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%f", float_swap_bytes(data.width));
+	height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0, "%f", float_swap_bytes(data.height));
 }
 
 void PrintBRLYTEntry_wnd1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
@@ -362,64 +362,64 @@ void PrintBRLYTEntry_wnd1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 	strcpy( origins[7] , "BOTTOM CENTER" );
 	strcpy( origins[8] , "BOTTOM RIGHT" );
 
-    mxml_node_t *flags, *origin, *alpha, *padding;
-    mxml_node_t *translate, *x, *y, *z;
-    mxml_node_t *rotate, *scale;
-    mxml_node_t *size, *width, *height;
-    brlyt_pane_chunk data;
-    BRLYT_fileoffset = entry.data_location;
-    BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pane_chunk));
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
-    mxmlElementSetAttrf(tag, "name", "%s", data.name);
-    mxmlElementSetAttrf(tag, "userdata", "%s", data.userdata);
-    flags = mxmlNewElement(tag, "visible"); mxmlNewTextf(flags, 0, "%02x", data.flag1 & 0x1);
-    flags = mxmlNewElement(tag, "WidescreenAffected"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x2)>>1);
-    flags = mxmlNewElement(tag, "flag"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x4)>>2);
+	mxml_node_t *flags, *origin, *alpha, *padding;
+	mxml_node_t *translate, *x, *y, *z;
+	mxml_node_t *rotate, *scale;
+	mxml_node_t *size, *width, *height;
+	brlyt_pane_chunk data;
+	BRLYT_fileoffset = entry.data_location;
+	BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pane_chunk));
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	mxmlElementSetAttrf(tag, "name", "%s", data.name);
+	mxmlElementSetAttrf(tag, "userdata", "%s", data.userdata);
+	flags = mxmlNewElement(tag, "visible"); mxmlNewTextf(flags, 0, "%02x", data.flag1 & 0x1);
+	flags = mxmlNewElement(tag, "WidescreenAffected"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x2)>>1);
+	flags = mxmlNewElement(tag, "flag"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x4)>>2);
 	origin  = mxmlNewElement(tag, "origin"); mxmlNewTextf(origin,0,"%s", origins[data.origin%9]);
-    alpha   = mxmlNewElement(tag, "alpha");   mxmlNewTextf(alpha, 0, "%02x", data.alpha);
+	alpha   = mxmlNewElement(tag, "alpha");   mxmlNewTextf(alpha, 0, "%02x", data.alpha);
 	padding = mxmlNewElement(tag, "padding"); mxmlNewTextf(padding, 0, "%02x", data.pad);
-    translate = mxmlNewElement(tag, "translate");
-    x = mxmlNewElement(translate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XTrans));
-    y = mxmlNewElement(translate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YTrans));
-    z = mxmlNewElement(translate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZTrans));
-    rotate = mxmlNewElement(tag, "rotate");
-    x = mxmlNewElement(rotate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XRotate));
-    y = mxmlNewElement(rotate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YRotate));
-    z = mxmlNewElement(rotate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZRotate));
-    scale = mxmlNewElement(tag, "scale");
-    x = mxmlNewElement(scale, "x"); mxmlNewTextf(x, 0, "%.10f", float_swap_bytes(data.XScale));
-    y = mxmlNewElement(scale, "y"); mxmlNewTextf(y, 0, "%.10f", float_swap_bytes(data.YScale));
-    size = mxmlNewElement(tag, "size");
-    width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%f", float_swap_bytes(data.width));
-    height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0, "%f", float_swap_bytes(data.height));
-
-    mxml_node_t *wndd, *unkk, *count, *offset1, *offset2;
-    int i, j;
-    brlyt_wnd wndy;
-    BRLYT_ReadDataFromMemory(&wndy, brlyt_file, sizeof(brlyt_wnd));
-    wndd = mxmlNewElement(tag, "wnd");
-    for(i=0;i<4;i++)
-    {
-        unkk = mxmlNewElement(wndd, "coordinate"); mxmlNewTextf(unkk, 0, "%f", float_swap_bytes(wndy.coords[i]));
-    }
-    count = mxmlNewElement(wndd, "FrameCount"); mxmlNewTextf(count, 0, "%02x", wndy.frame_count);
-    offset1 = mxmlNewElement(wndd, "offset1"); mxmlNewTextf(offset1, 0, "%08x", be32(wndy.offset1));
-    offset2 = mxmlNewElement(wndd, "offset2"); mxmlNewTextf(offset2, 0, "%08x", be32(wndy.offset2));
-
-    mxml_node_t *wnddd, *colors, *material;
-    brlyt_wnd1 wndy1;
-    BRLYT_ReadDataFromMemory(&wndy1, brlyt_file, sizeof(brlyt_wnd1));
-    wnddd = mxmlNewElement(tag, "wnd1");
-    for(i=0;i<4;i++)
-    {
-        colors = mxmlNewElement(wnddd, "color"); mxmlNewTextf(colors, 0, "%08x", int_swap_bytes(wndy1.colors[i]));
-    }
-
-    material = mxmlNewElement(wnddd, "material"); mxmlNewTextf(material, 0, "%04x", short_swap_bytes(wndy1.material));
-    count = mxmlNewElement(wnddd, "CoordinateCount"); mxmlNewTextf(count, 0, "%02x", short_swap_bytes(wndy1.coordinate_count));
-    padding = mxmlNewElement(wnddd, "padding"); mxmlNewTextf(padding, 0, "%02x", short_swap_bytes(wndy1.padding));
-
-    mxml_node_t *wnddddd, *texcoord;
+	translate = mxmlNewElement(tag, "translate");
+	x = mxmlNewElement(translate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XTrans));
+	y = mxmlNewElement(translate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YTrans));
+	z = mxmlNewElement(translate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZTrans));
+	rotate = mxmlNewElement(tag, "rotate");
+	x = mxmlNewElement(rotate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XRotate));
+	y = mxmlNewElement(rotate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YRotate));
+	z = mxmlNewElement(rotate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZRotate));
+	scale = mxmlNewElement(tag, "scale");
+	x = mxmlNewElement(scale, "x"); mxmlNewTextf(x, 0, "%.10f", float_swap_bytes(data.XScale));
+	y = mxmlNewElement(scale, "y"); mxmlNewTextf(y, 0, "%.10f", float_swap_bytes(data.YScale));
+	size = mxmlNewElement(tag, "size");
+	width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%f", float_swap_bytes(data.width));
+	height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0, "%f", float_swap_bytes(data.height));
+
+	mxml_node_t *wndd, *unkk, *count, *offset1, *offset2;
+	int i, j;
+	brlyt_wnd wndy;
+	BRLYT_ReadDataFromMemory(&wndy, brlyt_file, sizeof(brlyt_wnd));
+	wndd = mxmlNewElement(tag, "wnd");
+	for(i=0;i<4;i++)
+	{
+		unkk = mxmlNewElement(wndd, "coordinate"); mxmlNewTextf(unkk, 0, "%f", float_swap_bytes(wndy.coords[i]));
+	}
+	count = mxmlNewElement(wndd, "FrameCount"); mxmlNewTextf(count, 0, "%02x", wndy.frame_count);
+	offset1 = mxmlNewElement(wndd, "offset1"); mxmlNewTextf(offset1, 0, "%08x", be32(wndy.offset1));
+	offset2 = mxmlNewElement(wndd, "offset2"); mxmlNewTextf(offset2, 0, "%08x", be32(wndy.offset2));
+
+	mxml_node_t *wnddd, *colors, *material;
+	brlyt_wnd1 wndy1;
+	BRLYT_ReadDataFromMemory(&wndy1, brlyt_file, sizeof(brlyt_wnd1));
+	wnddd = mxmlNewElement(tag, "wnd1");
+	for(i=0;i<4;i++)
+	{
+		colors = mxmlNewElement(wnddd, "color"); mxmlNewTextf(colors, 0, "%08x", int_swap_bytes(wndy1.colors[i]));
+	}
+
+	material = mxmlNewElement(wnddd, "material"); mxmlNewTextf(material, 0, "%04x", short_swap_bytes(wndy1.material));
+	count = mxmlNewElement(wnddd, "CoordinateCount"); mxmlNewTextf(count, 0, "%02x", short_swap_bytes(wndy1.coordinate_count));
+	padding = mxmlNewElement(wnddd, "padding"); mxmlNewTextf(padding, 0, "%02x", short_swap_bytes(wndy1.padding));
+
+	mxml_node_t *wnddddd, *texcoord;
 	for ( i = 0 ; i < wndy1.coordinate_count ; i++ ){
 		brlyt_wnd3 wndy3;
 		BRLYT_ReadDataFromMemory(&wndy3, brlyt_file, sizeof(brlyt_wnd3));
@@ -430,25 +430,25 @@ void PrintBRLYTEntry_wnd1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 
 	}
 
-    mxml_node_t *wndddddd, *offsett;
-    brlyt_wnd4 wndy4;
-    for(i=0;i<wndy.frame_count;i++)
-    {
-        BRLYT_ReadDataFromMemory(&wndy4, brlyt_file, sizeof(brlyt_wnd4));
-        wndddddd = mxmlNewElement(tag, "wnd4");
-        offsett = mxmlNewElement(wndddddd, "offset"); mxmlNewTextf(offsett, 0, "%08x", be32(wndy4.offset));
-    }
-
-    mxml_node_t *wndmat, *matrl;
-    brlyt_wnd4_mat wndy4mat;
-    for(i=0;i<wndy.frame_count;i++)
-    {
-        BRLYT_ReadDataFromMemory(&wndy4mat, brlyt_file, sizeof(brlyt_wnd4_mat));
-        wndmat = mxmlNewElement(tag, "wnd4mat");
-        matrl = mxmlNewElement(wndmat, "material"); mxmlNewTextf(matrl, 0, "%04x", be16(wndy4mat.material));
-        matrl = mxmlNewElement(wndmat, "index"); mxmlNewTextf(matrl, 0, "%02x", wndy4mat.index);
-        matrl = mxmlNewElement(wndmat, "padding"); mxmlNewTextf(matrl, 0, "%02x", wndy4mat.padding);
-    }
+	mxml_node_t *wndddddd, *offsett;
+	brlyt_wnd4 wndy4;
+	for(i=0;i<wndy.frame_count;i++)
+	{
+		BRLYT_ReadDataFromMemory(&wndy4, brlyt_file, sizeof(brlyt_wnd4));
+		wndddddd = mxmlNewElement(tag, "wnd4");
+		offsett = mxmlNewElement(wndddddd, "offset"); mxmlNewTextf(offsett, 0, "%08x", be32(wndy4.offset));
+	}
+
+	mxml_node_t *wndmat, *matrl;
+	brlyt_wnd4_mat wndy4mat;
+	for(i=0;i<wndy.frame_count;i++)
+	{
+		BRLYT_ReadDataFromMemory(&wndy4mat, brlyt_file, sizeof(brlyt_wnd4_mat));
+		wndmat = mxmlNewElement(tag, "wnd4mat");
+		matrl = mxmlNewElement(wndmat, "material"); mxmlNewTextf(matrl, 0, "%04x", be16(wndy4mat.material));
+		matrl = mxmlNewElement(wndmat, "index"); mxmlNewTextf(matrl, 0, "%02x", wndy4mat.index);
+		matrl = mxmlNewElement(wndmat, "padding"); mxmlNewTextf(matrl, 0, "%02x", wndy4mat.padding);
+	}
 }
 
 void PrintBRLYTEntry_bnd1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
@@ -465,36 +465,36 @@ void PrintBRLYTEntry_bnd1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 	strcpy( origins[7] , "BOTTOM CENTER" );
 	strcpy( origins[8] , "BOTTOM RIGHT" );
 
-    mxml_node_t *flags, *origin, *alpha, *padding;
-    mxml_node_t *translate, *x, *y, *z;
-    mxml_node_t *rotate, *scale;
-    mxml_node_t *size, *width, *height;
-    brlyt_pane_chunk data;
-    BRLYT_fileoffset = entry.data_location;
-    BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pane_chunk));
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
-    mxmlElementSetAttrf(tag, "name", "%s", data.name);
-    mxmlElementSetAttrf(tag, "userdata", "%s", data.userdata);
-    flags = mxmlNewElement(tag, "visible"); mxmlNewTextf(flags, 0, "%02x", data.flag1 & 0x1);
-    flags = mxmlNewElement(tag, "WidescreenAffected"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x2)>>1);
-    flags = mxmlNewElement(tag, "flag"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x4)>>2);
+	mxml_node_t *flags, *origin, *alpha, *padding;
+	mxml_node_t *translate, *x, *y, *z;
+	mxml_node_t *rotate, *scale;
+	mxml_node_t *size, *width, *height;
+	brlyt_pane_chunk data;
+	BRLYT_fileoffset = entry.data_location;
+	BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pane_chunk));
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	mxmlElementSetAttrf(tag, "name", "%s", data.name);
+	mxmlElementSetAttrf(tag, "userdata", "%s", data.userdata);
+	flags = mxmlNewElement(tag, "visible"); mxmlNewTextf(flags, 0, "%02x", data.flag1 & 0x1);
+	flags = mxmlNewElement(tag, "WidescreenAffected"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x2)>>1);
+	flags = mxmlNewElement(tag, "flag"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x4)>>2);
 	origin  = mxmlNewElement(tag, "origin"); mxmlNewTextf(origin,0,"%s", origins[data.origin%9]);
-    alpha   = mxmlNewElement(tag, "alpha");   mxmlNewTextf(alpha, 0, "%02x", data.alpha);
+	alpha   = mxmlNewElement(tag, "alpha");   mxmlNewTextf(alpha, 0, "%02x", data.alpha);
 	padding = mxmlNewElement(tag, "padding"); mxmlNewTextf(padding, 0, "%02x", data.pad);
-    translate = mxmlNewElement(tag, "translate");
-    x = mxmlNewElement(translate, "x"); mxmlNewTextf(x, 0, "%.25f", float_swap_bytes(data.XTrans));
-    y = mxmlNewElement(translate, "y"); mxmlNewTextf(y, 0, "%.25f", float_swap_bytes(data.YTrans));
-    z = mxmlNewElement(translate, "z"); mxmlNewTextf(z, 0, "%.25f", float_swap_bytes(data.ZTrans));
-    rotate = mxmlNewElement(tag, "rotate");
-    x = mxmlNewElement(rotate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XRotate));
-    y = mxmlNewElement(rotate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YRotate));
-    z = mxmlNewElement(rotate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZRotate));
-    scale = mxmlNewElement(tag, "scale");
-    x = mxmlNewElement(scale, "x"); mxmlNewTextf(x, 0, "%.10f", float_swap_bytes(data.XScale));
-    y = mxmlNewElement(scale, "y"); mxmlNewTextf(y, 0, "%.10f", float_swap_bytes(data.YScale));
-    size = mxmlNewElement(tag, "size");
-    width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%f", float_swap_bytes(data.width));
-    height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0, "%f", float_swap_bytes(data.height));
+	translate = mxmlNewElement(tag, "translate");
+	x = mxmlNewElement(translate, "x"); mxmlNewTextf(x, 0, "%.25f", float_swap_bytes(data.XTrans));
+	y = mxmlNewElement(translate, "y"); mxmlNewTextf(y, 0, "%.25f", float_swap_bytes(data.YTrans));
+	z = mxmlNewElement(translate, "z"); mxmlNewTextf(z, 0, "%.25f", float_swap_bytes(data.ZTrans));
+	rotate = mxmlNewElement(tag, "rotate");
+	x = mxmlNewElement(rotate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XRotate));
+	y = mxmlNewElement(rotate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YRotate));
+	z = mxmlNewElement(rotate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZRotate));
+	scale = mxmlNewElement(tag, "scale");
+	x = mxmlNewElement(scale, "x"); mxmlNewTextf(x, 0, "%.10f", float_swap_bytes(data.XScale));
+	y = mxmlNewElement(scale, "y"); mxmlNewTextf(y, 0, "%.10f", float_swap_bytes(data.YScale));
+	size = mxmlNewElement(tag, "size");
+	width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%f", float_swap_bytes(data.width));
+	height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0, "%f", float_swap_bytes(data.height));
 }
 
 void PrintBRLYTEntry_pic1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
@@ -511,58 +511,67 @@ void PrintBRLYTEntry_pic1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 	strcpy( origins[7] , "BOTTOM CENTER" );
 	strcpy( origins[8] , "BOTTOM RIGHT" );
 
-    mxml_node_t *flags, *origin, *alpha, *padding;
-    mxml_node_t *translate, *x, *y, *z;
-    mxml_node_t *rotate, *scale;
-    mxml_node_t *size, *width, *height;
-    brlyt_pane_chunk data;
-    BRLYT_fileoffset = entry.data_location;
-    BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pane_chunk));
-    brlyt_pic_chunk data2;
-    BRLYT_ReadDataFromMemory(&data2, brlyt_file, sizeof(brlyt_pic_chunk));
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
-    mxmlElementSetAttrf(tag, "name", "%s", data.name);
-    mxmlElementSetAttrf(tag, "userdata", "%s", data.userdata);
-    flags = mxmlNewElement(tag, "visible"); mxmlNewTextf(flags, 0, "%02x", data.flag1 & 0x1);
-    flags = mxmlNewElement(tag, "WidescreenAffected"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x2)>>1);
-    flags = mxmlNewElement(tag, "flag"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x4)>>2);
+	mxml_node_t *flags, *origin, *alpha, *padding;
+	mxml_node_t *translate, *x, *y, *z;
+	mxml_node_t *rotate, *scale;
+	mxml_node_t *size, *width, *height;
+	brlyt_pane_chunk data;
+	BRLYT_fileoffset = entry.data_location;
+	BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pane_chunk));
+	brlyt_pic_chunk data2;
+	BRLYT_ReadDataFromMemory(&data2, brlyt_file, sizeof(brlyt_pic_chunk));
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	mxmlElementSetAttrf(tag, "name", "%s", data.name);
+	mxmlElementSetAttrf(tag, "userdata", "%s", data.userdata);
+	flags = mxmlNewElement(tag, "visible"); mxmlNewTextf(flags, 0, "%02x", data.flag1 & 0x1);
+	flags = mxmlNewElement(tag, "WidescreenAffected"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x2)>>1);
+	flags = mxmlNewElement(tag, "flag"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x4)>>2);
 	origin  = mxmlNewElement(tag, "origin"); mxmlNewTextf(origin,0,"%s", origins[data.origin%9]);
-    alpha   = mxmlNewElement(tag, "alpha");   mxmlNewTextf(alpha, 0, "%02x", data.alpha);
+	alpha   = mxmlNewElement(tag, "alpha");   mxmlNewTextf(alpha, 0, "%02x", data.alpha);
 	padding = mxmlNewElement(tag, "padding"); mxmlNewTextf(padding, 0, "%02x", data.pad);
-    translate = mxmlNewElement(tag, "translate");
-    x = mxmlNewElement(translate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XTrans));
-    y = mxmlNewElement(translate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YTrans));
-    z = mxmlNewElement(translate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZTrans
+	translate = mxmlNewElement(tag, "translate");
+	x = mxmlNewElement(translate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XTrans));
+	y = mxmlNewElement(translate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YTrans));
+	z = mxmlNewElement(translate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZTrans
 				));
-    rotate = mxmlNewElement(tag, "rotate");
-    x = mxmlNewElement(rotate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XRotate));
-    y = mxmlNewElement(rotate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YRotate));
-    z = mxmlNewElement(rotate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZRotate));
-    scale = mxmlNewElement(tag, "scale");
-    x = mxmlNewElement(scale, "x"); mxmlNewTextf(x, 0, "%.10f", float_swap_bytes(data.XScale));
-    y = mxmlNewElement(scale, "y"); mxmlNewTextf(y, 0, "%.10f", float_swap_bytes(data.YScale));
-    size = mxmlNewElement(tag, "size");
-    width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%f", float_swap_bytes(data.width));
-    height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0, "%f", float_swap_bytes(data.height));
-    mxml_node_t *material, *color, *vtx, *coordinates, *set, *coord;
-    material = mxmlNewElement(tag, "material"); mxmlElementSetAttrf(material, "name", "%s", getMaterial(short_swap_bytes(data2.mat_num)));
-    color = mxmlNewElement(tag, "colors");
-    int n; for (n=0;n<4;n++)
-    {
-        vtx = mxmlNewElement(color, "vtx"); mxmlNewTextf(vtx, 0, "%08X", be32(data2.vtx_colors[n]));
-    }
-    coordinates = mxmlNewElement(tag, "coordinates");
-    for (n=0;n<data2.num_texcoords;n++)
-    {
-        float texcoords[8];
-        BRLYT_ReadDataFromMemory(texcoords, brlyt_file, sizeof(texcoords));
-        int i;
-        set = mxmlNewElement(coordinates, "set");
-        for(i = 0; i < 8; i++)
-        {
-            coord = mxmlNewElement(set, "coord"); mxmlNewTextf(coord, 0, "%f", float_swap_bytes(texcoords[i]));
-        }
-    }
+	rotate = mxmlNewElement(tag, "rotate");
+	x = mxmlNewElement(rotate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XRotate));
+	y = mxmlNewElement(rotate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YRotate));
+	z = mxmlNewElement(rotate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZRotate));
+	scale = mxmlNewElement(tag, "scale");
+	x = mxmlNewElement(scale, "x"); mxmlNewTextf(x, 0, "%.10f", float_swap_bytes(data.XScale));
+	y = mxmlNewElement(scale, "y"); mxmlNewTextf(y, 0, "%.10f", float_swap_bytes(data.YScale));
+	size = mxmlNewElement(tag, "size");
+	width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%f", float_swap_bytes(data.width));
+	height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0, "%f", float_swap_bytes(data.height));
+	mxml_node_t *material, *color, *vtx, *attr, *coordinates, *set, *coord;
+	material = mxmlNewElement(tag, "material"); mxmlElementSetAttrf(material, "name", "%s", getMaterial(short_swap_bytes(data2.mat_num)));
+	color = mxmlNewElement(tag, "colors");
+	int n; for (n=0;n<4;n++)
+	{
+		vtx = mxmlNewElement(color, "vtx");
+		attr = mxmlNewElement(color, "red");
+		mxmlNewTextf( attr , 0 , "%02x" , ( be32(data2.vtx_colors[n]) >> 24 ) & 0xff );
+		attr = mxmlNewElement(color, "red");
+		mxmlNewTextf( attr , 0 , "%02x" , ( be32(data2.vtx_colors[n]) >> 16 ) & 0xff );
+		attr = mxmlNewElement(color, "red");
+		mxmlNewTextf( attr , 0 , "%02x" , ( be32(data2.vtx_colors[n]) >>  8 ) & 0xff );
+		attr = mxmlNewElement(color, "red");
+		mxmlNewTextf( attr , 0 , "%02x" , ( be32(data2.vtx_colors[n]) >>  0 ) & 0xff );
+
+	}
+	coordinates = mxmlNewElement(tag, "coordinates");
+	for (n=0;n<data2.num_texcoords;n++)
+	{
+		float texcoords[8];
+		BRLYT_ReadDataFromMemory(texcoords, brlyt_file, sizeof(texcoords));
+		int i;
+		set = mxmlNewElement(coordinates, "set");
+		for(i = 0; i < 8; i++)
+		{
+			coord = mxmlNewElement(set, "coord"); mxmlNewTextf(coord, 0, "%f", float_swap_bytes(texcoords[i]));
+		}
+	}
 }
 
 void PrintBRLYTEntry_txt1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
@@ -591,113 +600,113 @@ void PrintBRLYTEntry_txt1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 	strcpy( alignments[7] , "BOTTOM CENTER" );
 	strcpy( alignments[8] , "BOTTOM RIGHT" );
 
-    mxml_node_t *flags, *origin, *alpha, *padding;
-    mxml_node_t *translate, *x, *y, *z;
-    mxml_node_t *rotate, *scale;
-    mxml_node_t *size, *width, *height;
-    brlyt_pane_chunk data;
-    BRLYT_fileoffset = entry.data_location;
-    BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pane_chunk));
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
-    mxmlElementSetAttrf(tag, "name", "%s", data.name);
-    mxmlElementSetAttrf(tag, "userdata", "%s", data.userdata);
-    flags = mxmlNewElement(tag, "visible"); mxmlNewTextf(flags, 0, "%02x", data.flag1 & 0x1);
-    flags = mxmlNewElement(tag, "WidescreenAffected"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x2)>>1);
-    flags = mxmlNewElement(tag, "flag"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x4)>>2);
+	mxml_node_t *flags, *origin, *alpha, *padding;
+	mxml_node_t *translate, *x, *y, *z;
+	mxml_node_t *rotate, *scale;
+	mxml_node_t *size, *width, *height;
+	brlyt_pane_chunk data;
+	BRLYT_fileoffset = entry.data_location;
+	BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pane_chunk));
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	mxmlElementSetAttrf(tag, "name", "%s", data.name);
+	mxmlElementSetAttrf(tag, "userdata", "%s", data.userdata);
+	flags = mxmlNewElement(tag, "visible"); mxmlNewTextf(flags, 0, "%02x", data.flag1 & 0x1);
+	flags = mxmlNewElement(tag, "WidescreenAffected"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x2)>>1);
+	flags = mxmlNewElement(tag, "flag"); mxmlNewTextf(flags, 0, "%02x", (data.flag1 & 0x4)>>2);
 	origin  = mxmlNewElement(tag, "origin"); mxmlNewTextf(origin,0,"%s", origins[data.origin%9]);
-    alpha   = mxmlNewElement(tag, "alpha");   mxmlNewTextf(alpha, 0, "%02x", data.alpha);
+	alpha   = mxmlNewElement(tag, "alpha");   mxmlNewTextf(alpha, 0, "%02x", data.alpha);
 	padding = mxmlNewElement(tag, "padding"); mxmlNewTextf(padding, 0, "%02x", data.pad);
-    translate = mxmlNewElement(tag, "translate");
-    x = mxmlNewElement(translate, "x"); mxmlNewTextf(x, 0, "%.16f", float_swap_bytes(data.XTrans));
-    y = mxmlNewElement(translate, "y"); mxmlNewTextf(y, 0, "%.16f", float_swap_bytes(data.YTrans));
-    z = mxmlNewElement(translate, "z"); mxmlNewTextf(z, 0, "%.16f", float_swap_bytes(data.ZTrans));
-    rotate = mxmlNewElement(tag, "rotate");
-    x = mxmlNewElement(rotate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XRotate));
-    y = mxmlNewElement(rotate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YRotate));
-    z = mxmlNewElement(rotate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZRotate));
-    scale = mxmlNewElement(tag, "scale");
-    x = mxmlNewElement(scale, "x"); mxmlNewTextf(x, 0, "%.10f", float_swap_bytes(data.XScale));
-    y = mxmlNewElement(scale, "y"); mxmlNewTextf(y, 0, "%.10f", float_swap_bytes(data.YScale));
-    size = mxmlNewElement(tag, "size");
-    width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%.20f", float_swap_bytes(data.width));
-    height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0, "%.20f", float_swap_bytes(data.height));
-    mxml_node_t *length, *font, *xsize, *ysize, *charsize, *linesize, *alignment, *color1, *color2, *text;
-    brlyt_text_chunk data2;
-    BRLYT_ReadDataFromMemory(&data2, brlyt_file, sizeof(brlyt_text_chunk));
-    u8 texty[short_swap_bytes(data2.len2)];
-    memcpy(texty, &brlyt_file[BRLYT_fileoffset], short_swap_bytes(data2.len2));
-    length = mxmlNewElement(tag, "length"); mxmlNewTextf(length, 0, "%04x-%04x", short_swap_bytes(data2.len2), short_swap_bytes(data2.len2));
-    font = mxmlNewElement(tag, "font"); mxmlElementSetAttrf(font, "index", "%d", short_swap_bytes(data2.font_idx));
-    xsize = mxmlNewElement(font, "xsize"); mxmlNewTextf(xsize, 0, "%f", float_swap_bytes(data2.font_size_x));
-    ysize = mxmlNewElement(font, "ysize"); mxmlNewTextf(ysize, 0, "%f", float_swap_bytes(data2.font_size_y));
-    charsize = mxmlNewElement(font, "charsize"); mxmlNewTextf(charsize, 0, "%f", float_swap_bytes(data2.char_space));
-    linesize = mxmlNewElement(font, "linesize"); mxmlNewTextf(linesize, 0, "%f", float_swap_bytes(data2.line_space));
-    alignment = mxmlNewElement(font, "alignment"); mxmlNewTextf(alignment, 0, "%s", alignments[data2.alignment%9]);
-    color1 = mxmlNewElement(tag, "color1"); mxmlNewTextf(color1, 0, "%08x", be32(data2.color1) );
-    color2 = mxmlNewElement(tag, "color2"); mxmlNewTextf(color2, 0, "%08x", be32(data2.color2) );
-//    int q; for(q=0;q<short_swap_bytes(data2.len2);q++) printf("%02x", texty[q]);    // S T U P I D   U T F 1 6    T E X T
-    u8 textbuffer[4096];
-    int q; for(q=0;q<short_swap_bytes(data2.len2);q++) sprintf((char*)&textbuffer[q*2], "%02x", texty[q]);
-    text = mxmlNewElement(tag, "text"); mxmlNewTextf(text, 0, "%s", textbuffer);
+	translate = mxmlNewElement(tag, "translate");
+	x = mxmlNewElement(translate, "x"); mxmlNewTextf(x, 0, "%.16f", float_swap_bytes(data.XTrans));
+	y = mxmlNewElement(translate, "y"); mxmlNewTextf(y, 0, "%.16f", float_swap_bytes(data.YTrans));
+	z = mxmlNewElement(translate, "z"); mxmlNewTextf(z, 0, "%.16f", float_swap_bytes(data.ZTrans));
+	rotate = mxmlNewElement(tag, "rotate");
+	x = mxmlNewElement(rotate, "x"); mxmlNewTextf(x, 0, "%.20f", float_swap_bytes(data.XRotate));
+	y = mxmlNewElement(rotate, "y"); mxmlNewTextf(y, 0, "%.20f", float_swap_bytes(data.YRotate));
+	z = mxmlNewElement(rotate, "z"); mxmlNewTextf(z, 0, "%.20f", float_swap_bytes(data.ZRotate));
+	scale = mxmlNewElement(tag, "scale");
+	x = mxmlNewElement(scale, "x"); mxmlNewTextf(x, 0, "%.10f", float_swap_bytes(data.XScale));
+	y = mxmlNewElement(scale, "y"); mxmlNewTextf(y, 0, "%.10f", float_swap_bytes(data.YScale));
+	size = mxmlNewElement(tag, "size");
+	width = mxmlNewElement(size, "width"); mxmlNewTextf(width, 0, "%.20f", float_swap_bytes(data.width));
+	height = mxmlNewElement(size, "height"); mxmlNewTextf(height, 0, "%.20f", float_swap_bytes(data.height));
+	mxml_node_t *length, *font, *xsize, *ysize, *charsize, *linesize, *alignment, *color1, *color2, *text;
+	brlyt_text_chunk data2;
+	BRLYT_ReadDataFromMemory(&data2, brlyt_file, sizeof(brlyt_text_chunk));
+	u8 texty[short_swap_bytes(data2.len2)];
+	memcpy(texty, &brlyt_file[BRLYT_fileoffset], short_swap_bytes(data2.len2));
+	length = mxmlNewElement(tag, "length"); mxmlNewTextf(length, 0, "%04x-%04x", short_swap_bytes(data2.len2), short_swap_bytes(data2.len2));
+	font = mxmlNewElement(tag, "font"); mxmlElementSetAttrf(font, "index", "%d", short_swap_bytes(data2.font_idx));
+	xsize = mxmlNewElement(font, "xsize"); mxmlNewTextf(xsize, 0, "%f", float_swap_bytes(data2.font_size_x));
+	ysize = mxmlNewElement(font, "ysize"); mxmlNewTextf(ysize, 0, "%f", float_swap_bytes(data2.font_size_y));
+	charsize = mxmlNewElement(font, "charsize"); mxmlNewTextf(charsize, 0, "%f", float_swap_bytes(data2.char_space));
+	linesize = mxmlNewElement(font, "linesize"); mxmlNewTextf(linesize, 0, "%f", float_swap_bytes(data2.line_space));
+	alignment = mxmlNewElement(font, "alignment"); mxmlNewTextf(alignment, 0, "%s", alignments[data2.alignment%9]);
+	color1 = mxmlNewElement(tag, "color1"); mxmlNewTextf(color1, 0, "%08x", be32(data2.color1) );
+	color2 = mxmlNewElement(tag, "color2"); mxmlNewTextf(color2, 0, "%08x", be32(data2.color2) );
+//	int q; for(q=0;q<short_swap_bytes(data2.len2);q++) printf("%02x", texty[q]);	// S T U P I D   U T F 1 6	T E X T
+	u8 textbuffer[4096];
+	int q; for(q=0;q<short_swap_bytes(data2.len2);q++) sprintf((char*)&textbuffer[q*2], "%02x", texty[q]);
+	text = mxmlNewElement(tag, "text"); mxmlNewTextf(text, 0, "%s", textbuffer);
 }
 
 void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 {
-    mxml_node_t *entries, *colors, *forecolor, *backcolor, *unk2, *tev_k, *flags;
-    brlyt_numoffs_chunk data;
-    BRLYT_fileoffset = entry.data_location;
-    BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_numoffs_chunk));
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
-    int n = 0;
-    for (n=0;n<short_swap_bytes(data.num);n++)
-    {
-        int offset;
-        BRLYT_ReadDataFromMemory(&offset, brlyt_file, sizeof(offset));
-        int tempDataLocation = BRLYT_fileoffset;
-        BRLYT_fileoffset = entry.data_location + be32(offset) - 8;
-        brlyt_material_chunk data3;
-        BRLYT_ReadDataFromMemory(&data3, brlyt_file, sizeof(brlyt_material_chunk));
-
-        u32 flaggs = be32(data3.flags);
-        entries = mxmlNewElement(tag, "entries"); mxmlElementSetAttrf(entries, "name",  "%s", data3.name);
-        colors = mxmlNewElement(entries, "colors");
-        int i; for (i=0;i<4;i++)
-        {
-            forecolor = mxmlNewElement(colors, "forecolor");
-            mxmlNewTextf(forecolor, 0, "%d", short_swap_bytes(data3.forecolor[i]));
-        }
-        for (i=0;i<4;i++)
-        {
-            backcolor = mxmlNewElement(colors, "backcolor");
-            mxmlNewTextf(backcolor, 0, "%d", short_swap_bytes(data3.backcolor[i]));
-        }
-        for (i=0;i<4;i++)
-        {
-            unk2 = mxmlNewElement(colors, "colorReg3");
-            mxmlNewTextf(unk2, 0, "%d", short_swap_bytes(data3.colorReg3[i]));
-        }
-        for (i=0;i<4;i++)
-        {
-            tev_k = mxmlNewElement(colors, "tev_k");
-            mxmlNewTextf(tev_k, 0, "%08x", be32(data3.tev_kcolor[i]));
-        }
-
-        //flags = mxmlNewElement(entries, "flags"); mxmlNewTextf(flags, 0, "%08x", be32(data3.flags));
-
-        int newSize = lengthOfMaterials+strlen(data3.name)+1;
-        materials = realloc(materials, newSize);
-        numberOfMaterials += 1;
-        memcpy(materials+lengthOfMaterials, data3.name, 1+strlen(data3.name));
-        lengthOfMaterials = newSize;
-
-        mxml_node_t *texture, *wrap_t, *wrap_s;
-        int n;
-        for (n=0;n<bit_extract(flaggs, 28,31);n++)
-        {
-            brlyt_texref_chunk data4;
-            BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_texref_chunk));
-            int tplOffset = short_swap_bytes(data4.tex_offs);
-            texture = mxmlNewElement(entries, "texture"); mxmlElementSetAttrf(texture, "name", "%s", getTexture(tplOffset));
+	mxml_node_t *entries, *colors, *forecolor, *backcolor, *unk2, *tev_k, *flags;
+	brlyt_numoffs_chunk data;
+	BRLYT_fileoffset = entry.data_location;
+	BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_numoffs_chunk));
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	int n = 0;
+	for (n=0;n<short_swap_bytes(data.num);n++)
+	{
+		int offset;
+		BRLYT_ReadDataFromMemory(&offset, brlyt_file, sizeof(offset));
+		int tempDataLocation = BRLYT_fileoffset;
+		BRLYT_fileoffset = entry.data_location + be32(offset) - 8;
+		brlyt_material_chunk data3;
+		BRLYT_ReadDataFromMemory(&data3, brlyt_file, sizeof(brlyt_material_chunk));
+
+		u32 flaggs = be32(data3.flags);
+		entries = mxmlNewElement(tag, "entries"); mxmlElementSetAttrf(entries, "name",  "%s", data3.name);
+		colors = mxmlNewElement(entries, "colors");
+		int i; for (i=0;i<4;i++)
+		{
+			forecolor = mxmlNewElement(colors, "forecolor");
+			mxmlNewTextf(forecolor, 0, "%d", short_swap_bytes(data3.forecolor[i]));
+		}
+		for (i=0;i<4;i++)
+		{
+			backcolor = mxmlNewElement(colors, "backcolor");
+			mxmlNewTextf(backcolor, 0, "%d", short_swap_bytes(data3.backcolor[i]));
+		}
+		for (i=0;i<4;i++)
+		{
+			unk2 = mxmlNewElement(colors, "colorReg3");
+			mxmlNewTextf(unk2, 0, "%d", short_swap_bytes(data3.colorReg3[i]));
+		}
+		for (i=0;i<4;i++)
+		{
+			tev_k = mxmlNewElement(colors, "tev_k");
+			mxmlNewTextf(tev_k, 0, "%08x", be32(data3.tev_kcolor[i]));
+		}
+
+		//flags = mxmlNewElement(entries, "flags"); mxmlNewTextf(flags, 0, "%08x", be32(data3.flags));
+
+		int newSize = lengthOfMaterials+strlen(data3.name)+1;
+		materials = realloc(materials, newSize);
+		numberOfMaterials += 1;
+		memcpy(materials+lengthOfMaterials, data3.name, 1+strlen(data3.name));
+		lengthOfMaterials = newSize;
+
+		mxml_node_t *texture, *wrap_t, *wrap_s;
+		int n;
+		for (n=0;n<bit_extract(flaggs, 28,31);n++)
+		{
+			brlyt_texref_chunk data4;
+			BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_texref_chunk));
+			int tplOffset = short_swap_bytes(data4.tex_offs);
+			texture = mxmlNewElement(entries, "texture"); mxmlElementSetAttrf(texture, "name", "%s", getTexture(tplOffset));
 
 			char wraps[4][20];
 			int l;
@@ -708,30 +717,30 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 			strcpy( wraps[2] , "GX_MIRROR" );
 			strcpy( wraps[3] , "GX_MAXTEXWRAPMODE" );
 
-            wrap_s = mxmlNewElement(texture, "wrap_s");
+			wrap_s = mxmlNewElement(texture, "wrap_s");
 			mxmlNewTextf(wrap_s, 0, "%s", wraps[data4.wrap_s]);
-            wrap_t = mxmlNewElement(texture, "wrap_t");
+			wrap_t = mxmlNewElement(texture, "wrap_t");
 			mxmlNewTextf(wrap_t, 0, "%s", wraps[data4.wrap_t]);
-        }
-
-        mxml_node_t *tex_coords, *dataa;
-//        # 0x14 * flags[24-27], followed by
-                for (n=0;n<bit_extract(flaggs, 24,27);n++)
-                {
-                        brlyt_tex_srt data4;
-                        BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_tex_srt));
-                        tex_coords = mxmlNewElement(entries, "TextureSRT");
-                        dataa = mxmlNewElement(tex_coords, "XTrans"); mxmlNewTextf(dataa, 0, "%.10f", float_swap_bytes(data4.XTrans));
-                        dataa = mxmlNewElement(tex_coords, "YTrans"); mxmlNewTextf(dataa, 0, "%.10f", float_swap_bytes(data4.YTrans));
-                        dataa = mxmlNewElement(tex_coords, "Rotate"); mxmlNewTextf(dataa, 0, "%.10f", float_swap_bytes(data4.Rotate));
-                        dataa = mxmlNewElement(tex_coords, "XScale"); mxmlNewTextf(dataa, 0, "%.10f", float_swap_bytes(data4.XScale));
-                        dataa = mxmlNewElement(tex_coords, "YScale"); mxmlNewTextf(dataa, 0, "%.10f", float_swap_bytes(data4.YScale));
-                }
-                
-                mxml_node_t *ua3;
-        //# 4*flags[20-23], followed by
-                for (n=0;n<bit_extract(flaggs, 20,23);n++)
-                {
+		}
+
+		mxml_node_t *tex_coords, *dataa;
+//		# 0x14 * flags[24-27], followed by
+				for (n=0;n<bit_extract(flaggs, 24,27);n++)
+				{
+						brlyt_tex_srt data4;
+						BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_tex_srt));
+						tex_coords = mxmlNewElement(entries, "TextureSRT");
+						dataa = mxmlNewElement(tex_coords, "XTrans"); mxmlNewTextf(dataa, 0, "%.10f", float_swap_bytes(data4.XTrans));
+						dataa = mxmlNewElement(tex_coords, "YTrans"); mxmlNewTextf(dataa, 0, "%.10f", float_swap_bytes(data4.YTrans));
+						dataa = mxmlNewElement(tex_coords, "Rotate"); mxmlNewTextf(dataa, 0, "%.10f", float_swap_bytes(data4.Rotate));
+						dataa = mxmlNewElement(tex_coords, "XScale"); mxmlNewTextf(dataa, 0, "%.10f", float_swap_bytes(data4.XScale));
+						dataa = mxmlNewElement(tex_coords, "YScale"); mxmlNewTextf(dataa, 0, "%.10f", float_swap_bytes(data4.YScale));
+				}
+
+				mxml_node_t *ua3;
+		//# 4*flags[20-23], followed by
+				for (n=0;n<bit_extract(flaggs, 20,23);n++)
+				{
 						char tgen_types[11][20];
 						int l;
 						for ( l = 0 ; l < 11 ; l++ )
@@ -819,9 +828,9 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						strcpy( mtxsrc[40] , "GX_DTTMTX19" );
 						strcpy( mtxsrc[41] , "GX_DTTIDENTITY" );	// actually 125 not 124
 
-                        brlyt_tex_coordgen data4;
-                        BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_tex_coordgen));
-                        ua3 = mxmlNewElement(entries, "CoordGen");
+						brlyt_tex_coordgen data4;
+						BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_tex_coordgen));
+						ua3 = mxmlNewElement(entries, "CoordGen");
 
 						dataa = mxmlNewElement(ua3, "tgen_type");
 						mxmlNewTextf(dataa, 0, "%s", tgen_types[data4.tgen_type]);
@@ -830,12 +839,12 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						dataa = mxmlNewElement(ua3, "MatrixSource");
 						mxmlNewTextf(dataa, 0, "%s", mtxsrc[data4.mtxsrc/3]);
 						dataa = mxmlNewElement(ua3, "padding"); mxmlNewTextf(dataa, 0, "%02x", data4.padding);
-                }
+				}
 
-                mxml_node_t *ua4;
-        //# 4 * flags[6]
-                for (n=0;n<bit_extract(flaggs, 6,100);n++)
-                {
+				mxml_node_t *ua4;
+		//# 4 * flags[6]
+				for (n=0;n<bit_extract(flaggs, 6,100);n++)
+				{
 						char matsrc[2][20];
 						int l;
 						for ( l = 0 ; l < 2 ; l++ )
@@ -843,9 +852,9 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						strcpy( matsrc[0]  , "GX_SRC_REG" );
 						strcpy( matsrc[1]  , "GX_SRC_VTX" );
 
-                        brlyt_tex_chanctrl data4;
-                        BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_tex_chanctrl));
-                        ua4 = mxmlNewElement(entries, "ChanControl");
+						brlyt_tex_chanctrl data4;
+						BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_tex_chanctrl));
+						ua4 = mxmlNewElement(entries, "ChanControl");
 
 						dataa = mxmlNewElement(ua4, "ColorMatSource");
 						mxmlNewTextf(dataa, 0, "%s", matsrc[data4.color_matsrc]);
@@ -856,26 +865,26 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						dataa = mxmlNewElement(ua4, "Padding2");
 						mxmlNewTextf(dataa, 0, "%02x", data4.padding2);
 
-                }
-                
-                mxml_node_t *ua5;
-        //# 4 * flags[4]
-                for (n=0;n<bit_extract(flaggs, 4,100);n++)
-                {
-                        brlyt_tex_matcol data4;
-                        BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_tex_matcol));
-                        ua5 = mxmlNewElement(entries, "MaterialColor");
+				}
+
+				mxml_node_t *ua5;
+		//# 4 * flags[4]
+				for (n=0;n<bit_extract(flaggs, 4,100);n++)
+				{
+						brlyt_tex_matcol data4;
+						BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_tex_matcol));
+						ua5 = mxmlNewElement(entries, "MaterialColor");
 
 						dataa = mxmlNewElement(ua5, "red"); mxmlNewTextf(dataa, 0, "%02x", data4.red);
 						dataa = mxmlNewElement(ua5, "green"); mxmlNewTextf(dataa, 0, "%02x", data4.green);
 						dataa = mxmlNewElement(ua5, "blue"); mxmlNewTextf(dataa, 0, "%02x", data4.blue);
 						dataa = mxmlNewElement(ua5, "alpha"); mxmlNewTextf(dataa, 0, "%02x", data4.alpha);
-                }
-                
-                mxml_node_t *ua6;
-        //# 4 * flags[19]
-                for (n=0;n<bit_extract(flaggs, 19,100);n++)
-                {
+				}
+
+				mxml_node_t *ua6;
+		//# 4 * flags[19]
+				for (n=0;n<bit_extract(flaggs, 19,100);n++)
+				{
 						char tevcolor[4][20];
 						int l;
 						for ( l = 0 ; l < 4 ; l++ )
@@ -885,10 +894,10 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						strcpy( tevcolor[2]  , "GX_CH_BLUE" );
 						strcpy( tevcolor[3]  , "GX_CH_ALPHA" );
 
-                        brlyt_tev_swapmodetable data4;
-                        BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_tev_swapmodetable));
+						brlyt_tev_swapmodetable data4;
+						BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_tev_swapmodetable));
 
-                        ua6 = mxmlNewElement(entries, "TevSwapModeTable");
+						ua6 = mxmlNewElement(entries, "TevSwapModeTable");
 
 						dataa = mxmlNewElement(ua6, "OneRed");
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.one & 0x03) >> 0] );
@@ -898,7 +907,7 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.one & 0x30) >> 4] );
 						dataa = mxmlNewElement(ua6, "OneAlpha");
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.one & 0xC0) >> 6] );
-						
+
 						dataa = mxmlNewElement(ua6, "TwoRed");
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.two & 0x03) >> 0] );
 						dataa = mxmlNewElement(ua6, "TwoGreen");
@@ -907,7 +916,7 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.two & 0x30) >> 4] );
 						dataa = mxmlNewElement(ua6, "TwoAlpha");
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.two & 0xC0) >> 6] );
-						
+
 						dataa = mxmlNewElement(ua6, "ThreeRed");
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.three & 0x03) >> 0] );
 						dataa = mxmlNewElement(ua6, "ThreeGreen");
@@ -916,7 +925,7 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.three & 0x30) >> 4] );
 						dataa = mxmlNewElement(ua6, "ThreeAlpha");
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.three & 0xC0) >> 6] );
-						
+
 						dataa = mxmlNewElement(ua6, "FourRed");
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.four & 0x03) >> 0] );
 						dataa = mxmlNewElement(ua6, "FourGreen");
@@ -925,26 +934,26 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.four & 0x30) >> 4] );
 						dataa = mxmlNewElement(ua6, "FourAlpha");
 						mxmlNewTextf(dataa, 0, "%s", tevcolor[(data4.four & 0xC0) >> 6] );
-						
-                }
-                
-                mxml_node_t *ua7, *a, *b, *c, *d, *e;
-                for (n=0;n<bit_extract(flaggs, 17,18);n++)
-                {
-                        brlyt_indtex_srt data4;
-                        BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_indtex_srt));
-                        ua7 = mxmlNewElement(entries, "IndTextureSRT");
-                        a = mxmlNewElement(ua7, "XTrans"); mxmlNewTextf(a, 0, "%f", float_swap_bytes(data4.XTrans));
-                        b = mxmlNewElement(ua7, "YTrans"); mxmlNewTextf(b, 0, "%f", float_swap_bytes(data4.YTrans));
-                        c = mxmlNewElement(ua7, "Rotate"); mxmlNewTextf(c, 0, "%f", float_swap_bytes(data4.Rotate));
-                        d = mxmlNewElement(ua7, "XScale"); mxmlNewTextf(d, 0, "%f", float_swap_bytes(data4.XScale));
-                        e = mxmlNewElement(ua7, "YScale"); mxmlNewTextf(e, 0, "%f", float_swap_bytes(data4.YScale));
-                }
-                
-                mxml_node_t *ua8;
-        //# 4 * flags[14-16]
-                for (n=0;n<bit_extract(flaggs, 14,16);n++)
-                {
+
+				}
+
+				mxml_node_t *ua7, *a, *b, *c, *d, *e;
+				for (n=0;n<bit_extract(flaggs, 17,18);n++)
+				{
+						brlyt_indtex_srt data4;
+						BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_indtex_srt));
+						ua7 = mxmlNewElement(entries, "IndTextureSRT");
+						a = mxmlNewElement(ua7, "XTrans"); mxmlNewTextf(a, 0, "%f", float_swap_bytes(data4.XTrans));
+						b = mxmlNewElement(ua7, "YTrans"); mxmlNewTextf(b, 0, "%f", float_swap_bytes(data4.YTrans));
+						c = mxmlNewElement(ua7, "Rotate"); mxmlNewTextf(c, 0, "%f", float_swap_bytes(data4.Rotate));
+						d = mxmlNewElement(ua7, "XScale"); mxmlNewTextf(d, 0, "%f", float_swap_bytes(data4.XScale));
+						e = mxmlNewElement(ua7, "YScale"); mxmlNewTextf(e, 0, "%f", float_swap_bytes(data4.YScale));
+				}
+
+				mxml_node_t *ua8;
+		//# 4 * flags[14-16]
+				for (n=0;n<bit_extract(flaggs, 14,16);n++)
+				{
 						char scale[10][20];
 						int l;
 						for ( l = 0 ; l < 10 ; l++ )
@@ -960,9 +969,9 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						strcpy( scale[8]  , "GX_ITS_256" );
 						strcpy( scale[9]  , "GX_MAX_ITSCALE" );
 
-                        brlyt_indtex_order data4;
-                        BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_indtex_order));
-                        ua8 = mxmlNewElement(entries, "IndTextureOrder");
+						brlyt_indtex_order data4;
+						BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_indtex_order));
+						ua8 = mxmlNewElement(entries, "IndTextureOrder");
 
 						dataa = mxmlNewElement(ua8, "TextureCoordinate"); mxmlNewTextf(dataa, 0, "%02x", data4.tex_coord);
 						dataa = mxmlNewElement(ua8, "TextureMap"); mxmlNewTextf(dataa, 0, "%02x", data4.tex_map);
@@ -970,15 +979,15 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						mxmlNewTextf(dataa, 0, "%s", scale[data4.scale_s]);
 						dataa = mxmlNewElement(ua8, "ScaleT");
 						mxmlNewTextf(dataa, 0, "%s", scale[data4.scale_t]);
-                }
-                
-                mxml_node_t *ua9;
-        //# 0x10 * flags[9-13]
-                for (n=0;n<bit_extract(flaggs, 9,13);n++)
-                {
+				}
+
+				mxml_node_t *ua9;
+		//# 0x10 * flags[9-13]
+				for (n=0;n<bit_extract(flaggs, 9,13);n++)
+				{
 						TevStages data4;
-                        BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(TevStages));
-                        ua9 = mxmlNewElement(entries, "TevStage");
+						BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(TevStages));
+						ua9 = mxmlNewElement(entries, "TevStage");
 
 						dataa = mxmlNewElement(ua9, "TextureCoordinate");
 						mxmlNewTextf(dataa, 0, "%02x", data4.texcoord);
@@ -1094,12 +1103,12 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						dataa = mxmlNewElement(ua9, "Padding4");
 						mxmlNewTextf(dataa, 0, "%01x", data4.empty4);
 
-                }
-                
-                mxml_node_t *uaa;
-        //# 4 * flags[8]
-                for (n=0;n<bit_extract(flaggs, 8,8);n++)
-                {
+				}
+
+				mxml_node_t *uaa;
+		//# 4 * flags[8]
+				for (n=0;n<bit_extract(flaggs, 8,8);n++)
+				{
 						char compare[8][20];
 						int l;
 						for ( l = 0 ; l < 8 ; l++ )
@@ -1122,9 +1131,9 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						strcpy( aop[3]  , "GX_AOP_XNOR" );
 						strcpy( aop[4]  , "GX_MAX_ALPHAOP" );
 
-                        brlyt_alpha_compare data4;
-                        BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_alpha_compare));
-                        uaa = mxmlNewElement(entries, "AlphaCompare");
+						brlyt_alpha_compare data4;
+						BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_alpha_compare));
+						uaa = mxmlNewElement(entries, "AlphaCompare");
 						dataa = mxmlNewElement(uaa, "comp0");
 						mxmlNewTextf(dataa, 0, "%s", compare[data4.comp0]);
 						dataa = mxmlNewElement(uaa, "comp1");
@@ -1133,12 +1142,12 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						mxmlNewTextf(dataa, 0, "%s", aop[data4.aop]);
 						dataa = mxmlNewElement(uaa, "ref0"); mxmlNewTextf(dataa, 0, "%02x", data4.ref0);
 						dataa = mxmlNewElement(uaa, "ref1"); mxmlNewTextf(dataa, 0, "%02x", data4.ref1);
-                }
+				}
 
-                mxml_node_t *uab;
-        //# 4 * flags[7]
-                for (n=0;n<bit_extract(flaggs, 7,7);n++)
-                {
+				mxml_node_t *uab;
+		//# 4 * flags[7]
+				for (n=0;n<bit_extract(flaggs, 7,7);n++)
+				{
 						char blendmode[5][20];
 						int l;
 						for ( l = 0 ; l < 5 ; l++ )
@@ -1181,9 +1190,9 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						strcpy( logicop[14]  , "GX_LO_NAND" );
 						strcpy( logicop[15]  , "GX_LO_SET" );
 
-                        brlyt_blend_mode data4;
-                        BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_blend_mode));
-                        uab = mxmlNewElement(entries, "BlendMode");
+						brlyt_blend_mode data4;
+						BRLYT_ReadDataFromMemory(&data4, brlyt_file, sizeof(brlyt_blend_mode));
+						uab = mxmlNewElement(entries, "BlendMode");
 
 						dataa = mxmlNewElement(uab, "type");
 						mxmlNewTextf(dataa, 0, "%s", blendmode[data4.type]);
@@ -1194,449 +1203,449 @@ void PrintBRLYTEntry_mat1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 						dataa = mxmlNewElement(uab, "op");
 						mxmlNewTextf(dataa, 0, "%s", logicop[data4.op]);
 
-                }
-        BRLYT_fileoffset = tempDataLocation;        
-    }
+				}
+		BRLYT_fileoffset = tempDataLocation;
+	}
 }
 
 void PrintBRLYTEntry_gre1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 {
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
 }
 
 void PrintBRLYTEntry_grs1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 {
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
 }
 
 void PrintBRLYTEntry_pae1(brlyt_entry entry, u8* brlyt_file, mxml_node_t *tag)
 {
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
 }
 
 void PrintBRLYTEntry_pas1(brlyt_entry entry, u8* brlyt_file, mxml_node_t* tag)
 {
-    mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
+	mxmlElementSetAttrf(tag, "type", "%.4s", entry.magic);
 }
 
 void PrintBRLYTEntries(brlyt_entry *entries, int entrycnt, u8* brlyt_file, mxml_node_t *xmlyt)
 {
-    int i;
-    mxml_node_t *tag;    
-    for(i = 0; i < entrycnt; i++) {
-        tag = mxmlNewElement(xmlyt, "tag");
-        if((FourCCsMatch(entries[i].magic, pan1_magic) == 1)) {
-            PrintBRLYTEntry_pan1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, txt1_magic) == 1)) {
-            PrintBRLYTEntry_txt1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, pic1_magic) == 1)) {
-            PrintBRLYTEntry_pic1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, wnd1_magic) == 1)) {
-            PrintBRLYTEntry_wnd1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, bnd1_magic) == 1)) {
-            PrintBRLYTEntry_bnd1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, lyt1_magic) == 1)) {
-            PrintBRLYTEntry_lyt1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, grp1_magic) == 1)) {
-            PrintBRLYTEntry_grp1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, txl1_magic) == 1)) {
-            PrintBRLYTEntry_txl1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, fnl1_magic) == 1)) {
-            PrintBRLYTEntry_fnl1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, mat1_magic) == 1)) {
-            PrintBRLYTEntry_mat1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, gre1_magic) == 1)) {
-            PrintBRLYTEntry_gre1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, grs1_magic) == 1)) {
-            PrintBRLYTEntry_grs1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, pae1_magic) == 1)) {
-            PrintBRLYTEntry_pae1(entries[i], brlyt_file, tag);
-        }else if((FourCCsMatch(entries[i].magic, pas1_magic) == 1)) {
-            PrintBRLYTEntry_pas1(entries[i], brlyt_file, tag);
-        }else{
-        }
-    }
+	int i;
+	mxml_node_t *tag;
+	for(i = 0; i < entrycnt; i++) {
+		tag = mxmlNewElement(xmlyt, "tag");
+		if((FourCCsMatch(entries[i].magic, pan1_magic) == 1)) {
+			PrintBRLYTEntry_pan1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, txt1_magic) == 1)) {
+			PrintBRLYTEntry_txt1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, pic1_magic) == 1)) {
+			PrintBRLYTEntry_pic1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, wnd1_magic) == 1)) {
+			PrintBRLYTEntry_wnd1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, bnd1_magic) == 1)) {
+			PrintBRLYTEntry_bnd1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, lyt1_magic) == 1)) {
+			PrintBRLYTEntry_lyt1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, grp1_magic) == 1)) {
+			PrintBRLYTEntry_grp1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, txl1_magic) == 1)) {
+			PrintBRLYTEntry_txl1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, fnl1_magic) == 1)) {
+			PrintBRLYTEntry_fnl1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, mat1_magic) == 1)) {
+			PrintBRLYTEntry_mat1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, gre1_magic) == 1)) {
+			PrintBRLYTEntry_gre1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, grs1_magic) == 1)) {
+			PrintBRLYTEntry_grs1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, pae1_magic) == 1)) {
+			PrintBRLYTEntry_pae1(entries[i], brlyt_file, tag);
+		}else if((FourCCsMatch(entries[i].magic, pas1_magic) == 1)) {
+			PrintBRLYTEntry_pas1(entries[i], brlyt_file, tag);
+		}else{
+		}
+	}
 }
 
 void parse_brlyt(char *filename, char *filenameout)
 {
-    materials = (char*)malloc(12);
-    numberOfMaterials = 0;
-    lengthOfMaterials = 0;
-    textures = (char*)malloc(12);
-    numberOfTextures = 0;
-    lengthOfTextures = 0;
-    FILE* fp = fopen(filename, "rb");
-    if(fp == NULL) {
-        printf("Error! Couldn't open %s!\n", filename);
-        exit(1);
-    }
-    fseek(fp, 0, SEEK_END);
-    size_t file_size = ftell(fp);
-    u8* brlyt_file = (u8*)malloc(file_size);
-    fseek(fp, 0, SEEK_SET);
-    fread(brlyt_file, file_size, 1, fp);
-    fclose(fp);
-    BRLYT_fileoffset = 0;
-    brlyt_header header;
-    BRLYT_ReadDataFromMemory(&header, brlyt_file, sizeof(brlyt_header));
-    BRLYT_CheckHeaderSanity(header, file_size);
-    brlyt_entry *entries;
-    BRLYT_fileoffset = short_swap_bytes(header.lyt_offset);
-    brlyt_entry_header tempentry;
-    int i;
-    for(i = 0; BRLYT_fileoffset < file_size; i++) {
-        BRLYT_ReadDataFromMemoryX(&tempentry, brlyt_file, sizeof(brlyt_entry_header));
-        BRLYT_fileoffset += be32(tempentry.length);
-    }
-    int entrycount = i;
-    entries = (brlyt_entry*)calloc(entrycount, sizeof(brlyt_entry));
-    if(entries == NULL) {
-        printf("Couldn't allocate for entries!\n");
-        exit(1);
-    }
-    BRLYT_fileoffset = short_swap_bytes(header.lyt_offset);
-    for(i = 0; i < entrycount; i++) {
-        BRLYT_ReadDataFromMemoryX(&tempentry, brlyt_file, sizeof(brlyt_entry_header));
-        memcpy(entries[i].magic, tempentry.magic, 4);
-        entries[i].length = tempentry.length;
-        entries[i].data_location = BRLYT_fileoffset + sizeof(brlyt_entry_header);
-        BRLYT_fileoffset += be32(tempentry.length);
-    }    
-
-
-    FILE *xmlFile;
-    xmlFile = fopen(filenameout, "w");
-    mxml_node_t *xml;
-    mxml_node_t *xmlyt;
-    xml = mxmlNewXML("1.0");
-    xmlyt = mxmlNewElement(xml, "xmlyt");
-    mxmlElementSetAttrf(xmlyt, "version", "%d.%d.%d%s", BENZIN_VERSION_MAJOR, BENZIN_VERSION_MINOR, BENZIN_VERSION_BUILD, BENZIN_VERSION_OTHER);
-    PrintBRLYTEntries(entries, entrycount, brlyt_file, xmlyt);
-    mxmlSaveFile(xml, xmlFile, whitespace_cb);
-    fclose(xmlFile);
-    mxmlDelete(xml);
-    free(entries);
-    free(brlyt_file);
-    free(materials);
-    free(textures);
+	materials = (char*)malloc(12);
+	numberOfMaterials = 0;
+	lengthOfMaterials = 0;
+	textures = (char*)malloc(12);
+	numberOfTextures = 0;
+	lengthOfTextures = 0;
+	FILE* fp = fopen(filename, "rb");
+	if(fp == NULL) {
+		printf("Error! Couldn't open %s!\n", filename);
+		exit(1);
+	}
+	fseek(fp, 0, SEEK_END);
+	size_t file_size = ftell(fp);
+	u8* brlyt_file = (u8*)malloc(file_size);
+	fseek(fp, 0, SEEK_SET);
+	fread(brlyt_file, file_size, 1, fp);
+	fclose(fp);
+	BRLYT_fileoffset = 0;
+	brlyt_header header;
+	BRLYT_ReadDataFromMemory(&header, brlyt_file, sizeof(brlyt_header));
+	BRLYT_CheckHeaderSanity(header, file_size);
+	brlyt_entry *entries;
+	BRLYT_fileoffset = short_swap_bytes(header.lyt_offset);
+	brlyt_entry_header tempentry;
+	int i;
+	for(i = 0; BRLYT_fileoffset < file_size; i++) {
+		BRLYT_ReadDataFromMemoryX(&tempentry, brlyt_file, sizeof(brlyt_entry_header));
+		BRLYT_fileoffset += be32(tempentry.length);
+	}
+	int entrycount = i;
+	entries = (brlyt_entry*)calloc(entrycount, sizeof(brlyt_entry));
+	if(entries == NULL) {
+		printf("Couldn't allocate for entries!\n");
+		exit(1);
+	}
+	BRLYT_fileoffset = short_swap_bytes(header.lyt_offset);
+	for(i = 0; i < entrycount; i++) {
+		BRLYT_ReadDataFromMemoryX(&tempentry, brlyt_file, sizeof(brlyt_entry_header));
+		memcpy(entries[i].magic, tempentry.magic, 4);
+		entries[i].length = tempentry.length;
+		entries[i].data_location = BRLYT_fileoffset + sizeof(brlyt_entry_header);
+		BRLYT_fileoffset += be32(tempentry.length);
+	}
+
+
+	FILE *xmlFile;
+	xmlFile = fopen(filenameout, "w");
+	mxml_node_t *xml;
+	mxml_node_t *xmlyt;
+	xml = mxmlNewXML("1.0");
+	xmlyt = mxmlNewElement(xml, "xmlyt");
+	mxmlElementSetAttrf(xmlyt, "version", "%d.%d.%d%s", BENZIN_VERSION_MAJOR, BENZIN_VERSION_MINOR, BENZIN_VERSION_BUILD, BENZIN_VERSION_OTHER);
+	PrintBRLYTEntries(entries, entrycount, brlyt_file, xmlyt);
+	mxmlSaveFile(xml, xmlFile, whitespace_cb);
+	fclose(xmlFile);
+	mxmlDelete(xml);
+	free(entries);
+	free(brlyt_file);
+	free(materials);
+	free(textures);
 }
 
 void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* blobsize, char temp[4], FILE* fp, u32 *fileOffset)
 {
-    u32 startOfChunk = *fileOffset;
-
-    char lyt1[4] = {'l', 'y', 't', '1'};
-    char txl1[4] = {'t', 'x', 'l', '1'};
-    char fnl1[4] = {'f', 'n', 'l', '1'};
-    char mat1[4] = {'m', 'a', 't', '1'};
-    char pan1[4] = {'p', 'a', 'n', '1'};
-    char wnd1[4] = {'w', 'n', 'd', '1'};
-    char bnd1[4] = {'b', 'n', 'd', '1'};
-    char pic1[4] = {'p', 'i', 'c', '1'};
-    char txt1[4] = {'t', 'x', 't', '1'};
-    char grp1[4] = {'g', 'r', 'p', '1'};
-    char grs1[4] = {'g', 'r', 's', '1'};
-    char gre1[4] = {'g', 'r', 'e', '1'};
-    char pas1[4] = {'p', 'a', 's', '1'};
-    char pae1[4] = {'p', 'a', 'e', '1'};
-
-    if ( memcmp(temp, lyt1, sizeof(lyt1)) == 0)
-    {
-        brlyt_lytheader_chunk lytheader;
-
-        mxml_node_t *subnode = mxmlFindElement(node , node , "drawnFromMiddle", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempChar[4];
-            get_value(subnode, tempChar, 256);
-            lytheader.drawnFromMiddle = atoi(tempChar);
-            lytheader.pad[0]=0;lytheader.pad[1]=0;lytheader.pad[2]=0;
-        }
-        subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode = mxmlFindElement(subnode , subnode , "width", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempChar[4];
-                get_value(valnode, tempChar, 256);
-                *(float*)(&(lytheader.width)) = atof(tempChar);
-            }
-            valnode = mxmlFindElement(subnode , subnode ,"height", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempChar[4];
-                get_value(valnode, tempChar, 256);
-                
-                *(float*)(&(lytheader.height)) = atof(tempChar);
-            }
-        }
-        lytheader.pad[0] = 0; lytheader.pad[1] = 0; lytheader.pad[2] = 0;
-        lytheader.width = float_swap_bytes(lytheader.width);
-        lytheader.height = float_swap_bytes(lytheader.height);
-        fwrite(&lytheader, sizeof(brlyt_header), 1, fp);
-        *fileOffset = *fileOffset + sizeof(lytheader);
-    }
-    if ( memcmp(temp, txl1, sizeof(txl1)) == 0)
-    {
-        int numoffsOffset = ftell(fp);
-
-        brlyt_numoffs_chunk chunk;
-        chunk.num = 0;
-        chunk.offs = 0;
-        fwrite(&chunk, sizeof(chunk), 1, fp);
-        *fileOffset = *fileOffset + sizeof(chunk);
-
-        char *names;
-        names = malloc(sizeof(names));
-        int lengthOfNames = 0;
-        mxml_node_t *subnode = mxmlFindElement(node, node, "entries", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            int numEntries = 0;
-        
-            int oldNameLength;
-            int baseOffset = 0;
-
-            u32 *offsunks;
-
-            offsunks = malloc(sizeof(u32));
-
-            brlyt_offsunk_chunk chunk2;
-            mxml_node_t *valnode;
-            for(valnode = mxmlFindElement(subnode, subnode, "name", NULL, NULL, MXML_DESCEND); valnode != NULL; valnode = mxmlFindElement(valnode, subnode, "name", NULL, NULL, MXML_DESCEND)) {
-                if (valnode != NULL)
-                {
-                    char tempSub[256];
-                    get_value(valnode, tempSub, 256);
-
-                    oldNameLength = lengthOfNames;
-                    lengthOfNames += strlen(tempSub);
-
-                    offsunks = realloc(offsunks, (numEntries + 1)*(2 * sizeof(u32)));
-                    if (offsunks == NULL) printf("NULLed by a realloc\n");
-
-                    offsunks[(numEntries*2)+0] = baseOffset;
-                    offsunks[(numEntries*2)+1] = 0;
-
-                    *fileOffset = *fileOffset + sizeof(chunk2);
-                    numEntries++;
-                    
-                    baseOffset += (strlen(tempSub) + 1);
-
-                    names = realloc(names, 1 + sizeof(char) * lengthOfNames);
-                    strcpy(&names[oldNameLength], tempSub);
-                    char nuller = '\0';
-                    memcpy(&names[lengthOfNames], &nuller, sizeof(char));
-                    lengthOfNames += 1;
-                }
-            }
-            chunk.num = short_swap_bytes(numEntries);
-            chunk.offs = 0;
-            fseek(fp, numoffsOffset, SEEK_SET);
-            fwrite(&chunk, sizeof(chunk), 1, fp);
-
-            int i;
-            for(i=0;i<numEntries;i++) {
-                offsunks[(i*2)+0] = be32(offsunks[(i*2)+0] + (numEntries * 8));
-                offsunks[i*2+1] = 0;
-
-                fwrite(&offsunks[i*2], sizeof(u32), 1, fp);
-                fwrite(&offsunks[i*2+1], sizeof(u32), 1, fp);
-            }
-            free(offsunks);
-        }
-        fseek(fp, *fileOffset, SEEK_SET);
-        fwrite(names, lengthOfNames, 1, fp);
-        *fileOffset = *fileOffset + lengthOfNames;
-        if ((*fileOffset % 4) > 0)
-        {
-            u8 toAdd = 4-(*fileOffset % 4);
-            char nuller[3] = {'\0', '\0', '\0'};
-            fwrite(&nuller, sizeof(char), toAdd, fp);
-            *fileOffset = *fileOffset + toAdd;
-        }
-        textures = malloc(lengthOfNames * sizeof(char));
-        memcpy(textures, names, lengthOfNames * sizeof(char));
-        free(names);
-    }
-    if ( memcmp(temp, fnl1, sizeof(fnl1)) == 0)
-    {
-        brlyt_numoffs_chunk chunk;
-        chunk.num = 0;
-        chunk.offs = 0;
-        fwrite(&chunk, sizeof(chunk), 1, fp);
-        *fileOffset = *fileOffset + sizeof(chunk);
-
-        char *names;
-        names = malloc(sizeof(char));
-        int lengthOfNames = 0;
-        mxml_node_t *subnode = mxmlFindElement(node, node, "entries", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            int numEntries = 0;
-
-            int oldNameLength;
-            int baseOffset = 0;
-            int numoffsOffset = *fileOffset - 4;
-
-            u32 *offsunks;
-            offsunks = malloc(sizeof(u32));
-
-            brlyt_offsunk_chunk chunk2;
-            mxml_node_t *valnode;
-            for(valnode = mxmlFindElement(subnode, subnode, "name", NULL, NULL, MXML_DESCEND); valnode != NULL; valnode = mxmlFindElement(valnode, subnode, "name", NULL, NULL, MXML_DESCEND)) {
-                if (valnode != NULL)
-                {
-                    char tempSub[256];
-                    get_value(valnode, tempSub, 256);
-
-                    oldNameLength = lengthOfNames;
-                    lengthOfNames += strlen(tempSub);
-
-                    offsunks = realloc(offsunks, (numEntries + 1)*(2 * sizeof(u32)));
-                    offsunks[(numEntries*2)+0] = baseOffset;
-                    offsunks[(numEntries*2)+1] = 0;
-
-                    *fileOffset = *fileOffset + sizeof(chunk2);
-                    numEntries++;
-                    
-                    baseOffset += (strlen(tempSub) + 1);
-                    names = realloc(names, 1 + sizeof(char) * lengthOfNames);
-                    memcpy(&names[oldNameLength], tempSub, strlen(tempSub));
-                    char nuller = '\0';
-                    memcpy(&names[lengthOfNames], &nuller, sizeof(char));
-                    lengthOfNames += 1;
-                }
-            }
-            chunk.num = short_swap_bytes(numEntries);
-            chunk.offs = 0;
-            fseek(fp, numoffsOffset, SEEK_SET);
-            fwrite(&chunk, sizeof(chunk), 1, fp);
-
-            int i;
-            for(i=0;i<numEntries;i++) {
-                offsunks[(i*2)+0] = be32(offsunks[(i*2)+0] + (numEntries * 8));
-                offsunks[i*2+1] = 0;
-
-                fwrite(&offsunks[i*2], sizeof(u32), 1, fp);
-                fwrite(&offsunks[i*2+1], sizeof(u32), 1, fp);
-            }
-            free(offsunks);
-        }
-        fseek(fp, *fileOffset, SEEK_SET);
-        fwrite(names, lengthOfNames, 1, fp);
-        *fileOffset = *fileOffset + lengthOfNames;
-        if ((*fileOffset % 4) > 0)
-        {
-            u8 toAdd = 4-(*fileOffset % 4);
-            char nuller[3] = {'\0', '\0', '\0'};
-            fwrite(&nuller, sizeof(char), toAdd, fp);
-            *fileOffset = *fileOffset + toAdd;
-        }
-        free(names);
-    }
-    if ( memcmp(temp, mat1, sizeof(mat1)) == 0)
-    {
-        int numberOfEntries = 0;
-        int actualNumber = 0;
-        brlyt_numoffs_chunk numchunk;
-        brlyt_material_chunk chunk;
-        mxml_node_t *subnode;
-        for(subnode=mxmlFindElement(node, node, "entries", NULL, NULL, MXML_DESCEND);subnode!=NULL;subnode=mxmlFindElement(subnode, node, "entries", NULL, NULL, MXML_DESCEND))
-            numberOfEntries++;
-
-        numchunk.num = short_swap_bytes(numberOfEntries);
-        numchunk.offs = 0;
-        fwrite(&numchunk, sizeof(numchunk), 1, fp);
-        *fileOffset = *fileOffset + sizeof(numchunk);
-
-        int *offsets = calloc(numberOfEntries, sizeof(int));
-        int offsetsOffset = ftell(fp);
-        int materialOffset = 0;
-        actualNumber = numberOfEntries;
-        numberOfEntries = 0;
-        int matSize = 0;
-        int initialOffset = sizeof(numchunk) + 8 + (actualNumber * sizeof(int));
-
-        offsets[numberOfEntries] = be32(matSize + initialOffset);
-        fwrite(&offsets[0], sizeof(int), actualNumber, fp);
-        *fileOffset = *fileOffset + (actualNumber * 4);
-
-        for(subnode=mxmlFindElement(node,node,"entries",NULL,NULL,MXML_DESCEND);subnode!=NULL;subnode=mxmlFindElement(subnode,node,"entries",NULL,NULL,MXML_DESCEND))
-        {
-            numberOfEntries += 1;
-            char temp[256];
-            if(mxmlElementGetAttr(subnode, "name") != NULL)
-                strcpy(temp, mxmlElementGetAttr(subnode, "name"));
-            else{
-                printf("No name attribute found!\nQuitting!\n");
-                exit(1);
-            }
-            memset(chunk.name, 0, 20);
-            strcpy(chunk.name, temp);
-
-            materials = realloc(materials, lengthOfMaterials + strlen(chunk.name) + 1);
-            memcpy(&materials[lengthOfMaterials], chunk.name, strlen(chunk.name) + 1);
-            lengthOfMaterials += (1 + strlen(chunk.name));
-            numberOfMaterials += 1;
-
-            mxml_node_t *setnode;
-            setnode = mxmlFindElement(subnode, subnode, "colors", NULL, NULL, MXML_DESCEND);
-            if (setnode != NULL)
-            {
-                mxml_node_t *valnode;
-                int colorNumber = 0;
-                for (valnode=mxmlFindElement(setnode, setnode, "forecolor", NULL, NULL, MXML_DESCEND) ; valnode != NULL  ; valnode=mxmlFindElement(valnode, setnode, "forecolor", NULL, NULL, MXML_DESCEND) )
-                {
-                    char tempCoord[256];
-                    get_value(valnode, tempCoord, 256);
-                        
-                    chunk.forecolor[colorNumber] = strtol(tempCoord, NULL, 10);
-                    chunk.forecolor[colorNumber] = short_swap_bytes(chunk.forecolor[colorNumber]);
-
-                    colorNumber+=1;
-                }
-                colorNumber = 0;
-                for (valnode=mxmlFindElement(setnode, setnode, "backcolor", NULL, NULL, MXML_DESCEND) ; valnode != NULL  ; valnode=mxmlFindElement(valnode, setnode, "backcolor", NULL, NULL, MXML_DESCEND) )
-                {
-                    char tempCoord[256];
-                    get_value(valnode, tempCoord, 256);
-                    
-                    chunk.backcolor[colorNumber] = strtol(tempCoord, NULL, 10);
-                    chunk.backcolor[colorNumber] = short_swap_bytes(chunk.backcolor[colorNumber]);
-
-                    colorNumber+=1;
-                }
-                colorNumber = 0;
-                for (valnode=mxmlFindElement(setnode, setnode, "colorReg3", NULL, NULL, MXML_DESCEND) ; valnode != NULL  ; valnode=mxmlFindElement(valnode, setnode, "colorReg3", NULL, NULL, MXML_DESCEND) )
-                {
-                    char tempCoord[256];
-                    get_value(valnode, tempCoord, 256);
-                        
-                    chunk.colorReg3[colorNumber] = strtol(tempCoord, NULL, 10);
-                    chunk.colorReg3[colorNumber] = short_swap_bytes(chunk.colorReg3[colorNumber]);
-
-                    colorNumber+=1;
-                }
-                colorNumber = 0;
-                for (valnode=mxmlFindElement(setnode, setnode, "tev_k", NULL, NULL, MXML_DESCEND) ; valnode != NULL  ; valnode=mxmlFindElement(valnode, setnode, "tev_k", NULL, NULL, MXML_DESCEND) )
-                {
-                    char tempCoord[256];
-                    get_value(valnode, tempCoord, 256);
-                    chunk.tev_kcolor[colorNumber] = be32(strtoul(tempCoord, NULL, 16));
-                    colorNumber+=1;
-                }
-            }
+	u32 startOfChunk = *fileOffset;
+
+	char lyt1[4] = {'l', 'y', 't', '1'};
+	char txl1[4] = {'t', 'x', 'l', '1'};
+	char fnl1[4] = {'f', 'n', 'l', '1'};
+	char mat1[4] = {'m', 'a', 't', '1'};
+	char pan1[4] = {'p', 'a', 'n', '1'};
+	char wnd1[4] = {'w', 'n', 'd', '1'};
+	char bnd1[4] = {'b', 'n', 'd', '1'};
+	char pic1[4] = {'p', 'i', 'c', '1'};
+	char txt1[4] = {'t', 'x', 't', '1'};
+	char grp1[4] = {'g', 'r', 'p', '1'};
+	char grs1[4] = {'g', 'r', 's', '1'};
+	char gre1[4] = {'g', 'r', 'e', '1'};
+	char pas1[4] = {'p', 'a', 's', '1'};
+	char pae1[4] = {'p', 'a', 'e', '1'};
+
+	if ( memcmp(temp, lyt1, sizeof(lyt1)) == 0)
+	{
+		brlyt_lytheader_chunk lytheader;
+
+		mxml_node_t *subnode = mxmlFindElement(node , node , "drawnFromMiddle", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempChar[4];
+			get_value(subnode, tempChar, 256);
+			lytheader.drawnFromMiddle = atoi(tempChar);
+			lytheader.pad[0]=0;lytheader.pad[1]=0;lytheader.pad[2]=0;
+		}
+		subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode = mxmlFindElement(subnode , subnode , "width", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempChar[4];
+				get_value(valnode, tempChar, 256);
+				*(float*)(&(lytheader.width)) = atof(tempChar);
+			}
+			valnode = mxmlFindElement(subnode , subnode ,"height", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempChar[4];
+				get_value(valnode, tempChar, 256);
+
+				*(float*)(&(lytheader.height)) = atof(tempChar);
+			}
+		}
+		lytheader.pad[0] = 0; lytheader.pad[1] = 0; lytheader.pad[2] = 0;
+		lytheader.width = float_swap_bytes(lytheader.width);
+		lytheader.height = float_swap_bytes(lytheader.height);
+		fwrite(&lytheader, sizeof(brlyt_header), 1, fp);
+		*fileOffset = *fileOffset + sizeof(lytheader);
+	}
+	if ( memcmp(temp, txl1, sizeof(txl1)) == 0)
+	{
+		int numoffsOffset = ftell(fp);
+
+		brlyt_numoffs_chunk chunk;
+		chunk.num = 0;
+		chunk.offs = 0;
+		fwrite(&chunk, sizeof(chunk), 1, fp);
+		*fileOffset = *fileOffset + sizeof(chunk);
+
+		char *names;
+		names = malloc(sizeof(names));
+		int lengthOfNames = 0;
+		mxml_node_t *subnode = mxmlFindElement(node, node, "entries", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			int numEntries = 0;
+
+			int oldNameLength;
+			int baseOffset = 0;
+
+			u32 *offsunks;
+
+			offsunks = malloc(sizeof(u32));
+
+			brlyt_offsunk_chunk chunk2;
+			mxml_node_t *valnode;
+			for(valnode = mxmlFindElement(subnode, subnode, "name", NULL, NULL, MXML_DESCEND); valnode != NULL; valnode = mxmlFindElement(valnode, subnode, "name", NULL, NULL, MXML_DESCEND)) {
+				if (valnode != NULL)
+				{
+					char tempSub[256];
+					get_value(valnode, tempSub, 256);
+
+					oldNameLength = lengthOfNames;
+					lengthOfNames += strlen(tempSub);
+
+					offsunks = realloc(offsunks, (numEntries + 1)*(2 * sizeof(u32)));
+					if (offsunks == NULL) printf("NULLed by a realloc\n");
+
+					offsunks[(numEntries*2)+0] = baseOffset;
+					offsunks[(numEntries*2)+1] = 0;
+
+					*fileOffset = *fileOffset + sizeof(chunk2);
+					numEntries++;
+
+					baseOffset += (strlen(tempSub) + 1);
+
+					names = realloc(names, 1 + sizeof(char) * lengthOfNames);
+					strcpy(&names[oldNameLength], tempSub);
+					char nuller = '\0';
+					memcpy(&names[lengthOfNames], &nuller, sizeof(char));
+					lengthOfNames += 1;
+				}
+			}
+			chunk.num = short_swap_bytes(numEntries);
+			chunk.offs = 0;
+			fseek(fp, numoffsOffset, SEEK_SET);
+			fwrite(&chunk, sizeof(chunk), 1, fp);
+
+			int i;
+			for(i=0;i<numEntries;i++) {
+				offsunks[(i*2)+0] = be32(offsunks[(i*2)+0] + (numEntries * 8));
+				offsunks[i*2+1] = 0;
+
+				fwrite(&offsunks[i*2], sizeof(u32), 1, fp);
+				fwrite(&offsunks[i*2+1], sizeof(u32), 1, fp);
+			}
+			free(offsunks);
+		}
+		fseek(fp, *fileOffset, SEEK_SET);
+		fwrite(names, lengthOfNames, 1, fp);
+		*fileOffset = *fileOffset + lengthOfNames;
+		if ((*fileOffset % 4) > 0)
+		{
+			u8 toAdd = 4-(*fileOffset % 4);
+			char nuller[3] = {'\0', '\0', '\0'};
+			fwrite(&nuller, sizeof(char), toAdd, fp);
+			*fileOffset = *fileOffset + toAdd;
+		}
+		textures = malloc(lengthOfNames * sizeof(char));
+		memcpy(textures, names, lengthOfNames * sizeof(char));
+		free(names);
+	}
+	if ( memcmp(temp, fnl1, sizeof(fnl1)) == 0)
+	{
+		brlyt_numoffs_chunk chunk;
+		chunk.num = 0;
+		chunk.offs = 0;
+		fwrite(&chunk, sizeof(chunk), 1, fp);
+		*fileOffset = *fileOffset + sizeof(chunk);
+
+		char *names;
+		names = malloc(sizeof(char));
+		int lengthOfNames = 0;
+		mxml_node_t *subnode = mxmlFindElement(node, node, "entries", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			int numEntries = 0;
+
+			int oldNameLength;
+			int baseOffset = 0;
+			int numoffsOffset = *fileOffset - 4;
+
+			u32 *offsunks;
+			offsunks = malloc(sizeof(u32));
+
+			brlyt_offsunk_chunk chunk2;
+			mxml_node_t *valnode;
+			for(valnode = mxmlFindElement(subnode, subnode, "name", NULL, NULL, MXML_DESCEND); valnode != NULL; valnode = mxmlFindElement(valnode, subnode, "name", NULL, NULL, MXML_DESCEND)) {
+				if (valnode != NULL)
+				{
+					char tempSub[256];
+					get_value(valnode, tempSub, 256);
+
+					oldNameLength = lengthOfNames;
+					lengthOfNames += strlen(tempSub);
+
+					offsunks = realloc(offsunks, (numEntries + 1)*(2 * sizeof(u32)));
+					offsunks[(numEntries*2)+0] = baseOffset;
+					offsunks[(numEntries*2)+1] = 0;
+
+					*fileOffset = *fileOffset + sizeof(chunk2);
+					numEntries++;
+
+					baseOffset += (strlen(tempSub) + 1);
+					names = realloc(names, 1 + sizeof(char) * lengthOfNames);
+					memcpy(&names[oldNameLength], tempSub, strlen(tempSub));
+					char nuller = '\0';
+					memcpy(&names[lengthOfNames], &nuller, sizeof(char));
+					lengthOfNames += 1;
+				}
+			}
+			chunk.num = short_swap_bytes(numEntries);
+			chunk.offs = 0;
+			fseek(fp, numoffsOffset, SEEK_SET);
+			fwrite(&chunk, sizeof(chunk), 1, fp);
+
+			int i;
+			for(i=0;i<numEntries;i++) {
+				offsunks[(i*2)+0] = be32(offsunks[(i*2)+0] + (numEntries * 8));
+				offsunks[i*2+1] = 0;
+
+				fwrite(&offsunks[i*2], sizeof(u32), 1, fp);
+				fwrite(&offsunks[i*2+1], sizeof(u32), 1, fp);
+			}
+			free(offsunks);
+		}
+		fseek(fp, *fileOffset, SEEK_SET);
+		fwrite(names, lengthOfNames, 1, fp);
+		*fileOffset = *fileOffset + lengthOfNames;
+		if ((*fileOffset % 4) > 0)
+		{
+			u8 toAdd = 4-(*fileOffset % 4);
+			char nuller[3] = {'\0', '\0', '\0'};
+			fwrite(&nuller, sizeof(char), toAdd, fp);
+			*fileOffset = *fileOffset + toAdd;
+		}
+		free(names);
+	}
+	if ( memcmp(temp, mat1, sizeof(mat1)) == 0)
+	{
+		int numberOfEntries = 0;
+		int actualNumber = 0;
+		brlyt_numoffs_chunk numchunk;
+		brlyt_material_chunk chunk;
+		mxml_node_t *subnode;
+		for(subnode=mxmlFindElement(node, node, "entries", NULL, NULL, MXML_DESCEND);subnode!=NULL;subnode=mxmlFindElement(subnode, node, "entries", NULL, NULL, MXML_DESCEND))
+			numberOfEntries++;
+
+		numchunk.num = short_swap_bytes(numberOfEntries);
+		numchunk.offs = 0;
+		fwrite(&numchunk, sizeof(numchunk), 1, fp);
+		*fileOffset = *fileOffset + sizeof(numchunk);
+
+		int *offsets = calloc(numberOfEntries, sizeof(int));
+		int offsetsOffset = ftell(fp);
+		int materialOffset = 0;
+		actualNumber = numberOfEntries;
+		numberOfEntries = 0;
+		int matSize = 0;
+		int initialOffset = sizeof(numchunk) + 8 + (actualNumber * sizeof(int));
+
+		offsets[numberOfEntries] = be32(matSize + initialOffset);
+		fwrite(&offsets[0], sizeof(int), actualNumber, fp);
+		*fileOffset = *fileOffset + (actualNumber * 4);
+
+		for(subnode=mxmlFindElement(node,node,"entries",NULL,NULL,MXML_DESCEND);subnode!=NULL;subnode=mxmlFindElement(subnode,node,"entries",NULL,NULL,MXML_DESCEND))
+		{
+			numberOfEntries += 1;
+			char temp[256];
+			if(mxmlElementGetAttr(subnode, "name") != NULL)
+				strcpy(temp, mxmlElementGetAttr(subnode, "name"));
+			else{
+				printf("No name attribute found!\nQuitting!\n");
+				exit(1);
+			}
+			memset(chunk.name, 0, 20);
+			strcpy(chunk.name, temp);
+
+			materials = realloc(materials, lengthOfMaterials + strlen(chunk.name) + 1);
+			memcpy(&materials[lengthOfMaterials], chunk.name, strlen(chunk.name) + 1);
+			lengthOfMaterials += (1 + strlen(chunk.name));
+			numberOfMaterials += 1;
+
+			mxml_node_t *setnode;
+			setnode = mxmlFindElement(subnode, subnode, "colors", NULL, NULL, MXML_DESCEND);
+			if (setnode != NULL)
+			{
+				mxml_node_t *valnode;
+				int colorNumber = 0;
+				for (valnode=mxmlFindElement(setnode, setnode, "forecolor", NULL, NULL, MXML_DESCEND) ; valnode != NULL  ; valnode=mxmlFindElement(valnode, setnode, "forecolor", NULL, NULL, MXML_DESCEND) )
+				{
+					char tempCoord[256];
+					get_value(valnode, tempCoord, 256);
+
+					chunk.forecolor[colorNumber] = strtol(tempCoord, NULL, 10);
+					chunk.forecolor[colorNumber] = short_swap_bytes(chunk.forecolor[colorNumber]);
+
+					colorNumber+=1;
+				}
+				colorNumber = 0;
+				for (valnode=mxmlFindElement(setnode, setnode, "backcolor", NULL, NULL, MXML_DESCEND) ; valnode != NULL  ; valnode=mxmlFindElement(valnode, setnode, "backcolor", NULL, NULL, MXML_DESCEND) )
+				{
+					char tempCoord[256];
+					get_value(valnode, tempCoord, 256);
+
+					chunk.backcolor[colorNumber] = strtol(tempCoord, NULL, 10);
+					chunk.backcolor[colorNumber] = short_swap_bytes(chunk.backcolor[colorNumber]);
+
+					colorNumber+=1;
+				}
+				colorNumber = 0;
+				for (valnode=mxmlFindElement(setnode, setnode, "colorReg3", NULL, NULL, MXML_DESCEND) ; valnode != NULL  ; valnode=mxmlFindElement(valnode, setnode, "colorReg3", NULL, NULL, MXML_DESCEND) )
+				{
+					char tempCoord[256];
+					get_value(valnode, tempCoord, 256);
+
+					chunk.colorReg3[colorNumber] = strtol(tempCoord, NULL, 10);
+					chunk.colorReg3[colorNumber] = short_swap_bytes(chunk.colorReg3[colorNumber]);
+
+					colorNumber+=1;
+				}
+				colorNumber = 0;
+				for (valnode=mxmlFindElement(setnode, setnode, "tev_k", NULL, NULL, MXML_DESCEND) ; valnode != NULL  ; valnode=mxmlFindElement(valnode, setnode, "tev_k", NULL, NULL, MXML_DESCEND) )
+				{
+					char tempCoord[256];
+					get_value(valnode, tempCoord, 256);
+					chunk.tev_kcolor[colorNumber] = be32(strtoul(tempCoord, NULL, 16));
+					colorNumber+=1;
+				}
+			}
 			/*
-            setnode = mxmlFindElement(subnode,subnode,"flags",NULL,NULL,MXML_DESCEND);
-            if (setnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(setnode, tempCoord, 256);
-                chunk.flags = be32(strtoul(tempCoord, NULL, 16));
-            }
+			setnode = mxmlFindElement(subnode,subnode,"flags",NULL,NULL,MXML_DESCEND);
+			if (setnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(setnode, tempCoord, 256);
+				chunk.flags = be32(strtoul(tempCoord, NULL, 16));
+			}
 			*/
 
 			u32 tempFileOffset = ftell(fp);
@@ -1644,24 +1653,24 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 			flags.flags = 0;
 			chunk.flags = 0;
 
-            fwrite(&chunk, sizeof(chunk), 1, fp);
-            *fileOffset = *fileOffset + sizeof(chunk);
-            matSize += sizeof(chunk);
-
-            brlyt_texref_chunk chunkTexRef;
-            for(setnode = mxmlFindElement(subnode, subnode, "texture", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "texture", NULL, NULL, MXML_DESCEND))
-            {
-                mxml_node_t *valnode;
-                char temp[256];
-                if(mxmlElementGetAttr(setnode, "name") != NULL)
-                    strcpy(temp, mxmlElementGetAttr(setnode, "name"));
-                else{
-                    printf("No name attribute found!\nQuitting!\n");
-                    exit(1);
-                }
-                chunkTexRef.tex_offs = short_swap_bytes(findTexOffset(temp));
-
-                valnode=mxmlFindElement(setnode, setnode, "wrap_s", NULL, NULL, MXML_DESCEND);
+			fwrite(&chunk, sizeof(chunk), 1, fp);
+			*fileOffset = *fileOffset + sizeof(chunk);
+			matSize += sizeof(chunk);
+
+			brlyt_texref_chunk chunkTexRef;
+			for(setnode = mxmlFindElement(subnode, subnode, "texture", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "texture", NULL, NULL, MXML_DESCEND))
+			{
+				mxml_node_t *valnode;
+				char temp[256];
+				if(mxmlElementGetAttr(setnode, "name") != NULL)
+					strcpy(temp, mxmlElementGetAttr(setnode, "name"));
+				else{
+					printf("No name attribute found!\nQuitting!\n");
+					exit(1);
+				}
+				chunkTexRef.tex_offs = short_swap_bytes(findTexOffset(temp));
+
+				valnode=mxmlFindElement(setnode, setnode, "wrap_s", NULL, NULL, MXML_DESCEND);
 
 				char wraps[4][20];
 				int l;
@@ -1672,8 +1681,8 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 				strcpy( wraps[2] , "GX_MIRROR" );
 				strcpy( wraps[3] , "GX_MAXTEXWRAPMODE" );
 
-			    char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
 				chunkTexRef.wrap_s = strtoul(tempCoord, NULL, 16);
 				for ( l = 0 ; l < 4 ; l++ ) {
 					if ( strncmp( wraps[l] , tempCoord , 17 ) == 0 ) {
@@ -1682,9 +1691,9 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 					}
 				}
 
-                valnode=mxmlFindElement(setnode, setnode, "wrap_t", NULL, NULL, MXML_DESCEND);
+				valnode=mxmlFindElement(setnode, setnode, "wrap_t", NULL, NULL, MXML_DESCEND);
 
-                get_value(valnode, tempCoord, 256);
+				get_value(valnode, tempCoord, 256);
 				chunkTexRef.wrap_t = strtoul(tempCoord, NULL, 16);
 				for ( l = 0 ; l < 4 ; l++ ) {
 					if ( strncmp( wraps[l] , tempCoord , 17 ) == 0 ) {
@@ -1695,47 +1704,47 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 
 				flags.flag.Texture++;
 
-                fwrite(&chunkTexRef, sizeof(chunkTexRef), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkTexRef);
-                matSize += sizeof(chunkTexRef);
-            }
-
-            brlyt_tex_srt chunkTexCoords;
-            for(setnode = mxmlFindElement(subnode, subnode, "TextureSRT", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "TextureSRT", NULL, NULL, MXML_DESCEND))
-            {
-                char tempCoord[256];
-                mxml_node_t *valnode;
-                valnode=mxmlFindElement(setnode, setnode, "XTrans", NULL, NULL, MXML_DESCEND);
+				fwrite(&chunkTexRef, sizeof(chunkTexRef), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkTexRef);
+				matSize += sizeof(chunkTexRef);
+			}
+
+			brlyt_tex_srt chunkTexCoords;
+			for(setnode = mxmlFindElement(subnode, subnode, "TextureSRT", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "TextureSRT", NULL, NULL, MXML_DESCEND))
+			{
+				char tempCoord[256];
+				mxml_node_t *valnode;
+				valnode=mxmlFindElement(setnode, setnode, "XTrans", NULL, NULL, MXML_DESCEND);
 		memset(tempCoord, 0, 256);
-                get_value(valnode, tempCoord, 256);
-                chunkTexCoords.XTrans = float_swap_bytes(atof(tempCoord));
-                valnode=mxmlFindElement(setnode, setnode, "YTrans", NULL, NULL, MXML_DESCEND);
+				get_value(valnode, tempCoord, 256);
+				chunkTexCoords.XTrans = float_swap_bytes(atof(tempCoord));
+				valnode=mxmlFindElement(setnode, setnode, "YTrans", NULL, NULL, MXML_DESCEND);
 		memset(tempCoord, 0, 256);
-                get_value(valnode, tempCoord, 256);
-                chunkTexCoords.YTrans = float_swap_bytes(atof(tempCoord));
-                valnode=mxmlFindElement(setnode, setnode, "Rotate", NULL, NULL, MXML_DESCEND);
+				get_value(valnode, tempCoord, 256);
+				chunkTexCoords.YTrans = float_swap_bytes(atof(tempCoord));
+				valnode=mxmlFindElement(setnode, setnode, "Rotate", NULL, NULL, MXML_DESCEND);
 		memset(tempCoord, 0, 256);
-                get_value(valnode, tempCoord, 256);
-                chunkTexCoords.Rotate = float_swap_bytes(atof(tempCoord));
-                valnode=mxmlFindElement(setnode, setnode, "XScale", NULL, NULL, MXML_DESCEND);
+				get_value(valnode, tempCoord, 256);
+				chunkTexCoords.Rotate = float_swap_bytes(atof(tempCoord));
+				valnode=mxmlFindElement(setnode, setnode, "XScale", NULL, NULL, MXML_DESCEND);
 		memset(tempCoord, 0, 256);
-                get_value(valnode, tempCoord, 256);
-                chunkTexCoords.XScale = float_swap_bytes(atof(tempCoord));
-                valnode=mxmlFindElement(setnode, setnode, "YScale", NULL, NULL, MXML_DESCEND);
+				get_value(valnode, tempCoord, 256);
+				chunkTexCoords.XScale = float_swap_bytes(atof(tempCoord));
+				valnode=mxmlFindElement(setnode, setnode, "YScale", NULL, NULL, MXML_DESCEND);
 		memset(tempCoord, 0, 256);
-                get_value(valnode, tempCoord, 256);
-                chunkTexCoords.YScale = float_swap_bytes(atof(tempCoord));
+				get_value(valnode, tempCoord, 256);
+				chunkTexCoords.YScale = float_swap_bytes(atof(tempCoord));
 
 				flags.flag.TexSRT++;
 
-                fwrite(&chunkTexCoords, sizeof(chunkTexCoords), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkTexCoords);
-                matSize += sizeof(chunkTexCoords);
-            }
+				fwrite(&chunkTexCoords, sizeof(chunkTexCoords), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkTexCoords);
+				matSize += sizeof(chunkTexCoords);
+			}
 
-            brlyt_tex_coordgen chunkUa3;
-            for(setnode = mxmlFindElement(subnode, subnode, "CoordGen", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "CoordGen", NULL, NULL, MXML_DESCEND))
-            {
+			brlyt_tex_coordgen chunkUa3;
+			for(setnode = mxmlFindElement(subnode, subnode, "CoordGen", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "CoordGen", NULL, NULL, MXML_DESCEND))
+			{
 				char tgen_types[4][20];
 				int l;
 				for ( l = 0 ; l < 4 ; l++ )
@@ -1823,7 +1832,7 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 				strcpy( mtxsrc[40] , "GX_DTTMTX19" );
 				strcpy( mtxsrc[41] , "GX_DTTIDENTITY" );	// actually 125 not 124
 
-                mxml_node_t *valnode;
+				mxml_node_t *valnode;
 				char tempCoord[256];
 
 				valnode=mxmlFindElement(setnode, setnode, "tgen_type", NULL, NULL, MXML_DESCEND);
@@ -1869,14 +1878,14 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 
 				flags.flag.TexCoord++;
 
-                fwrite(&chunkUa3, sizeof(chunkUa3), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkUa3);
-                matSize += sizeof(chunkUa3);
-            }
+				fwrite(&chunkUa3, sizeof(chunkUa3), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkUa3);
+				matSize += sizeof(chunkUa3);
+			}
 
-            brlyt_tex_chanctrl chunkUa4;
-            for(setnode = mxmlFindElement(subnode, subnode, "ChanControl", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "ChanControl", NULL, NULL, MXML_DESCEND))
-            {
+			brlyt_tex_chanctrl chunkUa4;
+			for(setnode = mxmlFindElement(subnode, subnode, "ChanControl", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "ChanControl", NULL, NULL, MXML_DESCEND))
+			{
 				char matsrc[2][20];
 				int l;
 				for ( l = 0 ; l < 2 ; l++ )
@@ -1884,7 +1893,7 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 				strcpy( matsrc[0]  , "GX_SRC_REG" );
 				strcpy( matsrc[1]  , "GX_SRC_VTX" );
 
-                mxml_node_t *valnode;
+				mxml_node_t *valnode;
 				char tempCoord[256];
 
 				valnode=mxmlFindElement(setnode, setnode, "ColorMatSource", NULL, NULL, MXML_DESCEND);
@@ -1925,15 +1934,15 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 
 				flags.flag.ua4++;
 
-                fwrite(&chunkUa4, sizeof(chunkUa4), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkUa4);
-                matSize += sizeof(chunkUa4);
-            }
+				fwrite(&chunkUa4, sizeof(chunkUa4), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkUa4);
+				matSize += sizeof(chunkUa4);
+			}
 
-            brlyt_tex_matcol chunkUa5;
-            for(setnode = mxmlFindElement(subnode, subnode, "MaterialColor", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "MaterialColor", NULL, NULL, MXML_DESCEND))
-            {
-                mxml_node_t *valnode;
+			brlyt_tex_matcol chunkUa5;
+			for(setnode = mxmlFindElement(subnode, subnode, "MaterialColor", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "MaterialColor", NULL, NULL, MXML_DESCEND))
+			{
+				mxml_node_t *valnode;
 				char tempCoord[256];
 
 				valnode=mxmlFindElement(setnode, setnode, "red", NULL, NULL, MXML_DESCEND);
@@ -1958,13 +1967,13 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 
 				flags.flag.ua5++;
 
-                fwrite(&chunkUa5, sizeof(chunkUa5), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkUa5);
-                matSize += sizeof(chunkUa5);
-            }
-            brlyt_tev_swapmodetable chunkUa6;
-            for(setnode = mxmlFindElement(subnode, subnode, "TevSwapModeTable", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "TevSwapModeTable", NULL, NULL, MXML_DESCEND))
-            {
+				fwrite(&chunkUa5, sizeof(chunkUa5), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkUa5);
+				matSize += sizeof(chunkUa5);
+			}
+			brlyt_tev_swapmodetable chunkUa6;
+			for(setnode = mxmlFindElement(subnode, subnode, "TevSwapModeTable", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "TevSwapModeTable", NULL, NULL, MXML_DESCEND))
+			{
 				char tevcolor[4][20];
 				int l;
 				for ( l = 0 ; l < 4 ; l++ )
@@ -1974,7 +1983,7 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 				strcpy( tevcolor[2]  , "GX_CH_BLUE" );
 				strcpy( tevcolor[3]  , "GX_CH_ALPHA" );
 
-                mxml_node_t *valnode;
+				mxml_node_t *valnode;
 				char tempCoord[256];
 
 				valnode=mxmlFindElement(setnode, setnode, "OneRed", NULL, NULL, MXML_DESCEND);
@@ -2163,60 +2172,60 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 
 				flags.flag.ua6++;
 
-                fwrite(&chunkUa6, sizeof(chunkUa6), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkUa6);
-                matSize += sizeof(chunkUa6);
-            }
-
-            brlyt_indtex_srt chunkUa7;
-            for(setnode = mxmlFindElement(subnode, subnode, "IndTextureSRT", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "IndTextureSRT", NULL, NULL, MXML_DESCEND))
-            {
-                mxml_node_t *valnode;
-                valnode=mxmlFindElement(setnode, setnode, "XTrans", NULL, NULL, MXML_DESCEND);
-                if ( valnode != NULL )
-                {
-                        char tempCoord[256];
-                        get_value(valnode, tempCoord, 256);
-                        chunkUa7.XTrans = float_swap_bytes(atof(tempCoord));
-                }
-                valnode=mxmlFindElement(setnode, setnode, "YTrans", NULL, NULL, MXML_DESCEND);
-                if ( valnode != NULL )
-                {
-                        char tempCoord[256];
-                        get_value(valnode, tempCoord, 256);
-                        chunkUa7.YTrans = float_swap_bytes(atof(tempCoord));
-                }
-                valnode=mxmlFindElement(setnode, setnode, "Rotate", NULL, NULL, MXML_DESCEND);
-                if ( valnode != NULL )
-                {
-                        char tempCoord[256];
-                        get_value(valnode, tempCoord, 256);
-                        chunkUa7.Rotate = float_swap_bytes(atof(tempCoord));
-                }
-                valnode=mxmlFindElement(setnode, setnode, "XScale", NULL, NULL, MXML_DESCEND);
-                if ( valnode != NULL )
-                {
-                        char tempCoord[256];
-                        get_value(valnode, tempCoord, 256);
-                        chunkUa7.XScale = float_swap_bytes(atof(tempCoord));
-                }
-                valnode=mxmlFindElement(setnode, setnode, "YScale", NULL, NULL, MXML_DESCEND);
-                if ( valnode != NULL )
-                {
-                        char tempCoord[256];
-                        get_value(valnode, tempCoord, 256);
-                        chunkUa7.YScale = float_swap_bytes(atof(tempCoord));
-                }
+				fwrite(&chunkUa6, sizeof(chunkUa6), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkUa6);
+				matSize += sizeof(chunkUa6);
+			}
+
+			brlyt_indtex_srt chunkUa7;
+			for(setnode = mxmlFindElement(subnode, subnode, "IndTextureSRT", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "IndTextureSRT", NULL, NULL, MXML_DESCEND))
+			{
+				mxml_node_t *valnode;
+				valnode=mxmlFindElement(setnode, setnode, "XTrans", NULL, NULL, MXML_DESCEND);
+				if ( valnode != NULL )
+				{
+						char tempCoord[256];
+						get_value(valnode, tempCoord, 256);
+						chunkUa7.XTrans = float_swap_bytes(atof(tempCoord));
+				}
+				valnode=mxmlFindElement(setnode, setnode, "YTrans", NULL, NULL, MXML_DESCEND);
+				if ( valnode != NULL )
+				{
+						char tempCoord[256];
+						get_value(valnode, tempCoord, 256);
+						chunkUa7.YTrans = float_swap_bytes(atof(tempCoord));
+				}
+				valnode=mxmlFindElement(setnode, setnode, "Rotate", NULL, NULL, MXML_DESCEND);
+				if ( valnode != NULL )
+				{
+						char tempCoord[256];
+						get_value(valnode, tempCoord, 256);
+						chunkUa7.Rotate = float_swap_bytes(atof(tempCoord));
+				}
+				valnode=mxmlFindElement(setnode, setnode, "XScale", NULL, NULL, MXML_DESCEND);
+				if ( valnode != NULL )
+				{
+						char tempCoord[256];
+						get_value(valnode, tempCoord, 256);
+						chunkUa7.XScale = float_swap_bytes(atof(tempCoord));
+				}
+				valnode=mxmlFindElement(setnode, setnode, "YScale", NULL, NULL, MXML_DESCEND);
+				if ( valnode != NULL )
+				{
+						char tempCoord[256];
+						get_value(valnode, tempCoord, 256);
+						chunkUa7.YScale = float_swap_bytes(atof(tempCoord));
+				}
 
 				flags.flag.ua7++;
 
-                fwrite(&chunkUa7, sizeof(chunkUa7), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkUa7);
-                matSize += sizeof(chunkUa7);
-            }
-            brlyt_indtex_order chunkUa8;
-            for(setnode = mxmlFindElement(subnode, subnode, "IndTextureOrder", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "IndTextureOrder", NULL, NULL, MXML_DESCEND))
-            {
+				fwrite(&chunkUa7, sizeof(chunkUa7), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkUa7);
+				matSize += sizeof(chunkUa7);
+			}
+			brlyt_indtex_order chunkUa8;
+			for(setnode = mxmlFindElement(subnode, subnode, "IndTextureOrder", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "IndTextureOrder", NULL, NULL, MXML_DESCEND))
+			{
 				char scale[10][20];
 				int l;
 				for ( l = 0 ; l < 10 ; l++ )
@@ -2232,7 +2241,7 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 				strcpy( scale[8]  , "GX_ITS_256" );
 				strcpy( scale[9]  , "GX_MAX_ITSCALE" );
 
-                mxml_node_t *valnode;
+				mxml_node_t *valnode;
 				char tempCoord[256];
 
 				valnode=mxmlFindElement(setnode, setnode, "TextureCoordinate", NULL, NULL, MXML_DESCEND);
@@ -2269,15 +2278,15 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 
 				flags.flag.ua8++;
 
-                fwrite(&chunkUa8, sizeof(chunkUa8), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkUa8);
-                matSize += sizeof(chunkUa8);
-            }
+				fwrite(&chunkUa8, sizeof(chunkUa8), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkUa8);
+				matSize += sizeof(chunkUa8);
+			}
 
 			TevStages chunkUa9;
-            for (setnode = mxmlFindElement(subnode, subnode, "TevStage", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "TevStage", NULL, NULL, MXML_DESCEND))
-            {
-                mxml_node_t *valnode;
+			for (setnode = mxmlFindElement(subnode, subnode, "TevStage", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "TevStage", NULL, NULL, MXML_DESCEND))
+			{
+				mxml_node_t *valnode;
 				char tempCoord[256];
 
 				valnode=mxmlFindElement(setnode, setnode, "TextureCoordinate", NULL, NULL, MXML_DESCEND);
@@ -2478,14 +2487,14 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 
 				flags.flag.ua9++;
 
-                fwrite(&chunkUa9, sizeof(chunkUa9), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkUa9);
-                matSize += sizeof(chunkUa9);
-            }
+				fwrite(&chunkUa9, sizeof(chunkUa9), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkUa9);
+				matSize += sizeof(chunkUa9);
+			}
 
-            brlyt_alpha_compare chunkUaa;
-            for(setnode = mxmlFindElement(subnode, subnode, "AlphaCompare", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "AlphaCompare", NULL, NULL, MXML_DESCEND))
-            {
+			brlyt_alpha_compare chunkUaa;
+			for(setnode = mxmlFindElement(subnode, subnode, "AlphaCompare", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "AlphaCompare", NULL, NULL, MXML_DESCEND))
+			{
 				char compare[8][20];
 				int l;
 				for ( l = 0 ; l < 8 ; l++ )
@@ -2508,7 +2517,7 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 				strcpy( aop[3]  , "GX_AOP_XNOR" );
 				strcpy( aop[4]  , "GX_MAX_ALPHAOP" );
 
-                mxml_node_t *valnode;
+				mxml_node_t *valnode;
 				char tempCoord[256];
 
 				valnode=mxmlFindElement(setnode, setnode, "comp0", NULL, NULL, MXML_DESCEND);
@@ -2556,14 +2565,14 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 
 				flags.flag.uaa++;
 
-                fwrite(&chunkUaa, sizeof(chunkUaa), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkUaa);
-                matSize += sizeof(chunkUaa);
-            }
+				fwrite(&chunkUaa, sizeof(chunkUaa), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkUaa);
+				matSize += sizeof(chunkUaa);
+			}
 
-            brlyt_blend_mode chunkUab;
-            for(setnode = mxmlFindElement(subnode, subnode, "BlendMode", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "BlendMode", NULL, NULL, MXML_DESCEND))
-            {
+			brlyt_blend_mode chunkUab;
+			for(setnode = mxmlFindElement(subnode, subnode, "BlendMode", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "BlendMode", NULL, NULL, MXML_DESCEND))
+			{
 				char blendmode[5][20];
 				int l;
 				for ( l = 0 ; l < 5 ; l++ )
@@ -2606,7 +2615,7 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 				strcpy( logicop[14]  , "GX_LO_NAND" );
 				strcpy( logicop[15]  , "GX_LO_SET" );
 
-                mxml_node_t *valnode;
+				mxml_node_t *valnode;
 				char tempCoord[256];
 
 				valnode=mxmlFindElement(setnode, setnode, "type", NULL, NULL, MXML_DESCEND);
@@ -2655,161 +2664,161 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 
 				flags.flag.uab++;
 
-                fwrite(&chunkUab, sizeof(chunkUab), 1, fp);
-                *fileOffset = *fileOffset + sizeof(chunkUab);
-                matSize += sizeof(chunkUab);
-            }
+				fwrite(&chunkUab, sizeof(chunkUab), 1, fp);
+				*fileOffset = *fileOffset + sizeof(chunkUab);
+				matSize += sizeof(chunkUab);
+			}
 
 			// write mat1_header with flags
 			chunk.flags = be32( flags.flags );
 			u32 end = ftell(fp);
 			fseek( fp , tempFileOffset , SEEK_SET );
-            fwrite(&chunk, sizeof(chunk), 1, fp);
+			fwrite(&chunk, sizeof(chunk), 1, fp);
 			fseek( fp , end , SEEK_SET );
 
-            if (numberOfEntries < actualNumber)
-            {
-                offsets[numberOfEntries] = be32(matSize + initialOffset);
-                materialOffset = ftell(fp);
-                fseek(fp, offsetsOffset+(numberOfEntries * sizeof(int)), SEEK_SET);
-                fwrite(&offsets[numberOfEntries], sizeof(int), 1, fp);
-                fseek(fp, materialOffset, SEEK_SET);
-                initialOffset += matSize;
-                matSize = 0;
-            }
-        }
-        free(offsets);
-    }
-    if ( memcmp(temp, pan1, sizeof(pan1)) == 0)
-    {
-        brlyt_pane_chunk chunk;
-        char temp[256];
-        if(mxmlElementGetAttr(node, "name") != NULL)
-            strcpy(temp, mxmlElementGetAttr(node, "name"));
-        else{
-            printf("No name attribute found!\nQuitting!\n");
-            exit(1);
-        }
-        memset(chunk.name, 0, 24);
-        strcpy(chunk.name, temp);
-
-        mxml_node_t *subnode = mxmlFindElement(node, node, "translate", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XTrans = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YTrans = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.ZTrans = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "rotate", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XRotate = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YRotate = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.ZRotate = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "scale", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XScale = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YScale = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "width", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.width = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "height", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.height = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        
+			if (numberOfEntries < actualNumber)
+			{
+				offsets[numberOfEntries] = be32(matSize + initialOffset);
+				materialOffset = ftell(fp);
+				fseek(fp, offsetsOffset+(numberOfEntries * sizeof(int)), SEEK_SET);
+				fwrite(&offsets[numberOfEntries], sizeof(int), 1, fp);
+				fseek(fp, materialOffset, SEEK_SET);
+				initialOffset += matSize;
+				matSize = 0;
+			}
+		}
+		free(offsets);
+	}
+	if ( memcmp(temp, pan1, sizeof(pan1)) == 0)
+	{
+		brlyt_pane_chunk chunk;
+		char temp[256];
+		if(mxmlElementGetAttr(node, "name") != NULL)
+			strcpy(temp, mxmlElementGetAttr(node, "name"));
+		else{
+			printf("No name attribute found!\nQuitting!\n");
+			exit(1);
+		}
+		memset(chunk.name, 0, 24);
+		strcpy(chunk.name, temp);
+
+		mxml_node_t *subnode = mxmlFindElement(node, node, "translate", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XTrans = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YTrans = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.ZTrans = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "rotate", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XRotate = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YRotate = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.ZRotate = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "scale", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XScale = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YScale = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "width", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.width = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "height", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.height = float_swap_bytes(atof(tempCoord));
+			}
+		}
+
 		u8 flag1 = 0;
-        subnode = mxmlFindElement(node, node, "visible", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= strtol(tempCoord, NULL, 16);
-        }
-        subnode = mxmlFindElement(node, node, "WidescreenAffected", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= ( strtol(tempCoord, NULL, 16) << 1 );
-        }
-        subnode = mxmlFindElement(node, node, "flag", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= ( strtol(tempCoord, NULL, 16) << 2 );
-        }
+		subnode = mxmlFindElement(node, node, "visible", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= strtol(tempCoord, NULL, 16);
+		}
+		subnode = mxmlFindElement(node, node, "WidescreenAffected", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= ( strtol(tempCoord, NULL, 16) << 1 );
+		}
+		subnode = mxmlFindElement(node, node, "flag", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= ( strtol(tempCoord, NULL, 16) << 2 );
+		}
 		chunk.flag1 = flag1;
-        subnode = mxmlFindElement(node, node, "origin", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
+		subnode = mxmlFindElement(node, node, "origin", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
 			char origins[9][15];
 			memset( origins , 0 , 8 * 20 );
 			strcpy( origins[0] , "TOP LEFT" );
@@ -2822,9 +2831,9 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 			strcpy( origins[7] , "BOTTOM CENTER" );
 			strcpy( origins[8] , "BOTTOM RIGHT" );
 
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.origin = strtol(tempCoord, NULL, 16);
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.origin = strtol(tempCoord, NULL, 16);
 			int i;
 			for ( i = 0 ; i < 9 ; i++ ) {
 				if ( strncmp( origins[i] , tempCoord , 15 ) == 0 ) {
@@ -2832,154 +2841,154 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 					break;
 				}
 			}
-        }
-        subnode = mxmlFindElement(node, node, "alpha", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.alpha = strtol(tempCoord, NULL, 16);
-        }
-        subnode = mxmlFindElement(node, node, "padding", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.pad = strtol(tempCoord, NULL, 16);
-        }
-        fwrite(&chunk, sizeof(chunk), 1, fp);
-        *fileOffset = *fileOffset + sizeof(chunk);
-    }
-    if ( memcmp(temp, bnd1, sizeof(bnd1)) == 0)
-    {
-        brlyt_pane_chunk chunk;
-        char temp[256];
-        if(mxmlElementGetAttr(node, "name") != NULL)
-            strcpy(temp, mxmlElementGetAttr(node, "name"));
-        else{
-            printf("No name attribute found!\nQuitting!\n");
-            exit(1);
-        }
-        memset(chunk.name, 0, 24 * sizeof(char));
-        strcpy(chunk.name, temp);
-
-        mxml_node_t *subnode = mxmlFindElement(node, node, "translate", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XTrans = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YTrans = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.ZTrans = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "rotate", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XRotate = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YRotate = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.ZRotate = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "scale", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XScale = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YScale = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "width", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.width = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "height", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.height = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        
+		}
+		subnode = mxmlFindElement(node, node, "alpha", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.alpha = strtol(tempCoord, NULL, 16);
+		}
+		subnode = mxmlFindElement(node, node, "padding", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.pad = strtol(tempCoord, NULL, 16);
+		}
+		fwrite(&chunk, sizeof(chunk), 1, fp);
+		*fileOffset = *fileOffset + sizeof(chunk);
+	}
+	if ( memcmp(temp, bnd1, sizeof(bnd1)) == 0)
+	{
+		brlyt_pane_chunk chunk;
+		char temp[256];
+		if(mxmlElementGetAttr(node, "name") != NULL)
+			strcpy(temp, mxmlElementGetAttr(node, "name"));
+		else{
+			printf("No name attribute found!\nQuitting!\n");
+			exit(1);
+		}
+		memset(chunk.name, 0, 24 * sizeof(char));
+		strcpy(chunk.name, temp);
+
+		mxml_node_t *subnode = mxmlFindElement(node, node, "translate", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XTrans = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YTrans = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.ZTrans = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "rotate", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XRotate = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YRotate = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.ZRotate = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "scale", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XScale = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YScale = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "width", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.width = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "height", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.height = float_swap_bytes(atof(tempCoord));
+			}
+		}
+
 		u8 flag1 = 0;
-        subnode = mxmlFindElement(node, node, "visible", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= strtol(tempCoord, NULL, 16);
-        }
-        subnode = mxmlFindElement(node, node, "WidescreenAffected", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= ( strtol(tempCoord, NULL, 16) << 1 );
-        }
-        subnode = mxmlFindElement(node, node, "flag", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= ( strtol(tempCoord, NULL, 16) << 2 );
-        }
+		subnode = mxmlFindElement(node, node, "visible", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= strtol(tempCoord, NULL, 16);
+		}
+		subnode = mxmlFindElement(node, node, "WidescreenAffected", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= ( strtol(tempCoord, NULL, 16) << 1 );
+		}
+		subnode = mxmlFindElement(node, node, "flag", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= ( strtol(tempCoord, NULL, 16) << 2 );
+		}
 		chunk.flag1 = flag1;
-        subnode = mxmlFindElement(node, node, "origin", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
+		subnode = mxmlFindElement(node, node, "origin", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
 			char origins[9][15];
 			memset( origins , 0 , 8 * 20 );
 			strcpy( origins[0] , "TOP LEFT" );
@@ -2992,9 +3001,9 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 			strcpy( origins[7] , "BOTTOM CENTER" );
 			strcpy( origins[8] , "BOTTOM RIGHT" );
 
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.origin = strtol(tempCoord, NULL, 16);
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.origin = strtol(tempCoord, NULL, 16);
 			int i;
 			for ( i = 0 ; i < 9 ; i++ ) {
 				if ( strncmp( origins[i] , tempCoord , 15 ) == 0 ) {
@@ -3002,154 +3011,154 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 					break;
 				}
 			}
-        }
-        subnode = mxmlFindElement(node, node, "alpha", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.alpha = strtol(tempCoord, NULL, 16);
-        }
-        subnode = mxmlFindElement(node, node, "padding", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.pad = strtol(tempCoord, NULL, 16);
-        }
-        fwrite(&chunk, sizeof(chunk), 1, fp);
-        *fileOffset = *fileOffset + sizeof(chunk);
-    }
-    if ( memcmp(temp, wnd1, sizeof(wnd1)) == 0)
-    {
-        brlyt_pane_chunk chunk;
-        char temp[256];
-        if(mxmlElementGetAttr(node, "name") != NULL)
-            strcpy(temp, mxmlElementGetAttr(node, "name"));
-        else{
-            printf("No name attribute found!\nQuitting!\n");
-            exit(1);
-        }
-        memset(chunk.name, 0, 24 * sizeof(char));
-        strcpy(chunk.name, temp);
-
-        mxml_node_t *subnode = mxmlFindElement(node, node, "translate", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XTrans = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YTrans = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.ZTrans = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "rotate", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XRotate = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YRotate = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.ZRotate = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "scale", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XScale = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YScale = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "width", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.width = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "height", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.height = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        
+		}
+		subnode = mxmlFindElement(node, node, "alpha", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.alpha = strtol(tempCoord, NULL, 16);
+		}
+		subnode = mxmlFindElement(node, node, "padding", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.pad = strtol(tempCoord, NULL, 16);
+		}
+		fwrite(&chunk, sizeof(chunk), 1, fp);
+		*fileOffset = *fileOffset + sizeof(chunk);
+	}
+	if ( memcmp(temp, wnd1, sizeof(wnd1)) == 0)
+	{
+		brlyt_pane_chunk chunk;
+		char temp[256];
+		if(mxmlElementGetAttr(node, "name") != NULL)
+			strcpy(temp, mxmlElementGetAttr(node, "name"));
+		else{
+			printf("No name attribute found!\nQuitting!\n");
+			exit(1);
+		}
+		memset(chunk.name, 0, 24 * sizeof(char));
+		strcpy(chunk.name, temp);
+
+		mxml_node_t *subnode = mxmlFindElement(node, node, "translate", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XTrans = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YTrans = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.ZTrans = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "rotate", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XRotate = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YRotate = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.ZRotate = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "scale", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XScale = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YScale = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "width", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.width = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "height", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.height = float_swap_bytes(atof(tempCoord));
+			}
+		}
+
 		u8 flag1 = 0;
-        subnode = mxmlFindElement(node, node, "visible", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= strtol(tempCoord, NULL, 16);
-        }
-        subnode = mxmlFindElement(node, node, "WidescreenAffected", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= ( strtol(tempCoord, NULL, 16) << 1 );
-        }
-        subnode = mxmlFindElement(node, node, "flag", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= ( strtol(tempCoord, NULL, 16) << 2 );
-        }
+		subnode = mxmlFindElement(node, node, "visible", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= strtol(tempCoord, NULL, 16);
+		}
+		subnode = mxmlFindElement(node, node, "WidescreenAffected", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= ( strtol(tempCoord, NULL, 16) << 1 );
+		}
+		subnode = mxmlFindElement(node, node, "flag", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= ( strtol(tempCoord, NULL, 16) << 2 );
+		}
 		chunk.flag1 = flag1;
-        subnode = mxmlFindElement(node, node, "origin", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
+		subnode = mxmlFindElement(node, node, "origin", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
 			char origins[9][15];
 			memset( origins , 0 , 8 * 20 );
 			strcpy( origins[0] , "TOP LEFT" );
@@ -3162,9 +3171,9 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 			strcpy( origins[7] , "BOTTOM CENTER" );
 			strcpy( origins[8] , "BOTTOM RIGHT" );
 
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.origin = strtol(tempCoord, NULL, 16);
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.origin = strtol(tempCoord, NULL, 16);
 			int i;
 			for ( i = 0 ; i < 9 ; i++ ) {
 				if ( strncmp( origins[i] , tempCoord , 15 ) == 0 ) {
@@ -3172,304 +3181,304 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 					break;
 				}
 			}
-        }
-        subnode = mxmlFindElement(node, node, "alpha", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.alpha = strtol(tempCoord, NULL, 16);
-        }
-        subnode = mxmlFindElement(node, node, "padding", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.pad = strtol(tempCoord, NULL, 16);
-        }
-        fwrite(&chunk, sizeof(chunk), 1, fp);
-        *fileOffset = *fileOffset + sizeof(chunk);
-
-        int i;
-        brlyt_wnd wndy;
-        subnode = mxmlFindElement(node, node, "wnd", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            i = 0;
-            mxml_node_t *subsubnode;
-            for(subsubnode = mxmlFindElement(subnode, subnode, "coordinate", NULL, NULL, MXML_DESCEND); subsubnode != NULL; subsubnode = mxmlFindElement(subsubnode, subnode, "coordinate", NULL, NULL, MXML_DESCEND))
-            {
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy.coords[i] = float_swap_bytes(atof(tempCoord));
-                i++;
-            }
-            subsubnode = mxmlFindElement(subnode, subnode, "FrameCount", NULL, NULL, MXML_DESCEND);
-            if(subsubnode != NULL)
-            {
-                
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy.frame_count = (u8)(strtoul(tempCoord, NULL, 16));
-            }
-            wndy.padding[0] = 0x0;
-            wndy.padding[1] = 0x0;
-            wndy.padding[2] = 0x0;
-
-            subsubnode = mxmlFindElement(subnode, subnode, "offset1", NULL, NULL, MXML_DESCEND);
-            if(subsubnode != NULL)
-            {
-
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy.offset1 = be32(strtoul(tempCoord, NULL, 16));
-            }
-            subsubnode = mxmlFindElement(subnode, subnode, "offset2", NULL, NULL, MXML_DESCEND);
-            if(subsubnode != NULL)
-            {
-
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy.offset2 = be32(strtoul(tempCoord, NULL, 16));
-            }
-            fwrite(&wndy, sizeof(brlyt_wnd), 1, fp);
-            *fileOffset = *fileOffset + sizeof(brlyt_wnd);
-        }
-
-        brlyt_wnd1 wndy1;
-        subnode = mxmlFindElement(node, node, "wnd1", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            i=0;
-            mxml_node_t *subsubnode;
-            for(subsubnode = mxmlFindElement(subnode, subnode, "color", NULL, NULL, MXML_DESCEND); subsubnode != NULL; subsubnode = mxmlFindElement(subsubnode, subnode, "color", NULL, NULL, MXML_DESCEND))
-            {
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy1.colors[i] = be32(strtoul(tempCoord, NULL, 16));
-                i++;
-            }
-            subsubnode = mxmlFindElement(subnode, subnode, "material", NULL, NULL, MXML_DESCEND);
-            if (subnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy1.material = short_swap_bytes(strtoul(tempCoord, NULL, 16));
-            }
-            subsubnode = mxmlFindElement(subnode, subnode, "CoordinateCount", NULL, NULL, MXML_DESCEND);
-            if (subsubnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy1.coordinate_count = short_swap_bytes(strtoul(tempCoord, NULL, 16));
-            }
-            subsubnode = mxmlFindElement(subnode, subnode, "padding", NULL, NULL, MXML_DESCEND);
-            if (subsubnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy1.padding = short_swap_bytes(strtoul(tempCoord, NULL, 16));
-            }
-            fwrite(&wndy1, sizeof(brlyt_wnd1), 1, fp);
-            *fileOffset = *fileOffset + sizeof(brlyt_wnd1);
-        }
-
-        brlyt_wnd3 wndy3;
-        subnode = mxmlFindElement(node, node, "Coords", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            i=0;
-            mxml_node_t *subsubnode;
-            for(subsubnode = mxmlFindElement(subnode, subnode, "texcoord", NULL, NULL, MXML_DESCEND); subsubnode != NULL; subsubnode = mxmlFindElement(subsubnode, subnode, "texcoord", NULL, NULL, MXML_DESCEND))
-            {
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy3.texcoords[i] = float_swap_bytes(atof(tempCoord));
-                i++;
-            }
-            fwrite(&wndy3, sizeof(brlyt_wnd3), 1, fp);
-            *fileOffset = *fileOffset + sizeof(brlyt_wnd3);
-        }
-
-        brlyt_wnd4 wndy4;
-        for(subnode = mxmlFindElement(node, node, "wnd4", NULL, NULL, MXML_DESCEND); subnode != NULL; subnode = mxmlFindElement(subnode, node, "wnd4", NULL, NULL, MXML_DESCEND))
-        {
-            i=0;
-            mxml_node_t *subsubnode;
-            subsubnode = mxmlFindElement(subnode, subnode, "offset", NULL, NULL, MXML_DESCEND);
-            if (subsubnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy4.offset = be32(strtoul(tempCoord, NULL, 16));
-                i++;
-            }
-            fwrite(&wndy4, sizeof(brlyt_wnd4), 1, fp);
-            *fileOffset = *fileOffset + sizeof(brlyt_wnd4);
-        }
-        brlyt_wnd4_mat wndy4mat;
-        for(subnode = mxmlFindElement(node, node, "wnd4mat", NULL, NULL, MXML_DESCEND); subnode != NULL; subnode = mxmlFindElement(subnode, node, "wnd4mat", NULL, NULL, MXML_DESCEND))
-        {
-            i=0;
-            mxml_node_t *subsubnode;
-            subsubnode = mxmlFindElement(subnode, subnode, "material", NULL, NULL, MXML_DESCEND);
-            if (subsubnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy4mat.material = be16(strtoul(tempCoord, NULL, 16));
-                i++;
-            }
-            subsubnode = mxmlFindElement(subnode, subnode, "index", NULL, NULL, MXML_DESCEND);
-            if (subsubnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy4mat.index = strtoul(tempCoord, NULL, 16);
-			}
-            subsubnode = mxmlFindElement(subnode, subnode, "padding", NULL, NULL, MXML_DESCEND);
-            if (subsubnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(subsubnode, tempCoord, 256);
-                wndy4mat.padding = strtoul(tempCoord, NULL, 16);
-			}
-            fwrite(&wndy4mat, sizeof(brlyt_wnd4_mat), 1, fp);
-            *fileOffset = *fileOffset + sizeof(brlyt_wnd4_mat);
-        }
-    }
-    if ( memcmp(temp, txt1, sizeof(txt1)) == 0)
-    {
-        brlyt_pane_chunk chunk;
-        brlyt_text_chunk chunk2;
-        char temp[256];
-        if(mxmlElementGetAttr(node, "name") != NULL)
-            strcpy(temp, mxmlElementGetAttr(node, "name"));
-        else{
-            printf("No name attribute found!\nQuitting!\n");
-            exit(1);
-        }
-        memset(chunk.name, 0, 24 * sizeof(char));
-        strcpy(chunk.name, temp);
-        chunk2.mat_num = short_swap_bytes(findMatOffset(temp));
-
-        mxml_node_t *subnode = mxmlFindElement(node, node, "translate", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XTrans = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YTrans = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.ZTrans = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "rotate", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XRotate = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YRotate = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.ZRotate = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "scale", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XScale = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YScale = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "width", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.width = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "height", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.height = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        
+		}
+		subnode = mxmlFindElement(node, node, "alpha", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.alpha = strtol(tempCoord, NULL, 16);
+		}
+		subnode = mxmlFindElement(node, node, "padding", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.pad = strtol(tempCoord, NULL, 16);
+		}
+		fwrite(&chunk, sizeof(chunk), 1, fp);
+		*fileOffset = *fileOffset + sizeof(chunk);
+
+		int i;
+		brlyt_wnd wndy;
+		subnode = mxmlFindElement(node, node, "wnd", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			i = 0;
+			mxml_node_t *subsubnode;
+			for(subsubnode = mxmlFindElement(subnode, subnode, "coordinate", NULL, NULL, MXML_DESCEND); subsubnode != NULL; subsubnode = mxmlFindElement(subsubnode, subnode, "coordinate", NULL, NULL, MXML_DESCEND))
+			{
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy.coords[i] = float_swap_bytes(atof(tempCoord));
+				i++;
+			}
+			subsubnode = mxmlFindElement(subnode, subnode, "FrameCount", NULL, NULL, MXML_DESCEND);
+			if(subsubnode != NULL)
+			{
+
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy.frame_count = (u8)(strtoul(tempCoord, NULL, 16));
+			}
+			wndy.padding[0] = 0x0;
+			wndy.padding[1] = 0x0;
+			wndy.padding[2] = 0x0;
+
+			subsubnode = mxmlFindElement(subnode, subnode, "offset1", NULL, NULL, MXML_DESCEND);
+			if(subsubnode != NULL)
+			{
+
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy.offset1 = be32(strtoul(tempCoord, NULL, 16));
+			}
+			subsubnode = mxmlFindElement(subnode, subnode, "offset2", NULL, NULL, MXML_DESCEND);
+			if(subsubnode != NULL)
+			{
+
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy.offset2 = be32(strtoul(tempCoord, NULL, 16));
+			}
+			fwrite(&wndy, sizeof(brlyt_wnd), 1, fp);
+			*fileOffset = *fileOffset + sizeof(brlyt_wnd);
+		}
+
+		brlyt_wnd1 wndy1;
+		subnode = mxmlFindElement(node, node, "wnd1", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			i=0;
+			mxml_node_t *subsubnode;
+			for(subsubnode = mxmlFindElement(subnode, subnode, "color", NULL, NULL, MXML_DESCEND); subsubnode != NULL; subsubnode = mxmlFindElement(subsubnode, subnode, "color", NULL, NULL, MXML_DESCEND))
+			{
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy1.colors[i] = be32(strtoul(tempCoord, NULL, 16));
+				i++;
+			}
+			subsubnode = mxmlFindElement(subnode, subnode, "material", NULL, NULL, MXML_DESCEND);
+			if (subnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy1.material = short_swap_bytes(strtoul(tempCoord, NULL, 16));
+			}
+			subsubnode = mxmlFindElement(subnode, subnode, "CoordinateCount", NULL, NULL, MXML_DESCEND);
+			if (subsubnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy1.coordinate_count = short_swap_bytes(strtoul(tempCoord, NULL, 16));
+			}
+			subsubnode = mxmlFindElement(subnode, subnode, "padding", NULL, NULL, MXML_DESCEND);
+			if (subsubnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy1.padding = short_swap_bytes(strtoul(tempCoord, NULL, 16));
+			}
+			fwrite(&wndy1, sizeof(brlyt_wnd1), 1, fp);
+			*fileOffset = *fileOffset + sizeof(brlyt_wnd1);
+		}
+
+		brlyt_wnd3 wndy3;
+		subnode = mxmlFindElement(node, node, "Coords", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			i=0;
+			mxml_node_t *subsubnode;
+			for(subsubnode = mxmlFindElement(subnode, subnode, "texcoord", NULL, NULL, MXML_DESCEND); subsubnode != NULL; subsubnode = mxmlFindElement(subsubnode, subnode, "texcoord", NULL, NULL, MXML_DESCEND))
+			{
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy3.texcoords[i] = float_swap_bytes(atof(tempCoord));
+				i++;
+			}
+			fwrite(&wndy3, sizeof(brlyt_wnd3), 1, fp);
+			*fileOffset = *fileOffset + sizeof(brlyt_wnd3);
+		}
+
+		brlyt_wnd4 wndy4;
+		for(subnode = mxmlFindElement(node, node, "wnd4", NULL, NULL, MXML_DESCEND); subnode != NULL; subnode = mxmlFindElement(subnode, node, "wnd4", NULL, NULL, MXML_DESCEND))
+		{
+			i=0;
+			mxml_node_t *subsubnode;
+			subsubnode = mxmlFindElement(subnode, subnode, "offset", NULL, NULL, MXML_DESCEND);
+			if (subsubnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy4.offset = be32(strtoul(tempCoord, NULL, 16));
+				i++;
+			}
+			fwrite(&wndy4, sizeof(brlyt_wnd4), 1, fp);
+			*fileOffset = *fileOffset + sizeof(brlyt_wnd4);
+		}
+		brlyt_wnd4_mat wndy4mat;
+		for(subnode = mxmlFindElement(node, node, "wnd4mat", NULL, NULL, MXML_DESCEND); subnode != NULL; subnode = mxmlFindElement(subnode, node, "wnd4mat", NULL, NULL, MXML_DESCEND))
+		{
+			i=0;
+			mxml_node_t *subsubnode;
+			subsubnode = mxmlFindElement(subnode, subnode, "material", NULL, NULL, MXML_DESCEND);
+			if (subsubnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy4mat.material = be16(strtoul(tempCoord, NULL, 16));
+				i++;
+			}
+			subsubnode = mxmlFindElement(subnode, subnode, "index", NULL, NULL, MXML_DESCEND);
+			if (subsubnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy4mat.index = strtoul(tempCoord, NULL, 16);
+			}
+			subsubnode = mxmlFindElement(subnode, subnode, "padding", NULL, NULL, MXML_DESCEND);
+			if (subsubnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(subsubnode, tempCoord, 256);
+				wndy4mat.padding = strtoul(tempCoord, NULL, 16);
+			}
+			fwrite(&wndy4mat, sizeof(brlyt_wnd4_mat), 1, fp);
+			*fileOffset = *fileOffset + sizeof(brlyt_wnd4_mat);
+		}
+	}
+	if ( memcmp(temp, txt1, sizeof(txt1)) == 0)
+	{
+		brlyt_pane_chunk chunk;
+		brlyt_text_chunk chunk2;
+		char temp[256];
+		if(mxmlElementGetAttr(node, "name") != NULL)
+			strcpy(temp, mxmlElementGetAttr(node, "name"));
+		else{
+			printf("No name attribute found!\nQuitting!\n");
+			exit(1);
+		}
+		memset(chunk.name, 0, 24 * sizeof(char));
+		strcpy(chunk.name, temp);
+		chunk2.mat_num = short_swap_bytes(findMatOffset(temp));
+
+		mxml_node_t *subnode = mxmlFindElement(node, node, "translate", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XTrans = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YTrans = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.ZTrans = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "rotate", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XRotate = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YRotate = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.ZRotate = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "scale", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XScale = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YScale = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "width", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.width = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "height", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.height = float_swap_bytes(atof(tempCoord));
+			}
+		}
+
 		u8 flag1 = 0;
-        subnode = mxmlFindElement(node, node, "visible", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= strtol(tempCoord, NULL, 16);
-        }
-        subnode = mxmlFindElement(node, node, "WidescreenAffected", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= ( strtol(tempCoord, NULL, 16) << 1 );
-        }
-        subnode = mxmlFindElement(node, node, "flag", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= ( strtol(tempCoord, NULL, 16) << 2 );
-        }
+		subnode = mxmlFindElement(node, node, "visible", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= strtol(tempCoord, NULL, 16);
+		}
+		subnode = mxmlFindElement(node, node, "WidescreenAffected", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= ( strtol(tempCoord, NULL, 16) << 1 );
+		}
+		subnode = mxmlFindElement(node, node, "flag", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= ( strtol(tempCoord, NULL, 16) << 2 );
+		}
 		chunk.flag1 = flag1;
-        subnode = mxmlFindElement(node, node, "origin", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
+		subnode = mxmlFindElement(node, node, "origin", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
 			char origins[9][15];
 			memset( origins , 0 , 8 * 20 );
 			strcpy( origins[0] , "TOP LEFT" );
@@ -3482,9 +3491,9 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 			strcpy( origins[7] , "BOTTOM CENTER" );
 			strcpy( origins[8] , "BOTTOM RIGHT" );
 
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.origin = strtol(tempCoord, NULL, 16);
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.origin = strtol(tempCoord, NULL, 16);
 			int i;
 			for ( i = 0 ; i < 9 ; i++ ) {
 				if ( strncmp( origins[i] , tempCoord , 15 ) == 0 ) {
@@ -3492,67 +3501,67 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 					break;
 				}
 			}
-        }
-        subnode = mxmlFindElement(node, node, "alpha", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.alpha = strtol(tempCoord, NULL, 16);
-        }
-        subnode = mxmlFindElement(node, node, "padding", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.pad = strtol(tempCoord, NULL, 16);
-        }
-
-        subnode = mxmlFindElement(node, node, "font", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char temp[256];
-            if(mxmlElementGetAttr(subnode, "index") != NULL)
-                strcpy(temp, mxmlElementGetAttr(subnode, "index"));
-            else{
-                printf("No index attribute found!\nQuitting!\n");
-                exit(1);
-            }
-            chunk2.font_idx = atoi(temp);
-            chunk2.font_idx = short_swap_bytes(chunk2.font_idx);
-
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "xsize", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk2.font_size_x = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "ysize", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk2.font_size_y = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "charsize", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk2.char_space = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "linesize", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk2.line_space = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "alignment", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
+		}
+		subnode = mxmlFindElement(node, node, "alpha", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.alpha = strtol(tempCoord, NULL, 16);
+		}
+		subnode = mxmlFindElement(node, node, "padding", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.pad = strtol(tempCoord, NULL, 16);
+		}
+
+		subnode = mxmlFindElement(node, node, "font", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char temp[256];
+			if(mxmlElementGetAttr(subnode, "index") != NULL)
+				strcpy(temp, mxmlElementGetAttr(subnode, "index"));
+			else{
+				printf("No index attribute found!\nQuitting!\n");
+				exit(1);
+			}
+			chunk2.font_idx = atoi(temp);
+			chunk2.font_idx = short_swap_bytes(chunk2.font_idx);
+
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "xsize", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk2.font_size_x = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "ysize", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk2.font_size_y = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "charsize", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk2.char_space = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "linesize", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk2.line_space = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "alignment", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
 				char alignments[9][15];
 				memset( alignments , 0 , 8 * 20 );
 				strcpy( alignments[0] , "TOP LEFT" );
@@ -3575,200 +3584,200 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 						break;
 					}
 				}
-            }
-        }
-
-        subnode = mxmlFindElement(node, node, "length", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk2.len1 = strtoul(tempCoord, NULL, 16);
-            chunk2.len1 = short_swap_bytes(chunk2.len1);
-            chunk2.len2 = strtoul(tempCoord+5, NULL, 16);
-            chunk2.len2 = short_swap_bytes(chunk2.len2);
-        }
-        subnode = mxmlFindElement(node, node, "color1", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk2.color1 = be32(strtoul(tempCoord, NULL, 16));
-        }
-        subnode = mxmlFindElement(node, node, "color2", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk2.color2 = be32(strtoul(tempCoord, NULL, 16));
-        }
-        u16 textyLength = short_swap_bytes(chunk2.len2);
-        if ((textyLength % 4) != 0)
-            textyLength += (4 - (textyLength % 4));
+			}
+		}
+
+		subnode = mxmlFindElement(node, node, "length", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk2.len1 = strtoul(tempCoord, NULL, 16);
+			chunk2.len1 = short_swap_bytes(chunk2.len1);
+			chunk2.len2 = strtoul(tempCoord+5, NULL, 16);
+			chunk2.len2 = short_swap_bytes(chunk2.len2);
+		}
+		subnode = mxmlFindElement(node, node, "color1", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk2.color1 = be32(strtoul(tempCoord, NULL, 16));
+		}
+		subnode = mxmlFindElement(node, node, "color2", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk2.color2 = be32(strtoul(tempCoord, NULL, 16));
+		}
+		u16 textyLength = short_swap_bytes(chunk2.len2);
+		if ((textyLength % 4) != 0)
+			textyLength += (4 - (textyLength % 4));
 		u8 texty[textyLength + 1];
 		u8 tempy[textyLength*2];
-        subnode = mxmlFindElement(node, node, "text", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            u8 tempCoord[8184];
-            get_value(subnode, tempCoord, 8184);
-            memcpy(tempy, tempCoord, short_swap_bytes(chunk2.len2)*2);
-            u32 w; for (w=0;w<short_swap_bytes(chunk2.len2);w++)
-            {
-                u8 temp[3];
-                temp[0] = tempy[w*2+0];
-                temp[1] = tempy[w*2+1];
-                temp[2] = 0x0;
-                //printf("w: %d, temp: %s\n", w, temp);
-                texty[w] = (u8)strtoul((char*)temp, NULL, 16);
-            }
-        }
-        fwrite(&chunk, sizeof(chunk), 1, fp);
-        *fileOffset = *fileOffset + sizeof(chunk);
-
-        chunk2.name_offs=be32(0x74);
-        chunk2.pad[0]= 0;chunk2.pad[1]=0;chunk2.pad[2]=0;
-        fwrite(&chunk2, sizeof(chunk2), 1, fp);
-        *fileOffset = *fileOffset + sizeof(chunk2);
-
-    int q;for (q=short_swap_bytes(chunk2.len2);q<textyLength;q++)
-        {
-            q++;
-            texty[q] = 0x00;
-        }
-        fwrite(texty, textyLength, 1, fp);
-        *fileOffset = *fileOffset + textyLength;
-    }
-    if ( memcmp(temp, pic1, sizeof(pic1)) == 0)
-    {
-        brlyt_pane_chunk chunk;
-        char temp[256];
-        if(mxmlElementGetAttr(node, "name") != NULL)
-            strcpy(temp, mxmlElementGetAttr(node, "name"));
-        else{
-            printf("No name attribute found!\nQuitting!\n");
-            exit(1);
-        }
-        memset(chunk.name, 0, 24 * sizeof(char));
-        strcpy(chunk.name, temp);
-
-        mxml_node_t *subnode = mxmlFindElement(node, node, "translate", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XTrans = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YTrans = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.ZTrans = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "rotate", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XRotate = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YRotate = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.ZRotate = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "scale", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.XScale = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.YScale = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            valnode = mxmlFindElement(subnode, subnode, "width", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.width = float_swap_bytes(atof(tempCoord));
-            }
-            valnode = mxmlFindElement(subnode, subnode, "height", NULL, NULL, MXML_DESCEND);
-            if (valnode != NULL)
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk.height = float_swap_bytes(atof(tempCoord));
-            }
-        }
-        
+		subnode = mxmlFindElement(node, node, "text", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			u8 tempCoord[8184];
+			get_value(subnode, tempCoord, 8184);
+			memcpy(tempy, tempCoord, short_swap_bytes(chunk2.len2)*2);
+			u32 w; for (w=0;w<short_swap_bytes(chunk2.len2);w++)
+			{
+				u8 temp[3];
+				temp[0] = tempy[w*2+0];
+				temp[1] = tempy[w*2+1];
+				temp[2] = 0x0;
+				//printf("w: %d, temp: %s\n", w, temp);
+				texty[w] = (u8)strtoul((char*)temp, NULL, 16);
+			}
+		}
+		fwrite(&chunk, sizeof(chunk), 1, fp);
+		*fileOffset = *fileOffset + sizeof(chunk);
+
+		chunk2.name_offs=be32(0x74);
+		chunk2.pad[0]= 0;chunk2.pad[1]=0;chunk2.pad[2]=0;
+		fwrite(&chunk2, sizeof(chunk2), 1, fp);
+		*fileOffset = *fileOffset + sizeof(chunk2);
+
+	int q;for (q=short_swap_bytes(chunk2.len2);q<textyLength;q++)
+		{
+			q++;
+			texty[q] = 0x00;
+		}
+		fwrite(texty, textyLength, 1, fp);
+		*fileOffset = *fileOffset + textyLength;
+	}
+	if ( memcmp(temp, pic1, sizeof(pic1)) == 0)
+	{
+		brlyt_pane_chunk chunk;
+		char temp[256];
+		if(mxmlElementGetAttr(node, "name") != NULL)
+			strcpy(temp, mxmlElementGetAttr(node, "name"));
+		else{
+			printf("No name attribute found!\nQuitting!\n");
+			exit(1);
+		}
+		memset(chunk.name, 0, 24 * sizeof(char));
+		strcpy(chunk.name, temp);
+
+		mxml_node_t *subnode = mxmlFindElement(node, node, "translate", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XTrans = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YTrans = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.ZTrans = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "rotate", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XRotate = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YRotate = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "z", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.ZRotate = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "scale", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "x", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.XScale = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "y", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.YScale = float_swap_bytes(atof(tempCoord));
+			}
+		}
+		subnode = mxmlFindElement(node, node, "size", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			valnode = mxmlFindElement(subnode, subnode, "width", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.width = float_swap_bytes(atof(tempCoord));
+			}
+			valnode = mxmlFindElement(subnode, subnode, "height", NULL, NULL, MXML_DESCEND);
+			if (valnode != NULL)
+			{
+				char tempCoord[256];
+				get_value(valnode, tempCoord, 256);
+				chunk.height = float_swap_bytes(atof(tempCoord));
+			}
+		}
+
 		u8 flag1 = 0;
-        subnode = mxmlFindElement(node, node, "visible", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= strtol(tempCoord, NULL, 16);
-        }
-        subnode = mxmlFindElement(node, node, "WidescreenAffected", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= ( strtol(tempCoord, NULL, 16) << 1 );
-        }
-        subnode = mxmlFindElement(node, node, "flag", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            flag1 |= ( strtol(tempCoord, NULL, 16) << 2 );
-        }
+		subnode = mxmlFindElement(node, node, "visible", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= strtol(tempCoord, NULL, 16);
+		}
+		subnode = mxmlFindElement(node, node, "WidescreenAffected", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= ( strtol(tempCoord, NULL, 16) << 1 );
+		}
+		subnode = mxmlFindElement(node, node, "flag", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			flag1 |= ( strtol(tempCoord, NULL, 16) << 2 );
+		}
 		chunk.flag1 = flag1;
-        subnode = mxmlFindElement(node, node, "origin", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
+		subnode = mxmlFindElement(node, node, "origin", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
 			char origins[9][15];
 			memset( origins , 0 , 8 * 20 );
 			strcpy( origins[0] , "TOP LEFT" );
@@ -3781,9 +3790,9 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 			strcpy( origins[7] , "BOTTOM CENTER" );
 			strcpy( origins[8] , "BOTTOM RIGHT" );
 
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.origin = strtol(tempCoord, NULL, 16);
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.origin = strtol(tempCoord, NULL, 16);
 			int i;
 			for ( i = 0 ; i < 9 ; i++ ) {
 				if ( strncmp( origins[i] , tempCoord , 15 ) == 0 ) {
@@ -3791,256 +3800,284 @@ void WriteBRLYTEntry(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* bl
 					break;
 				}
 			}
-        }
-        subnode = mxmlFindElement(node, node, "alpha", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.alpha = strtol(tempCoord, NULL, 16);
-        }
-        subnode = mxmlFindElement(node, node, "padding", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char tempCoord[256];
-            get_value(subnode, tempCoord, 256);
-            chunk.pad = strtol(tempCoord, NULL, 16);
-        }
-
-        brlyt_pic_chunk chunk2;
-        subnode = mxmlFindElement(node, node, "material", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            char temp[256];
-            if(mxmlElementGetAttr(subnode, "name") != NULL)
-                strcpy(temp, mxmlElementGetAttr(subnode, "name"));
-            else{
-                printf("No name attribute found!\nQuitting!\n");
-                exit(1);
-            }
-            chunk2.mat_num = short_swap_bytes(findMatOffset(temp));
-        }
-        subnode = mxmlFindElement(node, node, "colors", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            int i=0;
-            for(valnode = mxmlFindElement(subnode, subnode, "vtx", NULL, NULL, MXML_DESCEND); valnode != NULL; valnode = mxmlFindElement(valnode, subnode, "vtx", NULL, NULL, MXML_DESCEND))
-            {
-                char tempCoord[256];
-                get_value(valnode, tempCoord, 256);
-                chunk2.vtx_colors[i] = be32(strtoul(tempCoord, NULL, 16));
-                i++;
-            }
-        }
-        u32 numberOfPicCoords = 0;
-        u32 sets = 1;
-        float* picCoords = malloc(8 * sizeof(float));
-        subnode = mxmlFindElement(node, node, "coordinates", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *setnode;
-            for (setnode = mxmlFindElement(subnode, subnode, "set", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "set", NULL, NULL, MXML_DESCEND))
-            {
-                picCoords = realloc(picCoords, sizeof(float) * 8 * sets);
-                mxml_node_t *valnode;
-                for (valnode=mxmlFindElement(setnode, setnode, "coord", NULL, NULL, MXML_DESCEND) ; valnode != NULL  ; valnode=mxmlFindElement(valnode, setnode, "coord", NULL, NULL, MXML_DESCEND) )
-                {
-                        
-                        char tempCoord[256];
-                        int j; for (j=0;j<256;j++) tempCoord[j]=0;
-                        get_value(valnode, tempCoord, 256);
-                        float tempCoordGotten = atof(tempCoord);
-                        float coordGotten = float_swap_bytes(tempCoordGotten);
-                        memcpy(&picCoords[numberOfPicCoords], &coordGotten, sizeof(float));
-                        numberOfPicCoords++;
-                }
-                sets++;
-            }
-        }
-        fwrite(&chunk, sizeof(chunk), 1, fp);
-        *fileOffset = *fileOffset + sizeof(chunk);
-        chunk2.num_texcoords = (sets - 1);
-        chunk2.padding = 0;
-        fwrite(&chunk2, sizeof(chunk2), 1, fp);
-        *fileOffset = *fileOffset + sizeof(chunk2);
-        fwrite(picCoords, numberOfPicCoords * sizeof(float), 1, fp);
-        *fileOffset = *fileOffset + (sizeof(float) * numberOfPicCoords);
-        free(picCoords);
-    }
-    if ( memcmp(temp, grp1, sizeof(grp1)) == 0)
-    {
-        brlyt_group_chunk chunk;
-        chunk.unk = 0;
-        char temp[256];
-        if(mxmlElementGetAttr(node, "name") != NULL)
-            strcpy(temp, mxmlElementGetAttr(node, "name"));
-        else{
-            printf("No name attribute found!\nQuitting!\n");
-            exit(1);
-        }
-        memset(chunk.name, 0, 16 * sizeof(char));
-        strcpy(chunk.name, temp);
-        int numSubs = 0;
-        char *subs;
+		}
+		subnode = mxmlFindElement(node, node, "alpha", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.alpha = strtol(tempCoord, NULL, 16);
+		}
+		subnode = mxmlFindElement(node, node, "padding", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char tempCoord[256];
+			get_value(subnode, tempCoord, 256);
+			chunk.pad = strtol(tempCoord, NULL, 16);
+		}
+
+		brlyt_pic_chunk chunk2;
+		subnode = mxmlFindElement(node, node, "material", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			char temp[256];
+			if(mxmlElementGetAttr(subnode, "name") != NULL)
+				strcpy(temp, mxmlElementGetAttr(subnode, "name"));
+			else{
+				printf("No name attribute found!\nQuitting!\n");
+				exit(1);
+			}
+			chunk2.mat_num = short_swap_bytes(findMatOffset(temp));
+		}
+		subnode = mxmlFindElement(node, node, "colors", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			int i=0;
+			for(valnode = mxmlFindElement(subnode, subnode, "vtx", NULL, NULL, MXML_DESCEND); valnode != NULL; valnode = mxmlFindElement(valnode, subnode, "vtx", NULL, NULL, MXML_DESCEND))
+			{
+				u32 red, green, blue, alpha;
+				mxml_node_t *subvalnode;
+				subvalnode = mxmlFindElement( valnode, valnode, "red", NULL, NULL, MXML_DESCEND);
+				if ( subvalnode != NULL ) {
+
+					char tempCoord[256];
+					get_value(valnode, tempCoord, 256);
+					red = strtoul(tempCoord, NULL, 16);
+				}
+				subvalnode = mxmlFindElement( valnode,valnode,"green", NULL, NULL, MXML_DESCEND);
+				if ( subvalnode != NULL ) {
+
+					char tempCoord[256];
+					get_value(valnode, tempCoord, 256);
+					green = strtoul(tempCoord, NULL, 16);
+				}
+				subvalnode = mxmlFindElement( valnode, valnode, "blue",NULL, NULL, MXML_DESCEND);
+				if ( subvalnode != NULL ) {
+
+					char tempCoord[256];
+					get_value(valnode, tempCoord, 256);
+					blue = strtoul(tempCoord, NULL, 16);
+				}
+				subvalnode = mxmlFindElement( valnode, valnode, "alpha",NULL,NULL, MXML_DESCEND);
+				if ( subvalnode != NULL ) {
+
+					char tempCoord[256];
+					get_value(valnode, tempCoord, 256);
+					alpha = strtoul(tempCoord, NULL, 16);
+				}
+				chunk2.vtx_colors[i] = ( red << 24 ) | ( green << 16 ) | ( blue << 8 ) | alpha;
+				i++;
+			}
+		}
+		u32 numberOfPicCoords = 0;
+		u32 sets = 1;
+		float* picCoords = malloc(8 * sizeof(float));
+		subnode = mxmlFindElement(node, node, "coordinates", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *setnode;
+			for (setnode = mxmlFindElement(subnode, subnode, "set", NULL, NULL, MXML_DESCEND); setnode != NULL; setnode = mxmlFindElement(setnode, subnode, "set", NULL, NULL, MXML_DESCEND))
+			{
+				picCoords = realloc(picCoords, sizeof(float) * 8 * sets);
+				mxml_node_t *valnode;
+				for (valnode=mxmlFindElement(setnode, setnode, "coord", NULL, NULL, MXML_DESCEND) ; valnode != NULL  ; valnode=mxmlFindElement(valnode, setnode, "coord", NULL, NULL, MXML_DESCEND) )
+				{
+
+						char tempCoord[256];
+						int j; for (j=0;j<256;j++) tempCoord[j]=0;
+						get_value(valnode, tempCoord, 256);
+						float tempCoordGotten = atof(tempCoord);
+						float coordGotten = float_swap_bytes(tempCoordGotten);
+						memcpy(&picCoords[numberOfPicCoords], &coordGotten, sizeof(float));
+						numberOfPicCoords++;
+				}
+				sets++;
+			}
+		}
+		fwrite(&chunk, sizeof(chunk), 1, fp);
+		*fileOffset = *fileOffset + sizeof(chunk);
+		chunk2.num_texcoords = (sets - 1);
+		chunk2.padding = 0;
+		fwrite(&chunk2, sizeof(chunk2), 1, fp);
+		*fileOffset = *fileOffset + sizeof(chunk2);
+		fwrite(picCoords, numberOfPicCoords * sizeof(float), 1, fp);
+		*fileOffset = *fileOffset + (sizeof(float) * numberOfPicCoords);
+		free(picCoords);
+	}
+	if ( memcmp(temp, grp1, sizeof(grp1)) == 0)
+	{
+		brlyt_group_chunk chunk;
+		chunk.unk = 0;
+		char temp[256];
+		if(mxmlElementGetAttr(node, "name") != NULL)
+			strcpy(temp, mxmlElementGetAttr(node, "name"));
+		else{
+			printf("No name attribute found!\nQuitting!\n");
+			exit(1);
+		}
+		memset(chunk.name, 0, 16 * sizeof(char));
+		strcpy(chunk.name, temp);
+		int numSubs = 0;
+		char *subs;
 	subs = malloc(0 * sizeof(char));
-        u32 subsLength = 0;
-
-        mxml_node_t *subnode = mxmlFindElement(node, node, "subs", NULL, NULL, MXML_DESCEND);
-        if (subnode != NULL)
-        {
-            mxml_node_t *valnode;
-            for(valnode = mxmlFindElement(subnode, subnode, "sub", NULL, NULL, MXML_DESCEND); valnode != NULL; valnode = mxmlFindElement(valnode, subnode, "sub", NULL, NULL, MXML_DESCEND)) {
-            if (valnode != NULL)
-            {
-                    u32 oldSubsLength = subsLength;
-                    char tempSub[256];
-                    get_value(valnode, tempSub, 256);
-                    subsLength += 16;
-                    subs = realloc(subs, 1 + sizeof(char) * subsLength);
-                    memset(&subs[oldSubsLength], 0x00, 16);
-                    strcpy(&subs[oldSubsLength], tempSub);
-                    numSubs++;
-                }
-            }
-        }
-        chunk.numsubs = short_swap_bytes(numSubs);
-        fwrite(&chunk, sizeof(chunk), 1, fp);
-        *fileOffset = *fileOffset + sizeof(chunk);
-        fwrite(subs, sizeof(char) * subsLength, 1, fp);
-        *fileOffset = *fileOffset + subsLength;
-        free(subs);
-    }
-    if ( memcmp(temp, grs1, sizeof(grs1)) == 0)
-    {
-
-    }
-    if ( memcmp(temp, gre1, sizeof(gre1)) == 0)
-    {
-
-    }
-    if ( memcmp(temp, pas1, sizeof(pas1)) == 0)
-    {
-
-    }
-    if ( memcmp(temp, pae1, sizeof(pae1)) == 0)
-    {
-
-    }
-
-    *blobsize = *fileOffset - startOfChunk;
+		u32 subsLength = 0;
+
+		mxml_node_t *subnode = mxmlFindElement(node, node, "subs", NULL, NULL, MXML_DESCEND);
+		if (subnode != NULL)
+		{
+			mxml_node_t *valnode;
+			for(valnode = mxmlFindElement(subnode, subnode, "sub", NULL, NULL, MXML_DESCEND); valnode != NULL; valnode = mxmlFindElement(valnode, subnode, "sub", NULL, NULL, MXML_DESCEND)) {
+			if (valnode != NULL)
+			{
+					u32 oldSubsLength = subsLength;
+					char tempSub[256];
+					get_value(valnode, tempSub, 256);
+					subsLength += 16;
+					subs = realloc(subs, 1 + sizeof(char) * subsLength);
+					memset(&subs[oldSubsLength], 0x00, 16);
+					strcpy(&subs[oldSubsLength], tempSub);
+					numSubs++;
+				}
+			}
+		}
+		chunk.numsubs = short_swap_bytes(numSubs);
+		fwrite(&chunk, sizeof(chunk), 1, fp);
+		*fileOffset = *fileOffset + sizeof(chunk);
+		fwrite(subs, sizeof(char) * subsLength, 1, fp);
+		*fileOffset = *fileOffset + subsLength;
+		free(subs);
+	}
+	if ( memcmp(temp, grs1, sizeof(grs1)) == 0)
+	{
+
+	}
+	if ( memcmp(temp, gre1, sizeof(gre1)) == 0)
+	{
+
+	}
+	if ( memcmp(temp, pas1, sizeof(pas1)) == 0)
+	{
+
+	}
+	if ( memcmp(temp, pae1, sizeof(pae1)) == 0)
+	{
+
+	}
+
+	*blobsize = *fileOffset - startOfChunk;
 }
 
 void WriteBRLYTHeader(brlyt_header rlythead, FILE* fp)
 {
-    brlyt_header writehead;
-    writehead.magic[0] = rlythead.magic[0];
-    writehead.magic[1] = rlythead.magic[1];
-    writehead.magic[2] = rlythead.magic[2];
-    writehead.magic[3] = rlythead.magic[3];
-    writehead.version = be32(rlythead.version);
-    writehead.filesize = be32(rlythead.filesize);
-    writehead.lyt_offset = short_swap_bytes(rlythead.lyt_offset);
-    writehead.sections = short_swap_bytes(rlythead.sections);
-
-    fwrite(&writehead, sizeof(brlyt_header), 1, fp);
+	brlyt_header writehead;
+	writehead.magic[0] = rlythead.magic[0];
+	writehead.magic[1] = rlythead.magic[1];
+	writehead.magic[2] = rlythead.magic[2];
+	writehead.magic[3] = rlythead.magic[3];
+	writehead.version = be32(rlythead.version);
+	writehead.filesize = be32(rlythead.filesize);
+	writehead.lyt_offset = short_swap_bytes(rlythead.lyt_offset);
+	writehead.sections = short_swap_bytes(rlythead.sections);
+
+	fwrite(&writehead, sizeof(brlyt_header), 1, fp);
 }
 
 void write_brlyt(char *infile, char *outfile)
 {
-    u32 fileOffset = 0;
-    FILE* fpx = fopen(infile, "r");
-    if(fpx == NULL) {
-        printf("xmlyt couldn't be opened!\n");
-        exit(1);
-    }
-    mxml_node_t *hightree = mxmlLoadFile(NULL, fpx, MXML_TEXT_CALLBACK);
-    if(hightree == NULL) {
-        printf("Couldn't open hightree!\n");
-        exit(1);
-    }
-    mxml_node_t *tree = mxmlFindElement(hightree, hightree, "xmlyt", NULL, NULL, MXML_DESCEND);
-    if(tree == NULL) {
-        printf("Couldn't get tree!\n");
-        exit(1);
-    }
-    mxml_node_t *node;
-    FILE* fp = fopen(outfile, "wb+");
-    if(fp == NULL) {
-        printf("destination brlyt couldn't be opened!\n");
-        exit(1);
-    }
-
-    u8* tagblob;
-    u32 blobsize;
-    u16 blobcount = 0;
-    brlyt_header rlythead;
-    rlythead.magic[0] = 'R';
-    rlythead.magic[1] = 'L';
-    rlythead.magic[2] = 'Y';
-    rlythead.magic[3] = 'T';
-    rlythead.version = 0xFEFF0008;
-    rlythead.filesize = 0;
-    rlythead.lyt_offset = sizeof(brlyt_header);
-    rlythead.sections = 1;
-    WriteBRLYTHeader(rlythead, fp);
-
-    fileOffset += sizeof(brlyt_header);
-
-    u32 numberOfEntries;
-
-    for(node = mxmlFindElement(tree, tree, "tag", NULL, NULL, MXML_DESCEND); node != NULL; node = mxmlFindElement(node, tree, "tag", NULL, NULL, MXML_DESCEND)) {
-
-        char tempType[4];
-        if(mxmlElementGetAttr(node, "type") != NULL)
-            strcpy(tempType, mxmlElementGetAttr(node, "type"));
-        else{
-            printf("No type attribute found!\n");
-            exit(1);
-        }
-
-        u32 chunkHeaderOffset = fileOffset;
-
-        brlyt_entry_header chunk;
-        chunk.magic[0]=tempType[0];
-        chunk.magic[1]=tempType[1];
-        chunk.magic[2]=tempType[2];
-        chunk.magic[3]=tempType[3];
-        chunk.length = 0;
-
-        fwrite(&chunk, sizeof(chunk), 1, fp);
-
-        fileOffset += sizeof(chunk);
-
-        WriteBRLYTEntry(tree, node, &tagblob, &blobsize, tempType, fp, &fileOffset);
-
-        chunk.length = be32(blobsize + sizeof(chunk));
-
-        fseek(fp, chunkHeaderOffset, SEEK_SET);
-        fwrite(&chunk, sizeof(chunk), 1, fp);
-        fseek(fp, fileOffset, SEEK_SET);
-
-        numberOfEntries++;
-
-        blobcount++;
-
-    }
-
-    rlythead.filesize = fileOffset;
-    rlythead.sections = blobcount;
-    fseek(fp, 0, SEEK_SET);
-    WriteBRLYTHeader(rlythead, fp);
-
-    fclose(fpx);
-    fclose(fp);
+	u32 fileOffset = 0;
+	FILE* fpx = fopen(infile, "r");
+	if(fpx == NULL) {
+		printf("xmlyt couldn't be opened!\n");
+		exit(1);
+	}
+	mxml_node_t *hightree = mxmlLoadFile(NULL, fpx, MXML_TEXT_CALLBACK);
+	if(hightree == NULL) {
+		printf("Couldn't open hightree!\n");
+		exit(1);
+	}
+	mxml_node_t *tree = mxmlFindElement(hightree, hightree, "xmlyt", NULL, NULL, MXML_DESCEND);
+	if(tree == NULL) {
+		printf("Couldn't get tree!\n");
+		exit(1);
+	}
+	mxml_node_t *node;
+	FILE* fp = fopen(outfile, "wb+");
+	if(fp == NULL) {
+		printf("destination brlyt couldn't be opened!\n");
+		exit(1);
+	}
+
+	u8* tagblob;
+	u32 blobsize;
+	u16 blobcount = 0;
+	brlyt_header rlythead;
+	rlythead.magic[0] = 'R';
+	rlythead.magic[1] = 'L';
+	rlythead.magic[2] = 'Y';
+	rlythead.magic[3] = 'T';
+	rlythead.version = 0xFEFF0008;
+	rlythead.filesize = 0;
+	rlythead.lyt_offset = sizeof(brlyt_header);
+	rlythead.sections = 1;
+	WriteBRLYTHeader(rlythead, fp);
+
+	fileOffset += sizeof(brlyt_header);
+
+	u32 numberOfEntries;
+
+	for(node = mxmlFindElement(tree, tree, "tag", NULL, NULL, MXML_DESCEND); node != NULL; node = mxmlFindElement(node, tree, "tag", NULL, NULL, MXML_DESCEND)) {
+
+		char tempType[4];
+		if(mxmlElementGetAttr(node, "type") != NULL)
+			strcpy(tempType, mxmlElementGetAttr(node, "type"));
+		else{
+			printf("No type attribute found!\n");
+			exit(1);
+		}
+
+		u32 chunkHeaderOffset = fileOffset;
+
+		brlyt_entry_header chunk;
+		chunk.magic[0]=tempType[0];
+		chunk.magic[1]=tempType[1];
+		chunk.magic[2]=tempType[2];
+		chunk.magic[3]=tempType[3];
+		chunk.length = 0;
+
+		fwrite(&chunk, sizeof(chunk), 1, fp);
+
+		fileOffset += sizeof(chunk);
+
+		WriteBRLYTEntry(tree, node, &tagblob, &blobsize, tempType, fp, &fileOffset);
+
+		chunk.length = be32(blobsize + sizeof(chunk));
+
+		fseek(fp, chunkHeaderOffset, SEEK_SET);
+		fwrite(&chunk, sizeof(chunk), 1, fp);
+		fseek(fp, fileOffset, SEEK_SET);
+
+		numberOfEntries++;
+
+		blobcount++;
+
+	}
+
+	rlythead.filesize = fileOffset;
+	rlythead.sections = blobcount;
+	fseek(fp, 0, SEEK_SET);
+	WriteBRLYTHeader(rlythead, fp);
+
+	fclose(fpx);
+	fclose(fp);
 }
 
 void make_brlyt(char* infile, char* outfile)
 {
-    printf("\x1b[33mParsing XMLYT @ \x1b[0m%s.\n", infile);
-    write_brlyt(infile, outfile);
-    free(materials);
-    free(textures);
-    printf("\x1b[34mParsing XMLYT @ \x1b[0m%s complete.\n", infile);
+	printf("\x1b[33mParsing XMLYT @ \x1b[0m%s.\n", infile);
+	write_brlyt(infile, outfile);
+	free(materials);
+	free(textures);
+	printf("\x1b[34mParsing XMLYT @ \x1b[0m%s complete.\n", infile);
 }
 
-- 
cgit v1.3.1