32 files changed, 1589 insertions, 3127 deletions

diff --git a/src/animation/AnimBlendAssocGroup.cpp b/src/animation/AnimBlendAssocGroup.cpp
index df47e9b5..ea6dea3e 100644
--- a/src/animation/AnimBlendAssocGroup.cpp
+++ b/src/animation/AnimBlendAssocGroup.cpp
@@ -14,6 +14,7 @@
 #include "RpAnimBlend.h"
 #include "AnimBlendAssociation.h"
 #include "AnimBlendAssocGroup.h"
+#include "KeyGen.h"
 
 //--MIAMI: file done
 
@@ -109,27 +110,34 @@ strcmpIgnoringDigits(const char *s1, const char *s2)
 	}
 }
 
+extern const char* csPlayerNames[];
+extern const char* playerNames[];
+
 CBaseModelInfo*
 GetModelFromName(const char *name)
 {
 	int i;
-	CBaseModelInfo *mi;
-	char playername[32];
-
-	if(strncasecmp(name, "CSplay", 6) == 0 &&
-	   strncasecmp(CModelInfo::GetModelInfo(MI_PLAYER)->GetModelName(), "ig", 2) == 0){
-		strcpy(playername, CModelInfo::GetModelInfo(MI_PLAYER)->GetModelName());
-		playername[0] = 'C';
-		playername[1] = 'S';
-		name = playername;
+	CBaseModelInfo* mi;
+	if (CKeyGen::GetUppercaseKey(name) == CKeyGen::GetUppercaseKey("cstoni_a")) {
+		i = 0;
+		while (csPlayerNames[i][0] != '\0') {
+			if (CModelInfo::GetModelInfo(0)->GetNameHashKey() == CKeyGen::GetUppercaseKey(playerNames[i])) {
+				name = csPlayerNames[i];
+				break;
+			}
+			i++;
+		}
 	}
 
-	for(i = 0; i < MODELINFOSIZE; i++){
+	uint32 hashKey = CKeyGen::GetUppercaseKey(name);
+	for (i = 0; i < MODELINFOSIZE; i++) {
 		mi = CModelInfo::GetModelInfo(i);
-		if(mi && mi->GetRwObject() && RwObjectGetType(mi->GetRwObject()) == rpCLUMP &&
-		   strcmpIgnoringDigits(mi->GetModelName(), name))
+		if (mi && mi->GetRwObject()
+			&& RwObjectGetType(mi->GetRwObject()) == rpCLUMP &&
+			hashKey == mi->GetNameHashKey())
 			return mi;
 	}
+
 	return nil;
 }
 
@@ -183,3 +191,45 @@ CAnimBlendAssocGroup::CreateAssociations(const char *blockName, RpClump *clump,
 	}
 	numAssociations = numAssocs;
 }
+
+void
+CAnimBlendAssocGroup::CreateAssociations(const char *blockName, const char *animNames, const char *objectNames, int numChars)
+{
+	if (!objectNames) {
+		CreateAssociations(blockName);
+		return;
+	}
+
+	if (assocList)
+		DestroyAssociations();
+
+	animBlock = CAnimManager::GetAnimationBlock(blockName);
+	assocList = new CAnimBlendAssociation[animBlock->numAnims];
+
+	numAssociations = 0;
+	if (animBlock->numAnims > 0)
+	{
+		int i, j;
+		for (i = 0; i < animBlock->numAnims; i++) {
+			int animId = -1;
+			for (j = 0; j != animBlock->numAnims; j++)
+				if (strcmp(CAnimManager::GetAnimation(i + animBlock->firstIndex)->name, animNames + numChars * j) == 0)
+					animId = j;
+
+			if (animId != -1) {
+				CBaseModelInfo* minfo = GetModelFromName(objectNames + numChars * animId);
+				if (minfo)
+				{
+					RpClump* clump = (RpClump*)minfo->CreateInstance();
+					RpAnimBlendClumpInit(clump);
+					assocList[numAssociations].Init(clump, CAnimManager::GetAnimation(i + animBlock->firstIndex));
+					if (IsClumpSkinned(clump))
+						RpClumpForAllAtomics(clump, AtomicRemoveAnimFromSkinCB, nil);
+					RpClumpDestroy(clump);
+					assocList[numAssociations].animId = i + numAssociations;
+					assocList[numAssociations++].groupId = groupId;
+				}
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/animation/AnimBlendAssocGroup.h b/src/animation/AnimBlendAssocGroup.h
index 86f0ca18..e264787e 100644
--- a/src/animation/AnimBlendAssocGroup.h
+++ b/src/animation/AnimBlendAssocGroup.h
@@ -21,4 +21,5 @@ public:
 	CAnimBlendAssociation *CopyAnimation(const char *name);
 	void CreateAssociations(const char *name);
 	void CreateAssociations(const char *blockName, RpClump *clump, const char **animNames, int numAssocs);
+	void CreateAssociations(const char *blockName, const char *animNames, const char *objectNames, int numChars);
 };
diff --git a/src/animation/CutsceneMgr.cpp b/src/animation/CutsceneMgr.cpp
index 88c73661..bbbd9aa3 100644
--- a/src/animation/CutsceneMgr.cpp
+++ b/src/animation/CutsceneMgr.cpp
@@ -22,594 +22,86 @@
 #include "ColStore.h"
 #include "Radar.h"
 #include "Pools.h"
+#include "crossplatform.h"
 
 //--MIAMI: file done
 
-const struct {
-	const char *szTrackName;
-	int iTrackId;
-} musicNameIdAssoc[] = {
-	{ "ASS_1", STREAMED_SOUND_CUTSCENE_ASS_1 },
-	{ "ASS_2", STREAMED_SOUND_CUTSCENE_ASS_2 },
-	{ "BANK_1", STREAMED_SOUND_CUTSCENE_BANK_1 },
-	{ "BANK_2A", STREAMED_SOUND_CUTSCENE_BANK_2A },
-	{ "BANK_2B", STREAMED_SOUND_CUTSCENE_BANK_2B },
-	{ "BANK_3A", STREAMED_SOUND_CUTSCENE_BANK_3A },
-	{ "BANK_3B", STREAMED_SOUND_CUTSCENE_BANK_3B },
-	{ "BANK_4", STREAMED_SOUND_CUTSCENE_BANK_4 },
-	{ "BIKE_1", STREAMED_SOUND_CUTSCENE_BIKE_1 },
-	{ "BIKE_2", STREAMED_SOUND_CUTSCENE_BIKE_2 },
-	{ "BIKE_3", STREAMED_SOUND_CUTSCENE_BIKE_3 },
-	{ "BUD_1", STREAMED_SOUND_CUTSCENE_BUD_1 },
-	{ "BUD_2", STREAMED_SOUND_CUTSCENE_BUD_2 },
-	{ "BUD_3", STREAMED_SOUND_CUTSCENE_BUD_3 },
-	{ "CAP_1", STREAMED_SOUND_CUTSCENE_CAP_1 },
-	{ "CAR_1", STREAMED_SOUND_CUTSCENE_CAR_1 },
-	{ "CNT_1A", STREAMED_SOUND_CUTSCENE_CNT_1A },
-	{ "CNT_1B", STREAMED_SOUND_CUTSCENE_CNT_1B },
-	{ "CNT_2", STREAMED_SOUND_CUTSCENE_CNT_2 },
-	{ "COK_1", STREAMED_SOUND_CUTSCENE_COK_1 },
-	{ "COK_2A", STREAMED_SOUND_CUTSCENE_COK_2A },
-	{ "COK_2B", STREAMED_SOUND_CUTSCENE_COK_2B },
-	{ "COK_3", STREAMED_SOUND_CUTSCENE_COK_3 },
-	{ "COK_4A", STREAMED_SOUND_CUTSCENE_COK_4A },
-	{ "COK_4A2", STREAMED_SOUND_CUTSCENE_COK_4A2 },
-	{ "COK_4B", STREAMED_SOUND_CUTSCENE_COK_4B },
-	{ "COL_1", STREAMED_SOUND_CUTSCENE_COL_1 },
-	{ "COL_2", STREAMED_SOUND_CUTSCENE_COL_2 },
-	{ "COL_3A", STREAMED_SOUND_CUTSCENE_COL_3A },
-	{ "COL_4A", STREAMED_SOUND_CUTSCENE_COL_4A },
-	{ "COL_5A", STREAMED_SOUND_CUTSCENE_COL_5A },
-	{ "COL_5B", STREAMED_SOUND_CUTSCENE_COL_5B },
-	{ "CUB_1", STREAMED_SOUND_CUTSCENE_CUB_1 },
-	{ "CUB_2", STREAMED_SOUND_CUTSCENE_CUB_2 },
-	{ "CUB_3", STREAMED_SOUND_CUTSCENE_CUB_3 },
-	{ "CUB_4", STREAMED_SOUND_CUTSCENE_CUB_4 },
-	{ "DRUG_1", STREAMED_SOUND_CUTSCENE_DRUG_1 },
-	{ "FIN", STREAMED_SOUND_CUTSCENE_FIN },
-	{ "FIN_2", STREAMED_SOUND_CUTSCENE_FIN2 },
-	{ "FINALE", STREAMED_SOUND_CUTSCENE_FINALE },
-	{ "HAT_1", STREAMED_SOUND_CUTSCENE_HAT_1 },
-	{ "HAT_2", STREAMED_SOUND_CUTSCENE_HAT_2 },
-	{ "HAT_3", STREAMED_SOUND_CUTSCENE_HAT_3 },
-	{ "ICE_1", STREAMED_SOUND_CUTSCENE_ICE_1 },
-	{ "INT_A", STREAMED_SOUND_CUTSCENE_INT_A },
-	{ "INT_B", STREAMED_SOUND_CUTSCENE_INT_B },
-	{ "INT_D", STREAMED_SOUND_CUTSCENE_INT_D },
-	{ "INT_M", STREAMED_SOUND_CUTSCENE_INT_M },
-	{ "LAW_1A", STREAMED_SOUND_CUTSCENE_LAW_1A },
-	{ "LAW_1B", STREAMED_SOUND_CUTSCENE_LAW_1B },
-	{ "LAW_2A", STREAMED_SOUND_CUTSCENE_LAW_2A },
-	{ "LAW_2B", STREAMED_SOUND_CUTSCENE_LAW_2B },
-	{ "LAW_2C", STREAMED_SOUND_CUTSCENE_LAW_2C },
-	{ "LAW_3", STREAMED_SOUND_CUTSCENE_LAW_3 },
-	{ "LAW_4", STREAMED_SOUND_CUTSCENE_LAW_4 },
-	{ "PHIL_1", STREAMED_SOUND_CUTSCENE_PHIL_1 },
-	{ "PHIL_2", STREAMED_SOUND_CUTSCENE_PHIL_2 },
-	{ "PORN_1", STREAMED_SOUND_CUTSCENE_PORN_1 },
-	{ "PORN_2", STREAMED_SOUND_CUTSCENE_PORN_2 },
-	{ "PORN_3", STREAMED_SOUND_CUTSCENE_PORN_3 },
-	{ "PORN_4", STREAMED_SOUND_CUTSCENE_PORN_4 },
-	{ "RESC_1A", STREAMED_SOUND_CUTSCENE_RESC_1A },
-	{ "ROK_1", STREAMED_SOUND_CUTSCENE_ROK_1 },
-	{ "ROK_2", STREAMED_SOUND_CUTSCENE_ROK_2 },
-	{ "ROK_3A", STREAMED_SOUND_CUTSCENE_ROK_3A },
-	{ "STRIPA", STREAMED_SOUND_CUTSCENE_STRIPA },
-	{ "TAX_1", STREAMED_SOUND_CUTSCENE_TAX_1 },
-	{ "TEX_1", STREAMED_SOUND_CUTSCENE_TEX_1 },
-	{ "TEX_2", STREAMED_SOUND_CUTSCENE_TEX_2 },
-	{ "TEX_3", STREAMED_SOUND_CUTSCENE_TEX_3 },
-	{ "GSPOT", STREAMED_SOUND_CUTSCENE_GLIGHT },
-	{ "FIST", STREAMED_SOUND_CUTSCENE_FIST },
-	{ "EL_PH1", STREAMED_SOUND_CUTSCENE_ELBURRO1_PH1 },
-	{ "EL_PH2", STREAMED_SOUND_CUTSCENE_ELBURRO2_PH2 },
-	{ NULL, 0 }
-};
+static bool bModelsRemovedForCutscene;
+static int32 NumberOfSavedWeapons;
+static eWeaponType SavedWeaponIDs[TOTAL_WEAPON_SLOTS];
+static int32 SavedWeaponAmmo[TOTAL_WEAPON_SLOTS];
 
-int
-FindCutsceneAudioTrackId(const char *szCutsceneName)
-{
-	for (int i = 0; musicNameIdAssoc[i].szTrackName; i++) {
-		if (!CGeneral::faststricmp(musicNameIdAssoc[i].szTrackName, szCutsceneName))
-			return musicNameIdAssoc[i].iTrackId;
-	}
-	return -1;
-}
-
-bool CCutsceneMgr::ms_running;
-bool CCutsceneMgr::ms_cutsceneProcessing;
+char CCutsceneMgr::ms_cAppendAnimName[NUMCUTSCENEOBJECTS][NAMELENGTH];
+char CCutsceneMgr::ms_cAppendObjectName[NUMCUTSCENEOBJECTS][NAMELENGTH];
+int CCutsceneMgr::ms_numAppendObjectNames;
 CDirectory *CCutsceneMgr::ms_pCutsceneDir;
-CCutsceneObject *CCutsceneMgr::ms_pCutsceneObjects[NUMCUTSCENEOBJECTS];
-int32 CCutsceneMgr::ms_numCutsceneObjs;
 bool CCutsceneMgr::ms_loaded;
-bool CCutsceneMgr::ms_animLoaded;
-bool CCutsceneMgr::ms_useLodMultiplier;
-char CCutsceneMgr::ms_cutsceneName[CUTSCENENAMESIZE];
-CAnimBlendAssocGroup CCutsceneMgr::ms_cutsceneAssociations;
-CVector CCutsceneMgr::ms_cutsceneOffset;
-float CCutsceneMgr::ms_cutsceneTimer;
+bool CCutsceneMgr::ms_hasFileInfo;
 bool CCutsceneMgr::ms_wasCutsceneSkipped;
+bool CCutsceneMgr::ms_useLodMultiplier;
+bool CCutsceneMgr::ms_cutsceneProcessing;
+bool CCutsceneMgr::ms_running;
+bool CCutsceneMgr::ms_animLoaded;
 uint32 CCutsceneMgr::ms_cutsceneLoadStatus;
-bool CCutsceneMgr::ms_useCutsceneShadows = true;
-
-bool bCamLoaded;
-bool bIsEverythingRemovedFromTheWorldForTheBiggestFuckoffCutsceneEver; // pls don't shrink the name :P
-int32 NumberOfSavedWeapons;
-eWeaponType SavedWeaponIDs[TOTAL_WEAPON_SLOTS];
-int32 SavedWeaponAmmo[TOTAL_WEAPON_SLOTS];
-char uncompressedAnims[8][32];
-uint32 numUncompressedAnims;
-
-
-RpAtomic *
-CalculateBoundingSphereRadiusCB(RpAtomic *atomic, void *data)
-{
-	float radius = RpAtomicGetBoundingSphere(atomic)->radius;
-	RwV3d center = RpAtomicGetBoundingSphere(atomic)->center;
-
-	for (RwFrame *frame = RpAtomicGetFrame(atomic); RwFrameGetParent(frame); frame = RwFrameGetParent(frame))
-		RwV3dTransformPoints(&center, &center, 1, RwFrameGetMatrix(frame));
-
-	float size = RwV3dLength(&center) + radius;
-	if (size > *(float *)data)
-		*(float *)data = size;
-	return atomic;
-}
 
 void
-CCutsceneMgr::Initialise(void)
+CCutsceneMgr::Initialise(void *dir)
 {
-	ms_numCutsceneObjs = 0;
-	ms_loaded = false;
-	ms_wasCutsceneSkipped = false;
+	ms_cutsceneLoadStatus = CUTSCENE_NOT_LOADED;
 	ms_running = false;
-	ms_useLodMultiplier = false;
 	ms_animLoaded = false;
 	ms_cutsceneProcessing = false;
-
-	ms_pCutsceneDir = new CDirectory(CUTSCENEDIRSIZE);
-	ms_pCutsceneDir->ReadDirFile("ANIM\\CUTS.DIR");
-
-	numUncompressedAnims = 0;
-	uncompressedAnims[0][0] = '\0';
-}
-
-void
-CCutsceneMgr::Shutdown(void)
-{
-	delete ms_pCutsceneDir;
-}
-
-void
-CCutsceneMgr::LoadCutsceneData(const char *szCutsceneName)
-{
-	int file;
-	uint32 size;
-	uint32 offset;
-	CPlayerPed *pPlayerPed;
-
-	ms_cutsceneProcessing = true;
+	ms_useLodMultiplier = false;
 	ms_wasCutsceneSkipped = false;
-	CTimer::Suspend();
-	if (!bIsEverythingRemovedFromTheWorldForTheBiggestFuckoffCutsceneEver)
-		CStreaming::RemoveCurrentZonesModels();
-
-	ms_pCutsceneDir->numEntries = 0;
-	ms_pCutsceneDir->ReadDirFile("ANIM\\CUTS.DIR");
-
-	CStreaming::RemoveUnusedModelsInLoadedList();
-	CGame::DrasticTidyUpMemory(true);
-
-	strcpy(ms_cutsceneName, szCutsceneName);
-
-	RwStream *stream;
-	stream = RwStreamOpen(rwSTREAMFILENAME, rwSTREAMREAD, "ANIM\\CUTS.IMG");
-	assert(stream);
-
-	// Load animations
-	sprintf(gString, "%s.IFP", szCutsceneName);
-	if (ms_pCutsceneDir->FindItem(gString, offset, size)) {
-		CStreaming::MakeSpaceFor(size << 11);
-		CStreaming::ImGonnaUseStreamingMemory();
-		RwStreamSkip(stream,  offset << 11);
-		CAnimManager::LoadAnimFile(stream, true, uncompressedAnims);
-		ms_cutsceneAssociations.CreateAssociations(szCutsceneName);
-		CStreaming::IHaveUsedStreamingMemory();
-		ms_animLoaded = true;
-	} else {
-		ms_animLoaded = false;
-	}
-	RwStreamClose(stream, nil);
-
-	// Load camera data
-	file = CFileMgr::OpenFile("ANIM\\CUTS.IMG", "rb");
-	sprintf(gString, "%s.DAT", szCutsceneName);
-	if (ms_pCutsceneDir->FindItem(gString, offset, size)) {
-		CStreaming::ImGonnaUseStreamingMemory();
-		CFileMgr::Seek(file, offset << 11, SEEK_SET);
-		TheCamera.LoadPathSplines(file);
-		CStreaming::IHaveUsedStreamingMemory();
-		bCamLoaded = true;
-	} else {
-		bCamLoaded = false;
-	}
-
-	CFileMgr::CloseFile(file);
-
-	if (CGeneral::faststricmp(ms_cutsceneName, "finale")) {
-		DMAudio.ChangeMusicMode(MUSICMODE_CUTSCENE);
-		int trackId = FindCutsceneAudioTrackId(szCutsceneName);
-		if (trackId != -1) {
-			printf("Start preload audio %s\n", szCutsceneName);
-			DMAudio.PreloadCutSceneMusic(trackId);
-			printf("End preload audio %s\n", szCutsceneName);
-		}
+	ms_hasFileInfo = false;
+	//ms_numCutsceneObjs = 0;
+	//ms_loaded = false;
+	if (gMakeResources) {
+		ms_pCutsceneDir = new CDirectory(CUTSCENEDIRSIZE);
+		ms_pCutsceneDir->ReadDirFile("ANIM\\CUTS.DIR");
 	}
+	else
+		ms_pCutsceneDir = (CDirectory*)dir;
 
-	ms_cutsceneTimer = 0.0f;
-	ms_loaded = true;
-	ms_cutsceneOffset = CVector(0.0f, 0.0f, 0.0f);
-
-	pPlayerPed = FindPlayerPed();
-	pPlayerPed->m_pWanted->ClearQdCrimes();
-	pPlayerPed->bIsVisible = false;
-	pPlayerPed->m_fCurrentStamina = pPlayerPed->m_fMaxStamina;
-	CPad::GetPad(0)->SetDisablePlayerControls(PLAYERCONTROL_CUTSCENE);
-	CWorld::Players[CWorld::PlayerInFocus].MakePlayerSafe(true);
-
-	CTimer::Resume();
-}
-
-void
-CCutsceneMgr::FinishCutscene()
-{
-	ms_wasCutsceneSkipped = true;
-	if (bCamLoaded) {
-		CCutsceneMgr::ms_cutsceneTimer = TheCamera.GetCutSceneFinishTime() * 0.001f;
-		TheCamera.FinishCutscene();
-	}
-
-	FindPlayerPed()->bIsVisible = true;
-	CWorld::Players[CWorld::PlayerInFocus].MakePlayerSafe(false);
+	//numUncompressedAnims = 0;
+	//uncompressedAnims[0][0] = '\0';
 }
 
-void
-CCutsceneMgr::SetupCutsceneToStart(void)
+void CCutsceneMgr::Write(base::cRelocatableChunkWriter& writer)
 {
-	if (bCamLoaded) {
-		TheCamera.SetCamCutSceneOffSet(ms_cutsceneOffset);
-		TheCamera.TakeControlWithSpline(JUMP_CUT);
-		TheCamera.SetWideScreenOn();
-	}
-
-	ms_cutsceneOffset.z++;
-
-	for (int i = ms_numCutsceneObjs - 1; i >= 0; i--) {
-		assert(RwObjectGetType(ms_pCutsceneObjects[i]->m_rwObject) == rpCLUMP);
-		if (CAnimBlendAssociation *pAnimBlendAssoc = RpAnimBlendClumpGetFirstAssociation((RpClump*)ms_pCutsceneObjects[i]->m_rwObject)) {
-			assert(pAnimBlendAssoc->hierarchy->sequences[0].HasTranslation());
-			if (ms_pCutsceneObjects[i]->m_pAttachTo != nil) {
-				pAnimBlendAssoc->flags &= (~ASSOC_HAS_TRANSLATION);
-			} else {
-				if (pAnimBlendAssoc->hierarchy->IsCompressed()){
-					KeyFrameTransCompressed *keyFrames = ((KeyFrameTransCompressed*)pAnimBlendAssoc->hierarchy->sequences[0].GetKeyFrameCompressed(0));
-					CVector trans;
-					keyFrames->GetTranslation(&trans);
-					ms_pCutsceneObjects[i]->SetPosition(ms_cutsceneOffset + trans);
-				}else{
-					KeyFrameTrans *keyFrames = ((KeyFrameTrans*)pAnimBlendAssoc->hierarchy->sequences[0].GetKeyFrame(0));
-					ms_pCutsceneObjects[i]->SetPosition(ms_cutsceneOffset + keyFrames->translation);
-				}
-			}
-			pAnimBlendAssoc->SetRun();
-		} else {
-			ms_pCutsceneObjects[i]->SetPosition(ms_cutsceneOffset);
-		}
-		CWorld::Add(ms_pCutsceneObjects[i]);
-		if (RwObjectGetType(ms_pCutsceneObjects[i]->m_rwObject) == rpCLUMP) {
-			ms_pCutsceneObjects[i]->UpdateRpHAnim();
-		}
-	}
-
-	CTimer::Update();
-	CTimer::Update();
-	ms_running = true;
-	ms_cutsceneTimer = 0.0f;
+	writer.AllocateRaw(ms_pCutsceneDir, sizeof(*ms_pCutsceneDir), 4, false, true);
+	writer.AllocateRaw(ms_pCutsceneDir->entries, sizeof(CDirectory::DirectoryInfo) * ms_pCutsceneDir->numEntries, 4, false, true);
+	writer.AddPatch(ms_pCutsceneDir);
 }
 
 void
-CCutsceneMgr::SetCutsceneAnim(const char *animName, CObject *pObject)
+CCutsceneMgr::Shutdown(void)
 {
-	CAnimBlendAssociation *pNewAnim;
-	CAnimBlendClumpData *pAnimBlendClumpData;
-
-	assert(RwObjectGetType(pObject->m_rwObject) == rpCLUMP);
-	debug("Give cutscene anim %s\n", animName);
-	RpAnimBlendClumpRemoveAllAssociations((RpClump*)pObject->m_rwObject);
-
-	pNewAnim = ms_cutsceneAssociations.GetAnimation(animName);
-	if (!pNewAnim) {
-		debug("\n\nHaven't I told you I can't find the fucking animation %s\n\n\n", animName);
-		return;
-	}
-
-	if (pNewAnim->hierarchy->IsCompressed())
-		pNewAnim->hierarchy->keepCompressed = true;
-
-	CStreaming::ImGonnaUseStreamingMemory();
-	pNewAnim = ms_cutsceneAssociations.CopyAnimation(animName);
-	CStreaming::IHaveUsedStreamingMemory();
-
-	pNewAnim->SetCurrentTime(0.0f);
-	pNewAnim->flags |= ASSOC_HAS_TRANSLATION;
-	pNewAnim->flags &= ~ASSOC_RUNNING;
-
-	pAnimBlendClumpData = *RPANIMBLENDCLUMPDATA(pObject->m_rwObject);
-	pAnimBlendClumpData->link.Prepend(&pNewAnim->link);
-
-	if (pNewAnim->hierarchy->keepCompressed)
-		pAnimBlendClumpData->frames->flag |= AnimBlendFrameData::COMPRESSED;
+	delete ms_pCutsceneDir;
 }
 
 void
-CCutsceneMgr::SetCutsceneAnimToLoop(const char* animName)
-{
-	ms_cutsceneAssociations.GetAnimation(animName)->flags |= ASSOC_REPEAT;
-}
-
-CCutsceneHead *
-CCutsceneMgr::AddCutsceneHead(CObject *pObject, int modelId)
-{
-	return nil;
-}
-
-void UpdateCutsceneObjectBoundingBox(RpClump* clump, int modelId)
-{
-	if (modelId >= MI_CUTOBJ01 && modelId <= MI_CUTOBJ05) {
-		CColModel* pColModel = &CTempColModels::ms_colModelCutObj[modelId - MI_CUTOBJ01];
-		float radius = 0.0f;
-		RpClumpForAllAtomics(clump, CalculateBoundingSphereRadiusCB, &radius);
-		pColModel->boundingSphere.radius = radius;
-		pColModel->boundingBox.min = CVector(-radius, -radius, -radius);
-		pColModel->boundingBox.max = CVector(radius, radius, radius);
-	}
-}
-
-CCutsceneObject *
-CCutsceneMgr::CreateCutsceneObject(int modelId)
+CCutsceneMgr::LoadCutsceneData(const char *szCutsceneName)
 {
-	CBaseModelInfo *pModelInfo;
-	CColModel *pColModel;
-	CCutsceneObject *pCutsceneObject;
-
-	CStreaming::ImGonnaUseStreamingMemory();
-	debug("Created cutscene object %s\n", CModelInfo::GetModelInfo(modelId)->GetModelName());
-	if (modelId >= MI_CUTOBJ01 && modelId <= MI_CUTOBJ05) {
-		pModelInfo = CModelInfo::GetModelInfo(modelId);
-		pColModel = &CTempColModels::ms_colModelCutObj[modelId - MI_CUTOBJ01];
-		pModelInfo->SetColModel(pColModel);
-		UpdateCutsceneObjectBoundingBox((RpClump*)pModelInfo->GetRwObject(), modelId);
-	} else if (modelId >= MI_SPECIAL01 && modelId <= MI_SPECIAL21) {
-		pModelInfo = CModelInfo::GetModelInfo(modelId);
-		if (pModelInfo->GetColModel() == &CTempColModels::ms_colModelPed1) {
-			CColModel *colModel = new CColModel();
-			colModel->boundingSphere.radius = 2.0f;
-			colModel->boundingSphere.center = CVector(0.0f, 0.0f, 0.0f);
-			pModelInfo->SetColModel(colModel, true);
-		}
-		pColModel = pModelInfo->GetColModel();
-		float radius = 2.0f;
-		pColModel->boundingSphere.radius = radius;
-		pColModel->boundingBox.min = CVector(-radius, -radius, -radius);
-		pColModel->boundingBox.max = CVector(radius, radius, radius);
-	}
-
-	pCutsceneObject = new CCutsceneObject();
-	pCutsceneObject->SetModelIndex(modelId);
-	if (ms_useCutsceneShadows)
-		pCutsceneObject->CreateShadow();
-	ms_pCutsceneObjects[ms_numCutsceneObjs++] = pCutsceneObject;
-	CStreaming::IHaveUsedStreamingMemory();
-	return pCutsceneObject;
+	LoadCutsceneData_overlay(szCutsceneName);
 }
 
 void
 CCutsceneMgr::DeleteCutsceneData(void)
 {
-	if (!ms_loaded) return;
-	CTimer::Suspend();
-
-	ms_cutsceneProcessing = false;
-	ms_useLodMultiplier = false;
-	ms_useCutsceneShadows = true;
-
-	for (--ms_numCutsceneObjs; ms_numCutsceneObjs >= 0; ms_numCutsceneObjs--) {
-		CWorld::Remove(ms_pCutsceneObjects[ms_numCutsceneObjs]);
-		ms_pCutsceneObjects[ms_numCutsceneObjs]->DeleteRwObject();
-		delete ms_pCutsceneObjects[ms_numCutsceneObjs];
-		ms_pCutsceneObjects[ms_numCutsceneObjs] = nil;
-	}
-	ms_numCutsceneObjs = 0;
-
-	/* TODO!!! tmp hack
-	for (int i = MI_SPECIAL01; i < MI_SPECIAL21; i++) {
-		CBaseModelInfo *minfo = CModelInfo::GetModelInfo(i);
-		CColModel *colModel = minfo->GetColModel();
-		if (colModel != &CTempColModels::ms_colModelPed1) {
-			delete colModel;
-			minfo->SetColModel(&CTempColModels::ms_colModelPed1);
-		}
-	}
-	*/
-
-	if (ms_animLoaded)
-		CAnimManager::RemoveLastAnimFile();
-
-	ms_animLoaded = false;
-	numUncompressedAnims = 0;
-	uncompressedAnims[0][0] = '\0';
-
-	if (bCamLoaded) {
-		TheCamera.RestoreWithJumpCut();
-		TheCamera.SetWideScreenOff();
-		TheCamera.DeleteCutSceneCamDataMemory();
-	}
-	ms_running = false;
-	ms_loaded = false;
-
-	FindPlayerPed()->bIsVisible = true;
-	CPad::GetPad(0)->SetEnablePlayerControls(PLAYERCONTROL_CUTSCENE);
-	CWorld::Players[CWorld::PlayerInFocus].MakePlayerSafe(false);
-
-	if (CGeneral::faststricmp(ms_cutsceneName, "finale")) {
-		DMAudio.StopCutSceneMusic();
-		DMAudio.ChangeMusicMode(MUSICMODE_GAME);
-	}
-
-	CStreaming::ms_disableStreaming = false;
-	CWorld::bProcessCutsceneOnly = false;
-
-	if(bCamLoaded)
-		CGame::DrasticTidyUpMemory(TheCamera.GetScreenFadeStatus() == FADE_2);
-	
-	CPad::GetPad(0)->Clear(false);
-	if (bIsEverythingRemovedFromTheWorldForTheBiggestFuckoffCutsceneEver) {
-		CStreaming::LoadInitialPeds();
-		CStreaming::LoadInitialWeapons();
-		CStreaming::LoadInitialVehicles();
-		bIsEverythingRemovedFromTheWorldForTheBiggestFuckoffCutsceneEver = false;
-		
-		CPlayerPed *pPlayerPed = FindPlayerPed();
-		for (int i = 0; i < NumberOfSavedWeapons; i++) {
-			int32 weaponModelId = CWeaponInfo::GetWeaponInfo(SavedWeaponIDs[i])->m_nModelId;
-			uint8 flags = CStreaming::ms_aInfoForModel[weaponModelId].m_flags;
-			CStreaming::RequestModel(weaponModelId, STREAMFLAGS_DONT_REMOVE);
-			CStreaming::LoadAllRequestedModels(false);
-			if (CWeaponInfo::GetWeaponInfo(SavedWeaponIDs[i])->m_nModel2Id != -1) {
-				CStreaming::RequestModel(CWeaponInfo::GetWeaponInfo(SavedWeaponIDs[i])->m_nModel2Id, 0);
-				CStreaming::LoadAllRequestedModels(false);
-			}
-			if (!(flags & STREAMFLAGS_DONT_REMOVE))
-				CStreaming::SetModelIsDeletable(weaponModelId);
-			pPlayerPed->GiveWeapon(SavedWeaponIDs[i], SavedWeaponAmmo[i], true);
-		}
-		NumberOfSavedWeapons = 0;
-	}
-
-	CTimer::Resume();
-}
-
-void
-CCutsceneMgr::Update(void)
-{
-	enum {
-		CUTSCENE_LOADING_0 = 0,
-		CUTSCENE_LOADING_AUDIO,
-		CUTSCENE_LOADING_2,
-		CUTSCENE_LOADING_3,
-		CUTSCENE_LOADING_4
-	};
-
-	switch (ms_cutsceneLoadStatus) {
-	case CUTSCENE_LOADING_AUDIO:
-		SetupCutsceneToStart();
-		if (CGeneral::faststricmp(ms_cutsceneName, "finale"))
-			DMAudio.PlayPreloadedCutSceneMusic();
-		ms_cutsceneLoadStatus++;
-		break;
-	case CUTSCENE_LOADING_2:
-	case CUTSCENE_LOADING_3:
-		ms_cutsceneLoadStatus++;
-		break;
-	case CUTSCENE_LOADING_4:
-		ms_cutsceneLoadStatus = CUTSCENE_LOADING_0;
-		break;
-	default:
-		break;
-	}
-
-	if (!ms_running) return;
-
-	ms_cutsceneTimer += CTimer::GetTimeStepNonClippedInSeconds();
-
-	for (int i = 0; i < ms_numCutsceneObjs; i++) {
-		int modelId = ms_pCutsceneObjects[i]->GetModelIndex();
-		if (modelId >= MI_CUTOBJ01 && modelId <= MI_CUTOBJ05)
-			UpdateCutsceneObjectBoundingBox(ms_pCutsceneObjects[i]->GetClump(), modelId);
-
-		if (ms_pCutsceneObjects[i]->m_pAttachTo != nil && modelId >= MI_SPECIAL01 && modelId <= MI_SPECIAL21)
-			UpdateCutsceneObjectBoundingBox(ms_pCutsceneObjects[i]->GetClump(), modelId);
-	}
-
-	if (bCamLoaded)
-		if (CGeneral::faststricmp(ms_cutsceneName, "finale") && TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FLYBY && ms_cutsceneLoadStatus == CUTSCENE_LOADING_0) {
-			if (CPad::GetPad(0)->GetCrossJustDown()
-				|| (CGame::playingIntro && CPad::GetPad(0)->GetStartJustDown())
-				|| CPad::GetPad(0)->GetLeftMouseJustDown()
-				|| CPad::GetPad(0)->GetEnterJustDown()
-				|| CPad::GetPad(0)->GetCharJustDown(' '))
-					FinishCutscene();
-		}
-}
-
-bool CCutsceneMgr::HasCutsceneFinished(void) { return !bCamLoaded || TheCamera.GetPositionAlongSpline() == 1.0f; }
-
-void
-CCutsceneMgr::LoadAnimationUncompressed(char const* name)
-{
-	strcpy(uncompressedAnims[numUncompressedAnims], name);
-	
-	// Because that's how CAnimManager knows the end of array
-	++numUncompressedAnims;
-	assert(numUncompressedAnims < ARRAY_SIZE(uncompressedAnims));
-	uncompressedAnims[numUncompressedAnims][0] = '\0';
-}
-
-void
-CCutsceneMgr::AttachObjectToParent(CObject *pObject, CEntity *pAttachTo)
-{
-	((CCutsceneObject*)pObject)->m_pAttachmentObject = nil;
-	((CCutsceneObject*)pObject)->m_pAttachTo = RpClumpGetFrame(pAttachTo->GetClump());
-
-	debug("Attach %s to %s\n", CModelInfo::GetModelInfo(pObject->GetModelIndex())->GetModelName(), CModelInfo::GetModelInfo(pAttachTo->GetModelIndex())->GetModelName());
-}
-
-void
-CCutsceneMgr::AttachObjectToFrame(CObject *pObject, CEntity *pAttachTo, const char *frame)
-{
-	((CCutsceneObject*)pObject)->m_pAttachmentObject = nil;
-	((CCutsceneObject*)pObject)->m_pAttachTo = RpAnimBlendClumpFindFrame(pAttachTo->GetClump(), frame)->frame;
-	debug("Attach %s to component %s of %s\n",
-		CModelInfo::GetModelInfo(pObject->GetModelIndex())->GetModelName(),
-		frame,
-		CModelInfo::GetModelInfo(pAttachTo->GetModelIndex())->GetModelName());
-	if (RwObjectGetType(pObject->m_rwObject) == rpCLUMP) {
-		RpClump *clump = (RpClump*)pObject->m_rwObject;
-		if (IsClumpSkinned(clump))
-			RpAtomicGetBoundingSphere(GetFirstAtomic(clump))->radius *= 1.1f;
-	}
+	DeleteCutsceneData_overlay();
+	if (bModelsRemovedForCutscene)
+		LoadEverythingBecauseCutsceneDeletedAllOfIt();
 }
 
 void
-CCutsceneMgr::AttachObjectToBone(CObject *pObject, CObject *pAttachTo, int bone)
+CCutsceneMgr::RemoveEverythingBecauseCutsceneDoesntFitInMemory()
 {
-	RpHAnimHierarchy *hanim = GetAnimHierarchyFromSkinClump(pAttachTo->GetClump());
-	RwInt32 id = RpHAnimIDGetIndex(hanim, bone);
-	RwMatrix *matrixArray = RpHAnimHierarchyGetMatrixArray(hanim);
-	((CCutsceneObject*)pObject)->m_pAttachmentObject = pAttachTo;
-	((CCutsceneObject*)pObject)->m_pAttachTo = &matrixArray[id];
-	debug("Attach %s to %s\n",
-		CModelInfo::GetModelInfo(pObject->GetModelIndex())->GetModelName(),
-		CModelInfo::GetModelInfo(pAttachTo->GetModelIndex())->GetModelName());
-}
-
-void
-CCutsceneMgr::RemoveEverythingFromTheWorldForTheBiggestFuckoffCutsceneEver()
-{
-	CStreaming::ms_disableStreaming = true;
+	//CStreaming::ms_disableStreaming = true;
+	CWorld::ClearExcitingStuffFromArea(FindPlayerCoors(), 120.0f, true);
 	CColStore::RemoveAllCollision();
 	CWorld::bProcessCutsceneOnly = true;
-	ms_cutsceneProcessing = true;
+	/*ms_cutsceneProcessing = true;
 
 	for (int i = CPools::GetPedPool()->GetSize() - 1; i >= 0; i--) {
 		CPed *pPed = CPools::GetPedPool()->GetSlot(i);
@@ -630,25 +122,21 @@ CCutsceneMgr::RemoveEverythingFromTheWorldForTheBiggestFuckoffCutsceneEver()
 			}
 		}
 	}
-
-	bIsEverythingRemovedFromTheWorldForTheBiggestFuckoffCutsceneEver = true;
+	CWorld::bProcessCutsceneOnly = true;
+	//bIsEverythingRemovedFromTheWorldForTheBiggestFuckoffCutsceneEver = true;*/
 	CStreaming::RemoveCurrentZonesModels();
+	while (CStreaming::RemoveLoadedVehicle());
+	CRadar::RemoveRadarSections();
 	CStreaming::SetModelIsDeletable(MI_MALE01);
 	CStreaming::SetModelTxdIsDeletable(MI_MALE01);
-	CStreaming::SetModelIsDeletable(MI_TAXI_D);
-	CStreaming::SetModelTxdIsDeletable(MI_TAXI_D);
+	CStreaming::SetModelIsDeletable(MI_COLT45);
+	CStreaming::SetModelTxdIsDeletable(MI_COLT45);
 	CStreaming::SetModelIsDeletable(MI_NIGHTSTICK);
 	CStreaming::SetModelTxdIsDeletable(MI_NIGHTSTICK);
 	CStreaming::SetModelIsDeletable(MI_MISSILE);
 	CStreaming::SetModelTxdIsDeletable(MI_MISSILE);
-	CStreaming::SetModelIsDeletable(MI_POLICE);
-	CStreaming::SetModelTxdIsDeletable(MI_POLICE);
-
-	while (CStreaming::RemoveLoadedVehicle()) ;
-
-	CRadar::RemoveRadarSections();
 
-	for (int i = CPools::GetDummyPool()->GetSize() - 1; i >= 0; i--) {
+	/*for (int i = CPools::GetDummyPool()->GetSize() - 1; i >= 0; i--) {
 		CDummy* pDummy = CPools::GetDummyPool()->GetSlot(i);
 		if (pDummy)
 			pDummy->DeleteRwObject();
@@ -668,7 +156,7 @@ CCutsceneMgr::RemoveEverythingFromTheWorldForTheBiggestFuckoffCutsceneEver()
 			if (!pBuilding->bImBeingRendered)
 				pBuilding->DeleteRwObject();
 		}
-	}
+	}*/
 
 	CPlayerPed *pPlayerPed = FindPlayerPed();
 	pPlayerPed->RemoveWeaponAnims(0, -1000.0f);
@@ -683,5 +171,69 @@ CCutsceneMgr::RemoveEverythingFromTheWorldForTheBiggestFuckoffCutsceneEver()
 	}
 
 	pPlayerPed->ClearWeapons();
-	CGame::DrasticTidyUpMemory(true);
+	bModelsRemovedForCutscene = true;
+	//CGame::DrasticTidyUpMemory(true);
+}
+
+void
+CCutsceneMgr::LoadEverythingBecauseCutsceneDeletedAllOfIt()
+{
+	bModelsRemovedForCutscene = false;
+	CStreaming::LoadInitialPeds();
+	CStreaming::LoadInitialWeapons();
+	//CStreaming::LoadInitialVehicles();
+		
+	CPlayerPed *pPlayerPed = FindPlayerPed();
+	for (int i = 0; i < NumberOfSavedWeapons; i++) {
+		int32 weaponModelId = CWeaponInfo::GetWeaponInfo(SavedWeaponIDs[i])->m_nModelId;
+		uint8 flags = CStreaming::ms_aInfoForModel[weaponModelId].m_flags;
+		CStreaming::RequestModel(weaponModelId, STREAMFLAGS_DONT_REMOVE);
+		CStreaming::LoadAllRequestedModels(false);
+		if (CWeaponInfo::GetWeaponInfo(SavedWeaponIDs[i])->m_nModel2Id != -1) {
+			CStreaming::RequestModel(CWeaponInfo::GetWeaponInfo(SavedWeaponIDs[i])->m_nModel2Id, 0);
+			CStreaming::LoadAllRequestedModels(false);
+		}
+		if (!(flags & STREAMFLAGS_DONT_REMOVE))
+			CStreaming::SetModelIsDeletable(weaponModelId);
+		pPlayerPed->GiveWeapon(SavedWeaponIDs[i], SavedWeaponAmmo[i], true);
+	}
+	NumberOfSavedWeapons = 0;
+}
+
+void
+CCutsceneMgr::Update(void)
+{
+	if (ms_cutsceneLoadStatus != CUTSCENE_NOT_LOADED)
+		Update_overlay();
+}
+
+void
+CCutsceneMgr::LoadAnimationUncompressed(char const* name)
+{
+	strcpy(ms_aUncompressedCutsceneAnims[ms_numUncompressedCutsceneAnims], name);
+	
+	// Because that's how CAnimManager knows the end of array
+	++ms_numUncompressedCutsceneAnims;
+	assert(ms_numUncompressedCutsceneAnims < ARRAY_SIZE(ms_aUncompressedCutsceneAnims));
+	ms_aUncompressedCutsceneAnims[ms_numUncompressedCutsceneAnims][0] = '\0';
+}
+
+
+bool
+CCutsceneMgr::IsCutsceneSkipButtonBeingPressed()
+{
+	return (CPad::GetPad(0)->GetCrossJustDown()
+		|| CPad::GetPad(0)->GetLeftMouseJustDown()
+		|| CPad::GetPad(0)->GetEnterJustDown()
+		|| CPad::GetPad(0)->GetCharJustDown(' '));
+}
+
+void
+CCutsceneMgr::AppendToNextCutscene(const char *object, const char *anim)
+{
+	strcpy(ms_cAppendObjectName[ms_numAppendObjectNames], object);
+	strlwr(ms_cAppendObjectName[ms_numAppendObjectNames]);
+	strcpy(ms_cAppendAnimName[ms_numAppendObjectNames], anim);
+	strlwr(ms_cAppendAnimName[ms_numAppendObjectNames]);
+	ms_numAppendObjectNames++;
 }
\ No newline at end of file
diff --git a/src/animation/CutsceneMgr.h b/src/animation/CutsceneMgr.h
index 51ef6c04..7c749d4b 100644
--- a/src/animation/CutsceneMgr.h
+++ b/src/animation/CutsceneMgr.h
@@ -1,14 +1,69 @@
 #pragma once
 #include "CutsceneObject.h"
 
-#define CUTSCENENAMESIZE 8
 
 class CDirectory;
 class CAnimBlendAssocGroup;
 class CCutsceneHead;
 
+enum {
+	CUTSCENE_NOT_LOADED = 0,
+	CUTSCENE_LOADING,
+	CUTSCENE_LOADED,
+};
+
+enum {
+	CUTSCENE_PLAYING_0 = 0,
+	CUTSCENE_STARTED,
+	CUTSCENE_PLAYING_2,
+	CUTSCENE_PLAYING_3,
+	CUTSCENE_PLAYING_4,
+};
+
+enum
+{
+	NAMELENGTH = 32,
+	NUM_CUTS_PARTICLE_EFFECTS = 8,
+	NUM_CUTS_MAX_TEXTS = 64,
+	NUM_CUTS_UNCOMPRESSED_ANIMS = 8,
+	TEXT_KEY_SIZE = 8,
+	CUTSCENENAMESIZE = 8
+};
+
+struct sToHideItem
+{
+	float x, y, z;
+	char name[NAMELENGTH];
+};
+
+// TODO: figure out from SA
+// this is unused in LCS anyway
+struct sParticleEffect
+{
+	char name[NAMELENGTH];
+	bool bPlayed; // ??
+	int iTime;
+	int unk1;
+	int unk2;
+	char name2[NAMELENGTH];
+	float x;
+	float y;
+	float z;
+	float unkX;
+	float unkY;
+	float unkZ;
+	bool unk10;
+	bool unk11;
+};
+
+struct sAttachInfo
+{
+	int attachToId, objectId, boneId;
+};
+
 class CCutsceneMgr
 {
+
 	static bool ms_running;
 	static CCutsceneObject *ms_pCutsceneObjects[NUMCUTSCENEOBJECTS];
 	
@@ -24,10 +79,55 @@ class CCutsceneMgr
 	static bool ms_wasCutsceneSkipped;
 	static bool ms_cutsceneProcessing;
 	static bool ms_useCutsceneShadows;
+	static bool ms_hasFileInfo;
+	static int ms_numLoadObjectNames;
+
+	static char ms_cAppendAnimName[NUMCUTSCENEOBJECTS][NAMELENGTH];
+	static char ms_cAppendObjectName[NUMCUTSCENEOBJECTS][NAMELENGTH];
+	static int ms_numAppendObjectNames;
 public:
 	static CDirectory *ms_pCutsceneDir;
 	static uint32 ms_cutsceneLoadStatus;
 
+	static bool mCutsceneSkipFading;
+	static int mCutsceneSkipFadeTime;
+
+	static float m_fPrevCarDensity;
+	static float m_fPrevPedDensity;
+
+	static bool m_PrevExtraColourOn;
+	static uint32 m_PrevExtraColour;
+
+	static uint32 ms_iNumParticleEffects;
+	static sParticleEffect ms_pParticleEffects[NUM_CUTS_PARTICLE_EFFECTS];
+
+	static sToHideItem ms_crToHideItems[NUMCUTSCENEOBJECTS];
+	static uint32 ms_iNumHiddenEntities;
+	static CEntity *ms_pHiddenEntities[NUMCUTSCENEOBJECTS];
+
+	static int ms_numAttachObjectToBones;
+	static bool ms_bRepeatObject[NUMCUTSCENEOBJECTS];
+
+	static sAttachInfo ms_iAttachObjectToBone[NUMCUTSCENEOBJECTS];
+
+	static uint32 ms_numUncompressedCutsceneAnims;
+
+	static char ms_aUncompressedCutsceneAnims[NUM_CUTS_UNCOMPRESSED_ANIMS][NAMELENGTH];
+
+	static uint32 ms_iTextDuration[NUM_CUTS_MAX_TEXTS];
+	static uint32 ms_iTextStartTime[NUM_CUTS_MAX_TEXTS];
+	static char ms_cTextOutput[NUM_CUTS_MAX_TEXTS][TEXT_KEY_SIZE];
+
+	static uint32 ms_currTextOutput;
+	static uint32 ms_numTextOutput;
+	static uint32 ms_iModelIndex[NUMCUTSCENEOBJECTS];
+
+	static char ms_cLoadAnimName[NUMCUTSCENEOBJECTS][NAMELENGTH];
+	static char ms_cLoadObjectName[NUMCUTSCENEOBJECTS][NAMELENGTH];
+
+	static uint32 ms_cutscenePlayStatus;
+
+	static void StartCutscene();
 	static void StartCutsceneProcessing() { ms_cutsceneProcessing = true; }
 	static bool IsRunning(void) { return ms_running; }
 	static bool HasLoaded(void) { return ms_loaded; }
@@ -35,19 +135,19 @@ public:
 	static bool WasCutsceneSkipped(void) { return ms_wasCutsceneSkipped; }
 	static bool UseLodMultiplier(void) { return ms_useLodMultiplier; }
 	static CCutsceneObject* GetCutsceneObject(int id) { return ms_pCutsceneObjects[id]; }
-	static int GetCutsceneTimeInMilleseconds(void) { return 1000.0f * ms_cutsceneTimer; }
+	static uint32 GetCutsceneTimeInMilleseconds(void);
 	static char *GetCutsceneName(void) { return ms_cutsceneName; }
 	static void SetCutsceneOffset(const CVector& vec) { ms_cutsceneOffset = vec; }
 	static bool HasCutsceneFinished(void);
 
-	static void Initialise(void);
+	static void Initialise(void *dir = nil);
 	static void Shutdown(void);
 	static void LoadCutsceneData(const char *szCutsceneName);
 	static void FinishCutscene(void);
 	static void SetupCutsceneToStart(void);
 	static void SetCutsceneAnim(const char *animName, CObject *pObject);
 	static void SetCutsceneAnimToLoop(const char *animName);
-	static CCutsceneHead *AddCutsceneHead(CObject *pObject, int modelId);
+	static CCutsceneHead *SetHeadAnim(const char*, CObject *pObject);
 	static CCutsceneObject *CreateCutsceneObject(int modelId);
 	static void DeleteCutsceneData(void);
 	static void LoadAnimationUncompressed(char const*);
@@ -56,6 +156,24 @@ public:
 	static void AttachObjectToParent(CObject *pObject, CEntity *pAttachTo);
 	static void AttachObjectToFrame(CObject *pObject, CEntity *pAttachTo, const char *frame);
 	static void AttachObjectToBone(CObject *pObject, CObject *pAttachTo, int frame);
-	static void RemoveEverythingFromTheWorldForTheBiggestFuckoffCutsceneEver();
+	static void RemoveEverythingBecauseCutsceneDoesntFitInMemory();
+	static void LoadEverythingBecauseCutsceneDeletedAllOfIt();
 	static void DisableCutsceneShadows() { ms_useCutsceneShadows = false; }
+
+
+	static void LoadCutsceneData_overlay(const char* szCutsceneName);
+	static bool LoadCutsceneData_postload(bool b = false);
+	static void Update_overlay(void);
+	static void DeleteCutsceneData_overlay(void);
+
+	static bool IsCutsceneSkipButtonBeingPressed();
+	static void AppendToNextCutscene(const char *object, const char *anim);
+
+	static void LoadCutsceneData_preload();
+	static void LoadCutsceneData_loading();
+	static void HideRequestedObjects();
+
+	static bool PresubBodge();
+
+	static void Write(base::cRelocatableChunkWriter& writer);
 };
diff --git a/src/animation/CutsceneMgr_overlay.cpp b/src/animation/CutsceneMgr_overlay.cpp
new file mode 100644
index 00000000..5fcb752d
--- /dev/null
+++ b/src/animation/CutsceneMgr_overlay.cpp
@@ -0,0 +1,1030 @@
+#include "common.h"
+#include "relocatableChunk.h"
+
+#include "General.h"
+#include "CutsceneMgr.h"
+#include "Directory.h"
+#include "Camera.h"
+#include "Streaming.h"
+#include "FileMgr.h"
+#include "main.h"
+#include "AnimManager.h"
+#include "AnimBlendAssociation.h"
+#include "AnimBlendAssocGroup.h"
+#include "AnimBlendClumpData.h"
+#include "Pad.h"
+#include "DMAudio.h"
+#include "World.h"
+#include "PlayerPed.h"
+#include "Wanted.h"
+#include "RpAnimBlend.h"
+#include "ModelIndices.h"
+#include "TempColModels.h"
+#include "ColStore.h"
+#include "Radar.h"
+#include "Pools.h"
+#include "Messages.h"
+#include "Population.h"
+#include "CarCtrl.h"
+#include "Timecycle.h"
+#include "Rubbish.h"
+#include "Text.h"
+#include "Hud.h"
+#include "crossplatform.h"
+
+const struct {
+	const char *szTrackName;
+	int iTrackId;
+} musicNameIdAssoc[] = {
+	{ "BIKER", STREAMED_SOUND_CUTSCENE_BIKER },
+	{ "BONEVOY", STREAMED_SOUND_CUTSCENE_BONEVOY },
+	{ "CAMPAIN", STREAMED_SOUND_CUTSCENE_CAMPAIN },
+	{ "CASHCHP", STREAMED_SOUND_CUTSCENE_CASHCHP },
+	{ "CONTBAN", STREAMED_SOUND_CUTSCENE_CONTBAN },
+	{ "CRAZY69", STREAMED_SOUND_CUTSCENE_CRAZY69 },
+	{ "CUTTEST", STREAMED_SOUND_CUTSCENE_CUTTEST },
+	{ "DEADLY", STREAMED_SOUND_CUTSCENE_DEADLY },
+	{ "DONPROB", STREAMED_SOUND_CUTSCENE_DONPROB },
+	{ "DRIVNMR", STREAMED_SOUND_CUTSCENE_DRIVNMR },
+	{ "ELECTON", STREAMED_SOUND_CUTSCENE_ELECTON },
+	{ "FINAL", STREAMED_SOUND_CUTSCENE_FINAL },
+	{ "FINAL_2", STREAMED_SOUND_CUTSCENE_FINAL_2 },
+	{ "HOMSWET", STREAMED_SOUND_CUTSCENE_HOMSWET },
+	{ "HOTWHEL", STREAMED_SOUND_CUTSCENE_HOTWHEL },
+	{ "KIDNAPP", STREAMED_SOUND_CUTSCENE_KIDNAPP },
+	{ "LANDGRB", STREAMED_SOUND_CUTSCENE_LANDGRB },
+	{ "MORGUE", STREAMED_SOUND_CUTSCENE_MORGUE },
+	{ "OVERDOS", STREAMED_SOUND_CUTSCENE_OVERDOS },
+	{ "RUFJUST", STREAMED_SOUND_CUTSCENE_RUFJUST },
+	{ "SAYONAR", STREAMED_SOUND_CUTSCENE_SAYONAR },
+	{ "SICILAN", STREAMED_SOUND_CUTSCENE_SICILAN },
+	{ "THEOFER", STREAMED_SOUND_CUTSCENE_THEOFER },
+	{ "INTRO", STREAMED_SOUND_CUTSCENE_INTRO },
+	{ "FINALE", STREAMED_SOUND_CUTSCENE_FINALE },
+	{ NULL, 0 }
+};
+
+int
+FindCutsceneAudioTrackId(const char *szCutsceneName)
+{
+	debug("looking for cutscene music track\n");
+	for (int i = 0; musicNameIdAssoc[i].szTrackName; i++) {
+		if (!CGeneral::faststricmp(musicNameIdAssoc[i].szTrackName, szCutsceneName)) {
+			debug("HUZZA! FOUND cutscene music track\n");
+			return musicNameIdAssoc[i].iTrackId;
+		}
+	}
+	debug("NOT FOUND cutscene music track\n");
+	return -1;
+}
+
+const char *
+GetNextLine(const char *buf, char *line, uint32 lineSize)
+{
+	while (*buf == '\n' || *buf == '\r')
+		buf++;
+
+	if (*buf == '\0')
+		return nil;
+
+	// size check never happened, eh?
+	while (*buf != '\n' && *buf != '\r') {
+		if (*buf == '\0')
+			break;
+		*(line++) = *(buf++);
+	}
+	*(line++) = '\0';
+	return buf;
+}
+
+RpAtomic*
+CalculateBoundingSphereRadiusCB(RpAtomic* atomic, void* data)
+{
+	float radius = RpAtomicGetBoundingSphere(atomic)->radius;
+	RwV3d center = RpAtomicGetBoundingSphere(atomic)->center;
+
+	for (RwFrame* frame = RpAtomicGetFrame(atomic); RwFrameGetParent(frame); frame = RwFrameGetParent(frame))
+		RwV3dTransformPoints(&center, &center, 1, RwFrameGetMatrix(frame));
+
+	float size = RwV3dLength(&center) + radius;
+	if (size > *(float*)data)
+		*(float*)data = size;
+	return atomic;
+}
+
+void UpdateCutsceneObjectBoundingBox(RpClump* clump, int modelId)
+{
+	if (modelId >= MI_CUTOBJ01 && modelId <= MI_CUTOBJ10) {
+		CColModel* pColModel = &CTempColModels::ms_colModelCutObj[modelId - MI_CUTOBJ01];
+		float oldRadius = pColModel->boundingSphere.radius;
+		float radius = 0.0f;
+		RpClumpForAllAtomics(clump, CalculateBoundingSphereRadiusCB, &radius);
+		if (oldRadius < 20.0f) oldRadius = 20.0f;
+		if (oldRadius < radius) {
+			debug("Limiting cutscene object radius %f\n", oldRadius);
+			radius = oldRadius;
+		}
+		radius = oldRadius;
+		pColModel->boundingSphere.radius = radius;
+		pColModel->boundingBox.min = CVector(-radius, -radius, -radius);
+		pColModel->boundingBox.max = CVector(radius, radius, radius);
+	}
+}
+
+bool bCamLoaded;
+bool bCamFading;
+
+// yes, they've actually doubled this thing here, thus this one is unused
+static bool bModelsRemovedForCutscene;
+static int32 NumberOfSavedWeapons;
+static eWeaponType SavedWeaponIDs[TOTAL_WEAPON_SLOTS];
+static int32 SavedWeaponAmmo[TOTAL_WEAPON_SLOTS];
+
+enum
+{
+	CUTMODEL_PLAYER = 1,
+	CUTMODEL_SIMPLE,
+	CUTMODEL_REPEATED,
+};
+
+bool CCutsceneMgr::ms_useCutsceneShadows = true;
+bool CCutsceneMgr::mCutsceneSkipFading;
+int CCutsceneMgr::mCutsceneSkipFadeTime;
+float CCutsceneMgr::m_fPrevCarDensity;
+float CCutsceneMgr::m_fPrevPedDensity;
+bool CCutsceneMgr::m_PrevExtraColourOn;
+uint32 CCutsceneMgr::m_PrevExtraColour;
+uint32 CCutsceneMgr::ms_iNumParticleEffects;
+sParticleEffect CCutsceneMgr::ms_pParticleEffects[NUM_CUTS_PARTICLE_EFFECTS];
+sToHideItem CCutsceneMgr::ms_crToHideItems[NUMCUTSCENEOBJECTS];
+uint32 CCutsceneMgr::ms_iNumHiddenEntities;
+CEntity *CCutsceneMgr::ms_pHiddenEntities[NUMCUTSCENEOBJECTS];
+int CCutsceneMgr::ms_numAttachObjectToBones;
+bool CCutsceneMgr::ms_bRepeatObject[NUMCUTSCENEOBJECTS];
+sAttachInfo CCutsceneMgr::ms_iAttachObjectToBone[NUMCUTSCENEOBJECTS];
+uint32 CCutsceneMgr::ms_numUncompressedCutsceneAnims;
+char CCutsceneMgr::ms_aUncompressedCutsceneAnims[NUM_CUTS_UNCOMPRESSED_ANIMS][NAMELENGTH];
+uint32 CCutsceneMgr::ms_iTextDuration[NUM_CUTS_MAX_TEXTS];
+uint32 CCutsceneMgr::ms_iTextStartTime[NUM_CUTS_MAX_TEXTS];
+char CCutsceneMgr::ms_cTextOutput[NUM_CUTS_MAX_TEXTS][TEXT_KEY_SIZE];
+uint32 CCutsceneMgr::ms_currTextOutput;
+uint32 CCutsceneMgr::ms_numTextOutput;
+uint32 CCutsceneMgr::ms_iModelIndex[NUMCUTSCENEOBJECTS];
+char CCutsceneMgr::ms_cLoadAnimName[NUMCUTSCENEOBJECTS][NAMELENGTH];
+char CCutsceneMgr::ms_cLoadObjectName[NUMCUTSCENEOBJECTS][NAMELENGTH];
+int CCutsceneMgr::ms_numLoadObjectNames;
+CCutsceneObject *CCutsceneMgr::ms_pCutsceneObjects[NUMCUTSCENEOBJECTS];
+int32 CCutsceneMgr::ms_numCutsceneObjs;
+CVector CCutsceneMgr::ms_cutsceneOffset;
+float CCutsceneMgr::ms_cutsceneTimer;
+uint32 CCutsceneMgr::ms_cutscenePlayStatus;
+CAnimBlendAssocGroup CCutsceneMgr::ms_cutsceneAssociations;
+char CCutsceneMgr::ms_cutsceneName[CUTSCENENAMESIZE];
+
+CCutsceneObject *
+CCutsceneMgr::CreateCutsceneObject(int modelId)
+{
+	CBaseModelInfo *pModelInfo;
+	CColModel *pColModel;
+	CCutsceneObject *pCutsceneObject;
+
+	CStreaming::ImGonnaUseStreamingMemory();
+	debug("Created cutscene object %s\n", CModelInfo::GetModelInfo(modelId)->GetModelName());
+	if (modelId >= MI_CUTOBJ01 && modelId <= MI_CUTOBJ10) {
+		pModelInfo = CModelInfo::GetModelInfo(modelId);
+		pColModel = &CTempColModels::ms_colModelCutObj[modelId - MI_CUTOBJ01];
+		pModelInfo->SetColModel(pColModel);
+		UpdateCutsceneObjectBoundingBox((RpClump*)pModelInfo->GetRwObject(), modelId);
+	}
+
+	pCutsceneObject = new CCutsceneObject();
+	pCutsceneObject->SetModelIndex(modelId);
+	if (ms_useCutsceneShadows)
+		pCutsceneObject->CreateShadow();
+	ms_pCutsceneObjects[ms_numCutsceneObjs++] = pCutsceneObject;
+	CStreaming::IHaveUsedStreamingMemory();
+	return pCutsceneObject;
+}
+
+void
+CCutsceneMgr::SetCutsceneAnim(const char *animName, CObject *pObject)
+{
+	CAnimBlendAssociation *pNewAnim;
+	CAnimBlendClumpData *pAnimBlendClumpData;
+
+	debug("Give cutscene anim %s\n", animName);
+	/*assert(RwObjectGetType(pObject->m_rwObject) == rpCLUMP);
+	debug("Give cutscene anim %s\n", animName);
+	RpAnimBlendClumpRemoveAllAssociations((RpClump*)pObject->m_rwObject);
+
+	pNewAnim = ms_cutsceneAssociations.GetAnimation(animName);
+	if (!pNewAnim) {
+		debug("\n\nHaven't I told you I can't find the fucking animation %s\n\n\n", animName);
+		return;
+	}
+
+	if (pNewAnim->hierarchy->IsCompressed())
+		pNewAnim->hierarchy->keepCompressed = true;*/
+
+	CStreaming::ImGonnaUseStreamingMemory();
+	pNewAnim = ms_cutsceneAssociations.CopyAnimation(animName);
+	CStreaming::IHaveUsedStreamingMemory();
+
+	pNewAnim->SetCurrentTime(0.0f);
+	pNewAnim->flags |= ASSOC_HAS_TRANSLATION;
+	pNewAnim->flags &= ~ASSOC_RUNNING;
+
+	pAnimBlendClumpData = *RPANIMBLENDCLUMPDATA(pObject->m_rwObject);
+	pAnimBlendClumpData->link.Prepend(&pNewAnim->link);
+
+	//if (pNewAnim->hierarchy->keepCompressed)
+	//	pAnimBlendClumpData->frames->flag |= AnimBlendFrameData::COMPRESSED;
+}
+
+void
+CCutsceneMgr::SetCutsceneAnimToLoop(const char* animName)
+{
+	ms_cutsceneAssociations.GetAnimation(animName)->flags |= ASSOC_REPEAT;
+}
+
+CCutsceneHead*
+CCutsceneMgr::SetHeadAnim(const char*, CObject* pObject)
+{
+	return nil;
+}
+
+void
+CCutsceneMgr::StartCutscene()
+{
+	ms_cutscenePlayStatus = CUTSCENE_STARTED;
+	if (bCamLoaded) {
+		TheCamera.SetWideScreenOn();
+		CHud::SetHelpMessage(nil, true);
+	}
+}
+
+void
+CCutsceneMgr::SetupCutsceneToStart(void)
+{
+	if (bCamLoaded) {
+		TheCamera.SetCamCutSceneOffSet(ms_cutsceneOffset);
+		TheCamera.TakeControlWithSpline(JUMP_CUT);
+		TheCamera.SetWideScreenOn();
+		CHud::SetHelpMessage(nil, true);
+	}
+
+	ms_cutsceneOffset.z += 1.0f;
+
+	for (int i = ms_numCutsceneObjs - 1; i >= 0; i--) {
+		assert(RwObjectGetType(ms_pCutsceneObjects[i]->m_rwObject) == rpCLUMP);
+		if (CAnimBlendAssociation *pAnimBlendAssoc = RpAnimBlendClumpGetFirstAssociation((RpClump*)ms_pCutsceneObjects[i]->m_rwObject)) {
+			assert(pAnimBlendAssoc->hierarchy->sequences[0].HasTranslation());
+			if (ms_pCutsceneObjects[i]->m_pAttachTo != nil) {
+				pAnimBlendAssoc->flags &= (~ASSOC_HAS_TRANSLATION);
+			} else {
+				if (pAnimBlendAssoc->hierarchy->IsCompressed()){
+					KeyFrameTransCompressed *keyFrames = ((KeyFrameTransCompressed*)pAnimBlendAssoc->hierarchy->sequences[0].GetKeyFrameCompressed(0));
+					CVector trans;
+					keyFrames->GetTranslation(&trans);
+					ms_pCutsceneObjects[i]->SetPosition(ms_cutsceneOffset + trans);
+				}else{
+					KeyFrameTrans *keyFrames = ((KeyFrameTrans*)pAnimBlendAssoc->hierarchy->sequences[0].GetKeyFrame(0));
+					ms_pCutsceneObjects[i]->SetPosition(ms_cutsceneOffset + keyFrames->translation);
+				}
+			}
+			pAnimBlendAssoc->SetRun();
+		} else {
+			ms_pCutsceneObjects[i]->SetPosition(ms_cutsceneOffset);
+		}
+		CWorld::Add(ms_pCutsceneObjects[i]);
+		if (RwObjectGetType(ms_pCutsceneObjects[i]->m_rwObject) == rpCLUMP) {
+			ms_pCutsceneObjects[i]->UpdateRpHAnim();
+		}
+	}
+
+	CTimer::Update();
+	CTimer::Update();
+	ms_cutsceneTimer = 0.0f;
+	ms_running = true;
+	mCutsceneSkipFadeTime = 0;
+	mCutsceneSkipFading = 0;
+}
+
+void
+CCutsceneMgr::FinishCutscene()
+{
+	if (bCamLoaded) {
+		ms_cutsceneTimer = TheCamera.GetCutSceneFinishTime() * 0.001f;
+		TheCamera.FinishCutscene();
+	}
+
+	FindPlayerPed()->bIsVisible = true;
+	CWorld::Players[CWorld::PlayerInFocus].MakePlayerSafe(false);
+}
+
+uint32
+CCutsceneMgr::GetCutsceneTimeInMilleseconds(void)
+{
+	return 1000.0f * ms_cutsceneTimer;
+}
+
+bool CCutsceneMgr::HasCutsceneFinished(void)
+{
+	return !bCamLoaded || TheCamera.GetPositionAlongSpline() == 1.0f;
+}
+
+void
+CCutsceneMgr::AttachObjectToBone(CObject *pObject, CObject *pAttachTo, int bone)
+{
+	RpHAnimHierarchy *hanim = GetAnimHierarchyFromSkinClump(pAttachTo->GetClump());
+	RwInt32 id = RpHAnimIDGetIndex(hanim, bone);
+	RwMatrix *matrixArray = RpHAnimHierarchyGetMatrixArray(hanim);
+	((CCutsceneObject*)pObject)->m_pAttachmentObject = pAttachTo;
+	((CCutsceneObject*)pObject)->m_pAttachTo = &matrixArray[id];
+	//debug("Attach %s to %s\n",
+	//	CModelInfo::GetModelInfo(pObject->GetModelIndex())->GetModelName(),
+	//	CModelInfo::GetModelInfo(pAttachTo->GetModelIndex())->GetModelName());
+}
+
+void
+CCutsceneMgr::AttachObjectToFrame(CObject *pObject, CEntity *pAttachTo, const char *frame)
+{
+	((CCutsceneObject*)pObject)->m_pAttachmentObject = nil;
+	((CCutsceneObject*)pObject)->m_pAttachTo = RpAnimBlendClumpFindFrame(pAttachTo->GetClump(), frame)->frame;
+	//debug("Attach %s to component %s of %s\n",
+	//	CModelInfo::GetModelInfo(pObject->GetModelIndex())->GetModelName(),
+	//	frame,
+	//	CModelInfo::GetModelInfo(pAttachTo->GetModelIndex())->GetModelName());
+	if (RwObjectGetType(pObject->m_rwObject) == rpCLUMP) {
+		RpClump *clump = (RpClump*)pObject->m_rwObject;
+		if (IsClumpSkinned(clump))
+			RpAtomicGetBoundingSphere(GetFirstAtomic(clump))->radius *= 1.1f;
+	}
+}
+
+void
+CCutsceneMgr::AttachObjectToParent(CObject *pObject, CEntity *pAttachTo)
+{
+	((CCutsceneObject*)pObject)->m_pAttachmentObject = nil;
+	((CCutsceneObject*)pObject)->m_pAttachTo = RpClumpGetFrame(pAttachTo->GetClump());
+
+	//debug("Attach %s to %s\n", CModelInfo::GetModelInfo(pObject->GetModelIndex())->GetModelName(), CModelInfo::GetModelInfo(pAttachTo->GetModelIndex())->GetModelName());
+}
+
+void
+CCutsceneMgr::HideRequestedObjects(void)
+{
+	int num = ms_iNumHiddenEntities;
+	ms_iNumHiddenEntities = 0;
+
+	for (int i = 0; i < num; i++) {
+		int id;
+		if (CModelInfo::GetModelInfo(ms_crToHideItems[i].name, &id)) {
+			CVector pos(ms_crToHideItems[i].x, ms_crToHideItems[i].y, ms_crToHideItems[i].z);
+			int16 foundEntities;
+			CEntity* pEntities[32];
+			CWorld::FindObjectsOfTypeInRange(id, pos, 1.5f, true, &foundEntities, 32, pEntities, true, false, false, true, true);
+			for (int j = 0; i < foundEntities; j++) {
+				if (pEntities[j]->bIsVisible) {
+					ms_pHiddenEntities[ms_iNumHiddenEntities] = pEntities[j];
+					ms_pHiddenEntities[ms_iNumHiddenEntities]->RegisterReference(&ms_pHiddenEntities[ms_iNumHiddenEntities]);
+					ms_pHiddenEntities[ms_iNumHiddenEntities]->bIsVisible = false;
+					ms_iNumHiddenEntities++;
+				}
+			}
+		}
+	}
+}
+
+bool
+CCutsceneMgr::PresubBodge()
+{
+	return true;
+}
+
+void
+CCutsceneMgr::LoadCutsceneData_loading()
+{
+	for (int i = 0; i < ms_numLoadObjectNames; i++) {
+		int mi = ms_iModelIndex[i];
+		if (mi >= MI_CUTOBJ01 && mi <= MI_CUTOBJ10) {
+			if (CStreaming::ms_aInfoForModel[mi].m_loadState != STREAMSTATE_LOADED)
+				return;
+		}
+	}
+
+	if (!LoadCutsceneData_postload())
+		return;
+
+	CCutsceneObject* cutsceneObject;
+	for (int i = 0; i < ms_numLoadObjectNames; i++) {
+		if (!ms_bRepeatObject[i])
+			cutsceneObject = CreateCutsceneObject(ms_iModelIndex[i]);
+		if (ms_cLoadAnimName[i][0] != '\0')
+			SetCutsceneAnim(ms_cLoadAnimName[i], cutsceneObject);
+	}
+
+	for (int i = 0; i < ms_numAttachObjectToBones; i++) {
+		int objectId = ms_iAttachObjectToBone[i].objectId;
+		int attachToId = ms_iAttachObjectToBone[i].attachToId;
+		int bone = ms_iAttachObjectToBone[i].boneId;
+		AttachObjectToBone(ms_pCutsceneObjects[objectId], ms_pCutsceneObjects[attachToId], bone);
+	}
+}
+
+bool
+CCutsceneMgr::LoadCutsceneData_postload(bool b)
+{
+	RwStream *stream = nil;
+	uint32 size;
+	uint32 offset;
+
+	bool result;
+
+	CMessages::ClearThisBigPrintNow(0);
+	CPopulation::PedDensityMultiplier = 0.0f;
+	CCarCtrl::CarDensityMultiplier = 0.0f;
+	CStreaming::ms_disableStreaming = false;
+	if (b)
+	{
+		sprintf(gString, "%s.IFP", ms_cutsceneName);
+		result = false;
+		ms_animLoaded = false;
+		RwStreamClose(stream, nil); // umm...
+		sprintf(gString, "%s.DAT", ms_cutsceneName);
+		bCamLoaded = false;
+	} else {
+
+		stream = RwStreamOpen(rwSTREAMFILENAME, rwSTREAMREAD, "ANIM\\CUTS.IMG");
+		sprintf(gString, "%s.IFP", ms_cutsceneName);
+		if (stream) {
+			if (ms_pCutsceneDir->FindItem(gString, offset, size))
+			{
+				CStreaming::MakeSpaceFor(size << 11);
+				CStreaming::ImGonnaUseStreamingMemory();
+				RwStreamSkip(stream, offset << 11);
+				CAnimManager::LoadAnimFile(stream, true, ms_aUncompressedCutsceneAnims);
+				ms_cutsceneAssociations.CreateAssociations(ms_cutsceneName, ms_cLoadAnimName[0], ms_cLoadObjectName[0], NAMELENGTH);
+				CStreaming::IHaveUsedStreamingMemory();
+				ms_animLoaded = true;
+			}
+			else
+			{
+				ms_animLoaded = false;
+			}
+			RwStreamClose(stream, nil);
+
+			int file = CFileMgr::OpenFile("ANIM\\CUTS.IMG", "rb");
+			sprintf(gString, "%s.DAT", ms_cutsceneName);
+			if (file) {
+				if (ms_pCutsceneDir->FindItem(gString, offset, size))
+				{
+					CStreaming::ImGonnaUseStreamingMemory();
+					CFileMgr::Seek(file, offset << 11, 0);
+					TheCamera.LoadPathSplines(file);
+					CStreaming::IHaveUsedStreamingMemory();
+					bCamLoaded = true;
+				}
+				else
+				{
+					bCamLoaded = false;
+				}
+				result = true;
+				CFileMgr::CloseFile(file);
+			}
+			else
+			{
+				bCamLoaded = false;
+				result = true;
+			}
+		}
+		else
+		{
+			result = false;
+			ms_animLoaded = false;
+			RwStreamClose(stream, nil);
+			sprintf(gString, "%s.DAT", ms_cutsceneName);
+			bCamLoaded = false;
+		}
+	}
+	ms_cutsceneLoadStatus = CUTSCENE_LOADED;
+	ms_cutsceneTimer = 0.0f;
+	FindPlayerPed()->m_pWanted->ClearQdCrimes();
+	return result;
+}
+
+void
+CCutsceneMgr::LoadCutsceneData_overlay(const char *szCutsceneName)
+{
+	CTimer::Suspend();
+	ms_cutsceneProcessing = true;
+	ms_wasCutsceneSkipped = false;
+	if (!bModelsRemovedForCutscene)
+		CStreaming::RemoveCurrentZonesModels();
+
+	ms_pCutsceneDir->numEntries = 0;
+	ms_pCutsceneDir->ReadDirFile("ANIM\\CUTS.DIR");
+
+	CStreaming::RemoveUnusedModelsInLoadedList();
+	CGame::DrasticTidyUpMemory(true);
+
+	strcpy(ms_cutsceneName, szCutsceneName);
+
+	LoadCutsceneData_preload();
+	CTimer::Resume();
+}
+
+void
+CCutsceneMgr::LoadCutsceneData_preload(void)
+{
+	uint32 size;
+	uint32 offset;
+	CPlayerPed* pPlayerPed;
+	if (CGeneral::faststricmp(ms_cutsceneName, "finale")) {
+		DMAudio.ChangeMusicMode(MUSICMODE_CUTSCENE);
+		int trackId = FindCutsceneAudioTrackId(ms_cutsceneName);
+		if (trackId != -1) {
+			printf("Start preload audio %s\n", ms_cutsceneName);
+			DMAudio.PreloadCutSceneMusic(trackId);
+			printf("End preload audio %s\n", ms_cutsceneName);
+		}
+	}
+
+	for (int i = MI_CUTOBJ01; i <= MI_CUTOBJ10; i++) {
+		if (CModelInfo::GetModelInfo(i)->GetNumRefs() <= 0) {
+			if (CStreaming::ms_aInfoForModel[i].m_loadState == STREAMSTATE_LOADED) {
+				CStreaming::RemoveModel(i);
+				CModelInfo::GetModelInfo(i)->SetModelName("&*%");
+			}
+		}
+	}
+
+	m_PrevExtraColour = CTimeCycle::m_ExtraColour;
+	m_PrevExtraColourOn = CTimeCycle::m_bExtraColourOn != 0;
+	m_fPrevPedDensity = CPopulation::PedDensityMultiplier;
+	m_fPrevCarDensity = CCarCtrl::CarDensityMultiplier;
+	ms_cutsceneOffset = CVector(0.0f, 0.0f, 0.0f);
+	ms_numTextOutput = 0;
+	ms_currTextOutput = 0;
+	ms_numLoadObjectNames = 0;
+	ms_numUncompressedCutsceneAnims = 0;
+	ms_numAttachObjectToBones = 0;
+	ms_iNumHiddenEntities = 0;
+	bCamFading = false;
+	ms_iNumParticleEffects = 0;
+
+	for (int i = 0; i < NUM_CUTS_UNCOMPRESSED_ANIMS; i++)
+		ms_aUncompressedCutsceneAnims[i][0] = '\0';
+
+	memset(ms_iModelIndex, 0, sizeof(ms_iModelIndex));
+	CRubbish::SetVisibility(false);
+
+	pPlayerPed = FindPlayerPed();
+	pPlayerPed->m_pWanted->ClearQdCrimes();
+	pPlayerPed->bIsVisible = false;
+	pPlayerPed->m_fCurrentStamina = pPlayerPed->m_fMaxStamina;
+	CPad::GetPad(0)->SetDisablePlayerControls(PLAYERCONTROL_CUTSCENE);
+	CWorld::Players[CWorld::PlayerInFocus].MakePlayerSafe(true);
+
+	sprintf(gString, "%s.CUT", ms_cutsceneName);
+	if (!ms_pCutsceneDir->FindItem(gString, offset, size)) {
+		LoadCutsceneData_postload();
+		return;
+	}
+
+	size <<= 11;
+	offset <<= 11;
+
+	char *cutsBuf = new char[size];
+
+	RwStream* stream = RwStreamOpen(rwSTREAMFILENAME, rwSTREAMREAD, "ANIM\\CUTS.IMG");
+
+	if (stream) {
+		RwStreamSkip(stream, offset);
+		RwStreamRead(stream, cutsBuf, size);
+		RwStreamClose(stream, nil);
+	}
+
+	enum
+	{
+		CUT_NONE = 0,
+		CUT_INFO,
+		CUT_MODEL,
+		CUT_TEXT,
+		CUT_UNCOMPRESS,
+		CUT_ATTACH,
+		CUT_REMOVE,
+		CUT_PARTICLE_EFFECT,
+		CUT_EXTRA_COLOR,
+	};
+
+	int cutSection = CUT_NONE;
+	bool bExtraColSet = false;
+
+	char line[1024];
+	const char *pCurLine = cutsBuf;
+
+	while (true)
+	{
+		pCurLine = GetNextLine(pCurLine, line, sizeof(line));
+		if (pCurLine) {
+			if (line[0] == '\0')
+				break;
+
+			if (strcmp(line, "end") == 0) {
+				cutSection = CUT_NONE;
+				continue;
+			}
+
+			switch (cutSection)
+			{
+			case CUT_NONE:
+				if (strcmp(line, "info") == 0)
+					cutSection = CUT_INFO;
+				if (strcmp(line, "model") == 0)
+					cutSection = CUT_MODEL;
+				if (strcmp(line, "text") == 0)
+					cutSection = CUT_TEXT;
+				if (strcmp(line, "uncompress") == 0)
+					cutSection = CUT_UNCOMPRESS;
+				if (strcmp(line, "attach") == 0)
+					cutSection = CUT_ATTACH;
+				if (strcmp(line, "remove") == 0)
+					cutSection = CUT_REMOVE;
+				if (strcmp(line, "peffect") == 0)
+					cutSection = CUT_PARTICLE_EFFECT;
+				if (strcmp(line, "extracol") == 0)
+					cutSection = CUT_EXTRA_COLOR;
+				break;
+			case CUT_INFO:
+			{
+				if (strncmp(line, "offset", 6) == 0) {
+					float x, y, z;
+					sscanf(line+7, "%f %f %f", &x, &y, &z);
+					FindPlayerPed(); // called for some sa check in here
+					ms_cutsceneOffset = CVector(x, y, z);
+				}
+				break;
+			}
+			case CUT_MODEL:
+			{
+				char objectName[NAMELENGTH];
+				char animName[NAMELENGTH];
+
+				int num; // unused
+				sscanf(strtok(line, " ,"), "%d", &num);
+				strcpy(objectName, strtok(nil, " ,"));
+				char* pAnimName = strtok(0, " ,"); 
+				strlwr(objectName);
+
+				bool bUsedFirstTime = true;
+				if (pAnimName) {
+					do {
+						strcpy(animName, pAnimName);
+						strlwr(animName);
+						strcpy(ms_cLoadObjectName[ms_numLoadObjectNames], objectName);
+						strcpy(ms_cLoadAnimName[ms_numLoadObjectNames], animName);
+						if (bUsedFirstTime) {
+							bUsedFirstTime = false;
+							ms_iModelIndex[ms_numLoadObjectNames] = CUTMODEL_SIMPLE;
+							ms_bRepeatObject[ms_numLoadObjectNames] = false;
+						} else {
+							ms_bRepeatObject[ms_numLoadObjectNames] = true;
+							ms_iModelIndex[ms_numLoadObjectNames] = CUTMODEL_REPEATED;
+						}
+						ms_numLoadObjectNames++;
+						pAnimName = strtok(0, " ,");
+					} while (pAnimName);
+				}
+				break;
+			}
+			case CUT_TEXT:
+			{
+				int iTextStartTime, iTextDuration;
+				char cTextOutput[8];
+				sscanf(line, "%d,%d,%s", &iTextStartTime, &iTextDuration, cTextOutput);
+				for (size_t i = 0; i < strlen(cTextOutput); i++)
+					cTextOutput[i] = toupper(cTextOutput[i]);
+
+				memcpy(ms_cTextOutput[ms_numTextOutput], cTextOutput, strlen(cTextOutput)+1);
+				ms_iTextStartTime[ms_numTextOutput] = iTextStartTime;
+				ms_iTextDuration[ms_numTextOutput] = iTextDuration;
+				ms_numTextOutput++;
+				break;
+			}
+			case CUT_UNCOMPRESS:
+				LoadAnimationUncompressed(strtok(line, " ,"));
+				break;
+			case CUT_ATTACH:
+			{
+				int attachToId, objectId, bone;
+				sscanf(line, "%d,%d,%d", &attachToId, &objectId, &bone);
+				ms_iAttachObjectToBone[ms_numAttachObjectToBones].attachToId = attachToId;
+				ms_iAttachObjectToBone[ms_numAttachObjectToBones].objectId = objectId;
+				ms_iAttachObjectToBone[ms_numAttachObjectToBones].boneId = bone;
+				ms_numAttachObjectToBones++;
+				break;
+			}
+			case CUT_REMOVE:
+			{
+				float x, y, z;
+				char name[NAMELENGTH];
+				sscanf(line, "%f,%f,%f,%s", &x, &y, &z, name);
+				ms_crToHideItems[ms_iNumHiddenEntities].x = x;
+				ms_crToHideItems[ms_iNumHiddenEntities].y = y;
+				ms_crToHideItems[ms_iNumHiddenEntities].z = z;
+				strcpy(ms_crToHideItems[ms_iNumHiddenEntities].name, name);
+				ms_iNumHiddenEntities++;
+				break;
+			}
+			case CUT_PARTICLE_EFFECT:
+			{
+				char name[NAMELENGTH];
+				char name2[NAMELENGTH];
+
+				int iTime;
+				int unk1;
+				int unk2;
+				float x;
+				float y;
+				float z;
+				float unkX;
+				float unkY;
+				float unkZ;
+
+				memset(name, 0, NAMELENGTH);
+				memset(name2, 0, NAMELENGTH);
+
+				strncpy(name, strtok(line, ","), NAMELENGTH-1);
+				iTime = atoi(strtok(0, ","));
+				unk1 = atoi(strtok(0, ","));
+				unk2 = atoi(strtok(0, ","));
+				strncpy(name, strtok(line, ","), NAMELENGTH-1);
+				x = strtod(strtok(0, ","), nil);
+				y = strtod(strtok(0, ","), nil);
+				z = strtod(strtok(0, ","), nil);
+				unkX = strtod(strtok(0, ","), nil);
+				unkY = strtod(strtok(0, ","), nil);
+				unkZ = strtod(strtok(0, ","), nil);
+
+				ms_pParticleEffects[ms_iNumParticleEffects].bPlayed = false;
+				ms_pParticleEffects[ms_iNumParticleEffects].iTime = iTime;
+				ms_pParticleEffects[ms_iNumParticleEffects].unk1 = unk1;
+				ms_pParticleEffects[ms_iNumParticleEffects].unk2 = unk2;
+				strcpy(CCutsceneMgr::ms_pParticleEffects[ms_iNumParticleEffects].name2, name2);
+				ms_pParticleEffects[ms_iNumParticleEffects].unk10 = false;
+				ms_pParticleEffects[ms_iNumParticleEffects].x = x;
+				ms_pParticleEffects[ms_iNumParticleEffects].y = y;
+				ms_pParticleEffects[ms_iNumParticleEffects].z = z;
+				ms_pParticleEffects[ms_iNumParticleEffects].unkX = unkX;
+				ms_pParticleEffects[ms_iNumParticleEffects].unkY = unkY;
+				ms_pParticleEffects[ms_iNumParticleEffects].unkZ = unkZ;
+				ms_pParticleEffects[ms_iNumParticleEffects].unk11 = false;
+				strcpy(CCutsceneMgr::ms_pParticleEffects[ms_iNumParticleEffects].name, name);
+				ms_iNumParticleEffects++;
+				break;
+			}
+			case CUT_EXTRA_COLOR:
+				if (!bExtraColSet) {
+					int colorId;
+					sscanf(line, "%d", &colorId);
+					if (colorId == 0)
+						bExtraColSet = false;
+					else {
+						CTimeCycle::StartExtraColour(colorId - 1, false);
+						bExtraColSet = true;
+					}
+				}
+				break;
+			default:
+				break;
+			};
+
+		}
+		else
+		{
+			delete[]cutsBuf;
+
+			// add manually inserted objects
+			for (int i = 0; i < ms_numAppendObjectNames; i++) {
+				strcpy(ms_cLoadObjectName[ms_numLoadObjectNames], ms_cAppendObjectName[i]);
+				strcpy(ms_cLoadAnimName[ms_numLoadObjectNames], ms_cAppendAnimName[i]);
+				ms_iModelIndex[ms_numLoadObjectNames] = CUTMODEL_SIMPLE;
+				ms_numLoadObjectNames++;
+			}
+			ms_numAppendObjectNames = 0;
+
+			int specialId = 0;
+			for (int i = 0; i < ms_numLoadObjectNames; i++)
+			{
+				if (strcasecmp(ms_cLoadObjectName[i], "csplay") == 0) {
+					ms_iModelIndex[i] = CUTMODEL_PLAYER;
+					continue;
+				} else if (ms_iModelIndex[i] == CUTMODEL_SIMPLE) {
+					int id;
+					if (CModelInfo::GetModelInfo(ms_cLoadObjectName[i], &id)) {
+						ms_iModelIndex[i] = id;
+						CStreaming::RequestModel(id, STREAMFLAGS_SCRIPTOWNED | STREAMFLAGS_DEPENDENCY | STREAMFLAGS_PRIORITY);
+					} else {
+						CStreaming::RequestSpecialModel(specialId + MI_CUTOBJ01, ms_cLoadObjectName[i], STREAMFLAGS_SCRIPTOWNED | STREAMFLAGS_DEPENDENCY | STREAMFLAGS_PRIORITY);
+						ms_iModelIndex[i] = specialId + MI_CUTOBJ01;
+						specialId++;
+						// skip if id is busy
+						while (CStreaming::ms_aInfoForModel[specialId + MI_CUTOBJ01].m_loadState == STREAMSTATE_LOADED)
+							specialId++;
+					}
+				}
+				else if (ms_iModelIndex[i] == CUTMODEL_REPEATED && i != 0)
+					ms_iModelIndex[i] = ms_iModelIndex[i - 1];
+			}
+
+			CStreaming::LoadAllRequestedModels(true);
+			ms_cutsceneLoadStatus = CUTSCENE_LOADING;
+			return;
+		}
+	}
+
+	delete[]cutsBuf;
+	LoadCutsceneData_postload(true);
+}
+
+void
+CCutsceneMgr::DeleteCutsceneData_overlay(void)
+{
+	if (ms_cutsceneLoadStatus == CUTSCENE_NOT_LOADED) return;
+	CTimer::Suspend();
+	CPopulation::PedDensityMultiplier = m_fPrevPedDensity;
+	CCarCtrl::CarDensityMultiplier = m_fPrevCarDensity;
+	if (m_PrevExtraColourOn)
+		CTimeCycle::StartExtraColour(m_PrevExtraColour, false);
+	else
+		CTimeCycle::StopExtraColour(m_PrevExtraColourOn);
+
+	for (uint32 i = 0; i < ms_iNumHiddenEntities; i++) {
+		if (ms_pHiddenEntities[i]) {
+			ms_pHiddenEntities[i]->CleanUpOldReference(&ms_pHiddenEntities[i]);
+			ms_pHiddenEntities[i]->bIsVisible = true;
+		}
+	}
+
+	ms_iNumHiddenEntities = 0;
+	ms_iNumParticleEffects = 0;
+	CMessages::ClearMessages();
+	CRubbish::SetVisibility(true);
+
+	ms_cutsceneProcessing = false;
+	ms_useLodMultiplier = false;
+	ms_useCutsceneShadows = false;
+
+	ms_numCutsceneObjs--;
+	while (ms_numCutsceneObjs >= 0) {
+		CWorld::Remove(ms_pCutsceneObjects[ms_numCutsceneObjs]);
+		ms_pCutsceneObjects[ms_numCutsceneObjs]->DeleteRwObject();
+		delete ms_pCutsceneObjects[ms_numCutsceneObjs];
+		ms_pCutsceneObjects[ms_numCutsceneObjs] = nil;
+		ms_numCutsceneObjs--;
+	}
+	ms_numCutsceneObjs = 0;
+
+	if (ms_animLoaded)
+		CAnimManager::RemoveLastAnimFile();
+
+	ms_animLoaded = false;
+	ms_cutsceneAssociations.DestroyAssociations();
+
+	ms_aUncompressedCutsceneAnims[0][0] = '\0';
+	ms_numUncompressedCutsceneAnims = 0;
+
+	if (bCamLoaded) {
+		TheCamera.RestoreWithJumpCut();
+		TheCamera.SetWideScreenOff();
+		TheCamera.DeleteCutSceneCamDataMemory();
+	}
+	ms_cutsceneLoadStatus = CUTSCENE_NOT_LOADED;
+	ms_running = false;
+
+	FindPlayerPed()->bIsVisible = true;
+	CPad::GetPad(0)->SetEnablePlayerControls(PLAYERCONTROL_CUTSCENE);
+	CWorld::Players[CWorld::PlayerInFocus].MakePlayerSafe(false);
+
+	if (CGeneral::faststricmp(ms_cutsceneName, "finale")) {
+		DMAudio.StopCutSceneMusic();
+		DMAudio.ChangeMusicMode(MUSICMODE_GAME);
+	}
+
+	CStreaming::ms_disableStreaming = false;
+	CWorld::bProcessCutsceneOnly = false;
+
+	//if(bCamLoaded)
+	//	CGame::DrasticTidyUpMemory(TheCamera.GetScreenFadeStatus() == FADE_2);
+	
+	CPad::GetPad(0)->Clear(false);
+
+	if (bModelsRemovedForCutscene) {
+		CStreaming::LoadInitialPeds();
+		CStreaming::LoadInitialWeapons();
+		CStreaming::LoadInitialVehicles();
+		bModelsRemovedForCutscene = false;
+
+		CPlayerPed *pPlayerPed = FindPlayerPed();
+		for (int i = 0; i < NumberOfSavedWeapons; i++) {
+			int32 weaponModelId = CWeaponInfo::GetWeaponInfo(SavedWeaponIDs[i])->m_nModelId;
+			uint8 flags = CStreaming::ms_aInfoForModel[weaponModelId].m_flags;
+			CStreaming::RequestModel(weaponModelId, STREAMFLAGS_DONT_REMOVE);
+			CStreaming::LoadAllRequestedModels(false);
+			if (CWeaponInfo::GetWeaponInfo(SavedWeaponIDs[i])->m_nModel2Id != -1) {
+				CStreaming::RequestModel(CWeaponInfo::GetWeaponInfo(SavedWeaponIDs[i])->m_nModel2Id, 0);
+				CStreaming::LoadAllRequestedModels(false);
+			}
+			if (!(flags & STREAMFLAGS_DONT_REMOVE))
+				CStreaming::SetModelIsDeletable(weaponModelId);
+			pPlayerPed->GiveWeapon(SavedWeaponIDs[i], SavedWeaponAmmo[i], true);
+		}
+		NumberOfSavedWeapons = 0;
+	}
+
+	for (int i = 0; i < ms_numLoadObjectNames; i++)
+		CStreaming::SetMissionDoesntRequireModel(ms_iModelIndex[i]);
+
+	CStreaming::SetMissionDoesntRequireModel(MI_COP);
+	CStreaming::StreamZoneModels(FindPlayerCoors());
+	CTimer::Resume();
+}
+
+void
+CCutsceneMgr::Update_overlay(void)
+{
+	if (ms_cutsceneLoadStatus == CUTSCENE_LOADING) {
+		debug("Loading Cutscene...\n");
+		CTimer::Suspend();
+		LoadCutsceneData_loading();
+		CTimer::Resume();
+		return;
+	}
+
+	if (ms_cutsceneLoadStatus != CUTSCENE_LOADED) {
+		debug("Cutscene Not Loaded!\n");
+		return;
+	}
+
+	switch (ms_cutscenePlayStatus) {
+	case CUTSCENE_STARTED:
+		SetupCutsceneToStart();
+		HideRequestedObjects();
+		ms_cutscenePlayStatus++;
+		break;
+	case CUTSCENE_PLAYING_2:
+	case CUTSCENE_PLAYING_3:
+		ms_cutscenePlayStatus++;
+		break;
+	case CUTSCENE_PLAYING_4:
+		ms_cutscenePlayStatus = CUTSCENE_PLAYING_0;
+		if (CGeneral::faststricmp(ms_cutsceneName, "finale"))
+			DMAudio.PlayPreloadedCutSceneMusic();
+		break;
+	default:
+		break;
+	}
+
+	if (!ms_running) return;
+
+	ms_cutsceneTimer += CTimer::GetTimeStepNonClippedInSeconds();
+	uint32 cutsceneTimeInMS = GetCutsceneTimeInMilleseconds();
+
+	if (ms_currTextOutput < ms_numTextOutput && cutsceneTimeInMS > ms_iTextStartTime[ms_currTextOutput]) {
+		CMessages::AddMessageJumpQ(TheText.Get(ms_cTextOutput[ms_currTextOutput]), ms_iTextDuration[ms_currTextOutput], 1);
+		ms_currTextOutput++;
+	}
+
+	for (int i = 0; i < ms_numCutsceneObjs; i++) {
+		int modelId = ms_pCutsceneObjects[i]->GetModelIndex();
+		if (modelId >= MI_CUTOBJ01 && modelId <= MI_CUTOBJ10)
+			UpdateCutsceneObjectBoundingBox(ms_pCutsceneObjects[i]->GetClump(), modelId);
+	}
+
+	if (!bCamLoaded) return;
+
+	if (CGeneral::faststricmp(ms_cutsceneName, "finale") && TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FLYBY && ms_cutsceneLoadStatus == CUTSCENE_LOADED) {
+		if (TheCamera.GetCutSceneFinishTime() < cutsceneTimeInMS + 1000) {
+			if (!bCamFading) {
+				bCamFading = true;
+				TheCamera.Fade(1.0f, FADE_OUT);
+			}
+		}
+		if (mCutsceneSkipFading) {
+			mCutsceneSkipFadeTime -= CTimer::GetTimeStepInMilliseconds();
+			if (mCutsceneSkipFadeTime < 0) {
+				CHud::m_BigMessage[1][0] = '\0';
+				ms_wasCutsceneSkipped = true;
+				FinishCutscene();
+				mCutsceneSkipFading = false;
+				mCutsceneSkipFadeTime = 0;
+			}
+		}
+		else if (IsCutsceneSkipButtonBeingPressed() && PresubBodge()){
+			mCutsceneSkipFading = true;
+			mCutsceneSkipFadeTime = 1000;
+			TheCamera.Fade(1.0f, FADE_OUT);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/audio/AudioLogic.cpp b/src/audio/AudioLogic.cpp
index c692a51b..cd341eac 100644
--- a/src/audio/AudioLogic.cpp
+++ b/src/audio/AudioLogic.cpp
@@ -9407,7 +9407,7 @@ struct MissionAudioData {
 
 
 const MissionAudioData MissionAudioNameSfxAssoc[] = {
-	{"mobring", STREAMED_SOUND_MISSION_MOBR1},    {"pagring", STREAMED_SOUND_MISSION_PAGER},    {"carrev", STREAMED_SOUND_MISSION_CARREV},
+	/*{"mobring", STREAMED_SOUND_MISSION_MOBR1},    {"pagring", STREAMED_SOUND_MISSION_PAGER},    {"carrev", STREAMED_SOUND_MISSION_CARREV},
 	{"bikerev", STREAMED_SOUND_MISSION_BIKEREV},  {"liftop", STREAMED_SOUND_MISSION_LIFTOP},    {"liftcl", STREAMED_SOUND_MISSION_LIFTCL},
 	{"liftrun", STREAMED_SOUND_MISSION_LIFTRUN},  {"liftbel", STREAMED_SOUND_MISSION_LIFTBEL},  {"inlift", STREAMED_SOUND_MISSION_INLIFT},
 	{"caml", STREAMED_SOUND_MISSION_CAMERAL},     {"camr", STREAMED_SOUND_MISSION_CAMERAR},     {"cheer1", STREAMED_SOUND_MISSION_CHEER1},
@@ -9780,7 +9780,7 @@ const MissionAudioData MissionAudioNameSfxAssoc[] = {
 	{"bust_18", STREAMED_SOUND_MISSION_BUST_18},  {"bust_19", STREAMED_SOUND_MISSION_BUST_19},  {"bust_20", STREAMED_SOUND_MISSION_BUST_20},
 	{"bust_21", STREAMED_SOUND_MISSION_BUST_21},  {"bust_22", STREAMED_SOUND_MISSION_BUST_22},  {"bust_23", STREAMED_SOUND_MISSION_BUST_23},
 	{"bust_24", STREAMED_SOUND_MISSION_BUST_24},  {"bust_25", STREAMED_SOUND_MISSION_BUST_25},  {"bust_26", STREAMED_SOUND_MISSION_BUST_26},
-	{"bust_27", STREAMED_SOUND_MISSION_BUST_27},  {"bust_28", STREAMED_SOUND_MISSION_BUST_28},  {nil, 0} };
+	{"bust_27", STREAMED_SOUND_MISSION_BUST_27},  {"bust_28", STREAMED_SOUND_MISSION_BUST_28}, */ {nil, 0} };
 
 int32
 FindMissionAudioSfx(const char *name)
@@ -9847,8 +9847,8 @@ cAudioManager::PlayLoadedMissionAudio(uint8 slot)
 bool
 cAudioManager::ShouldDuckMissionAudio(uint8 slot) const
 {
-	if (IsMissionAudioSamplePlaying(slot))
-		return m_sMissionAudio.m_nSampleIndex[slot] != STREAMED_SOUND_MISSION_ROK2_01;
+	//if (IsMissionAudioSamplePlaying(slot))
+	//	return m_sMissionAudio.m_nSampleIndex[slot] != STREAMED_SOUND_MISSION_ROK2_01;
 	return false;
 }
 
@@ -9947,11 +9947,11 @@ cAudioManager::ProcessMissionAudioSlot(uint8 slot)
 				if (m_nUserPause)
 					SampleManager.PauseStream(1, slot + 1);
 				if (m_sMissionAudio.m_bPredefinedProperties[slot]) {
-					if (m_sMissionAudio.m_nSampleIndex[slot] == STREAMED_SOUND_MISSION_CAMERAL)
-						SampleManager.SetStreamedVolumeAndPan(80, 0, 1, slot + 1);
-					else if (m_sMissionAudio.m_nSampleIndex[slot] == STREAMED_SOUND_MISSION_CAMERAR)
-						SampleManager.SetStreamedVolumeAndPan(80, 127, 1, slot + 1);
-					else
+					//if (m_sMissionAudio.m_nSampleIndex[slot] == STREAMED_SOUND_MISSION_CAMERAL)
+					//	SampleManager.SetStreamedVolumeAndPan(80, 0, 1, slot + 1);
+					//else if (m_sMissionAudio.m_nSampleIndex[slot] == STREAMED_SOUND_MISSION_CAMERAR)
+					//	SampleManager.SetStreamedVolumeAndPan(80, 127, 1, slot + 1);
+					//else
 						SampleManager.SetStreamedVolumeAndPan(80, 63, 1, slot + 1);
 				} else {
 					distSquared = GetDistanceSquared(m_sMissionAudio.m_vecPos[slot]);
@@ -9973,8 +9973,8 @@ cAudioManager::ProcessMissionAudioSlot(uint8 slot)
 			}
 			m_sMissionAudio.m_nPlayStatus[slot] = PLAY_STATUS_PLAYING;
 			nCheckPlayingDelay[slot] = 30;
-			if (m_sMissionAudio.m_nSampleIndex[slot] >= STREAMED_SOUND_MISSION_MOB_01A && m_sMissionAudio.m_nSampleIndex[slot] <= STREAMED_SOUND_MISSION_MOB_99A)
-				m_sMissionAudio.m_bIsMobile[slot] = true;
+			//if (m_sMissionAudio.m_nSampleIndex[slot] >= STREAMED_SOUND_MISSION_MOB_01A && m_sMissionAudio.m_nSampleIndex[slot] <= STREAMED_SOUND_MISSION_MOB_99A)
+			//	m_sMissionAudio.m_bIsMobile[slot] = true;
 			break;
 		case PLAY_STATUS_PLAYING:
 			if (m_bTimerJustReset) {
@@ -10017,12 +10017,12 @@ cAudioManager::ProcessMissionAudioSlot(uint8 slot)
 							SampleManager.SetStreamedVolumeAndPan(emittingVol, pan, 1, slot + 1);
 						}
 					}
-				} else if (m_sMissionAudio.m_nSampleIndex[slot] == STREAMED_SOUND_MISSION_ROK2_01) {
-					m_sMissionAudio.m_nPlayStatus[slot] = PLAY_STATUS_STOPPED;
+				//} else if (m_sMissionAudio.m_nSampleIndex[slot] == STREAMED_SOUND_MISSION_ROK2_01) {
+				//	m_sMissionAudio.m_nPlayStatus[slot] = PLAY_STATUS_STOPPED;
 				} else {
 					m_sMissionAudio.m_nPlayStatus[slot] = PLAY_STATUS_FINISHED;
-					if (m_sMissionAudio.m_nSampleIndex[slot] >= STREAMED_SOUND_MISSION_MOB_01A && m_sMissionAudio.m_nSampleIndex[slot] <= STREAMED_SOUND_MISSION_MOB_99A)
-						m_sMissionAudio.m_bIsMobile[slot] = false;
+					//if (m_sMissionAudio.m_nSampleIndex[slot] >= STREAMED_SOUND_MISSION_MOB_01A && m_sMissionAudio.m_nSampleIndex[slot] <= STREAMED_SOUND_MISSION_MOB_99A)
+					//	m_sMissionAudio.m_bIsMobile[slot] = false;
 					m_sMissionAudio.m_nSampleIndex[slot] = NO_SAMPLE;
 					SampleManager.StopStreamedFile(slot + 1);
 					m_sMissionAudio.m_nMissionAudioCounter[slot] = 0;
diff --git a/src/audio/MusicManager.cpp b/src/audio/MusicManager.cpp
index 098b2fc3..2a16dc14 100644
--- a/src/audio/MusicManager.cpp
+++ b/src/audio/MusicManager.cpp
@@ -160,8 +160,8 @@ cMusicManager::SetStartingTrackPositions(uint8 isNewGameTimer)
 
 			if (i < STREAMED_SOUND_CITY_AMBIENT && isNewGameTimer)
 				m_aTracks[i].m_nPosition = NewGameRadioTimers[i];
-			else if (i < STREAMED_SOUND_ANNOUNCE_BRIDGE_CLOSED)
-				m_aTracks[i].m_nPosition = (pos * AudioManager.GetRandomNumber(i % 5)) % m_aTracks[i].m_nLength;
+			//else if (i < STREAMED_SOUND_ANNOUNCE_BRIDGE_CLOSED)
+			//	m_aTracks[i].m_nPosition = (pos * AudioManager.GetRandomNumber(i % 5)) % m_aTracks[i].m_nLength;
 			else
 				m_aTracks[i].m_nPosition = 0;
 			
@@ -658,7 +658,7 @@ cMusicManager::ServiceGameMode()
 		}
 		if (vehicle == nil)
 		{
-			m_nFrontendTrack = STREAMED_SOUND_RADIO_WAVE; // huh?
+			m_nFrontendTrack = STREAMED_SOUND_RADIO_LCFR; // huh?
 			return;
 		}
 		if (m_bRadioSetByScript)
@@ -712,7 +712,7 @@ cMusicManager::SetUpCorrectAmbienceTrack()
 		else if (TheCamera.DistanceToWater <= 90.0f) {
 			if (CCullZones::bAtBeachForAudio) {
 				if (CWeather::OldWeatherType != WEATHER_HURRICANE && CWeather::NewWeatherType != WEATHER_HURRICANE || CWeather::Wind <= 1.0f)
-					m_nFrontendTrack = STREAMED_SOUND_BEACH_AMBIENT;
+					m_nFrontendTrack = STREAMED_SOUND_SAWMILL;
 				else
 					m_nFrontendTrack = STREAMED_SOUND_HAVANA_BEACH_AMBIENT;
 			}
diff --git a/src/audio/audio_enums.h b/src/audio/audio_enums.h
index 91fcec49..b2fb627c 100644
--- a/src/audio/audio_enums.h
+++ b/src/audio/audio_enums.h
@@ -12,8 +12,8 @@ enum eRadioStation
 	EMOTION,
 	WAVE,
 	USERTRACK,
-	NUM_RADIOS = 10,
-	POLICE_RADIO = 10,
+	NUM_RADIOS = 11,
+	POLICE_RADIO = 11,
 	//TAXI_RADIO,
 	RADIO_OFF,
 };
@@ -38,1230 +38,72 @@ enum ePlayerMood
 
 enum eStreamedSounds
 {
-	STREAMED_SOUND_RADIO_WILD,
+	STREAMED_SOUND_RADIO_HEAD,
+	STREAMED_SOUND_RADIO_DOUBLE,
+	STREAMED_SOUND_RADIO_KJAH,
+	STREAMED_SOUND_RADIO_RISE,
+	STREAMED_SOUND_RADIO_LIPS,
+	STREAMED_SOUND_RADIO_MUNDO,
+	STREAMED_SOUND_RADIO_MSX,
 	STREAMED_SOUND_RADIO_FLASH,
-	STREAMED_SOUND_RADIO_KCHAT,
-	STREAMED_SOUND_RADIO_FEVER,
-	STREAMED_SOUND_RADIO_VROCK,
-	STREAMED_SOUND_RADIO_VCPR,
-	STREAMED_SOUND_RADIO_ESPANTOSO,
-	STREAMED_SOUND_RADIO_EMOTION,
-	STREAMED_SOUND_RADIO_WAVE,
+	STREAMED_SOUND_RADIO_LCJ,
+	STREAMED_SOUND_RADIO_LCFR,
 	STREAMED_SOUND_RADIO_MP3_PLAYER,
 	STREAMED_SOUND_CITY_AMBIENT,
 	STREAMED_SOUND_WATER_AMBIENT,
-	STREAMED_SOUND_BEACH_AMBIENT,
-	STREAMED_SOUND_HAVANA_CITY_AMBIENT,
-	STREAMED_SOUND_HAVANA_WATER_AMBIENT,
-	STREAMED_SOUND_HAVANA_BEACH_AMBIENT,
-	STREAMED_SOUND_MALL_AMBIENT,
-	STREAMED_SOUND_STRIPCLUB_AMBIENT,
-	STREAMED_SOUND_MALIBU_AMBIENT,
-	STREAMED_SOUND_HOTEL_AMBIENT,
-	STREAMED_SOUND_DIRTRING_AMBIENT,
-	STREAMED_SOUND_LAW4RIOT_AMBIENT,
-	STREAMED_SOUND_AMBSIL_AMBIENT,
+	STREAMED_SOUND_SAWMILL,
+	STREAMED_SOUND_HAVANA_CITY_AMBIENT, // CITY
+	STREAMED_SOUND_HAVANA_WATER_AMBIENT, // WATER
+	STREAMED_SOUND_HAVANA_BEACH_AMBIENT, // WATER
+	STREAMED_SOUND_MALL_AMBIENT, // CITY
+	STREAMED_SOUND_STRIPCLUB_AMBIENT, // CITY
+	STREAMED_SOUND_MALIBU_AMBIENT, // CITY
+	STREAMED_SOUND_HOTEL_AMBIENT, // CITY
+	STREAMED_SOUND_DIRTRING_AMBIENT, // CITY
+	STREAMED_SOUND_LAW4RIOT_AMBIENT, // CITY
+	STREAMED_SOUND_AMBSIL_AMBIENT, // CITY
 	STREAMED_SOUND_RADIO_POLICE,
 	STREAMED_SOUND_RADIO_TAXI,
-	STREAMED_SOUND_ANNOUNCE_BRIDGE_CLOSED,
-	STREAMED_SOUND_ANNOUNCE_BRIDGE_OPEN,
-	STREAMED_SOUND_CUTSCENE_ASS_1,
-	STREAMED_SOUND_CUTSCENE_ASS_2,
-	STREAMED_SOUND_CUTSCENE_BANK_1,
-	STREAMED_SOUND_CUTSCENE_BANK_2A,
-	STREAMED_SOUND_CUTSCENE_BANK_2B,
-	STREAMED_SOUND_CUTSCENE_BANK_3A,
-	STREAMED_SOUND_CUTSCENE_BANK_3B,
-	STREAMED_SOUND_CUTSCENE_BANK_4,
-	STREAMED_SOUND_CUTSCENE_BIKE_1,
-	STREAMED_SOUND_CUTSCENE_BIKE_2,
-	STREAMED_SOUND_CUTSCENE_BIKE_3,
-	STREAMED_SOUND_CUTSCENE_BUD_1,
-	STREAMED_SOUND_CUTSCENE_BUD_2,
-	STREAMED_SOUND_CUTSCENE_BUD_3,
-	STREAMED_SOUND_CUTSCENE_CAP_1,
-	STREAMED_SOUND_CUTSCENE_CAR_1,
-	STREAMED_SOUND_CUTSCENE_CNT_1A,
-	STREAMED_SOUND_CUTSCENE_CNT_1B,
-	STREAMED_SOUND_CUTSCENE_CNT_2,
-	STREAMED_SOUND_CUTSCENE_COK_1,
-	STREAMED_SOUND_CUTSCENE_COK_2A,
-	STREAMED_SOUND_CUTSCENE_COK_2B,
-	STREAMED_SOUND_CUTSCENE_COK_3,
-	STREAMED_SOUND_CUTSCENE_COK_4A,
-	STREAMED_SOUND_CUTSCENE_COK_4A2,
-	STREAMED_SOUND_CUTSCENE_COK_4B,
-	STREAMED_SOUND_CUTSCENE_COL_1,
-	STREAMED_SOUND_CUTSCENE_COL_2,
-	STREAMED_SOUND_CUTSCENE_COL_3A,
-	STREAMED_SOUND_CUTSCENE_COL_4A,
-	STREAMED_SOUND_CUTSCENE_COL_5A,
-	STREAMED_SOUND_CUTSCENE_COL_5B,
-	STREAMED_SOUND_CUTSCENE_CUB_1,
-	STREAMED_SOUND_CUTSCENE_CUB_2,
-	STREAMED_SOUND_CUTSCENE_CUB_3,
-	STREAMED_SOUND_CUTSCENE_CUB_4,
-	STREAMED_SOUND_CUTSCENE_DRUG_1,
-	STREAMED_SOUND_CUTSCENE_FIN,
-	STREAMED_SOUND_CUTSCENE_FIN2,
+	STREAMED_SOUND_NEWS_A,
+	STREAMED_SOUND_NEWS_B,
+	STREAMED_SOUND_NEWS_C,
+	STREAMED_SOUND_NEWS_D,
+	STREAMED_SOUND_NEWS_E,
+	STREAMED_SOUND_NEWS_F,
+	STREAMED_SOUND_NEWS_G,
+	STREAMED_SOUND_NEWS_H,
+	STREAMED_SOUND_NEWS_I,
+	STREAMED_SOUND_NEWS_J,
+	STREAMED_SOUND_NEWS_K,
+	STREAMED_SOUND_NEWS_L,
+	STREAMED_SOUND_NEWS_M,
+	STREAMED_SOUND_NEWS_N,
+	STREAMED_SOUND_CUTSCENE_BIKER,
+	STREAMED_SOUND_CUTSCENE_BONEVOY,
+	STREAMED_SOUND_CUTSCENE_CAMPAIN,
+	STREAMED_SOUND_CUTSCENE_CASHCHP,
+	STREAMED_SOUND_CUTSCENE_CONTBAN,
+	STREAMED_SOUND_CUTSCENE_CRAZY69,
+	STREAMED_SOUND_CUTSCENE_CUTTEST,
+	STREAMED_SOUND_CUTSCENE_DEADLY,
+	STREAMED_SOUND_CUTSCENE_DONPROB,
+	STREAMED_SOUND_CUTSCENE_DRIVNMR,
+	STREAMED_SOUND_CUTSCENE_ELECTON,
+	STREAMED_SOUND_CUTSCENE_FINAL,
+	STREAMED_SOUND_CUTSCENE_FINAL_2,
+	STREAMED_SOUND_CUTSCENE_HOMSWET,
+	STREAMED_SOUND_CUTSCENE_HOTWHEL,
+	STREAMED_SOUND_CUTSCENE_KIDNAPP,
+	STREAMED_SOUND_CUTSCENE_LANDGRB,
+	STREAMED_SOUND_CUTSCENE_MORGUE,
+	STREAMED_SOUND_CUTSCENE_OVERDOS,
+	STREAMED_SOUND_CUTSCENE_RUFJUST,
+	STREAMED_SOUND_CUTSCENE_SAYONAR,
+	STREAMED_SOUND_CUTSCENE_SICILAN,
+	STREAMED_SOUND_CUTSCENE_THEOFER,
+	STREAMED_SOUND_CUTSCENE_INTRO,
 	STREAMED_SOUND_CUTSCENE_FINALE,
-	STREAMED_SOUND_CUTSCENE_HAT_1,
-	STREAMED_SOUND_CUTSCENE_HAT_2,
-	STREAMED_SOUND_CUTSCENE_HAT_3,
-	STREAMED_SOUND_CUTSCENE_ICE_1,
-	STREAMED_SOUND_CUTSCENE_INT_A,
-	STREAMED_SOUND_CUTSCENE_INT_B,
-	STREAMED_SOUND_CUTSCENE_INT_D,
-	STREAMED_SOUND_CUTSCENE_INT_M,
-	STREAMED_SOUND_CUTSCENE_LAW_1A,
-	STREAMED_SOUND_CUTSCENE_LAW_1B,
-	STREAMED_SOUND_CUTSCENE_LAW_2A,
-	STREAMED_SOUND_CUTSCENE_LAW_2B,
-	STREAMED_SOUND_CUTSCENE_LAW_2C,
-	STREAMED_SOUND_CUTSCENE_LAW_3,
-	STREAMED_SOUND_CUTSCENE_LAW_4,
-	STREAMED_SOUND_CUTSCENE_PHIL_1,
-	STREAMED_SOUND_CUTSCENE_PHIL_2,
-	STREAMED_SOUND_CUTSCENE_PORN_1,
-	STREAMED_SOUND_CUTSCENE_PORN_2,
-	STREAMED_SOUND_CUTSCENE_PORN_3,
-	STREAMED_SOUND_CUTSCENE_PORN_4,
-	STREAMED_SOUND_CUTSCENE_RESC_1A,
-	STREAMED_SOUND_CUTSCENE_ROK_1,
-	STREAMED_SOUND_CUTSCENE_ROK_2,
-	STREAMED_SOUND_CUTSCENE_ROK_3A,
-	STREAMED_SOUND_CUTSCENE_STRIPA,
-	STREAMED_SOUND_CUTSCENE_TAX_1,
-	STREAMED_SOUND_CUTSCENE_TEX_1,
-	STREAMED_SOUND_CUTSCENE_TEX_2,
-	STREAMED_SOUND_CUTSCENE_TEX_3,
-	STREAMED_SOUND_CUTSCENE_GLIGHT,
-	STREAMED_SOUND_CUTSCENE_FIST,
-	STREAMED_SOUND_CUTSCENE_ELBURRO1_PH1,
-	STREAMED_SOUND_CUTSCENE_ELBURRO2_PH2,
 	STREAMED_SOUND_MISSION_COMPLETED,
-	STREAMED_SOUND_MISSION_COMPLETED4,
-	STREAMED_SOUND_MISSION_MOBR1,
-	STREAMED_SOUND_MISSION_PAGER,
-	STREAMED_SOUND_MISSION_CARREV,
-	STREAMED_SOUND_MISSION_BIKEREV,
-	STREAMED_SOUND_MISSION_LIFTOP,
-	STREAMED_SOUND_MISSION_LIFTCL,
-	STREAMED_SOUND_MISSION_LIFTRUN,
-	STREAMED_SOUND_MISSION_LIFTBEL,
-	STREAMED_SOUND_MISSION_INLIFT,
-	STREAMED_SOUND_MISSION_SFX_01,
-	STREAMED_SOUND_MISSION_SFX_02,
-	STREAMED_SOUND_MISSION_CAMERAL,
-	STREAMED_SOUND_MISSION_CAMERAR,
-	STREAMED_SOUND_MISSION_CHEER1,
-	STREAMED_SOUND_MISSION_CHEER2,
-	STREAMED_SOUND_MISSION_CHEER3,
-	STREAMED_SOUND_MISSION_CHEER4,
-	STREAMED_SOUND_MISSION_OOH1,
-	STREAMED_SOUND_MISSION_OOH2,
-	STREAMED_SOUND_MISSION_RACE1,
-	STREAMED_SOUND_MISSION_RACE2,
-	STREAMED_SOUND_MISSION_RACE3,
-	STREAMED_SOUND_MISSION_RACE4,
-	STREAMED_SOUND_MISSION_RACE5,
-	STREAMED_SOUND_MISSION_RACE6,
-	STREAMED_SOUND_MISSION_RACE7,
-	STREAMED_SOUND_MISSION_RACE8,
-	STREAMED_SOUND_MISSION_RACE9,
-	STREAMED_SOUND_MISSION_RACE10,
-	STREAMED_SOUND_MISSION_RACE11,
-	STREAMED_SOUND_MISSION_RACE12,
-	STREAMED_SOUND_MISSION_RACE13,
-	STREAMED_SOUND_MISSION_RACE14,
-	STREAMED_SOUND_MISSION_RACE15,
-	STREAMED_SOUND_MISSION_HOT1,
-	STREAMED_SOUND_MISSION_HOT2,
-	STREAMED_SOUND_MISSION_HOT3,
-	STREAMED_SOUND_MISSION_HOT4,
-	STREAMED_SOUND_MISSION_HOT5,
-	STREAMED_SOUND_MISSION_HOT6,
-	STREAMED_SOUND_MISSION_HOT7,
-	STREAMED_SOUND_MISSION_HOT8,
-	STREAMED_SOUND_MISSION_HOT9,
-	STREAMED_SOUND_MISSION_HOT10,
-	STREAMED_SOUND_MISSION_HOT11,
-	STREAMED_SOUND_MISSION_HOT12,
-	STREAMED_SOUND_MISSION_HOT13,
-	STREAMED_SOUND_MISSION_HOT14,
-	STREAMED_SOUND_MISSION_HOT15,
-	STREAMED_SOUND_MISSION_LANSTP1,
-	STREAMED_SOUND_MISSION_LANSTP2,
-	STREAMED_SOUND_MISSION_LANAMU1,
-	STREAMED_SOUND_MISSION_LANAMU2,
-	STREAMED_SOUND_MISSION_AIRHORNL,
-	STREAMED_SOUND_MISSION_AIRHORNR,
-	STREAMED_SOUND_MISSION_SNIPSCRL,
-	STREAMED_SOUND_MISSION_SNIPSHORT,
-	STREAMED_SOUND_MISSION_BLOWROOF,
-	STREAMED_SOUND_MISSION_ASS_1,
-	STREAMED_SOUND_MISSION_ASS_2,
-	STREAMED_SOUND_MISSION_ASS_3,
-	STREAMED_SOUND_MISSION_ASS_4,
-	STREAMED_SOUND_MISSION_ASS_5,
-	STREAMED_SOUND_MISSION_ASS_6,
-	STREAMED_SOUND_MISSION_ASS_7,
-	STREAMED_SOUND_MISSION_ASS_8,
-	STREAMED_SOUND_MISSION_ASS_9,
-	STREAMED_SOUND_MISSION_ASS_10,
-	STREAMED_SOUND_MISSION_ASS_11,
-	STREAMED_SOUND_MISSION_ASS_12,
-	STREAMED_SOUND_MISSION_ASS_13,
-	STREAMED_SOUND_MISSION_ASS_14,
-	STREAMED_SOUND_MISSION_BIKE1_1,
-	STREAMED_SOUND_MISSION_BIKE1_2,
-	STREAMED_SOUND_MISSION_BIKE1_3,
-	STREAMED_SOUND_MISSION_BNK1_1,
-	STREAMED_SOUND_MISSION_BNK1_2,
-	STREAMED_SOUND_MISSION_BNK1_3,
-	STREAMED_SOUND_MISSION_BNK1_4,
-	STREAMED_SOUND_MISSION_BNK1_5,
-	STREAMED_SOUND_MISSION_BNK1_6,
-	STREAMED_SOUND_MISSION_BNK1_7,
-	STREAMED_SOUND_MISSION_BNK1_8,
-	STREAMED_SOUND_MISSION_BNK1_10,
-	STREAMED_SOUND_MISSION_BNK1_11,
-	STREAMED_SOUND_MISSION_BNK1_12,
-	STREAMED_SOUND_MISSION_BNK1_13,
-	STREAMED_SOUND_MISSION_BNK1_14,
-	STREAMED_SOUND_MISSION_BNK2_1,
-	STREAMED_SOUND_MISSION_BNK2_2,
-	STREAMED_SOUND_MISSION_BNK2_3,
-	STREAMED_SOUND_MISSION_BNK2_4,
-	STREAMED_SOUND_MISSION_BNK2_5,
-	STREAMED_SOUND_MISSION_BNK2_6,
-	STREAMED_SOUND_MISSION_BNK2_7,
-	STREAMED_SOUND_MISSION_BNK2_8,
-	STREAMED_SOUND_MISSION_BNK2_9,
-	STREAMED_SOUND_MISSION_BNK3_1,
-	STREAMED_SOUND_MISSION_BNK3_2,
-	STREAMED_SOUND_MISSION_BNK3_3A,
-	STREAMED_SOUND_MISSION_BNK3_3B,
-	STREAMED_SOUND_MISSION_BNK3_3C,
-	STREAMED_SOUND_MISSION_BNK3_4A,
-	STREAMED_SOUND_MISSION_BNK3_4B,
-	STREAMED_SOUND_MISSION_BNK3_4C,
-	STREAMED_SOUND_MISSION_BNK4_1,
-	STREAMED_SOUND_MISSION_BNK4_2,
-	STREAMED_SOUND_MISSION_BNK4_3A,
-	STREAMED_SOUND_MISSION_BNK4_3B,
-	STREAMED_SOUND_MISSION_BNK4_3C,
-	STREAMED_SOUND_MISSION_BNK4_3D,
-	STREAMED_SOUND_MISSION_BNK4_3E,
-	STREAMED_SOUND_MISSION_BNK4_3F,
-	STREAMED_SOUND_MISSION_BNK4_3G,
-	STREAMED_SOUND_MISSION_BNK4_3H,
-	STREAMED_SOUND_MISSION_BNK4_3I,
-	STREAMED_SOUND_MISSION_BNK4_3J,
-	STREAMED_SOUND_MISSION_BNK4_3K,
-	STREAMED_SOUND_MISSION_BNK4_3M,
-	STREAMED_SOUND_MISSION_BNK4_3O,
-	STREAMED_SOUND_MISSION_BNK4_3P,
-	STREAMED_SOUND_MISSION_BNK4_3Q,
-	STREAMED_SOUND_MISSION_BNK4_3R,
-	STREAMED_SOUND_MISSION_BNK4_3S,
-	STREAMED_SOUND_MISSION_BNK4_3T,
-	STREAMED_SOUND_MISSION_BNK4_3U,
-	STREAMED_SOUND_MISSION_BNK4_3V,
-	STREAMED_SOUND_MISSION_BNK4_4A,
-	STREAMED_SOUND_MISSION_BNK4_4B,
-	STREAMED_SOUND_MISSION_BNK4_5,
-	STREAMED_SOUND_MISSION_BNK4_6,
-	STREAMED_SOUND_MISSION_BNK4_7,
-	STREAMED_SOUND_MISSION_BNK4_8,
-	STREAMED_SOUND_MISSION_BNK4_9,
-	STREAMED_SOUND_MISSION_BNK4_10,
-	STREAMED_SOUND_MISSION_BNK4_11,
-	STREAMED_SOUND_MISSION_BK4_12A,
-	STREAMED_SOUND_MISSION_BK4_12B,
-	STREAMED_SOUND_MISSION_BK4_12C,
-	STREAMED_SOUND_MISSION_BNK4_13,
-	STREAMED_SOUND_MISSION_BK4_14A,
-	STREAMED_SOUND_MISSION_BK4_14B,
-	STREAMED_SOUND_MISSION_BNK4_15,
-	STREAMED_SOUND_MISSION_BNK4_16,
-	STREAMED_SOUND_MISSION_BNK4_17,
-	STREAMED_SOUND_MISSION_BNK4_18,
-	STREAMED_SOUND_MISSION_BK4_19A,
-	STREAMED_SOUND_MISSION_BK4_19B,
-	STREAMED_SOUND_MISSION_BK4_20A,
-	STREAMED_SOUND_MISSION_BK4_20B,
-	STREAMED_SOUND_MISSION_BNK4_21,
-	STREAMED_SOUND_MISSION_BNK422A,
-	STREAMED_SOUND_MISSION_BNK422B,
-	STREAMED_SOUND_MISSION_BK4_23A,
-	STREAMED_SOUND_MISSION_BK4_23B,
-	STREAMED_SOUND_MISSION_BK4_23C,
-	STREAMED_SOUND_MISSION_BK4_23D,
-	STREAMED_SOUND_MISSION_BK4_24A,
-	STREAMED_SOUND_MISSION_BK4_24B,
-	STREAMED_SOUND_MISSION_BNK4_25,
-	STREAMED_SOUND_MISSION_BNK4_26,
-	STREAMED_SOUND_MISSION_BNK4_27,
-	STREAMED_SOUND_MISSION_BNK4_28,
-	STREAMED_SOUND_MISSION_BNK4_29,
-	STREAMED_SOUND_MISSION_BNK4_30,
-	STREAMED_SOUND_MISSION_BK4_31A,
-	STREAMED_SOUND_MISSION_BK4_31B,
-	STREAMED_SOUND_MISSION_BNK4_32,
-	STREAMED_SOUND_MISSION_BK4_34A,
-	STREAMED_SOUND_MISSION_BK4_34B,
-	STREAMED_SOUND_MISSION_BK4_35A,
-	STREAMED_SOUND_MISSION_BK4_35B,
-	STREAMED_SOUND_MISSION_BNK4_36,
-	STREAMED_SOUND_MISSION_BNK4_37,
-	STREAMED_SOUND_MISSION_BNK4_38,
-	STREAMED_SOUND_MISSION_BNK4_39,
-	STREAMED_SOUND_MISSION_BK4_40A,
-	STREAMED_SOUND_MISSION_BK4_40B,
-	STREAMED_SOUND_MISSION_BNK4_41,
-	STREAMED_SOUND_MISSION_BNK4_42,
-	STREAMED_SOUND_MISSION_BNK4_43,
-	STREAMED_SOUND_MISSION_BNK4_44,
-	STREAMED_SOUND_MISSION_BNK4_45,
-	STREAMED_SOUND_MISSION_BNK4_46,
-	STREAMED_SOUND_MISSION_BNK4_47,
-	STREAMED_SOUND_MISSION_BNK4_48,
-	STREAMED_SOUND_MISSION_BNK4_49,
-	STREAMED_SOUND_MISSION_BNK450A,
-	STREAMED_SOUND_MISSION_BNK450B,
-	STREAMED_SOUND_MISSION_BNK4_51,
-	STREAMED_SOUND_MISSION_BNK4_94,
-	STREAMED_SOUND_MISSION_BNK4_95,
-	STREAMED_SOUND_MISSION_BNK4_96,
-	STREAMED_SOUND_MISSION_BNK4_97,
-	STREAMED_SOUND_MISSION_BNK4_98,
-	STREAMED_SOUND_MISSION_BNK4_99,
-	STREAMED_SOUND_MISSION_BUD1_1,
-	STREAMED_SOUND_MISSION_BUD1_2,
-	STREAMED_SOUND_MISSION_BUD1_3,
-	STREAMED_SOUND_MISSION_BUD1_4,
-	STREAMED_SOUND_MISSION_BUD1_5,
-	STREAMED_SOUND_MISSION_BUD1_9,
-	STREAMED_SOUND_MISSION_BUD1_10,
-	STREAMED_SOUND_MISSION_BUD2_1,
-	STREAMED_SOUND_MISSION_BUD2_2,
-	STREAMED_SOUND_MISSION_BUD2_3,
-	STREAMED_SOUND_MISSION_BUD2_4,
-	STREAMED_SOUND_MISSION_BUD2_5,
-	STREAMED_SOUND_MISSION_BUD2_6,
-	STREAMED_SOUND_MISSION_BUD2_7,
-	STREAMED_SOUND_MISSION_BUD3_1,
-	STREAMED_SOUND_MISSION_BUD3_1A,
-	STREAMED_SOUND_MISSION_BUD3_1B,
-	STREAMED_SOUND_MISSION_BUD3_1C,
-	STREAMED_SOUND_MISSION_BUD3_2,
-	STREAMED_SOUND_MISSION_BUD3_3,
-	STREAMED_SOUND_MISSION_BUD3_4,
-	STREAMED_SOUND_MISSION_BUD3_5,
-	STREAMED_SOUND_MISSION_BUD3_6,
-	STREAMED_SOUND_MISSION_BUD3_7,
-	STREAMED_SOUND_MISSION_BUD3_8A,
-	STREAMED_SOUND_MISSION_BUD3_8B,
-	STREAMED_SOUND_MISSION_BUD3_8C,
-	STREAMED_SOUND_MISSION_BUD3_9A,
-	STREAMED_SOUND_MISSION_BUD3_9B,
-	STREAMED_SOUND_MISSION_BUD3_9C,
-	STREAMED_SOUND_MISSION_CAP1_2,
-	STREAMED_SOUND_MISSION_CAP1_3,
-	STREAMED_SOUND_MISSION_CAP1_4,
-	STREAMED_SOUND_MISSION_CAP1_5,
-	STREAMED_SOUND_MISSION_CAP1_6,
-	STREAMED_SOUND_MISSION_CAP1_7,
-	STREAMED_SOUND_MISSION_CAP1_8,
-	STREAMED_SOUND_MISSION_CAP1_9,
-	STREAMED_SOUND_MISSION_CAP1_10,
-	STREAMED_SOUND_MISSION_CAP1_11,
-	STREAMED_SOUND_MISSION_CAP1_12,
-	STREAMED_SOUND_MISSION_CNT1_1,
-	STREAMED_SOUND_MISSION_CNT1_2,
-	STREAMED_SOUND_MISSION_CNT1_3,
-	STREAMED_SOUND_MISSION_CNT1_4,
-	STREAMED_SOUND_MISSION_CNT1_5,
-	STREAMED_SOUND_MISSION_CNT2_1,
-	STREAMED_SOUND_MISSION_CNT2_2,
-	STREAMED_SOUND_MISSION_CNT2_3,
-	STREAMED_SOUND_MISSION_CNT2_4,
-	STREAMED_SOUND_MISSION_COK1_1,
-	STREAMED_SOUND_MISSION_COK1_2,
-	STREAMED_SOUND_MISSION_COK1_3,
-	STREAMED_SOUND_MISSION_COK1_4,
-	STREAMED_SOUND_MISSION_COK1_5,
-	STREAMED_SOUND_MISSION_COK1_6,
-	STREAMED_SOUND_MISSION_COK2_1,
-	STREAMED_SOUND_MISSION_COK2_2,
-	STREAMED_SOUND_MISSION_COK2_3,
-	STREAMED_SOUND_MISSION_COK2_4,
-	STREAMED_SOUND_MISSION_COK2_5,
-	STREAMED_SOUND_MISSION_COK2_6,
-	STREAMED_SOUND_MISSION_COK2_7A,
-	STREAMED_SOUND_MISSION_COK2_7B,
-	STREAMED_SOUND_MISSION_COK2_7C,
-	STREAMED_SOUND_MISSION_COK2_8A,
-	STREAMED_SOUND_MISSION_COK2_8B,
-	STREAMED_SOUND_MISSION_COK2_8C,
-	STREAMED_SOUND_MISSION_COK2_8D,
-	STREAMED_SOUND_MISSION_COK2_9,
-	STREAMED_SOUND_MISSION_COK210A,
-	STREAMED_SOUND_MISSION_COK210B,
-	STREAMED_SOUND_MISSION_COK210C,
-	STREAMED_SOUND_MISSION_COK212A,
-	STREAMED_SOUND_MISSION_COK212B,
-	STREAMED_SOUND_MISSION_COK2_13,
-	STREAMED_SOUND_MISSION_COK2_14,
-	STREAMED_SOUND_MISSION_COK2_15,
-	STREAMED_SOUND_MISSION_COK2_16,
-	STREAMED_SOUND_MISSION_COK2_20,
-	STREAMED_SOUND_MISSION_COK2_21,
-	STREAMED_SOUND_MISSION_COK2_22,
-	STREAMED_SOUND_MISSION_COK3_1,
-	STREAMED_SOUND_MISSION_COK3_2,
-	STREAMED_SOUND_MISSION_COK3_3,
-	STREAMED_SOUND_MISSION_COK3_4,
-	STREAMED_SOUND_MISSION_COK4_1,
-	STREAMED_SOUND_MISSION_COK4_2,
-	STREAMED_SOUND_MISSION_COK4_3,
-	STREAMED_SOUND_MISSION_COK4_4,
-	STREAMED_SOUND_MISSION_COK4_5,
-	STREAMED_SOUND_MISSION_COK4_6,
-	STREAMED_SOUND_MISSION_COK4_7,
-	STREAMED_SOUND_MISSION_COK4_8,
-	STREAMED_SOUND_MISSION_COK4_9,
-	STREAMED_SOUND_MISSION_COK4_9A,
-	STREAMED_SOUND_MISSION_COK4_10,
-	STREAMED_SOUND_MISSION_COK4_11,
-	STREAMED_SOUND_MISSION_COK4_12,
-	STREAMED_SOUND_MISSION_COK4_13,
-	STREAMED_SOUND_MISSION_COK4_14,
-	STREAMED_SOUND_MISSION_COK4_15,
-	STREAMED_SOUND_MISSION_COK4_16,
-	STREAMED_SOUND_MISSION_COK4_17,
-	STREAMED_SOUND_MISSION_COK4_18,
-	STREAMED_SOUND_MISSION_COK4_19,
-	STREAMED_SOUND_MISSION_COK4_20,
-	STREAMED_SOUND_MISSION_COK4_21,
-	STREAMED_SOUND_MISSION_COK4_22,
-	STREAMED_SOUND_MISSION_COK4_23,
-	STREAMED_SOUND_MISSION_COK4_24,
-	STREAMED_SOUND_MISSION_COK4_25,
-	STREAMED_SOUND_MISSION_COK4_26,
-	STREAMED_SOUND_MISSION_COK4_27,
-	STREAMED_SOUND_MISSION_COL1_1,
-	STREAMED_SOUND_MISSION_COL1_2,
-	STREAMED_SOUND_MISSION_COL1_3,
-	STREAMED_SOUND_MISSION_COL1_4,
-	STREAMED_SOUND_MISSION_COL1_5,
-	STREAMED_SOUND_MISSION_COL1_6,
-	STREAMED_SOUND_MISSION_COL1_7,
-	STREAMED_SOUND_MISSION_COL1_8,
-	STREAMED_SOUND_MISSION_COL2_1,
-	STREAMED_SOUND_MISSION_COL2_2,
-	STREAMED_SOUND_MISSION_COL2_3,
-	STREAMED_SOUND_MISSION_COL2_4,
-	STREAMED_SOUND_MISSION_COL2_5,
-	STREAMED_SOUND_MISSION_COL2_6A,
-	STREAMED_SOUND_MISSION_COL2_7,
-	STREAMED_SOUND_MISSION_COL2_8,
-	STREAMED_SOUND_MISSION_COL2_9,
-	STREAMED_SOUND_MISSION_COL2_10,
-	STREAMED_SOUND_MISSION_COL2_11,
-	STREAMED_SOUND_MISSION_COL2_12,
-	STREAMED_SOUND_MISSION_COL2_13,
-	STREAMED_SOUND_MISSION_COL2_14,
-	STREAMED_SOUND_MISSION_COL2_15,
-	STREAMED_SOUND_MISSION_COL2_16,
-	STREAMED_SOUND_MISSION_COL3_1,
-	STREAMED_SOUND_MISSION_COL3_2,
-	STREAMED_SOUND_MISSION_COL3_2A,
-	STREAMED_SOUND_MISSION_COL3_2B,
-	STREAMED_SOUND_MISSION_COL3_3,
-	STREAMED_SOUND_MISSION_COL3_4,
-	STREAMED_SOUND_MISSION_COL3_5,
-	STREAMED_SOUND_MISSION_COL3_6,
-	STREAMED_SOUND_MISSION_COL3_7,
-	STREAMED_SOUND_MISSION_COL3_8,
-	STREAMED_SOUND_MISSION_COL3_9,
-	STREAMED_SOUND_MISSION_COL3_10,
-	STREAMED_SOUND_MISSION_COL3_11,
-	STREAMED_SOUND_MISSION_COL3_12,
-	STREAMED_SOUND_MISSION_COL3_13,
-	STREAMED_SOUND_MISSION_COL3_14,
-	STREAMED_SOUND_MISSION_COL3_15,
-	STREAMED_SOUND_MISSION_COL3_16,
-	STREAMED_SOUND_MISSION_COL3_17,
-	STREAMED_SOUND_MISSION_COL3_18,
-	STREAMED_SOUND_MISSION_COL3_19,
-	STREAMED_SOUND_MISSION_COL3_20,
-	STREAMED_SOUND_MISSION_COL3_21,
-	STREAMED_SOUND_MISSION_COL3_23,
-	STREAMED_SOUND_MISSION_COL3_24,
-	STREAMED_SOUND_MISSION_COL3_25,
-	STREAMED_SOUND_MISSION_COL4_1,
-	STREAMED_SOUND_MISSION_COL4_2,
-	STREAMED_SOUND_MISSION_COL4_3,
-	STREAMED_SOUND_MISSION_COL4_4,
-	STREAMED_SOUND_MISSION_COL4_5,
-	STREAMED_SOUND_MISSION_COL4_6,
-	STREAMED_SOUND_MISSION_COL4_7,
-	STREAMED_SOUND_MISSION_COL4_8,
-	STREAMED_SOUND_MISSION_COL4_9,
-	STREAMED_SOUND_MISSION_COL4_10,
-	STREAMED_SOUND_MISSION_COL4_11,
-	STREAMED_SOUND_MISSION_COL4_12,
-	STREAMED_SOUND_MISSION_COL4_13,
-	STREAMED_SOUND_MISSION_COL4_14,
-	STREAMED_SOUND_MISSION_COL4_15,
-	STREAMED_SOUND_MISSION_COL4_16,
-	STREAMED_SOUND_MISSION_COL4_17,
-	STREAMED_SOUND_MISSION_COL4_18,
-	STREAMED_SOUND_MISSION_COL4_19,
-	STREAMED_SOUND_MISSION_COL4_20,
-	STREAMED_SOUND_MISSION_COL4_21,
-	STREAMED_SOUND_MISSION_COL4_22,
-	STREAMED_SOUND_MISSION_COL4_23,
-	STREAMED_SOUND_MISSION_COL4_24,
-	STREAMED_SOUND_MISSION_COL4_25,
-	STREAMED_SOUND_MISSION_COL4_26,
-	STREAMED_SOUND_MISSION_COL5_1,
-	STREAMED_SOUND_MISSION_COL5_2,
-	STREAMED_SOUND_MISSION_COL5_3,
-	STREAMED_SOUND_MISSION_COL5_4,
-	STREAMED_SOUND_MISSION_COL5_5,
-	STREAMED_SOUND_MISSION_COL5_6,
-	STREAMED_SOUND_MISSION_COL5_7,
-	STREAMED_SOUND_MISSION_COL5_8,
-	STREAMED_SOUND_MISSION_COL5_9,
-	STREAMED_SOUND_MISSION_COL5_10,
-	STREAMED_SOUND_MISSION_COL5_11,
-	STREAMED_SOUND_MISSION_COL5_12,
-	STREAMED_SOUND_MISSION_COL5_13,
-	STREAMED_SOUND_MISSION_COL5_14,
-	STREAMED_SOUND_MISSION_COL5_15,
-	STREAMED_SOUND_MISSION_COL5_16,
-	STREAMED_SOUND_MISSION_COL5_17,
-	STREAMED_SOUND_MISSION_COL5_18,
-	STREAMED_SOUND_MISSION_COL5_19,
-	STREAMED_SOUND_MISSION_COL5_20,
-	STREAMED_SOUND_MISSION_COL5_21,
-	STREAMED_SOUND_MISSION_COL5_22,
-	STREAMED_SOUND_MISSION_CUB1_1,
-	STREAMED_SOUND_MISSION_CUB1_2,
-	STREAMED_SOUND_MISSION_CUB1_3,
-	STREAMED_SOUND_MISSION_CUB1_4,
-	STREAMED_SOUND_MISSION_CUB1_5,
-	STREAMED_SOUND_MISSION_CUB1_6,
-	STREAMED_SOUND_MISSION_CUB1_7,
-	STREAMED_SOUND_MISSION_CUB1_8,
-	STREAMED_SOUND_MISSION_CUB1_9,
-	STREAMED_SOUND_MISSION_CUB1_10,
-	STREAMED_SOUND_MISSION_CUB2_1,
-	STREAMED_SOUND_MISSION_CUB2_2,
-	STREAMED_SOUND_MISSION_CUB2_3A,
-	STREAMED_SOUND_MISSION_CUB2_3B,
-	STREAMED_SOUND_MISSION_CUB2_3C,
-	STREAMED_SOUND_MISSION_CUB2_4A,
-	STREAMED_SOUND_MISSION_CUB2_5,
-	STREAMED_SOUND_MISSION_CUB2_6,
-	STREAMED_SOUND_MISSION_CUB2_7,
-	STREAMED_SOUND_MISSION_CUB2_8,
-	STREAMED_SOUND_MISSION_CUB2_9,
-	STREAMED_SOUND_MISSION_CUB2_10,
-	STREAMED_SOUND_MISSION_CUB2_11,
-	STREAMED_SOUND_MISSION_CUB3_1,
-	STREAMED_SOUND_MISSION_CUB3_2,
-	STREAMED_SOUND_MISSION_CUB3_3,
-	STREAMED_SOUND_MISSION_CUB3_4,
-	STREAMED_SOUND_MISSION_CUB4_1,
-	STREAMED_SOUND_MISSION_CUB4_2,
-	STREAMED_SOUND_MISSION_CUB4_3,
-	STREAMED_SOUND_MISSION_CUB4_4,
-	STREAMED_SOUND_MISSION_CUB4_5,
-	STREAMED_SOUND_MISSION_CUB4_5A,
-	STREAMED_SOUND_MISSION_CUB4_6,
-	STREAMED_SOUND_MISSION_CUB4_7,
-	STREAMED_SOUND_MISSION_CUB4_8,
-	STREAMED_SOUND_MISSION_CUB4_9,
-	STREAMED_SOUND_MISSION_CUB4_10,
-	STREAMED_SOUND_MISSION_CUB4_11,
-	STREAMED_SOUND_MISSION_CUB4_12,
-	STREAMED_SOUND_MISSION_CUB4_13,
-	STREAMED_SOUND_MISSION_CUB4_14,
-	STREAMED_SOUND_MISSION_CUB4_15,
-	STREAMED_SOUND_MISSION_CUB4_16,
-	STREAMED_SOUND_MISSION_GOLF_1,
-	STREAMED_SOUND_MISSION_GOLF_2,
-	STREAMED_SOUND_MISSION_GOLF_3,
-	STREAMED_SOUND_MISSION_BAR_1,
-	STREAMED_SOUND_MISSION_BAR_2,
-	STREAMED_SOUND_MISSION_BAR_3,
-	STREAMED_SOUND_MISSION_BAR_4,
-	STREAMED_SOUND_MISSION_BAR_5,
-	STREAMED_SOUND_MISSION_BAR_6,
-	STREAMED_SOUND_MISSION_BAR_7,
-	STREAMED_SOUND_MISSION_BAR_8,
-	STREAMED_SOUND_MISSION_STRIP_1,
-	STREAMED_SOUND_MISSION_STRIP_2,
-	STREAMED_SOUND_MISSION_STRIP_3,
-	STREAMED_SOUND_MISSION_STRIP_4,
-	STREAMED_SOUND_MISSION_STRIP_5,
-	STREAMED_SOUND_MISSION_STRIP_6,
-	STREAMED_SOUND_MISSION_STRIP_7,
-	STREAMED_SOUND_MISSION_STRIP_8,
-	STREAMED_SOUND_MISSION_STRIP_9,
-	STREAMED_SOUND_MISSION_STAR_1,
-	STREAMED_SOUND_MISSION_STAR_2,
-	STREAMED_SOUND_MISSION_STAR_3,
-	STREAMED_SOUND_MISSION_STAR_4,
-	STREAMED_SOUND_MISSION_FIN_1A,
-	STREAMED_SOUND_MISSION_FIN_1B,
-	STREAMED_SOUND_MISSION_FIN_1C,
-	STREAMED_SOUND_MISSION_FIN_2B,
-	STREAMED_SOUND_MISSION_FIN_2C,
-	STREAMED_SOUND_MISSION_FIN_3,
-	STREAMED_SOUND_MISSION_FIN_4,
-	STREAMED_SOUND_MISSION_FIN_5,
-	STREAMED_SOUND_MISSION_FIN_6,
-	STREAMED_SOUND_MISSION_FIN_10,
-	STREAMED_SOUND_MISSION_FIN_11A,
-	STREAMED_SOUND_MISSION_FIN_11B,
-	STREAMED_SOUND_MISSION_FIN_12A,
-	STREAMED_SOUND_MISSION_FIN_12B,
-	STREAMED_SOUND_MISSION_FIN_12C,
-	STREAMED_SOUND_MISSION_FIN_13,
-	STREAMED_SOUND_MISSION_FINKILL,
-	STREAMED_SOUND_MISSION_LAW1_1,
-	STREAMED_SOUND_MISSION_LAW1_2,
-	STREAMED_SOUND_MISSION_LAW1_3,
-	STREAMED_SOUND_MISSION_LAW1_4,
-	STREAMED_SOUND_MISSION_LAW1_5,
-	STREAMED_SOUND_MISSION_LAW1_6,
-	STREAMED_SOUND_MISSION_LAW1_7,
-	STREAMED_SOUND_MISSION_LAW1_8,
-	STREAMED_SOUND_MISSION_LAW1_9,
-	STREAMED_SOUND_MISSION_LAW1_10,
-	STREAMED_SOUND_MISSION_LAW2_1,
-	STREAMED_SOUND_MISSION_LAW2_2,
-	STREAMED_SOUND_MISSION_LAW2_3,
-	STREAMED_SOUND_MISSION_LAW2_4,
-	STREAMED_SOUND_MISSION_LAW2_5,
-	STREAMED_SOUND_MISSION_LAW2_6,
-	STREAMED_SOUND_MISSION_LAW2_7,
-	STREAMED_SOUND_MISSION_LAW2_8,
-	STREAMED_SOUND_MISSION_LAW2_9,
-	STREAMED_SOUND_MISSION_LAW2_10,
-	STREAMED_SOUND_MISSION_LAW3_1,
-	STREAMED_SOUND_MISSION_LAW3_2,
-	STREAMED_SOUND_MISSION_LAW3_3,
-	STREAMED_SOUND_MISSION_LAW3_4,
-	STREAMED_SOUND_MISSION_LAW3_5,
-	STREAMED_SOUND_MISSION_LAW3_6,
-	STREAMED_SOUND_MISSION_LAW3_10,
-	STREAMED_SOUND_MISSION_LAW3_11,
-	STREAMED_SOUND_MISSION_LAW3_12,
-	STREAMED_SOUND_MISSION_LAW3_13,
-	STREAMED_SOUND_MISSION_LAW3_14,
-	STREAMED_SOUND_MISSION_LAW3_16,
-	STREAMED_SOUND_MISSION_LAW3_17,
-	STREAMED_SOUND_MISSION_LAW3_18,
-	STREAMED_SOUND_MISSION_LAW3_19,
-	STREAMED_SOUND_MISSION_LAW3_20,
-	STREAMED_SOUND_MISSION_LAW3_21,
-	STREAMED_SOUND_MISSION_LAW3_22,
-	STREAMED_SOUND_MISSION_LAW3_23,
-	STREAMED_SOUND_MISSION_LAW3_24,
-	STREAMED_SOUND_MISSION_LAW3_25,
-	STREAMED_SOUND_MISSION_LAW4_1A,
-	STREAMED_SOUND_MISSION_LAW4_1B,
-	STREAMED_SOUND_MISSION_LAW4_1C,
-	STREAMED_SOUND_MISSION_LAW4_1D,
-	STREAMED_SOUND_MISSION_LAW4_10,
-	STREAMED_SOUND_MISSION_LAW4_3,
-	STREAMED_SOUND_MISSION_LAW4_4,
-	STREAMED_SOUND_MISSION_LAW4_5,
-	STREAMED_SOUND_MISSION_LAW4_6,
-	STREAMED_SOUND_MISSION_LAW4_7,
-	STREAMED_SOUND_MISSION_LAW4_8,
-	STREAMED_SOUND_MISSION_LAW4_9,
-	STREAMED_SOUND_MISSION_PHIL1_2,
-	STREAMED_SOUND_MISSION_PHIL1_3,
-	STREAMED_SOUND_MISSION_PHIL2_1,
-	STREAMED_SOUND_MISSION_PHIL2_2,
-	STREAMED_SOUND_MISSION_PHIL2_3,
-	STREAMED_SOUND_MISSION_PHIL2_4,
-	STREAMED_SOUND_MISSION_PHIL2_5,
-	STREAMED_SOUND_MISSION_PHIL2_6,
-	STREAMED_SOUND_MISSION_PHIL2_7,
-	STREAMED_SOUND_MISSION_PHIL2_8,
-	STREAMED_SOUND_MISSION_PHIL2_9,
-	STREAMED_SOUND_MISSION_PHIL210,
-	STREAMED_SOUND_MISSION_PHIL211,
-	STREAMED_SOUND_MISSION_PORN1_1,
-	STREAMED_SOUND_MISSION_PORN1_2,
-	STREAMED_SOUND_MISSION_PORN1_3,
-	STREAMED_SOUND_MISSION_PRN1_3A,
-	STREAMED_SOUND_MISSION_PORN1_4,
-	STREAMED_SOUND_MISSION_PORN1_5,
-	STREAMED_SOUND_MISSION_PORN1_6,
-	STREAMED_SOUND_MISSION_PORN1_7,
-	STREAMED_SOUND_MISSION_PORN1_8,
-	STREAMED_SOUND_MISSION_PORN1_9,
-	STREAMED_SOUND_MISSION_PRN1_10,
-	STREAMED_SOUND_MISSION_PRN1_11,
-	STREAMED_SOUND_MISSION_PRN1_12,
-	STREAMED_SOUND_MISSION_PRN1_13,
-	STREAMED_SOUND_MISSION_PRN1_14,
-	STREAMED_SOUND_MISSION_PRN1_15,
-	STREAMED_SOUND_MISSION_PRN1_16,
-	STREAMED_SOUND_MISSION_PRN1_17,
-	STREAMED_SOUND_MISSION_PRN1_18,
-	STREAMED_SOUND_MISSION_PRN1_19,
-	STREAMED_SOUND_MISSION_PRN1_20,
-	STREAMED_SOUND_MISSION_PRN1_21,
-	STREAMED_SOUND_MISSION_PORN3_1,
-	STREAMED_SOUND_MISSION_PORN3_2,
-	STREAMED_SOUND_MISSION_PORN3_3,
-	STREAMED_SOUND_MISSION_PORN3_4,
-	STREAMED_SOUND_MISSION_PSYCH_1,
-	STREAMED_SOUND_MISSION_PSYCH_2,
-	STREAMED_SOUND_MISSION_ROK2_01,
-	STREAMED_SOUND_MISSION_ROK3_1,
-	STREAMED_SOUND_MISSION_ROK3_2,
-	STREAMED_SOUND_MISSION_ROK3_3,
-	STREAMED_SOUND_MISSION_ROK3_4,
-	STREAMED_SOUND_MISSION_ROK3_5,
-	STREAMED_SOUND_MISSION_ROK3_6,
-	STREAMED_SOUND_MISSION_ROK3_7,
-	STREAMED_SOUND_MISSION_ROK3_8,
-	STREAMED_SOUND_MISSION_ROK3_9,
-	STREAMED_SOUND_MISSION_ROK3_10,
-	STREAMED_SOUND_MISSION_ROK3_11,
-	STREAMED_SOUND_MISSION_ROK3_12,
-	STREAMED_SOUND_MISSION_ROK3_13,
-	STREAMED_SOUND_MISSION_ROK3_14,
-	STREAMED_SOUND_MISSION_ROK3_15,
-	STREAMED_SOUND_MISSION_ROK3_16,
-	STREAMED_SOUND_MISSION_ROK3_17,
-	STREAMED_SOUND_MISSION_ROK3_18,
-	STREAMED_SOUND_MISSION_ROK3_19,
-	STREAMED_SOUND_MISSION_ROK3_20,
-	STREAMED_SOUND_MISSION_ROK3_21,
-	STREAMED_SOUND_MISSION_ROK3_22,
-	STREAMED_SOUND_MISSION_ROK3_23,
-	STREAMED_SOUND_MISSION_ROK3_24,
-	STREAMED_SOUND_MISSION_ROK3_25,
-	STREAMED_SOUND_MISSION_ROK3_26,
-	STREAMED_SOUND_MISSION_ROK3_27,
-	STREAMED_SOUND_MISSION_ROK3_62,
-	STREAMED_SOUND_MISSION_ROK3_63,
-	STREAMED_SOUND_MISSION_ROK3_64,
-	STREAMED_SOUND_MISSION_ROK3_65,
-	STREAMED_SOUND_MISSION_ROK3_66,
-	STREAMED_SOUND_MISSION_ROK3_67,
-	STREAMED_SOUND_MISSION_ROK3_68,
-	STREAMED_SOUND_MISSION_ROK3_69,
-	STREAMED_SOUND_MISSION_ROK3_70,
-	STREAMED_SOUND_MISSION_ROK3_71,
-	STREAMED_SOUND_MISSION_ROK3_73,
-	STREAMED_SOUND_MISSION_RESC_1,
-	STREAMED_SOUND_MISSION_RESC_2,
-	STREAMED_SOUND_MISSION_RESC_3,
-	STREAMED_SOUND_MISSION_RESC_4,
-	STREAMED_SOUND_MISSION_RESC_5,
-	STREAMED_SOUND_MISSION_RESC_6,
-	STREAMED_SOUND_MISSION_RESC_7,
-	STREAMED_SOUND_MISSION_RESC_8,
-	STREAMED_SOUND_MISSION_RESC_9,
-	STREAMED_SOUND_MISSION_RESC_10,
-	STREAMED_SOUND_MISSION_ROK1_1A,
-	STREAMED_SOUND_MISSION_ROK1_1B,
-	STREAMED_SOUND_MISSION_ROK1_5,
-	STREAMED_SOUND_MISSION_ROK1_6,
-	STREAMED_SOUND_MISSION_ROK1_7,
-	STREAMED_SOUND_MISSION_ROK1_8,
-	STREAMED_SOUND_MISSION_ROK1_9,
-	STREAMED_SOUND_MISSION_TAX1_1,
-	STREAMED_SOUND_MISSION_TAX1_2,
-	STREAMED_SOUND_MISSION_TAX1_3,
-	STREAMED_SOUND_MISSION_TAX1_4,
-	STREAMED_SOUND_MISSION_TAX1_5,
-	STREAMED_SOUND_MISSION_TAX2_1,
-	STREAMED_SOUND_MISSION_TAX2_2,
-	STREAMED_SOUND_MISSION_TAX2_3,
-	STREAMED_SOUND_MISSION_TAX2_4,
-	STREAMED_SOUND_MISSION_TAX2_5,
-	STREAMED_SOUND_MISSION_TAX2_6,
-	STREAMED_SOUND_MISSION_TAX2_7,
-	STREAMED_SOUND_MISSION_TAX3_1,
-	STREAMED_SOUND_MISSION_TAX3_2,
-	STREAMED_SOUND_MISSION_TAX3_3,
-	STREAMED_SOUND_MISSION_TAX3_4,
-	STREAMED_SOUND_MISSION_TAX3_5,
-	STREAMED_SOUND_MISSION_TEX1_1,
-	STREAMED_SOUND_MISSION_TEX1_2,
-	STREAMED_SOUND_MISSION_TEX1_3,
-	STREAMED_SOUND_MISSION_TEX1_4,
-	STREAMED_SOUND_MISSION_TEX1_5,
-	STREAMED_SOUND_MISSION_TEX1_6,
-	STREAMED_SOUND_MISSION_TEX2_1,
-	STREAMED_SOUND_MISSION_TEX3_1,
-	STREAMED_SOUND_MISSION_TEX3_2,
-	STREAMED_SOUND_MISSION_TEX3_3,
-	STREAMED_SOUND_MISSION_TEX3_4,
-	STREAMED_SOUND_MISSION_TEX3_5,
-	STREAMED_SOUND_MISSION_TEX3_6,
-	STREAMED_SOUND_MISSION_TEX3_7,
-	STREAMED_SOUND_MISSION_TEX3_8,
-	STREAMED_SOUND_MISSION_HAT_1A,
-	STREAMED_SOUND_MISSION_INTRO1,
-	STREAMED_SOUND_MISSION_INTRO2,
-	STREAMED_SOUND_MISSION_INTRO3,
-	STREAMED_SOUND_MISSION_INTRO4,
-	STREAMED_SOUND_MISSION_MOB_01A,
-	STREAMED_SOUND_MISSION_MOB_01B,
-	STREAMED_SOUND_MISSION_MOB_01C,
-	STREAMED_SOUND_MISSION_MOB_02A,
-	STREAMED_SOUND_MISSION_MOB_02B,
-	STREAMED_SOUND_MISSION_MOB_02C,
-	STREAMED_SOUND_MISSION_MOB_03A,
-	STREAMED_SOUND_MISSION_MOB_03B,
-	STREAMED_SOUND_MISSION_MOB_03C,
-	STREAMED_SOUND_MISSION_MOB_03D,
-	STREAMED_SOUND_MISSION_MOB_03E,
-	STREAMED_SOUND_MISSION_SHARK_1,
-	STREAMED_SOUND_MISSION_SHARK_2,
-	STREAMED_SOUND_MISSION_SHARK_3,
-	STREAMED_SOUND_MISSION_SHARK_4,
-	STREAMED_SOUND_MISSION_SHARK_5,
-	STREAMED_SOUND_MISSION_MOB_04A,
-	STREAMED_SOUND_MISSION_MOB_04B,
-	STREAMED_SOUND_MISSION_MOB_04C,
-	STREAMED_SOUND_MISSION_MOB_04D,
-	STREAMED_SOUND_MISSION_MOB_05A,
-	STREAMED_SOUND_MISSION_MOB_05B,
-	STREAMED_SOUND_MISSION_MOB_05C,
-	STREAMED_SOUND_MISSION_MOB_05D,
-	STREAMED_SOUND_MISSION_MOB_06A,
-	STREAMED_SOUND_MISSION_MOB_06B,
-	STREAMED_SOUND_MISSION_MOB_06C,
-	STREAMED_SOUND_MISSION_MOB_07A,
-	STREAMED_SOUND_MISSION_MOB_07B,
-	STREAMED_SOUND_MISSION_MOB_08A,
-	STREAMED_SOUND_MISSION_MOB_08B,
-	STREAMED_SOUND_MISSION_MOB_08C,
-	STREAMED_SOUND_MISSION_MOB_08D,
-	STREAMED_SOUND_MISSION_MOB_08E,
-	STREAMED_SOUND_MISSION_MOB_08F,
-	STREAMED_SOUND_MISSION_MOB_08G,
-	STREAMED_SOUND_MISSION_MOB_09A,
-	STREAMED_SOUND_MISSION_MOB_09B,
-	STREAMED_SOUND_MISSION_MOB_09C,
-	STREAMED_SOUND_MISSION_MOB_09D,
-	STREAMED_SOUND_MISSION_MOB_09E,
-	STREAMED_SOUND_MISSION_MOB_09F,
-	STREAMED_SOUND_MISSION_MOB_10A,
-	STREAMED_SOUND_MISSION_MOB_10B,
-	STREAMED_SOUND_MISSION_MOB_10C,
-	STREAMED_SOUND_MISSION_MOB_10D,
-	STREAMED_SOUND_MISSION_MOB_10E,
-	STREAMED_SOUND_MISSION_MOB_11A,
-	STREAMED_SOUND_MISSION_MOB_11B,
-	STREAMED_SOUND_MISSION_MOB_11C,
-	STREAMED_SOUND_MISSION_MOB_11D,
-	STREAMED_SOUND_MISSION_MOB_11E,
-	STREAMED_SOUND_MISSION_MOB_11F,
-	STREAMED_SOUND_MISSION_MOB_14A,
-	STREAMED_SOUND_MISSION_MOB_14B,
-	STREAMED_SOUND_MISSION_MOB_14C,
-	STREAMED_SOUND_MISSION_MOB_14D,
-	STREAMED_SOUND_MISSION_MOB_14E,
-	STREAMED_SOUND_MISSION_MOB_14F,
-	STREAMED_SOUND_MISSION_MOB_14G,
-	STREAMED_SOUND_MISSION_MOB_14H,
-	STREAMED_SOUND_MISSION_MOB_16A,
-	STREAMED_SOUND_MISSION_MOB_16B,
-	STREAMED_SOUND_MISSION_MOB_16C,
-	STREAMED_SOUND_MISSION_MOB_16D,
-	STREAMED_SOUND_MISSION_MOB_16E,
-	STREAMED_SOUND_MISSION_MOB_16F,
-	STREAMED_SOUND_MISSION_MOB_16G,
-	STREAMED_SOUND_MISSION_MOB_17A,
-	STREAMED_SOUND_MISSION_MOB_17B,
-	STREAMED_SOUND_MISSION_MOB_17C,
-	STREAMED_SOUND_MISSION_MOB_17D,
-	STREAMED_SOUND_MISSION_MOB_17E,
-	STREAMED_SOUND_MISSION_MOB_17G,
-	STREAMED_SOUND_MISSION_MOB_17H,
-	STREAMED_SOUND_MISSION_MOB_17I,
-	STREAMED_SOUND_MISSION_MOB_17J,
-	STREAMED_SOUND_MISSION_MOB_17K,
-	STREAMED_SOUND_MISSION_MOB_17L,
-	STREAMED_SOUND_MISSION_MOB_18A,
-	STREAMED_SOUND_MISSION_MOB_18B,
-	STREAMED_SOUND_MISSION_MOB_18C,
-	STREAMED_SOUND_MISSION_MOB_18D,
-	STREAMED_SOUND_MISSION_MOB_18E,
-	STREAMED_SOUND_MISSION_MOB_18F,
-	STREAMED_SOUND_MISSION_MOB_18G,
-	STREAMED_SOUND_MISSION_MOB_20A,
-	STREAMED_SOUND_MISSION_MOB_20B,
-	STREAMED_SOUND_MISSION_MOB_20C,
-	STREAMED_SOUND_MISSION_MOB_20D,
-	STREAMED_SOUND_MISSION_MOB_20E,
-	STREAMED_SOUND_MISSION_MOB_24A,
-	STREAMED_SOUND_MISSION_MOB_24B,
-	STREAMED_SOUND_MISSION_MOB_24C,
-	STREAMED_SOUND_MISSION_MOB_24D,
-	STREAMED_SOUND_MISSION_MOB_24E,
-	STREAMED_SOUND_MISSION_MOB_24F,
-	STREAMED_SOUND_MISSION_MOB_24G,
-	STREAMED_SOUND_MISSION_MOB_24H,
-	STREAMED_SOUND_MISSION_MOB_25A,
-	STREAMED_SOUND_MISSION_MOB_25B,
-	STREAMED_SOUND_MISSION_MOB_25C,
-	STREAMED_SOUND_MISSION_MOB_25D,
-	STREAMED_SOUND_MISSION_MOB_26A,
-	STREAMED_SOUND_MISSION_MOB_26B,
-	STREAMED_SOUND_MISSION_MOB_26C,
-	STREAMED_SOUND_MISSION_MOB_26D,
-	STREAMED_SOUND_MISSION_MOB_26E,
-	STREAMED_SOUND_MISSION_MOB_29A,
-	STREAMED_SOUND_MISSION_MOB_29B,
-	STREAMED_SOUND_MISSION_MOB_29C,
-	STREAMED_SOUND_MISSION_MOB_29D,
-	STREAMED_SOUND_MISSION_MOB_29E,
-	STREAMED_SOUND_MISSION_MOB_29F,
-	STREAMED_SOUND_MISSION_MOB_29G,
-	STREAMED_SOUND_MISSION_MOB_30A,
-	STREAMED_SOUND_MISSION_MOB_30B,
-	STREAMED_SOUND_MISSION_MOB_30C,
-	STREAMED_SOUND_MISSION_MOB_30D,
-	STREAMED_SOUND_MISSION_MOB_30E,
-	STREAMED_SOUND_MISSION_MOB_30F,
-	STREAMED_SOUND_MISSION_MOB_33A,
-	STREAMED_SOUND_MISSION_MOB_33B,
-	STREAMED_SOUND_MISSION_MOB_33C,
-	STREAMED_SOUND_MISSION_MOB_33D,
-	STREAMED_SOUND_MISSION_MOB_34A,
-	STREAMED_SOUND_MISSION_MOB_34B,
-	STREAMED_SOUND_MISSION_MOB_34C,
-	STREAMED_SOUND_MISSION_MOB_34D,
-	STREAMED_SOUND_MISSION_MOB_35A,
-	STREAMED_SOUND_MISSION_MOB_35B,
-	STREAMED_SOUND_MISSION_MOB_35C,
-	STREAMED_SOUND_MISSION_MOB_35D,
-	STREAMED_SOUND_MISSION_MOB_36A,
-	STREAMED_SOUND_MISSION_MOB_36B,
-	STREAMED_SOUND_MISSION_MOB_36C,
-	STREAMED_SOUND_MISSION_MOB_40A,
-	STREAMED_SOUND_MISSION_MOB_40B,
-	STREAMED_SOUND_MISSION_MOB_40C,
-	STREAMED_SOUND_MISSION_MOB_40D,
-	STREAMED_SOUND_MISSION_MOB_40E,
-	STREAMED_SOUND_MISSION_MOB_40F,
-	STREAMED_SOUND_MISSION_MOB_40G,
-	STREAMED_SOUND_MISSION_MOB_40H,
-	STREAMED_SOUND_MISSION_MOB_40I,
-	STREAMED_SOUND_MISSION_MOB_41A,
-	STREAMED_SOUND_MISSION_MOB_41B,
-	STREAMED_SOUND_MISSION_MOB_41C,
-	STREAMED_SOUND_MISSION_MOB_41D,
-	STREAMED_SOUND_MISSION_MOB_41E,
-	STREAMED_SOUND_MISSION_MOB_41F,
-	STREAMED_SOUND_MISSION_MOB_41G,
-	STREAMED_SOUND_MISSION_MOB_41H,
-	STREAMED_SOUND_MISSION_MOB_42A,
-	STREAMED_SOUND_MISSION_MOB_42B,
-	STREAMED_SOUND_MISSION_MOB_42C,
-	STREAMED_SOUND_MISSION_MOB_42D,
-	STREAMED_SOUND_MISSION_MOB_42E,
-	STREAMED_SOUND_MISSION_MOB_43A,
-	STREAMED_SOUND_MISSION_MOB_43B,
-	STREAMED_SOUND_MISSION_MOB_43C,
-	STREAMED_SOUND_MISSION_MOB_43D,
-	STREAMED_SOUND_MISSION_MOB_43E,
-	STREAMED_SOUND_MISSION_MOB_43F,
-	STREAMED_SOUND_MISSION_MOB_43G,
-	STREAMED_SOUND_MISSION_MOB_43H,
-	STREAMED_SOUND_MISSION_MOB_45A,
-	STREAMED_SOUND_MISSION_MOB_45B,
-	STREAMED_SOUND_MISSION_MOB_45C,
-	STREAMED_SOUND_MISSION_MOB_45D,
-	STREAMED_SOUND_MISSION_MOB_45E,
-	STREAMED_SOUND_MISSION_MOB_45F,
-	STREAMED_SOUND_MISSION_MOB_45G,
-	STREAMED_SOUND_MISSION_MOB_45H,
-	STREAMED_SOUND_MISSION_MOB_45I,
-	STREAMED_SOUND_MISSION_MOB_45J,
-	STREAMED_SOUND_MISSION_MOB_45K,
-	STREAMED_SOUND_MISSION_MOB_45L,
-	STREAMED_SOUND_MISSION_MOB_45M,
-	STREAMED_SOUND_MISSION_MOB_45N,
-	STREAMED_SOUND_MISSION_MOB_46A,
-	STREAMED_SOUND_MISSION_MOB_46B,
-	STREAMED_SOUND_MISSION_MOB_46C,
-	STREAMED_SOUND_MISSION_MOB_46D,
-	STREAMED_SOUND_MISSION_MOB_46E,
-	STREAMED_SOUND_MISSION_MOB_46F,
-	STREAMED_SOUND_MISSION_MOB_46G,
-	STREAMED_SOUND_MISSION_MOB_46H,
-	STREAMED_SOUND_MISSION_MOB_47A,
-	STREAMED_SOUND_MISSION_MOB_52A,
-	STREAMED_SOUND_MISSION_MOB_52B,
-	STREAMED_SOUND_MISSION_MOB_52C,
-	STREAMED_SOUND_MISSION_MOB_52D,
-	STREAMED_SOUND_MISSION_MOB_52E,
-	STREAMED_SOUND_MISSION_MOB_52F,
-	STREAMED_SOUND_MISSION_MOB_52G,
-	STREAMED_SOUND_MISSION_MOB_52H,
-	STREAMED_SOUND_MISSION_MOB_54A,
-	STREAMED_SOUND_MISSION_MOB_54B,
-	STREAMED_SOUND_MISSION_MOB_54C,
-	STREAMED_SOUND_MISSION_MOB_54D,
-	STREAMED_SOUND_MISSION_MOB_54E,
-	STREAMED_SOUND_MISSION_MOB_55A,
-	STREAMED_SOUND_MISSION_MOB_55B,
-	STREAMED_SOUND_MISSION_MOB_55C,
-	STREAMED_SOUND_MISSION_MOB_55D,
-	STREAMED_SOUND_MISSION_MOB_55E,
-	STREAMED_SOUND_MISSION_MOB_55F,
-	STREAMED_SOUND_MISSION_MOB_56A,
-	STREAMED_SOUND_MISSION_MOB_56B,
-	STREAMED_SOUND_MISSION_MOB_56C,
-	STREAMED_SOUND_MISSION_MOB_56D,
-	STREAMED_SOUND_MISSION_MOB_56E,
-	STREAMED_SOUND_MISSION_MOB_56F,
-	STREAMED_SOUND_MISSION_MOB_57A,
-	STREAMED_SOUND_MISSION_MOB_57B,
-	STREAMED_SOUND_MISSION_MOB_57C,
-	STREAMED_SOUND_MISSION_MOB_57D,
-	STREAMED_SOUND_MISSION_MOB_57E,
-	STREAMED_SOUND_MISSION_MOB_58A,
-	STREAMED_SOUND_MISSION_MOB_58B,
-	STREAMED_SOUND_MISSION_MOB_58C,
-	STREAMED_SOUND_MISSION_MOB_58D,
-	STREAMED_SOUND_MISSION_MOB_58E,
-	STREAMED_SOUND_MISSION_MOB_58F,
-	STREAMED_SOUND_MISSION_MOB_58G,
-	STREAMED_SOUND_MISSION_MOB_61A,
-	STREAMED_SOUND_MISSION_MOB_61B,
-	STREAMED_SOUND_MISSION_MOB_62A,
-	STREAMED_SOUND_MISSION_MOB_62B,
-	STREAMED_SOUND_MISSION_MOB_62C,
-	STREAMED_SOUND_MISSION_MOB_62D,
-	STREAMED_SOUND_MISSION_MOB_63A,
-	STREAMED_SOUND_MISSION_MOB_63B,
-	STREAMED_SOUND_MISSION_MOB_63C,
-	STREAMED_SOUND_MISSION_MOB_63D,
-	STREAMED_SOUND_MISSION_MOB_63E,
-	STREAMED_SOUND_MISSION_MOB_63F,
-	STREAMED_SOUND_MISSION_MOB_63G,
-	STREAMED_SOUND_MISSION_MOB_63H,
-	STREAMED_SOUND_MISSION_MOB_63I,
-	STREAMED_SOUND_MISSION_MOB_63J,
-	STREAMED_SOUND_MISSION_MOB_66A,
-	STREAMED_SOUND_MISSION_MOB_66B,
-	STREAMED_SOUND_MISSION_MOB_68A,
-	STREAMED_SOUND_MISSION_MOB_68B,
-	STREAMED_SOUND_MISSION_MOB_68C,
-	STREAMED_SOUND_MISSION_MOB_68D,
-	STREAMED_SOUND_MISSION_MOB_70A,
-	STREAMED_SOUND_MISSION_MOB_70B,
-	STREAMED_SOUND_MISSION_MOB_71A,
-	STREAMED_SOUND_MISSION_MOB_71B,
-	STREAMED_SOUND_MISSION_MOB_71C,
-	STREAMED_SOUND_MISSION_MOB_71D,
-	STREAMED_SOUND_MISSION_MOB_71E,
-	STREAMED_SOUND_MISSION_MOB_71F,
-	STREAMED_SOUND_MISSION_MOB_71G,
-	STREAMED_SOUND_MISSION_MOB_71H,
-	STREAMED_SOUND_MISSION_MOB_71I,
-	STREAMED_SOUND_MISSION_MOB_71J,
-	STREAMED_SOUND_MISSION_MOB_71K,
-	STREAMED_SOUND_MISSION_MOB_71L,
-	STREAMED_SOUND_MISSION_MOB_71M,
-	STREAMED_SOUND_MISSION_MOB_71N,
-	STREAMED_SOUND_MISSION_MOB_72A,
-	STREAMED_SOUND_MISSION_MOB_72B,
-	STREAMED_SOUND_MISSION_MOB_72C,
-	STREAMED_SOUND_MISSION_MOB_72D,
-	STREAMED_SOUND_MISSION_MOB_72E,
-	STREAMED_SOUND_MISSION_MOB_72F,
-	STREAMED_SOUND_MISSION_MOB_72G,
-	STREAMED_SOUND_MISSION_MOB_73A,
-	STREAMED_SOUND_MISSION_MOB_73C,
-	STREAMED_SOUND_MISSION_MOB_73D,
-	STREAMED_SOUND_MISSION_MOB_73F,
-	STREAMED_SOUND_MISSION_MOB_73G,
-	STREAMED_SOUND_MISSION_MOB_73I,
-	STREAMED_SOUND_MISSION_MOB_95A,
-	STREAMED_SOUND_MISSION_MOB_96A,
-	STREAMED_SOUND_MISSION_MOB_98A,
-	STREAMED_SOUND_MISSION_MOB_99A,
-	STREAMED_SOUND_MISSION_JOB1_1B,
-	STREAMED_SOUND_MISSION_JOB1_1C,
-	STREAMED_SOUND_MISSION_JOB1_1D,
-	STREAMED_SOUND_MISSION_JOB2_1B,
-	STREAMED_SOUND_MISSION_JOB2_2,
-	STREAMED_SOUND_MISSION_JOB2_3,
-	STREAMED_SOUND_MISSION_JOB2_4,
-	STREAMED_SOUND_MISSION_JOB2_5,
-	STREAMED_SOUND_MISSION_JOB2_6,
-	STREAMED_SOUND_MISSION_JOB2_7,
-	STREAMED_SOUND_MISSION_JOB2_8,
-	STREAMED_SOUND_MISSION_JOB2_9,
-	STREAMED_SOUND_MISSION_JOB3_1,
-	STREAMED_SOUND_MISSION_JOB3_2,
-	STREAMED_SOUND_MISSION_JOB3_3,
-	STREAMED_SOUND_MISSION_JOB4_1,
-	STREAMED_SOUND_MISSION_JOB4_2,
-	STREAMED_SOUND_MISSION_JOB4_3,
-	STREAMED_SOUND_MISSION_JOB5_1,
-	STREAMED_SOUND_MISSION_JOB5_2,
-	STREAMED_SOUND_MISSION_JOB5_3,
-	STREAMED_SOUND_MISSION_BJM1_20,
-	STREAMED_SOUND_MISSION_BJM1_4,
-	STREAMED_SOUND_MISSION_BJM1_5,
-	STREAMED_SOUND_MISSION_MERC_39,
-	STREAMED_SOUND_MISSION_MONO_1,
-	STREAMED_SOUND_MISSION_MONO_2,
-	STREAMED_SOUND_MISSION_MONO_3,
-	STREAMED_SOUND_MISSION_MONO_4,
-	STREAMED_SOUND_MISSION_MONO_5,
-	STREAMED_SOUND_MISSION_MONO_6,
-	STREAMED_SOUND_MISSION_MONO_7,
-	STREAMED_SOUND_MISSION_MONO_8,
-	STREAMED_SOUND_MISSION_MONO_9,
-	STREAMED_SOUND_MISSION_MONO10,
-	STREAMED_SOUND_MISSION_MONO11,
-	STREAMED_SOUND_MISSION_MONO12,
-	STREAMED_SOUND_MISSION_MONO13,
-	STREAMED_SOUND_MISSION_MONO14,
-	STREAMED_SOUND_MISSION_MONO15,
-	STREAMED_SOUND_MISSION_MONO16,
-	STREAMED_SOUND_MISSION_FUD_01,
-	STREAMED_SOUND_MISSION_FUD_02,
-	STREAMED_SOUND_MISSION_FUD_03,
-	STREAMED_SOUND_MISSION_FUD_04,
-	STREAMED_SOUND_MISSION_FUD_05,
-	STREAMED_SOUND_MISSION_FUD_06,
-	STREAMED_SOUND_MISSION_FUD_07,
-	STREAMED_SOUND_MISSION_FUD_08,
-	STREAMED_SOUND_MISSION_FUD_09,
-	STREAMED_SOUND_MISSION_FUD_10,
-	STREAMED_SOUND_MISSION_FUD_11,
-	STREAMED_SOUND_MISSION_FUD_12,
-	STREAMED_SOUND_MISSION_FUD_13,
-	STREAMED_SOUND_MISSION_FUD_14,
-	STREAMED_SOUND_MISSION_FUD_15,
-	STREAMED_SOUND_MISSION_FUD_16,
-	STREAMED_SOUND_MISSION_FUD_17,
-	STREAMED_SOUND_MISSION_FUD_18,
-	STREAMED_SOUND_MISSION_FUD_19,
-	STREAMED_SOUND_MISSION_FUD_20,
-	STREAMED_SOUND_MISSION_BURG_01,
-	STREAMED_SOUND_MISSION_BURG_02,
-	STREAMED_SOUND_MISSION_BURG_03,
-	STREAMED_SOUND_MISSION_BURG_04,
-	STREAMED_SOUND_MISSION_BURG_05,
-	STREAMED_SOUND_MISSION_BURG_06,
-	STREAMED_SOUND_MISSION_BURG_07,
-	STREAMED_SOUND_MISSION_BURG_08,
-	STREAMED_SOUND_MISSION_BURG_09,
-	STREAMED_SOUND_MISSION_BURG_10,
-	STREAMED_SOUND_MISSION_BURG_11,
-	STREAMED_SOUND_MISSION_BURG_12,
-	STREAMED_SOUND_MISSION_CRUST01,
-	STREAMED_SOUND_MISSION_CRUST02,
-	STREAMED_SOUND_MISSION_CRUST03,
-	STREAMED_SOUND_MISSION_CRUST04,
-	STREAMED_SOUND_MISSION_CRUST05,
-	STREAMED_SOUND_MISSION_CRUST06,
-	STREAMED_SOUND_MISSION_CRUST07,
-	STREAMED_SOUND_MISSION_CRUST08,
-	STREAMED_SOUND_MISSION_CRUST09,
-	STREAMED_SOUND_MISSION_BAND_01,
-	STREAMED_SOUND_MISSION_BAND_02,
-	STREAMED_SOUND_MISSION_BAND_03,
-	STREAMED_SOUND_MISSION_BAND_04,
-	STREAMED_SOUND_MISSION_BAND_05,
-	STREAMED_SOUND_MISSION_BAND_06,
-	STREAMED_SOUND_MISSION_BAND_07,
-	STREAMED_SOUND_MISSION_BAND_08,
-	STREAMED_SOUND_MISSION_SHAFT01,
-	STREAMED_SOUND_MISSION_SHAFT02,
-	STREAMED_SOUND_MISSION_SHAFT03,
-	STREAMED_SOUND_MISSION_SHAFT04,
-	STREAMED_SOUND_MISSION_SHAFT05,
-	STREAMED_SOUND_MISSION_SHAFT06,
-	STREAMED_SOUND_MISSION_SHAFT07,
-	STREAMED_SOUND_MISSION_SHAFT08,
-	STREAMED_SOUND_MISSION_PISS_01,
-	STREAMED_SOUND_MISSION_PISS_02,
-	STREAMED_SOUND_MISSION_PISS_03,
-	STREAMED_SOUND_MISSION_PISS_04,
-	STREAMED_SOUND_MISSION_PISS_05,
-	STREAMED_SOUND_MISSION_PISS_06,
-	STREAMED_SOUND_MISSION_PISS_07,
-	STREAMED_SOUND_MISSION_PISS_08,
-	STREAMED_SOUND_MISSION_PISS_09,
-	STREAMED_SOUND_MISSION_PISS_10,
-	STREAMED_SOUND_MISSION_PISS_11,
-	STREAMED_SOUND_MISSION_PISS_12,
-	STREAMED_SOUND_MISSION_PISS_13,
-	STREAMED_SOUND_MISSION_PISS_14,
-	STREAMED_SOUND_MISSION_PISS_15,
-	STREAMED_SOUND_MISSION_PISS_16,
-	STREAMED_SOUND_MISSION_PISS_17,
-	STREAMED_SOUND_MISSION_PISS_18,
-	STREAMED_SOUND_MISSION_PISS_19,
-	STREAMED_SOUND_MISSION_GIMME01,
-	STREAMED_SOUND_MISSION_GIMME02,
-	STREAMED_SOUND_MISSION_GIMME03,
-	STREAMED_SOUND_MISSION_GIMME04,
-	STREAMED_SOUND_MISSION_GIMME05,
-	STREAMED_SOUND_MISSION_GIMME06,
-	STREAMED_SOUND_MISSION_GIMME07,
-	STREAMED_SOUND_MISSION_GIMME08,
-	STREAMED_SOUND_MISSION_GIMME09,
-	STREAMED_SOUND_MISSION_GIMME10,
-	STREAMED_SOUND_MISSION_GIMME11,
-	STREAMED_SOUND_MISSION_GIMME12,
-	STREAMED_SOUND_MISSION_GIMME13,
-	STREAMED_SOUND_MISSION_GIMME14,
-	STREAMED_SOUND_MISSION_GIMME15,
-	STREAMED_SOUND_MISSION_BUST_01,
-	STREAMED_SOUND_MISSION_BUST_02,
-	STREAMED_SOUND_MISSION_BUST_03,
-	STREAMED_SOUND_MISSION_BUST_04,
-	STREAMED_SOUND_MISSION_BUST_05,
-	STREAMED_SOUND_MISSION_BUST_06,
-	STREAMED_SOUND_MISSION_BUST_07,
-	STREAMED_SOUND_MISSION_BUST_08,
-	STREAMED_SOUND_MISSION_BUST_09,
-	STREAMED_SOUND_MISSION_BUST_10,
-	STREAMED_SOUND_MISSION_BUST_11,
-	STREAMED_SOUND_MISSION_BUST_12,
-	STREAMED_SOUND_MISSION_BUST_13,
-	STREAMED_SOUND_MISSION_BUST_14,
-	STREAMED_SOUND_MISSION_BUST_15,
-	STREAMED_SOUND_MISSION_BUST_16,
-	STREAMED_SOUND_MISSION_BUST_17,
-	STREAMED_SOUND_MISSION_BUST_18,
-	STREAMED_SOUND_MISSION_BUST_19,
-	STREAMED_SOUND_MISSION_BUST_20,
-	STREAMED_SOUND_MISSION_BUST_21,
-	STREAMED_SOUND_MISSION_BUST_22,
-	STREAMED_SOUND_MISSION_BUST_23,
-	STREAMED_SOUND_MISSION_BUST_24,
-	STREAMED_SOUND_MISSION_BUST_25,
-	STREAMED_SOUND_MISSION_BUST_26,
-	STREAMED_SOUND_MISSION_BUST_27,
-	STREAMED_SOUND_MISSION_BUST_28,
 	TOTAL_STREAMED_SOUNDS,
 	NO_TRACK,
 };
diff --git a/src/audio/sampman.h b/src/audio/sampman.h
index 2db29244..7597eafb 100644
--- a/src/audio/sampman.h
+++ b/src/audio/sampman.h
@@ -278,109 +278,72 @@ static char StreamedNameTable[][25] = {
 #elif defined(PS2_AUDIO_PATHS)
 static char StreamedNameTable[][40] =
 {
-	"AUDIO\\MUSIC\\WILD.VB",
+	"AUDIO\\MUSIC\\HEAD.VB",
+	"AUDIO\\MUSIC\\DOUBLE.VB",
+	"AUDIO\\MUSIC\\KJAH.VB",
+	"AUDIO\\MUSIC\\RISE.VB",
+	"AUDIO\\MUSIC\\LIPS.VB",
+	"AUDIO\\MUSIC\\MUNDO.VB",
+	"AUDIO\\MUSIC\\MSX.VB",
 	"AUDIO\\MUSIC\\FLASH.VB",
-	"AUDIO\\MUSIC\\KCHAT.VB", // 16 khz
-	"AUDIO\\MUSIC\\FEVER.VB",
-	"AUDIO\\MUSIC\\VROCK.VB",
-	"AUDIO\\MUSIC\\VCPR.VB", // 16 khz
-	"AUDIO\\MUSIC\\ESPANT.VB",
-	"AUDIO\\MUSIC\\EMOTION.VB",
-	"AUDIO\\MUSIC\\WAVE.VB",
-	"AUDIO\\MUSIC\\MISCOM.VB",
+	"AUDIO\\MUSIC\\LCJ.VB",
+	"AUDIO\\MUSIC\\LCFR.VB",
+	"AUDIO\\MUSIC\\MISCOM2.VB",
 	"AUDIO\\MUSIC\\CITY.VB",
 	"AUDIO\\MUSIC\\WATER.VB",
-	"AUDIO\\MUSIC\\BEACHAMB.VB",
-	"AUDIO\\MUSIC\\HCITY.VB",
-	"AUDIO\\MUSIC\\HWATER.VB",
-	"AUDIO\\MUSIC\\HBEACH.VB",
-	"AUDIO\\MUSIC\\MALLAMB.VB",
-	"AUDIO\\MUSIC\\STRIP.VB",
-	"AUDIO\\MUSIC\\MALIBU.VB",
-	"AUDIO\\MUSIC\\HOTEL.VB",
-	"AUDIO\\MUSIC\\DIRTRING.VB",
-	"AUDIO\\MUSIC\\LAW4RIOT.VB",
-	"AUDIO\\MUSIC\\AMBSIL.VB",
-	"AUDIO\\MUSIC\\POLICE.VB", // 16 khz
+	"AUDIO\\MUSIC\\SAWMILL.VB",
+	"AUDIO\\MUSIC\\CITY.VB",
+	"AUDIO\\MUSIC\\WATER.VB",
+	"AUDIO\\MUSIC\\WATER.VB",
+	"AUDIO\\MUSIC\\CITY.VB",
+	"AUDIO\\MUSIC\\CITY.VB",
+	"AUDIO\\MUSIC\\CITY.VB",
+	"AUDIO\\MUSIC\\CITY.VB",
+	"AUDIO\\MUSIC\\CITY.VB",
+	"AUDIO\\MUSIC\\CITY.VB",
+	"AUDIO\\MUSIC\\CITY.VB",
+	"AUDIO\\MUSIC\\POLICE.VB",
 	"AUDIO\\MUSIC\\TAXI.VB",
-	"AUDIO\\MUSIC\\BCLOSED.VB",
-	"AUDIO\\MUSIC\\BOPEN.VB",
-	"AUDIO\\CUTSCENE\\ASS\\ASS_1.VB",
-	"AUDIO\\CUTSCENE\\ASS\\ASS_2.VB",
-	"AUDIO\\CUTSCENE\\BANK\\BANK_1.VB",
-	"AUDIO\\CUTSCENE\\BANK\\BANK_2A.VB",
-	"AUDIO\\CUTSCENE\\BANK\\BANK_2B.VB",
-	"AUDIO\\CUTSCENE\\BANK\\BANK_3A.VB",
-	"AUDIO\\CUTSCENE\\BANK\\BANK_3B.VB",
-	"AUDIO\\CUTSCENE\\BANK\\BANK_4.VB",
-	"AUDIO\\CUTSCENE\\BIKE\\BIKE_1.VB",
-	"AUDIO\\CUTSCENE\\BIKE\\BIKE_2.VB",
-	"AUDIO\\CUTSCENE\\BIKE\\BIKE_3.VB",
-	"AUDIO\\CUTSCENE\\BUD\\BUD_1.VB",
-	"AUDIO\\CUTSCENE\\BUD\\BUD_2.VB",
-	"AUDIO\\CUTSCENE\\BUD\\BUD_3.VB",
-	"AUDIO\\CUTSCENE\\CAP\\CAP_1.VB",
-	"AUDIO\\CUTSCENE\\CAR\\CAR_1.VB",
-	"AUDIO\\CUTSCENE\\CNT\\CNT_1A.VB",
-	"AUDIO\\CUTSCENE\\CNT\\CNT_1B.VB",
-	"AUDIO\\CUTSCENE\\CNT\\CNT_2.VB",
-	"AUDIO\\CUTSCENE\\COK\\COK_1.VB",
-	"AUDIO\\CUTSCENE\\COK\\COK_2A.VB",
-	"AUDIO\\CUTSCENE\\COK\\COK_2B.VB",
-	"AUDIO\\CUTSCENE\\COK\\COK_3.VB",
-	"AUDIO\\CUTSCENE\\COK\\COK_4A.VB",
-	"AUDIO\\CUTSCENE\\COK\\COK_4A2.VB",
-	"AUDIO\\CUTSCENE\\COK\\COK_4B.VB",
-	"AUDIO\\CUTSCENE\\COL\\COL_1.VB",
-	"AUDIO\\CUTSCENE\\COL\\COL_2.VB",
-	"AUDIO\\CUTSCENE\\COL\\COL_3A.VB",
-	"AUDIO\\CUTSCENE\\COL\\COL_4A.VB",
-	"AUDIO\\CUTSCENE\\COL\\COL_5A.VB",
-	"AUDIO\\CUTSCENE\\COL\\COL_5B.VB",
-	"AUDIO\\CUTSCENE\\CUB\\CUB_1.VB",
-	"AUDIO\\CUTSCENE\\CUB\\CUB_2.VB",
-	"AUDIO\\CUTSCENE\\CUB\\CUB_3.VB",
-	"AUDIO\\CUTSCENE\\CUB\\CUB_4.VB",
-	"AUDIO\\CUTSCENE\\DRUG\\DRUG_1.VB",
-	"AUDIO\\CUTSCENE\\FIN\\FIN.VB",
-	"AUDIO\\CUTSCENE\\FIN\\FIN2.VB",
-	"AUDIO\\CUTSCENE\\FINALE\\FINALE.VB",
-	"AUDIO\\CUTSCENE\\HAT\\HAT_1.VB",
-	"AUDIO\\CUTSCENE\\HAT\\HAT_2.VB",
-	"AUDIO\\CUTSCENE\\HAT\\HAT_3.VB",
-	"AUDIO\\CUTSCENE\\ICE\\ICE_1.VB",
-	"AUDIO\\CUTSCENE\\INT\\INT_A.VB",
-	"AUDIO\\CUTSCENE\\INT\\INT_B.VB",
-	"AUDIO\\CUTSCENE\\INT\\INT_D.VB",
-	"AUDIO\\CUTSCENE\\INT\\INT_M.VB",
-	"AUDIO\\CUTSCENE\\LAW\\LAW_1A.VB",
-	"AUDIO\\CUTSCENE\\LAW\\LAW_1B.VB",
-	"AUDIO\\CUTSCENE\\LAW\\LAW_2A.VB",
-	"AUDIO\\CUTSCENE\\LAW\\LAW_2B.VB",
-	"AUDIO\\CUTSCENE\\LAW\\LAW_2C.VB",
-	"AUDIO\\CUTSCENE\\LAW\\LAW_3.VB",
-	"AUDIO\\CUTSCENE\\LAW\\LAW_4.VB",
-	"AUDIO\\CUTSCENE\\PHIL\\PHIL_1.VB",
-	"AUDIO\\CUTSCENE\\PHIL\\PHIL_2.VB",
-	"AUDIO\\CUTSCENE\\PORN\\PORN_1.VB",
-	"AUDIO\\CUTSCENE\\PORN\\PORN_2.VB",
-	"AUDIO\\CUTSCENE\\PORN\\PORN_3.VB",
-	"AUDIO\\CUTSCENE\\PORN\\PORN_4.VB",
-	"AUDIO\\CUTSCENE\\RESC\\RESC_1A.VB",
-	"AUDIO\\CUTSCENE\\ROK\\ROK_1.VB",
-	"AUDIO\\CUTSCENE\\ROK\\ROK_2.VB",
-	"AUDIO\\CUTSCENE\\ROK\\ROK_3A.VB",
-	"AUDIO\\CUTSCENE\\STRIPA\\STRIPA.VB",
-	"AUDIO\\CUTSCENE\\TAX\\TAX_1.VB",
-	"AUDIO\\CUTSCENE\\TEX\\TEX_1.VB",
-	"AUDIO\\CUTSCENE\\TEX\\TEX_2.VB",
-	"AUDIO\\CUTSCENE\\TEX\\TEX_3.VB",
-	"AUDIO\\MUSIC\\GLIGHT.VB",
-	"AUDIO\\MUSIC\\FIST.VB",
-	"AUDIO\\MUSIC\\MISCOM.VB",
-	"AUDIO\\MUSIC\\MISCOM.VB",
-	"AUDIO\\MUSIC\\MISCOM.VB",
-	"AUDIO\\MUSIC\\MISCOM.VB",
+	"AUDIO\\NEWS\\NEWS_A.VB",
+	"AUDIO\\NEWS\\NEWS_B.VB",
+	"AUDIO\\NEWS\\NEWS_C.VB",
+	"AUDIO\\NEWS\\NEWS_D.VB",
+	"AUDIO\\NEWS\\NEWS_E.VB",
+	"AUDIO\\NEWS\\NEWS_F.VB",
+	"AUDIO\\NEWS\\NEWS_G.VB",
+	"AUDIO\\NEWS\\NEWS_H.VB",
+	"AUDIO\\NEWS\\NEWS_I.VB",
+	"AUDIO\\NEWS\\NEWS_J.VB",
+	"AUDIO\\NEWS\\NEWS_K.VB",
+	"AUDIO\\NEWS\\NEWS_L.VB",
+	"AUDIO\\NEWS\\NEWS_M.VB",
+	"AUDIO\\NEWS\\NEWS_N.VB",
+	"AUDIO\\CUTSCENE\\BIKER.VB",
+	"AUDIO\\CUTSCENE\\BONEVOY.VB",
+	"AUDIO\\CUTSCENE\\CAMPAIN.VB",
+	"AUDIO\\CUTSCENE\\CASHCHP.VB",
+	"AUDIO\\CUTSCENE\\CONTBAN.VB",
+	"AUDIO\\CUTSCENE\\CRAZY69.VB",
+	"AUDIO\\CUTSCENE\\CRAZY69.VB",
+	"AUDIO\\CUTSCENE\\DEADLY.VB",
+	"AUDIO\\CUTSCENE\\DONPROB.VB",
+	"AUDIO\\CUTSCENE\\DRIVNMR.VB",
+	"AUDIO\\CUTSCENE\\ELECTON.VB",
+	"AUDIO\\CUTSCENE\\FINAL.VB",
+	"AUDIO\\CUTSCENE\\FINAL_2.VB",
+	"AUDIO\\CUTSCENE\\HOMSWET.VB",
+	"AUDIO\\CUTSCENE\\HOTWHEL.VB",
+	"AUDIO\\CUTSCENE\\KIDNAPP.VB",
+	"AUDIO\\CUTSCENE\\LANDGRB.VB",
+	"AUDIO\\CUTSCENE\\MORGUE.VB",
+	"AUDIO\\CUTSCENE\\OVERDOS.VB",
+	"AUDIO\\CUTSCENE\\RUFJUST.VB",
+	"AUDIO\\CUTSCENE\\SAYONAR.VB",
+	"AUDIO\\CUTSCENE\\SICILAN.VB",
+	"AUDIO\\CUTSCENE\\THEOFER.VB",
+	"AUDIO\\CUTSCENE\\INTRO.VB",
+	"AUDIO\\MUSIC\\FINALE.VB",
+	"AUDIO\\MUSIC\\MISCOM2.VB"
 #else
 static char StreamedNameTable[][25] =
 {
@@ -488,1125 +451,5 @@ static char StreamedNameTable[][25] =
 	"AUDIO\\MISCOM.MP3",
 	"AUDIO\\MISCOM.MP3",
 #endif
-	"AUDIO\\MOBR1.WAV",
-	"AUDIO\\PAGER.WAV",
-	"AUDIO\\CARREV.WAV",
-	"AUDIO\\BIKEREV.WAV",
-	"AUDIO\\LIFTOP.WAV",
-	"AUDIO\\LIFTCL.WAV",
-	"AUDIO\\LIFTRUN.WAV",
-	"AUDIO\\LIFTBEL.WAV",
-	"AUDIO\\INLIFT.WAV",
-	"AUDIO\\SFX_01.WAV",
-	"AUDIO\\SFX_02.WAV",
-	"AUDIO\\CAMERAL.WAV",
-	"AUDIO\\CAMERAR.WAV",
-	"AUDIO\\CHEER1.WAV",
-	"AUDIO\\CHEER2.WAV",
-	"AUDIO\\CHEER3.WAV",
-	"AUDIO\\CHEER4.WAV",
-	"AUDIO\\OOH1.WAV",
-	"AUDIO\\OOH2.WAV",
-	"AUDIO\\RACE1.WAV",
-	"AUDIO\\RACE2.WAV",
-	"AUDIO\\RACE3.WAV",
-	"AUDIO\\RACE4.WAV",
-	"AUDIO\\RACE5.WAV",
-	"AUDIO\\RACE6.WAV",
-	"AUDIO\\RACE7.WAV",
-	"AUDIO\\RACE8.WAV",
-	"AUDIO\\RACE9.WAV",
-	"AUDIO\\RACE10.WAV",
-	"AUDIO\\RACE11.WAV",
-	"AUDIO\\RACE12.WAV",
-	"AUDIO\\RACE13.WAV",
-	"AUDIO\\RACE14.WAV",
-	"AUDIO\\RACE15.WAV",
-	"AUDIO\\HOT1.WAV",
-	"AUDIO\\HOT2.WAV",
-	"AUDIO\\HOT3.WAV",
-	"AUDIO\\HOT4.WAV",
-	"AUDIO\\HOT5.WAV",
-	"AUDIO\\HOT6.WAV",
-	"AUDIO\\HOT7.WAV",
-	"AUDIO\\HOT8.WAV",
-	"AUDIO\\HOT9.WAV",
-	"AUDIO\\HOT10.WAV",
-	"AUDIO\\HOT11.WAV",
-	"AUDIO\\HOT12.WAV",
-	"AUDIO\\HOT13.WAV",
-	"AUDIO\\HOT14.WAV",
-	"AUDIO\\HOT15.WAV",
-	"AUDIO\\LANSTP1.WAV",
-	"AUDIO\\LANSTP2.WAV",
-	"AUDIO\\LANAMU1.WAV",
-	"AUDIO\\LANAMU2.WAV",
-	"AUDIO\\AIRHORNL.WAV",
-	"AUDIO\\AIRHORNR.WAV",
-	"AUDIO\\SNIPSCRL.WAV",
-	"AUDIO\\SNIPSHORT.WAV",
-	"AUDIO\\BLOWROOF.WAV",
-	"AUDIO\\ASS_1.WAV",
-	"AUDIO\\ASS_2.WAV",
-	"AUDIO\\ASS_3.WAV",
-	"AUDIO\\ASS_4.WAV",
-	"AUDIO\\ASS_5.WAV",
-	"AUDIO\\ASS_6.WAV",
-	"AUDIO\\ASS_7.WAV",
-	"AUDIO\\ASS_8.WAV",
-	"AUDIO\\ASS_9.WAV",
-	"AUDIO\\ASS_10.WAV",
-	"AUDIO\\ASS_11.WAV",
-	"AUDIO\\ASS_12.WAV",
-	"AUDIO\\ASS_13.WAV",
-	"AUDIO\\ASS_14.WAV",
-	"AUDIO\\BIKE1_1.WAV",
-	"AUDIO\\BIKE1_2.WAV",
-	"AUDIO\\BIKE1_3.WAV",
-	"AUDIO\\BNK1_1.WAV",
-	"AUDIO\\BNK1_2.WAV",
-	"AUDIO\\BNK1_3.WAV",
-	"AUDIO\\BNK1_4.WAV",
-	"AUDIO\\BNK1_5.WAV",
-	"AUDIO\\BNK1_6.WAV",
-	"AUDIO\\BNK1_7.WAV",
-	"AUDIO\\BNK1_8.WAV",
-	"AUDIO\\BNK1_10.WAV",
-	"AUDIO\\BNK1_11.WAV",
-	"AUDIO\\BNK1_12.WAV",
-	"AUDIO\\BNK1_13.WAV",
-	"AUDIO\\BNK1_14.WAV",
-	"AUDIO\\BNK2_1.WAV",
-	"AUDIO\\BNK2_2.WAV",
-	"AUDIO\\BNK2_3.WAV",
-	"AUDIO\\BNK2_4.WAV",
-	"AUDIO\\BNK2_5.WAV",
-	"AUDIO\\BNK2_6.WAV",
-	"AUDIO\\BNK2_7.WAV",
-	"AUDIO\\BNK2_8.WAV",
-	"AUDIO\\BNK2_9.WAV",
-	"AUDIO\\BNK3_1.WAV",
-	"AUDIO\\BNK3_2.WAV",
-	"AUDIO\\BNK3_3A.WAV",
-	"AUDIO\\BNK3_3B.WAV",
-	"AUDIO\\BNK3_3C.WAV",
-	"AUDIO\\BNK3_4A.WAV",
-	"AUDIO\\BNK3_4B.WAV",
-	"AUDIO\\BNK3_4C.WAV",
-	"AUDIO\\BNK4_1.WAV",
-	"AUDIO\\BNK4_2.WAV",
-	"AUDIO\\BNK4_3A.WAV",
-	"AUDIO\\BNK4_3B.WAV",
-	"AUDIO\\BNK4_3C.WAV",
-	"AUDIO\\BNK4_3D.WAV",
-	"AUDIO\\BNK4_3E.WAV",
-	"AUDIO\\BNK4_3F.WAV",
-	"AUDIO\\BNK4_3G.WAV",
-	"AUDIO\\BNK4_3H.WAV",
-	"AUDIO\\BNK4_3I.WAV",
-	"AUDIO\\BNK4_3J.WAV",
-	"AUDIO\\BNK4_3K.WAV",
-	"AUDIO\\BNK4_3M.WAV",
-	"AUDIO\\BNK4_3O.WAV",
-	"AUDIO\\BNK4_3P.WAV",
-	"AUDIO\\BNK4_3Q.WAV",
-	"AUDIO\\BNK4_3R.WAV",
-	"AUDIO\\BNK4_3S.WAV",
-	"AUDIO\\BNK4_3T.WAV",
-	"AUDIO\\BNK4_3U.WAV",
-	"AUDIO\\BNK4_3V.WAV",
-	"AUDIO\\BNK4_4A.WAV",
-	"AUDIO\\BNK4_4B.WAV",
-	"AUDIO\\BNK4_5.WAV",
-	"AUDIO\\BNK4_6.WAV",
-	"AUDIO\\BNK4_7.WAV",
-	"AUDIO\\BNK4_8.WAV",
-	"AUDIO\\BNK4_9.WAV",
-	"AUDIO\\BNK4_10.WAV",
-	"AUDIO\\BNK4_11.WAV",
-	"AUDIO\\BK4_12A.WAV",
-	"AUDIO\\BK4_12B.WAV",
-	"AUDIO\\BK4_12C.WAV",
-	"AUDIO\\BNK4_13.WAV",
-	"AUDIO\\BK4_14A.WAV",
-	"AUDIO\\BK4_14B.WAV",
-	"AUDIO\\BNK4_15.WAV",
-	"AUDIO\\BNK4_16.WAV",
-	"AUDIO\\BNK4_17.WAV",
-	"AUDIO\\BNK4_18.WAV",
-	"AUDIO\\BK4_19A.WAV",
-	"AUDIO\\BK4_19B.WAV",
-	"AUDIO\\BK4_20A.WAV",
-	"AUDIO\\BK4_20B.WAV",
-	"AUDIO\\BNK4_21.WAV",
-	"AUDIO\\BNK422A.WAV",
-	"AUDIO\\BNK422B.WAV",
-	"AUDIO\\BK4_23A.WAV",
-	"AUDIO\\BK4_23B.WAV",
-	"AUDIO\\BK4_23C.WAV",
-	"AUDIO\\BK4_23D.WAV",
-	"AUDIO\\BK4_24A.WAV",
-	"AUDIO\\BK4_24B.WAV",
-	"AUDIO\\BNK4_25.WAV",
-	"AUDIO\\BNK4_26.WAV",
-	"AUDIO\\BNK4_27.WAV",
-	"AUDIO\\BNK4_28.WAV",
-	"AUDIO\\BNK4_29.WAV",
-	"AUDIO\\BNK4_30.WAV",
-	"AUDIO\\BK4_31A.WAV",
-	"AUDIO\\BK4_31B.WAV",
-	"AUDIO\\BNK4_32.WAV",
-	"AUDIO\\BK4_34A.WAV",
-	"AUDIO\\BK4_34B.WAV",
-	"AUDIO\\BK4_35A.WAV",
-	"AUDIO\\BK4_35B.WAV",
-	"AUDIO\\BNK4_36.WAV",
-	"AUDIO\\BNK4_37.WAV",
-	"AUDIO\\BNK4_38.WAV",
-	"AUDIO\\BNK4_39.WAV",
-	"AUDIO\\BK4_40A.WAV",
-	"AUDIO\\BK4_40B.WAV",
-	"AUDIO\\BNK4_41.WAV",
-	"AUDIO\\BNK4_42.WAV",
-	"AUDIO\\BNK4_43.WAV",
-	"AUDIO\\BNK4_44.WAV",
-	"AUDIO\\BNK4_45.WAV",
-	"AUDIO\\BNK4_46.WAV",
-	"AUDIO\\BNK4_47.WAV",
-	"AUDIO\\BNK4_48.WAV",
-	"AUDIO\\BNK4_49.WAV",
-	"AUDIO\\BNK450A.WAV",
-	"AUDIO\\BNK450B.WAV",
-	"AUDIO\\BNK4_51.WAV",
-	"AUDIO\\BNK4_94.WAV",
-	"AUDIO\\BNK4_95.WAV",
-	"AUDIO\\BNK4_96.WAV",
-	"AUDIO\\BNK4_97.WAV",
-	"AUDIO\\BNK4_98.WAV",
-	"AUDIO\\BNK4_99.WAV",
-	"AUDIO\\BUD1_1.WAV",
-	"AUDIO\\BUD1_2.WAV",
-	"AUDIO\\BUD1_3.WAV",
-	"AUDIO\\BUD1_4.WAV",
-	"AUDIO\\BUD1_5.WAV",
-	"AUDIO\\BUD1_9.WAV",
-	"AUDIO\\BUD1_10.WAV",
-	"AUDIO\\BUD2_1.WAV",
-	"AUDIO\\BUD2_2.WAV",
-	"AUDIO\\BUD2_3.WAV",
-	"AUDIO\\BUD2_4.WAV",
-	"AUDIO\\BUD2_5.WAV",
-	"AUDIO\\BUD2_6.WAV",
-	"AUDIO\\BUD2_7.WAV",
-	"AUDIO\\BUD3_1.WAV",
-	"AUDIO\\BUD3_1A.WAV",
-	"AUDIO\\BUD3_1B.WAV",
-	"AUDIO\\BUD3_1C.WAV",
-	"AUDIO\\BUD3_2.WAV",
-	"AUDIO\\BUD3_3.WAV",
-	"AUDIO\\BUD3_4.WAV",
-	"AUDIO\\BUD3_5.WAV",
-	"AUDIO\\BUD3_6.WAV",
-	"AUDIO\\BUD3_7.WAV",
-	"AUDIO\\BUD3_8A.WAV",
-	"AUDIO\\BUD3_8B.WAV",
-	"AUDIO\\BUD3_8C.WAV",
-	"AUDIO\\BUD3_9A.WAV",
-	"AUDIO\\BUD3_9B.WAV",
-	"AUDIO\\BUD3_9C.WAV",
-	"AUDIO\\CAP1_2.WAV",
-	"AUDIO\\CAP1_3.WAV",
-	"AUDIO\\CAP1_4.WAV",
-	"AUDIO\\CAP1_5.WAV",
-	"AUDIO\\CAP1_6.WAV",
-	"AUDIO\\CAP1_7.WAV",
-	"AUDIO\\CAP1_8.WAV",
-	"AUDIO\\CAP1_9.WAV",
-	"AUDIO\\CAP1_10.WAV",
-	"AUDIO\\CAP1_11.WAV",
-	"AUDIO\\CAP1_12.WAV",
-	"AUDIO\\CNT1_1.WAV",
-	"AUDIO\\CNT1_2.WAV",
-	"AUDIO\\CNT1_3.WAV",
-	"AUDIO\\CNT1_4.WAV",
-	"AUDIO\\CNT1_5.WAV",
-	"AUDIO\\CNT2_1.WAV",
-	"AUDIO\\CNT2_2.WAV",
-	"AUDIO\\CNT2_3.WAV",
-	"AUDIO\\CNT2_4.WAV",
-	"AUDIO\\COK1_1.WAV",
-	"AUDIO\\COK1_2.WAV",
-	"AUDIO\\COK1_3.WAV",
-	"AUDIO\\COK1_4.WAV",
-	"AUDIO\\COK1_5.WAV",
-	"AUDIO\\COK1_6.WAV",
-	"AUDIO\\COK2_1.WAV",
-	"AUDIO\\COK2_2.WAV",
-	"AUDIO\\COK2_3.WAV",
-	"AUDIO\\COK2_4.WAV",
-	"AUDIO\\COK2_5.WAV",
-	"AUDIO\\COK2_6.WAV",
-	"AUDIO\\COK2_7A.WAV",
-	"AUDIO\\COK2_7B.WAV",
-	"AUDIO\\COK2_7C.WAV",
-	"AUDIO\\COK2_8A.WAV",
-	"AUDIO\\COK2_8B.WAV",
-	"AUDIO\\COK2_8C.WAV",
-	"AUDIO\\COK2_8D.WAV",
-	"AUDIO\\COK2_9.WAV",
-	"AUDIO\\COK210A.WAV",
-	"AUDIO\\COK210B.WAV",
-	"AUDIO\\COK210C.WAV",
-	"AUDIO\\COK212A.WAV",
-	"AUDIO\\COK212B.WAV",
-	"AUDIO\\COK2_13.WAV",
-	"AUDIO\\COK2_14.WAV",
-	"AUDIO\\COK2_15.WAV",
-	"AUDIO\\COK2_16.WAV",
-	"AUDIO\\COK2_20.WAV",
-	"AUDIO\\COK2_21.WAV",
-	"AUDIO\\COK2_2.WAV", // this is probably a typo of COK2_22
-	"AUDIO\\COK3_1.WAV",
-	"AUDIO\\COK3_2.WAV",
-	"AUDIO\\COK3_3.WAV",
-	"AUDIO\\COK3_4.WAV",
-	"AUDIO\\COK4_1.WAV",
-	"AUDIO\\COK4_2.WAV",
-	"AUDIO\\COK4_3.WAV",
-	"AUDIO\\COK4_4.WAV",
-	"AUDIO\\COK4_5.WAV",
-	"AUDIO\\COK4_6.WAV",
-	"AUDIO\\COK4_7.WAV",
-	"AUDIO\\COK4_8.WAV",
-	"AUDIO\\COK4_9.WAV",
-	"AUDIO\\COK4_9A.WAV",
-	"AUDIO\\COK4_10.WAV",
-	"AUDIO\\COK4_11.WAV",
-	"AUDIO\\COK4_12.WAV",
-	"AUDIO\\COK4_13.WAV",
-	"AUDIO\\COK4_14.WAV",
-	"AUDIO\\COK4_15.WAV",
-	"AUDIO\\COK4_16.WAV",
-	"AUDIO\\COK4_17.WAV",
-	"AUDIO\\COK4_18.WAV",
-	"AUDIO\\COK4_19.WAV",
-	"AUDIO\\COK4_20.WAV",
-	"AUDIO\\COK4_21.WAV",
-	"AUDIO\\COK4_22.WAV",
-	"AUDIO\\COK4_23.WAV",
-	"AUDIO\\COK4_24.WAV",
-	"AUDIO\\COK4_25.WAV",
-	"AUDIO\\COK4_26.WAV",
-	"AUDIO\\COK4_27.WAV",
-	"AUDIO\\COL1_1.WAV",
-	"AUDIO\\COL1_2.WAV",
-	"AUDIO\\COL1_3.WAV",
-	"AUDIO\\COL1_4.WAV",
-	"AUDIO\\COL1_5.WAV",
-	"AUDIO\\COL1_6.WAV",
-	"AUDIO\\COL1_7.WAV",
-	"AUDIO\\COL1_8.WAV",
-	"AUDIO\\COL2_1.WAV",
-	"AUDIO\\COL2_2.WAV",
-	"AUDIO\\COL2_3.WAV",
-	"AUDIO\\COL2_4.WAV",
-	"AUDIO\\COL2_5.WAV",
-	"AUDIO\\COL2_6A.WAV",
-	"AUDIO\\COL2_7.WAV",
-	"AUDIO\\COL2_8.WAV",
-	"AUDIO\\COL2_9.WAV",
-	"AUDIO\\COL2_10.WAV",
-	"AUDIO\\COL2_11.WAV",
-	"AUDIO\\COL2_12.WAV",
-	"AUDIO\\COL2_13.WAV",
-	"AUDIO\\COL2_14.WAV",
-	"AUDIO\\COL2_15.WAV",
-	"AUDIO\\COL2_16.WAV",
-	"AUDIO\\COL3_1.WAV",
-	"AUDIO\\COL3_2.WAV",
-	"AUDIO\\COL3_2A.WAV",
-	"AUDIO\\COL3_2B.WAV",
-	"AUDIO\\COL3_3.WAV",
-	"AUDIO\\COL3_4.WAV",
-	"AUDIO\\COL3_5.WAV",
-	"AUDIO\\COL3_6.WAV",
-	"AUDIO\\COL3_7.WAV",
-	"AUDIO\\COL3_8.WAV",
-	"AUDIO\\COL3_9.WAV",
-	"AUDIO\\COL3_10.WAV",
-	"AUDIO\\COL3_11.WAV",
-	"AUDIO\\COL3_12.WAV",
-	"AUDIO\\COL3_13.WAV",
-	"AUDIO\\COL3_14.WAV",
-	"AUDIO\\COL3_15.WAV",
-	"AUDIO\\COL3_16.WAV",
-	"AUDIO\\COL3_17.WAV",
-	"AUDIO\\COL3_18.WAV",
-	"AUDIO\\COL3_19.WAV",
-	"AUDIO\\COL3_20.WAV",
-	"AUDIO\\COL3_21.WAV",
-	"AUDIO\\COL3_23.WAV",
-	"AUDIO\\COL3_24.WAV",
-	"AUDIO\\COL3_25.WAV",
-	"AUDIO\\COL4_1.WAV",
-	"AUDIO\\COL4_2.WAV",
-	"AUDIO\\COL4_3.WAV",
-	"AUDIO\\COL4_4.WAV",
-	"AUDIO\\COL4_5.WAV",
-	"AUDIO\\COL4_6.WAV",
-	"AUDIO\\COL4_7.WAV",
-	"AUDIO\\COL4_8.WAV",
-	"AUDIO\\COL4_9.WAV",
-	"AUDIO\\COL4_10.WAV",
-	"AUDIO\\COL4_11.WAV",
-	"AUDIO\\COL4_12.WAV",
-	"AUDIO\\COL4_13.WAV",
-	"AUDIO\\COL4_14.WAV",
-	"AUDIO\\COL4_15.WAV",
-	"AUDIO\\COL4_16.WAV",
-	"AUDIO\\COL4_17.WAV",
-	"AUDIO\\COL4_18.WAV",
-	"AUDIO\\COL4_19.WAV",
-	"AUDIO\\COL4_20.WAV",
-	"AUDIO\\COL4_21.WAV",
-	"AUDIO\\COL4_22.WAV",
-	"AUDIO\\COL4_23.WAV",
-	"AUDIO\\COL4_24.WAV",
-	"AUDIO\\COL4_25.WAV",
-	"AUDIO\\COL4_26.WAV",
-	"AUDIO\\COL5_1.WAV",
-	"AUDIO\\COL5_2.WAV",
-	"AUDIO\\COL5_3.WAV",
-	"AUDIO\\COL5_4.WAV",
-	"AUDIO\\COL5_5.WAV",
-	"AUDIO\\COL5_6.WAV",
-	"AUDIO\\COL5_7.WAV",
-	"AUDIO\\COL5_8.WAV",
-	"AUDIO\\COL5_9.WAV",
-	"AUDIO\\COL5_10.WAV",
-	"AUDIO\\COL5_11.WAV",
-	"AUDIO\\COL5_12.WAV",
-	"AUDIO\\COL5_13.WAV",
-	"AUDIO\\COL5_14.WAV",
-	"AUDIO\\COL5_15.WAV",
-	"AUDIO\\COL5_16.WAV",
-	"AUDIO\\COL5_17.WAV",
-	"AUDIO\\COL5_18.WAV",
-	"AUDIO\\COL5_19.WAV",
-	"AUDIO\\COL5_20.WAV",
-	"AUDIO\\COL5_21.WAV",
-	"AUDIO\\COL5_22.WAV",
-	"AUDIO\\CUB1_1.WAV",
-	"AUDIO\\CUB1_2.WAV",
-	"AUDIO\\CUB1_3.WAV",
-	"AUDIO\\CUB1_4.WAV",
-	"AUDIO\\CUB1_5.WAV",
-	"AUDIO\\CUB1_6.WAV",
-	"AUDIO\\CUB1_7.WAV",
-	"AUDIO\\CUB1_8.WAV",
-	"AUDIO\\CUB1_9.WAV",
-	"AUDIO\\CUB1_10.WAV",
-	"AUDIO\\CUB2_1.WAV",
-	"AUDIO\\CUB2_2.WAV",
-	"AUDIO\\CUB2_3A.WAV",
-	"AUDIO\\CUB2_3B.WAV",
-	"AUDIO\\CUB2_3C.WAV",
-	"AUDIO\\CUB2_4A.WAV",
-	"AUDIO\\CUB2_5.WAV",
-	"AUDIO\\CUB2_6.WAV",
-	"AUDIO\\CUB2_7.WAV",
-	"AUDIO\\CUB2_8.WAV",
-	"AUDIO\\CUB2_9.WAV",
-	"AUDIO\\CUB2_10.WAV",
-	"AUDIO\\CUB2_11.WAV",
-	"AUDIO\\CUB3_1.WAV",
-	"AUDIO\\CUB3_2.WAV",
-	"AUDIO\\CUB3_3.WAV",
-	"AUDIO\\CUB3_4.WAV",
-	"AUDIO\\CUB4_1.WAV",
-	"AUDIO\\CUB4_2.WAV",
-	"AUDIO\\CUB4_3.WAV",
-	"AUDIO\\CUB4_4.WAV",
-	"AUDIO\\CUB4_5.WAV",
-	"AUDIO\\CUB4_5A.WAV",
-	"AUDIO\\CUB4_6.WAV",
-	"AUDIO\\CUB4_7.WAV",
-	"AUDIO\\CUB4_8.WAV",
-	"AUDIO\\CUB4_9.WAV",
-	"AUDIO\\CUB4_10.WAV",
-	"AUDIO\\CUB4_11.WAV",
-	"AUDIO\\CUB4_12.WAV",
-	"AUDIO\\CUB4_13.WAV",
-	"AUDIO\\CUB4_14.WAV",
-	"AUDIO\\CUB4_15.WAV",
-	"AUDIO\\CUB4_16.WAV",
-	"AUDIO\\GOLF_1.WAV",
-	"AUDIO\\GOLF_2.WAV",
-	"AUDIO\\GOLF_3.WAV",
-	"AUDIO\\BAR_1.WAV",
-	"AUDIO\\BAR_2.WAV",
-	"AUDIO\\BAR_3.WAV",
-	"AUDIO\\BAR_4.WAV",
-	"AUDIO\\BAR_5.WAV",
-	"AUDIO\\BAR_6.WAV",
-	"AUDIO\\BAR_7.WAV",
-	"AUDIO\\BAR_8.WAV",
-	"AUDIO\\STRIP_1.WAV",
-	"AUDIO\\STRIP_2.WAV",
-	"AUDIO\\STRIP_3.WAV",
-	"AUDIO\\STRIP_4.WAV",
-	"AUDIO\\STRIP_5.WAV",
-	"AUDIO\\STRIP_6.WAV",
-	"AUDIO\\STRIP_7.WAV",
-	"AUDIO\\STRIP_8.WAV",
-	"AUDIO\\STRIP_9.WAV",
-	"AUDIO\\STAR_1.WAV",
-	"AUDIO\\STAR_2.WAV",
-	"AUDIO\\STAR_3.WAV",
-	"AUDIO\\STAR_4.WAV",
-	"AUDIO\\FIN_1A.WAV",
-	"AUDIO\\FIN_1B.WAV",
-	"AUDIO\\FIN_1C.WAV",
-	"AUDIO\\FIN_2B.WAV",
-	"AUDIO\\FIN_2C.WAV",
-	"AUDIO\\FIN_3.WAV",
-	"AUDIO\\FIN_4.WAV",
-	"AUDIO\\FIN_5.WAV",
-	"AUDIO\\FIN_6.WAV",
-	"AUDIO\\FIN_10.WAV",
-	"AUDIO\\FIN_11A.WAV",
-	"AUDIO\\FIN_11B.WAV",
-	"AUDIO\\FIN_12A.WAV",
-	"AUDIO\\FIN_12B.WAV",
-	"AUDIO\\FIN_12C.WAV",
-	"AUDIO\\FIN_13.WAV",
-	"AUDIO\\FINKILL.WAV",
-	"AUDIO\\LAW1_1.WAV",
-	"AUDIO\\LAW1_2.WAV",
-	"AUDIO\\LAW1_3.WAV",
-	"AUDIO\\LAW1_4.WAV",
-	"AUDIO\\LAW1_5.WAV",
-	"AUDIO\\LAW1_6.WAV",
-	"AUDIO\\LAW1_7.WAV",
-	"AUDIO\\LAW1_8.WAV",
-	"AUDIO\\LAW1_9.WAV",
-	"AUDIO\\LAW1_10.WAV",
-	"AUDIO\\LAW2_1.WAV",
-	"AUDIO\\LAW2_2.WAV",
-	"AUDIO\\LAW2_3.WAV",
-	"AUDIO\\LAW2_4.WAV",
-	"AUDIO\\LAW2_5.WAV",
-	"AUDIO\\LAW2_6.WAV",
-	"AUDIO\\LAW2_7.WAV",
-	"AUDIO\\LAW2_8.WAV",
-	"AUDIO\\LAW2_9.WAV",
-	"AUDIO\\LAW2_10.WAV",
-	"AUDIO\\LAW3_1.WAV",
-	"AUDIO\\LAW3_2.WAV",
-	"AUDIO\\LAW3_3.WAV",
-	"AUDIO\\LAW3_4.WAV",
-	"AUDIO\\LAW3_5.WAV",
-	"AUDIO\\LAW3_6.WAV",
-	"AUDIO\\LAW3_10.WAV",
-	"AUDIO\\LAW3_11.WAV",
-	"AUDIO\\LAW3_12.WAV",
-	"AUDIO\\LAW3_13.WAV",
-	"AUDIO\\LAW3_14.WAV",
-	"AUDIO\\LAW3_16.WAV",
-	"AUDIO\\LAW3_17.WAV",
-	"AUDIO\\LAW3_18.WAV",
-	"AUDIO\\LAW3_19.WAV",
-	"AUDIO\\LAW3_20.WAV",
-	"AUDIO\\LAW3_21.WAV",
-	"AUDIO\\LAW3_22.WAV",
-	"AUDIO\\LAW3_23.WAV",
-	"AUDIO\\LAW3_24.WAV",
-	"AUDIO\\LAW3_25.WAV",
-	"AUDIO\\LAW4_1A.WAV",
-	"AUDIO\\LAW4_1B.WAV",
-	"AUDIO\\LAW4_1C.WAV",
-	"AUDIO\\LAW4_1D.WAV",
-	"AUDIO\\LAW4_10.WAV",
-	"AUDIO\\LAW4_3.WAV",
-	"AUDIO\\LAW4_4.WAV",
-	"AUDIO\\LAW4_5.WAV",
-	"AUDIO\\LAW4_6.WAV",
-	"AUDIO\\LAW4_7.WAV",
-	"AUDIO\\LAW4_8.WAV",
-	"AUDIO\\LAW4_9.WAV",
-	"AUDIO\\PHIL1_2.WAV",
-	"AUDIO\\PHIL1_3.WAV",
-	"AUDIO\\PHIL2_1.WAV",
-	"AUDIO\\PHIL2_2.WAV",
-	"AUDIO\\PHIL2_3.WAV",
-	"AUDIO\\PHIL2_4.WAV",
-	"AUDIO\\PHIL2_5.WAV",
-	"AUDIO\\PHIL2_6.WAV",
-	"AUDIO\\PHIL2_7.WAV",
-	"AUDIO\\PHIL2_8.WAV",
-	"AUDIO\\PHIL2_9.WAV",
-	"AUDIO\\PHIL210.WAV",
-	"AUDIO\\PHIL211.WAV",
-	"AUDIO\\PORN1_1.WAV",
-	"AUDIO\\PORN1_2.WAV",
-	"AUDIO\\PORN1_3.WAV",
-	"AUDIO\\PRN1_3A.WAV",
-	"AUDIO\\PORN1_4.WAV",
-	"AUDIO\\PORN1_5.WAV",
-	"AUDIO\\PORN1_6.WAV",
-	"AUDIO\\PORN1_7.WAV",
-	"AUDIO\\PORN1_8.WAV",
-	"AUDIO\\PORN1_9.WAV",
-	"AUDIO\\PRN1_10.WAV",
-	"AUDIO\\PRN1_11.WAV",
-	"AUDIO\\PRN1_12.WAV",
-	"AUDIO\\PRN1_13.WAV",
-	"AUDIO\\PRN1_14.WAV",
-	"AUDIO\\PRN1_15.WAV",
-	"AUDIO\\PRN1_16.WAV",
-	"AUDIO\\PRN1_17.WAV",
-	"AUDIO\\PRN1_18.WAV",
-	"AUDIO\\PRN1_19.WAV",
-	"AUDIO\\PRN1_20.WAV",
-	"AUDIO\\PRN1_21.WAV",
-	"AUDIO\\PORN3_1.WAV",
-	"AUDIO\\PORN3_2.WAV",
-	"AUDIO\\PORN3_3.WAV",
-	"AUDIO\\PORN3_4.WAV",
-	"AUDIO\\PSYCH_1.WAV",
-	"AUDIO\\PSYCH_2.WAV",
-	"AUDIO\\ROK2_01.WAV",
-	"AUDIO\\ROK3_1.WAV",
-	"AUDIO\\ROK3_2.WAV",
-	"AUDIO\\ROK3_3.WAV",
-	"AUDIO\\ROK3_4.WAV",
-	"AUDIO\\ROK3_5.WAV",
-	"AUDIO\\ROK3_6.WAV",
-	"AUDIO\\ROK3_7.WAV",
-	"AUDIO\\ROK3_8.WAV",
-	"AUDIO\\ROK3_9.WAV",
-	"AUDIO\\ROK3_10.WAV",
-	"AUDIO\\ROK3_11.WAV",
-	"AUDIO\\ROK3_12.WAV",
-	"AUDIO\\ROK3_13.WAV",
-	"AUDIO\\ROK3_14.WAV",
-	"AUDIO\\ROK3_15.WAV",
-	"AUDIO\\ROK3_16.WAV",
-	"AUDIO\\ROK3_17.WAV",
-	"AUDIO\\ROK3_18.WAV",
-	"AUDIO\\ROK3_19.WAV",
-	"AUDIO\\ROK3_20.WAV",
-	"AUDIO\\ROK3_21.WAV",
-	"AUDIO\\ROK3_22.WAV",
-	"AUDIO\\ROK3_23.WAV",
-	"AUDIO\\ROK3_24.WAV",
-	"AUDIO\\ROK3_25.WAV",
-	"AUDIO\\ROK3_26.WAV",
-	"AUDIO\\ROK3_27.WAV",
-	"AUDIO\\ROK3_62.WAV",
-	"AUDIO\\ROK3_63.WAV",
-	"AUDIO\\ROK3_64.WAV",
-	"AUDIO\\ROK3_65.WAV",
-	"AUDIO\\ROK3_66.WAV",
-	"AUDIO\\ROK3_67.WAV",
-	"AUDIO\\ROK3_68.WAV",
-	"AUDIO\\ROK3_69.WAV",
-	"AUDIO\\ROK3_70.WAV",
-	"AUDIO\\ROK3_71.WAV",
-	"AUDIO\\ROK3_73.WAV",
-	"AUDIO\\RESC_1.WAV",
-	"AUDIO\\RESC_2.WAV",
-	"AUDIO\\RESC_3.WAV",
-	"AUDIO\\RESC_4.WAV",
-	"AUDIO\\RESC_5.WAV",
-	"AUDIO\\RESC_6.WAV",
-	"AUDIO\\RESC_7.WAV",
-	"AUDIO\\RESC_8.WAV",
-	"AUDIO\\RESC_9.WAV",
-	"AUDIO\\RESC_10.WAV",
-	"AUDIO\\ROK1_1A.WAV",
-	"AUDIO\\ROK1_1B.WAV",
-	"AUDIO\\ROK1_5.WAV",
-	"AUDIO\\ROK1_6.WAV",
-	"AUDIO\\ROK1_7.WAV",
-	"AUDIO\\ROK1_8.WAV",
-	"AUDIO\\ROK1_9.WAV",
-	"AUDIO\\TAX1_1.WAV",
-	"AUDIO\\TAX1_2.WAV",
-	"AUDIO\\TAX1_3.WAV",
-	"AUDIO\\TAX1_4.WAV",
-	"AUDIO\\TAX1_5.WAV",
-	"AUDIO\\TAX2_1.WAV",
-	"AUDIO\\TAX2_2.WAV",
-	"AUDIO\\TAX2_3.WAV",
-	"AUDIO\\TAX2_4.WAV",
-	"AUDIO\\TAX2_5.WAV",
-	"AUDIO\\TAX2_6.WAV",
-	"AUDIO\\TAX2_7.WAV",
-	"AUDIO\\TAX3_1.WAV",
-	"AUDIO\\TAX3_2.WAV",
-	"AUDIO\\TAX3_3.WAV",
-	"AUDIO\\TAX3_4.WAV",
-	"AUDIO\\TAX3_5.WAV",
-	"AUDIO\\TEX1_1.WAV",
-	"AUDIO\\TEX1_2.WAV",
-	"AUDIO\\TEX1_3.WAV",
-	"AUDIO\\TEX1_4.WAV",
-	"AUDIO\\TEX1_5.WAV",
-	"AUDIO\\TEX1_6.WAV",
-	"AUDIO\\TEX2_1.WAV",
-	"AUDIO\\TEX3_1.WAV",
-	"AUDIO\\TEX3_2.WAV",
-	"AUDIO\\TEX3_3.WAV",
-	"AUDIO\\TEX3_4.WAV",
-	"AUDIO\\TEX3_5.WAV",
-	"AUDIO\\TEX3_6.WAV",
-	"AUDIO\\TEX3_7.WAV",
-	"AUDIO\\TEX3_8.WAV",
-	"AUDIO\\HAT_1A.WAV",
-	"AUDIO\\INTRO1.WAV",
-	"AUDIO\\INTRO2.WAV",
-	"AUDIO\\INTRO3.WAV",
-	"AUDIO\\INTRO4.WAV",
-	"AUDIO\\MOB_01A.WAV",
-	"AUDIO\\MOB_01B.WAV",
-	"AUDIO\\MOB_01C.WAV",
-	"AUDIO\\MOB_02A.WAV",
-	"AUDIO\\MOB_02B.WAV",
-	"AUDIO\\MOB_02C.WAV",
-	"AUDIO\\MOB_03A.WAV",
-	"AUDIO\\MOB_03B.WAV",
-	"AUDIO\\MOB_03C.WAV",
-	"AUDIO\\MOB_03D.WAV",
-	"AUDIO\\MOB_03E.WAV",
-	"AUDIO\\SHARK_1.WAV",
-	"AUDIO\\SHARK_2.WAV",
-	"AUDIO\\SHARK_3.WAV",
-	"AUDIO\\SHARK_4.WAV",
-	"AUDIO\\SHARK_5.WAV",
-	"AUDIO\\MOB_04A.WAV",
-	"AUDIO\\MOB_04B.WAV",
-	"AUDIO\\MOB_04C.WAV",
-	"AUDIO\\MOB_04D.WAV",
-	"AUDIO\\MOB_05A.WAV",
-	"AUDIO\\MOB_05B.WAV",
-	"AUDIO\\MOB_05C.WAV",
-	"AUDIO\\MOB_05D.WAV",
-	"AUDIO\\MOB_06A.WAV",
-	"AUDIO\\MOB_06B.WAV",
-	"AUDIO\\MOB_06C.WAV",
-	"AUDIO\\MOB_07A.WAV",
-	"AUDIO\\MOB_07B.WAV",
-	"AUDIO\\MOB_08A.WAV",
-	"AUDIO\\MOB_08B.WAV",
-	"AUDIO\\MOB_08C.WAV",
-	"AUDIO\\MOB_08D.WAV",
-	"AUDIO\\MOB_08E.WAV",
-	"AUDIO\\MOB_08F.WAV",
-	"AUDIO\\MOB_08G.WAV",
-	"AUDIO\\MOB_09A.WAV",
-	"AUDIO\\MOB_09B.WAV",
-	"AUDIO\\MOB_09C.WAV",
-	"AUDIO\\MOB_09D.WAV",
-	"AUDIO\\MOB_09E.WAV",
-	"AUDIO\\MOB_09F.WAV",
-	"AUDIO\\MOB_10A.WAV",
-	"AUDIO\\MOB_10B.WAV",
-	"AUDIO\\MOB_10C.WAV",
-	"AUDIO\\MOB_10D.WAV",
-	"AUDIO\\MOB_10E.WAV",
-	"AUDIO\\MOB_11A.WAV",
-	"AUDIO\\MOB_11B.WAV",
-	"AUDIO\\MOB_11C.WAV",
-	"AUDIO\\MOB_11D.WAV",
-	"AUDIO\\MOB_11E.WAV",
-	"AUDIO\\MOB_11F.WAV",
-	"AUDIO\\MOB_14A.WAV",
-	"AUDIO\\MOB_14B.WAV",
-	"AUDIO\\MOB_14C.WAV",
-	"AUDIO\\MOB_14D.WAV",
-	"AUDIO\\MOB_14E.WAV",
-	"AUDIO\\MOB_14F.WAV",
-	"AUDIO\\MOB_14G.WAV",
-	"AUDIO\\MOB_14H.WAV",
-	"AUDIO\\MOB_16A.WAV",
-	"AUDIO\\MOB_16B.WAV",
-	"AUDIO\\MOB_16C.WAV",
-	"AUDIO\\MOB_16D.WAV",
-	"AUDIO\\MOB_16E.WAV",
-	"AUDIO\\MOB_16F.WAV",
-	"AUDIO\\MOB_16G.WAV",
-	"AUDIO\\MOB_17A.WAV",
-	"AUDIO\\MOB_17B.WAV",
-	"AUDIO\\MOB_17C.WAV",
-	"AUDIO\\MOB_17D.WAV",
-	"AUDIO\\MOB_17E.WAV",
-	"AUDIO\\MOB_17G.WAV",
-	"AUDIO\\MOB_17H.WAV",
-	"AUDIO\\MOB_17I.WAV",
-	"AUDIO\\MOB_17J.WAV",
-	"AUDIO\\MOB_17K.WAV",
-	"AUDIO\\MOB_17L.WAV",
-	"AUDIO\\MOB_18A.WAV",
-	"AUDIO\\MOB_18B.WAV",
-	"AUDIO\\MOB_18C.WAV",
-	"AUDIO\\MOB_18D.WAV",
-	"AUDIO\\MOB_18E.WAV",
-	"AUDIO\\MOB_18F.WAV",
-	"AUDIO\\MOB_18G.WAV",
-	"AUDIO\\MOB_20A.WAV",
-	"AUDIO\\MOB_20B.WAV",
-	"AUDIO\\MOB_20C.WAV",
-	"AUDIO\\MOB_20D.WAV",
-	"AUDIO\\MOB_20E.WAV",
-	"AUDIO\\MOB_24A.WAV",
-	"AUDIO\\MOB_24B.WAV",
-	"AUDIO\\MOB_24C.WAV",
-	"AUDIO\\MOB_24D.WAV",
-	"AUDIO\\MOB_24E.WAV",
-	"AUDIO\\MOB_24F.WAV",
-	"AUDIO\\MOB_24G.WAV",
-	"AUDIO\\MOB_24H.WAV",
-	"AUDIO\\MOB_25A.WAV",
-	"AUDIO\\MOB_25B.WAV",
-	"AUDIO\\MOB_25C.WAV",
-	"AUDIO\\MOB_25D.WAV",
-	"AUDIO\\MOB_26A.WAV",
-	"AUDIO\\MOB_26B.WAV",
-	"AUDIO\\MOB_26C.WAV",
-	"AUDIO\\MOB_26D.WAV",
-	"AUDIO\\MOB_26E.WAV",
-	"AUDIO\\MOB_29A.WAV",
-	"AUDIO\\MOB_29B.WAV",
-	"AUDIO\\MOB_29C.WAV",
-	"AUDIO\\MOB_29D.WAV",
-	"AUDIO\\MOB_29E.WAV",
-	"AUDIO\\MOB_29F.WAV",
-	"AUDIO\\MOB_29G.WAV",
-	"AUDIO\\MOB_30A.WAV",
-	"AUDIO\\MOB_30B.WAV",
-	"AUDIO\\MOB_30C.WAV",
-	"AUDIO\\MOB_30D.WAV",
-	"AUDIO\\MOB_30E.WAV",
-	"AUDIO\\MOB_30F.WAV",
-	"AUDIO\\MOB_33A.WAV",
-	"AUDIO\\MOB_33B.WAV",
-	"AUDIO\\MOB_33C.WAV",
-	"AUDIO\\MOB_33D.WAV",
-	"AUDIO\\MOB_34A.WAV",
-	"AUDIO\\MOB_34B.WAV",
-	"AUDIO\\MOB_34C.WAV",
-	"AUDIO\\MOB_34D.WAV",
-	"AUDIO\\MOB_35A.WAV",
-	"AUDIO\\MOB_35B.WAV",
-	"AUDIO\\MOB_35C.WAV",
-	"AUDIO\\MOB_35D.WAV",
-	"AUDIO\\MOB_36A.WAV",
-	"AUDIO\\MOB_36B.WAV",
-	"AUDIO\\MOB_36C.WAV",
-	"AUDIO\\MOB_40A.WAV",
-	"AUDIO\\MOB_40B.WAV",
-	"AUDIO\\MOB_40C.WAV",
-	"AUDIO\\MOB_40D.WAV",
-	"AUDIO\\MOB_40E.WAV",
-	"AUDIO\\MOB_40F.WAV",
-	"AUDIO\\MOB_40G.WAV",
-	"AUDIO\\MOB_40H.WAV",
-	"AUDIO\\MOB_40I.WAV",
-	"AUDIO\\MOB_41A.WAV",
-	"AUDIO\\MOB_41B.WAV",
-	"AUDIO\\MOB_41C.WAV",
-	"AUDIO\\MOB_41D.WAV",
-	"AUDIO\\MOB_41E.WAV",
-	"AUDIO\\MOB_41F.WAV",
-	"AUDIO\\MOB_41G.WAV",
-	"AUDIO\\MOB_41H.WAV",
-	"AUDIO\\MOB_42A.WAV",
-	"AUDIO\\MOB_42B.WAV",
-	"AUDIO\\MOB_42C.WAV",
-	"AUDIO\\MOB_42D.WAV",
-	"AUDIO\\MOB_42E.WAV",
-	"AUDIO\\MOB_43A.WAV",
-	"AUDIO\\MOB_43B.WAV",
-	"AUDIO\\MOB_43C.WAV",
-	"AUDIO\\MOB_43D.WAV",
-	"AUDIO\\MOB_43E.WAV",
-	"AUDIO\\MOB_43F.WAV",
-	"AUDIO\\MOB_43G.WAV",
-	"AUDIO\\MOB_43H.WAV",
-	"AUDIO\\MOB_45A.WAV",
-	"AUDIO\\MOB_45B.WAV",
-	"AUDIO\\MOB_45C.WAV",
-	"AUDIO\\MOB_45D.WAV",
-	"AUDIO\\MOB_45E.WAV",
-	"AUDIO\\MOB_45F.WAV",
-	"AUDIO\\MOB_45G.WAV",
-	"AUDIO\\MOB_45H.WAV",
-	"AUDIO\\MOB_45I.WAV",
-	"AUDIO\\MOB_45J.WAV",
-	"AUDIO\\MOB_45K.WAV",
-	"AUDIO\\MOB_45L.WAV",
-	"AUDIO\\MOB_45M.WAV",
-	"AUDIO\\MOB_45N.WAV",
-	"AUDIO\\MOB_46A.WAV",
-	"AUDIO\\MOB_46B.WAV",
-	"AUDIO\\MOB_46C.WAV",
-	"AUDIO\\MOB_46D.WAV",
-	"AUDIO\\MOB_46E.WAV",
-	"AUDIO\\MOB_46F.WAV",
-	"AUDIO\\MOB_46G.WAV",
-	"AUDIO\\MOB_46H.WAV",
-	"AUDIO\\MOB_47A.WAV",
-	"AUDIO\\MOB_52A.WAV",
-	"AUDIO\\MOB_52B.WAV",
-	"AUDIO\\MOB_52C.WAV",
-	"AUDIO\\MOB_52D.WAV",
-	"AUDIO\\MOB_52E.WAV",
-	"AUDIO\\MOB_52F.WAV",
-	"AUDIO\\MOB_52G.WAV",
-	"AUDIO\\MOB_52H.WAV",
-	"AUDIO\\MOB_54A.WAV",
-	"AUDIO\\MOB_54B.WAV",
-	"AUDIO\\MOB_54C.WAV",
-	"AUDIO\\MOB_54D.WAV",
-	"AUDIO\\MOB_54E.WAV",
-	"AUDIO\\MOB_55A.WAV",
-	"AUDIO\\MOB_55B.WAV",
-	"AUDIO\\MOB_55C.WAV",
-	"AUDIO\\MOB_55D.WAV",
-	"AUDIO\\MOB_55E.WAV",
-	"AUDIO\\MOB_55F.WAV",
-	"AUDIO\\MOB_56A.WAV",
-	"AUDIO\\MOB_56B.WAV",
-	"AUDIO\\MOB_56C.WAV",
-	"AUDIO\\MOB_56D.WAV",
-	"AUDIO\\MOB_56E.WAV",
-	"AUDIO\\MOB_56F.WAV",
-	"AUDIO\\MOB_57A.WAV",
-	"AUDIO\\MOB_57B.WAV",
-	"AUDIO\\MOB_57C.WAV",
-	"AUDIO\\MOB_57D.WAV",
-	"AUDIO\\MOB_57E.WAV",
-	"AUDIO\\MOB_58A.WAV",
-	"AUDIO\\MOB_58B.WAV",
-	"AUDIO\\MOB_58C.WAV",
-	"AUDIO\\MOB_58D.WAV",
-	"AUDIO\\MOB_58E.WAV",
-	"AUDIO\\MOB_58F.WAV",
-	"AUDIO\\MOB_58G.WAV",
-	"AUDIO\\MOB_61A.WAV",
-	"AUDIO\\MOB_61B.WAV",
-	"AUDIO\\MOB_62A.WAV",
-	"AUDIO\\MOB_62B.WAV",
-	"AUDIO\\MOB_62C.WAV",
-	"AUDIO\\MOB_62D.WAV",
-	"AUDIO\\MOB_63A.WAV",
-	"AUDIO\\MOB_63B.WAV",
-	"AUDIO\\MOB_63C.WAV",
-	"AUDIO\\MOB_63D.WAV",
-	"AUDIO\\MOB_63E.WAV",
-	"AUDIO\\MOB_63F.WAV",
-	"AUDIO\\MOB_63G.WAV",
-	"AUDIO\\MOB_63H.WAV",
-	"AUDIO\\MOB_63I.WAV",
-	"AUDIO\\MOB_63J.WAV",
-	"AUDIO\\MOB_66A.WAV",
-	"AUDIO\\MOB_66B.WAV",
-	"AUDIO\\MOB_68A.WAV",
-	"AUDIO\\MOB_68B.WAV",
-	"AUDIO\\MOB_68C.WAV",
-	"AUDIO\\MOB_68D.WAV",
-	"AUDIO\\MOB_70A.WAV",
-	"AUDIO\\MOB_70B.WAV",
-	"AUDIO\\MOB_71A.WAV",
-	"AUDIO\\MOB_71B.WAV",
-	"AUDIO\\MOB_71C.WAV",
-	"AUDIO\\MOB_71D.WAV",
-	"AUDIO\\MOB_71E.WAV",
-	"AUDIO\\MOB_71F.WAV",
-	"AUDIO\\MOB_71G.WAV",
-	"AUDIO\\MOB_71H.WAV",
-	"AUDIO\\MOB_71I.WAV",
-	"AUDIO\\MOB_71J.WAV",
-	"AUDIO\\MOB_71K.WAV",
-	"AUDIO\\MOB_71L.WAV",
-	"AUDIO\\MOB_71M.WAV",
-	"AUDIO\\MOB_71N.WAV",
-	"AUDIO\\MOB_72A.WAV",
-	"AUDIO\\MOB_72B.WAV",
-	"AUDIO\\MOB_72C.WAV",
-	"AUDIO\\MOB_72D.WAV",
-	"AUDIO\\MOB_72E.WAV",
-	"AUDIO\\MOB_72F.WAV",
-	"AUDIO\\MOB_72G.WAV",
-	"AUDIO\\MOB_73A.WAV",
-	"AUDIO\\MOB_73C.WAV",
-	"AUDIO\\MOB_73D.WAV",
-	"AUDIO\\MOB_73F.WAV",
-	"AUDIO\\MOB_73G.WAV",
-	"AUDIO\\MOB_73I.WAV",
-	"AUDIO\\MOB_95A.WAV",
-	"AUDIO\\MOB_96A.WAV",
-	"AUDIO\\MOB_98A.WAV",
-	"AUDIO\\MOB_99A.WAV",
-	"AUDIO\\JOB1_1B.WAV",
-	"AUDIO\\JOB1_1C.WAV",
-	"AUDIO\\JOB1_1D.WAV",
-	"AUDIO\\JOB2_1B.WAV",
-	"AUDIO\\JOB2_2.WAV",
-	"AUDIO\\JOB2_3.WAV",
-	"AUDIO\\JOB2_4.WAV",
-	"AUDIO\\JOB2_5.WAV",
-	"AUDIO\\JOB2_6.WAV",
-	"AUDIO\\JOB2_7.WAV",
-	"AUDIO\\JOB2_8.WAV",
-	"AUDIO\\JOB2_9.WAV",
-	"AUDIO\\JOB3_1.WAV",
-	"AUDIO\\JOB3_2.WAV",
-	"AUDIO\\JOB3_3.WAV",
-	"AUDIO\\JOB4_1.WAV",
-	"AUDIO\\JOB4_2.WAV",
-	"AUDIO\\JOB4_3.WAV",
-	"AUDIO\\JOB5_1.WAV",
-	"AUDIO\\JOB5_2.WAV",
-	"AUDIO\\JOB5_3.WAV",
-	"AUDIO\\BJM1_20.WAV",
-	"AUDIO\\BJM1_4.WAV",
-	"AUDIO\\BJM1_5.WAV",
-	"AUDIO\\MERC_39.WAV",
-	"AUDIO\\MONO_1.WAV",
-	"AUDIO\\MONO_2.WAV",
-	"AUDIO\\MONO_3.WAV",
-	"AUDIO\\MONO_4.WAV",
-	"AUDIO\\MONO_5.WAV",
-	"AUDIO\\MONO_6.WAV",
-	"AUDIO\\MONO_7.WAV",
-	"AUDIO\\MONO_8.WAV",
-	"AUDIO\\MONO_9.WAV",
-	"AUDIO\\MONO10.WAV",
-	"AUDIO\\MONO11.WAV",
-	"AUDIO\\MONO12.WAV",
-	"AUDIO\\MONO13.WAV",
-	"AUDIO\\MONO14.WAV",
-	"AUDIO\\MONO15.WAV",
-	"AUDIO\\MONO16.WAV",
-	"AUDIO\\FUD_01.WAV",
-	"AUDIO\\FUD_02.WAV",
-	"AUDIO\\FUD_03.WAV",
-	"AUDIO\\FUD_04.WAV",
-	"AUDIO\\FUD_05.WAV",
-	"AUDIO\\FUD_06.WAV",
-	"AUDIO\\FUD_07.WAV",
-	"AUDIO\\FUD_08.WAV",
-	"AUDIO\\FUD_09.WAV",
-	"AUDIO\\FUD_10.WAV",
-	"AUDIO\\FUD_11.WAV",
-	"AUDIO\\FUD_12.WAV",
-	"AUDIO\\FUD_13.WAV",
-	"AUDIO\\FUD_14.WAV",
-	"AUDIO\\FUD_15.WAV",
-	"AUDIO\\FUD_16.WAV",
-	"AUDIO\\FUD_17.WAV",
-	"AUDIO\\FUD_18.WAV",
-	"AUDIO\\FUD_19.WAV",
-	"AUDIO\\FUD_20.WAV",
-	"AUDIO\\BURG_01.WAV",
-	"AUDIO\\BURG_02.WAV",
-	"AUDIO\\BURG_03.WAV",
-	"AUDIO\\BURG_04.WAV",
-	"AUDIO\\BURG_05.WAV",
-	"AUDIO\\BURG_06.WAV",
-	"AUDIO\\BURG_07.WAV",
-	"AUDIO\\BURG_08.WAV",
-	"AUDIO\\BURG_09.WAV",
-	"AUDIO\\BURG_10.WAV",
-	"AUDIO\\BURG_11.WAV",
-	"AUDIO\\BURG_12.WAV",
-	"AUDIO\\CRUST01.WAV",
-	"AUDIO\\CRUST02.WAV",
-	"AUDIO\\CRUST03.WAV",
-	"AUDIO\\CRUST04.WAV",
-	"AUDIO\\CRUST05.WAV",
-	"AUDIO\\CRUST06.WAV",
-	"AUDIO\\CRUST07.WAV",
-	"AUDIO\\CRUST08.WAV",
-	"AUDIO\\CRUST09.WAV",
-	"AUDIO\\BAND_01.WAV",
-	"AUDIO\\BAND_02.WAV",
-	"AUDIO\\BAND_03.WAV",
-	"AUDIO\\BAND_04.WAV",
-	"AUDIO\\BAND_05.WAV",
-	"AUDIO\\BAND_06.WAV",
-	"AUDIO\\BAND_07.WAV",
-	"AUDIO\\BAND_08.WAV",
-	"AUDIO\\SHAFT01.WAV",
-	"AUDIO\\SHAFT02.WAV",
-	"AUDIO\\SHAFT03.WAV",
-	"AUDIO\\SHAFT04.WAV",
-	"AUDIO\\SHAFT05.WAV",
-	"AUDIO\\SHAFT06.WAV",
-	"AUDIO\\SHAFT07.WAV",
-	"AUDIO\\SHAFT08.WAV",
-	"AUDIO\\PISS_01.WAV",
-	"AUDIO\\PISS_02.WAV",
-	"AUDIO\\PISS_03.WAV",
-	"AUDIO\\PISS_04.WAV",
-	"AUDIO\\PISS_05.WAV",
-	"AUDIO\\PISS_06.WAV",
-	"AUDIO\\PISS_07.WAV",
-	"AUDIO\\PISS_08.WAV",
-	"AUDIO\\PISS_09.WAV",
-	"AUDIO\\PISS_10.WAV",
-	"AUDIO\\PISS_11.WAV",
-	"AUDIO\\PISS_12.WAV",
-	"AUDIO\\PISS_13.WAV",
-	"AUDIO\\PISS_14.WAV",
-	"AUDIO\\PISS_15.WAV",
-	"AUDIO\\PISS_16.WAV",
-	"AUDIO\\PISS_17.WAV",
-	"AUDIO\\PISS_18.WAV",
-	"AUDIO\\PISS_19.WAV",
-	"AUDIO\\GIMME01.WAV",
-	"AUDIO\\GIMME02.WAV",
-	"AUDIO\\GIMME03.WAV",
-	"AUDIO\\GIMME04.WAV",
-	"AUDIO\\GIMME05.WAV",
-	"AUDIO\\GIMME06.WAV",
-	"AUDIO\\GIMME07.WAV",
-	"AUDIO\\GIMME08.WAV",
-	"AUDIO\\GIMME09.WAV",
-	"AUDIO\\GIMME10.WAV",
-	"AUDIO\\GIMME11.WAV",
-	"AUDIO\\GIMME12.WAV",
-	"AUDIO\\GIMME13.WAV",
-	"AUDIO\\GIMME14.WAV",
-	"AUDIO\\GIMME15.WAV",
-	"AUDIO\\BUST_01.WAV",
-	"AUDIO\\BUST_02.WAV",
-	"AUDIO\\BUST_03.WAV",
-	"AUDIO\\BUST_04.WAV",
-	"AUDIO\\BUST_05.WAV",
-	"AUDIO\\BUST_06.WAV",
-	"AUDIO\\BUST_07.WAV",
-	"AUDIO\\BUST_08.WAV",
-	"AUDIO\\BUST_09.WAV",
-	"AUDIO\\BUST_10.WAV",
-	"AUDIO\\BUST_11.WAV",
-	"AUDIO\\BUST_12.WAV",
-	"AUDIO\\BUST_13.WAV",
-	"AUDIO\\BUST_14.WAV",
-	"AUDIO\\BUST_15.WAV",
-	"AUDIO\\BUST_16.WAV",
-	"AUDIO\\BUST_17.WAV",
-	"AUDIO\\BUST_18.WAV",
-	"AUDIO\\BUST_19.WAV",
-	"AUDIO\\BUST_20.WAV",
-	"AUDIO\\BUST_21.WAV",
-	"AUDIO\\BUST_22.WAV",
-	"AUDIO\\BUST_23.WAV",
-	"AUDIO\\BUST_24.WAV",
-	"AUDIO\\BUST_25.WAV",
-	"AUDIO\\BUST_26.WAV",
-	"AUDIO\\BUST_27.WAV",
-	"AUDIO\\BUST_28.WAV",
+
 };
\ No newline at end of file
diff --git a/src/audio/sampman_miles.cpp b/src/audio/sampman_miles.cpp
index 2a4286eb..78de4e6b 100644
--- a/src/audio/sampman_miles.cpp
+++ b/src/audio/sampman_miles.cpp
@@ -1057,7 +1057,7 @@ cSampleManager::Initialise(void)
 			m_szCDRomRootPath[0] = '\0';
 
 			strcpy(m_WavFilesPath, m_szCDRomRootPath);
-
+			/*
 #ifdef AUDIO_CACHE
 			if ( CreateCache )
 #endif
@@ -1084,7 +1084,7 @@ cSampleManager::Initialise(void)
 					return false;
 				}
 			}
-
+			*/
 			// Find path of MP3s (originally in CD-Rom)
 			// if NO_CDCHECK is NOT defined but AUDIO_CACHE is defined, we still need to find MP3s' path, but will exit after the first file
 #ifndef NO_CDCHECK
@@ -1102,7 +1102,7 @@ cSampleManager::Initialise(void)
 			{
 #endif
 
-				for (int32 i = 0; i < STREAMED_SOUND_MISSION_MOBR1; i++)
+				for (int32 i = 0; i < TOTAL_STREAMED_SOUNDS; i++)
 				{
 					strcpy(filepath, m_MP3FilesPath);
 					strcat(filepath, StreamedNameTable[i]);
@@ -1143,7 +1143,7 @@ cSampleManager::Initialise(void)
 #endif
 
 			if ( !bFileNotFound ) {
-
+/*
 #ifdef AUDIO_CACHE
 			if ( CreateCache )
 #endif
@@ -1169,7 +1169,7 @@ cSampleManager::Initialise(void)
 						bFileNotFound = true;
 						break;
 					}
-				}
+				}*/
 			}
 			
 			m_bInitialised = !bFileNotFound;
@@ -2046,7 +2046,7 @@ cSampleManager::PreloadStreamedFile(uint32 nFile, uint8 nStream)
 			
 			char filepath[MAX_PATH];
 			
-			strcpy(filepath, nFile < STREAMED_SOUND_MISSION_COMPLETED4 ? m_MP3FilesPath : (nFile < STREAMED_SOUND_MISSION_MOBR1 ? m_MiscomPath : m_WavFilesPath));
+			strcpy(filepath, m_MP3FilesPath);
 			strcat(filepath, StreamedNameTable[nFile]);
 			
 			mp3Stream[nStream] = AIL_open_stream(DIG, filepath, 0);
diff --git a/src/audio/sampman_oal.cpp b/src/audio/sampman_oal.cpp
index ce6458e6..ef070825 100644
--- a/src/audio/sampman_oal.cpp
+++ b/src/audio/sampman_oal.cpp
@@ -396,7 +396,7 @@ set_new_provider(int index)
 static bool
 IsThisTrackAt16KHz(uint32 track)
 {
-	return track == STREAMED_SOUND_RADIO_KCHAT || track == STREAMED_SOUND_RADIO_VCPR || track == STREAMED_SOUND_RADIO_POLICE;
+	return false;// track == STREAMED_SOUND_RADIO_KCHAT || track == STREAMED_SOUND_RADIO_VCPR || track == STREAMED_SOUND_RADIO_POLICE;
 }
 
 cSampleManager::cSampleManager(void)
diff --git a/src/collision/TempColModels.cpp b/src/collision/TempColModels.cpp
index f8b26450..55058bde 100644
--- a/src/collision/TempColModels.cpp
+++ b/src/collision/TempColModels.cpp
@@ -10,7 +10,7 @@ CColModel CTempColModels::ms_colModelWheel1;
 CColModel CTempColModels::ms_colModelPanel1;
 CColModel CTempColModels::ms_colModelBodyPart2;
 CColModel CTempColModels::ms_colModelBodyPart1;
-CColModel CTempColModels::ms_colModelCutObj[5];
+CColModel CTempColModels::ms_colModelCutObj[10];
 CColModel CTempColModels::ms_colModelPedGroundHit;
 CColModel CTempColModels::ms_colModelBoot1;
 CColModel CTempColModels::ms_colModelDoor1;
diff --git a/src/collision/TempColModels.h b/src/collision/TempColModels.h
index 0c936d6f..457315b6 100644
--- a/src/collision/TempColModels.h
+++ b/src/collision/TempColModels.h
@@ -13,7 +13,7 @@ public:
 	static CColModel ms_colModelPanel1;
 	static CColModel ms_colModelBodyPart2;
 	static CColModel ms_colModelBodyPart1;
-	static CColModel ms_colModelCutObj[5];
+	static CColModel ms_colModelCutObj[10];
 	static CColModel ms_colModelPedGroundHit;
 	static CColModel ms_colModelBoot1;
 	static CColModel ms_colModelDoor1;
diff --git a/src/control/Script3.cpp b/src/control/Script3.cpp
index 87ecb8e0..88df935f 100644
--- a/src/control/Script3.cpp
+++ b/src/control/Script3.cpp
@@ -1984,7 +1984,7 @@ int8 CRunningScript::ProcessCommands700To799(int32 command)
 		return 0;
 	}
 	case COMMAND_START_CUTSCENE:
-		CCutsceneMgr::ms_cutsceneLoadStatus = 1;
+		CCutsceneMgr::StartCutscene();
 		return 0;
 	case COMMAND_GET_CUTSCENE_TIME:
 		SET_INTEGER_PARAM(0, CCutsceneMgr::GetCutsceneTimeInMilleseconds());
diff --git a/src/control/Script5.cpp b/src/control/Script5.cpp
index c0909356..c0e3ecad 100644
--- a/src/control/Script5.cpp
+++ b/src/control/Script5.cpp
@@ -2754,30 +2754,16 @@ void CTheScripts::ReadObjectNamesFromScript()
 
 void CTheScripts::UpdateObjectIndices()
 {
-	char name[USED_OBJECT_NAME_LENGTH];
 	char error[112];
 	for (int i = 1; i < NumberOfUsedObjects; i++) {
-		bool found = false;
-		for (int j = 0; j < MODELINFOSIZE && !found; j++) {
-			CBaseModelInfo* pModel = CModelInfo::GetModelInfo(j);
-			if (!pModel)
-				continue;
-			strcpy(name, pModel->GetModelName());
-#ifdef FIX_BUGS
-			for (int k = 0; k < USED_OBJECT_NAME_LENGTH && name[k]; k++)
-#else
-			for (int k = 0; k < USED_OBJECT_NAME_LENGTH; k++)
-#endif
-				name[k] = toupper(name[k]);
-			if (strcmp(name, UsedObjectArray[i].name) == 0) {
-				found = true;
-				UsedObjectArray[i].index = j;
-			}
-		}
-		if (!found) {
+		UsedObjectArray[i].index = -1;
+		CModelInfo::GetModelInfo(UsedObjectArray[i].name, &UsedObjectArray[i].index);
+#ifndef FINAL
+		if (UsedObjectArray[i].index == -1) {
 			sprintf(error, "CTheScripts::UpdateObjectIndices - Couldn't find %s", UsedObjectArray[i].name);
 			debug("%s\n", error);
 		}
+#endif
 	}
 }
 
diff --git a/src/control/Script7.cpp b/src/control/Script7.cpp
index 220a7c4d..b3f16106 100644
--- a/src/control/Script7.cpp
+++ b/src/control/Script7.cpp
@@ -1018,7 +1018,7 @@ int8 CRunningScript::ProcessCommands1300To1399(int32 command)
 		return 0;
 	case COMMAND_REMOVE_EVERYTHING_FOR_HUGE_CUTSCENE:
 	{
-		CCutsceneMgr::RemoveEverythingFromTheWorldForTheBiggestFuckoffCutsceneEver();
+		//CCutsceneMgr::RemoveEverythingFromTheWorldForTheBiggestFuckoffCutsceneEver();
 		return 0;
 	}
 	case COMMAND_IS_PLAYER_TOUCHING_VEHICLE:
diff --git a/src/control/Script8.cpp b/src/control/Script8.cpp
index cf5f1327..2f52b150 100644
--- a/src/control/Script8.cpp
+++ b/src/control/Script8.cpp
@@ -77,7 +77,7 @@ int8 CRunningScript::ProcessCommands1400To1499(int32 command)
 	case COMMAND_PLAY_ANNOUNCEMENT:
 	{
 		CollectParameters(&m_nIp, 1);
-		DMAudio.PlayRadioAnnouncement(ScriptParams[0] + STREAMED_SOUND_ANNOUNCE_BRIDGE_CLOSED);
+		DMAudio.PlayRadioAnnouncement(ScriptParams[0] + STREAMED_SOUND_NEWS_A);
 		return 0;
 	}
 	case COMMAND_SET_PLAYER_IS_IN_STADIUM:
diff --git a/src/core/Game.h b/src/core/Game.h
index 69d71700..dd14278a 100644
--- a/src/core/Game.h
+++ b/src/core/Game.h
@@ -80,4 +80,4 @@ public:
 	static void ProcessTidyUpMemory(void);
 };
 
-inline bool IsAreaVisible(int area) { return area == CGame::currArea || area == AREA_EVERYWHERE; }
+inline bool IsAreaVisible(int area) { return true; }
diff --git a/src/core/Streaming.cpp b/src/core/Streaming.cpp
index 4fff2367..4198dd84 100644
--- a/src/core/Streaming.cpp
+++ b/src/core/Streaming.cpp
@@ -37,6 +37,7 @@
 #include "Font.h"
 #include "Frontend.h"
 #include "VarConsole.h"
+#include "KeyGen.h"
 
 //--MIAMI: file done (possibly bugs)
 
@@ -948,53 +949,45 @@ CStreaming::RequestIslands(eLevelName level)
 	}
 }
 
-static char *IGnames[] = {
-	"player",
-	"player2",
-	"player3",
-	"player4",
-	"player5",
-	"player6",
-	"player7",
-	"player8",
-	"player9",
-	"play10",
-	"play11",
-	"igken",
-	"igcandy",
-	"igsonny",
-	"igbuddy",
-	"igjezz",
-	"ighlary",
-	"igphil",
-	"igmerc",
-	"igdick",
-	"igdiaz",
+const char *csPlayerNames[] =
+{
+	"csplr",
+	"csplr2",
+	"csplr3",
+	"csplr4",
+	"csplr5",
+	"csplr6",
+	"csplr7",
+	"csplr8",
+	"csplr9",
+	"csplr10",
+	"csplr11",
+	"csplr12",
+	"csplr13",
+	"csplr14",
+	"csplr15",
+	"csplr16",
 	""
 };
 
-static char *CSnames[] = {
-	"csplay",
-	"csplay2",
-	"csplay3",
-	"csplay4",
-	"csplay5",
-	"csplay6",
-	"csplay7",
-	"csplay8",
-	"csplay9",
-	"csplay10",
-	"csplay11",
-	"csken",
-	"cscandy",
-	"cssonny",
-	"csbuddy",
-	"csjezz",
-	"cshlary",
-	"csphil",
-	"csmerc",
-	"csdick",
-	"csdiaz",
+const char* playerNames[] =
+{
+	"plr",
+	"plr2",
+	"plr3",
+	"plr4",
+	"plr5",
+	"plr6",
+	"plr7",
+	"plr8",
+	"plr9",
+	"plr10",
+	"plr11",
+	"plr12",
+	"plr13",
+	"plr14",
+	"plr15",
+	"plr16",
 	""
 };
 
@@ -1008,15 +1001,17 @@ CStreaming::RequestSpecialModel(int32 modelId, const char *modelName, int32 flag
 	int i, n;
 
 	mi = CModelInfo::GetModelInfo(modelId);
-	if(strncasecmp("CSPlay", modelName, 6) == 0){
-		char *curname = CModelInfo::GetModelInfo(MI_PLAYER)->GetModelName();
-		for(int i = 0; CSnames[i][0]; i++){
-			if(strcasecmp(curname, IGnames[i]) == 0){
-				modelName = CSnames[i];
+	if (CKeyGen::GetUppercaseKey(modelName) == CKeyGen::GetUppercaseKey("cstoni_a")) {
+		i = 0;
+		while (csPlayerNames[i][0] != '\0') {
+			if (CModelInfo::GetModelInfo(0)->GetNameHashKey() == CKeyGen::GetUppercaseKey(playerNames[i])) {
+				modelName = csPlayerNames[i];
 				break;
 			}
+			i++;
 		}
 	}
+
 	if(!CGeneral::faststrcmp(mi->GetModelName(), modelName)){
 		// Already have the correct name, just request it
 		RequestModel(modelId, flags);
diff --git a/src/core/common.h b/src/core/common.h
index 3e919ab6..ace15ee1 100644
--- a/src/core/common.h
+++ b/src/core/common.h
@@ -93,6 +93,7 @@ typedef ptrdiff_t ssize_t;
 
 #include "config.h"
 #include "memoryManager.h"
+#include "relocatableChunk.h"
 
 #include <rphanim.h>
 #include <rpskin.h>
diff --git a/src/core/config.h b/src/core/config.h
index 711e119a..225863f3 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -371,7 +371,7 @@ static_assert(false, "SUPPORT_XBOX_SCRIPT and SUPPORT_MOBILE_SCRIPT are mutually
 
 // Audio
 #define AUDIO_CACHE // cache sound lengths to speed up the cold boot
-//#define PS2_AUDIO_PATHS // changes audio paths for cutscenes and radio to PS2 paths (needs vbdec on MSS builds)
+#define PS2_AUDIO_PATHS // changes audio paths for cutscenes and radio to PS2 paths (needs vbdec on MSS builds)
 //#define AUDIO_OAL_USE_SNDFILE // use libsndfile to decode WAVs instead of our internal decoder
 #define AUDIO_OAL_USE_MPG123 // use mpg123 to support mp3 files
 
diff --git a/src/core/main.cpp b/src/core/main.cpp
index 8685e42d..c516cd84 100644
--- a/src/core/main.cpp
+++ b/src/core/main.cpp
@@ -82,6 +82,10 @@ char gString2[512];
 wchar gUString[256];
 wchar gUString2[256];
 
+// leeds
+bool gMakeResources = true;
+bool gUseChunkFiles = false;
+
 float FramesPerSecond = 30.0f;
 
 bool gbPrintShite = false;
diff --git a/src/core/main.h b/src/core/main.h
index 37a82fb2..19dd57ba 100644
--- a/src/core/main.h
+++ b/src/core/main.h
@@ -24,6 +24,10 @@ extern bool gbShowTimebars;
 extern bool gbPrintMemoryUsage;
 #endif
 
+// leeds
+extern bool gMakeResources;
+extern bool gUseChunkFiles;
+
 class CSprite2d;
 
 bool DoRWStuffStartOfFrame(int16 TopRed, int16 TopGreen, int16 TopBlue, int16 BottomRed, int16 BottomGreen, int16 BottomBlue, int16 Alpha);
diff --git a/src/fakerw/fake.cpp b/src/fakerw/fake.cpp
index 863407b9..7f89c233 100644
--- a/src/fakerw/fake.cpp
+++ b/src/fakerw/fake.cpp
@@ -394,7 +394,7 @@ RwStream *RwStreamOpen(RwStreamType type, RwStreamAccessType accessType, const v
 		return nil;
 	}
 }
-RwBool RwStreamClose(RwStream * stream, void *pData) { stream->close(); rwFree(stream); return true; }
+RwBool RwStreamClose(RwStream * stream, void *pData) { if (!stream) return false; stream->close(); rwFree(stream); return true; }
 RwUInt32 RwStreamRead(RwStream * stream, void *buffer, RwUInt32 length) { return stream->read8(buffer, length); }
 RwStream *RwStreamWrite(RwStream * stream, const void *buffer, RwUInt32 length) { stream->write8(buffer, length); return stream; }
 RwStream *RwStreamSkip(RwStream * stream, RwUInt32 offset) { stream->seek(offset); return stream; }
diff --git a/src/modelinfo/BaseModelInfo.cpp b/src/modelinfo/BaseModelInfo.cpp
index f05be242..d92e4941 100644
--- a/src/modelinfo/BaseModelInfo.cpp
+++ b/src/modelinfo/BaseModelInfo.cpp
@@ -1,10 +1,12 @@
 #include "common.h"
 
 #include "templates.h"
+#include "main.h"
 #include "TxdStore.h"
 #include "2dEffect.h"
 #include "BaseModelInfo.h"
 #include "ModelInfo.h"
+#include "KeyGen.h"
 
 //--MIAMI: file done
 
@@ -18,6 +20,7 @@ CBaseModelInfo::CBaseModelInfo(ModelInfoType type)
 	m_type = type;
 	m_num2dEffects = 0;
 	m_bOwnsColModel = false;
+	m_name = new char[MAX_MODEL_NAME];
 }
 
 void
@@ -101,3 +104,12 @@ CBaseModelInfo::Get2dEffect(int n)
 	else
 		return nil;
 }
+
+
+void
+CBaseModelInfo::SetModelName(const char *name)
+{
+	m_nameKey = CKeyGen::GetUppercaseKey(name);
+	if (!gUseChunkFiles)
+		strcpy(m_name, name);
+}
\ No newline at end of file
diff --git a/src/modelinfo/BaseModelInfo.h b/src/modelinfo/BaseModelInfo.h
index a4906fc9..b76736c0 100644
--- a/src/modelinfo/BaseModelInfo.h
+++ b/src/modelinfo/BaseModelInfo.h
@@ -23,7 +23,9 @@ class C2dEffect;
 class CBaseModelInfo
 {
 protected:
-	char         m_name[MAX_MODEL_NAME];
+	char        *m_name;
+	uint32       m_nameKey;
+	RwObject    *m_object;
 	uint8        m_type;
 	uint8        m_num2dEffects;
 	bool         m_bOwnsColModel;
@@ -35,7 +37,11 @@ protected:
 
 public:
 	CBaseModelInfo(ModelInfoType type);
+#ifdef FIX_BUGS
+	virtual ~CBaseModelInfo() { delete []m_name; }
+#else
 	virtual ~CBaseModelInfo() {}
+#endif
 	virtual void Shutdown(void);
 	virtual void DeleteRwObject(void) = 0;
 	virtual RwObject *CreateInstance(RwMatrix *) = 0;
@@ -51,7 +57,8 @@ public:
 	bool IsSimple(void) { return m_type == MITYPE_SIMPLE || m_type == MITYPE_TIME || m_type == MITYPE_WEAPON; }
 	bool IsClump(void) { return m_type == MITYPE_CLUMP || m_type == MITYPE_PED || m_type == MITYPE_VEHICLE;	}
 	char *GetModelName(void) { return m_name; }
-	void SetModelName(const char *name) { strncpy(m_name, name, MAX_MODEL_NAME); }
+	void SetModelName(const char *name);
+	uint32 GetNameHashKey() { return m_nameKey; }
 	void SetColModel(CColModel *col, bool owns = false){
 		m_colModel = col; m_bOwnsColModel = owns; }
 	CColModel *GetColModel(void) { return m_colModel; }
diff --git a/src/modelinfo/ModelInfo.cpp b/src/modelinfo/ModelInfo.cpp
index 0a542cf6..02df1be6 100644
--- a/src/modelinfo/ModelInfo.cpp
+++ b/src/modelinfo/ModelInfo.cpp
@@ -4,6 +4,7 @@
 #include "TempColModels.h"
 #include "ModelIndices.h"
 #include "ModelInfo.h"
+#include "KeyGen.h"
 
 // --MIAMI: file done
 
@@ -186,10 +187,11 @@ CModelInfo::AddVehicleModel(int id)
 CBaseModelInfo*
 CModelInfo::GetModelInfo(const char *name, int *id)
 {
+	uint32 hashKey = CKeyGen::GetUppercaseKey(name);
 	CBaseModelInfo *modelinfo;
 	for(int i = 0; i < MODELINFOSIZE; i++){
 		modelinfo = CModelInfo::ms_modelInfoPtrs[i];
-	 	if(modelinfo && !CGeneral::faststricmp(modelinfo->GetModelName(), name)){
+	 	if(modelinfo && hashKey == modelinfo->GetNameHashKey()){
 			if(id)
 				*id = i;
 			return modelinfo;
@@ -201,13 +203,14 @@ CModelInfo::GetModelInfo(const char *name, int *id)
 CBaseModelInfo*
 CModelInfo::GetModelInfo(const char *name, int minIndex, int maxIndex)
 {
+	uint32 hashKey = CKeyGen::GetUppercaseKey(name);
 	if (minIndex > maxIndex)
 		return 0;
 
 	CBaseModelInfo *modelinfo;
 	for(int i = minIndex; i <= maxIndex; i++){
 		modelinfo = CModelInfo::ms_modelInfoPtrs[i];
-	 	if(modelinfo && !CGeneral::faststricmp(modelinfo->GetModelName(), name))
+	 	if(modelinfo && hashKey == modelinfo->GetNameHashKey())
 			return modelinfo;
 	}
 	return nil;
diff --git a/src/objects/CutsceneObject.cpp b/src/objects/CutsceneObject.cpp
index 8d1be357..01fb038f 100644
--- a/src/objects/CutsceneObject.cpp
+++ b/src/objects/CutsceneObject.cpp
@@ -53,12 +53,15 @@ CCutsceneObject::SetModelIndex(uint32 id)
 void
 CCutsceneObject::CreateShadow(void)
 {
+	// empty in LCS
+	/*
 	if ( IsPedModel(GetModelIndex()) )
 	{
 		m_pShadow = new CCutsceneShadow();
 		if (!m_pShadow->IsInitialized())
 			m_pShadow->Create(m_rwObject, 6, true, 4, true);
 	}
+	*/
 }
 
 void
@@ -150,9 +153,9 @@ CCutsceneObject::PreRender(void)
 void
 CCutsceneObject::Render(void)
 {
-	RwRenderStateSet(rwRENDERSTATECULLMODE, (void *)rwCULLMODECULLNONE);
+	SetCullMode(rwCULLMODECULLNONE);
 	CObject::Render();
-	RwRenderStateSet(rwRENDERSTATECULLMODE, (void *)rwCULLMODECULLBACK);
+	SetCullMode(rwCULLMODECULLBACK);
 }
 
 bool
diff --git a/src/render/Hud.cpp b/src/render/Hud.cpp
index d7a9d75d..350e8c45 100644
--- a/src/render/Hud.cpp
+++ b/src/render/Hud.cpp
@@ -91,7 +91,7 @@ bool CHud::m_HideRadar;
 int32 CHud::m_ClockState;
 
 // These aren't really in CHud
-float CHud::BigMessageInUse[6];
+float BigMessageInUse[6];
 float CHud::BigMessageAlpha[6];
 float CHud::BigMessageX[6];
 float CHud::OddJob2OffTimer;
diff --git a/src/render/Hud.h b/src/render/Hud.h
index a4b9609a..354f2438 100644
--- a/src/render/Hud.h
+++ b/src/render/Hud.h
@@ -47,6 +47,8 @@ enum eSprites
 	NUM_HUD_SPRITES = 69,
 };
 
+extern float BigMessageInUse[6];
+
 class CHud
 {
 public:
@@ -82,7 +84,6 @@ public:
 	static int32 m_ClockState;
 
 	// These aren't really in CHud
-	static float BigMessageInUse[6];
 	static float BigMessageAlpha[6];
 	static float BigMessageX[6];
 	static float OddJob2OffTimer;
diff --git a/src/text/Messages.cpp b/src/text/Messages.cpp
index db0865ae..440746c0 100644
--- a/src/text/Messages.cpp
+++ b/src/text/Messages.cpp
@@ -815,3 +815,12 @@ CMessages::ClearAllMessagesDisplayedByGame()
 	CHud::GetRidOfAllHudMessages();
 	CUserDisplay::Pager.ClearMessages();
 }
+
+void
+CMessages::ClearThisBigPrintNow(uint32 id)
+{
+	if (BIGMessages[id].m_Stack[0].m_pText)
+		ClearThisBigPrint(BIGMessages[id].m_Stack[0].m_pText);
+	CHud::m_BigMessage[id][0] = '\0';
+	BigMessageInUse[id] = 0.0f;
+}
\ No newline at end of file
diff --git a/src/text/Messages.h b/src/text/Messages.h
index e8ba1bf7..602a4a08 100644
--- a/src/text/Messages.h
+++ b/src/text/Messages.h
@@ -61,6 +61,7 @@ public:
 	static void ClearThisPrint(wchar *str);
 	static void ClearThisBigPrint(wchar *str);
 	static void ClearAllMessagesDisplayedByGame(void);
+	static void ClearThisBigPrintNow(uint32 id);
 
 	// unused or cut
 	//static void AddMessageSoonWithString(wchar*, uint32, uint16, wchar*);