diff --git a/polymer/eduke32/build/src/misc/enumdisplay.c b/polymer/eduke32/build/src/misc/enumdisplay.c
index 1274bf14a..6fb98bda7 100644
--- a/polymer/eduke32/build/src/misc/enumdisplay.c
+++ b/polymer/eduke32/build/src/misc/enumdisplay.c
@@ -12,145 +12,145 @@ FILE *output = NULL;
 
 void usage(void)
 {
-	printf(
-	"enumdisplay by Jonathon Fowler (jf@jonof.id.au)\n"
-	"Options:\n"
-	"   -h, -?, --help     This message\n"
-	"   -o <filename>      Use different output file (default: "
-		DEFAULT_OUTPUT_FILE ", use - for stdout)\n"
-	      );
+    printf(
+    "enumdisplay by Jonathon Fowler (jf@jonof.id.au)\n"
+    "Options:\n"
+    "   -h, -?, --help     This message\n"
+    "   -o <filename>      Use different output file (default: "
+        DEFAULT_OUTPUT_FILE ", use - for stdout)\n"
+          );
 }
 
 void dumpdevmode(DEVMODE *devmode)
 {
-	fprintf(output, "\tdmFields has");
-	if (devmode->dmFields & DM_PELSWIDTH) fprintf(output, " DM_PELSWIDTH");
-	if (devmode->dmFields & DM_PELSHEIGHT) fprintf(output, " DM_PELSHEIGHT");
-	if (devmode->dmFields & DM_BITSPERPEL) fprintf(output, " DM_BITSPERPEL");
-	fprintf(output, "\n\tdmPelsWidth = %d\n", devmode->dmPelsWidth);
-	fprintf(output, "\tdmPelsHeight = %d\n", devmode->dmPelsHeight);
-	fprintf(output, "\tdmBitsPerPel = %d\n", devmode->dmBitsPerPel);
+    fprintf(output, "\tdmFields has");
+    if (devmode->dmFields & DM_PELSWIDTH) fprintf(output, " DM_PELSWIDTH");
+    if (devmode->dmFields & DM_PELSHEIGHT) fprintf(output, " DM_PELSHEIGHT");
+    if (devmode->dmFields & DM_BITSPERPEL) fprintf(output, " DM_BITSPERPEL");
+    fprintf(output, "\n\tdmPelsWidth = %d\n", devmode->dmPelsWidth);
+    fprintf(output, "\tdmPelsHeight = %d\n", devmode->dmPelsHeight);
+    fprintf(output, "\tdmBitsPerPel = %d\n", devmode->dmBitsPerPel);
 }
 
 HRESULT WINAPI ddenum(DDSURFACEDESC *ddsd, VOID *udata)
 {
-	fprintf(output, "\tdwFlags has");
-	if (ddsd->dwFlags & DDSD_WIDTH) fprintf(output, " DDSD_WIDTH");
-	if (ddsd->dwFlags & DDSD_HEIGHT) fprintf(output, " DDSD_HEIGHT");
-	if (ddsd->dwFlags & DDSD_PIXELFORMAT) fprintf(output, " DDSD_PIXELFORMAT");
-	fprintf(output, "\n\tdwWidth = %d\n", ddsd->dwWidth);
-	fprintf(output, "\tdwHeight = %d\n", ddsd->dwHeight);
-	fprintf(output, "\tddpfPixelFormat.dwFlags has");
-	if (ddsd->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED1) fprintf(output, " DDPF_PALETTEINDEXED1");
-	if (ddsd->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED2) fprintf(output, " DDPF_PALETTEINDEXED2");
-	if (ddsd->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED4) fprintf(output, " DDPF_PALETTEINDEXED4");
-	if (ddsd->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) fprintf(output, " DDPF_PALETTEINDEXED8");
-	if (ddsd->ddpfPixelFormat.dwFlags & DDPF_RGB) fprintf(output, " DDPF_RGB");
-	fprintf(output, "\n\tddpfPixelFormat.dwRGBBitCount = %d\n", ddsd->ddpfPixelFormat.dwRGBBitCount);
-	fprintf(output, "\n");
+    fprintf(output, "\tdwFlags has");
+    if (ddsd->dwFlags & DDSD_WIDTH) fprintf(output, " DDSD_WIDTH");
+    if (ddsd->dwFlags & DDSD_HEIGHT) fprintf(output, " DDSD_HEIGHT");
+    if (ddsd->dwFlags & DDSD_PIXELFORMAT) fprintf(output, " DDSD_PIXELFORMAT");
+    fprintf(output, "\n\tdwWidth = %d\n", ddsd->dwWidth);
+    fprintf(output, "\tdwHeight = %d\n", ddsd->dwHeight);
+    fprintf(output, "\tddpfPixelFormat.dwFlags has");
+    if (ddsd->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED1) fprintf(output, " DDPF_PALETTEINDEXED1");
+    if (ddsd->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED2) fprintf(output, " DDPF_PALETTEINDEXED2");
+    if (ddsd->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED4) fprintf(output, " DDPF_PALETTEINDEXED4");
+    if (ddsd->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) fprintf(output, " DDPF_PALETTEINDEXED8");
+    if (ddsd->ddpfPixelFormat.dwFlags & DDPF_RGB) fprintf(output, " DDPF_RGB");
+    fprintf(output, "\n\tddpfPixelFormat.dwRGBBitCount = %d\n", ddsd->ddpfPixelFormat.dwRGBBitCount);
+    fprintf(output, "\n");
 
-	return(DDENUMRET_OK);
+    return(DDENUMRET_OK);
 }
 
 int InitDirectDraw(void)
 {
-	HRESULT result;
-	HRESULT (WINAPI *aDirectDrawCreate)(GUID *, LPDIRECTDRAW *, IUnknown *);
-	HRESULT (WINAPI *aDirectDrawEnumerate)(LPDDENUMCALLBACK, LPVOID);
-	DDCAPS ddcaps;
+    HRESULT result;
+    HRESULT (WINAPI *aDirectDrawCreate)(GUID *, LPDIRECTDRAW *, IUnknown *);
+    HRESULT (WINAPI *aDirectDrawEnumerate)(LPDDENUMCALLBACK, LPVOID);
+    DDCAPS ddcaps;
 
-	hDDrawDLL = LoadLibrary("DDRAW.DLL");
-	if (!hDDrawDLL) { fprintf(output, "Failed loading DDRAW.DLL\n"); return -1; }
+    hDDrawDLL = LoadLibrary("DDRAW.DLL");
+    if (!hDDrawDLL) { fprintf(output, "Failed loading DDRAW.DLL\n"); return -1; }
 
-	aDirectDrawEnumerate = (void *)GetProcAddress(hDDrawDLL, "DirectDrawEnumerateA");
-	if (!aDirectDrawEnumerate) { fprintf(output, "Error fetching DirectDrawEnumerate\n"); return -1; }
+    aDirectDrawEnumerate = (void *)GetProcAddress(hDDrawDLL, "DirectDrawEnumerateA");
+    if (!aDirectDrawEnumerate) { fprintf(output, "Error fetching DirectDrawEnumerate\n"); return -1; }
 
-	aDirectDrawCreate = (void *)GetProcAddress(hDDrawDLL, "DirectDrawCreate");
-	if (!aDirectDrawCreate) { fprintf(output, "Error fetching DirectDrawCreate\n"); return -1; }
+    aDirectDrawCreate = (void *)GetProcAddress(hDDrawDLL, "DirectDrawCreate");
+    if (!aDirectDrawCreate) { fprintf(output, "Error fetching DirectDrawCreate\n"); return -1; }
 
-	result = aDirectDrawCreate(NULL, &lpDD, NULL);
-	if (result != DD_OK) { fprintf(output, "DirectDrawCreate() failed (%d)\n", result); return -1; }
+    result = aDirectDrawCreate(NULL, &lpDD, NULL);
+    if (result != DD_OK) { fprintf(output, "DirectDrawCreate() failed (%d)\n", result); return -1; }
 
-	return 0;
+    return 0;
 }
 
 void UninitDirectDraw(void)
 {
-	if (lpDD) IDirectDraw_Release(lpDD);
-	lpDD = NULL;
-	if (hDDrawDLL) FreeLibrary(hDDrawDLL);
-	hDDrawDLL = NULL;
+    if (lpDD) IDirectDraw_Release(lpDD);
+    lpDD = NULL;
+    if (hDDrawDLL) FreeLibrary(hDDrawDLL);
+    hDDrawDLL = NULL;
 }
 
 int main(int argc, char **argv)
 {
-	int i;
+    int i;
 
-	DEVMODE devmode;
-	HRESULT hresult;
+    DEVMODE devmode;
+    HRESULT hresult;
 
-	for (i=1; i<argc; i++) {
-		if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "-?") || !strcmp(argv[i], "--help")) {
-			usage();
-			return 0;
-		} else if (!strcmp(argv[i], "-o")) {
-			outputfile = argv[++i];
-		}
-	}
+    for (i=1; i<argc; i++) {
+        if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "-?") || !strcmp(argv[i], "--help")) {
+            usage();
+            return 0;
+        } else if (!strcmp(argv[i], "-o")) {
+            outputfile = argv[++i];
+        }
+    }
 
-	if (!strcmp(outputfile, "-")) {
-		output = fdopen(1, "wt");
-		outputfile = NULL;
-	} else {
-		output = fopen(outputfile, "wt");
-		if (!output) {
-			fprintf(stderr, "enumdisplay: failed to open %s for output\n", outputfile);
-			return 1;
-		}
-	}
+    if (!strcmp(outputfile, "-")) {
+        output = fdopen(1, "wt");
+        outputfile = NULL;
+    } else {
+        output = fopen(outputfile, "wt");
+        if (!output) {
+            fprintf(stderr, "enumdisplay: failed to open %s for output\n", outputfile);
+            return 1;
+        }
+    }
 
-	fprintf(output,
-		"enumdisplay results\n"
-		"\n"
-		"Display settings:\n"
-	       );
-	ZeroMemory(&devmode, sizeof(devmode));
-	devmode.dmSize = sizeof(DEVMODE);
-	if (!EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode)) {
-		fprintf(output, "\tEnumDisplaySettings() FAILED!\n");
-	} else {
-		dumpdevmode(&devmode);
-	}
+    fprintf(output,
+        "enumdisplay results\n"
+        "\n"
+        "Display settings:\n"
+           );
+    ZeroMemory(&devmode, sizeof(devmode));
+    devmode.dmSize = sizeof(DEVMODE);
+    if (!EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode)) {
+        fprintf(output, "\tEnumDisplaySettings() FAILED!\n");
+    } else {
+        dumpdevmode(&devmode);
+    }
 
-	fprintf(output,
-		"\n"
-		"All modes from EnumDisplaySettings:\n"
-	       );
-	ZeroMemory(&devmode, sizeof(devmode));
-	devmode.dmSize = sizeof(DEVMODE);
-	i = 0;
-	while (EnumDisplaySettings(NULL, i, &devmode)) {
-		dumpdevmode(&devmode);
-		fprintf(output, "\n");
-		ZeroMemory(&devmode, sizeof(devmode));
-		devmode.dmSize = sizeof(DEVMODE);
-		i++;
-	}
+    fprintf(output,
+        "\n"
+        "All modes from EnumDisplaySettings:\n"
+           );
+    ZeroMemory(&devmode, sizeof(devmode));
+    devmode.dmSize = sizeof(DEVMODE);
+    i = 0;
+    while (EnumDisplaySettings(NULL, i, &devmode)) {
+        dumpdevmode(&devmode);
+        fprintf(output, "\n");
+        ZeroMemory(&devmode, sizeof(devmode));
+        devmode.dmSize = sizeof(DEVMODE);
+        i++;
+    }
 
-	if (!InitDirectDraw()) {
-		fprintf(output,
-			"\n"
-			"All modes from IDirectDraw::EnumDisplayModes:\n"
-		       );
-		hresult = IDirectDraw_EnumDisplayModes(lpDD, 0, NULL, (LPVOID)0, ddenum);
-		if (hresult != DD_OK) {
-			fprintf(output, "\tIDirectDraw::EnumDisplayModes() FAILED! (%d)\n", hresult);
-		}
-	}
-	UninitDirectDraw();
+    if (!InitDirectDraw()) {
+        fprintf(output,
+            "\n"
+            "All modes from IDirectDraw::EnumDisplayModes:\n"
+               );
+        hresult = IDirectDraw_EnumDisplayModes(lpDD, 0, NULL, (LPVOID)0, ddenum);
+        if (hresult != DD_OK) {
+            fprintf(output, "\tIDirectDraw::EnumDisplayModes() FAILED! (%d)\n", hresult);
+        }
+    }
+    UninitDirectDraw();
 
-	if (outputfile) fclose(output);
+    if (outputfile) fclose(output);
 
-	return 0;
+    return 0;
 }
 
diff --git a/polymer/eduke32/build/src/misc/getdxdidf.c b/polymer/eduke32/build/src/misc/getdxdidf.c
index f0c7675c6..079e6c900 100644
--- a/polymer/eduke32/build/src/misc/getdxdidf.c
+++ b/polymer/eduke32/build/src/misc/getdxdidf.c
@@ -1,129 +1,129 @@
-// compile with:
-// gcc -o getdxdidf.exe src\getdxdidf.c -Ic:\mingw32\dx6\include -Lc:\mingw32\dx6\lib -ldxguid -ldinput -mwindows
-
-#define WIN32_LEAN_AND_MEAN
-#define INITGUID
-#include <windows.h>
-#include <dinput.h>
-#include <stdio.h>
-
-
-char *WhatGUID(const GUID *guid)
-{
-	if (guid == &GUID_XAxis) return "&GUID_XAxis";
-	if (guid == &GUID_YAxis) return "&GUID_YAxis";
-	if (guid == &GUID_ZAxis) return "&GUID_ZAxis";
-	if (guid == &GUID_RxAxis) return "&GUID_RxAxis";
-	if (guid == &GUID_RyAxis) return "&GUID_RyAxis";
-	if (guid == &GUID_RzAxis) return "&GUID_RzAxis";
-	if (guid == &GUID_Slider) return "&GUID_Slider";
-
-	if (guid == &GUID_Button) return "&GUID_Button";
-	if (guid == &GUID_Key) return "&GUID_Key";
-
-	if (guid == &GUID_POV) return "&GUID_POV";
-
-	if (guid == &GUID_Unknown) return "&GUID_Unknown";
-
-	return "NULL";
-}
-
-
-
-int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
-{
-	FILE *fp;
-	DWORD i;
-
-	fp = fopen("didf.txt", "w");
-	if (!fp) return -1;
-	setvbuf(fp, NULL, _IONBF, 0);
-
-
-	fprintf(fp,
-		"// Keyboard\n"
-		"\n"
-		"static DIOBJECTDATAFORMAT c_dfDIKeyboard_odf[] = {\n"
-		);
-
-	for (i=0; i<c_dfDIKeyboard.dwNumObjs; i++) {
-		fprintf(fp,
-			"\t{ %s, %d, 0x%08X, 0x%08X },\n",
-				WhatGUID(c_dfDIKeyboard.rgodf[i].pguid),
-				c_dfDIKeyboard.rgodf[i].dwOfs,
-				c_dfDIKeyboard.rgodf[i].dwType,
-				c_dfDIKeyboard.rgodf[i].dwFlags
-			);
-	}
-	fprintf(fp,
-		"};\n"
-		"\n"
-		"const DIDATAFORMAT c_dfDIKeyboard = { %d, %d, 0x%08X, %d, %d, c_dfDIKeyboard_odf };\n\n",
-		c_dfDIKeyboard.dwSize,
-    		c_dfDIKeyboard.dwObjSize,
-    		c_dfDIKeyboard.dwFlags,
-    		c_dfDIKeyboard.dwDataSize,
-    		c_dfDIKeyboard.dwNumObjs
-		);
-
-
-
-	fprintf(fp,
-		"// Mouse\n"
-		"\n"
-		"static DIOBJECTDATAFORMAT c_dfDIMouse_odf[] = {\n"
-		);
-
-	for (i=0; i<c_dfDIMouse.dwNumObjs; i++) {
-		fprintf(fp,
-			"\t{ %s, %d, 0x%08X, 0x%08X },\n",
-				WhatGUID(c_dfDIMouse.rgodf[i].pguid),
-				c_dfDIMouse.rgodf[i].dwOfs,
-				c_dfDIMouse.rgodf[i].dwType,
-				c_dfDIMouse.rgodf[i].dwFlags
-			);
-	}
-	fprintf(fp,
-		"};\n"
-		"\n"
-		"const DIDATAFORMAT c_dfDIMouse = { %d, %d, 0x%08X, %d, %d, c_dfDIMouse_odf };\n\n",
-		c_dfDIMouse.dwSize,
-    		c_dfDIMouse.dwObjSize,
-    		c_dfDIMouse.dwFlags,
-    		c_dfDIMouse.dwDataSize,
-    		c_dfDIMouse.dwNumObjs
-		);
-
-
-
-	fprintf(fp,
-		"// Joystick\n"
-		"\n"
-		"static DIOBJECTDATAFORMAT c_dfDIJoystick_odf[] = {\n"
-		);
-
-	for (i=0; i<c_dfDIJoystick.dwNumObjs; i++) {
-		fprintf(fp,
-			"\t{ %s, %d, 0x%08X, 0x%08X },\n",
-				WhatGUID(c_dfDIJoystick.rgodf[i].pguid),
-				c_dfDIJoystick.rgodf[i].dwOfs,
-				c_dfDIJoystick.rgodf[i].dwType,
-				c_dfDIJoystick.rgodf[i].dwFlags
-			);
-	}
-	fprintf(fp,
-		"};\n"
-		"\n"
-		"const DIDATAFORMAT c_dfDIJoystick = { %d, %d, 0x%08X, %d, %d, c_dfDIJoystick_odf };\n\n",
-		c_dfDIJoystick.dwSize,
-    		c_dfDIJoystick.dwObjSize,
-    		c_dfDIJoystick.dwFlags,
-    		c_dfDIJoystick.dwDataSize,
-    		c_dfDIJoystick.dwNumObjs
-		);
-
-
-	fclose(fp);
-
-	return 0;
-}
+// compile with:
+// gcc -o getdxdidf.exe src\getdxdidf.c -Ic:\mingw32\dx6\include -Lc:\mingw32\dx6\lib -ldxguid -ldinput -mwindows
+
+#define WIN32_LEAN_AND_MEAN
+#define INITGUID
+#include <windows.h>
+#include <dinput.h>
+#include <stdio.h>
+
+
+char *WhatGUID(const GUID *guid)
+{
+    if (guid == &GUID_XAxis) return "&GUID_XAxis";
+    if (guid == &GUID_YAxis) return "&GUID_YAxis";
+    if (guid == &GUID_ZAxis) return "&GUID_ZAxis";
+    if (guid == &GUID_RxAxis) return "&GUID_RxAxis";
+    if (guid == &GUID_RyAxis) return "&GUID_RyAxis";
+    if (guid == &GUID_RzAxis) return "&GUID_RzAxis";
+    if (guid == &GUID_Slider) return "&GUID_Slider";
+
+    if (guid == &GUID_Button) return "&GUID_Button";
+    if (guid == &GUID_Key) return "&GUID_Key";
+
+    if (guid == &GUID_POV) return "&GUID_POV";
+
+    if (guid == &GUID_Unknown) return "&GUID_Unknown";
+
+    return "NULL";
+}
+
+
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
+{
+    FILE *fp;
+    DWORD i;
+
+    fp = fopen("didf.txt", "w");
+    if (!fp) return -1;
+    setvbuf(fp, NULL, _IONBF, 0);
+
+
+    fprintf(fp,
+        "// Keyboard\n"
+        "\n"
+        "static DIOBJECTDATAFORMAT c_dfDIKeyboard_odf[] = {\n"
+        );
+
+    for (i=0; i<c_dfDIKeyboard.dwNumObjs; i++) {
+        fprintf(fp,
+            "\t{ %s, %d, 0x%08X, 0x%08X },\n",
+                WhatGUID(c_dfDIKeyboard.rgodf[i].pguid),
+                c_dfDIKeyboard.rgodf[i].dwOfs,
+                c_dfDIKeyboard.rgodf[i].dwType,
+                c_dfDIKeyboard.rgodf[i].dwFlags
+            );
+    }
+    fprintf(fp,
+        "};\n"
+        "\n"
+        "const DIDATAFORMAT c_dfDIKeyboard = { %d, %d, 0x%08X, %d, %d, c_dfDIKeyboard_odf };\n\n",
+        c_dfDIKeyboard.dwSize,
+            c_dfDIKeyboard.dwObjSize,
+            c_dfDIKeyboard.dwFlags,
+            c_dfDIKeyboard.dwDataSize,
+            c_dfDIKeyboard.dwNumObjs
+        );
+
+
+
+    fprintf(fp,
+        "// Mouse\n"
+        "\n"
+        "static DIOBJECTDATAFORMAT c_dfDIMouse_odf[] = {\n"
+        );
+
+    for (i=0; i<c_dfDIMouse.dwNumObjs; i++) {
+        fprintf(fp,
+            "\t{ %s, %d, 0x%08X, 0x%08X },\n",
+                WhatGUID(c_dfDIMouse.rgodf[i].pguid),
+                c_dfDIMouse.rgodf[i].dwOfs,
+                c_dfDIMouse.rgodf[i].dwType,
+                c_dfDIMouse.rgodf[i].dwFlags
+            );
+    }
+    fprintf(fp,
+        "};\n"
+        "\n"
+        "const DIDATAFORMAT c_dfDIMouse = { %d, %d, 0x%08X, %d, %d, c_dfDIMouse_odf };\n\n",
+        c_dfDIMouse.dwSize,
+            c_dfDIMouse.dwObjSize,
+            c_dfDIMouse.dwFlags,
+            c_dfDIMouse.dwDataSize,
+            c_dfDIMouse.dwNumObjs
+        );
+
+
+
+    fprintf(fp,
+        "// Joystick\n"
+        "\n"
+        "static DIOBJECTDATAFORMAT c_dfDIJoystick_odf[] = {\n"
+        );
+
+    for (i=0; i<c_dfDIJoystick.dwNumObjs; i++) {
+        fprintf(fp,
+            "\t{ %s, %d, 0x%08X, 0x%08X },\n",
+                WhatGUID(c_dfDIJoystick.rgodf[i].pguid),
+                c_dfDIJoystick.rgodf[i].dwOfs,
+                c_dfDIJoystick.rgodf[i].dwType,
+                c_dfDIJoystick.rgodf[i].dwFlags
+            );
+    }
+    fprintf(fp,
+        "};\n"
+        "\n"
+        "const DIDATAFORMAT c_dfDIJoystick = { %d, %d, 0x%08X, %d, %d, c_dfDIJoystick_odf };\n\n",
+        c_dfDIJoystick.dwSize,
+            c_dfDIJoystick.dwObjSize,
+            c_dfDIJoystick.dwFlags,
+            c_dfDIJoystick.dwDataSize,
+            c_dfDIJoystick.dwNumObjs
+        );
+
+
+    fclose(fp);
+
+    return 0;
+}
diff --git a/polymer/eduke32/build/src/misc/makesdlkeytrans.c b/polymer/eduke32/build/src/misc/makesdlkeytrans.c
index e34271078..ea76c1d59 100644
--- a/polymer/eduke32/build/src/misc/makesdlkeytrans.c
+++ b/polymer/eduke32/build/src/misc/makesdlkeytrans.c
@@ -1,163 +1,163 @@
-// gcc b.c -Lc:/mingw32/lib -lmingw32 -lSDLmain -lSDL
-
-#include <stdio.h>
-#include "SDL/SDL.h"
-
-int keytranslation[SDLK_LAST];
-char *keysyms[SDLK_LAST];
-
-static int buildkeytranslationtable(void)
-{
-	memset(keytranslation,0,sizeof(keytranslation));
-	memset(keysyms,0,sizeof(keysyms));
-
-#define MAP(x,y) { \
-	keytranslation[x] = y; \
-	keysyms[x] = #x ; \
-}
-	MAP(SDLK_BACKSPACE,	0xe);
-	MAP(SDLK_TAB,		0xf);
-	MAP(SDLK_RETURN,	0x1c);
-	MAP(SDLK_PAUSE,		0x59);	// 0x1d + 0x45 + 0x9d + 0xc5
-	MAP(SDLK_ESCAPE,	0x1);
-	MAP(SDLK_SPACE,		0x39);
-	MAP(SDLK_EXCLAIM,	0x2);	// '1'
-	MAP(SDLK_QUOTEDBL,	0x28);	// '''
-	MAP(SDLK_HASH,		0x4);	// '3'
-	MAP(SDLK_DOLLAR,	0x5);	// '4'
-	MAP(37,			0x6);	// '5' <-- where's the keysym SDL guys?
-	MAP(SDLK_AMPERSAND,	0x8);	// '7'
-	MAP(SDLK_QUOTE,		0x28);	// '''
-	MAP(SDLK_LEFTPAREN,	0xa);	// '9'
-	MAP(SDLK_RIGHTPAREN,	0xb);	// '0'
-	MAP(SDLK_ASTERISK,	0x9);	// '8'
-	MAP(SDLK_PLUS,		0xd);	// '='
-	MAP(SDLK_COMMA,		0x33);
-	MAP(SDLK_MINUS,		0xc);
-	MAP(SDLK_PERIOD,	0x34);
-	MAP(SDLK_SLASH,		0x35);
-	MAP(SDLK_0,		0xb);
-	MAP(SDLK_1,		0x2);
-	MAP(SDLK_2,		0x3);
-	MAP(SDLK_3,		0x4);
-	MAP(SDLK_4,		0x5);
-	MAP(SDLK_5,		0x6);
-	MAP(SDLK_6,		0x7);
-	MAP(SDLK_7,		0x8);
-	MAP(SDLK_8,		0x9);
-	MAP(SDLK_9,		0xa);
-	MAP(SDLK_COLON,		0x27);
-	MAP(SDLK_SEMICOLON,	0x27);
-	MAP(SDLK_LESS,		0x33);
-	MAP(SDLK_EQUALS,	0xd);
-	MAP(SDLK_GREATER,	0x34);
-	MAP(SDLK_QUESTION,	0x35);
-	MAP(SDLK_AT,		0x3);	// '2'
-	MAP(SDLK_LEFTBRACKET,	0x1a);
-	MAP(SDLK_BACKSLASH,	0x2b);
-	MAP(SDLK_RIGHTBRACKET,	0x1b);
-	MAP(SDLK_CARET,		0x7);	// '7'
-	MAP(SDLK_UNDERSCORE,	0xc);
-	MAP(SDLK_BACKQUOTE,	0x29);
-	MAP(SDLK_a,		0x1e);
-	MAP(SDLK_b,		0x30);
-	MAP(SDLK_c,		0x2e);
-	MAP(SDLK_d,		0x20);
-	MAP(SDLK_e,		0x12);
-	MAP(SDLK_f,		0x21);
-	MAP(SDLK_g,		0x22);
-	MAP(SDLK_h,		0x23);
-	MAP(SDLK_i,		0x17);
-	MAP(SDLK_j,		0x24);
-	MAP(SDLK_k,		0x25);
-	MAP(SDLK_l,		0x26);
-	MAP(SDLK_m,		0x32);
-	MAP(SDLK_n,		0x31);
-	MAP(SDLK_o,		0x18);
-	MAP(SDLK_p,		0x19);
-	MAP(SDLK_q,		0x10);
-	MAP(SDLK_r,		0x13);
-	MAP(SDLK_s,		0x1f);
-	MAP(SDLK_t,		0x14);
-	MAP(SDLK_u,		0x16);
-	MAP(SDLK_v,		0x2f);
-	MAP(SDLK_w,		0x11);
-	MAP(SDLK_x,		0x2d);
-	MAP(SDLK_y,		0x15);
-	MAP(SDLK_z,		0x2c);
-	MAP(SDLK_DELETE,	0xd3);
-	MAP(SDLK_KP0,		0x52);
-	MAP(SDLK_KP1,		0x4f);
-	MAP(SDLK_KP2,		0x50);
-	MAP(SDLK_KP3,		0x51);
-	MAP(SDLK_KP4,		0x4b);
-	MAP(SDLK_KP5,		0x4c);
-	MAP(SDLK_KP6,		0x4d);
-	MAP(SDLK_KP7,		0x47);
-	MAP(SDLK_KP8,		0x48);
-	MAP(SDLK_KP9,		0x49);
-	MAP(SDLK_KP_PERIOD,	0x53);
-	MAP(SDLK_KP_DIVIDE,	0xb5);
-	MAP(SDLK_KP_MULTIPLY,	0x37);
-	MAP(SDLK_KP_MINUS,	0x4a);
-	MAP(SDLK_KP_PLUS,	0x4e);
-	MAP(SDLK_KP_ENTER,	0x9c);
-	//MAP(SDLK_KP_EQUALS,	);
-	MAP(SDLK_UP,		0xc8);
-	MAP(SDLK_DOWN,		0xd0);
-	MAP(SDLK_RIGHT,		0xcd);
-	MAP(SDLK_LEFT,		0xcb);
-	MAP(SDLK_INSERT,	0xd2);
-	MAP(SDLK_HOME,		0xc7);
-	MAP(SDLK_END,		0xcf);
-	MAP(SDLK_PAGEUP,	0xc9);
-	MAP(SDLK_PAGEDOWN,	0xd1);
-	MAP(SDLK_F1,		0x3b);
-	MAP(SDLK_F2,		0x3c);
-	MAP(SDLK_F3,		0x3d);
-	MAP(SDLK_F4,		0x3e);
-	MAP(SDLK_F5,		0x3f);
-	MAP(SDLK_F6,		0x40);
-	MAP(SDLK_F7,		0x41);
-	MAP(SDLK_F8,		0x42);
-	MAP(SDLK_F9,		0x43);
-	MAP(SDLK_F10,		0x44);
-	MAP(SDLK_F11,		0x57);
-	MAP(SDLK_F12,		0x58);
-	MAP(SDLK_NUMLOCK,	0x45);
-	MAP(SDLK_CAPSLOCK,	0x3a);
-	MAP(SDLK_SCROLLOCK,	0x46);
-	MAP(SDLK_RSHIFT,	0x36);
-	MAP(SDLK_LSHIFT,	0x2a);
-	MAP(SDLK_RCTRL,		0x9d);
-	MAP(SDLK_LCTRL,		0x1d);
-	MAP(SDLK_RALT,		0xb8);
-	MAP(SDLK_LALT,		0x38);
-	MAP(SDLK_LSUPER,	0xdb);	// win l
-	MAP(SDLK_RSUPER,	0xdc);	// win r
-	MAP(SDLK_PRINT,		-2);	// 0xaa + 0xb7
-	MAP(SDLK_SYSREQ,	0x54);	// alt+printscr
-	MAP(SDLK_BREAK,		0xb7);	// ctrl+pause
-	MAP(SDLK_MENU,		0xdd);	// win menu?
-#undef MAP
-
-	return 0;
-}
-
-#undef main
-
-int main(int argc, char **argv)
-{
-	int i;
-	
-	buildkeytranslationtable();
-
-	for (i=0;i<SDLK_LAST;i++) {
-		if (i>0) printf(", ");
-		if (i%8 == 7) printf("\n");
-		printf("%d",keytranslation[i]);
-	}
-	
-	return 0;
-}
-
+// gcc b.c -Lc:/mingw32/lib -lmingw32 -lSDLmain -lSDL
+
+#include <stdio.h>
+#include "SDL/SDL.h"
+
+int keytranslation[SDLK_LAST];
+char *keysyms[SDLK_LAST];
+
+static int buildkeytranslationtable(void)
+{
+    memset(keytranslation,0,sizeof(keytranslation));
+    memset(keysyms,0,sizeof(keysyms));
+
+#define MAP(x,y) { \
+    keytranslation[x] = y; \
+    keysyms[x] = #x ; \
+}
+    MAP(SDLK_BACKSPACE,    0xe);
+    MAP(SDLK_TAB,        0xf);
+    MAP(SDLK_RETURN,    0x1c);
+    MAP(SDLK_PAUSE,        0x59);    // 0x1d + 0x45 + 0x9d + 0xc5
+    MAP(SDLK_ESCAPE,    0x1);
+    MAP(SDLK_SPACE,        0x39);
+    MAP(SDLK_EXCLAIM,    0x2);    // '1'
+    MAP(SDLK_QUOTEDBL,    0x28);    // '''
+    MAP(SDLK_HASH,        0x4);    // '3'
+    MAP(SDLK_DOLLAR,    0x5);    // '4'
+    MAP(37,            0x6);    // '5' <-- where's the keysym SDL guys?
+    MAP(SDLK_AMPERSAND,    0x8);    // '7'
+    MAP(SDLK_QUOTE,        0x28);    // '''
+    MAP(SDLK_LEFTPAREN,    0xa);    // '9'
+    MAP(SDLK_RIGHTPAREN,    0xb);    // '0'
+    MAP(SDLK_ASTERISK,    0x9);    // '8'
+    MAP(SDLK_PLUS,        0xd);    // '='
+    MAP(SDLK_COMMA,        0x33);
+    MAP(SDLK_MINUS,        0xc);
+    MAP(SDLK_PERIOD,    0x34);
+    MAP(SDLK_SLASH,        0x35);
+    MAP(SDLK_0,        0xb);
+    MAP(SDLK_1,        0x2);
+    MAP(SDLK_2,        0x3);
+    MAP(SDLK_3,        0x4);
+    MAP(SDLK_4,        0x5);
+    MAP(SDLK_5,        0x6);
+    MAP(SDLK_6,        0x7);
+    MAP(SDLK_7,        0x8);
+    MAP(SDLK_8,        0x9);
+    MAP(SDLK_9,        0xa);
+    MAP(SDLK_COLON,        0x27);
+    MAP(SDLK_SEMICOLON,    0x27);
+    MAP(SDLK_LESS,        0x33);
+    MAP(SDLK_EQUALS,    0xd);
+    MAP(SDLK_GREATER,    0x34);
+    MAP(SDLK_QUESTION,    0x35);
+    MAP(SDLK_AT,        0x3);    // '2'
+    MAP(SDLK_LEFTBRACKET,    0x1a);
+    MAP(SDLK_BACKSLASH,    0x2b);
+    MAP(SDLK_RIGHTBRACKET,    0x1b);
+    MAP(SDLK_CARET,        0x7);    // '7'
+    MAP(SDLK_UNDERSCORE,    0xc);
+    MAP(SDLK_BACKQUOTE,    0x29);
+    MAP(SDLK_a,        0x1e);
+    MAP(SDLK_b,        0x30);
+    MAP(SDLK_c,        0x2e);
+    MAP(SDLK_d,        0x20);
+    MAP(SDLK_e,        0x12);
+    MAP(SDLK_f,        0x21);
+    MAP(SDLK_g,        0x22);
+    MAP(SDLK_h,        0x23);
+    MAP(SDLK_i,        0x17);
+    MAP(SDLK_j,        0x24);
+    MAP(SDLK_k,        0x25);
+    MAP(SDLK_l,        0x26);
+    MAP(SDLK_m,        0x32);
+    MAP(SDLK_n,        0x31);
+    MAP(SDLK_o,        0x18);
+    MAP(SDLK_p,        0x19);
+    MAP(SDLK_q,        0x10);
+    MAP(SDLK_r,        0x13);
+    MAP(SDLK_s,        0x1f);
+    MAP(SDLK_t,        0x14);
+    MAP(SDLK_u,        0x16);
+    MAP(SDLK_v,        0x2f);
+    MAP(SDLK_w,        0x11);
+    MAP(SDLK_x,        0x2d);
+    MAP(SDLK_y,        0x15);
+    MAP(SDLK_z,        0x2c);
+    MAP(SDLK_DELETE,    0xd3);
+    MAP(SDLK_KP0,        0x52);
+    MAP(SDLK_KP1,        0x4f);
+    MAP(SDLK_KP2,        0x50);
+    MAP(SDLK_KP3,        0x51);
+    MAP(SDLK_KP4,        0x4b);
+    MAP(SDLK_KP5,        0x4c);
+    MAP(SDLK_KP6,        0x4d);
+    MAP(SDLK_KP7,        0x47);
+    MAP(SDLK_KP8,        0x48);
+    MAP(SDLK_KP9,        0x49);
+    MAP(SDLK_KP_PERIOD,    0x53);
+    MAP(SDLK_KP_DIVIDE,    0xb5);
+    MAP(SDLK_KP_MULTIPLY,    0x37);
+    MAP(SDLK_KP_MINUS,    0x4a);
+    MAP(SDLK_KP_PLUS,    0x4e);
+    MAP(SDLK_KP_ENTER,    0x9c);
+    //MAP(SDLK_KP_EQUALS,    );
+    MAP(SDLK_UP,        0xc8);
+    MAP(SDLK_DOWN,        0xd0);
+    MAP(SDLK_RIGHT,        0xcd);
+    MAP(SDLK_LEFT,        0xcb);
+    MAP(SDLK_INSERT,    0xd2);
+    MAP(SDLK_HOME,        0xc7);
+    MAP(SDLK_END,        0xcf);
+    MAP(SDLK_PAGEUP,    0xc9);
+    MAP(SDLK_PAGEDOWN,    0xd1);
+    MAP(SDLK_F1,        0x3b);
+    MAP(SDLK_F2,        0x3c);
+    MAP(SDLK_F3,        0x3d);
+    MAP(SDLK_F4,        0x3e);
+    MAP(SDLK_F5,        0x3f);
+    MAP(SDLK_F6,        0x40);
+    MAP(SDLK_F7,        0x41);
+    MAP(SDLK_F8,        0x42);
+    MAP(SDLK_F9,        0x43);
+    MAP(SDLK_F10,        0x44);
+    MAP(SDLK_F11,        0x57);
+    MAP(SDLK_F12,        0x58);
+    MAP(SDLK_NUMLOCK,    0x45);
+    MAP(SDLK_CAPSLOCK,    0x3a);
+    MAP(SDLK_SCROLLOCK,    0x46);
+    MAP(SDLK_RSHIFT,    0x36);
+    MAP(SDLK_LSHIFT,    0x2a);
+    MAP(SDLK_RCTRL,        0x9d);
+    MAP(SDLK_LCTRL,        0x1d);
+    MAP(SDLK_RALT,        0xb8);
+    MAP(SDLK_LALT,        0x38);
+    MAP(SDLK_LSUPER,    0xdb);    // win l
+    MAP(SDLK_RSUPER,    0xdc);    // win r
+    MAP(SDLK_PRINT,        -2);    // 0xaa + 0xb7
+    MAP(SDLK_SYSREQ,    0x54);    // alt+printscr
+    MAP(SDLK_BREAK,        0xb7);    // ctrl+pause
+    MAP(SDLK_MENU,        0xdd);    // win menu?
+#undef MAP
+
+    return 0;
+}
+
+#undef main
+
+int main(int argc, char **argv)
+{
+    int i;
+
+    buildkeytranslationtable();
+
+    for (i=0;i<SDLK_LAST;i++) {
+        if (i>0) printf(", ");
+        if (i%8 == 7) printf("\n");
+        printf("%d",keytranslation[i]);
+    }
+
+    return 0;
+}
+
diff --git a/polymer/eduke32/build/src/util/bin2c.cpp b/polymer/eduke32/build/src/util/bin2c.cpp
index e0f5fe4ea..98741b232 100644
--- a/polymer/eduke32/build/src/util/bin2c.cpp
+++ b/polymer/eduke32/build/src/util/bin2c.cpp
@@ -24,115 +24,115 @@ int PathAddExt(char *path, char *ext);
 
 int main(int argc, char *argv[])
 {
-	printf("BIN2C - Binary to C data converter\n"
-			 "Copyright (c) 1999 Jonathon Fowler\n\n");
+    printf("BIN2C - Binary to C data converter\n"
+             "Copyright (c) 1999 Jonathon Fowler\n\n");
 
-	if (argc < 4)
-	{
-		printf("Usage:\n"
-				 "   BIN2C source<.DAT> output<.C> b|w\n\n"
-				 "   source<.DAT>   Binary source file\n"
-				 "   output<.C>     Output C code file\n"
-				 "   b|w            Byte or word-sized data\n\n");
-		exit(0);
-	}
+    if (argc < 4)
+    {
+        printf("Usage:\n"
+                 "   BIN2C source<.DAT> output<.C> b|w\n\n"
+                 "   source<.DAT>   Binary source file\n"
+                 "   output<.C>     Output C code file\n"
+                 "   b|w            Byte or word-sized data\n\n");
+        exit(0);
+    }
 
-	int arg;
-	FILE *in, *out;
-	char datab1, datab2;
-	int across=0, maxacross;
-	int length, written=0;
+    int arg;
+    FILE *in, *out;
+    char datab1, datab2;
+    int across=0, maxacross;
+    int length, written=0;
 
 
-	// get the source file
-	strcpy(source, argv[1]);
-	strupr(source);
-	PathAddExt(source, defsrcext);
-	printf("þ Source file:  %s\n", source);
+    // get the source file
+    strcpy(source, argv[1]);
+    strupr(source);
+    PathAddExt(source, defsrcext);
+    printf("þ Source file:  %s\n", source);
 
-	// get the output file
-	strcpy(output, argv[2]);
-	strupr(output);
-	PathAddExt(output, defoutext);
-	printf("þ Output file:  %s\n", output);
+    // get the output file
+    strcpy(output, argv[2]);
+    strupr(output);
+    PathAddExt(output, defoutext);
+    printf("þ Output file:  %s\n", output);
 
-	// get byte/word data
-	switch (tolower(argv[3][0]))
-	{
-		case 'b':
-			printf("þ Byte data.\n");
-			bytesize=1;
-			break;
+    // get byte/word data
+    switch (tolower(argv[3][0]))
+    {
+        case 'b':
+            printf("þ Byte data.\n");
+            bytesize=1;
+            break;
 
-		case 'w':
-			printf("þ Word data.\n");
-			bytesize=0;
-			break;
+        case 'w':
+            printf("þ Word data.\n");
+            bytesize=0;
+            break;
 
-		default:
-			printf("þ Unknown data size specified. Defaulting to byte.\n");
-			bytesize=1;
-			break;
-	}
+        default:
+            printf("þ Unknown data size specified. Defaulting to byte.\n");
+            bytesize=1;
+            break;
+    }
 
-	// open the input file
-	in = fopen(source, "rb");
-	if (!in)
-	{
-		printf("Error opening %s\n", source);
-		exit(1);
-	}
+    // open the input file
+    in = fopen(source, "rb");
+    if (!in)
+    {
+        printf("Error opening %s\n", source);
+        exit(1);
+    }
 
-	// open the output file
-	out = fopen(output, "w+t");
-	if (!out)
-	{
-		printf("Error creating %s\n", output);
-		exit(1);
-	}
+    // open the output file
+    out = fopen(output, "w+t");
+    if (!out)
+    {
+        printf("Error creating %s\n", output);
+        exit(1);
+    }
 
-	length = filelength(fileno(in));
+    length = filelength(fileno(in));
 
-	// write a header out to the output file
-	fprintf(out, "// %s\n\n// Generated by BIN2C.EXE\n// By Jonathon Fowler\n\n", output);
+    // write a header out to the output file
+    fprintf(out, "// %s\n\n// Generated by BIN2C.EXE\n// By Jonathon Fowler\n\n", output);
 
-	// start a data block
-	fprintf(out, "%s datablock[] = {\n // %ld bytes", (bytesize) ? "char" : "unsigned", length);
+    // start a data block
+    fprintf(out, "%s datablock[] = {\n // %ld bytes", (bytesize) ? "char" : "unsigned", length);
 
-	if (bytesize)
-		maxacross = 12;
-	else
-		maxacross = 9;
-	across = maxacross;
+    if (bytesize)
+        maxacross = 12;
+    else
+        maxacross = 9;
+    across = maxacross;
 
-	// convert the data
-	for (written=0; written<length; written++) {
-		if (across == maxacross)
-		{
-			fprintf(out, "\n  ");
-			across = 0;
-		}
+    // convert the data
+    for (written=0; written<length; written++) {
+        if (across == maxacross)
+        {
+            fprintf(out, "\n  ");
+            across = 0;
+        }
 
-		if (bytesize)
-		{
-			datab1 = fgetc(in);
-			fprintf(out, " 0x%02X%c", datab1, ((length-written)>1) ? ',' : '\n');
-		} else {
-			datab1 = fgetc(in);
-			datab2 = fgetc(in);
-			fprintf(out, " 0x%02X%02X%c", datab2, datab1, ((length-written)>2) ? ',' : '\n');
-		}
+        if (bytesize)
+        {
+            datab1 = fgetc(in);
+            fprintf(out, " 0x%02X%c", datab1, ((length-written)>1) ? ',' : '\n');
+        } else {
+            datab1 = fgetc(in);
+            datab2 = fgetc(in);
+            fprintf(out, " 0x%02X%02X%c", datab2, datab1, ((length-written)>2) ? ',' : '\n');
+        }
 
-		across++;
+        across++;
 
-		if (!bytesize) written++;
-	}
+        if (!bytesize) written++;
+    }
 
 
-	fprintf(out, "  };");
+    fprintf(out, "  };");
 
-	fclose(out);
-	fclose(in);
+    fclose(out);
+    fclose(in);
 
     return 0;
 }
@@ -141,13 +141,13 @@ int main(int argc, char *argv[])
 // Add an extention to a path if one doesn't exist
 int PathAddExt(char *path, char *ext)
 {
-	char drive[MAXDRIVE], dir[MAXDIR], name[MAXFILE], extn[MAXEXT];
-	int flags;
+    char drive[MAXDRIVE], dir[MAXDIR], name[MAXFILE], extn[MAXEXT];
+    int flags;
 
-	flags = fnsplit(path, drive, dir, name, extn);
+    flags = fnsplit(path, drive, dir, name, extn);
 
-	if (!(flags & EXTENSION))	// tack on an extension
-		strcat(path, ext);
+    if (!(flags & EXTENSION))    // tack on an extension
+        strcat(path, ext);
 
-	return ((flags & EXTENSION) == 0);
+    return ((flags & EXTENSION) == 0);
 }
diff --git a/polymer/eduke32/build/src/util/cacheinfo.c b/polymer/eduke32/build/src/util/cacheinfo.c
index cc658719b..893ad3fcc 100644
--- a/polymer/eduke32/build/src/util/cacheinfo.c
+++ b/polymer/eduke32/build/src/util/cacheinfo.c
@@ -10,81 +10,81 @@
 #define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  0x83F3
 
 typedef struct {
-	char magic[8];	// 'Polymost'
-	int xdim, ydim;	// of image, unpadded
-	int flags;		// 1 = !2^x, 2 = has alpha, 4 = lzw compressed
+    char magic[8];    // 'Polymost'
+    int xdim, ydim;    // of image, unpadded
+    int flags;        // 1 = !2^x, 2 = has alpha, 4 = lzw compressed
 } texcacheheader;
 typedef struct {
-	int size;
-	int format;
-	int xdim, ydim;	// of mipmap (possibly padded)
-	int border, depth;
+    int size;
+    int format;
+    int xdim, ydim;    // of mipmap (possibly padded)
+    int border, depth;
 } texcachepicture;
 
 int main(void)
 {
-	DIR *dir;
-	struct dirent *dirent;
-	struct stat st;
-	FILE *fp;
-	texcacheheader head;
-	texcachepicture mip;
-	
-	dir = opendir(".");
-	while ((dirent = readdir(dir))) {
-		if (stat(dirent->d_name, &st)) {
-			printf("%s: failed to stat\n", dirent->d_name);
-			continue;
-		}
-		if (!(st.st_mode&S_IFREG)) {
-			printf("%s: not a regular file\n", dirent->d_name);
-			continue;
-		}
-		
-		fp = fopen(dirent->d_name,"rb");
-		if (!fp) {
-			printf("%s: failed to open\n", dirent->d_name);
-			continue;
-		}
-		
-		if (fread(&head, sizeof(head), 1, fp) != 1) {
-			fclose(fp);
-			printf("%s: failed to read header\n", dirent->d_name);
-			continue;
-		}
-		head.xdim = B_LITTLE32(head.xdim);
-		head.ydim = B_LITTLE32(head.ydim);
-		head.flags = B_LITTLE32(head.flags);
-		if (fread(&mip, sizeof(mip), 1, fp) != 1) {
-			fclose(fp);
-			printf("%s: failed to read mipmap header\n", dirent->d_name);
-			continue;
-		}
-		mip.format = B_LITTLE32(mip.format);
-		fclose(fp);
-		if (memcmp(head.magic, "Polymost", 8)) {
-			printf("%s: bad signature\n", dirent->d_name);
-			continue;
-		}
-		else {
-			char *format;
-			char flags[4] = "", flagsc = 0;
-			switch (mip.format) {
-				case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: format = "RGB DXT1"; break;
-				case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: format = "RGBA DXT1"; break;
-				case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: format = "RGBA DXT3"; break;
-				case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: format = "RGBA DXT5"; break;
-				default: format = "Unknown"; break;
-			}
-			if (head.flags&1) flags[flagsc++] = '2';
-			if (head.flags&2) flags[flagsc++] = 'A';
-			if (head.flags&4) flags[flagsc++] = 'L';
-			flags[flagsc++] = 0;
-			
-			printf("%s: flags=%s format=%s\n", dirent->d_name, flags, format);
-		}
-	}
-	closedir(dir);
-	
-	return 0;
-}
\ No newline at end of file
+    DIR *dir;
+    struct dirent *dirent;
+    struct stat st;
+    FILE *fp;
+    texcacheheader head;
+    texcachepicture mip;
+
+    dir = opendir(".");
+    while ((dirent = readdir(dir))) {
+        if (stat(dirent->d_name, &st)) {
+            printf("%s: failed to stat\n", dirent->d_name);
+            continue;
+        }
+        if (!(st.st_mode&S_IFREG)) {
+            printf("%s: not a regular file\n", dirent->d_name);
+            continue;
+        }
+
+        fp = fopen(dirent->d_name,"rb");
+        if (!fp) {
+            printf("%s: failed to open\n", dirent->d_name);
+            continue;
+        }
+
+        if (fread(&head, sizeof(head), 1, fp) != 1) {
+            fclose(fp);
+            printf("%s: failed to read header\n", dirent->d_name);
+            continue;
+        }
+        head.xdim = B_LITTLE32(head.xdim);
+        head.ydim = B_LITTLE32(head.ydim);
+        head.flags = B_LITTLE32(head.flags);
+        if (fread(&mip, sizeof(mip), 1, fp) != 1) {
+            fclose(fp);
+            printf("%s: failed to read mipmap header\n", dirent->d_name);
+            continue;
+        }
+        mip.format = B_LITTLE32(mip.format);
+        fclose(fp);
+        if (memcmp(head.magic, "Polymost", 8)) {
+            printf("%s: bad signature\n", dirent->d_name);
+            continue;
+        }
+        else {
+            char *format;
+            char flags[4] = "", flagsc = 0;
+            switch (mip.format) {
+                case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: format = "RGB DXT1"; break;
+                case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: format = "RGBA DXT1"; break;
+                case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: format = "RGBA DXT3"; break;
+                case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: format = "RGBA DXT5"; break;
+                default: format = "Unknown"; break;
+            }
+            if (head.flags&1) flags[flagsc++] = '2';
+            if (head.flags&2) flags[flagsc++] = 'A';
+            if (head.flags&4) flags[flagsc++] = 'L';
+            flags[flagsc++] = 0;
+
+            printf("%s: flags=%s format=%s\n", dirent->d_name, flags, format);
+        }
+    }
+    closedir(dir);
+
+    return 0;
+}
diff --git a/polymer/eduke32/build/src/util/generateicon.c b/polymer/eduke32/build/src/util/generateicon.c
index db5860a28..9b8386854 100644
--- a/polymer/eduke32/build/src/util/generateicon.c
+++ b/polymer/eduke32/build/src/util/generateicon.c
@@ -3,109 +3,109 @@
 #include "compat.h"
 
 struct icon {
-	int width,height;
-	unsigned int *pixels;
-	unsigned char *mask;
+    int width,height;
+    unsigned int *pixels;
+    unsigned char *mask;
 };
 
 int writeicon(FILE *fp, struct icon *ico)
 {
-	int i;
-	
-	fprintf(fp,
-		"#include \"sdlayer.h\"\n"
-		"\n"
-	);
-	fprintf(fp,"static unsigned int sdlappicon_pixels[] = {\n");
-	for (i=0;i<ico->width*ico->height;i++) {
-		if ((i%6) == 0) fprintf(fp,"\t");
-		else fprintf(fp," ");
-		fprintf(fp, "0x%08x,", B_LITTLE32(ico->pixels[i]));
-		if ((i%6) == 5) fprintf(fp,"\n");
-	}
-	if ((i%16) > 0) fprintf(fp, "\n");
-	fprintf(fp, "};\n\n");
-	
-	fprintf(fp,"static unsigned char sdlappicon_mask[] = {\n");
-	for (i=0;i<((ico->width+7)/8)*ico->height;i++) {
-		if ((i%14) == 0) fprintf(fp,"\t");
-		else fprintf(fp," ");
-		fprintf(fp, "%3d,", ico->mask[i]);
-		if ((i%14) == 13) fprintf(fp,"\n");
-	}
-	if ((i%16) > 0) fprintf(fp, "\n");
-	fprintf(fp, "};\n\n");
+    int i;
 
-	fprintf(fp,
-		"struct sdlappicon sdlappicon = {\n"
-		"	%d,%d,	// width,height\n"
-		"	sdlappicon_pixels,\n"
-		"	sdlappicon_mask\n"
-		"};\n",
-		ico->width, ico->height
-	);
+    fprintf(fp,
+        "#include \"sdlayer.h\"\n"
+        "\n"
+    );
+    fprintf(fp,"static unsigned int sdlappicon_pixels[] = {\n");
+    for (i=0;i<ico->width*ico->height;i++) {
+        if ((i%6) == 0) fprintf(fp,"\t");
+        else fprintf(fp," ");
+        fprintf(fp, "0x%08x,", B_LITTLE32(ico->pixels[i]));
+        if ((i%6) == 5) fprintf(fp,"\n");
+    }
+    if ((i%16) > 0) fprintf(fp, "\n");
+    fprintf(fp, "};\n\n");
 
-	return 0;
+    fprintf(fp,"static unsigned char sdlappicon_mask[] = {\n");
+    for (i=0;i<((ico->width+7)/8)*ico->height;i++) {
+        if ((i%14) == 0) fprintf(fp,"\t");
+        else fprintf(fp," ");
+        fprintf(fp, "%3d,", ico->mask[i]);
+        if ((i%14) == 13) fprintf(fp,"\n");
+    }
+    if ((i%16) > 0) fprintf(fp, "\n");
+    fprintf(fp, "};\n\n");
+
+    fprintf(fp,
+        "struct sdlappicon sdlappicon = {\n"
+        "    %d,%d,    // width,height\n"
+        "    sdlappicon_pixels,\n"
+        "    sdlappicon_mask\n"
+        "};\n",
+        ico->width, ico->height
+    );
+
+    return 0;
 }
 
 int main(int argc, char **argv)
 {
-	struct icon icon;
-	int bpl;
-	int i;
-	unsigned char *maskp, bm, *pp;
+    struct icon icon;
+    int bpl;
+    int i;
+    unsigned char *maskp, bm, *pp;
 
-	if (argc<2) {
-		fprintf(stderr, "generateicon <picture file>\n");
-		return 1;
-	}
+    if (argc<2) {
+        fprintf(stderr, "generateicon <picture file>\n");
+        return 1;
+    }
 
-	memset(&icon, 0, sizeof(icon));
+    memset(&icon, 0, sizeof(icon));
 
-	kpzload(argv[1], (int*)&icon.pixels, &bpl, (int*)&icon.width, (int*)&icon.height);
-	if (!icon.pixels) {
-		fprintf(stderr, "Failure loading %s\n", argv[1]);
-		return 1;
-	}
+    kpzload(argv[1], (int*)&icon.pixels, &bpl, (int*)&icon.width, (int*)&icon.height);
+    if (!icon.pixels) {
+        fprintf(stderr, "Failure loading %s\n", argv[1]);
+        return 1;
+    }
 
-	if (bpl != icon.width * 4) {
-		fprintf(stderr, "bpl != icon.width * 4\n");
-		free(icon.pixels);
-		return 1;
-	}
+    if (bpl != icon.width * 4) {
+        fprintf(stderr, "bpl != icon.width * 4\n");
+        free(icon.pixels);
+        return 1;
+    }
 
-	icon.mask = (unsigned char *)calloc(icon.height, (icon.width+7)/8);
-	if (!icon.mask) {
-		fprintf(stderr, "Out of memory\n");
-		free(icon.pixels);
-		return 1;
-	}
+    icon.mask = (unsigned char *)calloc(icon.height, (icon.width+7)/8);
+    if (!icon.mask) {
+        fprintf(stderr, "Out of memory\n");
+        free(icon.pixels);
+        return 1;
+    }
 
-	maskp = icon.mask;
-	bm = 1;
-	pp = (unsigned char *)icon.pixels;
-	for (i=0; i<icon.height*icon.width; i++) {
-		if (bm == 0) {
-			bm = 1;
-			maskp++;
-		}
+    maskp = icon.mask;
+    bm = 1;
+    pp = (unsigned char *)icon.pixels;
+    for (i=0; i<icon.height*icon.width; i++) {
+        if (bm == 0) {
+            bm = 1;
+            maskp++;
+        }
 
-		{
-			unsigned char c = pp[0];
-			pp[0] = pp[2];
-			pp[2] = c;
-		}
-		if (pp[3] > 0) *maskp |= bm;
+        {
+            unsigned char c = pp[0];
+            pp[0] = pp[2];
+            pp[2] = c;
+        }
+        if (pp[3] > 0) *maskp |= bm;
 
-		bm <<= 1;
-		pp += 4;
-	}
+        bm <<= 1;
+        pp += 4;
+    }
 
-	writeicon(stdout, &icon);
-	
-	free(icon.pixels);
-	free(icon.mask);
+    writeicon(stdout, &icon);
 
-	return 0;
+    free(icon.pixels);
+    free(icon.mask);
+
+    return 0;
 }
 
diff --git a/polymer/eduke32/build/src/util/kextract.c b/polymer/eduke32/build/src/util/kextract.c
index ce2a158f3..c631270ff 100644
--- a/polymer/eduke32/build/src/util/kextract.c
+++ b/polymer/eduke32/build/src/util/kextract.c
@@ -18,68 +18,68 @@ static int fileoffs[MAXFILES+1], fileleng[MAXFILES];
 
 void findfiles(const char *dafilespec)
 {
-	char t[13];
-	int i;
+    char t[13];
+    int i;
 
-	for(i=numfiles-1;i>=0;i--)
-	{
-		memcpy(t,filelist[i],12);
-		t[12] = 0;
-		
-		if (Bwildmatch(t,dafilespec)) {
-			marked4extraction[i] = 1;
-			anyfiles4extraction = 1;
-		}
-	}
+    for(i=numfiles-1;i>=0;i--)
+    {
+        memcpy(t,filelist[i],12);
+        t[12] = 0;
+
+        if (Bwildmatch(t,dafilespec)) {
+            marked4extraction[i] = 1;
+            anyfiles4extraction = 1;
+        }
+    }
 }
 
 int main(int argc, char **argv)
 {
-	int i, j, k, l, fil, fil2;
+    int i, j, k, l, fil, fil2;
 
-	int onlylist = (argc==2);
+    int onlylist = (argc==2);
 
-	if (argc < 2)
-	{
-		printf("KEXTRACT <groupfile.grp> [@file or filespec...]           by Kenneth Silverman\n");
-		printf("   This program extracts files from a previously grouped group file.\n");
-		printf("   You can extract files using the ? and * wildcards.\n");
-		printf("   Ex: kextract stuff.dat tiles000.art nukeland.map palette.dat\n");
-		printf("         (stuff.dat is the group file, the rest are the files to extract)\n");
-		printf("       kextract stuff.grp\n");
+    if (argc < 2)
+    {
+        printf("KEXTRACT <groupfile.grp> [@file or filespec...]           by Kenneth Silverman\n");
+        printf("   This program extracts files from a previously grouped group file.\n");
+        printf("   You can extract files using the ? and * wildcards.\n");
+        printf("   Ex: kextract stuff.dat tiles000.art nukeland.map palette.dat\n");
+        printf("         (stuff.dat is the group file, the rest are the files to extract)\n");
+        printf("       kextract stuff.grp\n");
         printf("         (simply lists the contents of stuff.grp)\n");
-		return(0);
-	}
+        return(0);
+    }
 
-	if ((fil = Bopen(argv[1],BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
-	{
-		printf("Error: %s could not be opened\n",argv[1]);
-		return(0);
-	}
+    if ((fil = Bopen(argv[1],BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
+    {
+        printf("Error: %s could not be opened\n",argv[1]);
+        return(0);
+    }
 
-	Bread(fil,buf,16);
-	if ((buf[0] != 'K') || (buf[1] != 'e') || (buf[2] != 'n') ||
-		 (buf[3] != 'S') || (buf[4] != 'i') || (buf[5] != 'l') ||
-		 (buf[6] != 'v') || (buf[7] != 'e') || (buf[8] != 'r') ||
-		 (buf[9] != 'm') || (buf[10] != 'a') || (buf[11] != 'n'))
-	{
-		Bclose(fil);
-		printf("Error: %s not a valid group file\n",argv[1]);
-		return(0);
-	}
-	numfiles = *((int*)&buf[12]); numfiles = B_LITTLE32(numfiles);
+    Bread(fil,buf,16);
+    if ((buf[0] != 'K') || (buf[1] != 'e') || (buf[2] != 'n') ||
+         (buf[3] != 'S') || (buf[4] != 'i') || (buf[5] != 'l') ||
+         (buf[6] != 'v') || (buf[7] != 'e') || (buf[8] != 'r') ||
+         (buf[9] != 'm') || (buf[10] != 'a') || (buf[11] != 'n'))
+    {
+        Bclose(fil);
+        printf("Error: %s not a valid group file\n",argv[1]);
+        return(0);
+    }
+    numfiles = *((int*)&buf[12]); numfiles = B_LITTLE32(numfiles);
 
-	Bread(fil,filelist,numfiles<<4);
+    Bread(fil,filelist,numfiles<<4);
 
-	j = 0;
-	for(i=0;i<numfiles;i++)
-	{
-		k = *((int*)&filelist[i][12]); k = B_LITTLE32(k);
-		filelist[i][12] = 0;
-		fileoffs[i] = j;
-		j += k;
-	}
-	fileoffs[numfiles] = j;
+    j = 0;
+    for(i=0;i<numfiles;i++)
+    {
+        k = *((int*)&filelist[i][12]); k = B_LITTLE32(k);
+        filelist[i][12] = 0;
+        fileoffs[i] = j;
+        j += k;
+    }
+    fileoffs[numfiles] = j;
 
     if (onlylist)
     {
@@ -89,72 +89,72 @@ int main(int argc, char **argv)
         return 0;
     }
 
-	for(i=0;i<numfiles;i++) marked4extraction[i] = 0;
+    for(i=0;i<numfiles;i++) marked4extraction[i] = 0;
 
-	anyfiles4extraction = 0;
-	for(i=argc-1;i>1;i--)
-	{
-		if (argv[i][0] == '@')
-		{
-			if ((fil2 = Bopen(&argv[i][1],BO_BINARY|BO_RDONLY,BS_IREAD)) != -1)
-			{
-				l = Bread(fil2,buf,65536);
-				j = 0;
-				while ((j < l) && (buf[j] <= 32)) j++;
-				while (j < l)
-				{
-					k = j;
-					while ((k < l) && (buf[k] > 32)) k++;
+    anyfiles4extraction = 0;
+    for(i=argc-1;i>1;i--)
+    {
+        if (argv[i][0] == '@')
+        {
+            if ((fil2 = Bopen(&argv[i][1],BO_BINARY|BO_RDONLY,BS_IREAD)) != -1)
+            {
+                l = Bread(fil2,buf,65536);
+                j = 0;
+                while ((j < l) && (buf[j] <= 32)) j++;
+                while (j < l)
+                {
+                    k = j;
+                    while ((k < l) && (buf[k] > 32)) k++;
 
-					buf[k] = 0;
-					findfiles(&buf[j]);
-					j = k+1;
+                    buf[k] = 0;
+                    findfiles(&buf[j]);
+                    j = k+1;
 
-					while ((j < l) && (buf[j] <= 32)) j++;
-				}
-				Bclose(fil2);
-			}
-		}
-		else
-			findfiles(argv[i]);
-	}
+                    while ((j < l) && (buf[j] <= 32)) j++;
+                }
+                Bclose(fil2);
+            }
+        }
+        else
+            findfiles(argv[i]);
+    }
 
-	if (anyfiles4extraction == 0)
-	{
-		Bclose(fil);
-		printf("No files found in group file with those names\n");
-		return(0);
-	}
+    if (anyfiles4extraction == 0)
+    {
+        Bclose(fil);
+        printf("No files found in group file with those names\n");
+        return(0);
+    }
 
-	for(i=0;i<numfiles;i++)
-	{
-		if (marked4extraction[i] == 0) continue;
+    for(i=0;i<numfiles;i++)
+    {
+        if (marked4extraction[i] == 0) continue;
 
-		fileleng[i] = fileoffs[i+1]-fileoffs[i];
+        fileleng[i] = fileoffs[i+1]-fileoffs[i];
 
-		if ((fil2 = Bopen(filelist[i],BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
-		{
-			printf("Error: Could not write to %s\n",filelist[i]);
-			continue;
-		}
-		printf("Extracting %s...\n",filelist[i]);
-		Blseek(fil,fileoffs[i]+((numfiles+1)<<4),SEEK_SET);
-		for(j=0;j<fileleng[i];j+=65536)
-		{
-			k = min(fileleng[i]-j,65536);
-			Bread(fil,buf,k);
-			if (Bwrite(fil2,buf,k) < k)
-			{
-				printf("Write error (drive full?)\n");
-				Bclose(fil2);
-				Bclose(fil);
-				return(0);
-			}
-		}
-		Bclose(fil2);
-	}
-	Bclose(fil);
+        if ((fil2 = Bopen(filelist[i],BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
+        {
+            printf("Error: Could not write to %s\n",filelist[i]);
+            continue;
+        }
+        printf("Extracting %s...\n",filelist[i]);
+        Blseek(fil,fileoffs[i]+((numfiles+1)<<4),SEEK_SET);
+        for(j=0;j<fileleng[i];j+=65536)
+        {
+            k = min(fileleng[i]-j,65536);
+            Bread(fil,buf,k);
+            if (Bwrite(fil2,buf,k) < k)
+            {
+                printf("Write error (drive full?)\n");
+                Bclose(fil2);
+                Bclose(fil);
+                return(0);
+            }
+        }
+        Bclose(fil2);
+    }
+    Bclose(fil);
 
-	return 0;
+    return 0;
 }
 
diff --git a/polymer/eduke32/build/src/util/kgroup.c b/polymer/eduke32/build/src/util/kgroup.c
index 12942475e..0847b1f08 100644
--- a/polymer/eduke32/build/src/util/kgroup.c
+++ b/polymer/eduke32/build/src/util/kgroup.c
@@ -13,7 +13,7 @@ static void jstrupr(char *s) { while (*s) { *s = Btoupper(*s); s++; } }
 
 #define MAXFILES 4096
 
-static char buf[65536];		// These limits should be abolished one day
+static char buf[65536];        // These limits should be abolished one day
 
 static int numfiles;
 static char filespec[MAXFILES][128], filelist[MAXFILES][16];
@@ -23,149 +23,149 @@ static int fileleng[MAXFILES];
 static char *matchstr = "*.*";
 int checkmatch(const struct Bdirent *a)
 {
-	if (a->mode & BS_IFDIR) return 0;	// is a directory
-	if (a->namlen > 12) return 0;	// name too long
-	return Bwildmatch(a->name, matchstr);
+    if (a->mode & BS_IFDIR) return 0;    // is a directory
+    if (a->namlen > 12) return 0;    // name too long
+    return Bwildmatch(a->name, matchstr);
 }
 
 int filesize(const char *path, const char *name)
 {
-	char p[BMAX_PATH];
-	struct stat st;
+    char p[BMAX_PATH];
+    struct stat st;
 
-	strcpy(p, path);
-	strcat(p, "/");
-	strcat(p, name);
+    strcpy(p, path);
+    strcat(p, "/");
+    strcat(p, name);
 
-	if (!stat(p, &st)) return st.st_size;
-	return 0;
+    if (!stat(p, &st)) return st.st_size;
+    return 0;
 }
 
 void findfiles(const char *dafilespec)
 {
-	struct Bdirent *name;
-	int daspeclen;
-	char daspec[128], *dir;
-	BDIR *di;
+    struct Bdirent *name;
+    int daspeclen;
+    char daspec[128], *dir;
+    BDIR *di;
 
-	strcpy(daspec,dafilespec);
-	daspeclen=strlen(daspec);
-	while ((daspec[daspeclen] != '\\') && (daspec[daspeclen] != '/') && (daspeclen > 0)) daspeclen--;
-	if (daspeclen > 0) {
-		daspec[daspeclen]=0;
-		dir = daspec;
-		matchstr = &daspec[daspeclen+1];
-	} else {
-		dir = ".";
-		matchstr = daspec;
-	}
+    strcpy(daspec,dafilespec);
+    daspeclen=strlen(daspec);
+    while ((daspec[daspeclen] != '\\') && (daspec[daspeclen] != '/') && (daspeclen > 0)) daspeclen--;
+    if (daspeclen > 0) {
+        daspec[daspeclen]=0;
+        dir = daspec;
+        matchstr = &daspec[daspeclen+1];
+    } else {
+        dir = ".";
+        matchstr = daspec;
+    }
 
-	di = Bopendir(dir);
-	if (!di) return;
+    di = Bopendir(dir);
+    if (!di) return;
 
-	while ((name = Breaddir(di))) {
-		if (!checkmatch(name)) continue;
+    while ((name = Breaddir(di))) {
+        if (!checkmatch(name)) continue;
 
-		strcpy(&filelist[numfiles][0],name->name);
-		jstrupr(&filelist[numfiles][0]);
-		fileleng[numfiles] = name->size;
-		filelist[numfiles][12] = (char)(fileleng[numfiles]&255);
-		filelist[numfiles][13] = (char)((fileleng[numfiles]>>8)&255);
-		filelist[numfiles][14] = (char)((fileleng[numfiles]>>16)&255);
-		filelist[numfiles][15] = (char)((fileleng[numfiles]>>24)&255);
+        strcpy(&filelist[numfiles][0],name->name);
+        jstrupr(&filelist[numfiles][0]);
+        fileleng[numfiles] = name->size;
+        filelist[numfiles][12] = (char)(fileleng[numfiles]&255);
+        filelist[numfiles][13] = (char)((fileleng[numfiles]>>8)&255);
+        filelist[numfiles][14] = (char)((fileleng[numfiles]>>16)&255);
+        filelist[numfiles][15] = (char)((fileleng[numfiles]>>24)&255);
 
-		strcpy(filespec[numfiles],dir);
-		strcat(filespec[numfiles], "/");
-		strcat(filespec[numfiles],name->name);
+        strcpy(filespec[numfiles],dir);
+        strcat(filespec[numfiles], "/");
+        strcat(filespec[numfiles],name->name);
 
-		numfiles++;
-		if (numfiles > MAXFILES)
-		{
-			printf("FATAL ERROR: TOO MANY FILES SELECTED! (MAX is 4096)\n");
-			exit(0);
-		}
-	}
+        numfiles++;
+        if (numfiles > MAXFILES)
+        {
+            printf("FATAL ERROR: TOO MANY FILES SELECTED! (MAX is 4096)\n");
+            exit(0);
+        }
+    }
 
-	Bclosedir(di);
+    Bclosedir(di);
 }
 
 int main(int argc, char **argv)
 {
-	int i, j, k, l, fil, fil2;
+    int i, j, k, l, fil, fil2;
 
-	if (argc < 3)
-	{
-		printf("KGROUP [grouped file][@file or filespec...]           by Kenneth Silverman\n");
-		printf("   This program collects many files into 1 big uncompressed file called a\n");
-		printf("   group file\n");
-		printf("   Ex: kgroup stuff.dat *.art *.map *.k?? palette.dat tables.dat\n");
-		printf("      (stuff.dat is the group file, the rest are the files to add)\n");
-		exit(0);
-	}
+    if (argc < 3)
+    {
+        printf("KGROUP [grouped file][@file or filespec...]           by Kenneth Silverman\n");
+        printf("   This program collects many files into 1 big uncompressed file called a\n");
+        printf("   group file\n");
+        printf("   Ex: kgroup stuff.dat *.art *.map *.k?? palette.dat tables.dat\n");
+        printf("      (stuff.dat is the group file, the rest are the files to add)\n");
+        exit(0);
+    }
 
-	numfiles = 0;
-	for(i=argc-1;i>1;i--)
-	{
-		if (argv[i][0] == '@')
-		{
-			if ((fil = Bopen(&argv[i][1],BO_BINARY|BO_RDONLY,BS_IREAD)) != -1)
-			{
-				l = Bread(fil,buf,65536);
-				j = 0;
-				while ((j < l) && (buf[j] <= 32)) j++;
-				while (j < l)
-				{
-					k = j;
-					while ((k < l) && (buf[k] > 32)) k++;
+    numfiles = 0;
+    for(i=argc-1;i>1;i--)
+    {
+        if (argv[i][0] == '@')
+        {
+            if ((fil = Bopen(&argv[i][1],BO_BINARY|BO_RDONLY,BS_IREAD)) != -1)
+            {
+                l = Bread(fil,buf,65536);
+                j = 0;
+                while ((j < l) && (buf[j] <= 32)) j++;
+                while (j < l)
+                {
+                    k = j;
+                    while ((k < l) && (buf[k] > 32)) k++;
 
-					buf[k] = 0;
-					findfiles(&buf[j]);
-					j = k+1;
+                    buf[k] = 0;
+                    findfiles(&buf[j]);
+                    j = k+1;
 
-					while ((j < l) && (buf[j] <= 32)) j++;
-				}
-				Bclose(fil);
-			}
-		}
-		else
-			findfiles(argv[i]);
-	}
+                    while ((j < l) && (buf[j] <= 32)) j++;
+                }
+                Bclose(fil);
+            }
+        }
+        else
+            findfiles(argv[i]);
+    }
 
-	if ((fil = Bopen(argv[1],BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
-	{
-		printf("Error: %s could not be opened\n",argv[1]);
-		exit(0);
-	}
-	Bwrite(fil,"KenSilverman",12);
-	Bwrite(fil,&numfiles,4);
-	Bwrite(fil,filelist,numfiles<<4);
+    if ((fil = Bopen(argv[1],BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
+    {
+        printf("Error: %s could not be opened\n",argv[1]);
+        exit(0);
+    }
+    Bwrite(fil,"KenSilverman",12);
+    Bwrite(fil,&numfiles,4);
+    Bwrite(fil,filelist,numfiles<<4);
 
-	for(i=0;i<numfiles;i++)
-	{
-		printf("Adding %s...\n",filespec[i]);
-		if ((fil2 = Bopen(filespec[i],BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
-		{
-			printf("Error: %s not found\n",filespec[i]);
-			Bclose(fil);
-			return(0);
-		}
-		for(j=0;j<fileleng[i];j+=65536)
-		{
-			k = min(fileleng[i]-j,65536);
-			Bread(fil2,buf,k);
-			if (Bwrite(fil,buf,k) < k)
-			{
-				Bclose(fil2);
-				Bclose(fil);
-				printf("OUT OF HD SPACE!\n");
-				return(0);
-			}
-		}
-		Bclose(fil2);
-	}
-	Bclose(fil);
-	printf("Saved to %s.\n",argv[1]);
+    for(i=0;i<numfiles;i++)
+    {
+        printf("Adding %s...\n",filespec[i]);
+        if ((fil2 = Bopen(filespec[i],BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
+        {
+            printf("Error: %s not found\n",filespec[i]);
+            Bclose(fil);
+            return(0);
+        }
+        for(j=0;j<fileleng[i];j+=65536)
+        {
+            k = min(fileleng[i]-j,65536);
+            Bread(fil2,buf,k);
+            if (Bwrite(fil,buf,k) < k)
+            {
+                Bclose(fil2);
+                Bclose(fil);
+                printf("OUT OF HD SPACE!\n");
+                return(0);
+            }
+        }
+        Bclose(fil2);
+    }
+    Bclose(fil);
+    printf("Saved to %s.\n",argv[1]);
 
-	return 0;
+    return 0;
 }
 
diff --git a/polymer/eduke32/build/src/util/kmd2tool.c b/polymer/eduke32/build/src/util/kmd2tool.c
index b0fee95a6..9568e11dd 100644
--- a/polymer/eduke32/build/src/util/kmd2tool.c
+++ b/polymer/eduke32/build/src/util/kmd2tool.c
@@ -1,6 +1,6 @@
 #if 0
 kmd2tool.exe: kmd2tool.c; cl kmd2tool.c /Ox /G6fy /MD /link /opt:nowin98
-	del kmd2tool.obj
+    del kmd2tool.obj
 !if 0
 #endif
 
@@ -12,45 +12,45 @@ typedef struct { float x, y, z; } point3d;
 
 typedef struct
 {  int id, vers, skinxsiz, skinysiz, framebytes; //id:"IPD2", vers:8
-	int numskins, numverts, numuv, numtris, numglcmds, numframes;
-	int ofsskins, ofsuv, ofstris, ofsframes, ofsglcmds, ofseof; //ofsskins: skin names (64 bytes each)
+    int numskins, numverts, numuv, numtris, numglcmds, numframes;
+    int ofsskins, ofsuv, ofstris, ofsframes, ofsglcmds, ofseof; //ofsskins: skin names (64 bytes each)
 } md2typ;
 
 typedef struct { point3d mul, add; } frametyp;
 
 int main (int argc, char **argv)
 {
-	FILE *fil;
-	int i, leng;
-	char *fbuf;
-	md2typ *head;
-	frametyp *fptr;
+    FILE *fil;
+    int i, leng;
+    char *fbuf;
+    md2typ *head;
+    frametyp *fptr;
 
-	if (argc != 4) { puts("KMD2TOOL [MD2 in file] [MD2 out file] [z offset]                    by Ken Silverman"); return(0); }
-	if (!stricmp(argv[1],argv[2])) { puts("input&output filenames can't be same"); return(0); }
+    if (argc != 4) { puts("KMD2TOOL [MD2 in file] [MD2 out file] [z offset]                    by Ken Silverman"); return(0); }
+    if (!stricmp(argv[1],argv[2])) { puts("input&output filenames can't be same"); return(0); }
 
-	fil = fopen(argv[1],"rb"); if (!fil) { puts("error"); return(0); }
-	leng = filelength(_fileno(fil));
-	fbuf = (char *)malloc(leng); if (!fbuf) { puts("error"); return(0); }
-	fread(fbuf,leng,1,fil);
-	fclose(fil);
+    fil = fopen(argv[1],"rb"); if (!fil) { puts("error"); return(0); }
+    leng = filelength(_fileno(fil));
+    fbuf = (char *)malloc(leng); if (!fbuf) { puts("error"); return(0); }
+    fread(fbuf,leng,1,fil);
+    fclose(fil);
 
-	head = (md2typ *)fbuf;
-	if ((head->id != 0x32504449) && (head->vers != 8)) { free(fbuf); puts("error"); return(0); } //"IDP2"
-	for(i=0;i<head->numframes;i++)
-	{
-		fptr = (frametyp *)&fbuf[head->ofsframes+head->framebytes*i];
-		printf("frame %2d scale:%f,%f,%f offs:%f,%f,%f\n",i,fptr->mul.x,fptr->mul.y,fptr->mul.z,fptr->add.x,fptr->add.y,fptr->add.z);
-		fptr->add.z += atof(argv[3]);
-	}
+    head = (md2typ *)fbuf;
+    if ((head->id != 0x32504449) && (head->vers != 8)) { free(fbuf); puts("error"); return(0); } //"IDP2"
+    for(i=0;i<head->numframes;i++)
+    {
+        fptr = (frametyp *)&fbuf[head->ofsframes+head->framebytes*i];
+        printf("frame %2d scale:%f,%f,%f offs:%f,%f,%f\n",i,fptr->mul.x,fptr->mul.y,fptr->mul.z,fptr->add.x,fptr->add.y,fptr->add.z);
+        fptr->add.z += atof(argv[3]);
+    }
 
-	fil = fopen(argv[2],"wb"); if (!fil) { puts("error"); return(0); }
-	fwrite(fbuf,leng,1,fil);
-	fclose(fil);
+    fil = fopen(argv[2],"wb"); if (!fil) { puts("error"); return(0); }
+    fwrite(fbuf,leng,1,fil);
+    fclose(fil);
 
-	free(fbuf);
+    free(fbuf);
 
-	return(0);
+    return(0);
 }
 
 #if 0
diff --git a/polymer/eduke32/build/src/util/md2tool.c b/polymer/eduke32/build/src/util/md2tool.c
index 31ee05cd2..d9bf2b6e6 100644
--- a/polymer/eduke32/build/src/util/md2tool.c
+++ b/polymer/eduke32/build/src/util/md2tool.c
@@ -135,7 +135,7 @@ int main(int argc, char **argv)
     uint8_t maxv[3]={0,0,0};
     uint8_t minv[3]={255,255,255};
 
-    md2frame_t *fr;        
+    md2frame_t *fr;
     uint8_t *vp;
 
     md2model_t *m;
diff --git a/polymer/eduke32/build/src/util/transpal.c b/polymer/eduke32/build/src/util/transpal.c
index 23ffdf06b..a2d7fa91f 100644
--- a/polymer/eduke32/build/src/util/transpal.c
+++ b/polymer/eduke32/build/src/util/transpal.c
@@ -27,244 +27,244 @@ static int colscan[27];
 
 char getclosestcol(int r, int g, int b)
 {
-	int i, j, k, dist, mindist, retcol;
-	int *rlookup, *glookup, *blookup;
-	char *ptr;
+    int i, j, k, dist, mindist, retcol;
+    int *rlookup, *glookup, *blookup;
+    char *ptr;
 
-	if (closestcol[r][g][b] != 255) return(closestcol[r][g][b]);
+    if (closestcol[r][g][b] != 255) return(closestcol[r][g][b]);
 
-	j = (r>>3)*FASTPALGRIDSIZ*FASTPALGRIDSIZ+(g>>3)*FASTPALGRIDSIZ+(b>>3)+FASTPALGRIDSIZ*FASTPALGRIDSIZ+FASTPALGRIDSIZ+1;
-	mindist = min(rdist[coldist[r&7]+64+8],gdist[coldist[g&7]+64+8]);
-	mindist = min(mindist,bdist[coldist[b&7]+64+8]);
-	mindist++;
+    j = (r>>3)*FASTPALGRIDSIZ*FASTPALGRIDSIZ+(g>>3)*FASTPALGRIDSIZ+(b>>3)+FASTPALGRIDSIZ*FASTPALGRIDSIZ+FASTPALGRIDSIZ+1;
+    mindist = min(rdist[coldist[r&7]+64+8],gdist[coldist[g&7]+64+8]);
+    mindist = min(mindist,bdist[coldist[b&7]+64+8]);
+    mindist++;
 
-	rlookup = (int *)&rdist[64-r];
-	glookup = (int *)&gdist[64-g];
-	blookup = (int *)&bdist[64-b];
+    rlookup = (int *)&rdist[64-r];
+    glookup = (int *)&gdist[64-g];
+    blookup = (int *)&bdist[64-b];
 
-	retcol = -1;
-	for(k=26;k>=0;k--)
-	{
-		i = colscan[k]+j; if ((colhere[i>>3]&(1<<(i&7))) == 0) continue;
-		for(i=colhead[i];i>=0;i=colnext[i])
-		{
-			ptr = (char *)&palette[i*3];
-			dist = glookup[ptr[1]]; if (dist >= mindist) continue;
-			dist += rlookup[ptr[0]]; if (dist >= mindist) continue;
-			dist += blookup[ptr[2]]; if (dist >= mindist) continue;
-			mindist = dist; retcol = i;
-		}
-	}
-	if (retcol < 0)
-	{
-		mindist = 0x7fffffff;
-		ptr = (char *)&palette[768-3];
-		for(i=255;i>=0;i--,ptr-=3)
-		{
-			dist = glookup[ptr[1]]; if (dist >= mindist) continue;
-			dist += rlookup[ptr[0]]; if (dist >= mindist) continue;
-			dist += blookup[ptr[2]]; if (dist >= mindist) continue;
-			mindist = dist; retcol = i;
-		}
-	}
-	ptr = (char *)&closestcol[r][g][b];
-	*ptr = retcol;
-	if ((r >= 4) && (ptr[(-2)<<12] == retcol)) ptr[(-3)<<12] = retcol, ptr[(-2)<<12] = retcol, ptr[(-1)<<12] = retcol;
-	if ((g >= 4) && (ptr[(-2)<<6] == retcol)) ptr[(-3)<<6] = retcol, ptr[(-2)<<6] = retcol, ptr[(-1)<<6] = retcol;
-	if ((b >= 4) && (ptr[(-2)] == retcol)) ptr[(-3)] = retcol, ptr[(-2)] = retcol, ptr[(-1)] = retcol;
-	if ((r < 64-4) && (ptr[(2)<<12] == retcol)) ptr[(3)<<12] = retcol, ptr[(2)<<12] = retcol, ptr[(1)<<12] = retcol;
-	if ((g < 64-4) && (ptr[(2)<<6] == retcol)) ptr[(3)<<6] = retcol, ptr[(2)<<6] = retcol, ptr[(1)<<6] = retcol;
-	if ((b < 64-4) && (ptr[(2)] == retcol)) ptr[(3)] = retcol, ptr[(2)] = retcol, ptr[(1)] = retcol;
-	if ((r >= 2) && (ptr[(-1)<<12] == retcol)) ptr[(-1)<<12] = retcol;
-	if ((g >= 2) && (ptr[(-1)<<6] == retcol)) ptr[(-1)<<6] = retcol;
-	if ((b >= 2) && (ptr[(-1)] == retcol)) ptr[(-1)] = retcol;
-	if ((r < 64-2) && (ptr[(1)<<12] == retcol)) ptr[(1)<<12] = retcol;
-	if ((g < 64-2) && (ptr[(1)<<6] == retcol)) ptr[(1)<<6] = retcol;
-	if ((b < 64-2) && (ptr[(1)] == retcol)) ptr[(1)] = retcol;
-	return(retcol);
+    retcol = -1;
+    for(k=26;k>=0;k--)
+    {
+        i = colscan[k]+j; if ((colhere[i>>3]&(1<<(i&7))) == 0) continue;
+        for(i=colhead[i];i>=0;i=colnext[i])
+        {
+            ptr = (char *)&palette[i*3];
+            dist = glookup[ptr[1]]; if (dist >= mindist) continue;
+            dist += rlookup[ptr[0]]; if (dist >= mindist) continue;
+            dist += blookup[ptr[2]]; if (dist >= mindist) continue;
+            mindist = dist; retcol = i;
+        }
+    }
+    if (retcol < 0)
+    {
+        mindist = 0x7fffffff;
+        ptr = (char *)&palette[768-3];
+        for(i=255;i>=0;i--,ptr-=3)
+        {
+            dist = glookup[ptr[1]]; if (dist >= mindist) continue;
+            dist += rlookup[ptr[0]]; if (dist >= mindist) continue;
+            dist += blookup[ptr[2]]; if (dist >= mindist) continue;
+            mindist = dist; retcol = i;
+        }
+    }
+    ptr = (char *)&closestcol[r][g][b];
+    *ptr = retcol;
+    if ((r >= 4) && (ptr[(-2)<<12] == retcol)) ptr[(-3)<<12] = retcol, ptr[(-2)<<12] = retcol, ptr[(-1)<<12] = retcol;
+    if ((g >= 4) && (ptr[(-2)<<6] == retcol)) ptr[(-3)<<6] = retcol, ptr[(-2)<<6] = retcol, ptr[(-1)<<6] = retcol;
+    if ((b >= 4) && (ptr[(-2)] == retcol)) ptr[(-3)] = retcol, ptr[(-2)] = retcol, ptr[(-1)] = retcol;
+    if ((r < 64-4) && (ptr[(2)<<12] == retcol)) ptr[(3)<<12] = retcol, ptr[(2)<<12] = retcol, ptr[(1)<<12] = retcol;
+    if ((g < 64-4) && (ptr[(2)<<6] == retcol)) ptr[(3)<<6] = retcol, ptr[(2)<<6] = retcol, ptr[(1)<<6] = retcol;
+    if ((b < 64-4) && (ptr[(2)] == retcol)) ptr[(3)] = retcol, ptr[(2)] = retcol, ptr[(1)] = retcol;
+    if ((r >= 2) && (ptr[(-1)<<12] == retcol)) ptr[(-1)<<12] = retcol;
+    if ((g >= 2) && (ptr[(-1)<<6] == retcol)) ptr[(-1)<<6] = retcol;
+    if ((b >= 2) && (ptr[(-1)] == retcol)) ptr[(-1)] = retcol;
+    if ((r < 64-2) && (ptr[(1)<<12] == retcol)) ptr[(1)<<12] = retcol;
+    if ((g < 64-2) && (ptr[(1)<<6] == retcol)) ptr[(1)<<6] = retcol;
+    if ((b < 64-2) && (ptr[(1)] == retcol)) ptr[(1)] = retcol;
+    return(retcol);
 }
 
 char getpalookup(char dashade, char dacol)
 {
-	int r, g, b, t;
-	char *ptr;
+    int r, g, b, t;
+    char *ptr;
 
-	ptr = (char *)&palette[dacol*3];
-	t = divscale16(numpalookups-dashade,numpalookups);
-	r = ((ptr[0]*t+32768)>>16);
-	g = ((ptr[1]*t+32768)>>16);
-	b = ((ptr[2]*t+32768)>>16);
-	return(getclosestcol(r,g,b));
+    ptr = (char *)&palette[dacol*3];
+    t = divscale16(numpalookups-dashade,numpalookups);
+    r = ((ptr[0]*t+32768)>>16);
+    g = ((ptr[1]*t+32768)>>16);
+    b = ((ptr[2]*t+32768)>>16);
+    return(getclosestcol(r,g,b));
 }
 
 char gettrans(char dat1, char dat2, int datransratio)
 {
-	int r, g, b;
-	char *ptr, *ptr2;
+    int r, g, b;
+    char *ptr, *ptr2;
 
-	ptr = (char *)&palette[dat1*3];
-	ptr2 = (char *)&palette[dat2*3];
-	r = ptr[0]; r += (((ptr2[0]-r)*datransratio+128)>>8);
-	g = ptr[1]; g += (((ptr2[1]-g)*datransratio+128)>>8);
-	b = ptr[2]; b += (((ptr2[2]-b)*datransratio+128)>>8);
-	return(getclosestcol(r,g,b));
+    ptr = (char *)&palette[dat1*3];
+    ptr2 = (char *)&palette[dat2*3];
+    r = ptr[0]; r += (((ptr2[0]-r)*datransratio+128)>>8);
+    g = ptr[1]; g += (((ptr2[1]-g)*datransratio+128)>>8);
+    b = ptr[2]; b += (((ptr2[2]-b)*datransratio+128)>>8);
+    return(getclosestcol(r,g,b));
 }
 
 void initfastcolorlookup(int rscale, int gscale, int bscale)
 {
-	int i, j, x, y, z;
-	char *ptr;
+    int i, j, x, y, z;
+    char *ptr;
 
-	j = 0;
-	for(i=64;i>=0;i--)
-	{
-		//j = (i-64)*(i-64);
-		rdist[i] = rdist[128-i] = j*rscale;
-		gdist[i] = gdist[128-i] = j*gscale;
-		bdist[i] = bdist[128-i] = j*bscale;
-		j += 129-(i<<1);
-	}
+    j = 0;
+    for(i=64;i>=0;i--)
+    {
+        //j = (i-64)*(i-64);
+        rdist[i] = rdist[128-i] = j*rscale;
+        gdist[i] = gdist[128-i] = j*gscale;
+        bdist[i] = bdist[128-i] = j*bscale;
+        j += 129-(i<<1);
+    }
 
     Bmemset(colhere, 0, sizeof(colhere));
     Bmemset(colhead, 0, sizeof(colhead));
 
-	ptr = (char *)&palette[768-3];
-	for(i=255;i>=0;i--,ptr-=3)
-	{
-		j = (ptr[0]>>3)*FASTPALGRIDSIZ*FASTPALGRIDSIZ+(ptr[1]>>3)*FASTPALGRIDSIZ+(ptr[2]>>3)+FASTPALGRIDSIZ*FASTPALGRIDSIZ+FASTPALGRIDSIZ+1;
-		if (colhere[j>>3]&(1<<(j&7))) colnext[i] = colhead[j]; else colnext[i] = -1;
-		colhead[j] = i;
-		colhere[j>>3] |= (1<<(j&7));
-	}
+    ptr = (char *)&palette[768-3];
+    for(i=255;i>=0;i--,ptr-=3)
+    {
+        j = (ptr[0]>>3)*FASTPALGRIDSIZ*FASTPALGRIDSIZ+(ptr[1]>>3)*FASTPALGRIDSIZ+(ptr[2]>>3)+FASTPALGRIDSIZ*FASTPALGRIDSIZ+FASTPALGRIDSIZ+1;
+        if (colhere[j>>3]&(1<<(j&7))) colnext[i] = colhead[j]; else colnext[i] = -1;
+        colhead[j] = i;
+        colhere[j>>3] |= (1<<(j&7));
+    }
 
-	i = 0;
-	for(x=-FASTPALGRIDSIZ*FASTPALGRIDSIZ;x<=FASTPALGRIDSIZ*FASTPALGRIDSIZ;x+=FASTPALGRIDSIZ*FASTPALGRIDSIZ)
-		for(y=-FASTPALGRIDSIZ;y<=FASTPALGRIDSIZ;y+=FASTPALGRIDSIZ)
-			for(z=-1;z<=1;z++)
-				colscan[i++] = x+y+z;
-	i = colscan[13]; colscan[13] = colscan[26]; colscan[26] = i;
+    i = 0;
+    for(x=-FASTPALGRIDSIZ*FASTPALGRIDSIZ;x<=FASTPALGRIDSIZ*FASTPALGRIDSIZ;x+=FASTPALGRIDSIZ*FASTPALGRIDSIZ)
+        for(y=-FASTPALGRIDSIZ;y<=FASTPALGRIDSIZ;y+=FASTPALGRIDSIZ)
+            for(z=-1;z<=1;z++)
+                colscan[i++] = x+y+z;
+    i = colscan[13]; colscan[13] = colscan[26]; colscan[26] = i;
 }
 
 int main(int argc, char **argv)
 {
-	char col, ch;
-	short orignumpalookups;
-	int fil, i, j, rscale, gscale, bscale;
-	char buf[65536];
+    char col, ch;
+    short orignumpalookups;
+    int fil, i, j, rscale, gscale, bscale;
+    char buf[65536];
 
-	ch = 13;
-	if (argc>1) {
-		if (argv[1][0] == '-') {
-			if (argv[1][1] == 't') { ch = 32; puts("Updating translucency table ONLY"); }
-			argc--;
-			argv++;
-		}
-	}
+    ch = 13;
+    if (argc>1) {
+        if (argv[1][0] == '-') {
+            if (argv[1][1] == 't') { ch = 32; puts("Updating translucency table ONLY"); }
+            argc--;
+            argv++;
+        }
+    }
 
-	if ((argc != 3) && (argc != 6))
-	{
-		printf("TRANSPAL [-t] [numshades][trans#(0-inv,256-opa)][r][g][b]     by Kenneth Silverman\n");
-		printf("   Ex #1: transpal 32 170 30 59 11      (I use these values in my BUILD demo)\n");
-		printf("                          ÀÄÄÁÄÄÁÄÄÄ The RGB scales are optional\n");
-		printf("   Ex #2: transpal 64 160\n\n");
-		printf("Once tables are generated, the optional -t switch determines what to save:\n");
-		printf("   Exclude -t to update both the shade table and transluscent table\n");
-		printf("   Include -t to update the transluscent table ONLY\n");
-		exit(0);
-	}
+    if ((argc != 3) && (argc != 6))
+    {
+        printf("TRANSPAL [-t] [numshades][trans#(0-inv,256-opa)][r][g][b]     by Kenneth Silverman\n");
+        printf("   Ex #1: transpal 32 170 30 59 11      (I use these values in my BUILD demo)\n");
+        printf("                          ÀÄÄÁÄÄÁÄÄÄ The RGB scales are optional\n");
+        printf("   Ex #2: transpal 64 160\n\n");
+        printf("Once tables are generated, the optional -t switch determines what to save:\n");
+        printf("   Exclude -t to update both the shade table and transluscent table\n");
+        printf("   Include -t to update the transluscent table ONLY\n");
+        exit(0);
+    }
 
-	strcpy(palettefilename,"palette.dat");
-	numpalookups = atol(argv[1]);
-	transratio = atol(argv[2]);
+    strcpy(palettefilename,"palette.dat");
+    numpalookups = atol(argv[1]);
+    transratio = atol(argv[2]);
 
-	if (argc == 6)
-	{
-		rscale = atol(argv[3]);
-		gscale = atol(argv[4]);
-		bscale = atol(argv[5]);
-	}
-	else
-	{
-		rscale = 30;
-		gscale = 59;
-		bscale = 11;
-	}
+    if (argc == 6)
+    {
+        rscale = atol(argv[3]);
+        gscale = atol(argv[4]);
+        bscale = atol(argv[5]);
+    }
+    else
+    {
+        rscale = 30;
+        gscale = 59;
+        bscale = 11;
+    }
 
-	if ((numpalookups < 1) || (numpalookups > 256))
-		{ printf("Invalid number of shades\n"); exit(0); }
-	if ((transratio < 0) || (transratio > 256))
-		{ printf("Invalid transluscent ratio\n"); exit(0); }
+    if ((numpalookups < 1) || (numpalookups > 256))
+        { printf("Invalid number of shades\n"); exit(0); }
+    if ((transratio < 0) || (transratio > 256))
+        { printf("Invalid transluscent ratio\n"); exit(0); }
 
-	if ((fil = Bopen(palettefilename,BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
-	{
-		printf("%s not found",palettefilename);
-		return(0);
-	}
-	Bread(fil,palette,768);
-	Bread(fil,&orignumpalookups,2); orignumpalookups = B_LITTLE16(orignumpalookups);
-	orignumpalookups = min(max(orignumpalookups,1),256);
-	Bread(fil,origpalookup,(int)orignumpalookups<<8);
-	Bclose(fil);
+    if ((fil = Bopen(palettefilename,BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
+    {
+        printf("%s not found",palettefilename);
+        return(0);
+    }
+    Bread(fil,palette,768);
+    Bread(fil,&orignumpalookups,2); orignumpalookups = B_LITTLE16(orignumpalookups);
+    orignumpalookups = min(max(orignumpalookups,1),256);
+    Bread(fil,origpalookup,(int)orignumpalookups<<8);
+    Bclose(fil);
 
-	clearbuf(buf,65536>>2,0L);
+    clearbuf(buf,65536>>2,0L);
 
-	initfastcolorlookup(rscale,gscale,bscale);
-	clearbuf(closestcol,262144>>2,0xffffffff);
+    initfastcolorlookup(rscale,gscale,bscale);
+    clearbuf(closestcol,262144>>2,0xffffffff);
 
-	for(i=0;i<numpalookups;i++)
-		for(j=0;j<256;j++)
-		{
-			col = getpalookup((char)i,(char)j);
-			palookup[(i<<8)+j] = col;
+    for(i=0;i<numpalookups;i++)
+        for(j=0;j<256;j++)
+        {
+            col = getpalookup((char)i,(char)j);
+            palookup[(i<<8)+j] = col;
 
-			drawpixel(((((i<<1)+0)*320+(j+8))>>2)+buf,(int)col);
-			drawpixel(((((i<<1)+1)*320+(j+8))>>2)+buf,(int)col);
-		}
+            drawpixel(((((i<<1)+0)*320+(j+8))>>2)+buf,(int)col);
+            drawpixel(((((i<<1)+1)*320+(j+8))>>2)+buf,(int)col);
+        }
 
-	for(i=0;i<256;i++)
-		for(j=0;j<6;j++)
-		{
-			drawpixel((((j+132+0)*320+(i+8))>>2)+buf,i);
+    for(i=0;i<256;i++)
+        for(j=0;j<6;j++)
+        {
+            drawpixel((((j+132+0)*320+(i+8))>>2)+buf,i);
 
-			drawpixel((((i+132+8)*320+(j+0))>>2)+buf,i);
-		}
+            drawpixel((((i+132+8)*320+(j+0))>>2)+buf,i);
+        }
 
-	for(i=0;i<256;i++)
-		for(j=0;j<256;j++)
-		{
-			col = gettrans((char)i,(char)j,transratio);
-			transluc[(i<<8)+j] = col;
+    for(i=0;i<256;i++)
+        for(j=0;j<256;j++)
+        {
+            col = gettrans((char)i,(char)j,transratio);
+            transluc[(i<<8)+j] = col;
 
-			drawpixel((((j+132+8)*320+(i+8))>>2)+buf,(int)col);
-		}
+            drawpixel((((j+132+8)*320+(i+8))>>2)+buf,(int)col);
+        }
 
-	if (ch == 13)
-	{
-		short s;
-		if ((fil = Bopen(palettefilename,BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
-			{ printf("Couldn't save file %s",palettefilename); return(0); }
-		Bwrite(fil,palette,768);
-		s = B_LITTLE16(numpalookups); Bwrite(fil,&s,2);
-		Bwrite(fil,palookup,numpalookups<<8);
-		Bwrite(fil,transluc,65536);
-		Bclose(fil);
-		printf("Shade table AND transluscent table updated\n");
-	}
-	else if (ch == 32)
-	{
-		short s;
-		if ((fil = Bopen(palettefilename,BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
-			{ printf("Couldn't save file %s",palettefilename); return(0); }
-		Bwrite(fil,palette,768);
-		s = B_LITTLE16(orignumpalookups); Bwrite(fil,&s,2);
-		Bwrite(fil,origpalookup,(int)orignumpalookups<<8);
-		Bwrite(fil,transluc,65536);
-		Bclose(fil);
-		printf("Transluscent table updated\n");
-	}
-	else
-		printf("Palette file wasn't touched\n");
+    if (ch == 13)
+    {
+        short s;
+        if ((fil = Bopen(palettefilename,BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
+            { printf("Couldn't save file %s",palettefilename); return(0); }
+        Bwrite(fil,palette,768);
+        s = B_LITTLE16(numpalookups); Bwrite(fil,&s,2);
+        Bwrite(fil,palookup,numpalookups<<8);
+        Bwrite(fil,transluc,65536);
+        Bclose(fil);
+        printf("Shade table AND transluscent table updated\n");
+    }
+    else if (ch == 32)
+    {
+        short s;
+        if ((fil = Bopen(palettefilename,BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
+            { printf("Couldn't save file %s",palettefilename); return(0); }
+        Bwrite(fil,palette,768);
+        s = B_LITTLE16(orignumpalookups); Bwrite(fil,&s,2);
+        Bwrite(fil,origpalookup,(int)orignumpalookups<<8);
+        Bwrite(fil,transluc,65536);
+        Bclose(fil);
+        printf("Transluscent table updated\n");
+    }
+    else
+        printf("Palette file wasn't touched\n");
 
-	return 0;
+    return 0;
 }
 
diff --git a/polymer/eduke32/build/src/util/vgafont.cpp b/polymer/eduke32/build/src/util/vgafont.cpp
index a674f9ac7..ccca01c51 100644
--- a/polymer/eduke32/build/src/util/vgafont.cpp
+++ b/polymer/eduke32/build/src/util/vgafont.cpp
@@ -8,133 +8,133 @@
 
 int main(void)
 {
-	int font, width, height, numchars;
-	struct REGPACK r;
-	FILE *fp;
+    int font, width, height, numchars;
+    struct REGPACK r;
+    FILE *fp;
 
-	printf("VGA Font Grabber\n"
-		   "Copyright (c) 1997 Jonathon Fowler\n");
+    printf("VGA Font Grabber\n"
+           "Copyright (c) 1997 Jonathon Fowler\n");
 
-	do {
-		printf("\nSelect which font to grab:\n"
-			   "  1.   8-by-8 ROM\n"
-			   "  2.   8-by-14 ROM\n"
-			   "  3.   8-by-16 ROM\n"
-			   "  4.   9-by-16 ROM\n"
-			   "  5.   9-by-14 ROM\n"
-			   "  6.   Quit\n"
-			   " > ");
-		scanf("%d",&font);
+    do {
+        printf("\nSelect which font to grab:\n"
+               "  1.   8-by-8 ROM\n"
+               "  2.   8-by-14 ROM\n"
+               "  3.   8-by-16 ROM\n"
+               "  4.   9-by-16 ROM\n"
+               "  5.   9-by-14 ROM\n"
+               "  6.   Quit\n"
+               " > ");
+        scanf("%d",&font);
 
-		switch (font) {
-			case 1:
-				printf("Getting 8-by-8 ROM font...");
+        switch (font) {
+            case 1:
+                printf("Getting 8-by-8 ROM font...");
 
-				if ((fp = fopen("88vga.dat", "wb")) != NULL) {
-					width = 8;
-					height = 8;
-					numchars = 256;
+                if ((fp = fopen("88vga.dat", "wb")) != NULL) {
+                    width = 8;
+                    height = 8;
+                    numchars = 256;
 
-					r.r_ax = 0x1130;	// locate the font (1st half)
-					r.r_bx = 0x0300;
-					intr(0x10, &r);
+                    r.r_ax = 0x1130;    // locate the font (1st half)
+                    r.r_bx = 0x0300;
+                    intr(0x10, &r);
 
-					fwrite(MK_FP(r.r_es, r.r_bp), 1, (8 * 128), fp);
+                    fwrite(MK_FP(r.r_es, r.r_bp), 1, (8 * 128), fp);
 
-					r.r_ax = 0x1130;	// locate the font (2nd half)
-					r.r_bx = 0x0400;
-					intr(0x10, &r);
+                    r.r_ax = 0x1130;    // locate the font (2nd half)
+                    r.r_bx = 0x0400;
+                    intr(0x10, &r);
 
-					fwrite(MK_FP(r.r_es, r.r_bp), 1, (8 * 128), fp);
+                    fwrite(MK_FP(r.r_es, r.r_bp), 1, (8 * 128), fp);
 
-					fclose(fp);
-				}
+                    fclose(fp);
+                }
 
-				printf("Done\n");
-				break;
-			case 2:
-				printf("Getting 8-by-14 ROM font...");
+                printf("Done\n");
+                break;
+            case 2:
+                printf("Getting 8-by-14 ROM font...");
 
-				if ((fp = fopen("814vga.dat", "wb")) != NULL) {
-					width = 8;
-					height = 14;
-					numchars = 256;
+                if ((fp = fopen("814vga.dat", "wb")) != NULL) {
+                    width = 8;
+                    height = 14;
+                    numchars = 256;
 
-					r.r_ax = 0x1130;	// locate the font
-					r.r_bx = 0x0200;
-					intr(0x10, &r);
+                    r.r_ax = 0x1130;    // locate the font
+                    r.r_bx = 0x0200;
+                    intr(0x10, &r);
 
-					fwrite(MK_FP(r.r_es, r.r_bp), 1, (14 * 256), fp);
+                    fwrite(MK_FP(r.r_es, r.r_bp), 1, (14 * 256), fp);
 
-					fclose(fp);
-				}
+                    fclose(fp);
+                }
 
-				printf("Done\n");
-				break;
-			case 3:
-				printf("Getting 8-by-16 ROM font...");
+                printf("Done\n");
+                break;
+            case 3:
+                printf("Getting 8-by-16 ROM font...");
 
-				if ((fp = fopen("816vga.dat", "wb")) != NULL) {
-					width = 8;
-					height = 16;
-					numchars = 256;
+                if ((fp = fopen("816vga.dat", "wb")) != NULL) {
+                    width = 8;
+                    height = 16;
+                    numchars = 256;
 
-					r.r_ax = 0x1130;	// locate the font
-					r.r_bx = 0x0600;
-					intr(0x10, &r);
+                    r.r_ax = 0x1130;    // locate the font
+                    r.r_bx = 0x0600;
+                    intr(0x10, &r);
 
-					fwrite(MK_FP(r.r_es, r.r_bp), 1, (16 * 256), fp);
+                    fwrite(MK_FP(r.r_es, r.r_bp), 1, (16 * 256), fp);
 
-					fclose(fp);
-				}
+                    fclose(fp);
+                }
 
-				printf("Done\n");
-				break;
-			case 4:
-				printf("Getting 9-by-16 ROM font...");
+                printf("Done\n");
+                break;
+            case 4:
+                printf("Getting 9-by-16 ROM font...");
 
-				if ((fp = fopen("916vga.dat", "wb")) != NULL) {
-					width = 9;
-					height = 16;
-					numchars = 256;
+                if ((fp = fopen("916vga.dat", "wb")) != NULL) {
+                    width = 9;
+                    height = 16;
+                    numchars = 256;
 
-					r.r_ax = 0x1130;	// locate the font
-					r.r_bx = 0x0700;
-					intr(0x10, &r);
+                    r.r_ax = 0x1130;    // locate the font
+                    r.r_bx = 0x0700;
+                    intr(0x10, &r);
 
-					fwrite(MK_FP(r.r_es, r.r_bp), 1, (16 * 256) *2, fp);
+                    fwrite(MK_FP(r.r_es, r.r_bp), 1, (16 * 256) *2, fp);
 
-					fclose(fp);
-				}
+                    fclose(fp);
+                }
 
-				printf("Done\n");
-				break;
-			case 5:
-				printf("Getting 9-by-14 ROM font...");
+                printf("Done\n");
+                break;
+            case 5:
+                printf("Getting 9-by-14 ROM font...");
 
-				if ((fp = fopen("914vga.dat", "wb")) != NULL) {
-					width = 9;
-					height = 16;
-					numchars = 256;
+                if ((fp = fopen("914vga.dat", "wb")) != NULL) {
+                    width = 9;
+                    height = 16;
+                    numchars = 256;
 
-					r.r_ax = 0x1130;	// locate the font
-					r.r_bx = 0x0500;
-					intr(0x10, &r);
+                    r.r_ax = 0x1130;    // locate the font
+                    r.r_bx = 0x0500;
+                    intr(0x10, &r);
 
-					fwrite(MK_FP(r.r_es, r.r_bp), 1, (14 * 256)* 2, fp);
+                    fwrite(MK_FP(r.r_es, r.r_bp), 1, (14 * 256)* 2, fp);
 
-					fclose(fp);
-				}
+                    fclose(fp);
+                }
 
-				printf("Done\n");
-				break;
-			case 6:
-				break;
-			default:
-				printf("Please try again\n");
-				break;
-		}
-	} while (font != 6);
+                printf("Done\n");
+                break;
+            case 6:
+                break;
+            default:
+                printf("Please try again\n");
+                break;
+        }
+    } while (font != 6);
 
     return 0;
 }
diff --git a/polymer/eduke32/build/src/util/wad2art.c b/polymer/eduke32/build/src/util/wad2art.c
index 8cb7746fd..3db1df891 100644
--- a/polymer/eduke32/build/src/util/wad2art.c
+++ b/polymer/eduke32/build/src/util/wad2art.c
@@ -22,78 +22,78 @@ static char screen[65536], tempbuf[131072];
 
 void loadwadheader(void)
 {
-	int i, j;
+    int i, j;
 
-	Bread(fil1,&tempbuf[0],12);
-	numwads = ((int)tempbuf[4])+(((int)tempbuf[5])<<8)+(((int)tempbuf[6])<<16)+(((int)tempbuf[7])<<24);
-	i = ((int)tempbuf[8])+(((int)tempbuf[9])<<8)+(((int)tempbuf[10])<<16)+(((int)tempbuf[11])<<24);
-	Blseek(fil1,i,BSEEK_SET);
-	Bread(fil1,&tempbuf[0],numwads*16);
-	j = 0;
-	for(i=0;i<numwads;i++)
-	{
-		wadplc[i] = ((int)tempbuf[j])+(((int)tempbuf[j+1])<<8)+(((int)tempbuf[j+2])<<16)+(((int)tempbuf[j+3])<<24);
-		j += 4;
-		wadlen[i] = ((int)tempbuf[j])+(((int)tempbuf[j+1])<<8)+(((int)tempbuf[j+2])<<16)+(((int)tempbuf[j+3])<<24);
-		j += 4;
-		wadata[i][0] = tempbuf[j+0]; wadata[i][1] = tempbuf[j+1];
-		wadata[i][2] = tempbuf[j+2]; wadata[i][3] = tempbuf[j+3];
-		wadata[i][4] = tempbuf[j+4]; wadata[i][5] = tempbuf[j+5];
-		wadata[i][6] = tempbuf[j+6]; wadata[i][7] = tempbuf[j+7];
-		j += 8;
-	}
+    Bread(fil1,&tempbuf[0],12);
+    numwads = ((int)tempbuf[4])+(((int)tempbuf[5])<<8)+(((int)tempbuf[6])<<16)+(((int)tempbuf[7])<<24);
+    i = ((int)tempbuf[8])+(((int)tempbuf[9])<<8)+(((int)tempbuf[10])<<16)+(((int)tempbuf[11])<<24);
+    Blseek(fil1,i,BSEEK_SET);
+    Bread(fil1,&tempbuf[0],numwads*16);
+    j = 0;
+    for(i=0;i<numwads;i++)
+    {
+        wadplc[i] = ((int)tempbuf[j])+(((int)tempbuf[j+1])<<8)+(((int)tempbuf[j+2])<<16)+(((int)tempbuf[j+3])<<24);
+        j += 4;
+        wadlen[i] = ((int)tempbuf[j])+(((int)tempbuf[j+1])<<8)+(((int)tempbuf[j+2])<<16)+(((int)tempbuf[j+3])<<24);
+        j += 4;
+        wadata[i][0] = tempbuf[j+0]; wadata[i][1] = tempbuf[j+1];
+        wadata[i][2] = tempbuf[j+2]; wadata[i][3] = tempbuf[j+3];
+        wadata[i][4] = tempbuf[j+4]; wadata[i][5] = tempbuf[j+5];
+        wadata[i][6] = tempbuf[j+6]; wadata[i][7] = tempbuf[j+7];
+        j += 8;
+    }
 }
 
 void convpalette(void)
 {
-	int i, fil3;
-	short danumshades;
+    int i, fil3;
+    short danumshades;
 
-	i = 0;
-	while (Bstrncasecmp(wadata[i],"PLAYPAL",7) != 0) i++;
-	Blseek(fil1,wadplc[i],BSEEK_SET);
-	Bread(fil1,pal,768);
-	for(i=0;i<768;i++) pal[i] >>= 2;
+    i = 0;
+    while (Bstrncasecmp(wadata[i],"PLAYPAL",7) != 0) i++;
+    Blseek(fil1,wadplc[i],BSEEK_SET);
+    Bread(fil1,pal,768);
+    for(i=0;i<768;i++) pal[i] >>= 2;
 
-	i = 0;
-	while (Bstrncasecmp(wadata[i],"COLORMAP",8) != 0) i++;
-	Blseek(fil1,wadplc[i],BSEEK_SET);
-	Bread(fil1,palookup,8192);
+    i = 0;
+    while (Bstrncasecmp(wadata[i],"COLORMAP",8) != 0) i++;
+    Blseek(fil1,wadplc[i],BSEEK_SET);
+    Bread(fil1,palookup,8192);
 
-	if ((fil3 = Bopen("palette.dat",BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
-		{ printf("Cannot save palette.dat\n"); exit(0); }
-	Bwrite(fil3,pal,768);
-	danumshades = 32;
-	Bwrite(fil3,&danumshades,2);
-	Bwrite(fil3,palookup,8192);
-	Bclose(fil3);
+    if ((fil3 = Bopen("palette.dat",BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
+        { printf("Cannot save palette.dat\n"); exit(0); }
+    Bwrite(fil3,pal,768);
+    danumshades = 32;
+    Bwrite(fil3,&danumshades,2);
+    Bwrite(fil3,palookup,8192);
+    Bclose(fil3);
 }
 
 void saveart (short tilenum, short xlen, short ylen)
 {
-	int i, x, p, pend;
+    int i, x, p, pend;
 
-	pend = ylookup[ylen];
+    pend = ylookup[ylen];
 
-	tilesizx[tilenum] = xlen;
-	tilesizy[tilenum] = ylen;
-	i = 0;
-	for(x=0;x<xlen;x++)
-		for(p=x;p<pend;p+=320)
-			tempbuf[i++] = screen[p];
-	if (Bwrite(fil2,&tempbuf[0],i) < 0)
-	{
-		printf("NOT ENOUGH DISK SPACE!\n");
-		exit(0);
-	}
+    tilesizx[tilenum] = xlen;
+    tilesizy[tilenum] = ylen;
+    i = 0;
+    for(x=0;x<xlen;x++)
+        for(p=x;p<pend;p+=320)
+            tempbuf[i++] = screen[p];
+    if (Bwrite(fil2,&tempbuf[0],i) < 0)
+    {
+        printf("NOT ENOUGH DISK SPACE!\n");
+        exit(0);
+    }
 }
 
 void savenames(void)
 {
-	BFILE * fil3;
+    BFILE * fil3;
     int i;
 
-	fil3 = Bfopen("names.h","w");
+    fil3 = Bfopen("names.h","w");
 
     if (fil3 != NULL)
     {
@@ -109,159 +109,159 @@ void savenames(void)
 
 void showart (char *part)
 {
-	char yoff;
-	short xsiz, ysiz;
-	int i, z, zx, x, p, pend, curplc;
+    char yoff;
+    short xsiz, ysiz;
+    int i, z, zx, x, p, pend, curplc;
 
-	curplc = -1;
-	if ((Bstrncasecmp(part,"L_START",7) == 0) || (Bstrncasecmp(part,"S_START",7) == 0) || (Bstrncasecmp(part,"P_START",7) == 0))
-	{
-		if (Bstrncasecmp(part,"L_START",7) == 0)
-			z = 462;
-		else
-		{
-			z = 0;
-			while (Bstrncasecmp(wadata[z],part,7) != 0) z++;
-			z++;
-		}
-	 
-		do
-		{
-			if (Bstrncasecmp(wadata[z],"P1_START",8) == 0) z++;
-			if (Bstrncasecmp(wadata[z],"P1_END",6) == 0) z++;
-			if (Bstrncasecmp(wadata[z],"P2_START",8) == 0) z++;
-			if (Bstrncasecmp(wadata[z],"S_START",7) == 0) break;
-			if (Bstrncasecmp(wadata[z],"S_END",5) == 0) break;
-			if (Bstrncasecmp(wadata[z],"P_END",5) == 0) break;
-		  
-			if (curplc != wadplc[z]) Blseek(fil1,wadplc[z],BSEEK_SET);
-			read(fil1,&tempbuf[0],wadlen[z]);
-			curplc = wadplc[z]+wadlen[z];
+    curplc = -1;
+    if ((Bstrncasecmp(part,"L_START",7) == 0) || (Bstrncasecmp(part,"S_START",7) == 0) || (Bstrncasecmp(part,"P_START",7) == 0))
+    {
+        if (Bstrncasecmp(part,"L_START",7) == 0)
+            z = 462;
+        else
+        {
+            z = 0;
+            while (Bstrncasecmp(wadata[z],part,7) != 0) z++;
+            z++;
+        }
 
-			xsiz = (int)tempbuf[0]+(((int)tempbuf[1])<<8);
-			ysiz = (int)tempbuf[2]+(((int)tempbuf[3])<<8);
-			if ((xsiz <= 0) || (ysiz <= 0) || (xsiz > 320) || (ysiz > 200)) goto skipit;
-			i = 8;
-			for(zx=0;zx<xsiz;zx++)
-			{
-				xoffses[zx] = ((int)tempbuf[i])+(((int)tempbuf[i+1])<<8)+(((int)tempbuf[i+2])<<16)+(((int)tempbuf[i+3])<<24);
-				i += 4;
-			}
+        do
+        {
+            if (Bstrncasecmp(wadata[z],"P1_START",8) == 0) z++;
+            if (Bstrncasecmp(wadata[z],"P1_END",6) == 0) z++;
+            if (Bstrncasecmp(wadata[z],"P2_START",8) == 0) z++;
+            if (Bstrncasecmp(wadata[z],"S_START",7) == 0) break;
+            if (Bstrncasecmp(wadata[z],"S_END",5) == 0) break;
+            if (Bstrncasecmp(wadata[z],"P_END",5) == 0) break;
 
-			clearbuf(screen,ylookup[ysiz]>>2,0xffffffff);
+            if (curplc != wadplc[z]) Blseek(fil1,wadplc[z],BSEEK_SET);
+            read(fil1,&tempbuf[0],wadlen[z]);
+            curplc = wadplc[z]+wadlen[z];
 
-			for(x=0;x<xsiz;x++)
-			{
-				i = xoffses[x];
-				yoff = tempbuf[i++];
-				while (yoff != 255)
-				{
-					p = ylookup[yoff]+x;
-					pend = p+ylookup[tempbuf[i]];
-					i += 2;
-					for(;p<pend;p+=320)
-						screen[p] = tempbuf[i++];
-					i++;
-					yoff = tempbuf[i++];
-				}
-			}
+            xsiz = (int)tempbuf[0]+(((int)tempbuf[1])<<8);
+            ysiz = (int)tempbuf[2]+(((int)tempbuf[3])<<8);
+            if ((xsiz <= 0) || (ysiz <= 0) || (xsiz > 320) || (ysiz > 200)) goto skipit;
+            i = 8;
+            for(zx=0;zx<xsiz;zx++)
+            {
+                xoffses[zx] = ((int)tempbuf[i])+(((int)tempbuf[i+1])<<8)+(((int)tempbuf[i+2])<<16)+(((int)tempbuf[i+3])<<24);
+                i += 4;
+            }
 
-			saveart(z,xsiz,ysiz);
+            clearbuf(screen,ylookup[ysiz]>>2,0xffffffff);
+
+            for(x=0;x<xsiz;x++)
+            {
+                i = xoffses[x];
+                yoff = tempbuf[i++];
+                while (yoff != 255)
+                {
+                    p = ylookup[yoff]+x;
+                    pend = p+ylookup[tempbuf[i]];
+                    i += 2;
+                    for(;p<pend;p+=320)
+                        screen[p] = tempbuf[i++];
+                    i++;
+                    yoff = tempbuf[i++];
+                }
+            }
+
+            saveart(z,xsiz,ysiz);
 skipit:
-			z++;
-		} while (z < numwads);
-	}
-	else
-	{
-		z = 0;
-		while (Bstrncasecmp(wadata[z],part,7) != 0) z++;
-		z++;
-	 
-		while (1)
-		{
-			if (Bstrncasecmp(wadata[z],"F1_START",8) == 0) z++;
-			if (Bstrncasecmp(wadata[z],"F1_END",6) == 0) z++;
-			if (Bstrncasecmp(wadata[z],"F_END",5) == 0) break;
+            z++;
+        } while (z < numwads);
+    }
+    else
+    {
+        z = 0;
+        while (Bstrncasecmp(wadata[z],part,7) != 0) z++;
+        z++;
 
-			if (wadlen[z] == 4096)
-			{
-				if (curplc != wadplc[z]) Blseek(fil1,wadplc[z],BSEEK_SET);
-				Bread(fil1,&tempbuf[0],4096);
-				curplc = wadplc[z]+4096;
-				i = 0;
-				for(x=0;x<64;x++)
-					for(p=x;p<320*64;p+=320)
-						screen[p] = tempbuf[i++];
+        while (1)
+        {
+            if (Bstrncasecmp(wadata[z],"F1_START",8) == 0) z++;
+            if (Bstrncasecmp(wadata[z],"F1_END",6) == 0) z++;
+            if (Bstrncasecmp(wadata[z],"F_END",5) == 0) break;
 
-				saveart(z,64,64);
-			}
+            if (wadlen[z] == 4096)
+            {
+                if (curplc != wadplc[z]) Blseek(fil1,wadplc[z],BSEEK_SET);
+                Bread(fil1,&tempbuf[0],4096);
+                curplc = wadplc[z]+4096;
+                i = 0;
+                for(x=0;x<64;x++)
+                    for(p=x;p<320*64;p+=320)
+                        screen[p] = tempbuf[i++];
 
-			z++;
-		}
-	}
+                saveart(z,64,64);
+            }
+
+            z++;
+        }
+    }
 }
 
 int main(int argc, char **argv)
 {
-	int i, j, endoffile;
-	char wadfile[80];
+    int i, j, endoffile;
+    char wadfile[80];
 
-	printf("Wad2Art!                                       Copyright 1995 by Ken Silverman\n");
+    printf("Wad2Art!                                       Copyright 1995 by Ken Silverman\n");
 
-	if (argc != 2)
-	{
-		printf("Command line parameters: Wad2Art [Doom IWAD file]\n");
-		printf("   Creates TILES000.ART, PALETTE.DAT, and NAMES.H in current directory.\n");
-		printf("   Ex: wad2art c:\\doom\\doom.wad\n");
-		exit(0);
-	}
+    if (argc != 2)
+    {
+        printf("Command line parameters: Wad2Art [Doom IWAD file]\n");
+        printf("   Creates TILES000.ART, PALETTE.DAT, and NAMES.H in current directory.\n");
+        printf("   Ex: wad2art c:\\doom\\doom.wad\n");
+        exit(0);
+    }
 
-	strcpy(wadfile,argv[1]);
-	if (strchr(wadfile,'.') == 0) strcat(wadfile,".wad");
-	if ((fil1 = Bopen(wadfile,BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
-		{ printf("Wad not found\n"); exit(0); }
-	if ((fil2 = Bopen("tiles000.art",BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
-		{ printf("Can't open art file\n"); exit(0); }
+    strcpy(wadfile,argv[1]);
+    if (strchr(wadfile,'.') == 0) strcat(wadfile,".wad");
+    if ((fil1 = Bopen(wadfile,BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
+        { printf("Wad not found\n"); exit(0); }
+    if ((fil2 = Bopen("tiles000.art",BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
+        { printf("Can't open art file\n"); exit(0); }
 
-	j = 0;
-	for(i=0;i<256;i++) { ylookup[i] = j; j += 320; }
+    j = 0;
+    for(i=0;i<256;i++) { ylookup[i] = j; j += 320; }
 
-	printf("Loading wad header...\n");
-	loadwadheader();
-	Blseek(fil2,16+(numwads<<3),SEEK_SET);
-	for(i=0;i<numwads;i++)
-		{ tilesizx[i] = 0; tilesizy[i] = 0; picanm[i] = 0L; }
+    printf("Loading wad header...\n");
+    loadwadheader();
+    Blseek(fil2,16+(numwads<<3),SEEK_SET);
+    for(i=0;i<numwads;i++)
+        { tilesizx[i] = 0; tilesizy[i] = 0; picanm[i] = 0L; }
 
-	printf("Saving names.h\n");
-	savenames();
-	printf("Converting palette\n");
-	convpalette();
+    printf("Saving names.h\n");
+    savenames();
+    printf("Converting palette\n");
+    convpalette();
 
-	printf("Saving tiles000.art\n");
-	showart("L_START");
-	showart("S_START");
-	showart("P_START");
-	showart("F_START");
+    printf("Saving tiles000.art\n");
+    showart("L_START");
+    showart("S_START");
+    showart("P_START");
+    showart("F_START");
 
-	printf("Saving tiles000.art header\n");
-	artversion = 1; localtilestart = 0; localtileend = numwads-1;
+    printf("Saving tiles000.art header\n");
+    artversion = 1; localtilestart = 0; localtileend = numwads-1;
 
-	endoffile = Btell(fil2);
-	Blseek(fil2,0,BSEEK_SET);
-	Bwrite(fil2,&artversion,4);
-	Bwrite(fil2,&numwads,4);
-	Bwrite(fil2,&localtilestart,4);
-	Bwrite(fil2,&localtileend,4);
-	Bwrite(fil2,&tilesizx[0],numwads<<1);
-	Bwrite(fil2,&tilesizy[0],numwads<<1);
-	Bwrite(fil2,&picanm[0],numwads<<2);
-	Blseek(fil2,endoffile,BSEEK_SET);
+    endoffile = Btell(fil2);
+    Blseek(fil2,0,BSEEK_SET);
+    Bwrite(fil2,&artversion,4);
+    Bwrite(fil2,&numwads,4);
+    Bwrite(fil2,&localtilestart,4);
+    Bwrite(fil2,&localtileend,4);
+    Bwrite(fil2,&tilesizx[0],numwads<<1);
+    Bwrite(fil2,&tilesizy[0],numwads<<1);
+    Bwrite(fil2,&picanm[0],numwads<<2);
+    Blseek(fil2,endoffile,BSEEK_SET);
 
-	Bclose(fil2);
-	Bclose(fil1);
+    Bclose(fil2);
+    Bclose(fil1);
 
-	printf("Congratulations!  Your disk actually had enough space this time!\n");
+    printf("Congratulations!  Your disk actually had enough space this time!\n");
 
-	return 0;
+    return 0;
 }
 
diff --git a/polymer/eduke32/build/src/util/wad2map.c b/polymer/eduke32/build/src/util/wad2map.c
index 964bc3193..7c94adbe7 100644
--- a/polymer/eduke32/build/src/util/wad2map.c
+++ b/polymer/eduke32/build/src/util/wad2map.c
@@ -34,32 +34,32 @@ static short px[MAXPOINTS], py[MAXPOINTS];
 
 typedef struct
 {
-	short p1, p2, flags, special, tag;
-	short side1, side2;   //If side2 = -1, no left
+    short p1, p2, flags, special, tag;
+    short side1, side2;   //If side2 = -1, no left
 } linedeftype;
 static linedeftype line[MAXLINES];
 
 typedef struct
 {
-	short xoffset, yoffset;
-	char uppertexture[8], lowertexture[8], middletexture[8];
-	short sect;
+    short xoffset, yoffset;
+    char uppertexture[8], lowertexture[8], middletexture[8];
+    short sect;
 } sidedeftype;
 static sidedeftype side[MAXSIDES];
 static short sidetoppic[MAXSIDES], sidebotpic[MAXSIDES], sidemidpic[MAXSIDES];
 
 typedef struct
 {
-	short floorz, ceilingz;
-	char floorpic[8], ceilingpic[8];
-	short shade, type, tag;
+    short floorz, ceilingz;
+    char floorpic[8], ceilingpic[8];
+    short shade, type, tag;
 } secttype;
 static secttype sect[MAXSECTS];
 static short sectspri[MAXSECTS][8];
 
 typedef struct
 {
-	short x, y, ang, type, options;
+    short x, y, ang, type, options;
 } thingtype;
 static thingtype thing[MAXTHINGS];
 
@@ -69,47 +69,47 @@ static short textpname[MAXTEXTS];
 
 static char pname[MAXPNAMES][9];
 
-	//Build map-linking variables
+    //Build map-linking variables
 static short picindex[MAXPOINTS], linindex[MAXPOINTS];
 static short wx[MAXPOINTS], wy[MAXPOINTS], wx2[MAXPOINTS], wy2[MAXPOINTS];
 static short point2[MAXPOINTS], slist[MAXPOINTS], sectorofwall[MAXPOINTS];
 
 typedef struct
 {
-	short wallptr, wallnum;
-	int ceilingz, floorz;
-	short ceilingstat, floorstat;
-	short ceilingpicnum, ceilingheinum;
-	signed char ceilingshade;
-	char ceilingpal, ceilingxpanning, ceilingypanning;
-	short floorpicnum, floorheinum;
-	signed char floorshade;
-	char floorpal, floorxpanning, floorypanning;
-	char visibility, filler;
-	short lotag, hitag, extra;
+    short wallptr, wallnum;
+    int ceilingz, floorz;
+    short ceilingstat, floorstat;
+    short ceilingpicnum, ceilingheinum;
+    signed char ceilingshade;
+    char ceilingpal, ceilingxpanning, ceilingypanning;
+    short floorpicnum, floorheinum;
+    signed char floorshade;
+    char floorpal, floorxpanning, floorypanning;
+    char visibility, filler;
+    short lotag, hitag, extra;
 } sectortype;
 
 typedef struct
 {
-	int x, y;
-	short point2, nextwall, nextsector, cstat;
-	short picnum, overpicnum;
-	signed char shade;
-	char pal, xrepeat, yrepeat, xpanning, ypanning;
-	short lotag, hitag, extra;
+    int x, y;
+    short point2, nextwall, nextsector, cstat;
+    short picnum, overpicnum;
+    signed char shade;
+    char pal, xrepeat, yrepeat, xpanning, ypanning;
+    short lotag, hitag, extra;
 } walltype;
 
 typedef struct
 {
-	int x, y, z;
-	short cstat, picnum;
-	signed char shade;
-	char pal, clipdist, filler;
-	unsigned char xrepeat, yrepeat;
-	signed char xoffset, yoffset;
-	short sectnum, statnum;
-	short ang, owner, xvel, yvel, zvel;
-	short lotag, hitag, extra;
+    int x, y, z;
+    short cstat, picnum;
+    signed char shade;
+    char pal, clipdist, filler;
+    unsigned char xrepeat, yrepeat;
+    signed char xoffset, yoffset;
+    short sectnum, statnum;
+    short ang, owner, xvel, yvel, zvel;
+    short lotag, hitag, extra;
 } spritetype;
 
 static sectortype sector[MAXSECTORS];
@@ -120,7 +120,7 @@ static char tempbuf[16384];
 static short tempshort[4096];
 
 
-	//SCRIPT parsing variables:
+    //SCRIPT parsing variables:
 static char scriptname[16];
 static char filebuf[16384];
 static int filhandle, filpos, fileng;
@@ -179,1438 +179,1438 @@ static thinglisttype thinglist[THINGLISTNUM] =
 // These three were nicked from Build's engine.c.
 static inline unsigned int ksqrtasm(unsigned int a)
 {
-	unsigned short c;
+    unsigned short c;
 
-	if (a & 0xff000000) c = shlookup[(a >> 24) + 4096];
-	else c = shlookup[a >> 12];
-	a >>= c&0xff;
-	a = (a&0xffff0000)|(sqrtable[a]);
-	a >>= ((c&0xff00) >> 8);
+    if (a & 0xff000000) c = shlookup[(a >> 24) + 4096];
+    else c = shlookup[a >> 12];
+    a >>= c&0xff;
+    a = (a&0xffff0000)|(sqrtable[a]);
+    a >>= ((c&0xff00) >> 8);
 
-	return a;
+    return a;
 }
 
 static inline int msqrtasm(unsigned int c)
 {
-	unsigned int a,b;
+    unsigned int a,b;
 
-	a = 0x40000000l;
-	b = 0x20000000l;
-	do {
-		if (c >= a) {
-			c -= a;
-			a += b*4;
-		}
-		a -= b;
-		a >>= 1;
-		b >>= 2;
-	} while (b);
-	if (c >= a) a++;
-	a >>= 1;
-	return a;
+    a = 0x40000000l;
+    b = 0x20000000l;
+    do {
+        if (c >= a) {
+            c -= a;
+            a += b*4;
+        }
+        a -= b;
+        a >>= 1;
+        b >>= 2;
+    } while (b);
+    if (c >= a) a++;
+    a >>= 1;
+    return a;
 }
 
 static void initksqrt(void)
 {
-	int i, j, k;
+    int i, j, k;
 
-	j = 1; k = 0;
-	for(i=0;i<4096;i++)
-	{
-		if (i >= j) { j <<= 2; k++; }
-		sqrtable[i] = (unsigned short)(msqrtasm((i<<18)+131072)<<1);
-		shlookup[i] = (k<<1)+((10-k)<<8);
-		if (i < 256) shlookup[i+4096] = ((k+6)<<1)+((10-(k+6))<<8);
-	}
+    j = 1; k = 0;
+    for(i=0;i<4096;i++)
+    {
+        if (i >= j) { j <<= 2; k++; }
+        sqrtable[i] = (unsigned short)(msqrtasm((i<<18)+131072)<<1);
+        shlookup[i] = (k<<1)+((10-k)<<8);
+        if (i < 256) shlookup[i+4096] = ((k+6)<<1)+((10-(k+6))<<8);
+    }
 }
 
 
 int inside(int x, int y, short sectnum)
 {
-	walltype *wal;
-	int i, x1, y1, x2, y2;
-	char cnt;
+    walltype *wal;
+    int i, x1, y1, x2, y2;
+    char cnt;
 
-	cnt = 0;
+    cnt = 0;
 
-	wal = &wall[sector[sectnum].wallptr];
-	for(i=sector[sectnum].wallnum;i>0;i--)
-	{
-		y1 = wal->y-y; y2 = wall[wal->point2].y-y;
-		if ((y1^y2) < 0)
-		{
-			x1 = wal->x-x; x2 = wall[wal->point2].x-x;
+    wal = &wall[sector[sectnum].wallptr];
+    for(i=sector[sectnum].wallnum;i>0;i--)
+    {
+        y1 = wal->y-y; y2 = wall[wal->point2].y-y;
+        if ((y1^y2) < 0)
+        {
+            x1 = wal->x-x; x2 = wall[wal->point2].x-x;
 
-			if ((x1^x2) < 0)
-				cnt ^= (x1*y2<x2*y1)^(y1<y2);
-			else if (x1 >= 0)
-				cnt ^= 1;
-		}
-		wal++;
-	}
-	return(cnt);
+            if ((x1^x2) < 0)
+                cnt ^= (x1*y2<x2*y1)^(y1<y2);
+            else if (x1 >= 0)
+                cnt ^= 1;
+        }
+        wal++;
+    }
+    return(cnt);
 }
 
 int readbyte(void)
 {
-	if (filpos >= fileng) return(-1);
-	if ((filpos&16383) == 0) Bread(filhandle,filebuf,16384);
-	filpos++;
-	return((int)filebuf[(filpos-1)&16383]);
+    if (filpos >= fileng) return(-1);
+    if ((filpos&16383) == 0) Bread(filhandle,filebuf,16384);
+    filpos++;
+    return((int)filebuf[(filpos-1)&16383]);
 }
 
 int readline(void)
 {
-	int i, ch;
+    int i, ch;
 
-	do
-	{
-		do
-		{
-			ch = readbyte();
-			if (ch < 0) return(0);
-		} while ((ch == 13) || (ch == 10));
+    do
+    {
+        do
+        {
+            ch = readbyte();
+            if (ch < 0) return(0);
+        } while ((ch == 13) || (ch == 10));
 
-		i = 0; tempbuf[0] = 0;
-		while ((ch != 13) && (ch != 10))
-		{
-			if (ch < 0) return(0);
-			if (ch == ';')
-			{
-				do
-				{
-					if (ch < 0) return(0);
-					ch = readbyte();
-				} while ((ch != 13) && (ch != 10));
-				break;
-			}
-			if ((ch == 32) || (ch == 9)) ch = ',';
-			if ((ch != ',') || (i == 0) || (tempbuf[i-1] != ','))
-				{ tempbuf[i++] = ch; tempbuf[i] = 0; }
-			ch = readbyte();
-		}
-		if ((i > 0) && (tempbuf[i-1] == ',')) tempbuf[i-1] = 0;
-	} while (i <= 0);
-	return(i);
+        i = 0; tempbuf[0] = 0;
+        while ((ch != 13) && (ch != 10))
+        {
+            if (ch < 0) return(0);
+            if (ch == ';')
+            {
+                do
+                {
+                    if (ch < 0) return(0);
+                    ch = readbyte();
+                } while ((ch != 13) && (ch != 10));
+                break;
+            }
+            if ((ch == 32) || (ch == 9)) ch = ',';
+            if ((ch != ',') || (i == 0) || (tempbuf[i-1] != ','))
+                { tempbuf[i++] = ch; tempbuf[i] = 0; }
+            ch = readbyte();
+        }
+        if ((i > 0) && (tempbuf[i-1] == ',')) tempbuf[i-1] = 0;
+    } while (i <= 0);
+    return(i);
 }
 
 void parsescript(void)
 {
-	int i, j, k, l, lasti, breakout, tstart, tend, textnum = 0, frontbackstat;
-	int spritenumstat, slen;
-	char ch;
+    int i, j, k, l, lasti, breakout, tstart, tend, textnum = 0, frontbackstat;
+    int spritenumstat, slen;
+    char ch;
 
-	clearbufbyte(&sectspri[0], sizeof(short) * MAXSECTS * 8, 0xffffffff);
+    clearbufbyte(&sectspri[0], sizeof(short) * MAXSECTS * 8, 0xffffffff);
 
-	if (scriptname[0] == 0)
-	{
-		for(i=0;i<4096;i++) texturelookup[i] = i;
-		return;
-	}
+    if (scriptname[0] == 0)
+    {
+        for(i=0;i<4096;i++) texturelookup[i] = i;
+        return;
+    }
 
-	if ((filhandle = Bopen(scriptname,BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
-	{
-		printf("Could not find %s\n",scriptname);
-		exit(0);
-	}
-	filpos = 0; fileng = Bfilelength(filhandle);
-	while (readline() != 0)
-	{
-		i = 0; j = 0; lasti = 0;
-		while (1)
-		{
-			if ((tempbuf[i] == ',') || (tempbuf[i] == 0))
-			{
-				if (tempbuf[i] == 0) { breakout = 1; }
-				else { breakout = 0, tempbuf[i] = 0; }
+    if ((filhandle = Bopen(scriptname,BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
+    {
+        printf("Could not find %s\n",scriptname);
+        exit(0);
+    }
+    filpos = 0; fileng = Bfilelength(filhandle);
+    while (readline() != 0)
+    {
+        i = 0; j = 0; lasti = 0;
+        while (1)
+        {
+            if ((tempbuf[i] == ',') || (tempbuf[i] == 0))
+            {
+                if (tempbuf[i] == 0) { breakout = 1; }
+                else { breakout = 0, tempbuf[i] = 0; }
 
-				if (j == 0)
-				{
-					if (tempbuf[lasti] == '[')
-					{
-						definemode = 0;
-						thingtypemode = 0;
-						texturelookupmode = 0;
-						tagtypemode = 0;
-						sectypemode = 0;
-					}
+                if (j == 0)
+                {
+                    if (tempbuf[lasti] == '[')
+                    {
+                        definemode = 0;
+                        thingtypemode = 0;
+                        texturelookupmode = 0;
+                        tagtypemode = 0;
+                        sectypemode = 0;
+                    }
 
-					if (Bstrcasecmp(&tempbuf[lasti],"#define") == 0)
-						definemode = 1;
+                    if (Bstrcasecmp(&tempbuf[lasti],"#define") == 0)
+                        definemode = 1;
 
-					if (thingtypemode == 1)
-					{
-						thingoff[numthings] = thingopnum;
+                    if (thingtypemode == 1)
+                    {
+                        thingoff[numthings] = thingopnum;
 
-						k = lasti;
-						while ((tempbuf[k] != 0) && (tempbuf[k] != '-')) k++;
+                        k = lasti;
+                        while ((tempbuf[k] != 0) && (tempbuf[k] != '-')) k++;
 
-						if (tempbuf[k] == '-')
-						{
-							tempbuf[k] = 0;
-							thingnum[numthings] = atol(&tempbuf[lasti]);
-							thingnum2[numthings] = atol(&tempbuf[k+1]);
-						}
-						else
-						{
-							thingnum[numthings] = atol(&tempbuf[lasti]);
-							thingnum2[numthings] = thingnum[numthings];
-						}
+                        if (tempbuf[k] == '-')
+                        {
+                            tempbuf[k] = 0;
+                            thingnum[numthings] = atol(&tempbuf[lasti]);
+                            thingnum2[numthings] = atol(&tempbuf[k+1]);
+                        }
+                        else
+                        {
+                            thingnum[numthings] = atol(&tempbuf[lasti]);
+                            thingnum2[numthings] = thingnum[numthings];
+                        }
 
-						numthings++;
-					}
-					else if (Bstrcasecmp(&tempbuf[lasti],"[THINGTYPES]") == 0)
-						thingtypemode = 1;
+                        numthings++;
+                    }
+                    else if (Bstrcasecmp(&tempbuf[lasti],"[THINGTYPES]") == 0)
+                        thingtypemode = 1;
 
-					if (texturelookupmode == 1)
-					{
-						textnum = 0;
-						if ((tempbuf[lasti] >= 48) && (tempbuf[lasti] <= 57))
-						{
-							k = lasti;
-							while ((tempbuf[k] != 0) && (tempbuf[k] != '-')) k++;
+                    if (texturelookupmode == 1)
+                    {
+                        textnum = 0;
+                        if ((tempbuf[lasti] >= 48) && (tempbuf[lasti] <= 57))
+                        {
+                            k = lasti;
+                            while ((tempbuf[k] != 0) && (tempbuf[k] != '-')) k++;
 
-							if (tempbuf[k] == '-')
-							{
-								tempbuf[k] = 0;
-								tstart = atol(&tempbuf[lasti]);
-								tend = atol(&tempbuf[k+1]);
-								for(k=tstart;k<=tend;k++)
-									tempshort[textnum++] = k;
-							}
-							else
-								tempshort[textnum++] = atol(&tempbuf[lasti]);
-						}
-						else
-						{
-							slen = 0;
-							while (tempbuf[lasti+slen] != 0)
-							{
-								ch = tempbuf[lasti+slen];
-								if ((ch >= 97) && (ch <= 122)) tempbuf[lasti+slen] -= 32;
-								slen++;
-							}
-							if (slen > 0)
-								for(k=inumwads-1;k>=0;k--)
-									if ((iwadata[k][slen] == 0) || (iwadata[k][slen] == 32))
-										if ((iwadata[k][slen-1] != 0) && (iwadata[k][slen-1] != 32))
-										{
-											for(l=slen-1;l>=0;l--)
-												if (tempbuf[lasti+l] != '?')
-												{
-													ch = iwadata[k][l];
-													if ((ch >= 97) && (ch <= 122)) ch -= 32;
-													if (tempbuf[lasti+l] != ch) break;
-												}
-											if (l < 0) tempshort[textnum++] = k;
-										}
-						}
-					}
-					else if (Bstrcasecmp(&tempbuf[lasti],"[TEXTURELOOKUPS]") == 0)
-						texturelookupmode = 1;
+                            if (tempbuf[k] == '-')
+                            {
+                                tempbuf[k] = 0;
+                                tstart = atol(&tempbuf[lasti]);
+                                tend = atol(&tempbuf[k+1]);
+                                for(k=tstart;k<=tend;k++)
+                                    tempshort[textnum++] = k;
+                            }
+                            else
+                                tempshort[textnum++] = atol(&tempbuf[lasti]);
+                        }
+                        else
+                        {
+                            slen = 0;
+                            while (tempbuf[lasti+slen] != 0)
+                            {
+                                ch = tempbuf[lasti+slen];
+                                if ((ch >= 97) && (ch <= 122)) tempbuf[lasti+slen] -= 32;
+                                slen++;
+                            }
+                            if (slen > 0)
+                                for(k=inumwads-1;k>=0;k--)
+                                    if ((iwadata[k][slen] == 0) || (iwadata[k][slen] == 32))
+                                        if ((iwadata[k][slen-1] != 0) && (iwadata[k][slen-1] != 32))
+                                        {
+                                            for(l=slen-1;l>=0;l--)
+                                                if (tempbuf[lasti+l] != '?')
+                                                {
+                                                    ch = iwadata[k][l];
+                                                    if ((ch >= 97) && (ch <= 122)) ch -= 32;
+                                                    if (tempbuf[lasti+l] != ch) break;
+                                                }
+                                            if (l < 0) tempshort[textnum++] = k;
+                                        }
+                        }
+                    }
+                    else if (Bstrcasecmp(&tempbuf[lasti],"[TEXTURELOOKUPS]") == 0)
+                        texturelookupmode = 1;
 
-					if (tagtypemode == 1)
-					{
-						tagoff[numtags] = tagopnum;
+                    if (tagtypemode == 1)
+                    {
+                        tagoff[numtags] = tagopnum;
 
-						k = lasti;
-						while ((tempbuf[k] != 0) && (tempbuf[k] != '-')) k++;
+                        k = lasti;
+                        while ((tempbuf[k] != 0) && (tempbuf[k] != '-')) k++;
 
-						if (tempbuf[k] == '-')
-						{
-							tempbuf[k] = 0;
-							tagnum[numtags] = atol(&tempbuf[lasti]);
-							tagnum2[numtags] = atol(&tempbuf[k+1]);
-						}
-						else
-						{
-							tagnum[numtags] = atol(&tempbuf[lasti]);
-							tagnum2[numtags] = tagnum[numtags];
-						}
+                        if (tempbuf[k] == '-')
+                        {
+                            tempbuf[k] = 0;
+                            tagnum[numtags] = atol(&tempbuf[lasti]);
+                            tagnum2[numtags] = atol(&tempbuf[k+1]);
+                        }
+                        else
+                        {
+                            tagnum[numtags] = atol(&tempbuf[lasti]);
+                            tagnum2[numtags] = tagnum[numtags];
+                        }
 
-						numtags++;
-					}
-					else if (Bstrcasecmp(&tempbuf[lasti],"[TAGCONVERSIONS]") == 0)
-						tagtypemode = 1;
+                        numtags++;
+                    }
+                    else if (Bstrcasecmp(&tempbuf[lasti],"[TAGCONVERSIONS]") == 0)
+                        tagtypemode = 1;
 
-					if (sectypemode == 1)
-					{
-						secoff[numsecs] = secopnum;
+                    if (sectypemode == 1)
+                    {
+                        secoff[numsecs] = secopnum;
 
-						k = lasti;
-						while ((tempbuf[k] != 0) && (tempbuf[k] != '-')) k++;
+                        k = lasti;
+                        while ((tempbuf[k] != 0) && (tempbuf[k] != '-')) k++;
 
-						if (tempbuf[k] == '-')
-						{
-							tempbuf[k] = 0;
-							secnum[numsecs] = atol(&tempbuf[lasti]);
-							secnum2[numsecs] = atol(&tempbuf[k+1]);
-						}
-						else
-						{
-							secnum[numsecs] = atol(&tempbuf[lasti]);
-							secnum2[numsecs] = secnum[numsecs];
-						}
-						numsecs++;
-					}
-					else if (Bstrcasecmp(&tempbuf[lasti],"[SECTORCONVERSIONS]") == 0)
-						sectypemode = 1;
+                        if (tempbuf[k] == '-')
+                        {
+                            tempbuf[k] = 0;
+                            secnum[numsecs] = atol(&tempbuf[lasti]);
+                            secnum2[numsecs] = atol(&tempbuf[k+1]);
+                        }
+                        else
+                        {
+                            secnum[numsecs] = atol(&tempbuf[lasti]);
+                            secnum2[numsecs] = secnum[numsecs];
+                        }
+                        numsecs++;
+                    }
+                    else if (Bstrcasecmp(&tempbuf[lasti],"[SECTORCONVERSIONS]") == 0)
+                        sectypemode = 1;
 
-				}
-				else if (j > 0)
-				{
-					if (definemode == 1)
-					{
-						defineptr[numdefines] = (char *)(&define[definecnt]);
-						for(k=lasti;k<i;k++) define[definecnt++] = tempbuf[k];
-						define[definecnt++] = 0;
-						definemode = 2;
-					}
-					else if (definemode == 2)
-					{
-						defineval[numdefines++] = atol(&tempbuf[lasti]);
-						definemode = 0;
-					}
+                }
+                else if (j > 0)
+                {
+                    if (definemode == 1)
+                    {
+                        defineptr[numdefines] = (char *)(&define[definecnt]);
+                        for(k=lasti;k<i;k++) define[definecnt++] = tempbuf[k];
+                        define[definecnt++] = 0;
+                        definemode = 2;
+                    }
+                    else if (definemode == 2)
+                    {
+                        defineval[numdefines++] = atol(&tempbuf[lasti]);
+                        definemode = 0;
+                    }
 
-					if (thingtypemode == 1)
-					{
-						for(k=lasti;k<i;k++) if (tempbuf[k] == '=') break;
-						thingop[thingopnum] = 0;
-						if (tempbuf[k-1] == '+') thingop[thingopnum] = 1;
-						if (tempbuf[k-1] == '-') thingop[thingopnum] = 2;
-						if (tempbuf[k-1] == '|') thingop[thingopnum] = 3;
-						if (tempbuf[k-1] == '&') thingop[thingopnum] = 4;
-						if (tempbuf[k-1] == '^') thingop[thingopnum] = 5;
-						if (thingop[thingopnum] != 0) tempbuf[k-1] = 0;
-														 else tempbuf[k] = 0;
+                    if (thingtypemode == 1)
+                    {
+                        for(k=lasti;k<i;k++) if (tempbuf[k] == '=') break;
+                        thingop[thingopnum] = 0;
+                        if (tempbuf[k-1] == '+') thingop[thingopnum] = 1;
+                        if (tempbuf[k-1] == '-') thingop[thingopnum] = 2;
+                        if (tempbuf[k-1] == '|') thingop[thingopnum] = 3;
+                        if (tempbuf[k-1] == '&') thingop[thingopnum] = 4;
+                        if (tempbuf[k-1] == '^') thingop[thingopnum] = 5;
+                        if (thingop[thingopnum] != 0) tempbuf[k-1] = 0;
+                                                         else tempbuf[k] = 0;
 
-						if (Bstrcasecmp(&tempbuf[lasti],"x") == 0) thingfield[thingopnum] = 0;
-						if (Bstrcasecmp(&tempbuf[lasti],"y") == 0) thingfield[thingopnum] = 1;
-						if (Bstrcasecmp(&tempbuf[lasti],"z") == 0) thingfield[thingopnum] = 2;
-						if (Bstrcasecmp(&tempbuf[lasti],"cstat") == 0) thingfield[thingopnum] = 3;
-						if (Bstrcasecmp(&tempbuf[lasti],"shade") == 0) thingfield[thingopnum] = 4;
-						if (Bstrcasecmp(&tempbuf[lasti],"pal") == 0) thingfield[thingopnum] = 5;
-						if (Bstrcasecmp(&tempbuf[lasti],"clipdist") == 0) thingfield[thingopnum] = 6;
-						if (Bstrcasecmp(&tempbuf[lasti],"xrepeat") == 0) thingfield[thingopnum] = 7;
-						if (Bstrcasecmp(&tempbuf[lasti],"yrepeat") == 0) thingfield[thingopnum] = 8;
-						if (Bstrcasecmp(&tempbuf[lasti],"xoffset") == 0) thingfield[thingopnum] = 9;
-						if (Bstrcasecmp(&tempbuf[lasti],"yoffset") == 0) thingfield[thingopnum] = 10;
-						if (Bstrcasecmp(&tempbuf[lasti],"picnum") == 0) thingfield[thingopnum] = 11;
-						if (Bstrcasecmp(&tempbuf[lasti],"ang") == 0) thingfield[thingopnum] = 12;
-						if (Bstrcasecmp(&tempbuf[lasti],"xvel") == 0) thingfield[thingopnum] = 13;
-						if (Bstrcasecmp(&tempbuf[lasti],"yvel") == 0) thingfield[thingopnum] = 14;
-						if (Bstrcasecmp(&tempbuf[lasti],"zvel") == 0) thingfield[thingopnum] = 15;
-						if (Bstrcasecmp(&tempbuf[lasti],"owner") == 0) thingfield[thingopnum] = 16;
-						if (Bstrcasecmp(&tempbuf[lasti],"sectnum") == 0) thingfield[thingopnum] = 17;
-						if (Bstrcasecmp(&tempbuf[lasti],"statnum") == 0) thingfield[thingopnum] = 18;
-						if (Bstrcasecmp(&tempbuf[lasti],"lotag") == 0) thingfield[thingopnum] = 19;
-						if (Bstrcasecmp(&tempbuf[lasti],"hitag") == 0) thingfield[thingopnum] = 20;
-						if (Bstrcasecmp(&tempbuf[lasti],"extra") == 0) thingfield[thingopnum] = 21;
+                        if (Bstrcasecmp(&tempbuf[lasti],"x") == 0) thingfield[thingopnum] = 0;
+                        if (Bstrcasecmp(&tempbuf[lasti],"y") == 0) thingfield[thingopnum] = 1;
+                        if (Bstrcasecmp(&tempbuf[lasti],"z") == 0) thingfield[thingopnum] = 2;
+                        if (Bstrcasecmp(&tempbuf[lasti],"cstat") == 0) thingfield[thingopnum] = 3;
+                        if (Bstrcasecmp(&tempbuf[lasti],"shade") == 0) thingfield[thingopnum] = 4;
+                        if (Bstrcasecmp(&tempbuf[lasti],"pal") == 0) thingfield[thingopnum] = 5;
+                        if (Bstrcasecmp(&tempbuf[lasti],"clipdist") == 0) thingfield[thingopnum] = 6;
+                        if (Bstrcasecmp(&tempbuf[lasti],"xrepeat") == 0) thingfield[thingopnum] = 7;
+                        if (Bstrcasecmp(&tempbuf[lasti],"yrepeat") == 0) thingfield[thingopnum] = 8;
+                        if (Bstrcasecmp(&tempbuf[lasti],"xoffset") == 0) thingfield[thingopnum] = 9;
+                        if (Bstrcasecmp(&tempbuf[lasti],"yoffset") == 0) thingfield[thingopnum] = 10;
+                        if (Bstrcasecmp(&tempbuf[lasti],"picnum") == 0) thingfield[thingopnum] = 11;
+                        if (Bstrcasecmp(&tempbuf[lasti],"ang") == 0) thingfield[thingopnum] = 12;
+                        if (Bstrcasecmp(&tempbuf[lasti],"xvel") == 0) thingfield[thingopnum] = 13;
+                        if (Bstrcasecmp(&tempbuf[lasti],"yvel") == 0) thingfield[thingopnum] = 14;
+                        if (Bstrcasecmp(&tempbuf[lasti],"zvel") == 0) thingfield[thingopnum] = 15;
+                        if (Bstrcasecmp(&tempbuf[lasti],"owner") == 0) thingfield[thingopnum] = 16;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sectnum") == 0) thingfield[thingopnum] = 17;
+                        if (Bstrcasecmp(&tempbuf[lasti],"statnum") == 0) thingfield[thingopnum] = 18;
+                        if (Bstrcasecmp(&tempbuf[lasti],"lotag") == 0) thingfield[thingopnum] = 19;
+                        if (Bstrcasecmp(&tempbuf[lasti],"hitag") == 0) thingfield[thingopnum] = 20;
+                        if (Bstrcasecmp(&tempbuf[lasti],"extra") == 0) thingfield[thingopnum] = 21;
 
-						if ((tempbuf[k+1] >= 48) && (tempbuf[k+1] <= 57))
-							thingval[thingopnum] = atol(&tempbuf[k+1]);
-						else
-						{
-							for(l=0;l<numdefines;l++)
-								if (Bstrcasecmp(defineptr[l],&tempbuf[k+1]) == 0)
-									{ thingval[thingopnum] = defineval[l]; break; }
-						}
+                        if ((tempbuf[k+1] >= 48) && (tempbuf[k+1] <= 57))
+                            thingval[thingopnum] = atol(&tempbuf[k+1]);
+                        else
+                        {
+                            for(l=0;l<numdefines;l++)
+                                if (Bstrcasecmp(defineptr[l],&tempbuf[k+1]) == 0)
+                                    { thingval[thingopnum] = defineval[l]; break; }
+                        }
 
-						thingopnum++;
-					}
+                        thingopnum++;
+                    }
 
-					if ((texturelookupmode == 1) && (j == 1))
-					{
-						if ((tempbuf[lasti] >= 48) && (tempbuf[lasti] <= 57))
-							l = atol(&tempbuf[lasti]);
-						else
-						{
-							for(l=0;l<numdefines;l++)
-								if (Bstrcasecmp(defineptr[l],&tempbuf[lasti]) == 0)
-									{ l = defineval[l]; break; }
-						}
-						for(k=textnum-1;k>=0;k--) texturelookup[tempshort[k]] = l;
-					}
+                    if ((texturelookupmode == 1) && (j == 1))
+                    {
+                        if ((tempbuf[lasti] >= 48) && (tempbuf[lasti] <= 57))
+                            l = atol(&tempbuf[lasti]);
+                        else
+                        {
+                            for(l=0;l<numdefines;l++)
+                                if (Bstrcasecmp(defineptr[l],&tempbuf[lasti]) == 0)
+                                    { l = defineval[l]; break; }
+                        }
+                        for(k=textnum-1;k>=0;k--) texturelookup[tempshort[k]] = l;
+                    }
 
-					if (tagtypemode == 1)
-					{
-						for(k=lasti;k<i;k++) if (tempbuf[k] == '=') break;
-						tagop[tagopnum] = 0;
-						if (tempbuf[k-1] == '+') tagop[tagopnum] = 1;
-						if (tempbuf[k-1] == '-') tagop[tagopnum] = 2;
-						if (tempbuf[k-1] == '|') tagop[tagopnum] = 3;
-						if (tempbuf[k-1] == '&') tagop[tagopnum] = 4;
-						if (tempbuf[k-1] == '^') tagop[tagopnum] = 5;
-						if (tagop[tagopnum] != 0) tempbuf[k-1] = 0;
-														 else tempbuf[k] = 0;
+                    if (tagtypemode == 1)
+                    {
+                        for(k=lasti;k<i;k++) if (tempbuf[k] == '=') break;
+                        tagop[tagopnum] = 0;
+                        if (tempbuf[k-1] == '+') tagop[tagopnum] = 1;
+                        if (tempbuf[k-1] == '-') tagop[tagopnum] = 2;
+                        if (tempbuf[k-1] == '|') tagop[tagopnum] = 3;
+                        if (tempbuf[k-1] == '&') tagop[tagopnum] = 4;
+                        if (tempbuf[k-1] == '^') tagop[tagopnum] = 5;
+                        if (tagop[tagopnum] != 0) tempbuf[k-1] = 0;
+                                                         else tempbuf[k] = 0;
 
-							//Pick off first letter - is it f or b?
-						frontbackstat = 0;
-						if ((tempbuf[lasti] == 'b') || (tempbuf[lasti] == 'B')) frontbackstat = 1;
-						lasti++;
+                            //Pick off first letter - is it f or b?
+                        frontbackstat = 0;
+                        if ((tempbuf[lasti] == 'b') || (tempbuf[lasti] == 'B')) frontbackstat = 1;
+                        lasti++;
 
-						spritenumstat = 0;
-						if ((tempbuf[lasti] >= 48) && (tempbuf[lasti] <= 57))  //1 DIGIT ONLY!
-						{
-							spritenumstat = tempbuf[lasti]-48;
-							lasti++;
-						}
+                        spritenumstat = 0;
+                        if ((tempbuf[lasti] >= 48) && (tempbuf[lasti] <= 57))  //1 DIGIT ONLY!
+                        {
+                            spritenumstat = tempbuf[lasti]-48;
+                            lasti++;
+                        }
 
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.x") == 0) tagfield[tagopnum] = 0;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.y") == 0) tagfield[tagopnum] = 1;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.z") == 0) tagfield[tagopnum] = 2;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.cstat") == 0) tagfield[tagopnum] = 3;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.shade") == 0) tagfield[tagopnum] = 4;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.pal") == 0) tagfield[tagopnum] = 5;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.clipdist") == 0) tagfield[tagopnum] = 6;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.xrepeat") == 0) tagfield[tagopnum] = 7;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.yrepeat") == 0) tagfield[tagopnum] = 8;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.xoffset") == 0) tagfield[tagopnum] = 9;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.yoffset") == 0) tagfield[tagopnum] = 10;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.picnum") == 0) tagfield[tagopnum] = 11;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.ang") == 0) tagfield[tagopnum] = 12;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.xvel") == 0) tagfield[tagopnum] = 13;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.yvel") == 0) tagfield[tagopnum] = 14;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.zvel") == 0) tagfield[tagopnum] = 15;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.owner") == 0) tagfield[tagopnum] = 16;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.sectnum") == 0) tagfield[tagopnum] = 17;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.statnum") == 0) tagfield[tagopnum] = 18;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.lotag") == 0) tagfield[tagopnum] = 19;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.hitag") == 0) tagfield[tagopnum] = 20;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.extra") == 0) tagfield[tagopnum] = 21;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.x") == 0) tagfield[tagopnum] = 0;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.y") == 0) tagfield[tagopnum] = 1;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.z") == 0) tagfield[tagopnum] = 2;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.cstat") == 0) tagfield[tagopnum] = 3;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.shade") == 0) tagfield[tagopnum] = 4;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.pal") == 0) tagfield[tagopnum] = 5;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.clipdist") == 0) tagfield[tagopnum] = 6;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.xrepeat") == 0) tagfield[tagopnum] = 7;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.yrepeat") == 0) tagfield[tagopnum] = 8;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.xoffset") == 0) tagfield[tagopnum] = 9;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.yoffset") == 0) tagfield[tagopnum] = 10;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.picnum") == 0) tagfield[tagopnum] = 11;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.ang") == 0) tagfield[tagopnum] = 12;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.xvel") == 0) tagfield[tagopnum] = 13;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.yvel") == 0) tagfield[tagopnum] = 14;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.zvel") == 0) tagfield[tagopnum] = 15;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.owner") == 0) tagfield[tagopnum] = 16;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.sectnum") == 0) tagfield[tagopnum] = 17;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.statnum") == 0) tagfield[tagopnum] = 18;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.lotag") == 0) tagfield[tagopnum] = 19;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.hitag") == 0) tagfield[tagopnum] = 20;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.extra") == 0) tagfield[tagopnum] = 21;
 
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.wallptr") == 0) tagfield[tagopnum] = 32;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.wallnum") == 0) tagfield[tagopnum] = 33;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingpicnum") == 0) tagfield[tagopnum] = 34;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorpicnum") == 0) tagfield[tagopnum] = 35;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingheinum") == 0) tagfield[tagopnum] = 36;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorheinum") == 0) tagfield[tagopnum] = 37;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingz") == 0) tagfield[tagopnum] = 38;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorz") == 0) tagfield[tagopnum] = 39;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingshade") == 0) tagfield[tagopnum] = 40;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorshade") == 0) tagfield[tagopnum] = 41;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingxpanning") == 0) tagfield[tagopnum] = 42;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorxpanning") == 0) tagfield[tagopnum] = 43;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingypanning") == 0) tagfield[tagopnum] = 44;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorypanning") == 0) tagfield[tagopnum] = 45;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingstat") == 0) tagfield[tagopnum] = 46;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorstat") == 0) tagfield[tagopnum] = 47;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingpal") == 0) tagfield[tagopnum] = 48;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorpal") == 0) tagfield[tagopnum] = 49;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.visibility") == 0) tagfield[tagopnum] = 50;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.lotag") == 0) tagfield[tagopnum] = 51;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.hitag") == 0) tagfield[tagopnum] = 52;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.extra") == 0) tagfield[tagopnum] = 53;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.wallptr") == 0) tagfield[tagopnum] = 32;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.wallnum") == 0) tagfield[tagopnum] = 33;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingpicnum") == 0) tagfield[tagopnum] = 34;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorpicnum") == 0) tagfield[tagopnum] = 35;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingheinum") == 0) tagfield[tagopnum] = 36;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorheinum") == 0) tagfield[tagopnum] = 37;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingz") == 0) tagfield[tagopnum] = 38;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorz") == 0) tagfield[tagopnum] = 39;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingshade") == 0) tagfield[tagopnum] = 40;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorshade") == 0) tagfield[tagopnum] = 41;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingxpanning") == 0) tagfield[tagopnum] = 42;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorxpanning") == 0) tagfield[tagopnum] = 43;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingypanning") == 0) tagfield[tagopnum] = 44;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorypanning") == 0) tagfield[tagopnum] = 45;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingstat") == 0) tagfield[tagopnum] = 46;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorstat") == 0) tagfield[tagopnum] = 47;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingpal") == 0) tagfield[tagopnum] = 48;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorpal") == 0) tagfield[tagopnum] = 49;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.visibility") == 0) tagfield[tagopnum] = 50;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.lotag") == 0) tagfield[tagopnum] = 51;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.hitag") == 0) tagfield[tagopnum] = 52;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.extra") == 0) tagfield[tagopnum] = 53;
 
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.x") == 0) tagfield[tagopnum] = 64;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.y") == 0) tagfield[tagopnum] = 65;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.point2") == 0) tagfield[tagopnum] = 66;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.nextsector") == 0) tagfield[tagopnum] = 67;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.nextwall") == 0) tagfield[tagopnum] = 68;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.picnum") == 0) tagfield[tagopnum] = 69;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.overpicnum") == 0) tagfield[tagopnum] = 70;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.shade") == 0) tagfield[tagopnum] = 71;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.pal") == 0) tagfield[tagopnum] = 72;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.cstat") == 0) tagfield[tagopnum] = 73;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.xrepeat") == 0) tagfield[tagopnum] = 74;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.yrepeat") == 0) tagfield[tagopnum] = 75;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.xpanning") == 0) tagfield[tagopnum] = 76;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.ypanning") == 0) tagfield[tagopnum] = 77;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.lotag") == 0) tagfield[tagopnum] = 78;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.hitag") == 0) tagfield[tagopnum] = 79;
-						if (Bstrcasecmp(&tempbuf[lasti],"wall.extra") == 0) tagfield[tagopnum] = 80;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.x") == 0) tagfield[tagopnum] = 64;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.y") == 0) tagfield[tagopnum] = 65;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.point2") == 0) tagfield[tagopnum] = 66;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.nextsector") == 0) tagfield[tagopnum] = 67;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.nextwall") == 0) tagfield[tagopnum] = 68;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.picnum") == 0) tagfield[tagopnum] = 69;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.overpicnum") == 0) tagfield[tagopnum] = 70;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.shade") == 0) tagfield[tagopnum] = 71;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.pal") == 0) tagfield[tagopnum] = 72;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.cstat") == 0) tagfield[tagopnum] = 73;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.xrepeat") == 0) tagfield[tagopnum] = 74;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.yrepeat") == 0) tagfield[tagopnum] = 75;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.xpanning") == 0) tagfield[tagopnum] = 76;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.ypanning") == 0) tagfield[tagopnum] = 77;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.lotag") == 0) tagfield[tagopnum] = 78;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.hitag") == 0) tagfield[tagopnum] = 79;
+                        if (Bstrcasecmp(&tempbuf[lasti],"wall.extra") == 0) tagfield[tagopnum] = 80;
 
-						tagfield[tagopnum] += (frontbackstat<<7) + (spritenumstat<<8);
+                        tagfield[tagopnum] += (frontbackstat<<7) + (spritenumstat<<8);
 
-						if ((tempbuf[k+1] >= 48) && (tempbuf[k+1] <= 57))
-							tagval[tagopnum] = atol(&tempbuf[k+1]);
-						else if (Bstrcasecmp("tag",&tempbuf[k+1]) == 0)
-							tagval[tagopnum] = INT32_MIN;
-						else
-						{
-							for(l=0;l<numdefines;l++)
-								if (Bstrcasecmp(defineptr[l],&tempbuf[k+1]) == 0)
-									{ tagval[tagopnum] = defineval[l]; break; }
-						}
+                        if ((tempbuf[k+1] >= 48) && (tempbuf[k+1] <= 57))
+                            tagval[tagopnum] = atol(&tempbuf[k+1]);
+                        else if (Bstrcasecmp("tag",&tempbuf[k+1]) == 0)
+                            tagval[tagopnum] = INT32_MIN;
+                        else
+                        {
+                            for(l=0;l<numdefines;l++)
+                                if (Bstrcasecmp(defineptr[l],&tempbuf[k+1]) == 0)
+                                    { tagval[tagopnum] = defineval[l]; break; }
+                        }
 
-						tagopnum++;
-					}
+                        tagopnum++;
+                    }
 
-					if (sectypemode == 1)
-					{
-						for(k=lasti;k<i;k++) if (tempbuf[k] == '=') break;
-						secop[secopnum] = 0;
-						if (tempbuf[k-1] == '+') secop[secopnum] = 1;
-						if (tempbuf[k-1] == '-') secop[secopnum] = 2;
-						if (tempbuf[k-1] == '|') secop[secopnum] = 3;
-						if (tempbuf[k-1] == '&') secop[secopnum] = 4;
-						if (tempbuf[k-1] == '^') secop[secopnum] = 5;
-						if (secop[secopnum] != 0) tempbuf[k-1] = 0;
-													 else tempbuf[k] = 0;
+                    if (sectypemode == 1)
+                    {
+                        for(k=lasti;k<i;k++) if (tempbuf[k] == '=') break;
+                        secop[secopnum] = 0;
+                        if (tempbuf[k-1] == '+') secop[secopnum] = 1;
+                        if (tempbuf[k-1] == '-') secop[secopnum] = 2;
+                        if (tempbuf[k-1] == '|') secop[secopnum] = 3;
+                        if (tempbuf[k-1] == '&') secop[secopnum] = 4;
+                        if (tempbuf[k-1] == '^') secop[secopnum] = 5;
+                        if (secop[secopnum] != 0) tempbuf[k-1] = 0;
+                                                     else tempbuf[k] = 0;
 
-						spritenumstat = 0;
-						if ((tempbuf[lasti] >= 48) && (tempbuf[lasti] <= 57))  //1 DIGIT ONLY!
-						{
-							spritenumstat = tempbuf[lasti]-48;
-							lasti++;
-						}
+                        spritenumstat = 0;
+                        if ((tempbuf[lasti] >= 48) && (tempbuf[lasti] <= 57))  //1 DIGIT ONLY!
+                        {
+                            spritenumstat = tempbuf[lasti]-48;
+                            lasti++;
+                        }
 
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.x") == 0) secfield[secopnum] = 0;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.y") == 0) secfield[secopnum] = 1;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.z") == 0) secfield[secopnum] = 2;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.cstat") == 0) secfield[secopnum] = 3;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.shade") == 0) secfield[secopnum] = 4;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.pal") == 0) secfield[secopnum] = 5;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.clipdist") == 0) secfield[secopnum] = 6;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.xrepeat") == 0) secfield[secopnum] = 7;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.yrepeat") == 0) secfield[secopnum] = 8;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.xoffset") == 0) secfield[secopnum] = 9;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.yoffset") == 0) secfield[secopnum] = 10;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.picnum") == 0) secfield[secopnum] = 11;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.ang") == 0) secfield[secopnum] = 12;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.xvel") == 0) secfield[secopnum] = 13;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.yvel") == 0) secfield[secopnum] = 14;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.zvel") == 0) secfield[secopnum] = 15;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.owner") == 0) secfield[secopnum] = 16;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.sectnum") == 0) secfield[secopnum] = 17;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.statnum") == 0) secfield[secopnum] = 18;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.lotag") == 0) secfield[secopnum] = 19;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.hitag") == 0) secfield[secopnum] = 20;
-						if (Bstrcasecmp(&tempbuf[lasti],"sprite.extra") == 0) secfield[secopnum] = 21;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.x") == 0) secfield[secopnum] = 0;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.y") == 0) secfield[secopnum] = 1;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.z") == 0) secfield[secopnum] = 2;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.cstat") == 0) secfield[secopnum] = 3;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.shade") == 0) secfield[secopnum] = 4;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.pal") == 0) secfield[secopnum] = 5;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.clipdist") == 0) secfield[secopnum] = 6;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.xrepeat") == 0) secfield[secopnum] = 7;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.yrepeat") == 0) secfield[secopnum] = 8;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.xoffset") == 0) secfield[secopnum] = 9;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.yoffset") == 0) secfield[secopnum] = 10;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.picnum") == 0) secfield[secopnum] = 11;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.ang") == 0) secfield[secopnum] = 12;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.xvel") == 0) secfield[secopnum] = 13;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.yvel") == 0) secfield[secopnum] = 14;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.zvel") == 0) secfield[secopnum] = 15;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.owner") == 0) secfield[secopnum] = 16;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.sectnum") == 0) secfield[secopnum] = 17;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.statnum") == 0) secfield[secopnum] = 18;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.lotag") == 0) secfield[secopnum] = 19;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.hitag") == 0) secfield[secopnum] = 20;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sprite.extra") == 0) secfield[secopnum] = 21;
 
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.wallptr") == 0) secfield[secopnum] = 32;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.wallnum") == 0) secfield[secopnum] = 33;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingpicnum") == 0) secfield[secopnum] = 34;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorpicnum") == 0) secfield[secopnum] = 35;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingheinum") == 0) secfield[secopnum] = 36;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorheinum") == 0) secfield[secopnum] = 37;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingz") == 0) secfield[secopnum] = 38;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorz") == 0) secfield[secopnum] = 39;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingshade") == 0) secfield[secopnum] = 40;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorshade") == 0) secfield[secopnum] = 41;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingxpanning") == 0) secfield[secopnum] = 42;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorxpanning") == 0) secfield[secopnum] = 43;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingypanning") == 0) secfield[secopnum] = 44;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorypanning") == 0) secfield[secopnum] = 45;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingstat") == 0) secfield[secopnum] = 46;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorstat") == 0) secfield[secopnum] = 47;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingpal") == 0) secfield[secopnum] = 48;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.floorpal") == 0) secfield[secopnum] = 49;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.visibility") == 0) secfield[secopnum] = 50;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.lotag") == 0) secfield[secopnum] = 51;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.hitag") == 0) secfield[secopnum] = 52;
-						if (Bstrcasecmp(&tempbuf[lasti],"sector.extra") == 0) secfield[secopnum] = 53;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.wallptr") == 0) secfield[secopnum] = 32;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.wallnum") == 0) secfield[secopnum] = 33;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingpicnum") == 0) secfield[secopnum] = 34;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorpicnum") == 0) secfield[secopnum] = 35;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingheinum") == 0) secfield[secopnum] = 36;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorheinum") == 0) secfield[secopnum] = 37;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingz") == 0) secfield[secopnum] = 38;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorz") == 0) secfield[secopnum] = 39;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingshade") == 0) secfield[secopnum] = 40;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorshade") == 0) secfield[secopnum] = 41;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingxpanning") == 0) secfield[secopnum] = 42;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorxpanning") == 0) secfield[secopnum] = 43;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingypanning") == 0) secfield[secopnum] = 44;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorypanning") == 0) secfield[secopnum] = 45;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingstat") == 0) secfield[secopnum] = 46;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorstat") == 0) secfield[secopnum] = 47;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.ceilingpal") == 0) secfield[secopnum] = 48;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.floorpal") == 0) secfield[secopnum] = 49;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.visibility") == 0) secfield[secopnum] = 50;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.lotag") == 0) secfield[secopnum] = 51;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.hitag") == 0) secfield[secopnum] = 52;
+                        if (Bstrcasecmp(&tempbuf[lasti],"sector.extra") == 0) secfield[secopnum] = 53;
 
-						secfield[secopnum] += (spritenumstat<<8);
+                        secfield[secopnum] += (spritenumstat<<8);
 
-						if ((tempbuf[k+1] >= 48) && (tempbuf[k+1] <= 57))
-							secval[secopnum] = atol(&tempbuf[k+1]);
-						else if (Bstrcasecmp("tag",&tempbuf[k+1]) == 0)
-							secval[secopnum] = INT32_MIN;
-						else
-						{
-							for(l=0;l<numdefines;l++)
-								if (Bstrcasecmp(defineptr[l],&tempbuf[k+1]) == 0)
-									{ secval[secopnum] = defineval[l]; break; }
-						}
+                        if ((tempbuf[k+1] >= 48) && (tempbuf[k+1] <= 57))
+                            secval[secopnum] = atol(&tempbuf[k+1]);
+                        else if (Bstrcasecmp("tag",&tempbuf[k+1]) == 0)
+                            secval[secopnum] = INT32_MIN;
+                        else
+                        {
+                            for(l=0;l<numdefines;l++)
+                                if (Bstrcasecmp(defineptr[l],&tempbuf[k+1]) == 0)
+                                    { secval[secopnum] = defineval[l]; break; }
+                        }
 
-						secopnum++;
-					}
+                        secopnum++;
+                    }
 
-				}
-				if (breakout == 1) break;
-				lasti = i+1; j++;
-			}
-			i++;
-		}
-	}
-	thingoff[numthings] = thingopnum;
-	tagoff[numtags] = tagopnum;
-	secoff[numsecs] = secopnum;
-	close(filhandle);
+                }
+                if (breakout == 1) break;
+                lasti = i+1; j++;
+            }
+            i++;
+        }
+    }
+    thingoff[numthings] = thingopnum;
+    tagoff[numtags] = tagopnum;
+    secoff[numsecs] = secopnum;
+    close(filhandle);
 }
 
 int getspritefield(int i, int fieldnum)
 {
-	switch(fieldnum)
-	{
-		case 0: return((int)sprite[i].x);
-		case 1: return((int)sprite[i].y);
-		case 2: return((int)sprite[i].z);
-		case 3: return((int)sprite[i].cstat);
-		case 4: return((int)sprite[i].shade);
-		case 5: return((int)sprite[i].pal);
-		case 6: return((int)sprite[i].clipdist);
-		case 7: return((int)sprite[i].xrepeat);
-		case 8: return((int)sprite[i].yrepeat);
-		case 9: return((int)sprite[i].xoffset);
-		case 10: return((int)sprite[i].yoffset);
-		case 11: return((int)sprite[i].picnum);
-		case 12: return((int)sprite[i].ang);
-		case 13: return((int)sprite[i].xvel);
-		case 14: return((int)sprite[i].yvel);
-		case 15: return((int)sprite[i].zvel);
-		case 16: return((int)sprite[i].owner);
-		case 17: return((int)sprite[i].sectnum);
-		case 18: return((int)sprite[i].statnum);
-		case 19: return((int)sprite[i].lotag);
-		case 20: return((int)sprite[i].hitag);
-		case 21: return((int)sprite[i].extra);
-	}
-	return(0);
+    switch(fieldnum)
+    {
+        case 0: return((int)sprite[i].x);
+        case 1: return((int)sprite[i].y);
+        case 2: return((int)sprite[i].z);
+        case 3: return((int)sprite[i].cstat);
+        case 4: return((int)sprite[i].shade);
+        case 5: return((int)sprite[i].pal);
+        case 6: return((int)sprite[i].clipdist);
+        case 7: return((int)sprite[i].xrepeat);
+        case 8: return((int)sprite[i].yrepeat);
+        case 9: return((int)sprite[i].xoffset);
+        case 10: return((int)sprite[i].yoffset);
+        case 11: return((int)sprite[i].picnum);
+        case 12: return((int)sprite[i].ang);
+        case 13: return((int)sprite[i].xvel);
+        case 14: return((int)sprite[i].yvel);
+        case 15: return((int)sprite[i].zvel);
+        case 16: return((int)sprite[i].owner);
+        case 17: return((int)sprite[i].sectnum);
+        case 18: return((int)sprite[i].statnum);
+        case 19: return((int)sprite[i].lotag);
+        case 20: return((int)sprite[i].hitag);
+        case 21: return((int)sprite[i].extra);
+    }
+    return(0);
 }
 
 void setspritefield(int i, int fieldnum, int newval)
 {
-	switch(fieldnum)
-	{
-		case 0: sprite[i].x = newval; break;
-		case 1: sprite[i].y = newval; break;
-		case 2: sprite[i].z = newval; break;
-		case 3: sprite[i].cstat = newval; break;
-		case 4: sprite[i].shade = newval; break;
-		case 5: sprite[i].pal = newval; break;
-		case 6: sprite[i].clipdist = newval; break;
-		case 7: sprite[i].xrepeat = newval; break;
-		case 8: sprite[i].yrepeat = newval; break;
-		case 9: sprite[i].xoffset = newval; break;
-		case 10: sprite[i].yoffset = newval; break;
-		case 11: sprite[i].picnum = newval; break;
-		case 12: sprite[i].ang = newval; break;
-		case 13: sprite[i].xvel = newval; break;
-		case 14: sprite[i].yvel = newval; break;
-		case 15: sprite[i].zvel = newval; break;
-		case 16: sprite[i].owner = newval; break;
-		case 17: sprite[i].sectnum = newval; break;
-		case 18: sprite[i].statnum = newval; break;
-		case 19: sprite[i].lotag = newval; break;
-		case 20: sprite[i].hitag = newval; break;
-		case 21: sprite[i].extra = newval; break;
-	}
+    switch(fieldnum)
+    {
+        case 0: sprite[i].x = newval; break;
+        case 1: sprite[i].y = newval; break;
+        case 2: sprite[i].z = newval; break;
+        case 3: sprite[i].cstat = newval; break;
+        case 4: sprite[i].shade = newval; break;
+        case 5: sprite[i].pal = newval; break;
+        case 6: sprite[i].clipdist = newval; break;
+        case 7: sprite[i].xrepeat = newval; break;
+        case 8: sprite[i].yrepeat = newval; break;
+        case 9: sprite[i].xoffset = newval; break;
+        case 10: sprite[i].yoffset = newval; break;
+        case 11: sprite[i].picnum = newval; break;
+        case 12: sprite[i].ang = newval; break;
+        case 13: sprite[i].xvel = newval; break;
+        case 14: sprite[i].yvel = newval; break;
+        case 15: sprite[i].zvel = newval; break;
+        case 16: sprite[i].owner = newval; break;
+        case 17: sprite[i].sectnum = newval; break;
+        case 18: sprite[i].statnum = newval; break;
+        case 19: sprite[i].lotag = newval; break;
+        case 20: sprite[i].hitag = newval; break;
+        case 21: sprite[i].extra = newval; break;
+    }
 }
 
 int getwallfield(int i, int fieldnum)
 {
-	switch(fieldnum)
-	{
-		case 64: return((int)wall[i].x);
-		case 65: return((int)wall[i].y);
-		case 66: return((int)wall[i].point2);
-		case 67: return((int)wall[i].nextsector);
-		case 68: return((int)wall[i].nextwall);
-		case 69: return((int)wall[i].picnum);
-		case 70: return((int)wall[i].overpicnum);
-		case 71: return((int)wall[i].shade);
-		case 72: return((int)wall[i].pal);
-		case 73: return((int)wall[i].cstat);
-		case 74: return((int)wall[i].xrepeat);
-		case 75: return((int)wall[i].yrepeat);
-		case 76: return((int)wall[i].xpanning);
-		case 77: return((int)wall[i].ypanning);
-		case 78: return((int)wall[i].lotag);
-		case 79: return((int)wall[i].hitag);
-		case 80: return((int)wall[i].extra);
-	}
-	return(0);
+    switch(fieldnum)
+    {
+        case 64: return((int)wall[i].x);
+        case 65: return((int)wall[i].y);
+        case 66: return((int)wall[i].point2);
+        case 67: return((int)wall[i].nextsector);
+        case 68: return((int)wall[i].nextwall);
+        case 69: return((int)wall[i].picnum);
+        case 70: return((int)wall[i].overpicnum);
+        case 71: return((int)wall[i].shade);
+        case 72: return((int)wall[i].pal);
+        case 73: return((int)wall[i].cstat);
+        case 74: return((int)wall[i].xrepeat);
+        case 75: return((int)wall[i].yrepeat);
+        case 76: return((int)wall[i].xpanning);
+        case 77: return((int)wall[i].ypanning);
+        case 78: return((int)wall[i].lotag);
+        case 79: return((int)wall[i].hitag);
+        case 80: return((int)wall[i].extra);
+    }
+    return(0);
 }
 
 void setwallfield(int i, int fieldnum, int newval)
 {
-	switch(fieldnum)
-	{
-		case 64: wall[i].x = newval; break;
-		case 65: wall[i].y = newval; break;
-		case 66: wall[i].point2 = newval; break;
-		case 67: wall[i].nextsector = newval; break;
-		case 68: wall[i].nextwall = newval; break;
-		case 69: wall[i].picnum = newval; break;
-		case 70: wall[i].overpicnum = newval; break;
-		case 71: wall[i].shade = newval; break;
-		case 72: wall[i].pal = newval; break;
-		case 73: wall[i].cstat = newval; break;
-		case 74: wall[i].xrepeat = newval; break;
-		case 75: wall[i].yrepeat = newval; break;
-		case 76: wall[i].xpanning = newval; break;
-		case 77: wall[i].ypanning = newval; break;
-		case 78: wall[i].lotag = newval; break;
-		case 79: wall[i].hitag = newval; break;
-		case 80: wall[i].extra = newval; break;
-	}
+    switch(fieldnum)
+    {
+        case 64: wall[i].x = newval; break;
+        case 65: wall[i].y = newval; break;
+        case 66: wall[i].point2 = newval; break;
+        case 67: wall[i].nextsector = newval; break;
+        case 68: wall[i].nextwall = newval; break;
+        case 69: wall[i].picnum = newval; break;
+        case 70: wall[i].overpicnum = newval; break;
+        case 71: wall[i].shade = newval; break;
+        case 72: wall[i].pal = newval; break;
+        case 73: wall[i].cstat = newval; break;
+        case 74: wall[i].xrepeat = newval; break;
+        case 75: wall[i].yrepeat = newval; break;
+        case 76: wall[i].xpanning = newval; break;
+        case 77: wall[i].ypanning = newval; break;
+        case 78: wall[i].lotag = newval; break;
+        case 79: wall[i].hitag = newval; break;
+        case 80: wall[i].extra = newval; break;
+    }
 }
 
 int getsectorfield(int i, int fieldnum)
 {
-	switch(fieldnum)
-	{
-		case 32: return((int)sector[i].wallptr);
-		case 33: return((int)sector[i].wallnum);
-		case 34: return((int)sector[i].ceilingpicnum);
-		case 35: return((int)sector[i].floorpicnum);
-		case 36: return((int)sector[i].ceilingheinum);
-		case 37: return((int)sector[i].floorheinum);
-		case 38: return((int)sector[i].ceilingz);
-		case 39: return((int)sector[i].floorz);
-		case 40: return((int)sector[i].ceilingshade);
-		case 41: return((int)sector[i].floorshade);
-		case 42: return((int)sector[i].ceilingxpanning);
-		case 43: return((int)sector[i].floorxpanning);
-		case 44: return((int)sector[i].ceilingypanning);
-		case 45: return((int)sector[i].floorypanning);
-		case 46: return((int)sector[i].ceilingstat);
-		case 47: return((int)sector[i].floorstat);
-		case 48: return((int)sector[i].ceilingpal);
-		case 49: return((int)sector[i].floorpal);
-		case 50: return((int)sector[i].visibility);
-		case 51: return((int)sector[i].lotag);
-		case 52: return((int)sector[i].hitag);
-		case 53: return((int)sector[i].extra);
-	}
-	return(0);
+    switch(fieldnum)
+    {
+        case 32: return((int)sector[i].wallptr);
+        case 33: return((int)sector[i].wallnum);
+        case 34: return((int)sector[i].ceilingpicnum);
+        case 35: return((int)sector[i].floorpicnum);
+        case 36: return((int)sector[i].ceilingheinum);
+        case 37: return((int)sector[i].floorheinum);
+        case 38: return((int)sector[i].ceilingz);
+        case 39: return((int)sector[i].floorz);
+        case 40: return((int)sector[i].ceilingshade);
+        case 41: return((int)sector[i].floorshade);
+        case 42: return((int)sector[i].ceilingxpanning);
+        case 43: return((int)sector[i].floorxpanning);
+        case 44: return((int)sector[i].ceilingypanning);
+        case 45: return((int)sector[i].floorypanning);
+        case 46: return((int)sector[i].ceilingstat);
+        case 47: return((int)sector[i].floorstat);
+        case 48: return((int)sector[i].ceilingpal);
+        case 49: return((int)sector[i].floorpal);
+        case 50: return((int)sector[i].visibility);
+        case 51: return((int)sector[i].lotag);
+        case 52: return((int)sector[i].hitag);
+        case 53: return((int)sector[i].extra);
+    }
+    return(0);
 }
 
 void setsectorfield(int i, int fieldnum, int newval)
 {
-	switch(fieldnum)
-	{
-		case 32: sector[i].wallptr = newval; break;
-		case 33: sector[i].wallnum = newval; break;
-		case 34: sector[i].ceilingpicnum = newval; break;
-		case 35: sector[i].floorpicnum = newval; break;
-		case 36: sector[i].ceilingheinum = newval; break;
-		case 37: sector[i].floorheinum = newval; break;
-		case 38: sector[i].ceilingz = newval; break;
-		case 39: sector[i].floorz = newval; break;
-		case 40: sector[i].ceilingshade = newval; break;
-		case 41: sector[i].floorshade = newval; break;
-		case 42: sector[i].ceilingxpanning = newval; break;
-		case 43: sector[i].floorxpanning = newval; break;
-		case 44: sector[i].ceilingypanning = newval; break;
-		case 45: sector[i].floorypanning = newval; break;
-		case 46: sector[i].ceilingstat = newval; break;
-		case 47: sector[i].floorstat = newval; break;
-		case 48: sector[i].ceilingpal = newval; break;
-		case 49: sector[i].floorpal = newval; break;
-		case 50: sector[i].visibility = newval; break;
-		case 51: sector[i].lotag = newval; break;
-		case 52: sector[i].hitag = newval; break;
-		case 53: sector[i].extra = newval; break;
-	}
+    switch(fieldnum)
+    {
+        case 32: sector[i].wallptr = newval; break;
+        case 33: sector[i].wallnum = newval; break;
+        case 34: sector[i].ceilingpicnum = newval; break;
+        case 35: sector[i].floorpicnum = newval; break;
+        case 36: sector[i].ceilingheinum = newval; break;
+        case 37: sector[i].floorheinum = newval; break;
+        case 38: sector[i].ceilingz = newval; break;
+        case 39: sector[i].floorz = newval; break;
+        case 40: sector[i].ceilingshade = newval; break;
+        case 41: sector[i].floorshade = newval; break;
+        case 42: sector[i].ceilingxpanning = newval; break;
+        case 43: sector[i].floorxpanning = newval; break;
+        case 44: sector[i].ceilingypanning = newval; break;
+        case 45: sector[i].floorypanning = newval; break;
+        case 46: sector[i].ceilingstat = newval; break;
+        case 47: sector[i].floorstat = newval; break;
+        case 48: sector[i].ceilingpal = newval; break;
+        case 49: sector[i].floorpal = newval; break;
+        case 50: sector[i].visibility = newval; break;
+        case 51: sector[i].lotag = newval; break;
+        case 52: sector[i].hitag = newval; break;
+        case 53: sector[i].extra = newval; break;
+    }
 }
 
 int getwadindex(char *nam)
 {
-	int i, j;
+    int i, j;
 
-	i = 0;
-	for(j=2048;j>0;j>>=1)
-		if (i+j < inumwads)
-			if (Bstrcasecmp(iwadata[slist[i+j]],nam) <= 0) i += j;
-	if (Bstrcasecmp(iwadata[slist[i]],nam) == 0) return(slist[i]);
-	return(-1);
+    i = 0;
+    for(j=2048;j>0;j>>=1)
+        if (i+j < inumwads)
+            if (Bstrcasecmp(iwadata[slist[i+j]],nam) <= 0) i += j;
+    if (Bstrcasecmp(iwadata[slist[i]],nam) == 0) return(slist[i]);
+    return(-1);
 }
 
 int main(int argc, char **argv)
 {
-	char argstring[5][80];
-	char iwadfil[80], pwadfil[80], doommap[16], buildmap[16], picstr[16];
-	int w, numtexts, startnumtexts, danumtexts, numpnames;
-	int x, y, z, zz, zzz, zzx, zx, cx, cy, gap, i, j, k, l, offs;
-	int dnumpoints = 0, dnumlines = 0, dnumsides, dnumsectors, dnumthings;
-	int minx, maxx, miny, maxy, numwalls, wadtype;
-	int startnumwalls, l1, l2, startpoint2;
-	int fil, ifil, pfil, x1, y1, x2, y2, startwall, endwall;
-	int mapversion, posx, posy, posz, boardwadindex;
-	short ang, cursectnum;
+    char argstring[5][80];
+    char iwadfil[80], pwadfil[80], doommap[16], buildmap[16], picstr[16];
+    int w, numtexts, startnumtexts, danumtexts, numpnames;
+    int x, y, z, zz, zzz, zzx, zx, cx, cy, gap, i, j, k, l, offs;
+    int dnumpoints = 0, dnumlines = 0, dnumsides, dnumsectors, dnumthings;
+    int minx, maxx, miny, maxy, numwalls, wadtype;
+    int startnumwalls, l1, l2, startpoint2;
+    int fil, ifil, pfil, x1, y1, x2, y2, startwall, endwall;
+    int mapversion, posx, posy, posz, boardwadindex;
+    short ang, cursectnum;
 
-	printf("Wad2Map!                                       Copyright 1995 by Ken Silverman\n");
+    printf("Wad2Map!                                       Copyright 1995 by Ken Silverman\n");
 
-	if ((argc < 3) || (argc > 5))
-	{
-		printf("Command line parameters: Wad2Map (PWADName) IWADName MapName (ScriptName)\n");
-		printf("   Ex #1: wad2map c:\\doom\\doom.wad e1m1\n");
-		printf("   Ex #2: wad2map c:\\doom\\doom.wad e1m1 kenbuild.txt\n");
-		printf("   Ex #3: wad2map c:\\doom\\mypwad.wad c:\\doom\\doom.wad e1m1\n");
-		printf("   Ex #4: wad2map c:\\doom\\mypwad.wad c:\\doom\\doom.wad e1m1 kenbuild.txt\n");
-		exit(0);
-	}
+    if ((argc < 3) || (argc > 5))
+    {
+        printf("Command line parameters: Wad2Map (PWADName) IWADName MapName (ScriptName)\n");
+        printf("   Ex #1: wad2map c:\\doom\\doom.wad e1m1\n");
+        printf("   Ex #2: wad2map c:\\doom\\doom.wad e1m1 kenbuild.txt\n");
+        printf("   Ex #3: wad2map c:\\doom\\mypwad.wad c:\\doom\\doom.wad e1m1\n");
+        printf("   Ex #4: wad2map c:\\doom\\mypwad.wad c:\\doom\\doom.wad e1m1 kenbuild.txt\n");
+        exit(0);
+    }
 
-	for(i=1;i<argc;i++) strcpy(argstring[i],argv[i]);
+    for(i=1;i<argc;i++) strcpy(argstring[i],argv[i]);
 
-	strcpy(iwadfil,argstring[1]);     //"c:\games\doom\doom.wad"
-	if (strchr(iwadfil,'.') == 0) strcat(iwadfil,".wad");
-	if ((ifil = Bopen(iwadfil,BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
-		{ printf("Could not find %s\n",iwadfil); exit(0); }
+    strcpy(iwadfil,argstring[1]);     //"c:\games\doom\doom.wad"
+    if (strchr(iwadfil,'.') == 0) strcat(iwadfil,".wad");
+    if ((ifil = Bopen(iwadfil,BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
+        { printf("Could not find %s\n",iwadfil); exit(0); }
 
-	Bread(ifil,&wadtype,4);
-	if (wadtype == 0x44415749) wadtype = 0;       //IWAD
-	else if (wadtype == 0x44415750) wadtype = 1;  //PWAD
-	else { Bclose(ifil); printf("Invalid WAD header\n"); exit(0); }
+    Bread(ifil,&wadtype,4);
+    if (wadtype == 0x44415749) wadtype = 0;       //IWAD
+    else if (wadtype == 0x44415750) wadtype = 1;  //PWAD
+    else { Bclose(ifil); printf("Invalid WAD header\n"); exit(0); }
 
-	strcpy(pwadfil,iwadfil); pfil = ifil;
-	if (wadtype == 1)
-	{
-		strcpy(iwadfil,argstring[2]);
-		if (strchr(iwadfil,'.') == 0) strcat(iwadfil,".wad");
-		if ((ifil = Bopen(iwadfil,BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
-			{ Bclose(pfil); printf("Could not find %s\n",iwadfil); exit(0); }
+    strcpy(pwadfil,iwadfil); pfil = ifil;
+    if (wadtype == 1)
+    {
+        strcpy(iwadfil,argstring[2]);
+        if (strchr(iwadfil,'.') == 0) strcat(iwadfil,".wad");
+        if ((ifil = Bopen(iwadfil,BO_BINARY|BO_RDONLY,BS_IREAD)) == -1)
+            { Bclose(pfil); printf("Could not find %s\n",iwadfil); exit(0); }
 
-		Bread(ifil,&wadtype,4);
-		if (wadtype != 0x44415749)        //!= IWAD
-		{
-			Bclose(ifil); Bclose(pfil);
-			printf("Wad a' you think I am?  That ain't no IWAD!\n");
-			exit(0);
-		}
+        Bread(ifil,&wadtype,4);
+        if (wadtype != 0x44415749)        //!= IWAD
+        {
+            Bclose(ifil); Bclose(pfil);
+            printf("Wad a' you think I am?  That ain't no IWAD!\n");
+            exit(0);
+        }
 
-		strcpy(doommap,argstring[3]);     //"E1M1"
-		if (strchr(doommap,'.') != 0) *strchr(doommap,'.') = 0;
-		scriptname[0] = 0;
-		if (argc == 5)
-		{
-			strcpy(scriptname,argstring[4]);
-			if (strchr(scriptname,'.') == 0) strcat(scriptname,".txt");
-		}
-	}
-	else
-	{
-		strcpy(doommap,argstring[2]);     //"E1M1"
-		if (strchr(doommap,'.') != 0) *strchr(doommap,'.') = 0;
-		scriptname[0] = 0;
-		if (argc == 4)
-		{
-			strcpy(scriptname,argstring[3]);
-			if (strchr(scriptname,'.') == 0) strcat(scriptname,".txt");
-		}
-	}
+        strcpy(doommap,argstring[3]);     //"E1M1"
+        if (strchr(doommap,'.') != 0) *strchr(doommap,'.') = 0;
+        scriptname[0] = 0;
+        if (argc == 5)
+        {
+            strcpy(scriptname,argstring[4]);
+            if (strchr(scriptname,'.') == 0) strcat(scriptname,".txt");
+        }
+    }
+    else
+    {
+        strcpy(doommap,argstring[2]);     //"E1M1"
+        if (strchr(doommap,'.') != 0) *strchr(doommap,'.') = 0;
+        scriptname[0] = 0;
+        if (argc == 4)
+        {
+            strcpy(scriptname,argstring[3]);
+            if (strchr(scriptname,'.') == 0) strcat(scriptname,".txt");
+        }
+    }
 
-	initksqrt();
+    initksqrt();
 
-	Bread(ifil,&inumwads,4); Bread(ifil,&iwadstart,4);
-	Blseek(ifil,iwadstart,BSEEK_SET);
-	for(z=0;z<inumwads;z++)
-	{
-		if ((z&1023) == 0) Bread(ifil,tempbuf,16384);
-		zz = ((z&1023)<<4);
-		iwadplc[z] = ((int)tempbuf[zz]) + (((int)tempbuf[zz+1])<<8) + (((int)tempbuf[zz+2])<<16) + (((int)tempbuf[zz+3])<<24);
-		zz += 4;
-		iwadlen[z] = ((int)tempbuf[zz]) + (((int)tempbuf[zz+1])<<8) + (((int)tempbuf[zz+2])<<16) + (((int)tempbuf[zz+3])<<24);
-		zz += 4;
-		iwadata[z][0] = tempbuf[zz+0]; iwadata[z][1] = tempbuf[zz+1];
-		iwadata[z][2] = tempbuf[zz+2]; iwadata[z][3] = tempbuf[zz+3];
-		iwadata[z][4] = tempbuf[zz+4]; iwadata[z][5] = tempbuf[zz+5];
-		iwadata[z][6] = tempbuf[zz+6]; iwadata[z][7] = tempbuf[zz+7];
-		iwadata[z][8] = 0;
-	}
+    Bread(ifil,&inumwads,4); Bread(ifil,&iwadstart,4);
+    Blseek(ifil,iwadstart,BSEEK_SET);
+    for(z=0;z<inumwads;z++)
+    {
+        if ((z&1023) == 0) Bread(ifil,tempbuf,16384);
+        zz = ((z&1023)<<4);
+        iwadplc[z] = ((int)tempbuf[zz]) + (((int)tempbuf[zz+1])<<8) + (((int)tempbuf[zz+2])<<16) + (((int)tempbuf[zz+3])<<24);
+        zz += 4;
+        iwadlen[z] = ((int)tempbuf[zz]) + (((int)tempbuf[zz+1])<<8) + (((int)tempbuf[zz+2])<<16) + (((int)tempbuf[zz+3])<<24);
+        zz += 4;
+        iwadata[z][0] = tempbuf[zz+0]; iwadata[z][1] = tempbuf[zz+1];
+        iwadata[z][2] = tempbuf[zz+2]; iwadata[z][3] = tempbuf[zz+3];
+        iwadata[z][4] = tempbuf[zz+4]; iwadata[z][5] = tempbuf[zz+5];
+        iwadata[z][6] = tempbuf[zz+6]; iwadata[z][7] = tempbuf[zz+7];
+        iwadata[z][8] = 0;
+    }
 
-	parsescript();
+    parsescript();
 
-	for(z=0;z<inumwads;z++) slist[z] = z;
+    for(z=0;z<inumwads;z++) slist[z] = z;
 
-	for(gap=(inumwads>>1);gap>0;gap>>=1)
-		for(z=0;z<inumwads-gap;z++)
-			for(zz=z;zz>=0;zz-=gap)
-			{
-				if (Bstrcasecmp(iwadata[slist[zz]],iwadata[slist[zz+gap]]) <= 0) break;
-				i = slist[zz]; slist[zz] = slist[zz+gap]; slist[zz+gap] = i;
-			}
+    for(gap=(inumwads>>1);gap>0;gap>>=1)
+        for(z=0;z<inumwads-gap;z++)
+            for(zz=z;zz>=0;zz-=gap)
+            {
+                if (Bstrcasecmp(iwadata[slist[zz]],iwadata[slist[zz+gap]]) <= 0) break;
+                i = slist[zz]; slist[zz] = slist[zz+gap]; slist[zz+gap] = i;
+            }
 
-	if (ifil != pfil)
-	{
-		Bread(pfil,&pnumwads,4);
-		Bread(pfil,&pwadstart,4);
-		Blseek(pfil,pwadstart,SEEK_SET);
-		for(z=0;z<pnumwads;z++)
-		{
-			if ((z&1023) == 0) Bread(ifil,tempbuf,16384);
-			zz = ((z&1023)<<4);
-			pwadplc[z] = ((int)tempbuf[zz]) + (((int)tempbuf[zz+1])<<8) + (((int)tempbuf[zz+2])<<16) + (((int)tempbuf[zz+3])<<24);
-			zz += 4;
-			pwadlen[z] = ((int)tempbuf[zz]) + (((int)tempbuf[zz+1])<<8) + (((int)tempbuf[zz+2])<<16) + (((int)tempbuf[zz+3])<<24);
-			zz += 4;
-			pwadata[z][0] = tempbuf[zz+0]; pwadata[z][1] = tempbuf[zz+1];
-			pwadata[z][2] = tempbuf[zz+2]; pwadata[z][3] = tempbuf[zz+3];
-			pwadata[z][4] = tempbuf[zz+4]; pwadata[z][5] = tempbuf[zz+5];
-			pwadata[z][6] = tempbuf[zz+6]; pwadata[z][7] = tempbuf[zz+7];
-			pwadata[z][8] = 0;
-		}
-	}
-	else
-	{
-		pnumwads = inumwads;
-		pwadstart = iwadstart;
-		for(z=0;z<inumwads;z++)
-		{
-			pwadplc[z] = iwadplc[z];
-			pwadlen[z] = iwadlen[z];
-			pwadata[z][0] = iwadata[z][0]; pwadata[z][1] = iwadata[z][1];
-			pwadata[z][2] = iwadata[z][2]; pwadata[z][3] = iwadata[z][3];
-			pwadata[z][4] = iwadata[z][4]; pwadata[z][5] = iwadata[z][5];
-			pwadata[z][6] = iwadata[z][6]; pwadata[z][7] = iwadata[z][7];
-			pwadata[z][8] = iwadata[z][8];
-		}
-	}
+    if (ifil != pfil)
+    {
+        Bread(pfil,&pnumwads,4);
+        Bread(pfil,&pwadstart,4);
+        Blseek(pfil,pwadstart,SEEK_SET);
+        for(z=0;z<pnumwads;z++)
+        {
+            if ((z&1023) == 0) Bread(ifil,tempbuf,16384);
+            zz = ((z&1023)<<4);
+            pwadplc[z] = ((int)tempbuf[zz]) + (((int)tempbuf[zz+1])<<8) + (((int)tempbuf[zz+2])<<16) + (((int)tempbuf[zz+3])<<24);
+            zz += 4;
+            pwadlen[z] = ((int)tempbuf[zz]) + (((int)tempbuf[zz+1])<<8) + (((int)tempbuf[zz+2])<<16) + (((int)tempbuf[zz+3])<<24);
+            zz += 4;
+            pwadata[z][0] = tempbuf[zz+0]; pwadata[z][1] = tempbuf[zz+1];
+            pwadata[z][2] = tempbuf[zz+2]; pwadata[z][3] = tempbuf[zz+3];
+            pwadata[z][4] = tempbuf[zz+4]; pwadata[z][5] = tempbuf[zz+5];
+            pwadata[z][6] = tempbuf[zz+6]; pwadata[z][7] = tempbuf[zz+7];
+            pwadata[z][8] = 0;
+        }
+    }
+    else
+    {
+        pnumwads = inumwads;
+        pwadstart = iwadstart;
+        for(z=0;z<inumwads;z++)
+        {
+            pwadplc[z] = iwadplc[z];
+            pwadlen[z] = iwadlen[z];
+            pwadata[z][0] = iwadata[z][0]; pwadata[z][1] = iwadata[z][1];
+            pwadata[z][2] = iwadata[z][2]; pwadata[z][3] = iwadata[z][3];
+            pwadata[z][4] = iwadata[z][4]; pwadata[z][5] = iwadata[z][5];
+            pwadata[z][6] = iwadata[z][6]; pwadata[z][7] = iwadata[z][7];
+            pwadata[z][8] = iwadata[z][8];
+        }
+    }
 
-	clearbufbyte(&sector[0], sizeof(sectortype) * MAXSECTORS, 0);
-	clearbufbyte(&wall[0], sizeof(walltype) * MAXWALLS, 0);
-	clearbufbyte(&sprite[0], sizeof(spritetype) * MAXSPRITES, 0);
-	for(i=0;i<MAXSECTORS;i++) sector[i].extra = -1;
-	for(i=0;i<MAXWALLS;i++) wall[i].extra = -1;
-	for(i=0;i<MAXSPRITES;i++) sprite[i].extra = -1;
+    clearbufbyte(&sector[0], sizeof(sectortype) * MAXSECTORS, 0);
+    clearbufbyte(&wall[0], sizeof(walltype) * MAXWALLS, 0);
+    clearbufbyte(&sprite[0], sizeof(spritetype) * MAXSPRITES, 0);
+    for(i=0;i<MAXSECTORS;i++) sector[i].extra = -1;
+    for(i=0;i<MAXWALLS;i++) wall[i].extra = -1;
+    for(i=0;i<MAXSPRITES;i++) sprite[i].extra = -1;
 
-	if ((w = getwadindex("TEXTURE1")) < 0)
-		{ printf("TEXTURE1 not found!\n"); exit(0); }
-	Blseek(ifil,iwadplc[w],BSEEK_SET);
-	Bread(ifil,&numtexts,4);
-	Bread(ifil,textoffs,numtexts*sizeof(int));
-	for(z=0;z<numtexts;z++)
-	{
-		Blseek(ifil,iwadplc[w]+textoffs[z],BSEEK_SET);
-		Bread(ifil,tempbuf,32);
-		textname[z][0] = tempbuf[0]; textname[z][1] = tempbuf[1];
-		textname[z][2] = tempbuf[2]; textname[z][3] = tempbuf[3];
-		textname[z][4] = tempbuf[4]; textname[z][5] = tempbuf[5];
-		textname[z][6] = tempbuf[6]; textname[z][7] = tempbuf[7];
-		textname[z][8] = 0;
-		textpname[z] = ((int)tempbuf[26]) + (((int)tempbuf[27])<<8);
-	}
+    if ((w = getwadindex("TEXTURE1")) < 0)
+        { printf("TEXTURE1 not found!\n"); exit(0); }
+    Blseek(ifil,iwadplc[w],BSEEK_SET);
+    Bread(ifil,&numtexts,4);
+    Bread(ifil,textoffs,numtexts*sizeof(int));
+    for(z=0;z<numtexts;z++)
+    {
+        Blseek(ifil,iwadplc[w]+textoffs[z],BSEEK_SET);
+        Bread(ifil,tempbuf,32);
+        textname[z][0] = tempbuf[0]; textname[z][1] = tempbuf[1];
+        textname[z][2] = tempbuf[2]; textname[z][3] = tempbuf[3];
+        textname[z][4] = tempbuf[4]; textname[z][5] = tempbuf[5];
+        textname[z][6] = tempbuf[6]; textname[z][7] = tempbuf[7];
+        textname[z][8] = 0;
+        textpname[z] = ((int)tempbuf[26]) + (((int)tempbuf[27])<<8);
+    }
 
-	if ((w = getwadindex("TEXTURE2")) >= 0)
-	{
-		Blseek(ifil,iwadplc[w],BSEEK_SET);
-		startnumtexts = numtexts;
-		Bread(ifil,&danumtexts,4); numtexts += danumtexts;
-		Bread(ifil,&textoffs[startnumtexts],(numtexts-startnumtexts)*sizeof(int));
-		for(z=startnumtexts;z<numtexts;z++)
-		{
-			Blseek(ifil,iwadplc[w]+textoffs[z],BSEEK_SET);
-			Bread(ifil,tempbuf,32);
-			textname[z][0] = tempbuf[0]; textname[z][1] = tempbuf[1];
-			textname[z][2] = tempbuf[2]; textname[z][3] = tempbuf[3];
-			textname[z][4] = tempbuf[4]; textname[z][5] = tempbuf[5];
-			textname[z][6] = tempbuf[6]; textname[z][7] = tempbuf[7];
-			textname[z][8] = 0;
-			textpname[z] = ((int)tempbuf[26]) + (((int)tempbuf[27])<<8);
-		}
-	}
+    if ((w = getwadindex("TEXTURE2")) >= 0)
+    {
+        Blseek(ifil,iwadplc[w],BSEEK_SET);
+        startnumtexts = numtexts;
+        Bread(ifil,&danumtexts,4); numtexts += danumtexts;
+        Bread(ifil,&textoffs[startnumtexts],(numtexts-startnumtexts)*sizeof(int));
+        for(z=startnumtexts;z<numtexts;z++)
+        {
+            Blseek(ifil,iwadplc[w]+textoffs[z],BSEEK_SET);
+            Bread(ifil,tempbuf,32);
+            textname[z][0] = tempbuf[0]; textname[z][1] = tempbuf[1];
+            textname[z][2] = tempbuf[2]; textname[z][3] = tempbuf[3];
+            textname[z][4] = tempbuf[4]; textname[z][5] = tempbuf[5];
+            textname[z][6] = tempbuf[6]; textname[z][7] = tempbuf[7];
+            textname[z][8] = 0;
+            textpname[z] = ((int)tempbuf[26]) + (((int)tempbuf[27])<<8);
+        }
+    }
 
-	if ((w = getwadindex("PNAMES")) < 0)
-		{ printf("PNAMES not found!\n"); exit(0); }
-	Blseek(ifil,iwadplc[w],BSEEK_SET);
-	Bread(ifil,&numpnames,4);
-	Bread(ifil,tempbuf,numpnames*8);
-	for(z=0;z<numpnames;z++)
-	{
-		zz = (z<<3);
-		pname[z][0] = tempbuf[zz+0]; pname[z][1] = tempbuf[zz+1];
-		pname[z][2] = tempbuf[zz+2]; pname[z][3] = tempbuf[zz+3];
-		pname[z][4] = tempbuf[zz+4]; pname[z][5] = tempbuf[zz+5];
-		pname[z][6] = tempbuf[zz+6]; pname[z][7] = tempbuf[zz+7];
-		pname[z][8] = 0;
-	}
+    if ((w = getwadindex("PNAMES")) < 0)
+        { printf("PNAMES not found!\n"); exit(0); }
+    Blseek(ifil,iwadplc[w],BSEEK_SET);
+    Bread(ifil,&numpnames,4);
+    Bread(ifil,tempbuf,numpnames*8);
+    for(z=0;z<numpnames;z++)
+    {
+        zz = (z<<3);
+        pname[z][0] = tempbuf[zz+0]; pname[z][1] = tempbuf[zz+1];
+        pname[z][2] = tempbuf[zz+2]; pname[z][3] = tempbuf[zz+3];
+        pname[z][4] = tempbuf[zz+4]; pname[z][5] = tempbuf[zz+5];
+        pname[z][6] = tempbuf[zz+6]; pname[z][7] = tempbuf[zz+7];
+        pname[z][8] = 0;
+    }
 
-	if ((w = getwadindex(doommap)) < 0)
-		{ printf("Board not found!\n"); exit(0); }
-	boardwadindex = w;
-	for(w=boardwadindex+10;w>=boardwadindex;w--)
-	{
-		Blseek(pfil,pwadplc[w],BSEEK_SET);
+    if ((w = getwadindex(doommap)) < 0)
+        { printf("Board not found!\n"); exit(0); }
+    boardwadindex = w;
+    for(w=boardwadindex+10;w>=boardwadindex;w--)
+    {
+        Blseek(pfil,pwadplc[w],BSEEK_SET);
 
-		if (Bstrcasecmp(pwadata[w],"VERTEXES") == 0)
-		{
-			dnumpoints = (pwadlen[w]>>2);
-			Bread(pfil,tempbuf,pwadlen[w]);
-			offs = 0;
-			for(z=0;z<dnumpoints;z++)
-			{
-				px[z] = ((short)tempbuf[offs])+(((short)tempbuf[offs+1])<<8);
-				py[z] = -(((short)tempbuf[offs+2])+(((short)tempbuf[offs+3])<<8));
-				offs += 4;
-			}
-		}
-		if (Bstrcasecmp(pwadata[w],"LINEDEFS") == 0)
-		{
-			dnumlines = pwadlen[w]/sizeof(linedeftype);
-			Bread(pfil,line,sizeof(linedeftype)*dnumlines);
-		}
-		if (Bstrcasecmp(pwadata[w],"SIDEDEFS") == 0)
-		{
-			dnumsides = pwadlen[w]/sizeof(sidedeftype);
-			Bread(pfil,side,pwadlen[w]);
-			for(z=0;z<dnumsides;z++)
-			{
-				for(i=0;i<8;i++) picstr[i] = side[z].uppertexture[i];
-				picstr[8] = 0;
+        if (Bstrcasecmp(pwadata[w],"VERTEXES") == 0)
+        {
+            dnumpoints = (pwadlen[w]>>2);
+            Bread(pfil,tempbuf,pwadlen[w]);
+            offs = 0;
+            for(z=0;z<dnumpoints;z++)
+            {
+                px[z] = ((short)tempbuf[offs])+(((short)tempbuf[offs+1])<<8);
+                py[z] = -(((short)tempbuf[offs+2])+(((short)tempbuf[offs+3])<<8));
+                offs += 4;
+            }
+        }
+        if (Bstrcasecmp(pwadata[w],"LINEDEFS") == 0)
+        {
+            dnumlines = pwadlen[w]/sizeof(linedeftype);
+            Bread(pfil,line,sizeof(linedeftype)*dnumlines);
+        }
+        if (Bstrcasecmp(pwadata[w],"SIDEDEFS") == 0)
+        {
+            dnumsides = pwadlen[w]/sizeof(sidedeftype);
+            Bread(pfil,side,pwadlen[w]);
+            for(z=0;z<dnumsides;z++)
+            {
+                for(i=0;i<8;i++) picstr[i] = side[z].uppertexture[i];
+                picstr[8] = 0;
 
-				sidetoppic[z] = -1;
-				if (picstr[0] != '-')
-					for(zx=0;zx<numtexts;zx++)
-						if (Bstrcasecmp(picstr,textname[zx]) == 0)
-							{ sidetoppic[z] = getwadindex(pname[textpname[zx]]); break; }
+                sidetoppic[z] = -1;
+                if (picstr[0] != '-')
+                    for(zx=0;zx<numtexts;zx++)
+                        if (Bstrcasecmp(picstr,textname[zx]) == 0)
+                            { sidetoppic[z] = getwadindex(pname[textpname[zx]]); break; }
 
-				for(i=0;i<8;i++) picstr[i] = side[z].lowertexture[i];
-				picstr[8] = 0;
+                for(i=0;i<8;i++) picstr[i] = side[z].lowertexture[i];
+                picstr[8] = 0;
 
-				sidebotpic[z] = -1;
-				if (picstr[0] != '-')
-					for(zx=0;zx<numtexts;zx++)
-						if (Bstrcasecmp(picstr,textname[zx]) == 0)
-							{ sidebotpic[z] = getwadindex(pname[textpname[zx]]); break; }
+                sidebotpic[z] = -1;
+                if (picstr[0] != '-')
+                    for(zx=0;zx<numtexts;zx++)
+                        if (Bstrcasecmp(picstr,textname[zx]) == 0)
+                            { sidebotpic[z] = getwadindex(pname[textpname[zx]]); break; }
 
-				for(i=0;i<8;i++) picstr[i] = side[z].middletexture[i];
-				picstr[8] = 0;
+                for(i=0;i<8;i++) picstr[i] = side[z].middletexture[i];
+                picstr[8] = 0;
 
-				sidemidpic[z] = -1;
-				if (picstr[0] != '-')
-					for(zx=0;zx<numtexts;zx++)
-						if (Bstrcasecmp(picstr,textname[zx]) == 0)
-							{ sidemidpic[z] = getwadindex(pname[textpname[zx]]); break; }
-			}
-		}
-		if (Bstrcasecmp(pwadata[w],"SECTORS") == 0)
-		{
-			dnumsectors = pwadlen[w]/sizeof(secttype);
-			Bread(pfil,sect,pwadlen[w]);
-			for(z=0;z<dnumsectors;z++)
-			{
-				for(i=0;i<8;i++) picstr[i] = sect[z].floorpic[i];
-				picstr[8] = 0;
-				sector[z].floorpicnum = getwadindex(picstr);
-		  
-				for(i=0;i<8;i++) picstr[i] = sect[z].ceilingpic[i];
-				picstr[8] = 0;
-				sector[z].ceilingpicnum = getwadindex(picstr);
-			}
-		}
-		if (Bstrcasecmp(pwadata[w],"THINGS") == 0)
-		{
-			dnumthings = pwadlen[w]/sizeof(thingtype);
-			Bread(pfil,thing,pwadlen[w]);
-		}
-	}
-	close(ifil);
-	if (ifil != pfil) close(pfil);
+                sidemidpic[z] = -1;
+                if (picstr[0] != '-')
+                    for(zx=0;zx<numtexts;zx++)
+                        if (Bstrcasecmp(picstr,textname[zx]) == 0)
+                            { sidemidpic[z] = getwadindex(pname[textpname[zx]]); break; }
+            }
+        }
+        if (Bstrcasecmp(pwadata[w],"SECTORS") == 0)
+        {
+            dnumsectors = pwadlen[w]/sizeof(secttype);
+            Bread(pfil,sect,pwadlen[w]);
+            for(z=0;z<dnumsectors;z++)
+            {
+                for(i=0;i<8;i++) picstr[i] = sect[z].floorpic[i];
+                picstr[8] = 0;
+                sector[z].floorpicnum = getwadindex(picstr);
+
+                for(i=0;i<8;i++) picstr[i] = sect[z].ceilingpic[i];
+                picstr[8] = 0;
+                sector[z].ceilingpicnum = getwadindex(picstr);
+            }
+        }
+        if (Bstrcasecmp(pwadata[w],"THINGS") == 0)
+        {
+            dnumthings = pwadlen[w]/sizeof(thingtype);
+            Bread(pfil,thing,pwadlen[w]);
+        }
+    }
+    close(ifil);
+    if (ifil != pfil) close(pfil);
 
 
-	minx = 32767; maxx = -32768;
-	miny = 32767; maxy = -32768;
-	for(z=0;z<dnumpoints;z++)
-	{
-		x = px[z]; y = py[z];
-		if (x < minx) minx = x;
-		if (x > maxx) maxx = x;
-		if (y < miny) miny = y;
-		if (y > maxy) maxy = y;
-	}
-	cx = (((minx+maxx)>>1)&0xffffffc0);
-	cy = (((miny+maxy)>>1)&0xffffffc0);
+    minx = 32767; maxx = -32768;
+    miny = 32767; maxy = -32768;
+    for(z=0;z<dnumpoints;z++)
+    {
+        x = px[z]; y = py[z];
+        if (x < minx) minx = x;
+        if (x > maxx) maxx = x;
+        if (y < miny) miny = y;
+        if (y > maxy) maxy = y;
+    }
+    cx = (((minx+maxx)>>1)&0xffffffc0);
+    cy = (((miny+maxy)>>1)&0xffffffc0);
 
-	numwalls = 0;
+    numwalls = 0;
 
-	for(z=0;z<dnumsectors;z++)
-	{
-		startnumwalls = numwalls;
-		for(zz=0;zz<dnumlines;zz++)
-		{
-			if (z == side[line[zz].side1].sect)
-			{
-				wx[numwalls] = px[line[zz].p1]; wy[numwalls] = py[line[zz].p1];
-				wx2[numwalls] = px[line[zz].p2]; wy2[numwalls] = py[line[zz].p2];
-				picindex[numwalls] = line[zz].side1; linindex[numwalls++] = zz;
-			}
-			if ((line[zz].side2 >= 0) && (z == side[line[zz].side2].sect))
-			{
-				wx[numwalls] = px[line[zz].p2]; wy[numwalls] = py[line[zz].p2];
-				wx2[numwalls] = px[line[zz].p1]; wy2[numwalls] = py[line[zz].p1];
-				picindex[numwalls] = line[zz].side2; linindex[numwalls++] = zz;
-			}
-		}
+    for(z=0;z<dnumsectors;z++)
+    {
+        startnumwalls = numwalls;
+        for(zz=0;zz<dnumlines;zz++)
+        {
+            if (z == side[line[zz].side1].sect)
+            {
+                wx[numwalls] = px[line[zz].p1]; wy[numwalls] = py[line[zz].p1];
+                wx2[numwalls] = px[line[zz].p2]; wy2[numwalls] = py[line[zz].p2];
+                picindex[numwalls] = line[zz].side1; linindex[numwalls++] = zz;
+            }
+            if ((line[zz].side2 >= 0) && (z == side[line[zz].side2].sect))
+            {
+                wx[numwalls] = px[line[zz].p2]; wy[numwalls] = py[line[zz].p2];
+                wx2[numwalls] = px[line[zz].p1]; wy2[numwalls] = py[line[zz].p1];
+                picindex[numwalls] = line[zz].side2; linindex[numwalls++] = zz;
+            }
+        }
 
-		startpoint2 = startnumwalls;
-		for(zz=startnumwalls;zz<numwalls;zz++)
-		{
+        startpoint2 = startnumwalls;
+        for(zz=startnumwalls;zz<numwalls;zz++)
+        {
             x = wx2[zz];
             y = wy2[zz];
-			j = 0;
-			for(zzz=zz+1;zzz<numwalls;zzz++)
-				if ((wx[zzz] == x) && (wy[zzz] == y))
-				{
-					if (j == 0)
-					{
-						i = wx[zz+1]; wx[zz+1] = wx[zzz]; wx[zzz] = i;
-						i = wy[zz+1]; wy[zz+1] = wy[zzz]; wy[zzz] = i;
-						i = wx2[zz+1]; wx2[zz+1] = wx2[zzz]; wx2[zzz] = i;
-						i = wy2[zz+1]; wy2[zz+1] = wy2[zzz]; wy2[zzz] = i;
-						i = picindex[zz+1]; picindex[zz+1] = picindex[zzz]; picindex[zzz] = i;
-						i = linindex[zz+1]; linindex[zz+1] = linindex[zzz]; linindex[zzz] = i;
-						j = 1;
-					}
-					else
-					{
-						j = 1;
-						l1 = (x-wx[zz])*(wy2[zz+1]-y) - (y-wy[zz])*(wx2[zz+1]-x);
-						l2 = (x-wx[zz])*(wy2[zzz]-y) - (y-wy[zz])*(wx2[zzz]-x);
-						if (l1 == 0) j = 2;       //Don't want collinear lines!
-						else if ((l1 < 0) && (l2 > 0)) j = 2;
-						else if ((wx2[zz+1]-x)*(wy2[zzz]-y) > (wy2[zz+1]-y)*(wx2[zzz]-x)) j = 2;
+            j = 0;
+            for(zzz=zz+1;zzz<numwalls;zzz++)
+                if ((wx[zzz] == x) && (wy[zzz] == y))
+                {
+                    if (j == 0)
+                    {
+                        i = wx[zz+1]; wx[zz+1] = wx[zzz]; wx[zzz] = i;
+                        i = wy[zz+1]; wy[zz+1] = wy[zzz]; wy[zzz] = i;
+                        i = wx2[zz+1]; wx2[zz+1] = wx2[zzz]; wx2[zzz] = i;
+                        i = wy2[zz+1]; wy2[zz+1] = wy2[zzz]; wy2[zzz] = i;
+                        i = picindex[zz+1]; picindex[zz+1] = picindex[zzz]; picindex[zzz] = i;
+                        i = linindex[zz+1]; linindex[zz+1] = linindex[zzz]; linindex[zzz] = i;
+                        j = 1;
+                    }
+                    else
+                    {
+                        j = 1;
+                        l1 = (x-wx[zz])*(wy2[zz+1]-y) - (y-wy[zz])*(wx2[zz+1]-x);
+                        l2 = (x-wx[zz])*(wy2[zzz]-y) - (y-wy[zz])*(wx2[zzz]-x);
+                        if (l1 == 0) j = 2;       //Don't want collinear lines!
+                        else if ((l1 < 0) && (l2 > 0)) j = 2;
+                        else if ((wx2[zz+1]-x)*(wy2[zzz]-y) > (wy2[zz+1]-y)*(wx2[zzz]-x)) j = 2;
 
-						if (j == 2)
-						{
-							i = wx[zz+1]; wx[zz+1] = wx[zzz]; wx[zzz] = i;
-							i = wy[zz+1]; wy[zz+1] = wy[zzz]; wy[zzz] = i;
-							i = wx2[zz+1]; wx2[zz+1] = wx2[zzz]; wx2[zzz] = i;
-							i = wy2[zz+1]; wy2[zz+1] = wy2[zzz]; wy2[zzz] = i;
-							i = picindex[zz+1]; picindex[zz+1] = picindex[zzz]; picindex[zzz] = i;
-							i = linindex[zz+1]; linindex[zz+1] = linindex[zzz]; linindex[zzz] = i;
-						}
-					}
-					point2[zz] = zz+1;
-				}
-			if (j == 0) point2[zz] = startpoint2, startpoint2 = zz+1;
-		}
+                        if (j == 2)
+                        {
+                            i = wx[zz+1]; wx[zz+1] = wx[zzz]; wx[zzz] = i;
+                            i = wy[zz+1]; wy[zz+1] = wy[zzz]; wy[zzz] = i;
+                            i = wx2[zz+1]; wx2[zz+1] = wx2[zzz]; wx2[zzz] = i;
+                            i = wy2[zz+1]; wy2[zz+1] = wy2[zzz]; wy2[zzz] = i;
+                            i = picindex[zz+1]; picindex[zz+1] = picindex[zzz]; picindex[zzz] = i;
+                            i = linindex[zz+1]; linindex[zz+1] = linindex[zzz]; linindex[zzz] = i;
+                        }
+                    }
+                    point2[zz] = zz+1;
+                }
+            if (j == 0) point2[zz] = startpoint2, startpoint2 = zz+1;
+        }
 
-		sector[z].wallptr = startnumwalls;
-		sector[z].wallnum = numwalls-startnumwalls;
-	}
+        sector[z].wallptr = startnumwalls;
+        sector[z].wallnum = numwalls-startnumwalls;
+    }
 
-		//Collect sectors
-	for(z=0;z<dnumsectors;z++)
-	{
-		if (Bstrcasecmp(iwadata[sector[z].ceilingpicnum],"F_SKY1") == 0) sector[z].ceilingstat |= 1;
-		if (Bstrcasecmp(iwadata[sector[z].floorpicnum],"F_SKY1") == 0) sector[z].floorstat |= 1;
-		sector[z].ceilingz = -(sect[z].ceilingz<<8);
-		sector[z].floorz = -(sect[z].floorz<<8);
+        //Collect sectors
+    for(z=0;z<dnumsectors;z++)
+    {
+        if (Bstrcasecmp(iwadata[sector[z].ceilingpicnum],"F_SKY1") == 0) sector[z].ceilingstat |= 1;
+        if (Bstrcasecmp(iwadata[sector[z].floorpicnum],"F_SKY1") == 0) sector[z].floorstat |= 1;
+        sector[z].ceilingz = -(sect[z].ceilingz<<8);
+        sector[z].floorz = -(sect[z].floorz<<8);
 
-		startwall = sector[z].wallptr;
-		endwall = startwall + sector[z].wallnum;
-		for(zz=startwall;zz<endwall;zz++) sectorofwall[zz] = z;
+        startwall = sector[z].wallptr;
+        endwall = startwall + sector[z].wallnum;
+        for(zz=startwall;zz<endwall;zz++) sectorofwall[zz] = z;
 
-		j = 28-(sect[z].shade>>3);
-		if ((sector[z].ceilingstat&1) == 0) sector[z].ceilingshade = j;
-		if ((sector[z].floorstat&1) == 0) sector[z].floorshade = j;
-		for(i=startwall;i<endwall;i++) wall[i].shade = j;
-	}
+        j = 28-(sect[z].shade>>3);
+        if ((sector[z].ceilingstat&1) == 0) sector[z].ceilingshade = j;
+        if ((sector[z].floorstat&1) == 0) sector[z].floorshade = j;
+        for(i=startwall;i<endwall;i++) wall[i].shade = j;
+    }
 
 
-	for(i=0;i<MAXTHINGTYPES;i++) thinglookup[i] = -1;
+    for(i=0;i<MAXTHINGTYPES;i++) thinglookup[i] = -1;
 
-	for(i=0;i<THINGLISTNUM;i++)
-		thinglookup[thinglist[i].num] = getwadindex(thinglist[i].name);
+    for(i=0;i<THINGLISTNUM;i++)
+        thinglookup[thinglist[i].num] = getwadindex(thinglist[i].name);
 
-	for(i=0;i<MAXTHINGTYPES;i++)
-		if (thinglookup[i] == -1)   //Make bad type numbers into cans
-			thinglookup[i] = thinglookup[2035];
+    for(i=0;i<MAXTHINGTYPES;i++)
+        if (thinglookup[i] == -1)   //Make bad type numbers into cans
+            thinglookup[i] = thinglookup[2035];
 
 
-	for(z=0;z<numwalls;z++) slist[z] = z;
+    for(z=0;z<numwalls;z++) slist[z] = z;
 
-	for(gap=(numwalls>>1);gap>0;gap>>=1)
-		for(z=0;z<numwalls-gap;z++)
-			for(zz=z;zz>=0;zz-=gap)
-			{
-				if (wx[slist[zz]] <= wx[slist[zz+gap]]) break;
-				i = slist[zz]; slist[zz] = slist[zz+gap]; slist[zz+gap] = i;
-			}
+    for(gap=(numwalls>>1);gap>0;gap>>=1)
+        for(z=0;z<numwalls-gap;z++)
+            for(zz=z;zz>=0;zz-=gap)
+            {
+                if (wx[slist[zz]] <= wx[slist[zz+gap]]) break;
+                i = slist[zz]; slist[zz] = slist[zz+gap]; slist[zz+gap] = i;
+            }
 
-	for(z=0;z<numwalls;z++)
-	{
-		wall[z].x = (((int)wx[z]-cx)<<4);
-		wall[z].y = (((int)wy[z]-cy)<<4);
-		wall[z].point2 = point2[z];
+    for(z=0;z<numwalls;z++)
+    {
+        wall[z].x = (((int)wx[z]-cx)<<4);
+        wall[z].y = (((int)wy[z]-cy)<<4);
+        wall[z].point2 = point2[z];
 
-		wall[z].nextwall = -1;
-		wall[z].nextsector = -1;
+        wall[z].nextwall = -1;
+        wall[z].nextsector = -1;
 
-		x1 = wx[z]; x2 = wx[point2[z]];
-		y1 = wy[z]; y2 = wy[point2[z]];
+        x1 = wx[z]; x2 = wx[point2[z]];
+        y1 = wy[z]; y2 = wy[point2[z]];
 
-		zz = 0; zzz = 2048;
-		do
-		{
-			if ((zz+zzz < numwalls) && (wx[slist[zz+zzz]] < x2)) zz += zzz;
-			zzz >>= 1;
-			if ((zz+zzz < numwalls) && (wx[slist[zz+zzz]] < x2)) zz += zzz;
-			zzz >>= 1;
-		} while (zzz > 0);
+        zz = 0; zzz = 2048;
+        do
+        {
+            if ((zz+zzz < numwalls) && (wx[slist[zz+zzz]] < x2)) zz += zzz;
+            zzz >>= 1;
+            if ((zz+zzz < numwalls) && (wx[slist[zz+zzz]] < x2)) zz += zzz;
+            zzz >>= 1;
+        } while (zzz > 0);
 
-		do
-		{
-			zzx = slist[zz];
-			if (wx[zzx] > x2) break;
-			if (wy[zzx] == y2)
-				if ((wx[point2[zzx]] == x1) && (wy[point2[zzx]] == y1))
-				{
-					wall[z].nextwall = zzx;
-					wall[z].nextsector = sectorofwall[zzx];
-					break;
-				}
-			zz++;
-		} while (zz < numwalls);
+        do
+        {
+            zzx = slist[zz];
+            if (wx[zzx] > x2) break;
+            if (wy[zzx] == y2)
+                if ((wx[point2[zzx]] == x1) && (wy[point2[zzx]] == y1))
+                {
+                    wall[z].nextwall = zzx;
+                    wall[z].nextsector = sectorofwall[zzx];
+                    break;
+                }
+            zz++;
+        } while (zz < numwalls);
 
-		if (wall[z].nextwall < 0)
-		{
-			wall[z].picnum = sidemidpic[picindex[z]];
-			wall[z].overpicnum = 0;
-		}
-		else
-		{
-			wall[z].picnum = sidetoppic[picindex[z]];
-			if (wall[z].picnum <= 0) wall[z].picnum = sidebotpic[picindex[z]];
-			if ((wall[z].picnum <= 0) && (wall[z].nextwall >= 0))
-			{
-				zx = picindex[wall[z].nextwall];
-				wall[z].picnum = sidetoppic[zx];
-				if (wall[z].picnum <= 0) wall[z].picnum = sidebotpic[zx];
-			}
-			wall[z].overpicnum = sidemidpic[picindex[z]];
-			if (wall[z].overpicnum >= 0) wall[z].cstat |= (1+4+16);
-		}
-		wall[z].xrepeat = 8;
-		wall[z].yrepeat = 8;
-		wall[z].xpanning = (char)((-side[picindex[z]].xoffset)&255);
-		wall[z].ypanning = (char)(((side[picindex[z]].yoffset<<1))&255);
+        if (wall[z].nextwall < 0)
+        {
+            wall[z].picnum = sidemidpic[picindex[z]];
+            wall[z].overpicnum = 0;
+        }
+        else
+        {
+            wall[z].picnum = sidetoppic[picindex[z]];
+            if (wall[z].picnum <= 0) wall[z].picnum = sidebotpic[picindex[z]];
+            if ((wall[z].picnum <= 0) && (wall[z].nextwall >= 0))
+            {
+                zx = picindex[wall[z].nextwall];
+                wall[z].picnum = sidetoppic[zx];
+                if (wall[z].picnum <= 0) wall[z].picnum = sidebotpic[zx];
+            }
+            wall[z].overpicnum = sidemidpic[picindex[z]];
+            if (wall[z].overpicnum >= 0) wall[z].cstat |= (1+4+16);
+        }
+        wall[z].xrepeat = 8;
+        wall[z].yrepeat = 8;
+        wall[z].xpanning = (char)((-side[picindex[z]].xoffset)&255);
+        wall[z].ypanning = (char)(((side[picindex[z]].yoffset<<1))&255);
 
-		if (line[linindex[z]].flags&1) wall[z].cstat |= 1;
-		//if (wall[z].nextwall >= 0) wall[z].cstat |= 4;
-		//if ((line[linindex[z]].flags&24) && (wall[z].nextwall >= 0))
-		//   wall[z].cstat |= 4;
-	}
+        if (line[linindex[z]].flags&1) wall[z].cstat |= 1;
+        //if (wall[z].nextwall >= 0) wall[z].cstat |= 4;
+        //if ((line[linindex[z]].flags&24) && (wall[z].nextwall >= 0))
+        //   wall[z].cstat |= 4;
+    }
 
-	for(z=0;z<dnumthings;z++)
-	{
-		sprite[z].x = (((int)thing[z].x-cx)<<4);
-		sprite[z].y = (((int)-thing[z].y-cy)<<4);
+    for(z=0;z<dnumthings;z++)
+    {
+        sprite[z].x = (((int)thing[z].x-cx)<<4);
+        sprite[z].y = (((int)-thing[z].y-cy)<<4);
 
-		sprite[z].sectnum = 0;
-		for(zz=0;zz<dnumsectors;zz++)
-			if (inside(sprite[z].x,sprite[z].y,(short)zz) != 0)
-				{ sprite[z].sectnum = zz; break; }
+        sprite[z].sectnum = 0;
+        for(zz=0;zz<dnumsectors;zz++)
+            if (inside(sprite[z].x,sprite[z].y,(short)zz) != 0)
+                { sprite[z].sectnum = zz; break; }
 
-		sprite[z].z = -(sect[sprite[z].sectnum].floorz<<8);
-		sprite[z].clipdist = 32;
-		sprite[z].xrepeat = 64;
-		sprite[z].yrepeat = 64;
-		sprite[z].picnum = thinglookup[thing[z].type];
-		sprite[z].ang = ((-((thing[z].ang<<11)/360))&2047);
+        sprite[z].z = -(sect[sprite[z].sectnum].floorz<<8);
+        sprite[z].clipdist = 32;
+        sprite[z].xrepeat = 64;
+        sprite[z].yrepeat = 64;
+        sprite[z].picnum = thinglookup[thing[z].type];
+        sprite[z].ang = ((-((thing[z].ang<<11)/360))&2047);
 
 
-		for(i=0;i<numthings;i++)
-			if ((thing[z].type >= thingnum[i]) && (thing[z].type <= thingnum2[i]))
-				for(j=thingoff[i];j<thingoff[i+1];j++)
-				{
-					k = thingfield[j]; zz = thingval[j];
-					switch(thingop[j])
-					{
-						case 0: setspritefield(z,k,zz); break;
-						case 1: setspritefield(z,k,getspritefield(z,k)+zz); break;
-						case 2: setspritefield(z,k,getspritefield(z,k)-zz); break;
-						case 3: setspritefield(z,k,getspritefield(z,k)|zz); break;
-						case 4: setspritefield(z,k,getspritefield(z,k)&zz); break;
-						case 5: setspritefield(z,k,getspritefield(z,k)^zz); break;
-					}
-				}
-	}
+        for(i=0;i<numthings;i++)
+            if ((thing[z].type >= thingnum[i]) && (thing[z].type <= thingnum2[i]))
+                for(j=thingoff[i];j<thingoff[i+1];j++)
+                {
+                    k = thingfield[j]; zz = thingval[j];
+                    switch(thingop[j])
+                    {
+                        case 0: setspritefield(z,k,zz); break;
+                        case 1: setspritefield(z,k,getspritefield(z,k)+zz); break;
+                        case 2: setspritefield(z,k,getspritefield(z,k)-zz); break;
+                        case 3: setspritefield(z,k,getspritefield(z,k)|zz); break;
+                        case 4: setspritefield(z,k,getspritefield(z,k)&zz); break;
+                        case 5: setspritefield(z,k,getspritefield(z,k)^zz); break;
+                    }
+                }
+    }
 
-	for(zx=0;zx<numwalls;zx++)
-	{
-		z = linindex[zx];
-		for(i=0;i<numtags;i++)
-		{
-			if ((line[z].special < tagnum[i]) || (line[z].special > tagnum2[i])) continue;
+    for(zx=0;zx<numwalls;zx++)
+    {
+        z = linindex[zx];
+        for(i=0;i<numtags;i++)
+        {
+            if ((line[z].special < tagnum[i]) || (line[z].special > tagnum2[i])) continue;
 
-			for(j=tagoff[i];j<tagoff[i+1];j++)
-			{
-				k = (tagfield[j]&127);
-				zz = tagval[j]; if (zz == INT32_MIN) zz = line[z].tag;
-				if (k < 32)
-				{
-					l = sectorofwall[zx];
-					if (wall[zx].nextsector >= 0)
-						if ((tagfield[j]&128) ^ (picindex[zx] == line[z].side1))
-							l = wall[zx].nextsector;
+            for(j=tagoff[i];j<tagoff[i+1];j++)
+            {
+                k = (tagfield[j]&127);
+                zz = tagval[j]; if (zz == INT32_MIN) zz = line[z].tag;
+                if (k < 32)
+                {
+                    l = sectorofwall[zx];
+                    if (wall[zx].nextsector >= 0)
+                        if ((tagfield[j]&128) ^ (picindex[zx] == line[z].side1))
+                            l = wall[zx].nextsector;
 
-					zzz = sectspri[l][(tagfield[j]>>8)&7];
-					if (zzz < 0)
-					{
-						zzz = dnumthings++;
-						sectspri[l][(tagfield[j]>>8)&7] = zzz;
-						zzx = sector[l].wallptr; x1 = wall[zzx].x; y1 = wall[zzx].y;
-						zzx = wall[zzx].point2; x2 = wall[zzx].x; y2 = wall[zzx].y;
-						sprite[zzz].x = ((x1+x2)>>1) + ksgn(y1-y2);
-						sprite[zzz].y = ((y1+y2)>>1) + ksgn(x2-x1);
-						sprite[zzz].sectnum = l;
-						sprite[zzz].z = sector[l].floorz;
-						sprite[zzz].clipdist = 32;
-						sprite[zzz].xrepeat = 64;
-						sprite[zzz].yrepeat = 64;
-					}
+                    zzz = sectspri[l][(tagfield[j]>>8)&7];
+                    if (zzz < 0)
+                    {
+                        zzz = dnumthings++;
+                        sectspri[l][(tagfield[j]>>8)&7] = zzz;
+                        zzx = sector[l].wallptr; x1 = wall[zzx].x; y1 = wall[zzx].y;
+                        zzx = wall[zzx].point2; x2 = wall[zzx].x; y2 = wall[zzx].y;
+                        sprite[zzz].x = ((x1+x2)>>1) + ksgn(y1-y2);
+                        sprite[zzz].y = ((y1+y2)>>1) + ksgn(x2-x1);
+                        sprite[zzz].sectnum = l;
+                        sprite[zzz].z = sector[l].floorz;
+                        sprite[zzz].clipdist = 32;
+                        sprite[zzz].xrepeat = 64;
+                        sprite[zzz].yrepeat = 64;
+                    }
 
-					switch(tagop[j])
-					{
-						case 0: setspritefield(zzz,k,zz); break;
-						case 1: setspritefield(zzz,k,getspritefield(zzz,k)+zz); break;
-						case 2: setspritefield(zzz,k,getspritefield(zzz,k)-zz); break;
-						case 3: setspritefield(zzz,k,getspritefield(zzz,k)|zz); break;
-						case 4: setspritefield(zzz,k,getspritefield(zzz,k)&zz); break;
-						case 5: setspritefield(zzz,k,getspritefield(zzz,k)^zz); break;
-					}
-				}
-				else if (k < 64)
-				{
-					l = sectorofwall[zx];
-					if (wall[zx].nextsector >= 0)
-						if ((tagfield[j]&128) ^ (picindex[zx] == line[z].side1))
-							l = wall[zx].nextsector;
+                    switch(tagop[j])
+                    {
+                        case 0: setspritefield(zzz,k,zz); break;
+                        case 1: setspritefield(zzz,k,getspritefield(zzz,k)+zz); break;
+                        case 2: setspritefield(zzz,k,getspritefield(zzz,k)-zz); break;
+                        case 3: setspritefield(zzz,k,getspritefield(zzz,k)|zz); break;
+                        case 4: setspritefield(zzz,k,getspritefield(zzz,k)&zz); break;
+                        case 5: setspritefield(zzz,k,getspritefield(zzz,k)^zz); break;
+                    }
+                }
+                else if (k < 64)
+                {
+                    l = sectorofwall[zx];
+                    if (wall[zx].nextsector >= 0)
+                        if ((tagfield[j]&128) ^ (picindex[zx] == line[z].side1))
+                            l = wall[zx].nextsector;
 
-					switch(tagop[j])
-					{
-						case 0: setsectorfield(l,k,zz); break;
-						case 1: setsectorfield(l,k,getsectorfield(l,k)+zz); break;
-						case 2: setsectorfield(l,k,getsectorfield(l,k)-zz); break;
-						case 3: setsectorfield(l,k,getsectorfield(l,k)|zz); break;
-						case 4: setsectorfield(l,k,getsectorfield(l,k)&zz); break;
-						case 5: setsectorfield(l,k,getsectorfield(l,k)^zz); break;
-					}
-				}
-				else if (k < 96)
-				{
-					l = zx;
-					if (wall[zx].nextwall >= 0)
-						if ((tagfield[j]&128) ^ (picindex[zx] == line[z].side1))
-							l = wall[zx].nextwall;
+                    switch(tagop[j])
+                    {
+                        case 0: setsectorfield(l,k,zz); break;
+                        case 1: setsectorfield(l,k,getsectorfield(l,k)+zz); break;
+                        case 2: setsectorfield(l,k,getsectorfield(l,k)-zz); break;
+                        case 3: setsectorfield(l,k,getsectorfield(l,k)|zz); break;
+                        case 4: setsectorfield(l,k,getsectorfield(l,k)&zz); break;
+                        case 5: setsectorfield(l,k,getsectorfield(l,k)^zz); break;
+                    }
+                }
+                else if (k < 96)
+                {
+                    l = zx;
+                    if (wall[zx].nextwall >= 0)
+                        if ((tagfield[j]&128) ^ (picindex[zx] == line[z].side1))
+                            l = wall[zx].nextwall;
 
-					switch(tagop[j])
-					{
-						case 0: setwallfield(l,k,zz); break;
-						case 1: setwallfield(l,k,getwallfield(l,k)+zz); break;
-						case 2: setwallfield(l,k,getwallfield(l,k)-zz); break;
-						case 3: setwallfield(l,k,getwallfield(l,k)|zz); break;
-						case 4: setwallfield(l,k,getwallfield(l,k)&zz); break;
-						case 5: setwallfield(l,k,getwallfield(l,k)^zz); break;
-					}
-				}
-			}
-		}
-	}
+                    switch(tagop[j])
+                    {
+                        case 0: setwallfield(l,k,zz); break;
+                        case 1: setwallfield(l,k,getwallfield(l,k)+zz); break;
+                        case 2: setwallfield(l,k,getwallfield(l,k)-zz); break;
+                        case 3: setwallfield(l,k,getwallfield(l,k)|zz); break;
+                        case 4: setwallfield(l,k,getwallfield(l,k)&zz); break;
+                        case 5: setwallfield(l,k,getwallfield(l,k)^zz); break;
+                    }
+                }
+            }
+        }
+    }
 
-	for(l=0;l<dnumsectors;l++)
-		for(i=0;i<numsecs;i++)
-			if ((sect[l].type >= secnum[i]) && (sect[l].type <= secnum2[i]))
-			{
-				for(j=secoff[i];j<secoff[i+1];j++)
-				{
-					k = (secfield[j]&127);
-					zz = secval[j]; if (zz == INT32_MIN) zz = sect[l].tag;
-					if (k < 32)
-					{
-						zzz = sectspri[l][(secfield[j]>>8)&7];
-						if (zzz < 0)
-						{
-							zzz = dnumthings++;
-							sectspri[l][(secfield[j]>>8)&7] = zzz;
-							zzx = sector[l].wallptr; x1 = wall[zzx].x; y1 = wall[zzx].y;
-							zzx = wall[zzx].point2; x2 = wall[zzx].x; y2 = wall[zzx].y;
-							sprite[zzz].x = ((x1+x2)>>1) + ksgn(y1-y2);
-							sprite[zzz].y = ((y1+y2)>>1) + ksgn(x2-x1);
-							sprite[zzz].sectnum = l;
-							sprite[zzz].z = sector[l].floorz;
-							sprite[zzz].clipdist = 32;
-							sprite[zzz].xrepeat = 64;
-							sprite[zzz].yrepeat = 64;
-						}
+    for(l=0;l<dnumsectors;l++)
+        for(i=0;i<numsecs;i++)
+            if ((sect[l].type >= secnum[i]) && (sect[l].type <= secnum2[i]))
+            {
+                for(j=secoff[i];j<secoff[i+1];j++)
+                {
+                    k = (secfield[j]&127);
+                    zz = secval[j]; if (zz == INT32_MIN) zz = sect[l].tag;
+                    if (k < 32)
+                    {
+                        zzz = sectspri[l][(secfield[j]>>8)&7];
+                        if (zzz < 0)
+                        {
+                            zzz = dnumthings++;
+                            sectspri[l][(secfield[j]>>8)&7] = zzz;
+                            zzx = sector[l].wallptr; x1 = wall[zzx].x; y1 = wall[zzx].y;
+                            zzx = wall[zzx].point2; x2 = wall[zzx].x; y2 = wall[zzx].y;
+                            sprite[zzz].x = ((x1+x2)>>1) + ksgn(y1-y2);
+                            sprite[zzz].y = ((y1+y2)>>1) + ksgn(x2-x1);
+                            sprite[zzz].sectnum = l;
+                            sprite[zzz].z = sector[l].floorz;
+                            sprite[zzz].clipdist = 32;
+                            sprite[zzz].xrepeat = 64;
+                            sprite[zzz].yrepeat = 64;
+                        }
 
-						switch(secop[j])
-						{
-							case 0: setspritefield(zzz,k,zz); break;
-							case 1: setspritefield(zzz,k,getspritefield(zzz,k)+zz); break;
-							case 2: setspritefield(zzz,k,getspritefield(zzz,k)-zz); break;
-							case 3: setspritefield(zzz,k,getspritefield(zzz,k)|zz); break;
-							case 4: setspritefield(zzz,k,getspritefield(zzz,k)&zz); break;
-							case 5: setspritefield(zzz,k,getspritefield(zzz,k)^zz); break;
-						}
-					}
-					else if (k < 64)
-					{
-						switch(secop[j])
-						{
-							case 0: setsectorfield(l,k,zz); break;
-							case 1: setsectorfield(l,k,getsectorfield(l,k)+zz); break;
-							case 2: setsectorfield(l,k,getsectorfield(l,k)-zz); break;
-							case 3: setsectorfield(l,k,getsectorfield(l,k)|zz); break;
-							case 4: setsectorfield(l,k,getsectorfield(l,k)&zz); break;
-							case 5: setsectorfield(l,k,getsectorfield(l,k)^zz); break;
-						}
-					}
-				}
-			}
+                        switch(secop[j])
+                        {
+                            case 0: setspritefield(zzz,k,zz); break;
+                            case 1: setspritefield(zzz,k,getspritefield(zzz,k)+zz); break;
+                            case 2: setspritefield(zzz,k,getspritefield(zzz,k)-zz); break;
+                            case 3: setspritefield(zzz,k,getspritefield(zzz,k)|zz); break;
+                            case 4: setspritefield(zzz,k,getspritefield(zzz,k)&zz); break;
+                            case 5: setspritefield(zzz,k,getspritefield(zzz,k)^zz); break;
+                        }
+                    }
+                    else if (k < 64)
+                    {
+                        switch(secop[j])
+                        {
+                            case 0: setsectorfield(l,k,zz); break;
+                            case 1: setsectorfield(l,k,getsectorfield(l,k)+zz); break;
+                            case 2: setsectorfield(l,k,getsectorfield(l,k)-zz); break;
+                            case 3: setsectorfield(l,k,getsectorfield(l,k)|zz); break;
+                            case 4: setsectorfield(l,k,getsectorfield(l,k)&zz); break;
+                            case 5: setsectorfield(l,k,getsectorfield(l,k)^zz); break;
+                        }
+                    }
+                }
+            }
 
-	for(z=0;z<dnumsectors;z++)
-	{
-		sector[z].ceilingpicnum = texturelookup[sector[z].ceilingpicnum];
-		sector[z].floorpicnum = texturelookup[sector[z].floorpicnum];
-	}
-	for(z=0;z<numwalls;z++)
-	{
-		x = wall[wall[z].point2].x-wall[z].x;
-		y = wall[wall[z].point2].y-wall[z].y;
-		if ((klabs(x) >= 32768) || (klabs(y) >= 32768))
-			wall[z].xrepeat = 255;
-		else
-		{
-			zx = mulscale10(ksqrtasm(x*x+y*y),wall[z].yrepeat);
-			wall[z].xrepeat = (char)min(max(zx,1),255);
-		}
+    for(z=0;z<dnumsectors;z++)
+    {
+        sector[z].ceilingpicnum = texturelookup[sector[z].ceilingpicnum];
+        sector[z].floorpicnum = texturelookup[sector[z].floorpicnum];
+    }
+    for(z=0;z<numwalls;z++)
+    {
+        x = wall[wall[z].point2].x-wall[z].x;
+        y = wall[wall[z].point2].y-wall[z].y;
+        if ((klabs(x) >= 32768) || (klabs(y) >= 32768))
+            wall[z].xrepeat = 255;
+        else
+        {
+            zx = mulscale10(ksqrtasm(x*x+y*y),wall[z].yrepeat);
+            wall[z].xrepeat = (char)min(max(zx,1),255);
+        }
 
-		wall[z].picnum = texturelookup[wall[z].picnum];
-		wall[z].overpicnum = texturelookup[wall[z].overpicnum];
-	}
+        wall[z].picnum = texturelookup[wall[z].picnum];
+        wall[z].overpicnum = texturelookup[wall[z].overpicnum];
+    }
 
-	mapversion = 7; posx = 0; posy = 0; posz = 0; ang = 1536; cursectnum = 0;
+    mapversion = 7; posx = 0; posy = 0; posz = 0; ang = 1536; cursectnum = 0;
 
-		//WATCH OUT THAT FOR DNUMTHINGS BEING HIGHER THAN NUMBER ON DOOM MAP!
-	for(i=0;i<dnumthings;i++)
-		if (thing[i].type == 1)
-		{
-			posx = (((int)thing[i].x-cx)<<4);
-			posy = (((int)-thing[i].y-cy)<<4);
+        //WATCH OUT THAT FOR DNUMTHINGS BEING HIGHER THAN NUMBER ON DOOM MAP!
+    for(i=0;i<dnumthings;i++)
+        if (thing[i].type == 1)
+        {
+            posx = (((int)thing[i].x-cx)<<4);
+            posy = (((int)-thing[i].y-cy)<<4);
 
-			cursectnum = 0;
-			for(zz=0;zz<dnumsectors;zz++)
-				if (inside(posx,posy,(short)zz) != 0)
-					{ cursectnum = zz; break; }
+            cursectnum = 0;
+            for(zz=0;zz<dnumsectors;zz++)
+                if (inside(posx,posy,(short)zz) != 0)
+                    { cursectnum = zz; break; }
 
-			posz = -(sect[cursectnum].floorz<<8) - (32<<8);
-			ang = ((-((thing[i].ang<<11)/360))&2047);
-			break;
-		}
+            posz = -(sect[cursectnum].floorz<<8) - (32<<8);
+            ang = ((-((thing[i].ang<<11)/360))&2047);
+            break;
+        }
 
-	//getch();
+    //getch();
 
-	//setvmode(0x3);
+    //setvmode(0x3);
 
-	strcpy(buildmap,doommap);
-	if (strchr(buildmap,'.') == 0) strcat(buildmap,".map");
-	if ((fil = Bopen(buildmap,BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
-	{
-		printf("Could not write to %s\n",buildmap);
-		exit(0);
-	}
-	Bwrite(fil,&mapversion,4);
-	Bwrite(fil,&posx,4);
-	Bwrite(fil,&posy,4);
-	Bwrite(fil,&posz,4);
-	Bwrite(fil,&ang,2);
-	Bwrite(fil,&cursectnum,2);
-	Bwrite(fil,&dnumsectors,2);
-	Bwrite(fil,sector,sizeof(sectortype)*dnumsectors);
-	Bwrite(fil,&numwalls,2);
-	Bwrite(fil,wall,sizeof(walltype)*numwalls);
-	Bwrite(fil,&dnumthings,2);
-	Bwrite(fil,sprite,sizeof(spritetype)*dnumthings);
-	Bclose(fil);
+    strcpy(buildmap,doommap);
+    if (strchr(buildmap,'.') == 0) strcat(buildmap,".map");
+    if ((fil = Bopen(buildmap,BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
+    {
+        printf("Could not write to %s\n",buildmap);
+        exit(0);
+    }
+    Bwrite(fil,&mapversion,4);
+    Bwrite(fil,&posx,4);
+    Bwrite(fil,&posy,4);
+    Bwrite(fil,&posz,4);
+    Bwrite(fil,&ang,2);
+    Bwrite(fil,&cursectnum,2);
+    Bwrite(fil,&dnumsectors,2);
+    Bwrite(fil,sector,sizeof(sectortype)*dnumsectors);
+    Bwrite(fil,&numwalls,2);
+    Bwrite(fil,wall,sizeof(walltype)*numwalls);
+    Bwrite(fil,&dnumthings,2);
+    Bwrite(fil,sprite,sizeof(spritetype)*dnumthings);
+    Bclose(fil);
 
-	printf("Map converted.\n");
+    printf("Map converted.\n");
 
-	return 0;
+    return 0;
 }