added code for dig music

svn-id: r12445

4 files changed, 336 insertions, 225 deletions

diff --git a/scumm/imuse_digi/dimuse.cpp b/scumm/imuse_digi/dimuse.cpp
index b83ee3ff96..4dc40a5164 100644
--- a/scumm/imuse_digi/dimuse.cpp
+++ b/scumm/imuse_digi/dimuse.cpp
@@ -52,9 +52,8 @@ IMuseDigital::IMuseDigital(ScummEngine *scumm)
 	_curMusicCue = 0;
 	memset(_attributesSeq, 0, sizeof(_attributesSeq));
 	memset(_attributesState, 0, sizeof(_attributesState));
+	memset(_attributesTable, 0, sizeof(_attributesTable));
 	_curSeqAtribPos = 0;
-
-	_curMusicSoundId = -1;
 }
 
 IMuseDigital::~IMuseDigital() {
@@ -303,11 +302,6 @@ void IMuseDigital::startSound(int soundId, const char *soundName, int soundType,
 				_vm->_mixer->playInputStream(&_track[l].handle, _track[l].stream, true, _track[l].vol / 1000, _track[l].pan, -1);
 			}
 
-			if ((_track[l].soundGroup == IMUSE_MUSIC) && (_vm->_gameId != GID_FT) && !((_vm->_gameId == GID_CMI) && (_vm->_features != GF_DEMO))) {
-				fadeOutMusic(120);
-				_curMusicSoundId = soundId;
-			}
-
 			_track[l].locked = false;
 			_track[l].used = true;
 			return;
@@ -316,19 +310,6 @@ void IMuseDigital::startSound(int soundId, const char *soundName, int soundType,
 	warning("IMuseDigital::startSound(): All slots are full");
 }
 
-void IMuseDigital::stopMusic() {
-	debug(5, "IMuseDigital::stopMusic()");
-	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-		_track[l].locked = true;
-		if ((_track[l].soundId == _curMusicSoundId) && _track[l].used) {
-			if (_track[l].stream) {
-				_track[l].toBeRemoved = true;
-			}
-		}
-		_track[l].locked = false;
-	}
-}
-
 void IMuseDigital::stopSound(int soundId) {
 	debug(5, "IMuseDigital::stopSound(%d)", soundId);
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
@@ -357,8 +338,6 @@ void IMuseDigital::stopAllSounds(bool waitForStop) {
 		_track[l].locked = false;
 	}
 
-	_curMusicSoundId = -1;
-
 	if (waitForStop) {
 		bool used;
 		do {
@@ -411,8 +390,6 @@ void IMuseDigital::parseScriptCmds(int a, int b, int c, int d, int e, int f, int
 				_track[l].locked = true;
 				if ((_track[l].soundId == sample) && _track[l].used) {
 					_track[l].vol = d * 1000;
-//					if (_track[l].volFadeUsed)
-//						_track[l].volFadeStep = (_track[l].volFadeDest - _track[l].vol) * 60 * 40 / (1000 * _track[chan].volFadeDelay);
 				}
 				_track[l].locked = false;
 			}
@@ -469,16 +446,6 @@ void IMuseDigital::parseScriptCmds(int a, int b, int c, int d, int e, int f, int
 			break;
 		}
 		break;
-	case 15: // ImuseSetHook
-		debug(5, "ImuseSetHookId (%d, %d)", sample, c);
-		for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-			_track[l].locked = true;
-			if ((_track[l].soundId == sample) && _track[l].used) {
-				_track[l].curHookId = c;
-			}
-			_track[l].locked = false;
-		}
-		break;
 	case 25: // ImuseStartStream
 		debug(5, "ImuseStartStream (%d, %d, %d)", sample, c, d);
 		break;
@@ -488,41 +455,36 @@ void IMuseDigital::parseScriptCmds(int a, int b, int c, int d, int e, int f, int
 	case 0x1000: // ImuseSetState
 		debug(5, "ImuseSetState (%d)", b);
 		if ((_vm->_gameId == GID_DIG) && (_vm->_features & GF_DEMO)) {
-			if (b == 1)
+			if (b == 1) {
+				fadeOutMusic(120);
 				startMusic(1, false);
-			else {
-				if (getSoundStatus(2) == 0)
+			} else {
+				if (getSoundStatus(2) == 0) {
+					fadeOutMusic(120);
 					startMusic(2, false);
-			}
-		} else if (_vm->_gameId == GID_DIG) {
-			if (b == 1000) {		// STATE_NULL
-				stopMusic();
-				return;
-			}
-			for (l = 0; _digStateMusicMap[l].room != -1; l++) {
-				if (_digStateMusicMap[l].room == b) {
-					int music = _digStateMusicMap[l].table_index;
-					debug(5, "Play imuse music: %s, %s, %s", _digStateMusicTable[music].name, _digStateMusicTable[music].title, _digStateMusicTable[music].filename);
-					if (_digStateMusicTable[music].filename[0] != 0) {
-						startMusic(_digStateMusicTable[music].filename, _digStateMusicTable[music].id, false, 0);
-					}
-					break;
 				}
 			}
 		} else if ((_vm->_gameId == GID_CMI) && (_vm->_features & GF_DEMO)) {
 			if (b == 2) {
+				fadeOutMusic(120);
 				startMusic("in1.imx", 2002, false, 0);
 			} else if (b == 4) {
+				fadeOutMusic(120);
 				startMusic("in2.imx", 2004, false, 0);
 			} else if (b == 8) {
+				fadeOutMusic(120);
 				startMusic("out1.imx", 2008, false, 0);
 			} else if (b == 9) {
+				fadeOutMusic(120);
 				startMusic("out2.imx", 2009, false, 0);
 			} else if (b == 16) {
+				fadeOutMusic(120);
 				startMusic("gun.imx", 2016, false, 0);
 			} else {
 				warning("imuse digital: set state unknown for cmi demo: %d, room: %d", b, this->_vm->_currentRoom);
 			}
+		} else if (_vm->_gameId == GID_DIG) {
+			setDigMusicState(b);
 		} else if (_vm->_gameId == GID_CMI) {
 			setComiMusicState(b);
 		} else if (_vm->_gameId == GID_FT) {
@@ -532,15 +494,7 @@ void IMuseDigital::parseScriptCmds(int a, int b, int c, int d, int e, int f, int
 	case 0x1001: // ImuseSetSequence
 		debug(5, "ImuseSetSequence (%d)", b);
 		if (_vm->_gameId == GID_DIG) {
-			for (l = 0; _digSeqMusicTable[l].room != -1; l++) {
-				if (_digSeqMusicTable[l].room == b) {
-					debug(5, "Play imuse music: %s, %s, %s", _digSeqMusicTable[l].name, _digSeqMusicTable[l].title, _digSeqMusicTable[l].filename);
-					if (_digSeqMusicTable[l].filename[0] != 0) {
-						startMusic(_digSeqMusicTable[l].filename, b, false, 0);
-					}
-					break;
-				}
-			}
+			setDigMusicSequence(b);
 		} else if (_vm->_gameId == GID_CMI) {
 			setComiMusicSequence(b);
 		} else if (_vm->_gameId == GID_FT) {
@@ -556,6 +510,8 @@ void IMuseDigital::parseScriptCmds(int a, int b, int c, int d, int e, int f, int
 	case 0x1003: // ImuseSetAttribute
 		debug(5, "ImuseSetAttribute (%d, %d)", b, c);
 		if (_vm->_gameId == GID_DIG) {
+			assert(b >= 0 && b < 11);
+			_attributesTable[b] = c;
 		}
 		break;
 	case 0x2000: // ImuseSetMasterSFXVolume
diff --git a/scumm/imuse_digi/dimuse.h b/scumm/imuse_digi/dimuse.h
index 3f0744a3ef..81fd8764a4 100644
--- a/scumm/imuse_digi/dimuse.h
+++ b/scumm/imuse_digi/dimuse.h
@@ -35,6 +35,7 @@ namespace Scumm {
 
 #define MAX_DIGITAL_TRACKS 16
 
+struct imuseDigTable;
 struct imuseComiTable;
 
 class IMuseDigital : public MusicEngine {
@@ -77,6 +78,7 @@ private:
 	ImuseDigiSndMgr *_sound;
 	bool _pause;
 
+	int _attributesTable[11];
 	int _attributesState[97];
 	int _attributesSeq[91];
 	int _curSeqAtribPos;
@@ -85,8 +87,6 @@ private:
 	int _curMusicSeq;
 	int _curMusicCue;
 
-	int _curMusicSoundId;
-
 	static void timer_handler(void *refConf);
 	void callback();
 	void switchToNextRegion(int track);
@@ -95,10 +95,9 @@ private:
 	int32 getPosInMs(int soundId);
 	void getLipSync(int soundId, int syncId, int32 msPos, int32 &width, int32 &height);
 
-	void stopMusic();
-
 	int getSoundIdByName(const char *soundName);
 	void fadeOutMusic(int fadeDelay);
+
 	void setFtMusicState(int stateId);
 	void setFtMusicSequence(int seqId);
 	void setFtMusicCuePoint(int cueId);
@@ -108,6 +107,10 @@ private:
 	void setComiMusicSequence(int seqId);
 	void playComiMusic(const char *songName, const imuseComiTable *table, int atribPos, bool sequence);
 
+	void setDigMusicState(int stateId);
+	void setDigMusicSequence(int seqId);
+	void playDigMusic(const char *songName, const imuseDigTable *table, int atribPos, bool sequence);
+
 public:
 	IMuseDigital(ScummEngine *scumm);
 	virtual ~IMuseDigital();
@@ -141,24 +144,21 @@ public:
 	int32 getCurMusicLipSyncHeight(int syncId);
 };
 
-struct imuse_music_map {
-	int room;
-	int table_index;
+struct imuseRoomMap {
+	int roomId;
+	int musicTableIndex;
 	int unk1;
 	int unk2;
 	int unk3;
 	int unk4;
 };
 
-struct imuseDigtable {
-	int room;
-	int id;
-	int unk1;
-	int unk2;
-	int unk3;
-	int unk4;
-	char name[30];
+struct imuseDigTable {
 	char title[30];
+	int opcode;
+	int soundId;
+	char name[30];
+	int param;
 	char filename[13];
 };
 
@@ -192,18 +192,18 @@ struct imuseFtSeqTable {
 };
 
 #ifdef __PALM_OS__
-extern imuse_music_map *_digStateMusicMap;
-extern const imuseDigtable *_digStateMusicTable;
-extern const imuseDigtable *_comiStateMusicTable;
+extern const imuseRoomMap *_digStateMusicMap;
+extern const imuseDigTable *_digStateMusicTable;
+extern const imuseDigTable *_comiStateMusicTable;
 extern const imuseComiTable *_comiSeqMusicTable;
 extern const imuseComiTable *_digSeqMusicTable;
 extern const imuseFtStateTable *_ftStateMusicTable;
 extern const imuseFtSeqTable *_ftSeqMusicTable;
 extern const imuseFtNames *_ftSeqNames;
 #else
-extern imuse_music_map _digStateMusicMap[];
-extern const imuseDigtable _digStateMusicTable[];
-extern const imuseDigtable _digSeqMusicTable[];
+extern const imuseRoomMap _digStateMusicMap[];
+extern const imuseDigTable _digStateMusicTable[];
+extern const imuseDigTable _digSeqMusicTable[];
 extern const imuseComiTable _comiStateMusicTable[];
 extern const imuseComiTable _comiSeqMusicTable[];
 extern const imuseFtStateTable _ftStateMusicTable[];
diff --git a/scumm/imuse_digi/dimuse_music.cpp b/scumm/imuse_digi/dimuse_music.cpp
index 63c6aa2458..a80f18e31b 100644
--- a/scumm/imuse_digi/dimuse_music.cpp
+++ b/scumm/imuse_digi/dimuse_music.cpp
@@ -25,10 +25,164 @@
 
 namespace Scumm {
 
+void IMuseDigital::setDigMusicState(int stateId) {
+	int l, num = -1;
+
+	for (l = 0; _digStateMusicTable[l].soundId != -1; l++) {
+		if ((_digStateMusicTable[l].soundId == stateId)) {
+			debug(5, "Set music state: %s, %s, %s", _digStateMusicTable[l].name, _digStateMusicTable[l].title, _digStateMusicTable[l].filename);
+			num = l;
+			break;
+		}
+	}
+
+	if (num == -1) {
+		for (l = 0; _digStateMusicMap[l].roomId != -1; l++) {
+			if ((_digStateMusicMap[l].roomId == stateId)) {
+				break;
+			}
+		}
+		num = l;
+
+		int val2 = _attributesTable[_digStateMusicMap[num].unk1];
+		if (val2 == 0) {
+			if (_attributesTable[_digStateMusicMap[num].unk3] != 0) {
+				num = _digStateMusicMap[num].unk4;
+			} else {
+				num = _digStateMusicMap[num].musicTableIndex;
+			}
+		} else {
+			int val = _attributesTable[_digStateMusicMap[num].unk2];
+			if (val == 0) {
+				num = _digStateMusicMap[num].musicTableIndex + val2;
+			} else {
+				num = val;
+			}
+		}
+	}
+
+	debug(5, "Set music state: %s, %s, %s", _digStateMusicTable[num].name, _digStateMusicTable[num].title, _digStateMusicTable[num].filename);
+
+	if (_curMusicState == num)
+		return;
+
+	if (_curMusicSeq == 0) {
+		if (num == 0)
+			playDigMusic(NULL, &_digStateMusicTable[num], num, false);
+		else
+			playDigMusic(_digStateMusicTable[num].name, &_digStateMusicTable[num], num, false);
+	}
+
+	_curMusicState = num;
+}
+
+void IMuseDigital::setDigMusicSequence(int seqId) {
+	int l, num = -1;
+
+	if (seqId == 0)
+		seqId = 2000;
+
+	for (l = 0; _digSeqMusicTable[l].soundId != -1; l++) {
+		if ((_digSeqMusicTable[l].soundId == seqId)) {
+			debug(5, "Set music sequence: %s, %s, %s", _digSeqMusicTable[l].name, _digSeqMusicTable[l].title, _digSeqMusicTable[l].filename);
+			num = l;
+			break;
+		}
+	}
+	assert(num != -1);
+
+	if (_curMusicSeq == num)
+		return;
+
+	if (num != 0) {
+		if (_curMusicSeq == 0) {
+			playDigMusic(_digSeqMusicTable[num].name, &_digSeqMusicTable[num], 0, true);
+			_curSeqAtribPos = 0;
+			_attributesSeq[num] = 1;
+		} else {
+			if ((_digSeqMusicTable[_curMusicSeq].opcode == 4) && (_digSeqMusicTable[_curMusicSeq].opcode == 6)) {
+				_curSeqAtribPos = num;
+				return;
+			} else if (_digSeqMusicTable[_curMusicSeq].opcode == 6) {
+				playDigMusic(_digSeqMusicTable[num].name, &_digSeqMusicTable[num], 0, true);
+				_curSeqAtribPos = 0;
+				_attributesSeq[num] = 1;
+			}
+		}
+	} else {
+		if (_curSeqAtribPos != 0) {
+			playDigMusic(_digSeqMusicTable[_curSeqAtribPos].name, &_digSeqMusicTable[num], 0, true);
+			_attributesSeq[_curSeqAtribPos] = 1;
+			_curSeqAtribPos = 0;
+			num = _curSeqAtribPos;
+		} else {
+			if (_curMusicState != 0)
+				playDigMusic(_digStateMusicTable[_curMusicState].name, &_digSeqMusicTable[num], _curMusicState, false);
+			else
+				playDigMusic(NULL, &_digStateMusicTable[num], _curMusicState, false);
+			num = 0;
+		}
+	}
+
+	_curMusicSeq = num;
+}
+
+void IMuseDigital::playDigMusic(const char *songName, const imuseDigTable *table, int atribPos, bool sequence) {
+	int hookId = 0;
+
+	if (songName != NULL) {
+		if ((_attributesSeq[38] != 0) && (_attributesSeq[41] == _attributesSeq[38])) {
+			if ((atribPos == 43) || (atribPos == 44))
+				hookId = 3;
+		}
+
+		if ((_attributesSeq[46] != 0) && (_attributesSeq[48] == 0)) {
+			if ((atribPos == 38) || (atribPos == 39))
+				hookId = 3;
+		}
+
+		if ((_attributesSeq[53] != 0)) {
+			if ((atribPos == 50) || (atribPos == 51))
+				hookId = 3;
+		}
+
+		if ((atribPos != 0) && (hookId == 0)) {
+			if (table->param != 0)
+				atribPos = table->param;
+			hookId = _attributesSeq[atribPos];
+		}
+	}
+
+	if (table->filename[0] == 0) {
+		fadeOutMusic(120);
+		return;
+	}
+
+	fadeOutMusic(120);
+
+	switch(table->opcode) {
+		case 0:
+		case 5:
+		case 6:
+			break;
+		case 3:
+			if ((!sequence) && (table->param != 0)) {
+				if (table->param == _digStateMusicTable[_curMusicState].param) {
+					startMusic(table->filename, table->soundId, sequence, 0);
+				} 
+			} else {
+				startMusic(table->filename, table->soundId, sequence, hookId);
+			}
+		case 4:
+			startMusic(table->filename, table->soundId, sequence, 0);
+			break;
+	}
+}
+
 void IMuseDigital::setComiMusicState(int stateId) {
 	int l, num = -1;
 
-	if (stateId == 0)
+	if ((stateId == 0) && (stateId == 4))
 		stateId = 1000;
 
 	for (l = 0; _comiStateMusicTable[l].soundId != -1; l++) {
diff --git a/scumm/imuse_digi/dimuse_tables.cpp b/scumm/imuse_digi/dimuse_tables.cpp
index 95aaa44872..8c1d1cee77 100644
--- a/scumm/imuse_digi/dimuse_tables.cpp
+++ b/scumm/imuse_digi/dimuse_tables.cpp
@@ -24,15 +24,16 @@
 namespace Scumm {
 
 #ifdef __PALM_OS__
-imuse_music_map *_digStateMusicMap;
-const imuse_music_table *_digStateMusicTable;
-const imuse_music_table *_comiStateMusicTable;
-const imuse_music_table *_comiSeqMusicTable;
-const imuse_music_table *_digSeqMusicTable;
-const imuse_ft_music_table *_ftStateMusicTable;
-const imuse_ft_music_table *_ftSeqMusicTable;
+const imuseRoomMap *_digStateMusicMap;
+const imuseDigTable *_digStateMusicTable;
+const imuseDigTable *_digSeqMusicTable;
+const imuseComiTable *_comiStateMusicTable;
+const imuseComiTable *_comiSeqMusicTable;
+const imuseFtStateTable *_ftStateMusicTable;
+const imuseFtSeqTable *_ftSeqMusicTable;
+const imuseFtNames *_ftSeqNames;
 #else
-imuse_music_map _digStateMusicMap[] = {
+const imuseRoomMap _digStateMusicMap[] = {
 	{0,   0,  0,  0,  0,  0 },
 	{1,   0,  0,  0,  0,  0 },
 	{2,   2,  0,  0,  0,  0 },
@@ -150,143 +151,143 @@ imuse_music_map _digStateMusicMap[] = {
 	{-1,  1,  0,  0,  0,  0 }
 };
 
-const imuseDigtable _digStateMusicTable[] = {
-	{0,   1000, 0, 0, 0, 0, "STATE_NULL",           "",                     ""},
-	{1,   1001, 0, 0, 0, 0, "stateNoChange",        "",                     ""},
-	{2,   1100, 0, 3, 2, 0, "stateAstShip",         "Asteroid (amb-ship)",  "ASTERO~1.IMU"},
-	{3,   1120, 0, 3, 2, 0, "stateAstClose",        "Asteroid (amb-close)", "ASTERO~2.IMU"},
-	{4,   1140, 0, 3, 0, 0, "stateAstInside",       "Asteroid (inside)",    "ASTERO~3.IMU"},
-	{5,   1150, 0, 3, 0, 0, "stateAstCore",         "Asteroid (core)",      "ASTERO~4.IMU"},
-	{6,   1200, 0, 3, 0, 0, "stateCanyonClose",     "Canyon (close)",       "CANYON~1.IMU"},
-	{7,   1205, 0, 3, 0, 0, "stateCanyonClose_m",   "Canyon (close-m)",     "CANYON~2.IMU"},
-	{8,   1210, 0, 3, 0, 0, "stateCanyonOver",      "Canyon (over)",        "CANYON~3.IMU"},
-	{9,   1220, 0, 3, 0, 0, "stateCanyonWreck",     "Canyon (wreck)",       "CANYON~4.IMU"},
-	{10,  1300, 0, 3,10, 0, "stateNexusCanyon",     "Nexus (plan)",         "NEXUS(~1.IMU"},
-	{11,  1310, 0, 3,10, 0, "stateNexusPlan",       "Nexus (plan)",         "NEXUS(~1.IMU"},
-	{12,  1320, 0, 3,10, 0, "stateNexusRamp",       "Nexus (ramp)",         "NEXUS(~2.IMU"},
-	{13,  1330, 0, 3,10, 0, "stateNexusMuseum",     "Nexus (museum)",       "NEXUS(~3.IMU"},
-	{14,  1340, 0, 3,10, 0, "stateNexusMap",        "Nexus (map)",          "NEXUS(~4.IMU"},
-	{15,  1350, 0, 3,10, 0, "stateNexusTomb",       "Nexus (tomb)",         "NE3706~5.IMU"},
-	{16,  1360, 0, 3,10, 0, "stateNexusCath",       "Nexus (cath)",         "NE3305~5.IMU"},
-	{17,  1370, 0, 3, 0, 0, "stateNexusAirlock",    "Nexus (airlock)",      "NE2D3A~5.IMU"},
-	{18,  1380, 0, 3, 0, 0, "stateNexusPowerOff",   "Nexus (power)",        "NE8522~5.IMU"},
-	{19,  1400, 0, 3, 0, 0, "stateMuseumTramNear",  "Tram (mu-near)",       "TRAM(M~1.IMU"},
-	{20,  1410, 0, 3, 0, 0, "stateMuseumTramFar",   "Tram (mu-far)",        "TRAM(M~2.IMU"},
-	{21,  1420, 0, 3, 0, 0, "stateMuseumLockup",    "Museum (lockup)",      "MUSEUM~1.IMU"},
-	{22,  1433, 0, 3,22, 0, "stateMuseumPool",      "Museum (amb-pool)",    "MUSEUM~2.IMU"},
-	{23,  1436, 0, 3,22, 0, "stateMuseumSpire",     "Museum (amb-spire)",   "MUSEUM~3.IMU"},
-	{24,  1440, 0, 3,22, 0, "stateMuseumMuseum",    "Museum (amb-mu)",      "MUSEUM~4.IMU"},
-	{25,  1450, 0, 3, 0, 0, "stateMuseumLibrary",   "Museum (library)",     "MUB575~5.IMU"},
-	{26,  1460, 0, 3, 0, 0, "stateMuseumCavern",    "Museum (cavern)",      "MUF9BE~5.IMU"},
-	{27,  1500, 0, 3, 0, 0, "stateTombTramNear",    "Tram (tomb-near)",     "TRAM(T~1.IMU"},
-	{28,  1510, 0, 3,28, 0, "stateTombBase",        "Tomb (amb-base)",      "TOMB(A~1.IMU"},
-	{29,  1520, 0, 3,28, 0, "stateTombSpire",       "Tomb (amb-spire)",     "TOMB(A~2.IMU"},
-	{30,  1530, 0, 3,28, 0, "stateTombCave",        "Tomb (amb-cave)",      "TOMB(A~3.IMU"},
-	{31,  1540, 0, 3,31, 0, "stateTombCrypt",       "Tomb (crypt)",         "TOMB(C~1.IMU"},
-	{32,  1550, 0, 3,31, 0, "stateTombGuards",      "Tomb (crypt-guards)",  "TOMB(C~2.IMU"},
-	{33,  1560, 0, 3, 0, 0, "stateTombInner",       "Tomb (inner)",         "TOMB(I~1.IMU"},
-	{34,  1570, 0, 3, 0, 0, "stateTombCreator1",    "Tomb (creator 1)",     "TOMB(C~3.IMU"},
-	{35,  1580, 0, 3, 0, 0, "stateTombCreator2",    "Tomb (creator 2)",     "TOMB(C~4.IMU"},
-	{36,  1600, 0, 3, 0, 0, "statePlanTramNear",    "Tram (plan-near)",     "TRAM(P~1.IMU"},
-	{37,  1610, 0, 3, 0, 0, "statePlanTramFar",     "Tram (plan-far)",      "TRAM(P~2.IMU"},
-	{38,  1620, 0, 3,38, 0, "statePlanBase",        "Plan (amb-base)",      "PLAN(A~1.IMU"},
-	{39,  1630, 0, 3,38, 0, "statePlanSpire",       "Plan (amb-spire)",     "PLAN(A~2.IMU"},
-	{40,  1650, 0, 3, 0, 0, "statePlanDome",        "Plan (dome)",          "PLAN(D~1.IMU"},
-	{41,  1700, 0, 3, 0, 0, "stateMapTramNear",     "Tram (map-near)",      "TRAM(M~3.IMU"},
-	{42,  1710, 0, 3, 0, 0, "stateMapTramFar",      "Tram (map-far)",       "TRAM(M~4.IMU"},
-	{43,  1720, 0, 3,43, 0, "stateMapCanyon",       "Map (amb-canyon)",     "MAP(AM~1.IMU"},
-	{44,  1730, 0, 3,43, 0, "stateMapExposed",      "Map (amb-exposed)",    "MAP(AM~2.IMU"},
-	{45,  1750, 0, 3,43, 0, "stateMapNestEmpty",    "Map (amb-nest)",       "MAP(AM~4.IMU"},
-	{46,  1760, 0, 3, 0, 0, "stateMapNestMonster",  "Map (monster)",        "MAP(MO~1.IMU"},
-	{47,  1770, 0, 3, 0, 0, "stateMapKlein",        "Map (klein)",          "MAP(KL~1.IMU"},
-	{48,  1800, 0, 3, 0, 0, "stateCathTramNear",    "Tram (cath-near)",     "TRAM(C~1.IMU"},
-	{49,  1810, 0, 3, 0, 0, "stateCathTramFar",     "Tram (cath-far)",      "TRAM(C~2.IMU"},
-	{50,  1820, 0, 3,50, 0, "stateCathLab",         "Cath (amb-inside)",    "CATH(A~1.IMU"},
-	{51,  1830, 0, 3,50, 0, "stateCathOutside",     "Cath (amb-outside)",   "CATH(A~2.IMU"},
-	{52,  1900, 0, 3,52, 0, "stateWorldMuseum",     "World (museum)",       "WORLD(~1.IMU"},
-	{53,  1901, 0, 3,52, 0, "stateWorldPlan",       "World (plan)",         "WORLD(~2.IMU"},
-	{54,  1902, 0, 3,52, 0, "stateWorldTomb",       "World (tomb)",         "WORLD(~3.IMU"},
-	{55,  1903, 0, 3,52, 0, "stateWorldMap",        "World (map)",          "WORLD(~4.IMU"},
-	{56,  1904, 0, 3,52, 0, "stateWorldCath",       "World (cath)",         "WO3227~5.IMU"},
-	{57,  1910, 0, 3, 0, 0, "stateEye1",            "Eye 1",                "EYE1~1.IMU"},
-	{58,  1911, 0, 3, 0, 0, "stateEye2",            "Eye 2",                "EYE2~1.IMU"},
-	{59,  1912, 0, 3, 0, 0, "stateEye3",            "Eye 3",                "EYE3~1.IMU"},
-	{60,  1913, 0, 3, 0, 0, "stateEye4",            "Eye 4",                "EYE4~1.IMU"},
-	{61,  1914, 0, 3, 0, 0, "stateEye5",            "Eye 5",                "EYE5~1.IMU"},
-	{62,  1915, 0, 3, 0, 0, "stateEye6",            "Eye 6",                "EYE6~1.IMU"},
-	{63,  1916, 0, 3, 0, 0, "stateEye7",            "Eye 7",                "EYE7~1.IMU"},
-	{-1,  -1,   0, 0, 0, 0, "",                     "",                     ""}
+const imuseDigTable _digStateMusicTable[] = {
+	{"",                     0, 1000, "STATE_NULL",          0, ""},
+	{"",                     0, 1001, "stateNoChange",       0, ""},
+	{"Asteroid (amb-ship)",  3, 1100, "stateAstShip",        2, "ASTERO~1.IMU"},
+	{"Asteroid (amb-close)", 3, 1120, "stateAstClose",       2, "ASTERO~2.IMU"},
+	{"Asteroid (inside)",    3, 1140, "stateAstInside",      0, "ASTERO~3.IMU"},
+	{"Asteroid (core)",      3, 1150, "stateAstCore",        0, "ASTERO~4.IMU"},
+	{"Canyon (close)",       3, 1200, "stateCanyonClose",    0, "CANYON~1.IMU"},
+	{"Canyon (close-m)",     3, 1205, "stateCanyonClose_m",  0, "CANYON~2.IMU"},
+	{"Canyon (over)",        3, 1210, "stateCanyonOver",     0, "CANYON~3.IMU"},
+	{"Canyon (wreck)",       3, 1220, "stateCanyonWreck",    0, "CANYON~4.IMU"},
+	{"Nexus (plan)",         3, 1300, "stateNexusCanyon",   10, "NEXUS(~1.IMU"},
+	{"Nexus (plan)",         3, 1310, "stateNexusPlan",     10, "NEXUS(~1.IMU"},
+	{"Nexus (ramp)",         3, 1320, "stateNexusRamp",     10, "NEXUS(~2.IMU"},
+	{"Nexus (museum)",       3, 1330, "stateNexusMuseum",   10, "NEXUS(~3.IMU"},
+	{"Nexus (map)",          3, 1340, "stateNexusMap",      10, "NEXUS(~4.IMU"},
+	{"Nexus (tomb)",         3, 1350, "stateNexusTomb",     10, "NE3706~5.IMU"},
+	{"Nexus (cath)",         3, 1360, "stateNexusCath",     10, "NE3305~5.IMU"},
+	{"Nexus (airlock)",      3, 1370, "stateNexusAirlock",   0, "NE2D3A~5.IMU"},
+	{"Nexus (power)",        3, 1380, "stateNexusPowerOff",  0, "NE8522~5.IMU"},
+	{"Tram (mu-near)",       3, 1400, "stateMuseumTramNear", 0, "TRAM(M~1.IMU"},
+	{"Tram (mu-far)",        3, 1410, "stateMuseumTramFar",  0, "TRAM(M~2.IMU"},
+	{"Museum (lockup)",      3, 1420, "stateMuseumLockup",   0, "MUSEUM~1.IMU"},
+	{"Museum (amb-pool)",    3, 1433, "stateMuseumPool",    22, "MUSEUM~2.IMU"},
+	{"Museum (amb-spire)",   3, 1436, "stateMuseumSpire",   22, "MUSEUM~3.IMU"},
+	{"Museum (amb-mu)",      3, 1440, "stateMuseumMuseum",  22, "MUSEUM~4.IMU"},
+	{"Museum (library)",     3, 1450, "stateMuseumLibrary",  0, "MUB575~5.IMU"},
+	{"Museum (cavern)",      3, 1460, "stateMuseumCavern",   0, "MUF9BE~5.IMU"},
+	{"Tram (tomb-near)",     3, 1500, "stateTombTramNear",   0, "TRAM(T~1.IMU"},
+	{"Tomb (amb-base)",      3, 1510, "stateTombBase",      28, "TOMB(A~1.IMU"},
+	{"Tomb (amb-spire)",     3, 1520, "stateTombSpire",     28, "TOMB(A~2.IMU"},
+	{"Tomb (amb-cave)",      3, 1530, "stateTombCave",      28, "TOMB(A~3.IMU"},
+	{"Tomb (crypt)",         3, 1540, "stateTombCrypt",     31, "TOMB(C~1.IMU"},
+	{"Tomb (crypt-guards)",  3, 1550, "stateTombGuards",    31, "TOMB(C~2.IMU"},
+	{"Tomb (inner)",         3, 1560, "stateTombInner",      0, "TOMB(I~1.IMU"},
+	{"Tomb (creator 1)",     3, 1570, "stateTombCreator1",   0, "TOMB(C~3.IMU"},
+	{"Tomb (creator 2)",     3, 1580, "stateTombCreator2",   0, "TOMB(C~4.IMU"},
+	{"Tram (plan-near)",     3, 1600, "statePlanTramNear",   0, "TRAM(P~1.IMU"},
+	{"Tram (plan-far)",      3, 1610, "statePlanTramFar",    0, "TRAM(P~2.IMU"},
+	{"Plan (amb-base)",      3, 1620, "statePlanBase",      38, "PLAN(A~1.IMU"},
+	{"Plan (amb-spire)",     3, 1630, "statePlanSpire",     38, "PLAN(A~2.IMU"},
+	{"Plan (dome)",          3, 1650, "statePlanDome",       0, "PLAN(D~1.IMU"},
+	{"Tram (map-near)",      3, 1700, "stateMapTramNear",    0, "TRAM(M~3.IMU"},
+	{"Tram (map-far)",       3, 1710, "stateMapTramFar",     0, "TRAM(M~4.IMU"},
+	{"Map (amb-canyon)",     3, 1720, "stateMapCanyon",     43, "MAP(AM~1.IMU"},
+	{"Map (amb-exposed)",    3, 1730, "stateMapExposed",    43, "MAP(AM~2.IMU"},
+	{"Map (amb-nest)",       3, 1750, "stateMapNestEmpty",  43, "MAP(AM~4.IMU"},
+	{"Map (monster)",        3, 1760, "stateMapNestMonster", 0, "MAP(MO~1.IMU"},
+	{"Map (klein)",          3, 1770, "stateMapKlein",       0, "MAP(KL~1.IMU"},
+	{"Tram (cath-near)",     3, 1800, "stateCathTramNear",   0, "TRAM(C~1.IMU"},
+	{"Tram (cath-far)",      3, 1810, "stateCathTramFar",    0, "TRAM(C~2.IMU"},
+	{"Cath (amb-inside)",    3, 1820, "stateCathLab",       50, "CATH(A~1.IMU"},
+	{"Cath (amb-outside)",   3, 1830, "stateCathOutside",   50, "CATH(A~2.IMU"},
+	{"World (museum)",       3, 1900, "stateWorldMuseum",   52, "WORLD(~1.IMU"},
+	{"World (plan)",         3, 1901, "stateWorldPlan",     52, "WORLD(~2.IMU"},
+	{"World (tomb)",         3, 1902, "stateWorldTomb",     52, "WORLD(~3.IMU"},
+	{"World (map)",          3, 1903, "stateWorldMap",      52, "WORLD(~4.IMU"},
+	{"World (cath)",         3, 1904, "stateWorldCath",     52, "WO3227~5.IMU"},
+	{"Eye 1",                3, 1910, "stateEye1",           0, "EYE1~1.IMU"},
+	{"Eye 2",                3, 1911, "stateEye2",           0, "EYE2~1.IMU"},
+	{"Eye 3",                3, 1912, "stateEye3",           0, "EYE3~1.IMU"},
+	{"Eye 4",                3, 1913, "stateEye4",           0, "EYE4~1.IMU"},
+	{"Eye 5",                3, 1914, "stateEye5",           0, "EYE5~1.IMU"},
+	{"Eye 6",                3, 1915, "stateEye6",           0, "EYE6~1.IMU"},
+	{"Eye 7",                3, 1916, "stateEye7",           0, "EYE7~1.IMU"},
+	{"",                     0,   -1,  "",                   0, ""}
 };
 
-const imuseDigtable _digSeqMusicTable[] = {
-	{0, 2000, 0, 0, 0, 0, "SEQ_NULL",             "",                       ""            },
-	{0, 2005, 0, 0, 0, 0, "seqLogo",              "",                       ""            },
-	{0, 2010, 0, 0, 0, 0, "seqIntro",             "",                       ""            },
-	{0, 2020, 0, 6, 0, 0, "seqExplosion1b",       "",                       ""            },
-	{0, 2030, 0, 3, 0, 0, "seqAstTunnel1a",       "Seq (ast tunnel 1a)",    "SEQ(AS~1.IMU"},
-	{0, 2031, 0, 6, 0, 0, "seqAstTunnel2b",       "",                       ""            },
-	{0, 2032, 0, 4, 0, 0, "seqAstTunnel3a",       "Seq (ast tunnel 3a)",    "SEQ(AS~2.IMU"},
-	{0, 2040, 0, 5, 0, 0, "seqToPlanet1b",        "",                       ""            },
-	{0, 2045, 0, 4, 0, 0, "seqArgBegin",          "Seq (arg begin)",        "SEQ(AR~1.IMU"},
-	{0, 2046, 0, 4, 0, 0, "seqArgEnd",            "Seq (arg end)",          "SEQ(AR~2.IMU"},
-	{0, 2050, 0, 4, 0, 0, "seqWreckGhost",        "Seq (ghost-wreck)",      "SEQ(GH~1.IMU"},
-	{0, 2060, 0, 4, 0, 0, "seqCanyonGhost",       "Seq (ghost-canyon)",     "SEQ(GH~2.IMU"},
-	{0, 2070, 0, 0, 0, 0, "seqBrinkFall",         "",                       ""            },
-	{0, 2080, 0, 4, 0, 0, "seqPanUpCanyon",       "Seq (pan up canyon)",    "SEQ(PA~1.IMU"},
-	{0, 2091, 0, 6, 0, 0, "seqAirlockTunnel1b",   "",                       ""            },
-	{0, 2100, 0, 6, 0, 0, "seqTramToMu",          "",                       ""            },
-	{0, 2101, 0, 6, 0, 0, "seqTramFromMu",        "",                       ""            },
-	{0, 2102, 0, 6, 0, 0, "seqTramToTomb",        "",                       ""            },
-	{0, 2103, 0, 6, 0, 0, "seqTramFromTomb",      "",                       ""            },
-	{0, 2104, 0, 6, 0, 0, "seqTramToPlan",        "",                       ""            },
-	{0, 2105, 0, 6, 0, 0, "seqTramFromPlan",      "",                       ""            },
-	{0, 2106, 0, 6, 0, 0, "seqTramToMap",         "",                       ""            },
-	{0, 2107, 0, 6, 0, 0, "seqTramFromMap",       "",                       ""            },
-	{0, 2108, 0, 6, 0, 0, "seqTramToCath",        "",                       ""            },
-	{0, 2109, 0, 6, 0, 0, "seqTramFromCath",      "",                       ""            },
-	{0, 2110, 0, 0, 0, 0, "seqMuseumGhost",       "",                       ""            },
-	{0, 2120, 0, 0, 0, 0, "seqSerpentAppears",    "",                       ""            },
-	{0, 2130, 0, 0, 0, 0, "seqSerpentEats",       "",                       ""            },
-	{0, 2140, 0, 6, 0, 0, "seqBrinkRes1b",        "",                       ""            },
-	{0, 2141, 0, 4, 0, 0, "seqBrinkRes2a",        "Seq (brink's madness)",  "SEQ(BR~1.IMU"},
-	{0, 2150, 0, 3, 0, 0, "seqLockupEntry",       "Seq (brink's madness)",  "SEQ(BR~1.IMU"},
-	{0, 2160, 0, 0, 0, 0, "seqSerpentExplodes",   "",                       ""            },
-	{0, 2170, 0, 4, 0, 0, "seqSwimUnderwater",    "Seq (descent)",          "SEQ(DE~1.IMU"},
-	{0, 2175, 0, 4, 0, 0, "seqWavesPlunge",       "Seq (plunge)",           "SEQ(PL~1.IMU"},
-	{0, 2180, 0, 0, 0, 0, "seqCryptOpens",        "",                       ""            },
-	{0, 2190, 0, 0, 0, 0, "seqGuardsFight",       "",                       ""            },
-	{0, 2200, 0, 3, 0, 0, "seqCreatorRes1.1a",    "Seq (creator res 1.1a)", "SEQ(CR~1.IMU"},
-	{0, 2201, 0, 6, 0, 0, "seqCreatorRes1.2b",    "",                       ""            },
-	{0, 2210, 0, 6, 0, 0, "seqMaggieCapture1b",   "",                       ""            },
-	{0, 2220, 0, 3, 0, 0, "seqStealCrystals",     "Seq (brink's madness)",  "SEQ(BR~1.IMU"},
-	{0, 2230, 0, 0, 0, 0, "seqGetByMonster",      "",                       ""            },
-	{0, 2240, 0, 6, 0, 0, "seqKillMonster1b",     "",                       ""            },
-	{0, 2250, 0, 3, 0, 0, "seqCreatorRes2.1a",    "Seq (creator res 2.1a)", "SEQ(CR~2.IMU"},
-	{0, 2251, 0, 6, 0, 0, "seqCreatorRes2.2b",    "",                       ""            },
-	{0, 2252, 0, 4, 0, 0, "seqCreatorRes2.3a",    "Seq (creator res 2.3a)", "SEQ(CR~3.IMU"},
-	{0, 2260, 0, 0, 0, 0, "seqMaggieInsists",     "",                       ""            },
-	{0, 2270, 0, 0, 0, 0, "seqBrinkHelpCall",     "",                       ""            },
-	{0, 2280, 0, 3, 0, 0, "seqBrinkCrevice1a",    "Seq (brink crevice 1a)", "SEQ(BR~2.IMU"},
-	{0, 2281, 0, 3, 0, 0, "seqBrinkCrevice2a",    "Seq (brink crevice 2a)", "SEQ(BR~3.IMU"},
-	{0, 2290, 0, 6, 0, 0, "seqCathAccess1b",      "",                       ""            },
-	{0, 2291, 0, 4, 0, 0, "seqCathAccess2a",      "Seq (cath access 2a)",   "SEQ(CA~1.IMU"},
-	{0, 2300, 0, 3, 0, 0, "seqBrinkAtGenerator",  "Seq (brink's madness)",  "SEQ(BR~1.IMU"},
-	{0, 2320, 0, 6, 0, 0, "seqFightBrink1b",      "",                       ""            },
-	{0, 2340, 0, 6, 0, 0, "seqMaggieDies1b",      "",                       ""            },
-	{0, 2346, 0, 6, 0, 0, "seqMaggieRes1b",       "",                       ""            },
-	{0, 2347, 0, 4, 0, 0, "seqMaggieRes2a",       "Seq (maggie res 2a)",    "SEQ(MA~1.IMU"},
-	{0, 2350, 0, 0, 0, 0, "seqCreatureFalls",     "",                       ""            },
-	{0, 2360, 0, 5, 0, 0, "seqFinale1b",          "",                       ""            },
-	{0, 2370, 0, 3, 0, 0, "seqFinale2a",          "Seq (finale 2a)",        "SEQ(FI~1.IMU"},
-	{0, 2380, 0, 6, 0, 0, "seqFinale3b1",         "",                       ""            },
-	{0, 2390, 0, 6, 0, 0, "seqFinale3b2",         "",                       ""            },
-	{0, 2400, 0, 3, 0, 0, "seqFinale4a",          "Seq (finale 4a)",        "SEQ(FI~2.IMU"},
-	{0, 2410, 0, 3, 0, 0, "seqFinale5a",          "Seq (finale 5a)",        "SEQ(FI~3.IMU"},
-	{0, 2420, 0, 3, 0, 0, "seqFinale6a",          "Seq (finale 6a)",        "SEQ(FI~4.IMU"},
-	{0, 2430, 0, 3, 0, 0, "seqFinale7a",          "Seq (finale 7a)",        "SE3D2B~5.IMU"},
-	{0, 2440, 0, 6, 0, 0, "seqFinale8b",          "",                       ""            },
-	{0, 2450, 0, 4, 0, 0, "seqFinale9a",          "Seq (finale 9a)",        "SE313B~5.IMU"},
-	{-1,  -1, 0, 0, 0, 0, "",                     "",                       ""            }
+const imuseDigTable _digSeqMusicTable[] = {
+	{"",                       0, 2000, "SEQ_NULL",            0, ""},
+	{"",                       0, 2005, "seqLogo",             0, ""},
+	{"",                       0, 2010, "seqIntro",            0, ""},
+	{"",                       6, 2020, "seqExplosion1b",      0, ""},
+	{"Seq (ast tunnel 1a)",    3, 2030, "seqAstTunnel1a",      0, "SEQ(AS~1.IMU"},
+	{"",                       6, 2031, "seqAstTunnel2b",      0, ""},
+	{"Seq (ast tunnel 3a)",    4, 2032, "seqAstTunnel3a",      0, "SEQ(AS~2.IMU"},
+	{"",                       5, 2040, "seqToPlanet1b",       0, ""},
+	{"Seq (arg begin)",        4, 2045, "seqArgBegin",         0, "SEQ(AR~1.IMU"},
+	{"Seq (arg end)",          4, 2046, "seqArgEnd",           0, "SEQ(AR~2.IMU"},
+	{"Seq (ghost-wreck)",      4, 2050, "seqWreckGhost",       0, "SEQ(GH~1.IMU"},
+	{"Seq (ghost-canyon)",     4, 2060, "seqCanyonGhost",      0, "SEQ(GH~2.IMU"},
+	{"",                       0, 2070, "seqBrinkFall",        0, ""},
+	{"Seq (pan up canyon)",    4, 2080, "seqPanUpCanyon",      0, "SEQ(PA~1.IMU"},
+	{"",                       6, 2091, "seqAirlockTunnel1b",  0, ""},
+	{"",                       6, 2100, "seqTramToMu",         0, ""},
+	{"",                       6, 2101, "seqTramFromMu",       0, ""},
+	{"",                       6, 2102, "seqTramToTomb",       0, ""},
+	{"",                       6, 2103, "seqTramFromTomb",     0, ""},
+	{"",                       6, 2104, "seqTramToPlan",       0, ""},
+	{"",                       6, 2105, "seqTramFromPlan",     0, ""},
+	{"",                       6, 2106, "seqTramToMap",        0, ""},
+	{"",                       6, 2107, "seqTramFromMap",      0, ""},
+	{"",                       6, 2108, "seqTramToCath",       0, ""},
+	{"",                       6, 2109, "seqTramFromCath",     0, ""},
+	{"",                       0, 2110, "seqMuseumGhost",      0, ""},
+	{"",                       0, 2120, "seqSerpentAppears",   0, ""},
+	{"",                       0, 2130, "seqSerpentEats",      0, ""},
+	{"",                       6, 2140, "seqBrinkRes1b",       0, ""},
+	{"Seq (brink's madness)",  4, 2141, "seqBrinkRes2a",       0, "SEQ(BR~1.IMU"},
+	{"Seq (brink's madness)",  3, 2150, "seqLockupEntry",      0, "SEQ(BR~1.IMU"},
+	{"",                       0, 2160, "seqSerpentExplodes",  0, ""},
+	{"Seq (descent)",          4, 2170, "seqSwimUnderwater",   0, "SEQ(DE~1.IMU"},
+	{"Seq (plunge)",           4, 2175, "seqWavesPlunge",      0, "SEQ(PL~1.IMU"},
+	{"",                       0, 2180, "seqCryptOpens",       0, ""},
+	{"",                       0, 2190, "seqGuardsFight",      0, ""},
+	{"Seq (creator res 1.1a)", 3, 2200, "seqCreatorRes1.1a",   0, "SEQ(CR~1.IMU"},
+	{"",                       6, 2201, "seqCreatorRes1.2b",   0, ""},
+	{"",                       6, 2210, "seqMaggieCapture1b",  0, ""},
+	{"Seq (brink's madness)",  3, 2220, "seqStealCrystals",    0, "SEQ(BR~1.IMU"},
+	{"",                       0, 2230, "seqGetByMonster",     0, ""},
+	{"",                       6, 2240, "seqKillMonster1b",    0, ""},
+	{"Seq (creator res 2.1a)", 3, 2250, "seqCreatorRes2.1a",   0, "SEQ(CR~2.IMU"},
+	{"",                       6, 2251, "seqCreatorRes2.2b",   0, ""},
+	{"Seq (creator res 2.3a)", 4, 2252, "seqCreatorRes2.3a",   0, "SEQ(CR~3.IMU"},
+	{"",                       0, 2260, "seqMaggieInsists",    0, ""},
+	{"",                       0, 2270, "seqBrinkHelpCall",    0, ""},
+	{"Seq (brink crevice 1a)", 3, 2280, "seqBrinkCrevice1a",   0, "SEQ(BR~2.IMU"},
+	{"Seq (brink crevice 2a)", 3, 2281, "seqBrinkCrevice2a",   0, "SEQ(BR~3.IMU"},
+	{"",                       6, 2290, "seqCathAccess1b",     0, ""},
+	{"Seq (cath access 2a)",   4, 2291, "seqCathAccess2a",     0, "SEQ(CA~1.IMU"},
+	{"Seq (brink's madness)",  3, 2300, "seqBrinkAtGenerator", 0, "SEQ(BR~1.IMU"},
+	{"",                       6, 2320, "seqFightBrink1b",     0, ""},
+	{"",                       6, 2340, "seqMaggieDies1b",     0, ""},
+	{"",                       6, 2346, "seqMaggieRes1b",      0, ""},
+	{"Seq (maggie res 2a)",    4, 2347, "seqMaggieRes2a",      0, "SEQ(MA~1.IMU"},
+	{"",                       0, 2350, "seqCreatureFalls",    0, ""},
+	{"",                       5, 2360, "seqFinale1b",         0, ""},
+	{"Seq (finale 2a)",        3, 2370, "seqFinale2a",         0, "SEQ(FI~1.IMU"},
+	{"",                       6, 2380, "seqFinale3b1",        0, ""},
+	{"",                       6, 2390, "seqFinale3b2",        0, ""},
+	{"Seq (finale 4a)",        3, 2400, "seqFinale4a",         0, "SEQ(FI~2.IMU"},
+	{"Seq (finale 5a)",        3, 2410, "seqFinale5a",         0, "SEQ(FI~3.IMU"},
+	{"Seq (finale 6a)",        3, 2420, "seqFinale6a",         0, "SEQ(FI~4.IMU"},
+	{"Seq (finale 7a)",        3, 2430, "seqFinale7a",         0, "SE3D2B~5.IMU"},
+	{"",                       6, 2440, "seqFinale8b",         0, ""},
+	{"Seq (finale 9a)",        4, 2450, "seqFinale9a",         0, "SE313B~5.IMU"},
+	{"",                       0,   -1, "",                    0, ""}
 };
 
 const imuseComiTable _comiStateMusicTable[] = {