REDRIVER2/src_rebuild/GAME/C/SPOOL.C

#include "THISDUST.H"

#ifndef PSX
#include <SDL.h>
#endif // !PSX
#include <STRINGS.H>

#include "LIBETC.H"
#include "PAD.H"
#include "SPOOL.H"
#include "MAP.H"
#include "SYSTEM.H"
#include "MAIN.H"
#include "XAPLAY.H"
#include "DIRECTOR.H"
#include "SOUND.H"
#include "TEXTURE.H"
#include "MODELS.H"
#include "OBJANIM.H"
#include "GLAUNCH.H"
#include "CARS.H"
#include "COSMETIC.H"
#include "DENTING.H"
#include "HANDLING.H"
#include "MISSION.H"
#include "CIV_AI.H"
#include "CAMERA.H"
#include "DR2ROADS.H"

int date_date = 0xA11;
int date_time = 0x27220B;

int SpecialByRegion[4][20] = {
	{5, 1, 3, 3, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 2, 3, 2, 2, 3, 0},
	{2, 4, 1, 1, 4, 4, 3, 3, 3, 3, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0},
	{2, 4, 1, 1, 1, 1, 1, 1, 4, 2, 3, 3, 5, 0, 0, 0, 0, 0, 0, 0},
	{2, 5, 4, 1, 2, 1, 4, 3, 2, 2, 2, 2, 3, 3, 3, 0, 0, 0, 0, 0},
};

char* model_spool_buffer = NULL;

int cell_objects_add[5];
int cell_slots_add[5];

SXYPAIR* Music_And_AmbientOffsets;

AreaDataStr* AreaData;
unsigned char* AreaTPages;	// 16 per area
int NumAreas;

char* RegionSpoolInfo;
unsigned short *spoolinfo_offsets;

char* specmallocptr;
char *specLoadBuffer;

int doSpooling = 1;

short loading_region[4];
int regions_unpacked[4];

int spool_regioncounter;
int spoolerror;	// UNUSED
int spool_regionpos;
volatile int spoolactive;	// volatile is required at least for PC
volatile int quickSpool;
int models_ready;

short specspooldata[3] = { 20, 10, 4 };

int tsetcounter;
int tsetpos;

int spoolcounter;
int spoolseek;		// Probably UNUSED

int loadbank_read;
int loadbank_write;

int spoolpos;
int spoolpos_reading;
int spoolpos_writing;

int allowSpecSpooling;
int startSpecSpool;

int unpack_roadmap_flag;
int unpack_cellptr_flag;

char *packed_cell_pointers;
SPL_REGIONINFO spool_regioninfo[8];

static int sectors_this_chunk;
static volatile int sectors_to_read;
static char *target_address;

static int nTPchunks;
static int nTPchunks_reading;
static int nTPchunks_writing;

static int ntpages;
static int current_sector;
static int switch_spooltype;

static int endchunk;
int send_bank;
int sample_chunk;
int chunk_complete;

int new_area_location;
int LoadingArea = 0;
unsigned short *newmodels;

struct SPOOLQ spooldata[48];

#if !defined(PSX) && !defined(SIMPLE_SPOOL)
#include <assert.h>

typedef void(*data_callbackFn)(void);
typedef void(*ready_callbackFn)(unsigned char intr, unsigned char *result);

data_callbackFn g_dataCallbackPC = NULL;
ready_callbackFn g_readyCallbackPC = NULL;
char g_sectorData[2048] = { 0 };
bool g_isSectorDataRead = false;
bool g_spoolDoneFlag = false;

extern char g_CurrentLevelFileName[64];

SDL_Thread* levelSpoolerPCThread = NULL;
SDL_mutex* levelSpoolerPCMutex = NULL;
volatile int levelSpoolerSeekCmd = 0;

//-----------------------------------------------------
// copies read sector data to addr
//-----------------------------------------------------
void getLevSectorPC(char* dest, int count)
{
	count *= 4;

#ifdef _DEBUG
	SPOOLQ* which = &spooldata[spoolpos_reading];
	sectors_this_chunk;
	current_sector;
	sectors_to_read;
#endif // _DEBUG

	assert(count <= 2048);
	assert(dest);
	assert(sectors_to_read > 0);

	//SDL_LockMutex(levelSpoolerPCMutex);

	memcpy(dest, g_sectorData, count);
	g_isSectorDataRead = true;

	//SDL_UnlockMutex(levelSpoolerPCMutex);
}

void levelSpoolerPCDataCallback(data_callbackFn cb)
{
	SDL_LockMutex(levelSpoolerPCMutex);
	g_dataCallbackPC = cb;
	SDL_UnlockMutex(levelSpoolerPCMutex);
}

void levelSpoolerPCReadyCallback(ready_callbackFn cb)
{
	SDL_LockMutex(levelSpoolerPCMutex);
	g_readyCallbackPC = cb;
	SDL_UnlockMutex(levelSpoolerPCMutex);
}

// Main spooler thread function
int levelSpoolerPCFunc(void* data)
{
	//Print incoming data
	printWarning("Running SPOOL thread...\n");

	g_spoolDoneFlag = false;
	g_isSectorDataRead = false;

	ready_callbackFn readyCb = g_readyCallbackPC;
	data_callbackFn dataCb = g_dataCallbackPC;

	FILE* fp = fopen(g_CurrentLevelFileName, "rb");
	if (!fp)
	{
		char errPrint[1024];
		sprintf(errPrint, "Cannot open '%s'\n", g_CurrentLevelFileName);
		SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "ERROR", errPrint, NULL);

		if (readyCb)
			readyCb(0, { 0x0 });

		return -1;
	}

	do
	{
		SDL_LockMutex(levelSpoolerPCMutex);

		if (levelSpoolerSeekCmd != 0)
		{
			int sector = levelSpoolerSeekCmd;

			if (sector == -1)
			{
				printInfo("SPOOL thread recieved 'CdlPause'\n", sector);

				levelSpoolerSeekCmd = 0;
				g_spoolDoneFlag = true;
			}
			else
			{
				printInfo("SPOOL thread recieved 'CdlReadS' at %d\n", sector);

				// seek
				fseek(fp, sector * 2048, SEEK_SET);
				levelSpoolerSeekCmd = 0;
			}
		}

		dataCb = g_dataCallbackPC;
		readyCb = g_readyCallbackPC;

		SDL_UnlockMutex(levelSpoolerPCMutex);

		// clear sector before proceed
		ClearMem(g_sectorData, sizeof(g_sectorData));
		fread(g_sectorData, 1, 2048, fp);

		g_isSectorDataRead = false;

		if (readyCb)
		{
			readyCb(1, { 0x0 });
			
			if (g_isSectorDataRead && dataCb)
				dataCb();
		}
		else
			break;

	} while (!g_spoolDoneFlag);

	printInfo("SPOOLER thread work done.\n");

	fclose(fp);

	return 0;
}

//-----------------------------------------------------
// reads sector from LEV file
//-----------------------------------------------------
void startReadLevSectorsPC(int sector)
{
	if (!levelSpoolerPCMutex)
		levelSpoolerPCMutex = SDL_CreateMutex();

	SDL_LockMutex(levelSpoolerPCMutex);
	levelSpoolerSeekCmd = sector;
	SDL_UnlockMutex(levelSpoolerPCMutex);

	if (levelSpoolerPCThread && g_spoolDoneFlag)
	{
		int returnValue;
		SDL_WaitThread(levelSpoolerPCThread, &returnValue);

		levelSpoolerPCThread = NULL;
	}

	if (!levelSpoolerPCThread)
	{
		levelSpoolerPCThread = SDL_CreateThread(levelSpoolerPCFunc, "Spooler", NULL);

		if (NULL == levelSpoolerPCThread)
		{
			printError("SDL_CreateThread failed: %s\n", SDL_GetError());
		}
	}
}
#endif // !PSX

// decompiled code
// original method signature: 
// void /*$ra*/ test_changemode()
 // line 532, offset 0x0007b228
	/* begin block 1 */
		// Start line: 534
		// Start offset: 0x0007B228
		// Variables:
	// 		struct SPOOLQ *current; // $a3
	/* end block 1 */
	// End offset: 0x0007B3B4
	// End Line: 588

	/* begin block 2 */
		// Start line: 1064
	/* end block 2 */
	// End Line: 1065

	/* begin block 3 */
		// Start line: 1065
	/* end block 3 */
	// End Line: 1066

	/* begin block 4 */
		// Start line: 1067
	/* end block 4 */
	// End Line: 1068

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void test_changemode(void)
{
#ifndef SIMPLE_SPOOL
	char bVar1;

	SPOOLQ *current = &spooldata[spoolpos_reading];

	if (spoolpos_reading == spoolcounter)
	{
		switch_spooltype = 0;

#ifdef PSX
		CdReadyCallback(0);
		CdControlF(CdlPause, 0);
#else
		levelSpoolerPCReadyCallback(NULL);
		levelSpoolerSeekCmd = -1;
#endif // PSX
	}
	else if (current_sector == current->sector)
	{
		target_address = current->addr;
		bVar1 = current->type;
		switch_spooltype = 1;

		if (bVar1 == 0)
		{
			sectors_to_read = spool_regioninfo[spool_regionpos + 1].nsectors;
			sectors_this_chunk = (current->nsectors);
#ifdef PSX
			CdReadyCallback(ready_cb_regions);
#else
			levelSpoolerPCReadyCallback(ready_cb_regions);
#endif // PSX
		}
		else if (bVar1 == 1)
		{
			sectors_to_read = 17;
			target_address += 0x4000;
			nTPchunks_reading = 0;
			nTPchunks_writing = 0;
			ntpages = tsetcounter;
			sectors_this_chunk = (uint)bVar1;
#ifdef PSX
			CdReadyCallback(ready_cb_textures);
#else
			levelSpoolerPCReadyCallback(ready_cb_textures);
#endif // PSX
		}
		else if (bVar1 == 2)
		{
			sectors_to_read = (current->nsectors);
			send_bank = (current->data);
			sample_chunk = 0;
			nTPchunks_reading = 0;
			nTPchunks_writing = 0;
			target_address = target_address + (loadbank_read & 1U) * 0x1000;
			sectors_this_chunk = (uint)bVar1;

#ifdef PSX
			CdReadyCallback(ready_cb_soundbank);
#else
			levelSpoolerPCReadyCallback(ready_cb_soundbank);
#endif // PSX
		}
		else if (bVar1 == 3)
		{
			sectors_to_read = (current->nsectors);
#ifdef PSX
			CdReadyCallback(ready_cb_misc);
#else
			levelSpoolerPCReadyCallback(ready_cb_misc);
#endif // PSX
		}
	}
	else
	{
		switch_spooltype = 0;

#ifdef PSX
		CdReadyCallback(0);
#else
		levelSpoolerPCReadyCallback(NULL);
#endif // PSX
	}
#endif // SIMPLE_SPOOL
}



// decompiled code
// original method signature: 
// void /*$ra*/ changemode(struct SPOOLQ *current /*$a0*/)
 // line 591, offset 0x0007e1a8
	/* begin block 1 */
		// Start line: 1182
	/* end block 1 */
	// End Line: 1183

	/* begin block 2 */
		// Start line: 5397
	/* end block 2 */
	// End Line: 5398

// [D]
void changemode(SPOOLQ *current)
{
#ifndef SIMPLE_SPOOL
	switch_spooltype = 0;
	endchunk = 0;

	switch (current->type)
	{
		case 0:
		{
#ifdef PSX
			CdDataCallback(data_cb_regions);
#else
			levelSpoolerPCDataCallback(data_cb_regions);
#endif // PSX
			break;
		}
		case 1:
		{
#ifdef PSX
			CdDataCallback(data_cb_textures);
#else
			levelSpoolerPCDataCallback(data_cb_textures);
#endif // PSX
			break;
		}
		case 2:
		{
#ifdef PSX
			CdDataCallback(data_cb_soundbank);
#else
			levelSpoolerPCDataCallback(data_cb_soundbank);
#endif // PSX
			break;
		}
		case 3:
		{
#ifdef PSX
			CdDataCallback(data_cb_misc);
#else
			levelSpoolerPCDataCallback(data_cb_misc);
#endif // PSX
			break;
		}
	}
#endif // SIMPLE_SPOOL
}



// decompiled code
// original method signature: 
// int /*$ra*/ check_regions_present()
 // line 625, offset 0x0007b3c4
	/* begin block 1 */
		// Start line: 627
		// Start offset: 0x0007B3C4
		// Variables:
	// 		struct AREA_LOAD_INFO regions_to_unpack[3]; // stack offset -160
	// 		int leftright_unpack; // $a2
	// 		int topbottom_unpack; // $a3
	// 		int num_regions_to_unpack; // $a1
	// 		int x; // $v1
	// 		int z; // $v0
	// 		int loop; // $t1
	// 		int retval; // $a3
	// 		int region_to_unpack; // $a0
	// 		int barrel_region; // $v1
	// 		char textbuf[128]; // stack offset -136
	/* end block 1 */
	// End offset: 0x0007B6C4
	// End Line: 771

	/* begin block 2 */
		// Start line: 1267
	/* end block 2 */
	// End Line: 1268

	/* begin block 3 */
		// Start line: 1268
	/* end block 3 */
	// End Line: 1269

	/* begin block 4 */
		// Start line: 1269
	/* end block 4 */
	// End Line: 1270

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
int check_regions_present(void)
{
	AREA_LOAD_INFO *pAVar1;
	int iVar2;
	int iVar3;
	int iVar4;
	int iVar5;
	AREA_LOAD_INFO *pAVar6;
	AREA_LOAD_INFO region_to_unpack[3];
	char textbuf[128];

	pAVar6 = region_to_unpack;
	iVar4 = 0;
	iVar5 = 0;
	iVar3 = 0;
	if (current_barrel_region_xcell < 9) {
		region_to_unpack[0].xoffset = -1;
		if (region_x != 0) {
			iVar4 = 1;
		LAB_0007b44c:
			iVar3 = 1;
			region_to_unpack[0].zoffset = 0;
		}
	}
	else {
		if (0x17 < current_barrel_region_xcell) {
			iVar2 = cells_across;
			if (cells_across < 0) {
				iVar2 = cells_across + 0x1f;
			}
			region_to_unpack[0].xoffset = 1;
			if (region_x < iVar2 >> 5) {
				iVar4 = 2;
				goto LAB_0007b44c;
			}
		}
	}
	if (current_barrel_region_zcell < 9) {
		if (region_z == 0) goto LAB_0007b4e0;
		iVar5 = 1;
		region_to_unpack[iVar3].xoffset = 0;
		iVar2 = -1;
	}
	else {
		if ((current_barrel_region_zcell < 0x18) || (region_z == 0)) goto LAB_0007b4e0;
		iVar5 = 2;
		region_to_unpack[iVar3].xoffset = 0;
		iVar2 = 1;
	}
	pAVar1 = region_to_unpack + iVar3;
	iVar3 = iVar3 + 1;
	pAVar1->zoffset = iVar2;
LAB_0007b4e0:
	if (iVar3 == 2) {
		if (iVar5 == 1) {
			iVar3 = 3;
			if (iVar4 == 1) {
				region_to_unpack[2].xoffset = -1;
				region_to_unpack[2].zoffset = -1;
			}
			else {
				region_to_unpack[2].xoffset = 1;
				region_to_unpack[2].zoffset = -1;
			}
		}
		else {
			iVar3 = 3;
			if (iVar4 == 1) {
				region_to_unpack[2].xoffset = -1;
			}
			else {
				region_to_unpack[2].xoffset = 1;
			}
			region_to_unpack[2].zoffset = 1;
		}
	}
	iVar4 = 0;
	while (iVar3 != 0) {
		iVar5 = cells_across;
		if (cells_across < 0) {
			iVar5 = cells_across + 0x1f;
		}
		iVar5 = current_region + *(int *)pAVar6 + ((int *)pAVar6)[1] * (iVar5 >> 5);
		if ((((int)loading_region[(region_x + *(int *)pAVar6 & 1U) + (region_z + ((int *)pAVar6)[1] & 1U) * 2] !=
			-1) && (spoolinfo_offsets[iVar5] != 0xffff)) &&
			((int)loading_region
				[(region_x + *(int *)pAVar6 & 1U) + (region_z + ((int *)pAVar6)[1] & 1U) * 2] ==
				iVar5)) {
			iVar4 = iVar4 + 1;
		}
		iVar3 = iVar3 + -1;
		pAVar6 = (AREA_LOAD_INFO *)((int *)pAVar6 + 2);
	}
	if (LoadingArea != 0) {
		if (new_area_location == 1) {
			if (0x1a < current_barrel_region_xcell) {
				iVar4 = iVar4 + 1;
			}
		}
		else {
			if (new_area_location < 2) {
				if ((new_area_location == 0) && (0x1a < current_barrel_region_zcell)) {
					iVar4 = iVar4 + 1;
				}
			}
			else {
				iVar3 = current_barrel_region_zcell;
				if (((new_area_location == 2) ||
					(iVar3 = current_barrel_region_xcell, new_area_location == 3)) && (iVar3 < 6)) {
					iVar4 = iVar4 + 1;
				}
			}
		}
	}
	return iVar4;
}



// decompiled code
// original method signature: 
// void /*$ra*/ stopgame()
 // line 818, offset 0x0007e958
	/* begin block 1 */
		// Start line: 822
		// Start offset: 0x0007E958
	/* end block 1 */
	// End offset: 0x0007E9A0
	// End Line: 827

	/* begin block 2 */
		// Start line: 1636
	/* end block 2 */
	// End Line: 1637

	/* begin block 3 */
		// Start line: 8809
	/* end block 3 */
	// End Line: 8810

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void stopgame(void)
{
	StopPadVibration(0);
	StopPadVibration(1);
	PauseSFX();
	DrawSync(0);
	PutDrawEnv(&last->draw);
}



// decompiled code
// original method signature: 
// void /*$ra*/ startgame()
 // line 829, offset 0x0007e9a0
	/* begin block 1 */
		// Start line: 831
		// Start offset: 0x0007E9A0
	/* end block 1 */
	// End offset: 0x0007E9D0
	// End Line: 833

	/* begin block 2 */
		// Start line: 8825
	/* end block 2 */
	// End Line: 8826

	/* begin block 3 */
		// Start line: 8828
	/* end block 3 */
	// End Line: 8829

	/* begin block 4 */
		// Start line: 8829
	/* end block 4 */
	// End Line: 8830

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void startgame(void)
{
	PutDrawEnv(&current->draw);
	UnPauseSFX();
}



// decompiled code
// original method signature: 
// void /*$ra*/ DrawCDicon()
 // line 836, offset 0x0007e24c
	/* begin block 1 */
		// Start line: 838
		// Start offset: 0x0007E24C
		// Variables:
	// 		unsigned short *palette; // $a1
	// 		int temp; // $a2
	// 		int i; // $a0
	// 		struct RECT dest; // stack offset -16
	/* end block 1 */
	// End offset: 0x0007E2CC
	// End Line: 856

	/* begin block 2 */
		// Start line: 5885
	/* end block 2 */
	// End Line: 5886

	/* begin block 3 */
		// Start line: 5886
	/* end block 3 */
	// End Line: 5887

/* WARNING: Unknown calling convention yet parameter storage is locked */

extern POLY_FT4 cd_sprite;
extern unsigned short cd_icon[288];

// [D]
void DrawCDicon(void)
{
	ushort *puVar1;
	int iVar2;
	RECT16 local_10;

	cd_icon[23] = cd_icon[11];
	iVar2 = 0xb;
	puVar1 = cd_icon + 10;
	do {
		iVar2 = iVar2 + -1;
		puVar1[1] = puVar1[2];
		puVar1 = puVar1 + 1;
	} while (-1 < iVar2);

	local_10.x = 960;
	local_10.y = 433;
	local_10.w = 16;
	local_10.h = 1;

	LoadImage(&local_10, (u_long *)(cd_icon + 10));
	DrawPrim(&cd_sprite);
	DrawSync(0);
}



// decompiled code
// original method signature: 
// void /*$ra*/ CheckValidSpoolData()
 // line 859, offset 0x0007e2cc
	/* begin block 1 */
		// Start line: 861
		// Start offset: 0x0007E2CC
		// Variables:
	// 		struct RECT dest; // stack offset -16
	/* end block 1 */
	// End offset: 0x0007E35C
	// End Line: 918

	/* begin block 2 */
		// Start line: 5946
	/* end block 2 */
	// End Line: 5947

	/* begin block 3 */
		// Start line: 5950
	/* end block 3 */
	// End Line: 5951

	/* begin block 4 */
		// Start line: 5951
	/* end block 4 */
	// End Line: 5952

	/* begin block 5 */
		// Start line: 5962
	/* end block 5 */
	// End Line: 5963

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void CheckValidSpoolData(void)
{
	if (models_ready != 0)
		init_spooled_models();

	if (spoolactive != 0)
	{
		if (check_regions_present() != 0)
		{
			stopgame();

			while (spoolactive != 0)
			{
				DrawCDicon();
				VSync(0);
			}

			startgame();

			PutDrawEnv(&current->draw);
			UnPauseSFX();
		}
	}
}



// decompiled code
// original method signature: 
// void /*$ra*/ UpdateSpool()
 // line 925, offset 0x0007b6c4
	/* begin block 1 */
		// Start line: 927
		// Start offset: 0x0007B6C4
		// Variables:
	// 		struct SPOOLQ *current; // $s0
	// 		struct CdlLOC pos; // stack offset -16
	/* end block 1 */
	// End offset: 0x0007B87C
	// End Line: 977

	/* begin block 2 */
		// Start line: 1793
	/* end block 2 */
	// End Line: 1794

	/* begin block 3 */
		// Start line: 1903
	/* end block 3 */
	// End Line: 1904

	/* begin block 4 */
		// Start line: 1904
	/* end block 4 */
	// End Line: 1905

	/* begin block 5 */
		// Start line: 1908
	/* end block 5 */
	// End Line: 1909

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void UpdateSpool(void)
{
#ifdef SIMPLE_SPOOL
	extern char g_CurrentLevelFileName[64];

	FILE* fp = fopen(g_CurrentLevelFileName, "rb");

	if (!fp)
	{
		char errPrint[1024];
		sprintf(errPrint, "Cannot open '%s'\n", g_CurrentLevelFileName);
		SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "ERROR", errPrint, NULL);
		return;
	}

	for (; spoolpos_reading < spoolcounter; spoolpos_reading++)
	{
		SPOOLQ *current = &spooldata[spoolpos_reading];

#ifdef _DEBUG
		char* nameType;
		switch (current->type)
		{
		case 0:	// regions
			nameType = "REGION"; 
			break;
		case 1:	// textures
			nameType = "TPAGE";
			break;
		case 2:	// sbk
			nameType = "SBK";
			break;
		case 3:	// misc
			nameType = "MISC";
			break;
		}

		printWarning("spool type=%s cb=%d sec=%d cnt=%d id=%d\n", nameType, current->func ? 1 : 0, current->sector, current->nsectors, spoolpos_reading);
#endif // _DEBUG

		// seek to required sector
		fseek(fp, current->sector * 2048, SEEK_SET);

		switch (current->type)
		{
		case 0:	// regions
			fread(current->addr, 2048, current->nsectors, fp);

			if (current->func)
				current->func();

			break;
		case 1:	// textures

			// read cluts
			nTPchunks = 0;
			fread(current->addr + 0x4000, 2048, 1, fp);
			SendTPage();

			nTPchunks++;

			// read tpage (4 sectors 4 times = 16)
			for (int i = 0; i < 4; i++)
			{
				fread(current->addr + (loadbank_write & 1U) * TPAGE_WIDTH * 32, 2048, 4, fp);
				SendTPage();

				nTPchunks++;
			}

			break;
		case 2:	// sbk
			// nothing to do with this
			break;
		case 3:	// misc
			fread(current->addr, 2048, current->nsectors, fp);

			if (current->func)
				current->func();

			break;
		}
	}

	spoolcounter = 0;
	spoolpos_reading = 0;
	spoolactive = 0;

	fclose(fp);
	
#else
	char bVar1;
	int iVar3;
	CdlLOC pos;

	iVar3 = XAPrepared();

	SPOOLQ *current = &spooldata[spoolpos_reading];

	if (iVar3 != 1) 
	{
		target_address = current->addr;
		bVar1 = current->type;

		if (bVar1 == 0) // SPOOLTYPE_REGIONS
		{
			sectors_this_chunk = (current->nsectors);
			sectors_to_read = spool_regioninfo[spool_regionpos].nsectors;

			spoolseek = 5;
#ifdef PSX
			CdDataCallback(data_cb_regions);
			CdReadyCallback(ready_cb_regions);
#else
			levelSpoolerPCDataCallback(data_cb_regions);
			levelSpoolerPCReadyCallback(ready_cb_regions);
#endif // PSX
		}
		else if (bVar1 == 1) // SPOOLTYPE_TEXTURES
		{
			spoolseek = 5;

			nTPchunks_reading = 0;
			nTPchunks_writing = 0;
			sectors_to_read = 17;
			ntpages = tsetcounter;
			sectors_this_chunk = (uint)bVar1;

#ifdef PSX
			CdDataCallback(data_cb_textures);
			CdReadyCallback(ready_cb_textures);
#else
			levelSpoolerPCDataCallback(data_cb_textures);
			levelSpoolerPCReadyCallback(ready_cb_textures);
#endif // PSX

			target_address = target_address + 0x4000;
		}
		else if (bVar1 == 2) // SPOOLTYPE_SOUNDBANK
		{
			sectors_to_read = (current->nsectors);

			send_bank = (current->data);
			spoolseek = 5;
			sample_chunk = 0;
			nTPchunks_reading = 0;
			nTPchunks_writing = 0;
			sectors_this_chunk = (uint)bVar1;

#ifdef PSX
			CdDataCallback(data_cb_soundbank);
			CdReadyCallback(ready_cb_soundbank);
#else
			levelSpoolerPCDataCallback(data_cb_soundbank);
			levelSpoolerPCReadyCallback(ready_cb_soundbank);
#endif // PSX

			target_address = target_address + (loadbank_read & 1U) * 0x1000;
		}
		else if (bVar1 == 3)  // SPOOLTYPE_MISC
		{
			sectors_to_read = (current->nsectors);

			spoolseek = 5;
#ifdef PSX
			CdDataCallback(data_cb_misc);
			CdReadyCallback(ready_cb_misc);
#else
			levelSpoolerPCDataCallback(data_cb_misc);
			levelSpoolerPCReadyCallback(ready_cb_misc);
#endif // PSX
		}

		current_sector = current->sector;
		endchunk = 0;
		switch_spooltype = 0;

		// run sector reading
#ifdef PSX
		CdIntToPos(current_sector, &pos);
		CdControlF(CdlReadS, (u_char*)&pos);
#else
		startReadLevSectorsPC(current_sector);
#endif // PSX
	}
#endif
}



// decompiled code
// original method signature: 
// void /*$ra*/ RequestSpool(int type /*$a0*/, int data /*$a1*/, int offset /*$a2*/, int loadsize /*$a3*/, char *address /*stack 16*/, TDRFuncPtr_RequestSpool5func func /*stack 20*/)
 // line 1104, offset 0x0007e36c
	/* begin block 1 */
		// Start line: 1105
		// Start offset: 0x0007E36C
		// Variables:
	// 		struct SPOOLQ *next; // $t0
	// 		int sector; // $v0
	/* end block 1 */
	// End offset: 0x0007E3E4
	// End Line: 1126

	/* begin block 2 */
		// Start line: 6440
	/* end block 2 */
	// End Line: 6441

	/* begin block 3 */
		// Start line: 6447
	/* end block 3 */
	// End Line: 6448

// [D]
#ifdef _DEBUG
void _RequestSpool(int type, int data, int offset, int loadsize, char *address, spooledFuncPtr func, const char* requestby, int line)
#define RequestSpool(type, data, offset, loadsize, loadaddr, func) _RequestSpool(type, data, offset, loadsize, loadaddr, func, __FUNCTION__, __LINE__)
#else
void RequestSpool(int type, int data, int offset, int loadsize, char *address, spooledFuncPtr func)
#endif _DEBUG
{
	if (!(spoolcounter < 48))
		trap(0x400);

	SPOOLQ *next;

	next = &spooldata[spoolcounter];

	next->type = type;
	next->data = data;
	next->sector = (citylumps[GameLevel][CITYLUMP_SPOOL].x / 2048) + offset;
	next->nsectors = loadsize;
	next->addr = address;
	next->func = func;

#ifdef _DEBUG
	next->requestby = requestby;
	next->requestbyline = line;
#endif // _DEBUG

	spoolcounter++;
}



// decompiled code
// original method signature: 
// void /*$ra*/ InitSpooling()
 // line 1129, offset 0x0007e494
	/* begin block 1 */
		// Start line: 1131
		// Start offset: 0x0007E494
		// Variables:
	// 		int i; // $s0
	// 		char namebuffer[128]; // stack offset -152
	// 		struct CdlLOC pos; // stack offset -24
	/* end block 1 */
	// End offset: 0x0007E528
	// End Line: 1158

	/* begin block 2 */
		// Start line: 7099
	/* end block 2 */
	// End Line: 7100

	/* begin block 3 */
		// Start line: 2258
	/* end block 3 */
	// End Line: 2259

	/* begin block 4 */
		// Start line: 7100
	/* end block 4 */
	// End Line: 7101

	/* begin block 5 */
		// Start line: 7105
	/* end block 5 */
	// End Line: 7106

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void InitSpooling(void)
{
	int target_region;

	target_region = 0;

	do {
		loading_region[target_region] = -1;
		ClearRegion(target_region);
		target_region++;
	} while (target_region < 4);

	newmodels = NULL;
	spool_regioncounter = 0;
	spoolerror = 0;
	spool_regionpos = 0;
	spoolactive = 0;
	tsetcounter = 0;
	models_ready = 0;
	tsetpos = 0;
	spoolcounter = 0;
	loadbank_read = 0;
	spoolpos = 0;
	unpack_roadmap_flag = 0;
	loadbank_write = 0;
	spoolseek = 0;
	unpack_cellptr_flag = 0;
}



// decompiled code
// original method signature: 
// void /*$ra*/ SendTPage()
 // line 1161, offset 0x0007b88c
	/* begin block 1 */
		// Start line: 1163
		// Start offset: 0x0007B88C
		// Variables:
	// 		int tpage2send; // $s2
	// 		int slot; // $s0
	// 		int old; // $v1
	// 		char *tpageaddress; // $t0

		/* begin block 1.1 */
			// Start line: 1176
			// Start offset: 0x0007B900
			// Variables:
		// 		struct RECT cluts; // stack offset -32
		// 		int npalettes; // $s1
		// 		int i; // $a3
		// 		unsigned long *clutptr; // $a1
		/* end block 1.1 */
		// End offset: 0x0007BA24
		// End Line: 1208
	/* end block 1 */
	// End offset: 0x0007BB14
	// End Line: 1235

	/* begin block 2 */
		// Start line: 2385
	/* end block 2 */
	// End Line: 2386

	/* begin block 3 */
		// Start line: 2386
	/* end block 3 */
	// End Line: 2387

	/* begin block 4 */
		// Start line: 2390
	/* end block 4 */
	// End Line: 2391

/* WARNING: Unknown calling convention yet parameter storage is locked */

int tsetinfo[32];

// [D]
void SendTPage(void)
{
	unsigned char bVar1;
	ulong *clutptr;
	int iVar5;
	int npalettes;
	int iVar7;
	RECT16 cluts;

	iVar7 = tsetinfo[tsetpos * 2];
	iVar5 = tsetinfo[tsetpos * 2 + 1];

	if (iVar7 == 0xFF || iVar5 == 0xFF)	// [A] bug fix
		return;

	if (nTPchunks == 0) 
	{
		if (iVar5 != tpageloaded[iVar7]-1)
		{
			npalettes = *(int *)(model_spool_buffer + 0xE000);

			tpage.w = 64;
			tpage.h = 64;
			cluts.w = 64;

			tpage.x = slot_tpagepos[iVar5].vx;
			tpage.y = slot_tpagepos[iVar5].vy;

			cluts.y = slot_clutpos[iVar5].vy;
			cluts.x = slot_clutpos[iVar5].vx;

			cluts.h = npalettes / 4 + 1;

			LoadImage(&cluts, (u_long *)(model_spool_buffer + 0xE000 + 4));

			clutptr = (ulong *)(texture_cluts[iVar7]);
			iVar5 = 0;

			if (0 < npalettes)
			{
				do {
					//int test1 = (uVar3 | iVar2 + 0x10 >> 4 & 0x3fU) << 0x10 | uVar3 | (int)((uint)cluts.x << 0x10) >> 0x14 & 0x3fU;
					//int test2 = (uVar3 | iVar2 + 0x30 >> 4 & 0x3fU) << 0x10 | uVar3 | iVar2 + 0x20 >> 4 & 0x3fU;

					clutptr[0] = getClut(cluts.x + 16, cluts.y) << 0x10 | getClut(cluts.x, cluts.y);
					clutptr[1] = getClut(cluts.x + 48, cluts.y) << 0x10 | getClut(cluts.x + 32, cluts.y);

					clutptr+=2;
					cluts.y++;
					iVar5 += 4;;
				} while (iVar5 < npalettes);
			}

			texture_pages[iVar7] = getTPage(0, 0, tpage.x, tpage.y);

			// OLD VALUE: (short)(tpage.y & 0x100U) >> 4 | (ushort)(((uint)(ushort)tpage.x & 0x3ff) >> 6) | (ushort)(((uint)(ushort)tpage.y & 0x200) << 2);
			// please check me if above is correct
		}
	}
	else 
	{
		if (iVar5 != tpageloaded[iVar7] - 1) 
		{
			LoadImage(&tpage, (u_long *)(model_spool_buffer + 0xA000 + (loadbank_write % 2) * TPAGE_WIDTH * 32));
			tpage.y = tpage.y + tpage.h;
		}

		if (nTPchunks == 4)
		{
			bVar1 = tpageslots[iVar5];
			tpageslots[iVar5] = iVar7;

			if(bVar1 != 0xFF)	// [A] bug fix
				tpageloaded[bVar1] = 0;

			tpageloaded[iVar7] = iVar5 + 1;

			tsetpos++;

			if (tsetpos == tsetcounter)
			{
				tsetcounter = 0;
				tsetpos = 0;
			}
		}
	}
}



// decompiled code
// original method signature: 
// void /*$ra*/ SpoolSYNC()
 // line 1239, offset 0x0007e528
	/* begin block 1 */
		// Start line: 7247
	/* end block 1 */
	// End Line: 7248

	/* begin block 2 */
		// Start line: 7329
	/* end block 2 */
	// End Line: 7330

	/* begin block 3 */
		// Start line: 7345
	/* end block 3 */
	// End Line: 7346

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void SpoolSYNC(void)
{
	do {
	} while (spoolactive != 0);
}



// decompiled code
// original method signature: 
// void /*$ra*/ LoadInAreaTSets(int area /*$t4*/)
 // line 1262, offset 0x0007bb14
	/* begin block 1 */
		// Start line: 1263
		// Start offset: 0x0007BB14
		// Variables:
	// 		unsigned char *tpages; // $s1
	// 		int ntpages_to_load; // $s3
	// 		int i; // $s0
	// 		int slot; // $a0
	// 		int j; // $a1
	// 		int offset; // $s4
	// 		int availableslots[16]; // stack offset -104
	// 		int navailable; // $s2
	// 		char *loadaddr; // $fp
	/* end block 1 */
	// End offset: 0x0007BD84
	// End Line: 1333

	/* begin block 2 */
		// Start line: 2620
	/* end block 2 */
	// End Line: 2621

	/* begin block 3 */
		// Start line: 2648
	/* end block 3 */
	// End Line: 2649

	/* begin block 4 */
		// Start line: 2660
	/* end block 4 */
	// End Line: 2661

// [D]
void LoadInAreaTSets(int area)
{
	bool bVar1;
	
	uint uVar3;
	int iVar4;
	int offset;
	int *piVar5;
	int i;

	int slot;

	unsigned char *tpages;
	int ntpages_to_load;
	int navailable;

	char *loadaddr;
	int availableslots[16];

	tpages = AreaTPages + area * 16;
	ntpages_to_load = AreaData[area].num_tpages;

	loadaddr = model_spool_buffer + 0xA000;
	navailable = 0;

	if (slotsused < 19)
	{
		piVar5 = availableslots;
		slot = slotsused;

		do {
			offset = 0;

			if (tpageslots[slot] == 0xff) // [A]
			{
				*piVar5++ = slot;
				navailable++;
			}
			else 
			{
				if (ntpages_to_load != 0 && tpageslots[slot] != *tpages) // [A]
				{
					uVar3 = 1;
					do {
						offset = uVar3;

						if (ntpages_to_load <= offset)
							break;

						uVar3 = offset + 1;
					} while (tpageslots[slot] != tpages[offset]); // [A]
				}

				if (offset == ntpages_to_load)
				{
					*piVar5++ = slot;
					navailable++;
				}
			}

			slot++;
		} while (slot < 19);
	}

	offset = AreaData[area].gfx_offset;
	i = 0;

	if (ntpages_to_load != 0) 
	{
		uVar3 = *tpages;

		if (tpageloaded[uVar3] != 0)	// weird goto lol
		{
			goto LAB_0007bc94;
		}

		bVar1 = 0 < navailable;
		navailable--;

		if (bVar1) 
		{
			iVar4 = availableslots[navailable];

			while (true) 
			{
				tsetinfo[tsetcounter*2 + 1] = iVar4;

				while (true)
				{
					RequestSpool(1, 0, offset, 17, loadaddr, SendTPage);
					offset += 17;

					i++;
					tsetinfo[tsetcounter * 2] = *tpages;

					tsetcounter++;
					tpages++;

					if (ntpages_to_load <= i)
						return;

					uVar3 = *tpages;

					if (tpageloaded[uVar3] == 0)
						break;

				LAB_0007bc94:
					tsetinfo[tsetcounter * 2 + 1] = tpageloaded[uVar3] - 1;
				}

				if (navailable < 1)
					break;

				navailable--;

				iVar4 = availableslots[navailable];
			}
		}
	}
}



// decompiled code
// original method signature: 
// void /*$ra*/ SendSBK()
 // line 1337, offset 0x0007bd84
	/* begin block 1 */
		// Start line: 1339
		// Start offset: 0x0007BD84
		// Variables:
	// 		char *address; // $s0
	// 		int slength; // $s1
	// 		int i; // $a1
	// 		unsigned long *source; // $v0
	// 		unsigned long *dest; // $a0
	/* end block 1 */
	// End offset: 0x0007BEBC
	// End Line: 1380

	/* begin block 2 */
		// Start line: 2921
	/* end block 2 */
	// End Line: 2922

	/* begin block 3 */
		// Start line: 2926
	/* end block 3 */
	// End Line: 2927

	/* begin block 4 */
		// Start line: 2927
	/* end block 4 */
	// End Line: 2928

/* WARNING: Unknown calling convention yet parameter storage is locked */

void SendSBK(void)
{
	UNIMPLEMENTED();
	/*
	ulong uVar1;
	uint uVar2;
	SAMPLE_DATA *pSVar3;
	ulong *puVar4;
	uint uVar5;
	int *piVar6;
	int iVar7;

	piVar6 = (int *)(model_spool_buffer + (loadbank_write & 1U) * 0x1000 + 0x8000);
	if (sample_chunk == 0) {
		if (Song_ID != -1) {
			StopXM();
			FreeXM();
		}
		uVar5 = 0;
		pSVar3 = samples;
		num_samples = piVar6[1];
		uVar2 = num_samples << 2;
		puVar4 = (ulong *)(piVar6 + 2);
		if (uVar2 != 0) {
			do {
				uVar1 = *puVar4;
				puVar4 = puVar4 + 1;
				uVar5 = uVar5 + 1;
				pSVar3->address = uVar1;
				pSVar3 = (SAMPLE_DATA *)&pSVar3->length;
			} while (uVar5 < uVar2);
		}
		piVar6 = piVar6 + 1 + num_samples * 4 + 1;
		spuaddress = (&bankaddr)[send_bank];
		iVar7 = num_samples * -0x10 + 0xff8;
	}
	else {
		iVar7 = 0x1000;
	}
	SpuSetTransferMode(0);
	SpuSetTransferStartAddr(spuaddress);
	SpuWrite(piVar6, iVar7 + 0x3fU & 0xffffffc0);
	spuaddress = spuaddress + iVar7;
	sample_chunk = sample_chunk + 1;
	return;
	*/
}



// decompiled code
// original method signature: 
// void /*$ra*/ init_spooled_models()
 // line 1484, offset 0x0007bebc
	/* begin block 1 */
		// Start line: 1486
		// Start offset: 0x0007BEBC
		// Variables:
	// 		int i; // $s1
	// 		int nmodels; // $s4
	// 		int size; // $s2
	// 		int model_number; // $a1
	// 		char *addr; // $s0
	// 		struct MODEL *parentmodel; // $a1

		/* begin block 1.1 */
			// Start line: 1519
			// Start offset: 0x0007BFBC
		/* end block 1.1 */
		// End offset: 0x0007BFD0
		// End Line: 1521

		/* begin block 1.2 */
			// Start line: 1528
			// Start offset: 0x0007C004
		/* end block 1.2 */
		// End offset: 0x0007C048
		// End Line: 1536
	/* end block 1 */
	// End offset: 0x0007C08C
	// End Line: 1543

	/* begin block 2 */
		// Start line: 3131
	/* end block 2 */
	// End Line: 3132

	/* begin block 3 */
		// Start line: 3236
	/* end block 3 */
	// End Line: 3237

	/* begin block 4 */
		// Start line: 3237
	/* end block 4 */
	// End Line: 3238

	/* begin block 5 */
		// Start line: 3246
	/* end block 5 */
	// End Line: 3247

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void init_spooled_models(void)
{
	int nmodels;
	ushort lod;
	int model_number;
	MODEL *parentmodel;
	char *addr;
	MODEL *model;
	int i;
	int size;

	addr = model_spool_buffer;
	models_ready = 0;

	nmodels = *newmodels;

	printInfo("loading %d model slots\n", nmodels);

	//for (i = 0; i < 1536; i++)
	//{
	//	if (addr <= (char*)&modelpointers[i])
	//		modelpointers[i] = &dummyModel;
	//}

	unsigned short* new_model_numbers = newmodels + 1;

	for (i = 0; i < nmodels; i++)
	{
		model_number = new_model_numbers[i];

		size = *(int *)addr;
		model = (MODEL *)(addr + 4);

		modelpointers[model_number] = model;
		pLodModels[model_number] = model;

		lod = Low2LowerDetailTable[model_number];

		if (lod != 0xffff && lod != model_number)
			pLodModels[model_number] = modelpointers[lod];

		if (model->instance_number == -1)
		{
			if (model->collision_block != 0)
				model->collision_block += (int)model;

			model->vertices += (int)model;
			model->normals += (int)model;
			model->point_normals += (int)model;

			InitSpooledAnimObj(model_number);
		}
		else
		{
			parentmodel = modelpointers[model->instance_number];

			if (parentmodel->collision_block != 0)
				model->collision_block = parentmodel->collision_block;

			model->vertices = parentmodel->vertices;
			model->normals = parentmodel->normals;
			model->point_normals = parentmodel->point_normals;

			InitSpooledAnimObj(parentmodel->instance_number);
		}
		model->poly_block += (int)model;

		addr += size + 4;
	}

	LoadingArea = 0;
}



// decompiled code
// original method signature: 
// void /*$ra*/ SetupModels()
 // line 1545, offset 0x0007e540
	/* begin block 1 */
		// Start line: 7941
	/* end block 1 */
	// End Line: 7942

	/* begin block 2 */
		// Start line: 7945
	/* end block 2 */
	// End Line: 7946

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void SetupModels(void)
{
	if (old_region == -1)
		init_spooled_models();
	else
		models_ready = 1;
}



// decompiled code
// original method signature: 
// void /*$ra*/ LoadInAreaModels(int area /*$a0*/)
 // line 1559, offset 0x0007e580
	/* begin block 1 */
		// Start line: 1561
		// Start offset: 0x0007E580
		// Variables:
	// 		int offset; // $a2
	// 		int length; // $a3
	/* end block 1 */
	// End offset: 0x0007E5DC
	// End Line: 1571

	/* begin block 2 */
		// Start line: 7969
	/* end block 2 */
	// End Line: 7970

	/* begin block 3 */
		// Start line: 7970
	/* end block 3 */
	// End Line: 7971

	/* begin block 4 */
		// Start line: 7974
	/* end block 4 */
	// End Line: 7975

// [D]
void LoadInAreaModels(int area)
{
	if (newmodels)
	{
		// clear old model ids
		int nmodels = *newmodels;
		unsigned short* new_model_numbers = newmodels + 1;

		// set old model ids to dummy
		for (int i = 0; i < nmodels; i++)
		{
			int model_number = new_model_numbers[i];
			modelpointers[model_number] = &dummyModel;
		}

		printInfo("freed %d model slots\n", nmodels);
	}

	int length = AreaData[area].model_size;
	newmodels = (ushort *)(model_spool_buffer + (length-1) * 2048);

	RequestSpool(3, 0, AreaData[area].model_offset, length, model_spool_buffer, SetupModels);
}



// decompiled code
// original method signature: 
// void /*$ra*/ CheckLoadAreaData(int cellx /*$t9*/, int cellz /*$a1*/)
 // line 1574, offset 0x0007c08c
	/* begin block 1 */
		// Start line: 1575
		// Start offset: 0x0007C08C
		// Variables:
	// 		int i; // $a2
	// 		int nAreas; // $t0
	// 		struct Spool *spoolptr; // $t1
	// 		int load; // $a3
	// 		int force_load_boundary; // $a0
	/* end block 1 */
	// End offset: 0x0007C27C
	// End Line: 1666

	/* begin block 2 */
		// Start line: 3485
	/* end block 2 */
	// End Line: 3486

	/* begin block 3 */
		// Start line: 3517
	/* end block 3 */
	// End Line: 3518

	/* begin block 4 */
		// Start line: 3522
	/* end block 4 */
	// End Line: 3523

// [D]
void CheckLoadAreaData(int cellx, int cellz)
{
	int nAreas;
	int load;
	int force_load_boundary;
	int i;
	Spool *spoolptr;

	if (spoolinfo_offsets[current_region] == 0xffff)
		return;

	spoolptr = (Spool *)(RegionSpoolInfo + spoolinfo_offsets[current_region]);

#ifndef PSX
	if (LoadedArea != spoolptr->super_region && spoolptr->super_region != 0xFF && old_region != -1)
	{
		LoadedArea = spoolptr->super_region;
	}
	else
#endif
	if (old_region == -1 && spoolptr->super_region != 0xFF)
	{
		// just load the area if no
		LoadedArea = spoolptr->super_region;
	}
	else
	{
		nAreas = spoolptr->num_connected_areas;

		if (old_region == -1)
		{
			LoadedArea = -1;
		}
		else
		{
			//if (spoolptr->super_region == 0xFF)		// [A] if this is on, it stops spool. You still may want to load connected areas
			//	return;

			if (nAreas == 0)
				return;
		}

		force_load_boundary = (lead_car == 0) ? 15 : 13;

		// check area bounds
		for (i = 0; i < nAreas; i++)
		{
			load = spoolptr->connected_areas[i] >> 6;

			if (LoadedArea != (spoolptr->connected_areas[i] & 0x3f))
			{
				new_area_location = load;

				// [A] bounds?
				if (load == 0 && (32-force_load_boundary < cellz))
				{
					break;
				}
				else if (load == 1 && (32-force_load_boundary < cellx))
				{
					break;
				}
				else if (load == 2 && (cellz < force_load_boundary))
				{
					break;
				}
				else if (load == 3 && (cellx < force_load_boundary))
				{
					break;
				}
			}
		}

		if (nAreas == i)
		{
			if (LoadedArea != -1)
				return;

			LoadedArea = initarea;

			if (initarea == -1)
				return;
		}
		else
		{
			LoadedArea = spoolptr->connected_areas[i] & 0x3f;
		}
	}

	LoadingArea = 1;

	LoadInAreaTSets(LoadedArea);
	LoadInAreaModels(LoadedArea);
}



// decompiled code
// original method signature: 
// void /*$ra*/ ClearRegion(int target_region /*$a0*/)
 // line 1670, offset 0x0007e3e4
	/* begin block 1 */
		// Start line: 1671
		// Start offset: 0x0007E3E4
		// Variables:
	// 		int loop; // $a1
	// 		unsigned short *cell_ptrs_s; // $v1
	// 		unsigned long *pvsptr; // $v0
	/* end block 1 */
	// End offset: 0x0007E494
	// End Line: 1711

	/* begin block 2 */
		// Start line: 7049
	/* end block 2 */
	// End Line: 7050

	/* begin block 3 */
		// Start line: 7594
	/* end block 3 */
	// End Line: 7595

	/* begin block 4 */
		// Start line: 7604
	/* end block 4 */
	// End Line: 7605

// [D]
void ClearRegion(int target_region)
{
	long *pvsptr;
	ushort *cell_ptrs_s;
	int loop;

	loop = 1024;
	cell_ptrs_s = cell_ptrs + target_region * 1024;
	pvsptr = (long *)PVS_Buffers[target_region];

	do {
		*cell_ptrs_s++ = 0xffff;
		*pvsptr++ = 0;
	} while (--loop != 0);

	ClearMem(PVS_Buffers[target_region]-4, pvsSize[target_region]);

	RoadMapDataRegions[target_region] = (short*)PVS_Buffers[0];
}


// decompiled code
// original method signature: 
// int /*$ra*/ LoadRegionData(int region /*$s4*/, int target_region /*$s5*/)
 // line 1713, offset 0x0007c28c
	/* begin block 1 */
		// Start line: 1714
		// Start offset: 0x0007C28C
		// Variables:
	// 		int offset; // $s0
	// 		char *target_unpacked_data; // $t1
	// 		struct Spool *spoolptr; // $s1
	// 		char *roadmap_buffer; // $s6
	// 		char *cell_buffer; // $s3
	/* end block 1 */
	// End offset: 0x0007C464
	// End Line: 1776

	/* begin block 2 */
		// Start line: 3836
	/* end block 2 */
	// End Line: 3837

// [D]
int LoadRegionData(int region, int target_region)
{
	char *cell_buffer;
	ushort *spofs;
	int offset;
	Spool *spoolptr;
	char *roadmap_buffer;	// D1 leftover?

	roadmap_buffer = NULL; // [A]

	spofs = (spoolinfo_offsets + region);

	if (*spofs == 0xFFFF)	// has region offset?
		return 0;

	loading_region[target_region] = region;
	cell_buffer = packed_cell_pointers;
	spoolptr = (Spool *)(RegionSpoolInfo + *spofs);

	offset = spoolptr->offset;

//#define HAVANA_AUGUST_DEMO // uncomment to load August Demo HAVANA.LEV

#ifdef HAVANA_AUGUST_DEMO
	RequestSpool(0, 0, offset, spoolptr->roadm_size, PVS_Buffers[target_region], NULL);
	offset += spoolptr->roadm_size;

	RequestSpool(0, 0, offset, spoolptr->cell_data_size[1], packed_cell_pointers, NULL);
	offset += spoolptr->cell_data_size[1];
		
	RequestSpool(0, 0, offset, spoolptr->cell_data_size[0], (char *)(cells + cell_slots_add[target_region]), NULL);
	offset += spoolptr->cell_data_size[0];

	RequestSpool(0, 0, offset, spoolptr->cell_data_size[2], (char *)(cell_objects + num_straddlers + cell_objects_add[target_region]), GotRegion);
	offset += spoolptr->cell_data_size[2];

	//offset -= spoolptr->roadm_size; // [A] if PVS_Buffers loading temporarily disabled this should be uncommented

	spool_regioninfo[spool_regioncounter].nsectors = offset - spoolptr->offset;
#else
	extern bool gDriver1Level;
	if (gDriver1Level)
	{

	}
	else
	{
		RequestSpool(0, 0, offset, spoolptr->cell_data_size[1], packed_cell_pointers, NULL);
		offset += spoolptr->cell_data_size[1];

		RequestSpool(0, 0, offset, spoolptr->cell_data_size[0], (char *)(cells + cell_slots_add[target_region]), NULL);
		offset += spoolptr->cell_data_size[0];

		RequestSpool(0, 0, offset, spoolptr->cell_data_size[2], (char *)(cell_objects + num_straddlers + cell_objects_add[target_region]), NULL);
		offset += spoolptr->cell_data_size[2];

		RequestSpool(0, 0, offset, spoolptr->roadm_size, PVS_Buffers[target_region] - 4, GotRegion);
		offset += spoolptr->roadm_size;
	}

	spool_regioninfo[spool_regioncounter].nsectors = offset - spoolptr->offset;
#endif

	spool_regioninfo[spool_regioncounter].region_to_unpack = region;
	spool_regioninfo[spool_regioncounter].target_barrel_region = target_region;
	spool_regioninfo[spool_regioncounter].cell_addr = cell_buffer;
	spool_regioninfo[spool_regioncounter].roadm_addr = roadmap_buffer;

	return 1;
}



// decompiled code
// original method signature: 
// void /*$ra*/ UnpackRegion(int region_to_unpack /*$s1*/, int target_barrel_region /*$s0*/)
 // line 1779, offset 0x0007e5dc
	/* begin block 1 */
		// Start line: 1780
		// Start offset: 0x0007E5DC
	/* end block 1 */
	// End offset: 0x0007E658
	// End Line: 1812

	/* begin block 2 */
		// Start line: 8208
	/* end block 2 */
	// End Line: 8209

	/* begin block 3 */
		// Start line: 8417
	/* end block 3 */
	// End Line: 8418

int RoadMapRegions[4];

// [D]
void UnpackRegion(int region_to_unpack, int target_barrel_region)
{
	if (loading_region[target_barrel_region] == -1) 
	{
		if (LoadRegionData(region_to_unpack, target_barrel_region))
			spool_regioncounter++;

		regions_unpacked[target_barrel_region] = region_to_unpack;
		RoadMapRegions[target_barrel_region] = region_to_unpack;
	}
}



// decompiled code
// original method signature: 
// void /*$ra*/ ProcessSpoolInfoLump(char *lump_ptr /*$a2*/, int lump_size /*$a1*/)
 // line 1815, offset 0x0007c464
	/* begin block 1 */
		// Start line: 1816
		// Start offset: 0x0007C464
		// Variables:
	// 		int i; // $t2
	// 		int size; // $v1
	// 		int slots_count; // $t0
	// 		int objects_count; // $t1
	// 		int num_of_regions; // $v0
	// 		char *alloclist; // $a3
	/* end block 1 */
	// End offset: 0x0007C5C0
	// End Line: 1918

	/* begin block 2 */
		// Start line: 4141
	/* end block 2 */
	// End Line: 4142

	/* begin block 3 */
		// Start line: 4181
	/* end block 3 */
	// End Line: 4182

inline int _getIntAdv(char** ptr)
{
	int value = *(int*)*ptr;
	*ptr += 4;
	return value;
}

#define getIntAdv(ptr) _getIntAdv(&ptr)

// [D]
void ProcessSpoolInfoLump(char *lump_ptr, int lump_size)
{
	int i;
	int size;
	char *alloclist;

	pvsSize[0] = 0;
	pvsSize[1] = 0;
	pvsSize[2] = 0;
	pvsSize[3] = 0;

	char* ptr = lump_ptr;

	size = getIntAdv(ptr) * 2048;

	if (size < 0x10000)
		size = 0x10000;	// smaller still should be fixed to 64k

	MALLOC_BEGIN();
	model_spool_buffer = D_MALLOC(size);
	MALLOC_END();

	cell_slots_add[4] = 0;
	cell_objects_add[4] = 0;

	int music_and_ambients_size = getIntAdv(ptr);
	Music_And_AmbientOffsets = (SXYPAIR *)ptr;	// [A] seems to be UNUSED
	ptr += music_and_ambients_size;

	NumAreas = getIntAdv(ptr);
	AreaData = (AreaDataStr *)ptr; 
	ptr += sizeof(AreaDataStr) * NumAreas;

	AreaTPages = (unsigned char *)ptr;
	ptr += NumAreas * 16;

	// get the pointers
	int* slots_add = (int *)ptr;
	ptr += sizeof(int) * 4;

	int* objects_add = (int *)ptr;
	ptr += sizeof(int) * 4;

	int* pvsSizes = (int *)ptr;
	ptr += sizeof(int) * 4;

	for (i = 0; i < 4; i++)
	{
		int slots_count = slots_add[i];
		int objects_count = objects_add[i];

		// set last totals
		cell_objects_add[i] = cell_objects_add[4];
		cell_slots_add[i] = cell_slots_add[4];
		
		// increment totals
		cell_slots_add[4] += slots_count;
		cell_objects_add[4] += objects_count;

		// by the fact it's a roadmap size + pvs size
		pvsSize[i] = pvsSizes[i] + 0x7ffU & 0xfffff800;

		MALLOC_BEGIN();
		alloclist = D_MALLOC(pvsSize[i]);
		MALLOC_END();

		PVS_Buffers[i] = alloclist + 4;		// +4 for -1 cases
	}

	int num_of_regions = getIntAdv(ptr);
	spoolinfo_offsets = (ushort*)ptr;
	ptr += sizeof(ushort) * num_of_regions;

	int spoolinfo_size = getIntAdv(ptr);
	RegionSpoolInfo = ptr;
}



// decompiled code
// original method signature: 
// void /*$ra*/ WaitCloseLid()
 // line 1928, offset 0x0007e66c
	/* begin block 1 */
		// Start line: 1930
		// Start offset: 0x0007E66C
		// Variables:
	// 		void (*old)(); // $s1
	/* end block 1 */
	// End offset: 0x0007E6D8
	// End Line: 1942

	/* begin block 2 */
		// Start line: 8731
	/* end block 2 */
	// End Line: 8732

	/* begin block 3 */
		// Start line: 8732
	/* end block 3 */
	// End Line: 8733

	/* begin block 4 */
		// Start line: 8733
	/* end block 4 */
	// End Line: 8734

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void WaitCloseLid(void)
{
#ifdef PSX
	void (*old)();
	int loop;

	old = (void(*)())CdReadyCallback(0);
	stopgame();

	while (loop = CdDiskReady(1), loop != 2) 
	{
		DrawCDicon();
		VSync(0);
	}

	startgame();

	CdReadyCallback((CdlCB)old);
#endif // PSX
}



// decompiled code
// original method signature: 
// void /*$ra*/ FoundError(char *name /*$a0*/, unsigned char intr /*$a1*/, unsigned char *result /*$a2*/)
 // line 1945, offset 0x0007e6d8
	/* begin block 1 */
		// Start line: 1947
		// Start offset: 0x0007E6D8
		// Variables:
	// 		struct CdlLOC p; // stack offset -16
	/* end block 1 */
	// End offset: 0x0007E724
	// End Line: 1963

	/* begin block 2 */
		// Start line: 8761
	/* end block 2 */
	// End Line: 8762

	/* begin block 3 */
		// Start line: 8765
	/* end block 3 */
	// End Line: 8766

	/* begin block 4 */
		// Start line: 8766
	/* end block 4 */
	// End Line: 8767

	/* begin block 5 */
		// Start line: 8768
	/* end block 5 */
	// End Line: 8769

// [D]
void FoundError(char *name, unsigned char intr, unsigned char *result)
{
#ifndef SIMPLE_SPOOL
	CdlLOC p;

	if ((*result & 0x10) != 0) 
	{
		WaitCloseLid();
	}

#ifdef _DEBUG
	printError("FoundError: %s, intr: %d\n", name, intr);
#endif // _DEBUG

	spoolerror = 0x3c;
#ifdef PSX
	CdIntToPos(current_sector, &p);
	CdControlF(CdlReadS, (u_char*)&p);
#else
	UNIMPLEMENTED();
#endif
#endif // SIMPLE_SPOOL
}



// decompiled code
// original method signature: 
// void /*$ra*/ GotRegion()
 // line 1970, offset 0x0007d9cc
	/* begin block 1 */
		// Start line: 1972
		// Start offset: 0x0007D9CC
		// Variables:
	// 		int cbr; // $a1
	/* end block 1 */
	// End offset: 0x0007DA60
	// End Line: 1990

	/* begin block 2 */
		// Start line: 6109
	/* end block 2 */
	// End Line: 6110

	/* begin block 3 */
		// Start line: 3940
	/* end block 3 */
	// End Line: 3941

	/* begin block 4 */
		// Start line: 6110
	/* end block 4 */
	// End Line: 6111

	/* begin block 5 */
		// Start line: 6113
	/* end block 5 */
	// End Line: 6114

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void GotRegion(void)
{
	uint target_barrel_reg;

	Unpack_CellPtrs();

	target_barrel_reg = spool_regioninfo[spool_regionpos].target_barrel_region;
	spool_regionpos++;

	char* pvs = PVS_Buffers[target_barrel_reg];

	loading_region[target_barrel_reg] = -1;

	int cbr = *(int *)(pvs - 4);
	RoadMapDataRegions[target_barrel_reg] = (short*)(pvs + cbr);

	if (spool_regionpos == spool_regioncounter)
	{
		spool_regioncounter = 0;
		spool_regionpos = 0;
	}
}



// decompiled code
// original method signature: 
// void /*$ra*/ data_cb_textures()
 // line 1993, offset 0x0007df64
	/* begin block 1 */
		// Start line: 1995
		// Start offset: 0x0007DF64

		/* begin block 1.1 */
			// Start line: 1997
			// Start offset: 0x0007DF78
		/* end block 1.1 */
		// End offset: 0x0007E068
		// End Line: 2033
	/* end block 1 */
	// End offset: 0x0007E078
	// End Line: 2034

	/* begin block 2 */
		// Start line: 6680
	/* end block 2 */
	// End Line: 6681

	/* begin block 3 */
		// Start line: 3986
	/* end block 3 */
	// End Line: 3987

	/* begin block 4 */
		// Start line: 6681
	/* end block 4 */
	// End Line: 6682

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void data_cb_textures(void)
{
#ifndef SIMPLE_SPOOL
	//printf("data_cb_textures remaining: %d\n", sectors_to_read);

	if (chunk_complete != 0) 
	{
		chunk_complete = 0;
		nTPchunks = nTPchunks_writing;

		SendTPage();

		if (nTPchunks != 0)
			loadbank_write++;

		nTPchunks_writing++;

		if (nTPchunks_writing == 5)
		{
			nTPchunks_writing = 0;
			spoolpos_writing++;

			if (ntpages == 0)
			{
				if (switch_spooltype == 0)
				{
#ifdef PSX
					CdDataCallback(0);
#else
					levelSpoolerPCDataCallback(NULL);
#endif // PSX

					if (spoolpos_writing == spoolcounter)
					{
						printWarning("All SPOOL requests (%d) completed successfully on TEXTURES\n", spoolcounter);	// [A]

						spoolcounter = 0;
						spoolpos_writing = 0;
						spoolpos_reading = 0;
						spoolactive = 0;
					}
					else
					{
						UpdateSpool();
					}
				}
				else
				{
					changemode(spooldata + spoolpos_writing);
				}
			}
		}
	}
#endif // SIMPLE_SPOOL
}



// decompiled code
// original method signature: 
// void /*$ra*/ ready_cb_textures(unsigned char intr /*$s0*/, unsigned char *result /*$a2*/)
 // line 2036, offset 0x0007e078
	/* begin block 1 */
		// Start line: 2037
		// Start offset: 0x0007E078

		/* begin block 1.1 */
			// Start line: 2050
			// Start offset: 0x0007E0D8
			// Variables:
		// 		struct SPOOLQ *current; // $a2
		/* end block 1.1 */
		// End offset: 0x0007E188
		// End Line: 2080
	/* end block 1 */
	// End offset: 0x0007E198
	// End Line: 2086

	/* begin block 2 */
		// Start line: 6770
	/* end block 2 */
	// End Line: 6771

	/* begin block 3 */
		// Start line: 6773
	/* end block 3 */
	// End Line: 6774

// [D]
void ready_cb_textures(unsigned char intr, unsigned char *result)
{
#ifndef SIMPLE_SPOOL
	if (intr == 1)
	{
#ifdef PSX
		CdGetSector(target_address, 0x200);
#else
		getLevSectorPC(target_address, 0x200);
#endif // PSX

		target_address = target_address + 0x800;
		sectors_this_chunk--;
		current_sector++;
		sectors_to_read--;

		if (sectors_this_chunk == 0) 
		{
			if (nTPchunks_reading != 0)
				loadbank_read++;

			nTPchunks_reading++;
			chunk_complete = intr;

			if (sectors_to_read == 0)
			{
				ntpages--;

				if (ntpages == 0)
				{
					spoolpos_reading++;
					test_changemode();
				}
				else
				{
					nTPchunks_reading = 0;
					sectors_to_read = 17;

					target_address = spooldata[spoolpos_reading].addr + 0x4000;
					spoolpos_reading++;

					sectors_this_chunk = intr;
				}
			}
			else 
			{
				sectors_this_chunk = 4;
				target_address = spooldata[spoolpos_reading].addr + (loadbank_read & 1U) * 0x2000;
			}
		}
	}
	else 
		FoundError("ready_cb_textures", intr, result);
#endif // SIMPLE_SPOOL
}



// decompiled code
// original method signature: 
// void /*$ra*/ ready_cb_regions(unsigned char intr /*$s0*/, unsigned char *result /*$a2*/)
 // line 2090, offset 0x0007de90
	/* begin block 1 */
		// Start line: 2091
		// Start offset: 0x0007DE90

		/* begin block 1.1 */
			// Start line: 2110
			// Start offset: 0x0007DF08
			// Variables:
		// 		struct SPOOLQ *current; // $v1
		/* end block 1.1 */
		// End offset: 0x0007DF08
		// End Line: 2110
	/* end block 1 */
	// End offset: 0x0007DF64
	// End Line: 2129

	/* begin block 2 */
		// Start line: 6728
	/* end block 2 */
	// End Line: 6729

	/* begin block 3 */
		// Start line: 4180
	/* end block 3 */
	// End Line: 4181

void ready_cb_regions(unsigned char intr, unsigned char *result)
{
#ifndef SIMPLE_SPOOL
	if (intr == 1) 
	{
#ifdef PSX
		CdGetSector(target_address, 0x200);
#else
		getLevSectorPC(target_address, 0x200);
#endif // PSX

		target_address = target_address + 0x800;
		sectors_this_chunk--;
		current_sector++;
		sectors_to_read--;

		if (sectors_this_chunk == 0) 
		{
			spoolpos_reading++;
			chunk_complete = intr;

			if (sectors_to_read == 0)
			{
				endchunk = intr;
				test_changemode();
			}
			else 
			{
				target_address = spooldata[spoolpos_reading].addr;
				sectors_this_chunk = (spooldata[spoolpos_reading].nsectors);
			}
		}
	}
	else 
		FoundError("ready_cb_regions", intr, result);
#endif // SIMPLE_SPOOL
}



// decompiled code
// original method signature: 
// void /*$ra*/ data_cb_regions()
 // line 2132, offset 0x0007dda8
	/* begin block 1 */
		// Start line: 2134
		// Start offset: 0x0007DDA8

		/* begin block 1.1 */
			// Start line: 2136
			// Start offset: 0x0007DDBC
			// Variables:
		// 		struct SPOOLQ *current; // $v0
		/* end block 1.1 */
		// End offset: 0x0007DE80
		// End Line: 2167
	/* end block 1 */
	// End offset: 0x0007DE90
	// End Line: 2168

	/* begin block 2 */
		// Start line: 4264
	/* end block 2 */
	// End Line: 4265

	/* begin block 3 */
		// Start line: 6733
	/* end block 3 */
	// End Line: 6734

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void data_cb_regions(void)
{
#ifndef SIMPLE_SPOOL
	//printf("data_cb_regions remaining: %d\n", sectors_to_read);

	SPOOLQ* current = &spooldata[spoolpos_writing];

	if (chunk_complete != 0) 
	{
		chunk_complete = 0;

		if (current->func != NULL)
			(current->func)();

		spoolpos_writing++;

		if (endchunk != 0)
		{
			if (switch_spooltype == 0) 
			{
#ifdef PSX
				CdDataCallback(0);
#else
				levelSpoolerPCDataCallback(NULL);
#endif // PSX

				if (spoolpos_writing == spoolcounter) 
				{
					printWarning("All SPOOL requests (%d) completed successfully on REGIONS\n", spoolcounter);	// [A]

					spoolcounter = 0;
					spoolpos_writing = 0;
					spoolpos_reading = 0;
					spoolactive = 0;
				}
				else 
				{
					UpdateSpool();
				}
			}
			else 
			{
				changemode(&spooldata[spoolpos_writing]);
			}
		}
	}
#endif // SIMPLE_SPOOL
}



// decompiled code
// original method signature: 
// void /*$ra*/ data_cb_soundbank()
 // line 2171, offset 0x0007dbcc
	/* begin block 1 */
		// Start line: 2173
		// Start offset: 0x0007DBCC

		/* begin block 1.1 */
			// Start line: 2175
			// Start offset: 0x0007DBE0
		/* end block 1.1 */
		// End offset: 0x0007DC94
		// End Line: 2200
	/* end block 1 */
	// End offset: 0x0007DCA4
	// End Line: 2201

	/* begin block 2 */
		// Start line: 4342
	/* end block 2 */
	// End Line: 4343

	/* begin block 3 */
		// Start line: 6666
	/* end block 3 */
	// End Line: 6667

/* WARNING: Unknown calling convention yet parameter storage is locked */

void data_cb_soundbank(void)
{
	UNIMPLEMENTED();
	/*
	if (chunk_complete != 0) {
		chunk_complete = 0;
		SendSBK();
		loadbank_write = loadbank_write + 1;
		if (endchunk != 0) {
			spoolpos_writing = spoolpos_writing + 1;
			if (switch_spooltype == 0) {
#ifdef PSX
				CdDataCallback(0);
#else
				UNIMPLEMENTED();
#endif // PSX
				if (spoolpos_writing == spoolcounter) {
					spoolcounter = 0;
					spoolpos_writing = 0;
					spoolpos_reading = 0;
					spoolactive = 0;
				}
				else {
					UpdateSpool();
				}
			}
			else {
				changemode(spooldata + spoolpos_writing);
			}
		}
	}
	return;*/
}



// decompiled code
// original method signature: 
// void /*$ra*/ ready_cb_soundbank(unsigned char intr /*$s0*/, unsigned char *result /*$a2*/)
 // line 2203, offset 0x0007dca4
	/* begin block 1 */
		// Start line: 2204
		// Start offset: 0x0007DCA4

		/* begin block 1.1 */
			// Start line: 2217
			// Start offset: 0x0007DD04
			// Variables:
		// 		struct SPOOLQ *current; // $a0
		/* end block 1.1 */
		// End offset: 0x0007DD70
		// End Line: 2237
	/* end block 1 */
	// End offset: 0x0007DD98
	// End Line: 2244

	/* begin block 2 */
		// Start line: 6729
	/* end block 2 */
	// End Line: 6730

	/* begin block 3 */
		// Start line: 6732
	/* end block 3 */
	// End Line: 6733

void ready_cb_soundbank(unsigned char intr, unsigned char *result)
{
	UNIMPLEMENTED();
	/*
	uint uVar1;

	uVar1 = (uint)intr;
	if (intr == '\x01') {
#ifdef PSX
		CdGetSector(target_address, 0x200);
#else
		getLevSectorPC(target_address, 0x200);
#endif // PSX

		target_address = target_address + 0x800;
		sectors_this_chunk--;
		current_sector++;
		sectors_to_read--;
		if (sectors_this_chunk == 0) {
			loadbank_read = loadbank_read + 1;
			nTPchunks_reading = nTPchunks_reading + 1;
			chunk_complete = uVar1;
			if (sectors_to_read == 0) {
				spoolpos_reading = spoolpos_reading + 1;
				endchunk = uVar1;
				test_changemode();
			}
			else {
				sectors_this_chunk = 2;
				if (sectors_to_read < 2) {
					sectors_this_chunk = sectors_to_read;
				}
				target_address = spooldata[spoolpos_reading].addr + (loadbank_read & 1U) * 0x1000;
			}
		}
	}
	else {
		FoundError(s_ready_cb_soundbank_00011d5c, intr, result);
	}
	return;*/
}



// decompiled code
// original method signature: 
// void /*$ra*/ data_cb_misc()
 // line 2246, offset 0x0007da60
	/* begin block 1 */
		// Start line: 2248
		// Start offset: 0x0007DA60

		/* begin block 1.1 */
			// Start line: 2250
			// Start offset: 0x0007DA74
			// Variables:
		// 		struct SPOOLQ *current; // $v0
		/* end block 1.1 */
		// End offset: 0x0007DB28
		// End Line: 2275
	/* end block 1 */
	// End offset: 0x0007DB38
	// End Line: 2276

	/* begin block 2 */
		// Start line: 6421
	/* end block 2 */
	// End Line: 6422

	/* begin block 3 */
		// Start line: 6678
	/* end block 3 */
	// End Line: 6679

	/* begin block 4 */
		// Start line: 6679
	/* end block 4 */
	// End Line: 6680

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void data_cb_misc(void)
{
#ifndef SIMPLE_SPOOL
	//printf("data_cb_misc remaining: %d\n", sectors_to_read);

	SPOOLQ *current = &spooldata[spoolpos_writing];

	if (chunk_complete != 0) 
	{
		chunk_complete = 0;

		if (current->func != NULL)
		{
			(*current->func)();
		}

		spoolpos_writing++;

		if (switch_spooltype == 0)
		{
#ifdef PSX
			CdDataCallback(0);
#else
			levelSpoolerPCDataCallback(NULL);
#endif // PSX
			if (spoolpos_writing == spoolcounter)
			{
				printWarning("All SPOOL requests (%d) completed successfully on MISC\n", spoolcounter);	// [A]

				spoolcounter = 0;
				spoolpos_writing = 0;
				spoolpos_reading = 0;
				spoolactive = 0;
			}
			else
			{
				UpdateSpool();
			}
		}
		else
		{
			changemode(spooldata + spoolpos_writing);
		}
	}
#endif // SIMPLE_SPOOL
}



// decompiled code
// original method signature: 
// void /*$ra*/ ready_cb_misc(unsigned char intr /*$s0*/, unsigned char *result /*$a2*/)
 // line 2278, offset 0x0007db38
	/* begin block 1 */
		// Start line: 6744
	/* end block 1 */
	// End Line: 6745

	/* begin block 2 */
		// Start line: 6747
	/* end block 2 */
	// End Line: 6748

// [D]
void ready_cb_misc(unsigned char intr, unsigned char *result)
{
#ifndef SIMPLE_SPOOL
	if (intr == 1) 
	{
#ifdef PSX
		CdGetSector(target_address, 0x200);
#else
		getLevSectorPC(target_address, 0x200);
#endif // PSX

		target_address = target_address + 0x800;
		sectors_to_read--;
		current_sector++;

		if (sectors_to_read == 0) 
		{
			spoolpos_reading++;
			chunk_complete = intr;
			test_changemode();
		}
	}
	else 
	{
		FoundError("ready_cb_misc", intr, result);
	}
#endif // SIMPLE_SPOOL
}



// decompiled code
// original method signature: 
// void /*$ra*/ StartSpooling()
 // line 2302, offset 0x0007e724
	/* begin block 1 */
		// Start line: 2304
		// Start offset: 0x0007E724
	/* end block 1 */
	// End offset: 0x0007E7B0
	// End Line: 2321

	/* begin block 2 */
		// Start line: 9140
	/* end block 2 */
	// End Line: 9141

	/* begin block 3 */
		// Start line: 9480
	/* end block 3 */
	// End Line: 9481

	/* begin block 4 */
		// Start line: 9481
	/* end block 4 */
	// End Line: 9482

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void StartSpooling(void)
{
	static unsigned char param[8];
	static unsigned char result[8];

	int iVar1;

	if ((spoolcounter != 0) && (spoolactive == 0))
	{
		iVar1 = XAPrepared();

		if (iVar1 == 0)
		{
#ifdef PSX
			param[0] = -0x80;
			CdControlB(0xe, param, result);

			if ((result[0] & 0x15) != 0)
			{
				WaitCloseLid();
			}
#endif // PSX
			spoolactive = 1;
			UpdateSpool();

			if (FastForward != 0)
			{
				SpoolSYNC();
			}
		}
	}
}



// decompiled code
// original method signature: 
// void /*$ra*/ unpack_cellpointers()
 // line 2351, offset 0x0007c5c0
	/* begin block 1 */
		// Start line: 2353
		// Start offset: 0x0007C5C0
		// Variables:
	// 		int target_barrel_region; // $t0
	// 		char *source_packed_data; // $v0
	// 		int bitpos; // $a3
	// 		int loop; // $a2
	// 		int packtype; // $a0
	// 		unsigned short cell; // $a0
	// 		unsigned short *short_ptr; // $a1
	// 		unsigned short pcode; // $t1
	/* end block 1 */
	// End offset: 0x0007C74C
	// End Line: 2437

	/* begin block 2 */
		// Start line: 4939
	/* end block 2 */
	// End Line: 4940

	/* begin block 3 */
		// Start line: 5373
	/* end block 3 */
	// End Line: 5374

	/* begin block 4 */
		// Start line: 5374
	/* end block 4 */
	// End Line: 5375

	/* begin block 5 */
		// Start line: 5383
	/* end block 5 */
	// End Line: 5384

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D] [A] - altered declaration
void unpack_cellpointers(int region_to_unpack, int target_barrel_region, char* cell_addr)
{
	ushort *puVar1;
	ushort *puVar2;
	ushort uVar3;
	int loop;
	uint uVar6;
	uint uVar7;

	int packtype;
	
	unpack_cellptr_flag = 0;
	packtype = *(int *)(cell_addr + 4);
	puVar1 = (ushort *)(cell_addr + 8);

	if (packtype == 0)
	{
		puVar1 = cell_ptrs + target_barrel_region * 1024;

		for (loop = 0; loop < 1024; loop++)
			*puVar1++ = 0xffff;
	}
	else if (packtype == 1)
	{
		puVar2 = cell_ptrs + target_barrel_region * 1024;

		for (loop = 0; loop < 1024; loop++)
		{
			uVar3 = *puVar1++;

			if (uVar3 != 0xffff)
				uVar3 += cell_slots_add[target_barrel_region];

			*puVar2++ = uVar3;
		}
	}
	else if (packtype == 2)
	{
		uVar6 = 0x8000;
		uVar7 = (uint)*puVar1;

		puVar2 = (ushort *)(cell_addr + 10);
		puVar1 = cell_ptrs + target_barrel_region * 1024;

		for (loop = 0; loop < 1024; loop++)
		{
			if (uVar7 & uVar6)
			{
				uVar3 = *puVar2++;
				uVar3 += cell_slots_add[target_barrel_region];

			}
			else
				uVar3 = 0xffff;

			uVar6 >>= 1;
			*puVar1++ = uVar3;

			if (uVar6 == 0)
			{
				uVar6 = 0x8000;
				uVar7 = *puVar2++;
			}
		}
	}
	else 
	{
		if (FrameCnt != 0x78654321)
		{
			do {
				trap(0x400);
			} while (FrameCnt != 0x78654321);

			unpack_cellptr_flag = 0;
		}
	}
}



// decompiled code
// original method signature: 
// void /*$ra*/ Unpack_CellPtrs()
 // line 2442, offset 0x0007d978
	/* begin block 1 */
		// Start line: 2444
		// Start offset: 0x0007D978
		// Variables:
	// 		int region_to_unpack; // $a1
	// 		int target_barrel_region; // $a1
	// 		char *source_packed_data; // $v1
	/* end block 1 */
	// End offset: 0x0007D9CC
	// End Line: 2469

	/* begin block 2 */
		// Start line: 4884
	/* end block 2 */
	// End Line: 4885

	/* begin block 3 */
		// Start line: 6539
	/* end block 3 */
	// End Line: 6540

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D] [A] altered unpack_cellpointers
void Unpack_CellPtrs(void)
{
	SPL_REGIONINFO* spool = &spool_regioninfo[spool_regionpos];

	unpack_cellpointers(spool->region_to_unpack, spool->target_barrel_region, spool->cell_addr);
}



// decompiled code
// original method signature: 
// void /*$ra*/ SpecClutsSpooled()
 // line 2509, offset 0x0007c74c
	/* begin block 1 */
		// Start line: 2511
		// Start offset: 0x0007C74C
		// Variables:
	// 		char *loadaddr; // $s4
	// 		int i; // $s1
	// 		int j; // $s2
	// 		int tpage; // $s0
	// 		struct RECT specCluts; // stack offset -48

		/* begin block 1.1 */
			// Start line: 2522
			// Start offset: 0x0007C7F4
			// Variables:
		// 		int index; // $a3

			/* begin block 1.1.1 */
				// Start line: 2537
				// Start offset: 0x0007C91C
			/* end block 1.1.1 */
			// End offset: 0x0007C91C
			// End Line: 2537
		/* end block 1.1 */
		// End offset: 0x0007C95C
		// End Line: 2542
	/* end block 1 */
	// End offset: 0x0007C9B8
	// End Line: 2546

	/* begin block 2 */
		// Start line: 5647
	/* end block 2 */
	// End Line: 5648

	/* begin block 3 */
		// Start line: 5720
	/* end block 3 */
	// End Line: 5721

	/* begin block 4 */
		// Start line: 5721
	/* end block 4 */
	// End Line: 5722

	/* begin block 5 */
		// Start line: 5730
	/* end block 5 */
	// End Line: 5731

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void SpecClutsSpooled(void)
{
	unsigned char bVar1;
	short sVar2;
	short sVar3;
	u_short uVar4;
	int iVar5;
	int iVar6;
	uint uVar7;
	ushort *puVar8;
	int iVar9;
	int iVar10;
	char *pcVar11;
	RECT16 specCluts;

	iVar9 = 0;

	specCluts.x = slot_clutpos[specialSlot].vx;
	specCluts.y = slot_clutpos[specialSlot].vy;
	specCluts.w = 16;
	specCluts.h = 1;

	pcVar11 = specLoadBuffer;
	do {
		iVar5 = 7;
		if (iVar9 == 0)
			iVar5 = 6;

		iVar10 = 0;

		iVar6 = specialSlot + iVar9;

		int tpage = specTpages[GameLevel][(specspooldata[2]-1) * 2 + iVar9];

		carTpages[GameLevel][iVar5] = tpageslots[iVar6] = tpage;
		tpageloaded[tpage] = specialSlot + iVar9 + 1;

		slot_tpagepos[iVar6].vx = tpagepos[iVar6].x;
		slot_tpagepos[iVar6].vy = tpagepos[iVar6].y;

		texture_pages[tpage] = GetTPage(0, 0, slot_tpagepos[iVar6].vx, slot_tpagepos[iVar6].vy);
		

		if (0 < tpage_texamts[tpage])
		{
			puVar8 = texture_cluts[tpage];

			do {
				LoadImage2(&specCluts, (u_long*)pcVar11);
				pcVar11 += 32;
				

				*puVar8++ = GetClut(specCluts.x, specCluts.y);
				IncrementClutNum(&specCluts);

				iVar10++;
			} while (iVar10 < tpage_texamts[tpage]);
		}

		iVar9++;
	} while (iVar9 < 2);

	if (quickSpool != 1)
	{
		DrawSyncCallback(SpecialStartNextBlock);
	}
}



// decompiled code
// original method signature: 
// void /*$ra*/ CleanModelSpooled()
 // line 2549, offset 0x0007c9b8
	/* begin block 1 */
		// Start line: 2552
		// Start offset: 0x0007C9B8
		// Variables:
	// 		int *loadaddr; // $a1
	// 		int *mem; // $a3

		/* begin block 1.1 */
			// Start line: 2576
			// Start offset: 0x0007CA80
		/* end block 1.1 */
		// End offset: 0x0007CAD0
		// End Line: 2587
	/* end block 1 */
	// End offset: 0x0007CAFC
	// End Line: 2591

	/* begin block 2 */
		// Start line: 5870
	/* end block 2 */
	// End Line: 5871

	/* begin block 3 */
		// Start line: 5874
	/* end block 3 */
	// End Line: 5875

	/* begin block 4 */
		// Start line: 5876
	/* end block 4 */
	// End Line: 5877

	/* begin block 5 */
		// Start line: 5880
	/* end block 5 */
	// End Line: 5881

/* WARNING: Unknown calling convention yet parameter storage is locked */

int *modelMemory;

int lengthLowBlock;
int lastCleanBlock;
int lengthDamBlock;

int firstLowBlock;
int firstDamBlock;

int specBlocksToLoad = 0;
int specialState = 0;
char specModelValid = 1;
int specSpoolComplete;

// [D]
void CleanModelSpooled(void)
{
	int *piVar1;
	ushort *puVar2;
	int iVar4;
	int *piVar5;
	int *in_a3;

	piVar5 = (int *)specLoadBuffer;
	if (specBlocksToLoad == lastCleanBlock-1) 
	{
		piVar5 = (int *)(specLoadBuffer + 12);
		modelMemory = (int *)specmallocptr;
		gCarCleanModelPtr[4] = (MODEL *)specmallocptr;
	}

	// memcpy
	while (piVar5 < (int*)(specLoadBuffer + 0x800))
		*modelMemory++ = *piVar5++;

	in_a3 = (int*)((int)gCarCleanModelPtr[4] + gCarCleanModelPtr[4]->poly_block);	// [A] pls check, might be invalid

	if (specBlocksToLoad == 0 || in_a3 < modelMemory)
	{
		specBlocksToLoad = 0;

		modelMemory = in_a3;

		gCarCleanModelPtr[4]->vertices += (int)gCarCleanModelPtr[4];
		gCarCleanModelPtr[4]->normals += (int)gCarCleanModelPtr[4];
		gCarCleanModelPtr[4]->point_normals += (int)gCarCleanModelPtr[4];
		gCarCleanModelPtr[4]->poly_block += (int)gCarCleanModelPtr[4];

		NewCarModel[4].nlist = (SVECTOR *)gCarCleanModelPtr[4]->point_normals;
		NewCarModel[4].vlist = (SVECTOR *)gCarCleanModelPtr[4]->vertices;
	}

	if (quickSpool != 1)
		DrawSyncCallback(SpecialStartNextBlock);
}



// decompiled code
// original method signature: 
// void /*$ra*/ DamagedModelSpooled()
 // line 2594, offset 0x0007cafc
	/* begin block 1 */
		// Start line: 2596
		// Start offset: 0x0007CAFC
		// Variables:
	// 		int *loadaddr; // $a1
	// 		int *mem; // $a3

		/* begin block 1.1 */
			// Start line: 2620
			// Start offset: 0x0007CBC0
		/* end block 1.1 */
		// End offset: 0x0007CBF8
		// End Line: 2629
	/* end block 1 */
	// End offset: 0x0007CC24
	// End Line: 2633

	/* begin block 2 */
		// Start line: 5981
	/* end block 2 */
	// End Line: 5982

	/* begin block 3 */
		// Start line: 5985
	/* end block 3 */
	// End Line: 5986

	/* begin block 4 */
		// Start line: 5986
	/* end block 4 */
	// End Line: 5987

	/* begin block 5 */
		// Start line: 5990
	/* end block 5 */
	// End Line: 5991

/* WARNING: Unknown calling convention yet parameter storage is locked */

int damOffset;

// [D]
void DamagedModelSpooled(void)
{
	MODEL *pMVar1;
	int iVar2;
	int *piVar3;
	int *in_a3;

	piVar3 = (int *)specLoadBuffer;

	if (specBlocksToLoad == lengthDamBlock + -1) 
	{
		piVar3 = (int *)(specLoadBuffer + damOffset);
		gCarDamModelPtr[4] = (MODEL *)modelMemory;
	}

	// memcpy
	while (piVar3 < (int*)(specLoadBuffer + 0x800))
		*modelMemory++ = *piVar3++;

	in_a3 = (int*)((int)gCarDamModelPtr[4] + gCarDamModelPtr[4]->poly_block);	// [A] pls check, might be invalid

	if (specBlocksToLoad == 0 || in_a3 < modelMemory) 
	{
		piVar3 = &gCarDamModelPtr[4]->normals;

		specBlocksToLoad = 0;
		modelMemory = in_a3;

		gCarDamModelPtr[4]->vertices += (int)gCarDamModelPtr[4];
		gCarDamModelPtr[4]->normals += (int)gCarDamModelPtr[4];
		gCarDamModelPtr[4]->poly_block += (int)gCarDamModelPtr[4];
		gCarDamModelPtr[4]->point_normals += (int)gCarDamModelPtr[4];
	}

	if (quickSpool != 1)
		DrawSyncCallback(SpecialStartNextBlock);

}



// decompiled code
// original method signature: 
// void /*$ra*/ LowModelSpooled()
 // line 2635, offset 0x0007cc24
	/* begin block 1 */
		// Start line: 2637
		// Start offset: 0x0007CC24
		// Variables:
	// 		int *loadaddr; // $a1
	// 		int *mem; // $a3

		/* begin block 1.1 */
			// Start line: 2661
			// Start offset: 0x0007CCE8
		/* end block 1.1 */
		// End offset: 0x0007CD38
		// End Line: 2672
	/* end block 1 */
	// End offset: 0x0007CD64
	// End Line: 2676

	/* begin block 2 */
		// Start line: 6081
	/* end block 2 */
	// End Line: 6082

	/* begin block 3 */
		// Start line: 6084
	/* end block 3 */
	// End Line: 6085

	/* begin block 4 */
		// Start line: 6085
	/* end block 4 */
	// End Line: 6086

	/* begin block 5 */
		// Start line: 6089
	/* end block 5 */
	// End Line: 6090

/* WARNING: Unknown calling convention yet parameter storage is locked */

int lowOffset;

// [D]
void LowModelSpooled(void)
{
	int *piVar1;
	ushort *puVar2;
	int iVar4;
	int *piVar5;
	int *in_a3;

	piVar5 = (int *)specLoadBuffer;

	if (specBlocksToLoad == lengthLowBlock + -1) 
	{
		piVar5 = (int *)(specLoadBuffer + lowOffset);
		gCarLowModelPtr[4] = (MODEL *)modelMemory;
	}

	// memcpy
	while (piVar5 < (int*)(specLoadBuffer + 0x800))
		*modelMemory++ = *piVar5++;

	in_a3 = (int*)((int)gCarLowModelPtr[4] + gCarLowModelPtr[4]->poly_block);	// [A] pls check, might be invalid

	if ((specBlocksToLoad == 0) || (in_a3 < modelMemory))
	{
		specBlocksToLoad = 0;
		modelMemory = in_a3;

		gCarLowModelPtr[4]->vertices += (int)gCarLowModelPtr[4];
		gCarLowModelPtr[4]->normals += (int)gCarLowModelPtr[4];
		gCarLowModelPtr[4]->poly_block += (int)gCarLowModelPtr[4];
		gCarLowModelPtr[4]->point_normals += (int)gCarLowModelPtr[4];

		NewLowCarModel[4].nlist = (SVECTOR *)gCarLowModelPtr[4]->point_normals;
		NewLowCarModel[4].vlist = (SVECTOR *)gCarLowModelPtr[4]->vertices;
	}

	if (quickSpool != 1) {
		DrawSyncCallback(SpecialStartNextBlock);
	}
}



// decompiled code
// original method signature: 
// void /*$ra*/ CleanSpooled()
 // line 2680, offset 0x0007cd64
	/* begin block 1 */
		// Start line: 2683
		// Start offset: 0x0007CD64
		// Variables:
	// 		char *loadaddr; // $a1

		/* begin block 1.1 */
			// Start line: 2702
			// Start offset: 0x0007CE8C
			// Variables:
		// 		struct MODEL *tempModel; // $a1
		/* end block 1.1 */
		// End offset: 0x0007CEE0
		// End Line: 2713
	/* end block 1 */
	// End offset: 0x0007CF0C
	// End Line: 2717

	/* begin block 2 */
		// Start line: 6189
	/* end block 2 */
	// End Line: 6190

	/* begin block 3 */
		// Start line: 6194
	/* end block 3 */
	// End Line: 6195

	/* begin block 4 */
		// Start line: 6196
	/* end block 4 */
	// End Line: 6197

	/* begin block 5 */
		// Start line: 6198
	/* end block 5 */
	// End Line: 6199

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void CleanSpooled(void)
{
	int *piVar1;
	char *pcVar2;
	int iVar3;
	int iVar4;
	MODEL *model;

	if (specBlocksToLoad == 6)
	{
		lastCleanBlock = *(int *)specmallocptr + 0x80b;
		lastCleanBlock = lastCleanBlock >> 0xb;

		firstLowBlock = *(int *)specmallocptr + *(int *)(specmallocptr + 4) + 0xc;
		firstLowBlock = firstLowBlock >> 0xb;

		iVar4 = *(int *)specmallocptr + *(int *)(specmallocptr + 4) + *(int *)(specmallocptr + 8);

		iVar3 = iVar4 + 0x80b;
		lengthLowBlock = (iVar3 >> 0xb) - firstLowBlock;

		lowOffset = (*(int *)specmallocptr + *(int *)(specmallocptr + 4)) - (firstLowBlock * 0x800 + -12);

		firstDamBlock = *(int *)specmallocptr + 12;
		firstDamBlock = firstDamBlock >> 0xb;

		iVar3 = *(int *)specmallocptr + *(int *)(specmallocptr + 4) + 0x80b;

		lengthDamBlock = (iVar3 >> 0xb) - firstDamBlock;
		damOffset = *(int *)specmallocptr - (firstDamBlock * 0x800 + -12);
	}

	model = (MODEL *)(specmallocptr + 12);

	if (specBlocksToLoad == 7-lastCleanBlock) 
	{
		model->vertices += (int)model;
		model->poly_block += (int)model;
		model->normals += (int)model;
		model->point_normals += (int)model;

		whichCP = baseSpecCP;

		buildNewCarFromModel(&NewCarModel[4], model, 0);
		specBlocksToLoad = 0;
	}

	if (quickSpool != 1)
		DrawSyncCallback(SpecialStartNextBlock);
}



// decompiled code
// original method signature: 
// void /*$ra*/ LowSpooled()
 // line 2720, offset 0x0007e7c0
	/* begin block 1 */
		// Start line: 2723
		// Start offset: 0x0007E7C0
		// Variables:
	// 		char *loadaddr; // $v1

		/* begin block 1.1 */
			// Start line: 2728
			// Start offset: 0x0007E7D8
			// Variables:
		// 		struct MODEL *tempModel; // $a1
		/* end block 1.1 */
		// End offset: 0x0007E820
		// End Line: 2737
	/* end block 1 */
	// End offset: 0x0007E84C
	// End Line: 2741

	/* begin block 2 */
		// Start line: 10317
	/* end block 2 */
	// End Line: 10318

	/* begin block 3 */
		// Start line: 10319
	/* end block 3 */
	// End Line: 10320

	/* begin block 4 */
		// Start line: 10321
	/* end block 4 */
	// End Line: 10322

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void LowSpooled(void)
{
	MODEL *model;

	if (specBlocksToLoad == 0) 
	{
		model = (MODEL *)(specmallocptr + lowOffset);

		model->vertices += (int)model;
		model->normals += (int)model;
		model->poly_block += (int)model;
		model->point_normals += (int)model;

		buildNewCarFromModel(&NewLowCarModel[4], model, 0);
	}

	if (quickSpool != 1) 
		DrawSyncCallback(SpecialStartNextBlock);
}



// decompiled code
// original method signature: 
// void /*$ra*/ Tada()
 // line 2744, offset 0x0007cf0c
	/* begin block 1 */
		// Start line: 2746
		// Start offset: 0x0007CF0C
		// Variables:
	// 		char *loadaddr; // $s1

		/* begin block 1.1 */
			// Start line: 2751
			// Start offset: 0x0007CF60
			// Variables:
		// 		struct RECT tpage; // stack offset -32
		// 		int spec_tpage; // $a0
		/* end block 1.1 */
		// End offset: 0x0007D018
		// End Line: 2764

		/* begin block 1.2 */
			// Start line: 2767
			// Start offset: 0x0007D018
			// Variables:
		// 		struct RECT tpage; // stack offset -24
		// 		int spec_tpage; // $a0
		/* end block 1.2 */
		// End offset: 0x0007D0EC
		// End Line: 2780

		/* begin block 1.3 */
			// Start line: 2783
			// Start offset: 0x0007D0EC
		/* end block 1.3 */
		// End offset: 0x0007D130
		// End Line: 2789
	/* end block 1 */
	// End offset: 0x0007D144
	// End Line: 2793

	/* begin block 2 */
		// Start line: 6312
	/* end block 2 */
	// End Line: 6313

	/* begin block 3 */
		// Start line: 6340
	/* end block 3 */
	// End Line: 6341

	/* begin block 4 */
		// Start line: 6341
	/* end block 4 */
	// End Line: 6342

	/* begin block 5 */
		// Start line: 6342
	/* end block 5 */
	// End Line: 6343

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void Tada(void)
{
	int spec_tpage;
	RECT16 tpagerect;

	if (specialState == 2)
	{
		tpagerect.w = 64;
		tpagerect.h = 16;

		spec_tpage = specialSlot + 1;
		tpagerect.x = tpagepos[spec_tpage].x;
		tpagerect.y = tpagepos[spec_tpage].y + (15 - specBlocksToLoad) * 16;

		if (specBlocksToLoad == 15) 
			update_slotinfo(specTpages[GameLevel][specspooldata[2]-1], specialSlot, &tpagerect);

		LoadImage(&tpagerect, (u_long *)specLoadBuffer);
	}
	else
	{
		if (2 < specialState) 
		{
			if (specialState != 4)
				return;

			SetupSpecCosmetics(specLoadBuffer);
			FixCarCos(&car_cosmetics[4], MissionHeader->residentModels[4]);
			SetupSpecDenting(specLoadBuffer + sizeof(CAR_COSMETICS));

			if (quickSpool == 1)
				return;

			DrawSyncCallback(SpecialStartNextBlock);
			return;
		}

		if (specialState != 1)
			return;

		spec_tpage = specialSlot;
		tpagerect.w = 64;
		tpagerect.h = 16;

		tpagerect.x = tpagepos[spec_tpage].x;
		tpagerect.y = tpagepos[spec_tpage].y + (15 - specBlocksToLoad) * 16;

		if (specBlocksToLoad == 15) 
			update_slotinfo(specTpages[GameLevel][specspooldata[2]-1], spec_tpage, &tpagerect);

		LoadImage(&tpagerect, (u_long *)specLoadBuffer);
	}

	if (quickSpool != 1)
		DrawSyncCallback(SpecialStartNextBlock);
}



// decompiled code
// original method signature: 
// void /*$ra*/ SpecialStartNextBlock()
 // line 2799, offset 0x0007d144
	/* begin block 1 */
		// Start line: 2801
		// Start offset: 0x0007D144
		// Variables:
	// 		char *loadaddr; // $s0
	// 		int fileSector; // $t0
	/* end block 1 */
	// End offset: 0x0007D4D0
	// End Line: 2925

	/* begin block 2 */
		// Start line: 6482
	/* end block 2 */
	// End Line: 6483

	/* begin block 3 */
		// Start line: 6489
	/* end block 3 */
	// End Line: 6490

	/* begin block 4 */
		// Start line: 6490
	/* end block 4 */
	// End Line: 6491

	/* begin block 5 */
		// Start line: 6493
	/* end block 5 */
	// End Line: 6494

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void SpecialStartNextBlock(void)
{
	char *loadaddr;
	int fileSector;
	spooledFuncPtr spoolFunc;

	loadaddr = specLoadBuffer;
	DrawSyncCallback(0);

	// if previous state blocks are fully loaded, start next state
	if (specBlocksToLoad == 0)
	{
		switch (specialState) 
		{
			case 0:
			case 1:
				specBlocksToLoad = 16;
				break;
			case 2:
			case 3:
				specBlocksToLoad = 1;
				break;
			case 4:
				specBlocksToLoad = 7;
				break;
			case 5:
			case 8:
				specBlocksToLoad = lengthLowBlock;
				break;
			case 6:
				specBlocksToLoad = lastCleanBlock;
				break;
			case 7:
				specBlocksToLoad = lengthDamBlock;
				break;
			default:
				specBlocksToLoad = 0;
		}

		specialState++;
	}

	fileSector = 0x1400 + (citystart[GameLevel] - citylumps[GameLevel][CITYLUMP_SPOOL].x / 2048) + (specspooldata[2]-1) * 42;

	switch (specialState)
	{
		case 1:
			spoolFunc = Tada;
			fileSector += (17 - specBlocksToLoad);
			break;
		case 2:
			spoolFunc = Tada;
			fileSector += (33 - specBlocksToLoad);
			break;
		case 3:
			spoolFunc = SpecClutsSpooled;
			break;
		case 4:
			fileSector += 33;
			spoolFunc = Tada;
			break;
		case 5:
			spoolFunc = CleanSpooled;
			fileSector += (41 - specBlocksToLoad);
			loadaddr = specmallocptr + (7 - specBlocksToLoad) * 2048;
			break;
		case 6:
			spoolFunc = LowSpooled;
			fileSector += ((firstLowBlock + lengthLowBlock) - specBlocksToLoad) + 34;
			loadaddr = specmallocptr + (lengthLowBlock - specBlocksToLoad) * 2048;
			break;
		case 7:
			spoolFunc = CleanModelSpooled;
			fileSector += (lastCleanBlock - specBlocksToLoad) + 34;
			break;
		case 8:
			spoolFunc = DamagedModelSpooled;
			fileSector += ((firstDamBlock + lengthDamBlock) - specBlocksToLoad) + 34;
			break;
		case 9:
			spoolFunc = LowModelSpooled;
			fileSector += ((firstLowBlock + lengthLowBlock) - specBlocksToLoad) + 34;
			break;
		default:
			if (quickSpool == 1)
			{
				specModelValid = 1;
				specialState = 0;
				quickSpool = 0;
				specSpoolComplete = 0;
				return;
			}

			specSpoolComplete = 1;
			return;
	}

	RequestSpool(3, 0, fileSector, 1, loadaddr, spoolFunc);
	specBlocksToLoad--;
}



// decompiled code
// original method signature: 
// void /*$ra*/ CheckSpecialSpool()
 // line 2956, offset 0x0007d4e0
	/* begin block 1 */
		// Start line: 2958
		// Start offset: 0x0007D4E0
		// Variables:
	// 		struct _CAR_DATA *lcp; // $a0
	// 		int ret; // $a3

		/* begin block 1.1 */
			// Start line: 2965
			// Start offset: 0x0007D51C
		/* end block 1.1 */
		// End offset: 0x0007D53C
		// End Line: 2969
	/* end block 1 */
	// End offset: 0x0007D6C8
	// End Line: 3022

	/* begin block 2 */
		// Start line: 6827
	/* end block 2 */
	// End Line: 6828

	/* begin block 3 */
		// Start line: 6828
	/* end block 3 */
	// End Line: 6829

	/* begin block 4 */
		// Start line: 6831
	/* end block 4 */
	// End Line: 6832

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void CheckSpecialSpool(void)
{
	int ret;
	int iVar2;
	_CAR_DATA *lcp;

	if (startSpecSpool != -1 && startSpecSpool+400 < CameraCnt) 
	{
		while (specSpoolComplete == 0)
		{
			SpoolSYNC();

			if (DrawSync(1) == 0)
				SpecialStartNextBlock();

			StartSpooling();
		}

		specModelValid = 1;
		specialState = 0;
		specBlocksToLoad = 0;
		specSpoolComplete = 0;
		startSpecSpool = -1;
	}

	if (allowSpecSpooling && 
		specSpoolComplete != 1 && 
		GameType != GAME_PURSUIT &&
		LoadedArea != -1 &&
		SpecialByRegion[GameLevel][LoadedArea] != MissionHeader->residentModels[4]-7) 
	{
		lcp = car_data;

		// if there are cars that still using special models, deny spooling
		do	// [A]
		{
			if (MissionHeader->residentModels[lcp->ap.model] > 4)
				return;

			lcp++;
		} while (lcp <= &car_data[20]);


		specModelValid = 0;
		startSpecSpool = CameraCnt;

		gCarDamModelPtr[4] = NULL;
		gCarCleanModelPtr[4] = NULL;
		gCarLowModelPtr[4] = NULL;

		specspooldata[2] = SpecialByRegion[GameLevel][LoadedArea];
		MissionHeader->residentModels[4] = SpecialByRegion[GameLevel][LoadedArea] + 7;

		if (specialState == 0)
			SpecialStartNextBlock();
	}
}



// decompiled code
// original method signature: 
// void /*$ra*/ QuickSpoolSpecial()
 // line 3025, offset 0x0007e84c
	/* begin block 1 */
		// Start line: 10949
	/* end block 1 */
	// End Line: 10950

	/* begin block 2 */
		// Start line: 10950
	/* end block 2 */
	// End Line: 10951

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void QuickSpoolSpecial(void)
{
	quickSpool = 1;
	specialState = 0;
	specBlocksToLoad = 0;

	gCarCleanModelPtr[4] = NULL;
	gCarDamModelPtr[4] = NULL;
	gCarLowModelPtr[4] = NULL;

	specspooldata[2] = MissionHeader->residentModels[4]-7;

	do {
		SpoolSYNC();
		DrawSync(0);
		SpecialStartNextBlock();
		StartSpooling();
	} while (quickSpool == 1);
}



// decompiled code
// original method signature: 
// void /*$ra*/ PrepareSecretCar()
 // line 3046, offset 0x0007e8dc
	/* begin block 1 */
		// Start line: 11011
	/* end block 1 */
	// End Line: 11012

	/* begin block 2 */
		// Start line: 11012
	/* end block 2 */
	// End Line: 11013

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void PrepareSecretCar(void)
{
	allowSpecSpooling = 0;
	PingOutAllSpecialCivCars();

	gCarDamModelPtr[4] = NULL;
	gCarCleanModelPtr[4] = NULL;
	gCarLowModelPtr[4] = NULL;

	specspooldata[2] = 5;
	specModelValid = 0;
	startSpecSpool = CameraCnt;
	MissionHeader->residentModels[4] = 12;
	specialState = 0;
	specBlocksToLoad = 0;
	SpecialStartNextBlock();
}



// decompiled code
// original method signature: 
// void /*$ra*/ InitSpecSpool()
 // line 3063, offset 0x0007d6d8
	/* begin block 1 */
		// Start line: 7058
	/* end block 1 */
	// End Line: 7059

	/* begin block 2 */
		// Start line: 7059
	/* end block 2 */
	// End Line: 7060

	/* begin block 3 */
		// Start line: 7064
	/* end block 3 */
	// End Line: 7065

/* WARNING: Unknown calling convention yet parameter storage is locked */

// [D]
void InitSpecSpool(void)
{
	switch (gCurrentMissionNumber)
	{
		case 2: 
		case 4:
		case 6:
		case 7:
		case 10:
		case 11:
		case 12:
		case 13:
		case 16:
		case 18:
		case 19:
		case 20:
		case 24:
		case 26:
		case 27:
		case 29:
		case 30:
		case 31:
		case 33:
		case 35:
		case 38:
		case 39:
		case 40:
		case 58:
		case 59:
		case 60:
		case 61:
		case 62:
		case 63:
		case 64:
		case 65:
		case 70:
		case 78:
		case 86:
		case 94:
		case 228:
		case 229:
		case 236:
		case 237:
		case 244:
		case 245:
		case 252:
		case 253:
		case 352:
		case 353:
		case 360:
		case 169:
		case 368:
		case 369:
		case 376:
		case 377:
		case 420:
		case 421:
		case 428:
		case 429:
		case 436:
		case 437:
		case 444:
		case 445:
		case 480:
		case 481:
		case 482:
		case 483:
		case 484:
		case 485:
		case 486:
		case 487:
		case 498:
		case 499:
		case 500:
		case 501:
		case 502:
		case 503:
		case 504:
		case 505:
			allowSpecSpooling = 0;
			break;
		default:
			allowSpecSpooling = 1;
	}

	specModelValid = 1;
	specialState = 0;
	specBlocksToLoad = 0;
	quickSpool = 0;
	specSpoolComplete = 0;
	startSpecSpool = -1;
}