new video engine (expect broken non-sdl builds),

simon the sorcerer 1 & 2 support (non SCUMM games)

svn-id: r3912

4 files changed, 10697 insertions, 0 deletions

diff --git a/simon/midi.cpp b/simon/midi.cpp
new file mode 100644
index 0000000000..79bcb47c8f
--- /dev/null
+++ b/simon/midi.cpp
@@ -0,0 +1,704 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+
+#include "stdafx.h"
+#include "scummsys.h"
+#include "system.h"
+#include "simon.h"
+
+
+void MidiPlayer::read_from_file(void *dst, uint size) {
+	if (fread(dst, size, 1, _input) != 1)
+		error("Midi read error");
+}
+
+byte MidiPlayer::read_byte_from_file() {
+	byte num;
+	read_from_file(&num, 1);
+	return num;
+}
+
+uint32 MidiPlayer::read_uint32_from_file() {
+	uint32 num;
+	read_from_file(&num, 4);
+	return swap32(num);
+}
+
+uint16 MidiPlayer::read_uint16_from_file() {
+	uint16 num;
+	read_from_file(&num, 2);
+	return swap16(num);
+}
+
+void MidiPlayer::read_all_songs(FILE *in) {
+	uint i,num;
+	
+	_input = in;
+
+	_midi_cur_song_ptr = _midi_songs;
+
+	num = read_byte_from_file();
+
+	for(i=0; i!=num; i++) {
+		read_one_song(&_midi_songs[i]);
+	}
+}
+
+void MidiPlayer::read_all_songs_old(FILE *in) {
+	uint i,num;
+	
+	_input = in;
+	_midi_cur_song_ptr = _midi_songs;
+
+	num = 1;
+
+	for(i=0; i!=num; i++) {
+		read_one_song(&_midi_songs[i]);
+	}
+}
+
+void MidiPlayer::read_mthd(Song *s, bool old) {
+	Track *t;
+	uint i;
+
+	if (!old) {
+		if (read_uint32_from_file() != 6)
+			error("Invalid 'MThd' chunk size");
+		s->midi_format = read_uint16_from_file();
+		s->num_tracks = read_uint16_from_file();
+		s->ppqn = read_uint16_from_file();
+	} else {
+		s->midi_format = 0;
+		s->num_tracks = 1;
+		s->ppqn = 0xc0;
+
+		read_uint16_from_file();
+		read_byte_from_file();
+	}
+
+	s->tracks = t = (Track*)calloc(s->num_tracks, sizeof(Track));
+	if (t == NULL)
+		error("Out of memory when allocating MIDI tracks");
+	
+	for(i=0; i!=s->num_tracks; i++, t++) {
+		if (!old) {
+			if (read_uint32_from_file() != 'MTrk')
+				error("Midi track has no 'MTrk'");
+	
+			t->data_size = read_uint32_from_file();
+		} else {
+			uint32 pos = ftell(_input);
+			fseek(_input, 0, SEEK_END);
+			uint32 end = ftell(_input);
+			fseek(_input, pos, SEEK_SET);
+			t->data_size = end - pos;
+		}
+
+		t->data_ptr = (byte*)calloc(t->data_size,1);
+		if (t->data_ptr == NULL)
+			error("Out of memory when allocating MIDI track data");
+
+		read_from_file(t->data_ptr, t->data_size);
+
+		t->data_cur_size = t->data_size;
+		t->data_cur_ptr = t->data_ptr;
+
+		t->a = 0;
+		t->last_cmd = 0;
+		t->delay = 0;
+		
+		if (t->data_cur_size == 0) {
+			t->a |= 1;
+			continue;
+		}
+		
+		t->delay = track_read_gamma(t);
+	}
+
+}
+
+
+void MidiPlayer::read_one_song(Song *s) {
+	_midi_var10 = 0;
+	
+	s->ppqn = 0;
+	s->midi_format = 0;
+	s->num_tracks = 0;
+	s->tracks = NULL;
+
+	uint32 id = read_uint32_from_file();
+
+	switch(id) {
+	case 'MThd':
+		read_mthd(s, false);
+		break;
+
+	case 'GMF\x1':
+		warning("Old style songs not properly supported yet");
+		read_mthd(s, true);
+		break;
+
+	default:
+		error("Midi song has no 'MThd'");
+	}
+
+}
+
+uint32 MidiPlayer::track_read_gamma(Track *t) {
+	uint32 sum;
+	byte b;
+
+	sum = 0;
+	do {
+		b = track_read_byte(t);
+		sum = (sum<<7) | (b & 0x7F);
+	} while (b & 0x80);
+
+	return sum;	
+}
+
+byte MidiPlayer::track_read_byte(Track *t) {
+	if (t->a & 1)
+		error("Trying to read byte from MIDI stream when end reached");
+	
+	if (!--t->data_cur_size) {
+		t->a|=1;
+	}
+
+	return *t->data_cur_ptr++;
+}
+
+void MidiPlayer::initialize() {
+	uint i;
+	MyMidiHdr *mmh;
+	MIDIPROPTIMEDIV mptd;
+	uint x;
+
+	if (_midi_stream_handle == NULL) {
+		_midi_device_id = 0;
+		check_error(midiStreamOpen(&_midi_stream_handle, &_midi_device_id, 1, 
+			(uint32)midi_callback, (uint32)this, CALLBACK_FUNCTION));
+	}
+
+	for(i=0,mmh=_prepared_headers; i!=NumPreparedHeaders; i++,mmh++) {
+		mmh->hdr.dwBufferLength = 0x400;
+		mmh->hdr.lpData = (LPSTR)calloc(0x400,1);
+		if (mmh->hdr.lpData == NULL)
+			error("Out of memory for prepared header");
+	}
+
+	for(i=0; i!=16; i++)
+		_midi_volume_table[i] = 100;
+	
+	mptd.cbStruct = sizeof(mptd);
+	mptd.dwTimeDiv = _midi_songs[0].ppqn;
+
+	check_error(midiStreamProperty(_midi_stream_handle, (byte*)&mptd, 
+		MIDIPROP_SET | MIDIPROP_TIMEDIV));
+
+	_midi_5 = 0;
+	x = 1;
+	
+	for(i=0,mmh=_prepared_headers; i!=NumPreparedHeaders; i++,mmh++) {
+		
+		fill(x, mmh);
+
+		mmh->hdr.dwBytesRecorded = mmh->b;
+		
+		if (!_midi_var9) {
+			check_error(midiOutPrepareHeader((HMIDIOUT)_midi_stream_handle, 
+				&mmh->hdr, sizeof(mmh->hdr)));
+		}
+		
+		check_error(midiStreamOut(_midi_stream_handle, 
+			&mmh->hdr, sizeof(mmh->hdr)));
+
+		x = 0;
+	}
+
+	_midi_var9 = true;
+}
+
+int MidiPlayer::fill(uint x, MyMidiHdr *mmh) {
+	uint32 best,i;
+	Track *best_track,*t;
+	bool did_reset;
+
+	mmh->a = 0;
+	mmh->size = 0x200;
+	mmh->c = 0;
+	mmh->d = 0;
+	mmh->b = 0;
+
+	did_reset = false;
+	
+	for(;;) {
+		if (mmh->size - mmh->b < 12)
+			return 1;
+		
+		best_track = NULL;
+		best = 0xFFFFFFFF;
+
+		/* Locate which track that's next */
+		t = _midi_cur_song_ptr->tracks;
+		for(i=0; i!=_midi_cur_song_ptr->num_tracks; i++,t++) {
+			if (!(t->a&1)) {
+				if (t->delay < best) {
+					best = t->delay;
+					best_track = t;
+				} 
+			}
+		}
+
+		if (best_track == NULL) {
+			/* reset tracks if song ended? */
+			if (did_reset) {
+				return 0;
+			}
+			did_reset = true;
+			reset_tracks();
+			continue;
+		}
+
+		read_next_note(best_track, &_midi_tmp_note_rec);
+//		if ((_midi_tmp_note_rec.cmd&0xF)==3) {
+//			printf("%4d: %2X %d\n", _midi_tmp_note_rec.delay,
+//				_midi_tmp_note_rec.cmd, _midi_tmp_note_rec.param_1);
+			fill_helper(&_midi_tmp_note_rec, mmh);
+//		}
+
+		if (_midi_num_sysex) {
+			free(_midi_tmp_note_rec.sysex_data);
+			_midi_num_sysex--;
+		}
+	}
+}
+
+int MidiPlayer::fill_helper(NoteRec *nr, MyMidiHdr *mmh) {
+	byte *lpdata;
+	uint b;
+
+	lpdata = (byte*)mmh->hdr.lpData + mmh->a + mmh->b;
+
+	b = nr->delay - _midi_var10;
+	_midi_var10 = nr->delay;
+	
+	if (nr->cmd<0xF0) {
+		((MIDIEVENT*)lpdata)->dwDeltaTime = b;
+		((MIDIEVENT*)lpdata)->dwStreamID = 0;
+		((MIDIEVENT*)lpdata)->dwEvent = nr->cmd | (nr->param_1<<8) | (nr->param_2<<16);
+		
+		if ((nr->cmd&0xF0) == 0xB0 && nr->param_1 == 7) {
+			_midi_volume_table[nr->cmd&0xF] = nr->param_2;
+
+			nr->param_1 = 0x76;
+
+			((MIDIEVENT*)lpdata)->dwEvent = nr->cmd | 
+				(nr->param_1<<8) | (nr->param_2<<16) | MEVT_F_CALLBACK;
+		}
+
+		mmh->b += 12;
+	} else if (nr->cmd==0xF0 || nr->cmd==0xF7) {
+	} else if (nr->param_1 != 0x51) {
+		return -105;
+	} else {
+		((MIDIEVENT*)lpdata)->dwDeltaTime = b;
+		((MIDIEVENT*)lpdata)->dwStreamID = 0;
+
+		_midi_tempo = nr->sysex_data[2] | 
+			(nr->sysex_data[1]<<8) | (nr->sysex_data[0]<<16);
+		
+		((MIDIEVENT*)lpdata)->dwEvent = _midi_tempo | (MEVT_TEMPO<<24);
+
+		_midi_var8 = (_midi_cur_song_ptr->ppqn*60000) / _midi_tempo;
+		
+		if(_midi_num_sysex) {
+			free(nr->sysex_data);
+			_midi_num_sysex--;
+		}
+	
+		mmh->b += 12;
+	}
+
+	return 0;
+}
+
+#if 0
+int MidiPlayer::fill(uint x, MyMidiHdr *mmh) {
+	Track *t;
+	uint i;
+	uint32 best;
+	Track *best_track;
+	int result;
+
+	mmh->b = 0;
+
+	if (x&1) {
+		NoteRec *nr = &_midi_tmp_note_rec;
+		
+		_midi_var1 = 0;
+		nr->delay = 0;
+		nr->big_cmd = 0;
+		nr->cmd_length = 0;
+		nr->sysex_data = NULL;
+
+		_midi_track_ptr = NULL;
+		_midi_tick_track_ptr = NULL;
+	}
+
+	if (_midi_var1 & 1) {
+		if (_midi_var2 == 0)
+			error("MidiPlayer::fill: Return -103");
+		reset_tracks();
+		_midi_var1 = 0;
+	} else if (_midi_var1 & 2) {
+		error("MidiPlayer::fill: Return -102");
+	} else if (_midi_var1 & 4) {
+		_midi_var1 ^= 4;
+		
+		if (_midi_tmp_note_rec.cmd==0xFF && _midi_tmp_note_rec.param_1==0x2F) {
+			if (_midi_num_sysex) {
+				free(_midi_tmp_note_rec.sysex_data);
+				_midi_num_sysex--;
+			}
+		} else {
+			result = fill_helper(&_midi_tmp_note_rec, mmh);
+			if (result==-104) {
+				_midi_var1 |= 4;
+				return 0;
+			}
+		}
+	}
+
+	/* find_next_track_to_run */
+	for(;;) {
+		best_track = NULL;
+		best = 0xFFFFFFFF;
+
+		/* Locate which track that's next */
+		t = _midi_cur_song_ptr->tracks;
+		for(i=0; i!=_midi_cur_song_ptr->num_tracks; i++,t++) {
+			if (!(t->a&1)) {
+				if (t->delay < best) {
+					best = t->delay;
+					best_track = t;
+				}
+			}
+		}
+
+		if (best_track == NULL) {
+			_midi_var1 |= 1;
+			return 0;
+		}
+
+		read_next_note(best_track, &_midi_tmp_note_rec);
+
+		if (_midi_tmp_note_rec.cmd==0xFF && _midi_tmp_note_rec.param_1==0x2F) {
+			if (_midi_num_sysex) {
+				free(_midi_tmp_note_rec.sysex_data);
+				_midi_num_sysex--;
+			}
+			continue;
+		}
+
+		result = fill_helper(&_midi_tmp_note_rec, mmh);
+		if (result==-104) {
+			_midi_var1 |= 4;
+			return 0;
+		}
+	}
+}
+
+int MidiPlayer::fill_helper(NoteRec *nr, MyMidiHdr *mmh) {
+	byte *lpdata;
+	uint a,b;
+
+	lpdata = (byte*)mmh->hdr.lpData + mmh->a + mmh->b;
+
+	if (mmh->b == 0) {
+		mmh->c = _midi_var10;
+	}
+
+	if (_midi_var10 - mmh->c > _midi_var8) {
+		if (mmh->d!=0) {
+			mmh->d = 0;
+			return -104;
+		}
+		mmh->d = 1;
+	}
+
+	a = _midi_var10;
+	b = nr->delay - _midi_var10;
+	_midi_var10 = nr->delay;
+	
+	if (nr->cmd<0xF0) {
+		if (mmh->size - mmh->b < 12)
+			return -104;
+
+		((MIDIEVENT*)lpdata)->dwDeltaTime = b;
+		((MIDIEVENT*)lpdata)->dwStreamID = 0;
+		((MIDIEVENT*)lpdata)->dwEvent = nr->cmd | (nr->param_1<<8) | (nr->param_2<<16);
+		
+		if ((nr->cmd&0xF0) == 0xB0 && nr->param_1 == 7) {
+			_midi_volume_table[nr->cmd&0xF] = nr->param_2;
+
+			nr->param_1 = 0x76;
+
+			((MIDIEVENT*)lpdata)->dwEvent = nr->cmd | 
+				(nr->param_1<<8) | (nr->param_2<<16) | MEVT_F_CALLBACK;
+		}
+
+		mmh->b += 12;
+	} else if (nr->cmd==0xF0 || nr->cmd==0xF7) {
+		if(_midi_num_sysex) {
+			free(nr->sysex_data);
+			_midi_num_sysex--;
+		}
+	} else if (nr->param_1 != 0x51) {
+		if(_midi_num_sysex) {
+			free(nr->sysex_data);
+			_midi_num_sysex--;
+		}
+
+		return -105;
+	} else if (mmh->size - mmh->b < 12) {
+		if(_midi_num_sysex) {
+			free(nr->sysex_data);
+			_midi_num_sysex--;
+		}
+		return -104;
+	} else {
+		((MIDIEVENT*)lpdata)->dwDeltaTime = b;
+		((MIDIEVENT*)lpdata)->dwStreamID = 0;
+
+		_midi_tempo = nr->sysex_data[2] | 
+			(nr->sysex_data[1]<<8) | (nr->sysex_data[0]<<16);
+		
+		((MIDIEVENT*)lpdata)->dwEvent = _midi_tempo | (MEVT_TEMPO<<24);
+
+		_midi_var8 = (_midi_cur_song_ptr->ppqn*60000) / _midi_tempo;
+		
+		if(_midi_num_sysex) {
+			free(nr->sysex_data);
+			_midi_num_sysex--;
+		}
+	
+		mmh->b += 12;
+	}
+
+	return 0;
+}
+#endif
+
+void MidiPlayer::add_finished_hdrs() {
+	uint i;
+	MyMidiHdr *mmh = _prepared_headers;
+
+	for(i=0; i!=NumPreparedHeaders; i++,mmh++) {
+		if (!(mmh->hdr.dwFlags & MHDR_INQUEUE)) {
+			fill(0, mmh);
+			if (mmh->b == 0)
+				break;
+			mmh->hdr.dwBytesRecorded = mmh->b;
+			check_error(midiStreamOut(_midi_stream_handle, &mmh->hdr, sizeof(mmh->hdr)));
+		}
+	}
+}
+
+void CALLBACK MidiPlayer::midi_callback(HMIDIOUT hmo, UINT wMsg,
+	DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) {
+
+	switch(wMsg) {
+	case MM_MOM_DONE:{
+		MidiPlayer *mp = ((MidiPlayer*)dwInstance);
+		if (!mp->_shutting_down)
+			mp->add_finished_hdrs();
+		break;
+		}
+	}
+}
+
+void MidiPlayer::check_error(MMRESULT result) {
+	char buf[200];
+	if (result != MMSYSERR_NOERROR) {
+		midiOutGetErrorText(result, buf, 200);
+		error("MM System Error '%s'", buf);
+	}
+}
+
+void MidiPlayer::reset_tracks() {
+	Track *t;
+	uint i;
+
+	_midi_var10 = 0;
+
+	for(i=0,t=_midi_cur_song_ptr->tracks; i!=_midi_cur_song_ptr->num_tracks; i++,t++) {
+		t->data_cur_size = t->data_size;
+		t->data_cur_ptr = t->data_ptr;
+		t->a = 0;
+		t->last_cmd = 0;
+		t->delay = 0;
+		if (t->data_cur_size==0) {
+			t->a|=1;
+		} else {
+			t->delay = track_read_gamma(t);
+		}
+	}
+}
+
+void MidiPlayer::read_next_note(Track *t, NoteRec *nr) {
+	byte cmd_byte;
+	uint i;
+
+	nr->delay = 0;
+	nr->big_cmd = 0;
+	nr->cmd_length = 0;
+	nr->sysex_data = NULL;
+	
+	if(t->a&1 || t->data_cur_size==0)
+		error("read next note when track ended");
+
+	/* read next midi byte, but skip any pitch bends. */
+	for(;;) {
+		cmd_byte = track_read_byte(t);
+		if ((cmd_byte&0xF0) != 0xE0)
+			break;
+
+		track_read_byte(t);
+		track_read_byte(t);
+	} 
+	
+	if (!(cmd_byte & 0x80)) {
+		/* running status? */
+		if (t->last_cmd==0)
+			error("Last cmd = 0");
+		nr->cmd = t->last_cmd;
+		nr->param_1 = cmd_byte;
+		cmd_byte = nr->cmd&0xF0;
+		nr->cmd_length = 2;
+		if (cmd_byte!=0xC0 && cmd_byte!=0xD0) {
+			nr->param_2 = track_read_byte(t);
+			nr->cmd_length++;
+		}
+	} else if ((cmd_byte&0xF0)!=0xF0) {
+		nr->cmd = cmd_byte;
+		t->last_cmd = cmd_byte;
+		cmd_byte &= 0xF0;
+		nr->cmd_length = (cmd_byte==0xC0 || cmd_byte==0xD0) ? 2 : 3;
+		
+		if (t->data_cur_size < nr->cmd_length-1) {
+			error("read_next_note: end of stream");
+		}
+		
+		nr->param_1 = track_read_byte(t);
+		if (nr->cmd_length==3)
+			nr->param_2 = track_read_byte(t);
+
+	} else if (cmd_byte==0xF0 || cmd_byte==0xF7) {
+		nr->cmd = cmd_byte;
+		nr->cmd_length = track_read_gamma(t);
+		if (t->data_cur_size < nr->cmd_length)
+			error("read_next_note: end of stream 2");
+		nr->sysex_data = (byte*)malloc(nr->cmd_length);
+		if (nr->sysex_data==NULL)
+			error("read_next_note: out of memory");
+		for(i=0; i!=nr->cmd_length; i++)
+			nr->sysex_data[i] = track_read_byte(t);
+		_midi_num_sysex++;
+	} else if (cmd_byte==0xFF) {
+		
+		nr->cmd = cmd_byte;
+		nr->param_1 = track_read_byte(t);
+		nr->cmd_length = track_read_gamma(t);
+		if (nr->cmd_length) {
+			if (t->data_cur_size < nr->cmd_length)
+				error("read_next_note: end of stream 3");
+			nr->sysex_data = (byte*)malloc(nr->cmd_length);
+			if (nr->sysex_data==NULL)
+				error("read_next_note: out of memory");
+			for(i=0; i!=nr->cmd_length; i++)
+				nr->sysex_data[i] = track_read_byte(t);
+			_midi_num_sysex++;
+		}
+		if (nr->param_1==0x2F)
+			t->a|=1;
+	} else {
+		error("Invalid sysex cmd");
+	}
+
+	nr->delay = t->delay;
+	if (!(t->a&1)) {
+		t->delay += track_read_gamma(t);
+	}
+}
+
+void MidiPlayer::shutdown() {
+	
+	if (_midi_stream_handle != NULL) {
+		_shutting_down = true;
+		
+		check_error(midiStreamStop(_midi_stream_handle));
+		check_error(midiOutReset((HMIDIOUT)_midi_stream_handle));
+
+		unload();
+		unprepare();
+
+		check_error(midiStreamClose(_midi_stream_handle));
+		_midi_stream_handle = NULL;
+
+		_shutting_down = false;
+	}
+}
+
+void MidiPlayer::unload() {
+	uint i,j;
+	Song *s;
+	Track *t;
+	for(i=0,s=_midi_songs; i!=8; i++,s++) {
+		if (s->tracks) {
+			for(j=0,t=s->tracks; j!=s->num_tracks;j++,t++) {
+				if (t->data_ptr)
+					free(t->data_ptr);
+			}
+			free(s->tracks);
+			s->tracks = NULL;
+		}
+	}
+}
+
+void MidiPlayer::unprepare() {
+	uint i;
+	MyMidiHdr *mmh = _prepared_headers;
+
+	for(i=0; i!=NumPreparedHeaders; i++,mmh++) {
+		check_error(midiOutUnprepareHeader(
+			(HMIDIOUT)_midi_stream_handle, &mmh->hdr, sizeof(mmh->hdr)));
+		free(mmh->hdr.lpData);
+		mmh->hdr.lpData = NULL;
+	}
+
+	_midi_var9 = false;
+}
+
+void MidiPlayer::play() {
+	check_error(midiStreamRestart(_midi_stream_handle));
+}
\ No newline at end of file
diff --git a/simon/simon.cpp b/simon/simon.cpp
new file mode 100644
index 0000000000..2adbc59423
--- /dev/null
+++ b/simon/simon.cpp
@@ -0,0 +1,8794 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+
+#include "stdafx.h"
+#include "scummsys.h"
+#include "system.h"
+#include "simon.h"
+
+
+#include <time.h>
+#ifdef WIN32
+#include <malloc.h>
+#endif
+#include <sys/stat.h>
+
+int sdl_mouse_x, sdl_mouse_y;
+
+byte *sdl_buf_3;
+byte *sdl_buf;
+byte *sdl_buf_attached;
+
+SimonState *g_simon;
+
+static const GameSpecificSettings simon1_settings = {
+	1, /* VGA_DELAY_BASE */
+	1576/4, /* TABLE_INDEX_BASE */
+	1460/4, /* TEXT_INDEX_BASE */
+	1700/4, /* NUM_GAME_OFFSETS */
+	64, /* NUM_VIDEO_OP_CODES */
+	1000000, /* VGA_MEM_SIZE */
+	50000, /* TABLES_MEM_SIZE */
+	3624, /* NUM_VOICE_RESOURCES */
+	1316/4, /* MUSIC_INDEX_BASE */
+	-1,			/* SOUND_INDEX_BASE */
+	"simon.gme",	/* gme_filename */
+	"simon.wav",	/* wav_filename */
+	"gamepc",			/* gamepc_filename */
+};
+
+static const GameSpecificSettings simon2_settings = {
+	5, /* VGA_DELAY_BASE */
+	1580/4, /* TABLE_INDEX_BASE */
+	1500/4, /* TEXT_INDEX_BASE */
+	2116/4, /* NUM_GAME_OFFSETS */
+	75, /* NUM_VIDEO_OP_CODES */
+	2000000, /* VGA_MEM_SIZE */
+	100000, /* TABLES_MEM_SIZE */
+	12256, /* NUM_VOICE_RESOURCES */
+	1128/4, /* MUSIC_INDEX_BASE */
+	1660/4,			/* SOUND_INDEX_BASE */
+	"simon2.gme", /* gme_filename */
+	"simon2.wav",	/* wav_filename */
+	"gsptr30",		/* gamepc_filename */
+};
+
+//#ifdef USE_2xSAI
+//#define NUM_PALETTE_FADEOUT 32
+//#else
+#define NUM_PALETTE_FADEOUT 32
+//#endif
+
+void palette_fadeout(uint32 *pal_values,uint num) {
+	byte *p = (byte*)pal_values;
+
+//#ifdef USE_2xSAI
+	do {
+		if (p[0]>=8) p[0] -= 8; else p[0] = 0;
+		if (p[1]>=8) p[1] -= 8; else p[1] = 0;
+		if (p[2]>=8) p[2] -= 8; else p[2] = 0;
+		p += sizeof(uint32);
+	} while (--num);
+//#else
+//	do {
+//		if (p[0]) p[0] -= 4;
+//		if (p[1]) p[1] -= 4;
+//		if (p[2]) p[2] -= 4;
+//		p += sizeof(uint32);
+//	} while (--num);
+
+//#endif
+
+}
+
+
+uint fileReadItemID(FILE *in) {	
+	uint32 val = fileReadBE32(in);
+	if (val==0xFFFFFFFF)
+		return 0;
+	return val + 2;
+}
+
+
+byte *SimonState::allocateItem(uint size) {
+	byte *org = _itemheap_ptr;
+	size = (size + 1) & ~1;
+
+	_itemheap_ptr += size;
+	_itemheap_curpos += size;
+
+	if (_itemheap_curpos > _itemheap_size)
+		error("Itemheap overflow");
+
+	return org;
+}
+
+byte *SimonState::allocateTable(uint size) {
+	byte *org = _tablesheap_ptr;
+	size = (size + 1) & ~1;
+
+	_tablesheap_ptr += size;
+	_tablesheap_curpos += size;
+
+	if (_tablesheap_curpos > _tablesheap_size)
+		error("Tablesheap overflow");
+
+	return org;
+}
+
+int SimonState::allocGamePcVars(FILE *in) {
+	uint item_array_size, item_array_inited, stringtable_num;
+	uint32 version;
+	uint i;
+	
+	item_array_size = fileReadBE32(in);
+	version = fileReadBE32(in);
+	item_array_inited = fileReadBE32(in);
+	stringtable_num = fileReadBE32(in);
+
+	item_array_inited += 2; /* first two items are predefined */
+	item_array_size += 2;
+
+	if (version != 0x80)
+		error("Not a runtime database");
+
+	_itemarray_ptr = (Item**)calloc(item_array_size, sizeof(Item*));
+	if (_itemarray_ptr == NULL)
+		error("Out of memory for Item array");
+
+	_itemarray_size = item_array_size;
+	_itemarray_inited = item_array_inited;
+
+	for(i=2; i!=item_array_inited; i++) {
+		_itemarray_ptr[i] = (Item*)allocateItem(sizeof(Item));
+	}
+
+	/* The rest is cleared automatically by calloc */
+	allocateStringTable(stringtable_num + 10);
+	_stringtab_num = stringtable_num;
+
+	return item_array_inited;	
+}
+
+
+Item *SimonState::allocItem1() {
+	Item *item = (Item*)allocateItem(sizeof(Item));
+	_itemarray_ptr[1] = item;
+	return item;
+}
+
+void SimonState::loginPlayerHelper(Item *item, int a, int b) {
+	Child9 *child;
+
+	child = (Child9*)findChildOfType(item, 9);
+	if (child == NULL) {
+		child = (Child9*)allocateChildBlock(item, 9, sizeof(Child9));
+	}
+
+	if (a>=0 && a<=3)
+		child->array[a] = b;
+}
+
+
+void SimonState::loginPlayer() {
+	Item *item;
+	Child *child;
+
+	item = _itemarray_ptr[1];
+	item->unk2 = -1;
+	item->unk1 = 10000;
+	_item_1 = item;
+
+	child = (Child*)allocateChildBlock(item, 3, sizeof(Child));
+	if (child == NULL)
+		error("player create failure");
+
+	loginPlayerHelper(item, 0, 0);
+}
+
+void SimonState::allocateStringTable(int num) {
+	_stringtab_ptr = (byte**)calloc(num, sizeof(byte*));
+	_stringtab_pos = 0;
+	_stringtab_numalloc = num;
+}
+
+void SimonState::setupStringTable(byte *mem, int num) {
+	int i = 0;
+	for(;;) {
+		_stringtab_ptr[i++] = mem;
+		if (--num == 0)
+			break;
+		for(;*mem;mem++);
+		mem++;
+	}
+
+	_stringtab_pos = i;
+}
+
+void SimonState::setupLocalStringTable(byte *mem, int num) {
+	int i = 0;
+	for(;;) {
+		_local_stringtable[i++] = mem;
+		if (--num == 0)
+			break;
+		for(;*mem;mem++);
+		mem++;
+	}
+}
+
+void SimonState::readGamePcText(FILE *in) {
+	uint text_size;
+	byte *text_mem;
+
+	_text_size = text_size = fileReadBE32(in);
+	text_mem = (byte*)malloc(text_size);
+	if (text_mem == NULL)
+		error("Out of text memory");
+
+	fread(text_mem, text_size, 1, in);
+
+	setupStringTable(text_mem, _stringtab_num);
+}
+
+void SimonState::readItemChildren(FILE *in, Item *item, uint tmp) {
+	if (tmp == 1) {
+		uint fr1 = fileReadBE16(in);
+		uint fr2 = fileReadBE16(in);
+		uint i, size;
+		uint j, k;
+		Child1 *child;
+
+		size = sizeof(Child1);
+		for(i=0,j=fr2; i!=6; i++, j>>=2)
+			if (j&3)
+				size += sizeof(child->array[0]);
+
+		child = (Child1*)allocateChildBlock(item, 1, size);
+		child->subroutine_id = fr1;
+		child->fr2 = fr2;
+
+		for(i=k=0,j=fr2; i!=6; i++, j>>=2)
+			if (j&3)
+				child->array[k++] = (uint16)fileReadItemID(in);
+	} else if (tmp == 2) {
+		uint32 fr = fileReadBE32(in);
+		uint i,k,size;
+		Child2 *child;
+
+		size = sizeof(Child2);
+		for(i=0; i!=16; i++)
+			if (fr & (1<<i))
+				size += sizeof(child->array[0]);
+
+		child = (Child2*)allocateChildBlock(item, 2, size);
+		child->avail_props = fr;
+
+		k = 0;
+		if (fr & 1) {
+			child->array[k++] = (uint16)fileReadBE32(in);
+		}
+		for(i=1; i!=16; i++)
+			if(fr & (1<<i))
+				child->array[k++] = fileReadBE16(in);
+
+		child->string_id = (uint16)fileReadBE32(in);
+	} else {
+		error("readItemChildren: invalid mode");
+	}
+}
+
+
+void SimonState::readItemFromGamePc(FILE *in, Item *item) {
+	uint32 tmp;
+
+	item->unk2 = fileReadBE16(in);
+	item->unk1 = fileReadBE16(in);
+	item->unk3 = fileReadBE16(in);
+	item->sibling = (uint16)fileReadItemID(in);
+	item->child = (uint16)fileReadItemID(in);
+	item->parent = (uint16)fileReadItemID(in);
+	fileReadBE16(in);
+	item->unk4 = fileReadBE16(in);
+	item->children = NULL;
+
+	tmp = fileReadBE32(in);
+	while (tmp) {
+		tmp = fileReadBE16(in);
+		if (tmp != 0)
+			readItemChildren(in, item, tmp);
+	}
+}
+
+
+static const char * const opcode_arg_table_simon1win[256] = {
+" ","I ","I ","I ","I ","I ","I ","II ","II ","II ","II ","B ","B ","BN ","BN ","BN ",
+"BN ","BB ","BB ","BB ","BB ","II ","II ","N ","I ","I ","I ","IN ","IB ","II ","I ","I ",
+"II ","II ","IBB ","BIB ","BB ","B ","BI ","IB ","B ","B ","BN ","BN ","BN ","BB ","BB ","BN ",
+"BN ","BB ","BB ","BN ","BB ","BN ","B ","I ","IB ","IB ","II ","I ","I ","IN ","B ","T ",
+"T ","NNNNNB ","BT ","BTS ","T "," ","B ","N ","IBN ","I ","I ","I ","NN "," "," ","IT ",
+"II ","I ","B "," ","IB ","IBB ","IIB ","T "," "," ","IB ","IB ","IB ","B ","BB ","IBB ",
+"NB ","N ","NBNNN ","N "," ","BNNNNNN ","B "," ","B ","B ","BB ","NNNNNIN ","N ","N ","N ","NNN ",
+"NBNN ","IBNN ","IB ","IB ","IB ","IB ","N ","N ","N ","BI "," "," ","N ","I ","IBB ","NN ",
+"N ","N ","Ban ","BB "," "," "," "," ","IB ","B "," ","II "," ","BI ","N ","I ",
+"IB ","IB ","IB ","IB ","IB ","IB ","IB ","BI ","BB ","B ","B ","B ","B ","IBB ","IBN ","IB ",
+"B ","BNBN ","BBTS ","N "," ","Ian ","B ","B ","B ","B ","T ","T ","B "," ","I "," ",
+" ","BBI ","NNBB ","BBB "," "," "," "," ","N ","N "," "," ",
+};
+
+static const char * const opcode_arg_table_simon1dos[256] = {
+" ","I ","I ","I ","I ","I ","I ","II ","II ","II ","II ","B ","B ","BN ","BN ","BN ",
+"BN ","BB ","BB ","BB ","BB ","II ","II ","N ","I ","I ","I ","IN ","IB ","II ","I ","I ",
+"II ","II ","IBB ","BIB ","BB ","B ","BI ","IB ","B ","B ","BN ","BN ","BN ","BB ","BB ","BN ",
+"BN ","BB ","BB ","BN ","BB ","BN ","B ","I ","IB ","IB ","II ","I ","I ","IN ","B ","T ",
+"T ","NNNNNB ","BT ","BT ","T "," ","B ","N ","IBN ","I ","I ","I ","NN "," "," ","IT ",
+"II ","I ","B "," ","IB ","IBB ","IIB ","T "," "," ","IB ","IB ","IB ","B ","BB ","IBB ",
+"NB ","N ","NBNNN ","N "," ","BNNNNNN ","B "," ","B ","B ","BB ","NNNNNIN ","N ","N ","N ","NNN ",
+"NBNN ","IBNN ","IB ","IB ","IB ","IB ","N ","N ","N ","BI "," "," ","N ","I ","IBB ","NN ",
+"N ","N ","Ban ","BB "," "," "," "," ","IB ","B "," ","II "," ","BI ","N ","I ",
+"IB ","IB ","IB ","IB ","IB ","IB ","IB ","BI ","BB ","B ","B ","B ","B ","IBB ","IBN ","IB ",
+"B ","BNBN ","BBT ","N "," ","Ian ","B ","B ","B ","B ","T ","T ","B "," ","I "," ",
+" ","BBI ","NNBB ","BBB "," "," "," "," ","N ","N "," "," ",
+};
+
+static const char * const opcode_arg_table_simon2win[256] = {
+" ","I ","I ","I ","I ","I ","I ","II ","II ","II ","II ","B ","B ","BN ","BN ","BN ",
+"BN ","BB ","BB ","BB ","BB ","II ","II ","N ","I ","I ","I ","IN ","IB ","II ","I ","I ",
+"II ","II ","IBB ","BIB ","BB ","B ","BI ","IB ","B ","B ","BN ","BN ","BN ","BB ","BB ","BN ",
+"BN ","BB ","BB ","BN ","BB ","BN ","B ","I ","IB ","IB ","II ","I ","I ","IN ","B ","T ",
+"T ","NNNNNB ","BT ","BTS ","T "," ","B ","N ","IBN ","I ","I ","I ","NN "," "," ","IT ",
+"II ","I ","B "," ","IB ","IBB ","IIB ","T "," "," ","IB ","IB ","IB ","B ","BB ","IBB ",
+"NB ","N ","NNBNNN ","NN "," ","BNNNNNN ","B "," ","B ","B ","BB ","NNNNNIN ","N ","N ","N ","NNN ",
+"NBNN ","IBNN ","IB ","IB ","IB ","IB ","N ","N ","N ","BI "," "," ","N ","I ","IBB ","NNB ",
+"N ","N ","Ban ","BB "," "," "," "," ","IB ","B "," ","II "," ","BI ","N ","I ",
+"IB ","IB ","IB ","IB ","IB ","IB ","IB ","BI ","BB ","B ","B ","B ","B ","IBB ","IBN ","IB ",
+"B ","BNBN ","BBTS ","N "," ","Ian ","B ","B ","B ","B ","T ","T ","B "," ","I "," ",
+" ","BBI ","NNBB ","BBB "," "," "," "," ","N ","N "," "," ","BT "," ","B "};
+
+/* read_single_opcode */
+byte *SimonState::readSingleOpcode(FILE *in, byte *ptr) {
+	int i,l;
+	const char *string_ptr;
+	uint val;
+
+	const char * const *table;
+
+	switch(_game) {
+	case GAME_SIMON1WIN: table = opcode_arg_table_simon1win; break;
+	case GAME_SIMON2WIN: table = opcode_arg_table_simon2win; break;
+	case GAME_SIMON1DOS: table = opcode_arg_table_simon1dos; break;
+	default:
+		error("Invalid game specified");
+	}
+
+	i = 0;
+
+	string_ptr = table[*ptr++];
+	for(;;) {
+		if (string_ptr[i] == ' ')
+			return ptr;
+
+		l = string_ptr[i++];
+		switch(l) {
+		case 'N':
+		case 'S':
+		case 'a':
+		case 'n':
+		case 'p':
+		case 'v':
+			val = fileReadBE16(in);
+			*ptr++ = val >> 8;
+			*ptr++ = val & 255;
+			break;
+	
+		case 'B':
+			*ptr++ = fileReadByte(in);
+			if (ptr[-1] == 0xFF) {
+				*ptr++ = fileReadByte(in);
+			}
+			break;
+
+		case 'I':
+			val = fileReadBE16(in);
+			switch(val) {
+			case 1: val = 0xFFFF; break;
+			case 3: val = 0xFFFD; break;
+			case 5: val = 0xFFFB; break;
+			case 7: val = 0xFFF9; break;
+			case 9: val = 0xFFF7; break;
+			default:
+				val = fileReadItemID(in);;
+			}
+			*ptr++ = val >> 8;
+			*ptr++ = val & 255;
+			break;
+
+		case 'T':
+			val = fileReadBE16(in);
+			switch(val) {
+			case 0:
+				val = 0xFFFF;
+				break;
+			case 3:
+				val = 0xFFFD;
+				break;
+			default:
+				val = (uint16)fileReadBE32(in);
+				break;
+			}
+			*ptr++ = val >> 8;
+			*ptr++ = val & 255;
+			break;
+
+		default:
+			error("Bad cmd table entry %c", l);
+		}
+	}
+}
+
+void SimonState::readSubroutineLine(FILE *in, SubroutineLine *sl, Subroutine *sub) {
+	byte line_buffer[1024], *q = line_buffer;
+	int size;
+	
+	if (sub->id == 0) {
+		sl->cond_a = fileReadBE16(in);
+		sl->cond_b = fileReadBE16(in);
+		sl->cond_c = fileReadBE16(in);
+	}
+
+	while ( (*q = fileReadByte(in)) != 0xFF) {
+		if (*q == 87) {
+			fileReadBE16(in);
+		} else {
+			q = readSingleOpcode(in, q);
+		}
+	}
+
+	size = q - line_buffer + 1;
+
+	memcpy(allocateTable(size), line_buffer, size);
+}
+
+SubroutineLine *SimonState::createSubroutineLine(Subroutine *sub, int where) {
+	SubroutineLine *sl, *cur_sl = NULL, *last_sl = NULL;
+
+	if (sub->id == 0)
+		sl = (SubroutineLine*)allocateTable(SUBROUTINE_LINE_BIG_SIZE);
+	else
+		sl = (SubroutineLine*)allocateTable(SUBROUTINE_LINE_SMALL_SIZE);
+
+	/* where is what offset to insert the line at, locate the proper beginning line */
+	if (sub->first != 0) {
+		cur_sl = (SubroutineLine*) ((byte*)sub + sub->first);
+		while (where) {
+			last_sl = cur_sl;
+			cur_sl = (SubroutineLine*) ((byte*)sub + cur_sl->next);
+			if ((byte*)cur_sl == (byte*)sub)
+				break;
+			where--;
+		}
+	}
+
+	if (last_sl != NULL) {
+		/* Insert the subroutine line in the middle of the link */
+		last_sl->next = (byte*)sl - (byte*)sub;
+		sl->next = (byte*)cur_sl - (byte*)sub;
+	} else {
+		/* Insert the subroutine line at the head of the link */
+		sl->next = sub->first;
+		sub->first = (byte*)sl - (byte*)sub;
+	}
+
+	return sl;
+}
+
+void SimonState::readSubroutine(FILE *in, Subroutine *sub) {
+	while (fileReadBE16(in) == 0) {
+		readSubroutineLine(in,createSubroutineLine(sub, 0xFFFF),sub);
+	}
+}
+
+Subroutine *SimonState::createSubroutine(uint id) {
+	Subroutine *sub = (Subroutine*)allocateTable(sizeof(Subroutine));
+	sub->id = id;
+	sub->first = 0;
+	sub->next = _subroutine_list;
+	_subroutine_list = sub;
+	return sub;
+}
+
+void SimonState::readSubroutineBlock(FILE *in) {
+	while (fileReadBE16(in) == 0) {
+		readSubroutine(in,createSubroutine(fileReadBE16(in)));
+	}
+}
+
+bool SimonState::loadGamePcFile(const char *filename) {
+	FILE *in;
+	int num_inited_objects;
+	int i, file_size;
+
+	/* read main gamepc file */
+	in = fopen(filename, "rb");
+	if (in==NULL) return false;
+
+	num_inited_objects = allocGamePcVars(in);
+
+	allocItem1();
+	loginPlayer();
+	readGamePcText(in);
+
+	for(i=2; i<num_inited_objects; i++) {
+		readItemFromGamePc(in, _itemarray_ptr[i]);
+	}
+
+	readSubroutineBlock(in);
+
+	fclose(in);
+
+	/* Read list of TABLE resources */
+	in = fopen("tbllist", "rb");
+	if (in==NULL) return false;
+
+	fseek(in, 0, SEEK_END);
+	file_size = ftell(in);
+
+	_tbl_list = (byte*)malloc(file_size);
+	if (_tbl_list == NULL)
+		error("Out of memory for strip table list");
+	rewind(in);
+	fread(_tbl_list, file_size, 1, in);
+	fclose(in);
+
+	/* Remember the current state */
+	_subroutine_list_org = _subroutine_list;
+	_tablesheap_ptr_org = _tablesheap_ptr;
+	_tablesheap_curpos_org = _tablesheap_curpos;
+	
+	/* Read list of TEXT resources */
+	in = fopen("stripped.txt", "rb");
+	if (in==NULL) return false;
+
+	fseek(in, 0, SEEK_END);
+	file_size = ftell(in);
+	_stripped_txt_mem = (byte*)malloc(file_size);
+	if (_stripped_txt_mem == NULL)
+		error("Out of memory for strip text list");
+	rewind(in);
+	fread(_stripped_txt_mem, file_size, 1, in);
+	fclose(in);
+
+	return true;
+}
+
+Child *SimonState::findChildOfType(Item *i, uint type) {
+	Child *child = i->children;
+	for(;child; child = child->next)
+		if (child->type == type)
+			return child;
+	return NULL;
+}
+
+bool SimonState::hasChildOfType1(Item *item) {
+	return findChildOfType1(item) != NULL;
+}
+
+bool SimonState::hasChildOfType2(Item *item) {
+	return findChildOfType2(item) != NULL;
+}
+
+Child1 *SimonState::findChildOfType1(Item *item) {
+	return (Child1*)findChildOfType(item, 1);
+}
+
+Child2 *SimonState::findChildOfType2(Item *item) {
+	return (Child2*)findChildOfType(item, 2);
+}
+
+Child3 *SimonState::findChildOfType3(Item *item) {
+	return (Child3*)findChildOfType(item, 3);
+}
+
+uint SimonState::getOffsetOfChild2Param(Child2 *child, uint prop) {
+	uint m = 1;
+	uint offset = 0;
+	while (m != prop) {
+		if (child->avail_props & m)
+			offset++;
+		m<<=1;
+	}
+	return offset;
+}
+
+
+Child *SimonState::allocateChildBlock(Item *i, uint type, uint size) {
+	Child *child = (Child*)allocateItem(size);
+	child->next = i->children;
+	i->children = child;
+	child->type = type;
+	return child;
+}
+
+void SimonState::allocItemHeap() {
+	_itemheap_size = 10000;
+	_itemheap_curpos = 0;
+	_itemheap_ptr = (byte*)calloc(10000, 1);
+}
+
+void SimonState::allocTablesHeap() {
+	_tablesheap_size = gss->TABLES_MEM_SIZE;
+	_tablesheap_curpos = 0;
+	_tablesheap_ptr = (byte*)calloc(gss->TABLES_MEM_SIZE, 1);
+}
+
+void SimonState::setItemUnk3(Item *item, int value) {
+	item->unk3 = value;
+}
+
+int SimonState::startSubroutine(Subroutine *sub) {
+	int result = -1;
+	SubroutineLine *sl;
+	byte *old_code_ptr;
+
+//	warning("startSubroutine(%d)", sub->id);
+#ifdef DUMP_START_MAINSCRIPT
+	dumpSubroutine(sub);
+#endif
+
+	old_code_ptr = _code_ptr;
+
+	if (++_recursion_depth > 40)
+		error("Recursion error");
+
+	sl = (SubroutineLine*)((byte*)sub + sub->first);
+
+	while ((byte*)sl != (byte*)sub) {
+		if (checkIfToRunSubroutineLine(sl, sub)) {
+			result = 0;
+			_code_ptr = (byte*)sl;
+			if (sub->id) _code_ptr += 2; else _code_ptr += 8;
+
+#ifdef DUMP_CONTINOUS_MAINSCRIPT
+			fprintf(_dump_file,"; %d\n", sub->id);
+#endif
+			result = runScript();
+			if (result != 0) {
+				/* result -10 means restart subroutine */
+				if (result == -10) {
+					delay(0); /* maybe leave control to the VGA */
+					sl = (SubroutineLine*)((byte*)sub + sub->first);
+					continue;
+				}
+				break;
+			}
+		}
+		sl = (SubroutineLine*)((byte*)sub + sl->next);
+	}
+
+	_code_ptr = old_code_ptr;
+
+	_recursion_depth--;
+	return result;
+}
+
+int SimonState::startSubroutineEx(Subroutine *sub) {
+	_item_1_ptr = _item_1;
+	return startSubroutine(sub);
+}
+
+bool SimonState::checkIfToRunSubroutineLine(SubroutineLine *sl, Subroutine *sub) {
+	if (sub->id)
+		return true;
+
+	if (sl->cond_a != -1 && sl->cond_a != _script_cond_a &&
+		  (sl->cond_a != -2 || _script_cond_a != -1))
+		return false;
+	
+	if (sl->cond_b != -1 && sl->cond_b != _script_cond_b &&
+		  (sl->cond_b != -2 || _script_cond_b != -1))
+		return false;
+
+	if (sl->cond_c != -1 && sl->cond_c != _script_cond_c &&
+		  (sl->cond_c != -2 || _script_cond_c != -1))
+		return false;
+
+	return true;
+}
+
+int SimonState::runScript() {
+	byte opcode;
+	bool flag, condition;
+
+	do {
+#ifdef DUMP_CONTINOUS_MAINSCRIPT
+	dumpOpcode(_code_ptr);
+#endif	
+		
+	opcode = getByte();
+	if (opcode==0xFF)
+		return 0;
+
+	if (_run_script_return_1)
+		return 1;
+
+	/* Invert condition? */
+	flag = false;
+	if (opcode==0) {
+		flag = true;
+		opcode = getByte();
+		if (opcode==0xFF)
+			return 0;
+	}
+
+	condition = true;
+	
+	switch(opcode) {
+	case 1: { /* ptrA parent is */
+		condition = (getItem1Ptr()->parent == getNextItemID());
+	} break;
+
+	case 2: { /* ptrA parent is not */
+		condition = (getItem1Ptr()->parent != getNextItemID());
+	} break;
+
+	case 5: {	/* parent is 1 */
+		condition = (getNextItemPtr()->parent == getItem1ID());
+	} break;
+
+	case 6: { /* parent isnot 1 */
+		condition = (getNextItemPtr()->parent != getItem1ID());
+	} break;
+
+	case 7: { /* parent is */
+		Item *item = getNextItemPtr();
+		condition = (item->parent == getNextItemID());
+	} break;
+
+	case 11: { /* is zero */
+		condition = (getNextVarContents() == 0);
+	} break;
+
+	case 12: { /* isnot zero */
+		condition = (getNextVarContents() != 0);
+	} break;
+
+	case 13: { /* equal */
+		uint tmp = getNextVarContents();
+		condition = (tmp == getVarOrWord());
+	} break;
+
+	case 14: { /* not equal */
+		uint tmp = getNextVarContents();
+		condition = (tmp != getVarOrWord());
+	} break;
+
+	case 15: { /* is greater */
+		uint tmp = getNextVarContents();
+		condition = (tmp > getVarOrWord());
+	} break;
+
+	case 16: { /* is less */
+		uint tmp = getNextVarContents();
+		condition = (tmp < getVarOrWord());
+	} break;
+
+	case 17: { /* is eq f */
+		uint tmp = getNextVarContents();
+		condition = (tmp == getNextVarContents());
+	} break;
+
+	case 18: { /* is not equal f */
+		uint tmp = getNextVarContents();
+		condition = (tmp != getNextVarContents());
+	} break;
+
+	case 19: { /* is greater f */
+		uint tmp = getNextVarContents();
+		condition = (tmp < getNextVarContents());
+	} break;
+
+	case 20: { /* is less f */
+		uint tmp = getNextVarContents();
+		condition = (tmp > getNextVarContents());
+	} break;
+
+	case 23: {
+		condition = o_unk_23(getVarOrWord());
+	} break;
+
+	case 25: { /* has child of type 1 */
+		condition = hasChildOfType1(getNextItemPtr());
+	} break;
+		
+	case 26: { /* has child of type 2 */
+		condition = hasChildOfType2(getNextItemPtr());
+	} break;
+
+	case 27: { /* item unk3 is */
+		Item *item = getNextItemPtr();
+		condition = ((uint)item->unk3 == getVarOrWord());
+	} break;
+
+	case 28: { /* item has prop */
+		Child2 *child = findChildOfType2(getNextItemPtr());
+		byte num = getVarOrByte();
+		condition = child!=NULL && (child->avail_props & (1<<num)) != 0;
+	} break;
+
+	case 31: { /* set no parent */
+		setItemParent(getNextItemPtr(), NULL);
+	} break;
+
+	case 33: { /* set item parent */
+		Item *item = getNextItemPtr();
+		setItemParent(item, getNextItemPtr());
+	} break;
+
+	case 36: { /* copy var */
+		uint value = getNextVarContents();
+		writeNextVarContents(value);
+	} break;
+
+	case 41: { /* zero var */
+		writeNextVarContents(0);
+	} break;
+
+	case 42: { /* set var */
+		uint var = getVarOrByte();
+		writeVariable(var, getVarOrWord());
+	} break;
+
+	case 43: { /* add */
+		uint var = getVarOrByte();
+		writeVariable(var, readVariable(var) + getVarOrWord());
+	} break;
+
+	case 44: { /* sub */
+		uint var = getVarOrByte();
+		writeVariable(var, readVariable(var) - getVarOrWord());
+	} break;
+
+	case 45: { /* add f */
+		uint var = getVarOrByte();
+		writeVariable(var, readVariable(var) + getNextVarContents());
+	} break;
+
+	case 46: { /* sub f */
+		uint var = getVarOrByte();
+		writeVariable(var, readVariable(var) - getNextVarContents());
+	} break;
+			
+	case 47: { /* mul */
+		uint var = getVarOrByte();
+		writeVariable(var, readVariable(var) * getVarOrWord());
+	} break;
+
+	case 48: { /* div */
+		uint var = getVarOrByte();
+		int value = getVarOrWord();
+		if (value == 0)
+			error("Division by zero in div");
+		writeVariable(var, readVariable(var) / value);
+	} break;
+
+	case 49: { /* mul f */
+		uint var = getVarOrByte();
+		writeVariable(var, readVariable(var) * getNextVarContents());
+	} break;
+		
+	case 50: { /* div f */
+		uint var = getVarOrByte();
+		int value = getNextVarContents();
+		if (value == 0)
+			error("Division by zero in div f");
+		writeVariable(var, readVariable(var) / value);
+	} break;
+
+	case 51: { /* mod */
+		uint var = getVarOrByte();
+		int value = getVarOrWord();
+		if (value == 0)
+			error("Division by zero in mod");
+		writeVariable(var, readVariable(var) % value);
+	} break;
+
+	case 52: { /* mod f */
+		uint var = getVarOrByte();
+		int value = getNextVarContents();
+		if (value == 0)
+			error("Division by zero in mod f");
+		writeVariable(var, readVariable(var) % value);
+	} break;
+
+	case 53: { /* random */
+		uint var = getVarOrByte();
+		uint value = (uint16)getVarOrWord();
+		uint rand_value;
+		
+		for(;;) {
+			uint value_2 = value;
+			rand_value = rand() & 0x7FFF;
+
+			if (value == 0)
+				error("Invalid random range");
+			
+			value = 0x8000 / value;
+			
+			if (value == 0)
+				error("Invalid random range");
+
+			if (rand_value / value != value_2)
+				break;
+				
+			value = value_2;
+		}
+
+		writeVariable(var, rand_value / value);
+	} break;
+
+	case 55: { /* set itemA parent */
+		setItemParent(getItem1Ptr(), getNextItemPtr());
+	} break;
+
+	case 56: { /* set child2 fr bit */
+		Child2 *child = findChildOfType2(getNextItemPtr());
+		int value = getVarOrByte();
+		if (child != NULL && value >= 0x10)
+			child->avail_props |= 1<<value;
+	} break;
+
+	case 57: { /* clear child2 fr bit */
+		Child2 *child = findChildOfType2(getNextItemPtr());
+		int value = getVarOrByte();
+		if (child != NULL && value >= 0x10)
+			child->avail_props &= ~(1<<value);
+	} break;
+
+	case 58: { /* make siblings */
+		Item *item = getNextItemPtr();
+		setItemParent(item, derefItem(getNextItemPtr()->parent));
+	} break;
+
+	case 59: { /* item inc unk3 */
+		Item *item = getNextItemPtr();
+		if (item->unk3<=30000)
+			setItemUnk3(item, item->unk3 + 1);
+	} break;
+
+	case 60: { /* item dec unk3 */
+		Item *item = getNextItemPtr();
+		if (item->unk3>=0)
+			setItemUnk3(item, item->unk3 - 1);
+	} break;
+
+	case 61: { /* item set unk3 */
+		Item *item = getNextItemPtr();
+		int value = getVarOrWord();
+		if (value<0) value = 0;
+		if (value>30000) value = 30000;
+		setItemUnk3(item, value);
+	} break;
+	
+	case 62: { /* show int */
+		showMessageFormat("%d", getNextVarContents());
+	} break;
+
+	case 63: { /* show string nl */
+		showMessageFormat("%s\n", getStringPtrByID(getNextStringID()));
+	} break;	
+
+	case 64: { /* show string */
+		showMessageFormat("%s", getStringPtrByID(getNextStringID()));
+	} break;
+
+	case 65: { /* add hit area */
+		int id = getVarOrWord();
+		int x = getVarOrWord();
+		int y = getVarOrWord();
+		int w = getVarOrWord();
+		int h = getVarOrWord();
+		int number = getVarOrByte();
+		if (number < 20)
+			addNewHitArea(id, x, y, w, h, (number<<8) + 129, 0xD0, &_dummy_item_2);
+	} break;
+	
+	case 66: { /* set array 2 */
+		uint var = getVarOrByte();
+		uint string_id = getNextStringID();
+		if (var < 20)
+			_stringid_array_2[var] = string_id;
+	} break;
+
+	case 67: { /* set array 3 and 4 */
+		if (_game == GAME_SIMON1WIN || _game&GAME_SIMON2) {
+			uint var = getVarOrByte();
+			uint string_id = getNextStringID();
+			uint value = getNextWord();
+			if (var < 20) {
+				_stringid_array_3[var] = string_id;
+				_array_4[var] = value;
+			}
+		} else {
+			uint var = getVarOrByte();
+			uint string_id = getNextStringID();
+			if (var < 20) {
+				_stringid_array_3[var] = string_id;
+			}
+		}
+	} break;
+
+	case 68: { /* exit interpreter */
+		error("Exit interpreter opcode");
+	} break;
+
+	case 69: { /* return 1 */
+		return 1;
+	}
+
+	case 70: { /* show string from array */
+		const char *str = (const char*)getStringPtrByID(_stringid_array_3[getVarOrByte()]);
+
+		if (_game & GAME_SIMON2) {
+			writeVariable(51, strlen(str)/53 * 8 + 8);
+		}
+
+		showMessageFormat("%s\n", str);
+	} break;
+
+	case 71: { /* start subroutine */
+		Subroutine *sub = getSubroutineByID(getVarOrWord());
+		if (sub != NULL)
+			startSubroutine(sub);
+	} break;
+
+	case 76: { /* add event */
+		uint timeout = getVarOrWord();
+		addTimeEvent(timeout, getVarOrWord());
+	} break;
+
+	case 77: { /* has item minus 1 */
+		condition = _subject_item != NULL;
+	} break;
+			
+	case 78: { /* has item minus 3 */
+		condition = _object_item != NULL;
+	} break;
+
+	case 79: { /* childstruct fr2 is */
+		Child2 *child = findChildOfType2(getNextItemPtr());
+		uint string_id = getNextStringID();
+		condition = (child != NULL) && child->string_id == string_id;
+	} break;
+
+	case 80: { /* item equal */
+		condition = getNextItemPtr() == getNextItemPtr();
+	} break;
+
+	case 82: { /* dummy opcode? */
+		getVarOrByte();
+	} break;
+
+	case 83: { /* restart subroutine */
+		return -10;
+	}
+
+	case 87: { /* dummy opcode? */
+		getNextStringID();
+	} break;
+
+	case 88: { /* or_lock_word */
+		_lock_word |= 0x10;
+	} break;
+
+	case 89: { /* and lock word */
+		_lock_word &= ~0x10;
+	} break;
+
+	case 90: { /* set minusitem to parent */
+		Item *item = derefItem(getNextItemPtr()->parent);
+		switch(getVarOrByte()) {
+		case 0:
+			_object_item = item;
+			break;
+		case 1:
+			_subject_item = item;
+			break;
+		default:
+			error("set minusitem to parent, invalid subcode");
+		}
+	} break;
+
+	case 91: { /* set minusitem to sibling */
+		Item *item = derefItem(getNextItemPtr()->sibling);
+		switch(getVarOrByte()) {
+		case 0:
+			_object_item = item;
+			break;
+		case 1:
+			_subject_item = item;
+			break;
+		default:
+			error("set minusitem to sibling, invalid subcode");
+		}
+	} break;
+		
+	case 92: { /* set minusitem to child */
+		Item *item = derefItem(getNextItemPtr()->child);
+		switch(getVarOrByte()) {
+		case 0:
+			_object_item = item;
+			break;
+		case 1:
+			_subject_item = item;
+			break;
+		default:
+			error("set minusitem to child, invalid subcode");
+		}
+	} break;
+
+	case 96: {
+		uint val = getVarOrWord();
+		o_set_video_mode(getVarOrByte(), val);
+	} break;
+
+	case 97: { /* load vga */
+		ensureVgaResLoadedC(getVarOrWord());
+	} break;
+
+	case 98: {
+		if (!(_game & GAME_SIMON2)) {
+			uint a = getVarOrWord();
+			uint b = getVarOrByte();
+			uint c = getVarOrWord();
+			uint d = getVarOrWord();
+			uint f = getVarOrWord();
+			start_vga_code(b, a/100, a, c, d, f);
+		} else {
+			uint a = getVarOrWord();
+			uint b = getVarOrWord();
+			uint c = getVarOrByte();
+			uint d = getVarOrWord();
+			uint e = getVarOrWord();
+			uint f = getVarOrWord();
+			start_vga_code(c,a,b,d,e,f);
+		}
+	} break;
+
+	case 99: {
+		if (!(_game & GAME_SIMON2)) {
+			o_unk_99_simon1(getVarOrWord());
+		} else {
+			uint a = getVarOrWord();
+			uint b = getVarOrWord();
+			o_unk_99_simon2(a,b);
+		}
+	} break;
+
+	case 100: {
+		o_vga_reset();
+	} break;
+
+	case 101: {
+		uint a = getVarOrByte();
+		uint b = getVarOrWord();
+		uint c = getVarOrWord();
+		uint d = getVarOrWord();
+		uint e = getVarOrWord();
+		uint f = getVarOrWord();
+		uint g = getVarOrWord();
+		o_unk26_helper(a, b, c, d, e, f, g, 0);
+	} break;
+
+	case 102: {
+		fcs_unk_2(getVarOrByte() & 7);
+	} break;
+
+	case 103: {
+		o_unk_103();
+	} break;
+
+	case 104: {
+		fcs_delete(getVarOrByte() & 7);
+	} break;
+	
+	case 107: { /* ADD_ITEM_HITAREA(id,x,y,w,h,item,unk3) */
+		uint flags = 0;
+		uint id = getVarOrWord();
+		uint params = id / 1000;
+		uint x,y,w,h,unk3;
+		Item *item;
+		
+		id = id % 1000;
+
+		if (params & 1) flags |= 8;
+		if (params & 2) flags |= 4;
+		if (params & 4) flags |= 0x80;
+		if (params & 8) flags |= 1;
+		if (params & 16) flags |= 0x10;
+
+		x = getVarOrWord();
+		y = getVarOrWord();
+		w = getVarOrWord();
+		h = getVarOrWord();
+		item = getNextItemPtrStrange();
+		unk3 = getVarOrWord();
+		if (x >= 1000) {
+			unk3 += 0x4000;
+			x -= 1000;
+		}
+		addNewHitArea(id, x, y, w, h, flags, unk3, item);
+	} break;
+
+	case 108: { /* delete hitarea */
+		delete_hitarea(getVarOrWord());
+	} break;
+
+	case 109: { /* clear hitarea bit 0x40 */
+		clear_hitarea_bit_0x40(getVarOrWord());
+	} break;
+
+	case 110: { /* set hitarea bit 0x40 */
+		set_hitarea_bit_0x40(getVarOrWord());
+	} break;
+
+	case 111: { /* set hitarea xy */
+		uint hitarea_id = getVarOrWord();
+		uint x = getVarOrWord();
+		uint y = getVarOrWord();
+		set_hitarea_x_y(hitarea_id, x, y);
+	} break;
+
+	case 114: {
+		Item *item = getNextItemPtr();
+		uint fcs_index = getVarOrByte();
+		lock();
+		fcs_unk_proc_1(fcs_index, item, 0, 0);
+		unlock();
+	} break;
+
+	case 115: { /* item has flag */
+		Item *item = getNextItemPtr();
+		condition = (item->unk4 & (1 << getVarOrByte())) != 0;
+	} break;
+
+	case 116: { /* item set flag */
+		Item *item = getNextItemPtr();
+		item->unk4 |= (1 << getVarOrByte());
+	} break;
+	
+	case 117: { /* item clear flag */
+		Item *item = getNextItemPtr();
+		item->unk4 &= ~(1 << getVarOrByte());
+	} break;
+
+	case 119: { /* WAIT_VGA */
+		uint var = getVarOrWord();
+		_scriptvar_2 = (var==200);
+		
+		if (var!=200 || !_skip_vga_wait)
+			o_wait_for_vga(var);
+		_skip_vga_wait = false;
+	} break;
+
+	case 120: {
+		o_unk_120(getVarOrWord());
+	} break;
+
+	case 121: { /* SET_VGA_ITEM */
+		uint slot = getVarOrByte();
+		_vc_item_array[slot] = getNextItemPtr();
+	} break;
+	
+	case 125: { /* item is sibling with item 1 */
+		Item *item = getNextItemPtr();
+		condition = (getItem1Ptr()->parent == item->parent);
+	} break;
+
+	case 126: {
+		Item *item = getNextItemPtr();
+		uint fcs_index = getVarOrByte();
+		uint a = 1<<getVarOrByte();
+		lock();
+		fcs_unk_proc_1(fcs_index, item, 1, a);
+		unlock();
+	} break;
+
+	case 127: { /* deals with music */
+		o_unk_127();
+	} break;
+
+	case 128: { /* dummy instruction? */
+		getVarOrWord();
+	} break;
+
+	case 129: { /* dummy instruction? */
+		getVarOrWord();
+		condition = true;
+	} break;
+
+	case 130: { /* set script cond */
+		uint a = getVarOrByte();
+		if (a == 1) {
+			getNextWord();
+			_script_cond_b = getNextWord();
+		} else {
+			getNextWord();
+			_script_cond_c = getNextWord();
+		}
+	} break;
+
+	case 132: {
+		o_save_game();
+	} break;
+
+	case 133: {
+		o_load_game();
+	} break;
+
+	case 134: {
+		warning("stopMidiMusic: not implemented");
+		/* dummy proc */
+	} break;
+
+	case 135: {
+		error("Quit if user presses Y unimplemented");
+	} break;
+
+	case 136: { /* set var to item unk3 */
+		Item *item = getNextItemPtr();
+		writeNextVarContents(item->unk3);
+	} break;
+
+	case 137: {
+		o_unk_137(getVarOrByte());
+	} break;
+
+	case 138: {
+		o_unk_138();
+	} break;
+
+	case 139: { /* SET_PARENT_SPECIAL */
+		Item *item = getNextItemPtr();
+		_no_parent_notify = true;
+		setItemParent(item, getNextItemPtr());
+		_no_parent_notify = false;
+	} break;
+
+	case 140: {
+		killAllTimers();
+		addTimeEvent(3, 0xA0);
+	} break;
+	
+	case 141: {
+		uint which = getVarOrByte();
+		Item *item = getNextItemPtr();
+		if(which == 1) {
+			_subject_item = item;
+		} else {
+			_object_item = item;
+		}
+	} break;
+
+	case 142: {
+		condition = is_hitarea_0x40_clear(getVarOrWord());
+	} break;
+
+	case 143: { /* start item sub */
+		Child1 *child = findChildOfType1(getNextItemPtr());
+		if (child != NULL) {
+			Subroutine *sub = getSubroutineByID(child->subroutine_id);
+			if (sub)
+				startSubroutine(sub);
+		}
+	} break;
+
+	case 151: { /* set array6 to item */
+		uint var = getVarOrByte();
+		Item *item = getNextItemPtr();
+		_item_array_6[var] = item;
+	} break;
+
+	case 152: { /* set m1 or m3 to array6 */
+		Item *item = _item_array_6[getVarOrByte()];
+		uint var = getVarOrByte();
+		if (var==1) {
+			_subject_item = item;
+		} else {
+			_object_item = item;
+		}
+	} break;
+
+	case 153: { /* set bit */
+		uint bit = getVarOrByte();
+		_bit_array[bit>>4] |= 1<<(bit&15);
+		break;
+	}
+
+	case 154: { /* clear bit */
+		uint bit = getVarOrByte();
+		_bit_array[bit>>4] &= ~(1<<(bit&15));
+		break;
+	}
+
+	case 155: { /* is bit clear? */
+		uint bit = getVarOrByte();
+		condition = (_bit_array[bit>>4] & (1<<(bit&15))) == 0;
+	} break;
+
+	case 156: { /* is bit set? */
+		uint bit = getVarOrByte();
+		condition = (_bit_array[bit>>4] & (1<<(bit&15))) != 0;
+	} break;
+
+	case 157: { /* get item int prop */
+		Item *item = getNextItemPtr();
+		Child2 *child = findChildOfType2(item);
+		uint prop = getVarOrByte();
+
+		if (child != NULL && child->avail_props&(1<<prop) && prop < 16) {
+			uint offs = getOffsetOfChild2Param(child, 1<<prop);
+			writeNextVarContents(child->array[offs]);
+		} else {
+			writeNextVarContents(0);	
+		}
+	} break;
+
+	case 158: { /* set item prop */
+		Item *item = getNextItemPtr();
+		Child2 *child = findChildOfType2(item);
+		uint prop = getVarOrByte();
+		int value = getVarOrWord();
+
+		if (child != NULL && child->avail_props&(1<<prop) && prop < 16) {
+			uint offs = getOffsetOfChild2Param(child, 1<<prop);
+			child->array[offs] = value;
+		}
+	} break;
+
+	case 160: {
+		o_unk_160(getVarOrByte());
+	} break;
+
+	case 161: { /* setup text */
+		uint value = getVarOrByte();
+		ThreeValues *tv;
+
+		switch(value) {
+		case 1: tv = &_threevalues_1; break;
+		case 2: tv = &_threevalues_2; break;
+		case 101: tv = &_threevalues_3; break;
+		case 102: tv = &_threevalues_4; break;
+		default:
+			error("setup text, invalid value %d", value);
+		}
+
+		tv->a = getVarOrWord();
+		tv->b = getVarOrByte();
+		tv->c = getVarOrWord();
+	} break;
+
+	case 162: {
+		o_print_str();
+	} break;
+
+	case 163: {
+		o_unk_163(getVarOrWord());
+	} break;
+
+	case 164: {
+		_show_preposition = true;
+		o_setup_cond_c();
+		_show_preposition = false;
+	} break;
+
+	case 165: {
+		Item *item = getNextItemPtr();
+		int16 a = getNextWord(),
+					b = getNextWord();
+		condition = (item->unk2 == a && item->unk1 == b);
+	} break;
+
+	case 166: { /* set bit2 */
+		uint bit = getVarOrByte();
+		_bit_array[(bit>>4)+16] |= 1<<(bit&15);
+	} break;
+		
+	case 167: { /* clear bit2 */
+		uint bit = getVarOrByte();
+		_bit_array[(bit>>4)+16] &= ~(1<<(bit&15));
+	} break;
+
+	case 168: { /* is bit clear? */
+		uint bit = getVarOrByte();
+		condition = (_bit_array[(bit>>4)+16] & (1<<(bit&15))) == 0;
+	} break;
+
+	case 169: { /* is bit set? */
+		uint bit = getVarOrByte();
+		condition = (_bit_array[(bit>>4)+16] & (1<<(bit&15))) != 0;
+	} break;
+
+	case 175: {
+		o_unk_175();
+	} break;
+
+	case 176: {
+		o_unk_176();
+	} break;
+
+	case 177: {
+		o_177();
+	} break;
+
+	case 178: { /* path find */
+		uint a = getVarOrWord();
+		uint b = getVarOrWord();
+		uint c = getVarOrByte();
+		uint d = getVarOrByte();
+		o_pathfind(a,b,c,d);
+	} break;
+
+	case 179: {
+		if (_game == GAME_SIMON1WIN) {
+			uint b = getVarOrByte();
+			uint c = getVarOrByte();
+			uint a = getVarOrByte();
+			uint d = _array_4[a];
+			if (d!=0)
+				talk_with_speech(d, b);
+		} else if (_game == GAME_SIMON1DOS) {
+			uint b = getVarOrByte();
+			uint c = getVarOrByte();
+			uint a = getVarOrByte();
+			const char *s = (const char*)getStringPtrByID(_stringid_array_3[a]);
+			ThreeValues *tv;
+			
+			switch(b) {
+			case 1: tv = &_threevalues_1; break;
+			case 2: tv = &_threevalues_2; break;
+			case 101: tv = &_threevalues_3; break;
+			case 102: tv = &_threevalues_4; break;
+			default:
+				error("setup text, invalid value %d", b);
+			}
+
+			talk_with_text(b, c, s, tv->a, tv->b, tv->c);
+		} else if (_game == GAME_SIMON2WIN) {
+			uint b = getVarOrByte();
+			uint c = getVarOrByte();
+			uint a = getVarOrByte();
+			uint d;
+			const char *s = (const char*)getStringPtrByID(_stringid_array_3[a]);
+			ThreeValues *tv;
+			
+			switch(b) {
+			case 1: tv = &_threevalues_1; break;
+			case 2: tv = &_threevalues_2; break;
+			case 101: tv = &_threevalues_3; break;
+			case 102: tv = &_threevalues_4; break;
+			default:
+				error("setup text, invalid value %d", b);
+			}
+
+			d = _array_4[a];
+			if (d!=0 && !_vk_t_toggle)
+				talk_with_speech(d, b);
+
+			if (s!=NULL && _vk_t_toggle)
+				talk_with_text(b, c, s, tv->a, tv->b, tv->c);
+		}
+	} break;
+
+	case 180: {
+		o_force_unlock();
+	} break;
+
+	case 181: {
+		o_force_lock();
+		if (_game == GAME_SIMON2WIN) {
+			fcs_unk_2(1);
+			showMessageFormat("\xC");		
+		}
+	} break;
+	
+	case 182: {
+		if (_game & GAME_SIMON2) goto invalid_opcode;
+		o_read_vgares_328();
+	} break;
+
+	case 183: {
+		if (_game & GAME_SIMON2) goto invalid_opcode;
+		o_read_vgares_23();
+	} break;
+
+	case 184: {
+		o_clear_vgapointer_entry(getVarOrWord());
+	} break;
+
+	case 185: {
+		if (_game & GAME_SIMON2) goto invalid_opcode;
+		getVarOrWord();
+	} break;
+
+	case 186: {
+		o_unk_186();
+	} break;
+
+	case 187: {
+		if (_game & GAME_SIMON2) goto invalid_opcode;
+		o_fade_to_black();
+	} break;
+
+	case 188: 
+		if (!(_game & GAME_SIMON2)) goto invalid_opcode;
+		{
+			uint i = getVarOrByte();
+			uint str = getNextStringID();
+			condition = (str<20 && _stringid_array_2[i] == str);
+		} break;
+
+	case 189: {
+		if (!(_game & GAME_SIMON2)) goto invalid_opcode;
+		_op_189_flags = 0;
+	} break;
+
+	case 190: {
+		uint i;
+		if (!(_game & GAME_SIMON2)) goto invalid_opcode;
+		i = getVarOrByte();
+		if (!(_op_189_flags&(1<<i)))
+			o_190_helper(i);
+	} break;
+
+	default:
+invalid_opcode:;
+		error("Invalid opcode '%d'", opcode);
+	}
+
+	} while (condition != flag);
+
+	return 0;
+}
+
+void SimonState::o_190_helper(uint i) {
+	warning("o_190_helper not implemented");
+}
+
+
+bool SimonState::o_unk_23(uint a) {
+	if (a == 0)
+		return 0;
+
+	if (a == 100)
+		return 1;
+
+	a += _script_unk_1;
+	if (a<=0) {
+		_script_unk_1 = 0;
+		return 0;
+	}
+	
+	if (((uint)(rand()>>5))%100 < a) {
+		if (_script_unk_1 <= 0)
+			_script_unk_1 -= 5;
+		else
+			_script_unk_1 = 0;
+		return 1;
+	}
+
+	if (_script_unk_1 >= 0)
+		_script_unk_1 += 5;
+	else
+		_script_unk_1 = 0;
+
+	return 0;
+}
+
+void SimonState::o_177() {
+	if (_game == GAME_SIMON1WIN) {
+		uint a = getVarOrByte();
+		uint b = getVarOrByte();
+		uint offs;
+		Child2 *child = findChildOfType2(getNextItemPtr());
+		if (child != NULL && child->avail_props&0x200) {
+			offs = getOffsetOfChild2Param(child, 0x200);
+			talk_with_speech(child->array[offs], a);
+		} else if (child != NULL && child->avail_props&0x100) {
+			offs = getOffsetOfChild2Param(child, 0x100);
+			talk_with_speech(child->array[offs]+3550, a);
+		}
+	} else if (_game == GAME_SIMON1DOS) {
+		uint a = getVarOrByte();
+		uint b = getVarOrByte();
+		Child2 *child = findChildOfType2(getNextItemPtr());
+		if (child!=NULL && child->avail_props&1) {
+			const char *s = (const char*)getStringPtrByID(child->array[0]);
+			ThreeValues *tv;
+			char buf[256];
+			switch(a) {
+			case 1: tv = &_threevalues_1; break;
+			case 2: tv = &_threevalues_2; break;
+			case 101: tv = &_threevalues_3; break;
+			case 102: tv = &_threevalues_4; break;
+			default:
+				error("setup text, invalid value %d", a);
+			}
+
+			if (child->avail_props&0x100) {
+				uint x = getOffsetOfChild2Param(child,0x100);
+				sprintf(buf,"%d%s",child->array[x],s);
+				s = buf;
+			}
+
+			talk_with_text(a,b,s,tv->a, tv->b,tv->c);
+		}
+	} else if (_game == GAME_SIMON2WIN) {
+		uint a = getVarOrByte();
+		uint b = getVarOrByte();
+		Child2 *child = findChildOfType2(getNextItemPtr());
+		const char *s;
+		ThreeValues *tv;
+		char buf[256];
+
+		if (child != NULL && child->avail_props&1) {
+			s = (const char*)getStringPtrByID(child->array[0]);
+			switch(a) {
+			case 1: tv = &_threevalues_1; break;
+			case 2: tv = &_threevalues_2; break;
+			case 101: tv = &_threevalues_3; break;
+			case 102: tv = &_threevalues_4; break;
+			default:
+				error("setup text, invalid value %d", a);
+			}
+		}
+
+		if (child != NULL && child->avail_props&0x200) {
+			uint var200 = child->array[getOffsetOfChild2Param(child, 0x200)];
+
+			if (child->avail_props&0x100) {
+				uint var100 = child->array[getOffsetOfChild2Param(child, 0x100)];
+
+				if (var200 == 116) var200 = var100 + 115;
+				if (var200 == 92) var200 = var100 + 98;
+				if (var200 == 99) var200 = 9;
+				if (var200 == 97) {
+					switch(var100) {
+					case 12: var200 = 109; break;
+					case 14: var200 = 108; break;
+					case 18: var200 = 107; break;
+					case 20: var200 = 106; break;
+					case 22: var200 = 105; break;
+					case 28: var200 = 104; break;
+					case 90: var200 = 103; break;
+					case 92: var200 = 102; break;
+					case 100: var200 = 51; break;
+					default:
+						error("o_177: invalid case %d", var100);
+					}
+				}
+			}
+
+			if (!_vk_t_toggle)
+				talk_with_speech(var200, a);
+		} 
+
+		if (!_vk_t_toggle)
+			return;
+
+		if (child==NULL || !(child->avail_props&1))
+			return;
+			
+		if (child->avail_props&0x100) {
+			sprintf(buf, "%d%s", child->array[getOffsetOfChild2Param(child, 0x100)], s);
+			s = buf;
+		}
+		
+		talk_with_text(a,b,s,tv->a, tv->b,tv->c); 
+	}
+}
+
+
+void SimonState::o_unk_137(uint fcs_index) {
+	FillOrCopyStruct *fcs;
+
+	fcs = _fcs_ptr_array_3[fcs_index & 7];
+	if (fcs->fcs_data == NULL)
+		return;
+	fcs_unk_proc_1(fcs_index, fcs->fcs_data->item_ptr, fcs->fcs_data->unk1, fcs->fcs_data->unk2);
+}
+
+byte SimonState::getByte() {
+	return *_code_ptr++;
+}
+
+int SimonState::getNextWord() {
+	_code_ptr += 2;
+	return (int16)((_code_ptr[-2]<<8) | _code_ptr[-1]);
+}
+
+uint SimonState::getNextStringID() {
+	return (uint16)getNextWord();
+}
+
+uint SimonState::getVarOrByte() {
+	uint a = *_code_ptr++;
+	if (a!=255)
+		return a;
+	return readVariable(*_code_ptr++);
+}
+
+uint SimonState::getVarOrWord() {
+	uint a = (_code_ptr[0]<<8) | _code_ptr[1];
+	_code_ptr += 2;
+	if (a>=30000 && a<30512)
+		return readVariable(a - 30000);
+	return a;
+}
+
+Item *SimonState::getNextItemPtr() {
+	int a = getNextWord();
+	switch(a) {
+	case -1: return _subject_item;
+	case -3: return _object_item;
+	case -5: return getItem1Ptr();
+	case -7: return getItemPtrB();
+	case -9: return derefItem(getItem1Ptr()->parent);
+	default:
+		return derefItem(a);
+	}
+}
+
+Item *SimonState::getNextItemPtrStrange() {
+	int a = getNextWord();
+	switch(a) {
+	case -1: return _subject_item;
+	case -3: return _object_item;
+	case -5: return &_dummy_item_2;
+	case -7: return NULL;
+	case -9: return &_dummy_item_3;
+	default:
+		return derefItem(a);
+	}
+}
+
+
+uint SimonState::getNextItemID() {
+	int a = getNextWord();
+	switch(a) {
+	case -1: return itemPtrToID(_subject_item);
+	case -3: return itemPtrToID(_object_item);
+	case -5: return getItem1ID();
+	case -7: return 0;
+	case -9: return getItem1Ptr()->parent;
+	default:
+		return a;
+	}
+}
+
+Item *SimonState::getItem1Ptr() {
+	if (_item_1_ptr)
+		return _item_1_ptr;	
+	return &_dummy_item_1;
+}
+
+Item *SimonState::getItemPtrB() {
+	error("getItemPtrB: is this code ever used?");
+	if (_item_ptr_B)
+		return _item_ptr_B;	
+	return &_dummy_item_1;
+}
+
+uint SimonState::getNextVarContents() {
+	return (uint16)readVariable(getVarOrByte());
+}
+
+uint SimonState::readVariable(uint variable) {
+	if (variable >= 255)
+		error("Variable %d out of range in read", variable);
+	return _variableArray[variable];
+}
+
+void SimonState::writeNextVarContents(uint16 contents) {
+	writeVariable(getVarOrByte(), contents);
+}
+
+void SimonState::writeVariable(uint variable, uint16 contents) {
+	if (variable >= 256)
+		error("Variable %d out of range in write", variable);
+	_variableArray[variable] = contents;
+}
+
+void SimonState::setItemParent(Item *item, Item *parent) {
+	Item *old_parent = derefItem(item->parent);
+
+	if (item==parent)
+		error("Trying to set item as its own parent");
+	
+	/* unlink it if it has a parent */
+	if (old_parent)
+		unlinkItem(item);
+	itemChildrenChanged(old_parent);
+	linkItem(item, parent);
+	itemChildrenChanged(parent);
+}
+
+void SimonState::itemChildrenChanged(Item *item) {
+	int i;
+	FillOrCopyStruct *fcs;
+
+	if (_no_parent_notify)
+		return;
+		
+	lock();
+
+	for(i=0; i!=8; i++) {
+		fcs = _fcs_ptr_array_3[i];
+		if (fcs && fcs->fcs_data && fcs->fcs_data->item_ptr == item) {
+			if (_fcs_data_1[i]) {
+				_fcs_data_2[i] = true;
+			} else {
+				_fcs_data_2[i] = false;
+				fcs_unk_proc_1(i, item, fcs->fcs_data->unk1, fcs->fcs_data->unk2);
+			}
+		}		
+	}	
+		
+	unlock();		
+}
+
+void SimonState::unlinkItem(Item *item) {
+	Item *first, *parent, *next;
+
+	/* cannot unlink item without parent */
+	if (item->parent == 0)
+		return;
+
+	/* get parent and first child of parent */
+	parent = derefItem(item->parent);
+	first = derefItem(parent->child);
+	
+	/* the node to remove is first in the parent's children? */
+	if (first == item) {
+		parent->child = item->sibling;
+		item->parent = 0;
+		item->sibling = 0;
+		return;
+	}
+
+	for(;;) {
+		if (!first)
+			error("unlinkItem: parent empty");
+		if (first->sibling == 0)
+			error("unlinkItem: parent does not contain child");
+
+		next = derefItem(first->sibling);
+		if (next == item) {
+			first->sibling = next->sibling;
+			item->parent = 0;
+			item->sibling = 0;
+			return;			
+		}
+		first = next;
+	}
+}
+
+void SimonState::linkItem(Item *item, Item *parent) {
+	uint id;
+	/* Don't allow that an item that is already linked is relinked */
+	if (item->parent)
+		return;
+
+	id = itemPtrToID(parent);
+	item->parent = id;
+
+	if (parent != 0) {
+		item->sibling = parent->child;
+		parent->child = itemPtrToID(item);
+	} else {
+		item->sibling = 0;
+	}
+}
+
+const byte *SimonState::getStringPtrByID(uint string_id) {
+	const byte *string_ptr;
+	byte *dst;
+
+	_free_string_slot ^= 1;	
+
+	if (string_id < 0x8000) {
+		string_ptr = _stringtab_ptr[string_id];
+	} else {
+		string_ptr = getLocalStringByID(string_id);
+	}
+
+	dst = &_stringReturnBuffer[_free_string_slot][0];
+	strcpy((char*)dst, (const char*)string_ptr);
+	return dst;
+}
+
+const byte *SimonState::getLocalStringByID(uint string_id) {
+	if (string_id < _string_id_local_min || string_id >= _string_id_local_max) {
+		loadTextIntoMem(string_id);
+	}
+	return _local_stringtable[string_id - _string_id_local_min];
+}
+
+void SimonState::loadTextIntoMem(uint string_id) {
+	byte *p;
+	char filename[30];
+	int i;
+	uint base_min = 0x8000, base_max, size;
+
+	_tablesheap_ptr = _tablesheap_ptr_new;
+	_tablesheap_curpos = _tablesheap_curpos_new;
+
+	p = _stripped_txt_mem;
+
+	/* get filename */
+	while (*p) {
+		for(i=0;*p;p++,i++)
+			filename[i] = *p;
+		filename[i] = 0;
+		p++;
+
+		base_max = (p[0]<<8) | p[1];
+		p += 2;
+
+		if (string_id < base_max) {
+			_string_id_local_min = base_min;
+			_string_id_local_max = base_max;
+			
+			_local_stringtable = (byte**)_tablesheap_ptr;
+
+			size = (base_max - base_min + 1) * sizeof(byte*);
+			_tablesheap_ptr += size;
+			_tablesheap_curpos += size;
+
+			size = loadTextFile(filename, _tablesheap_ptr);
+
+			setupLocalStringTable(_tablesheap_ptr, base_max - base_min + 1);
+
+			_tablesheap_ptr += size;
+			_tablesheap_curpos += size;
+
+			if (_tablesheap_curpos > _tablesheap_size) {
+				error("loadTextIntoMem: Out of table memory");
+			}
+			return;
+		}
+
+		base_min = base_max;
+	}
+
+	error("loadTextIntoMem: didn't find %d", string_id);
+}
+
+void SimonState::loadTablesIntoMem(uint subr_id) {
+	byte *p;
+	int i;
+	uint min_num, max_num;
+	char filename[30];
+	FILE *in;
+
+	p = _tbl_list;
+	if (p == NULL)
+			return;
+
+	while (*p) {
+		for(i=0;*p;p++,i++)
+			filename[i] = *p;
+		filename[i] = 0;
+		p++;
+
+		for(;;) {
+			min_num = (p[0]<<8) | p[1];
+			p += 2;
+
+			if (min_num==0)
+				break;
+
+			max_num = (p[0]<<8) | p[1];
+			p += 2;
+
+			if (subr_id >= min_num && subr_id <= max_num) {
+				_subroutine_list = _subroutine_list_org;
+				_tablesheap_ptr = _tablesheap_ptr_org;
+				_tablesheap_curpos = _tablesheap_curpos_org;
+				_string_id_local_min = 1;
+				_string_id_local_max = 0;
+
+				in = openTablesFile(filename);
+				readSubroutineBlock(in);
+				closeTablesFile(in);
+
+				memcpy(filename, "SFXXXX", 6);
+				readSfxFile(filename);
+
+				_tablesheap_ptr_new = _tablesheap_ptr;
+				_tablesheap_curpos_new = _tablesheap_curpos;
+
+				if (_tablesheap_curpos > _tablesheap_size)
+					error("loadTablesIntoMem: Out of table memory");
+				return;
+			}
+		}
+	}
+
+	warning("loadTablesIntoMem: didn't find %d", subr_id);
+}
+
+Subroutine *SimonState::getSubroutineByID(uint subroutine_id) {
+	Subroutine *cur;
+		
+	for(cur=_subroutine_list; cur; cur = cur->next) {
+		if (cur->id == subroutine_id)
+			return cur;
+	}
+
+	loadTablesIntoMem(subroutine_id);
+	
+	for(cur=_subroutine_list; cur; cur = cur->next) {
+		if (cur->id == subroutine_id)
+			return cur;
+	}
+
+	warning("getSubroutineByID: subroutine %d not found", subroutine_id);
+	return NULL;
+}
+
+uint SimonState::loadTextFile_gme(const char *filename, byte *dst) {
+	uint res;
+	uint32 offs;
+	uint32 size;
+
+	res = atoi(filename + 4) + gss->TEXT_INDEX_BASE - 1;
+	offs = _game_offsets_ptr[res];
+	size = _game_offsets_ptr[res+1] - offs;
+
+	resfile_read(dst, offs, size);
+
+	return size;
+}
+
+FILE *SimonState::openTablesFile_gme(const char *filename) {
+	uint res;
+	uint32 offs;
+
+	res = atoi(filename + 6) + gss->TABLE_INDEX_BASE - 1;
+	offs = _game_offsets_ptr[res];
+
+	fseek(_game_file, offs, SEEK_SET);
+	return _game_file;
+}
+
+void SimonState::closeTablesFile_gme(FILE *in) {
+	/* not needed */
+}
+
+/* Simon1DOS load tables file */
+uint SimonState::loadTextFile_simon1(const char *filename, byte *dst) {
+	FILE *fo = fopen(filename, "rb");
+	uint32 size;
+	
+	if (fo==NULL)
+		error("loadTextFile: Cannot open '%s'", filename);
+
+	fseek(fo, 0, SEEK_END);
+	size = ftell(fo);
+	rewind(fo);
+
+	if (fread(dst, size,1, fo) != 1)
+		error("loadTextFile: fread failed");
+	fclose(fo);
+
+	return size;
+}
+
+
+FILE *SimonState::openTablesFile_simon1(const char *filename) {
+	FILE *fo = fopen(filename, "rb");
+	if (fo==NULL)
+		error("openTablesFile: Cannot open '%s'", filename);
+	return fo;
+}
+
+void SimonState::closeTablesFile_simon1(FILE *in) {
+	fclose(in);
+}
+
+uint SimonState::loadTextFile(const char *filename, byte *dst) {
+	if (_game == GAME_SIMON1DOS)
+		return loadTextFile_simon1(filename, dst);
+	else
+		return loadTextFile_gme(filename, dst);
+}
+
+FILE *SimonState::openTablesFile(const char *filename) {
+	if (_game == GAME_SIMON1DOS)
+		return openTablesFile_simon1(filename);
+	else
+		return openTablesFile_gme(filename);
+}
+
+void SimonState::closeTablesFile(FILE *in) {
+	if (_game == GAME_SIMON1DOS)
+		closeTablesFile_simon1(in);
+	else
+		closeTablesFile_gme(in);
+}
+
+void SimonState::addTimeEvent(uint timeout, uint subroutine_id) {
+	TimeEvent *te = (TimeEvent*)malloc(sizeof(TimeEvent)), *first, *last = NULL;
+	time_t cur_time;
+
+	time(&cur_time);
+
+	te->time = cur_time + timeout - _base_time;
+	te->subroutine_id = subroutine_id;
+
+	first = _first_time_struct;
+	while (first) {
+		if (te->time <= first->time) {
+			if (last) {
+				last->next = te;
+				te->next = first;
+				return;
+			}
+			te->next = _first_time_struct;
+			_first_time_struct = te;
+			return;
+		}
+
+		last = first;
+		first = first->next;
+	}
+
+	if (last) {
+		last->next = te;
+		te->next = NULL;
+	} else {
+		_first_time_struct = te;
+		te->next = NULL;
+	}
+}
+
+void SimonState::delTimeEvent(TimeEvent *te) {
+	TimeEvent *cur;
+
+	if (te == _pending_delete_time_event)
+		_pending_delete_time_event = NULL;
+
+	if (te == _first_time_struct) {
+		_first_time_struct = te->next;
+		free(te);
+		return;
+	}
+
+	cur = _first_time_struct;
+	if (cur == NULL)
+		error("delTimeEvent: none available");
+	
+	for(;;) {
+		if (cur->next == NULL)
+			error("delTimeEvent: no such te");
+		if (te == cur->next) {
+			cur->next = te->next;
+			free(te);
+			return;
+		}
+		cur = cur->next;
+	}
+}
+
+void SimonState::killAllTimers() {
+	TimeEvent *cur, *next;
+
+	for(cur=_first_time_struct; cur; cur = next) {
+		next = cur->next;
+		delTimeEvent(cur);
+	}
+}
+
+bool SimonState::kickoffTimeEvents() {
+	time_t cur_time;
+	TimeEvent *te;
+	bool result = false;
+
+	time(&cur_time);
+	cur_time -= _base_time;
+
+	while ((te=_first_time_struct) != NULL && te->time<=(uint32)cur_time) {
+		result = true;
+		_pending_delete_time_event = te;
+		invokeTimeEvent(te);
+		if (_pending_delete_time_event) {
+			_pending_delete_time_event = NULL;
+			delTimeEvent(te);
+		}
+	}
+
+	return result;
+}
+
+void SimonState::invokeTimeEvent(TimeEvent *te) {
+	Subroutine *sub;
+
+	_script_cond_a = 0;
+	if (_run_script_return_1)
+		return;
+	sub = getSubroutineByID(te->subroutine_id);
+	if (sub != NULL)
+		startSubroutineEx(sub);
+	_run_script_return_1 = false;
+}
+
+void SimonState::o_setup_cond_c() {
+	Item *item = _item_1;
+
+	setup_cond_c_helper();
+
+	_item_1_ptr = item;
+	_object_item = _hitarea_object_item;
+	
+	if (_object_item == &_dummy_item_2)
+		_object_item = getItem1Ptr();
+	
+	if (_object_item == &_dummy_item_3)
+		_object_item = derefItem(getItem1Ptr()->parent);
+
+	if (_object_item != NULL) {
+		_script_cond_c = _object_item->unk1;
+	} else {
+		_script_cond_c = -1;
+	}
+}
+
+void SimonState::setup_cond_c_helper() {
+	HitArea *last;
+
+	if (_game == GAME_SIMON2WIN) {
+		_mouse_cursor = 0;
+		if (_hitarea_unk_4!=999) {
+			_mouse_cursor = 9;
+			_need_hitarea_recalc++;
+			_hitarea_unk_4 = 0;
+		}
+	}
+
+	_last_hitarea = 0;
+	_hitarea_object_item = NULL;
+	_hitarea_unk_6 = true;
+	
+	last = _last_hitarea_2_ptr;
+	defocusHitarea();
+	_last_hitarea_2_ptr = last;
+
+	for(;;) {
+		_last_hitarea = NULL;
+		_last_hitarea_3 = 0;
+		_left_button_down = 0;
+
+		do {
+			if (GetAsyncKeyState(VK_F5) != 0 && _bit_array[0]&0x200) {
+				startSubroutine170();
+				goto out_of_here;
+			}
+
+			delay(100);
+		} while (_last_hitarea_3 == (HitArea*)0xFFFFFFFF || _last_hitarea_3 == 0);
+
+		if (_last_hitarea == NULL) {
+		} else if (_last_hitarea->id == 0x7FFB) {
+			handle_unk2_hitarea(_last_hitarea->fcs);
+		} else if (_last_hitarea->id == 0x7FFC) {
+			handle_unk_hitarea(_last_hitarea->fcs);
+		} else if (_last_hitarea->item_ptr != NULL) {
+			_hitarea_object_item = _last_hitarea->item_ptr;
+			_variableArray[0x78/2] = (_last_hitarea->flags&1) ? (_last_hitarea->flags>>8) : 0xFFFF;
+			break;
+		}
+	}
+
+out_of_here:
+	_last_hitarea_3 = 0;
+	_last_hitarea = 0;
+	_last_hitarea_2_ptr = NULL;
+	_hitarea_unk_6 = false;
+}
+
+void SimonState::startSubroutine170() {
+	Subroutine *sub;
+
+	/* XXX: stop speech */
+
+	sub = getSubroutineByID(170);
+	if (sub != NULL)
+		startSubroutineEx(sub);
+
+	_run_script_return_1 = true;
+}
+
+void SimonState::defocusHitarea() {
+	HitArea *last;
+	HitArea *ha;
+
+	if (_game == GAME_SIMON2WIN) {
+		if (_bit_array[4]&0x8000) {
+			o_unk_120(202);
+			_last_hitarea_2_ptr = NULL;
+			return;
+		}
+	}
+	
+	last = _hitarea_ptr_5;
+
+	if (last == _hitarea_ptr_7)
+		return;
+
+	hitareaChangedHelper();
+	_hitarea_ptr_7 = last;
+
+	if (last != NULL && _hitarea_unk_6 &&
+			(ha = findHitAreaByID(200)) && (ha->flags&0x40) &&
+		  !(last->flags&0x40))
+			focusVerb(last->id);
+}
+
+static const char * const verb_names[] = {
+	"Walk to",
+	"Look at",
+	"Open",
+	"Move",
+
+	"Consume",
+	"Pick up",
+	"Close",
+	"Use",
+
+	"Talk to",
+	"Remove",
+	"Wear",
+	"Give"
+};
+
+static const char * const verb_prep_names[] = {
+	"","","","",
+	"","","","with what ?",
+	"","","","to whom ?"
+};
+
+void SimonState::focusVerb(uint hitarea_id) {
+	uint x;
+	const char *txt;
+
+	hitarea_id -= 101;
+
+	CHECK_BOUNDS(hitarea_id, verb_prep_names);
+	
+	if (_show_preposition) {
+		txt = verb_prep_names[hitarea_id];
+	} else {
+		txt = verb_names[hitarea_id];
+	}
+	x = (53 - strlen(txt)) * 3;
+	showActionString(x, (const byte*)txt);
+
+}
+
+void SimonState::showActionString(uint x, const byte *string) {
+	FillOrCopyStruct *fcs;
+
+	fcs = _fcs_ptr_array_3[1];
+	if (fcs ==  NULL || fcs->text_color==0)
+		return;
+
+	fcs->unk1 = x >> 3;
+	fcs->unk3 = x & 7;
+
+	for(;*string;string++)
+		video_putchar(fcs, *string);
+}
+
+
+void SimonState::hitareaChangedHelper() {
+	FillOrCopyStruct *fcs;
+
+	if (_game == GAME_SIMON2WIN) {
+		if (_bit_array[4]&0x8000)
+			return;
+	}
+
+	fcs = _fcs_ptr_array_3[1];
+	if (fcs != NULL && fcs->text_color != 0)
+		video_fill_or_copy_from_3_to_2(fcs);
+
+	_last_hitarea_2_ptr = NULL;
+	_hitarea_ptr_7 = NULL;
+}
+
+HitArea *SimonState::findHitAreaByID(uint hitarea_id) {
+	HitArea *ha = _hit_areas;
+	uint count = ARRAYSIZE(_hit_areas);
+	
+	do{
+		if (ha->id == hitarea_id)
+			return ha;
+	} while(ha++,--count);
+	return NULL;
+}
+
+HitArea *SimonState::findEmptyHitArea() {
+	HitArea *ha = _hit_areas;
+	uint count = ARRAYSIZE(_hit_areas);
+	
+	do{
+		if (ha->flags == 0)
+			return ha;
+	} while(ha++,--count);
+	return NULL;
+}
+
+void SimonState::clear_hitarea_bit_0x40(uint hitarea) {
+	HitArea *ha = findHitAreaByID(hitarea);
+	if (ha != NULL)
+		ha->flags &= ~0x40;
+}
+
+void SimonState::set_hitarea_bit_0x40(uint hitarea) {
+	HitArea *ha = findHitAreaByID(hitarea);
+	if (ha != NULL) {
+		ha->flags |= 0x40;
+		ha->flags &= ~2;
+		if (hitarea == 102)
+			hitarea_proc_1();
+	}
+}
+
+void SimonState::set_hitarea_x_y(uint hitarea, int x, int y) {
+	HitArea *ha = findHitAreaByID(hitarea);
+	if (ha != NULL) {
+		ha->x = x;
+		ha->y = y;
+	}
+}
+
+void SimonState::delete_hitarea(uint hitarea) {
+	HitArea *ha = findHitAreaByID(hitarea);
+	if (ha != NULL) {
+		ha->flags = 0;
+		if (ha == _last_hitarea_2_ptr)
+			defocusHitarea();
+		_need_hitarea_recalc++;
+	}
+}
+
+bool SimonState::is_hitarea_0x40_clear(uint hitarea) {
+	HitArea *ha = findHitAreaByID(hitarea);
+	if (ha == NULL)
+		return false;
+	return (ha->flags & 0x40) == 0;
+}
+
+void SimonState::addNewHitArea(int id, int x, int y, int width, int height, 
+	int flags, int unk3,Item *item_ptr) {
+	
+	HitArea *ha;
+	delete_hitarea(id);
+
+	ha = findEmptyHitArea();
+	ha->x = x;
+	ha->y = y;
+	ha->width = width;
+	ha->height = height;
+	ha->flags = flags | 0x20;
+	ha->id = ha->layer = id;
+	ha->unk3 = unk3;
+	ha->item_ptr = item_ptr;
+
+	_need_hitarea_recalc++;
+}
+
+void SimonState::hitarea_proc_1() {
+	uint id;
+	HitArea *ha;
+
+	if (_game & GAME_SIMON2) {
+		id=2;
+		if (!(_bit_array[4]&0x8000))
+			id = (_mouse_y >= 136) ? 102 : 101;
+	} else {
+		id = (_mouse_y >= 136) ? 102 : 101;
+
+	}
+
+	_hitarea_unk_4 = id;
+
+	ha = findHitAreaByID(id);
+	if (ha == NULL)
+		return;
+
+	if (ha->flags & 0x40) {
+		_hitarea_unk_4 = 999;
+		_hitarea_ptr_5 = NULL;
+	} else {
+		_verb_hitarea = ha->unk3;
+		handle_verb_hitarea(ha);
+	}
+}
+
+void SimonState::handle_verb_hitarea(HitArea *ha) {
+	HitArea *tmp = _hitarea_ptr_5;
+
+	if (ha == tmp) 
+		return;
+
+	if (!(_game & GAME_SIMON2)) {
+		if (tmp != NULL) {
+			tmp->flags |= 8;
+			video_toggle_colors(tmp, 0xd5, 0xd0, 0xd5, 0xA);
+		}
+
+		if (ha->flags & 2)
+			video_toggle_colors(ha, 0xda, 0xd5, 0xd5, 5);
+		else
+			video_toggle_colors(ha, 0xdf, 0xda, 0xda, 0xA);
+
+		ha->flags &= ~ (2 + 8);
+
+	} else {
+		if (ha->id<101)
+			return;
+		_mouse_cursor = ha->id - 101;
+		_need_hitarea_recalc++;
+
+	}
+
+	_hitarea_ptr_5 = ha;
+}
+
+void SimonState::hitarea_leave(HitArea *ha) {
+	if (!(_game & GAME_SIMON2)) {
+		video_toggle_colors(ha, 0xdf, 0xd5, 0xda, 5);
+	} else {
+		video_toggle_colors(ha, 0xe7, 0xe5, 0xe6, 1);
+	}
+}
+
+void SimonState::leaveHitAreaById(uint hitarea_id) {
+	HitArea *ha = findHitAreaByID(hitarea_id);
+	if (ha)
+		hitarea_leave(ha);
+}
+
+void SimonState::handle_unk2_hitarea(FillOrCopyStruct *fcs) {
+	uint index;
+
+	index = get_fcs_ptr_3_index(fcs);
+
+	if (fcs->fcs_data->unk1 == 0)
+		return;
+
+	lock();
+	fcs_unk_proc_1(index, fcs->fcs_data->item_ptr, 
+		fcs->fcs_data->unk1-1, fcs->fcs_data->unk2);
+	unlock();
+}
+
+void SimonState::handle_unk_hitarea(FillOrCopyStruct *fcs) {
+	uint index;
+
+	index = get_fcs_ptr_3_index(fcs);
+
+	lock();
+	fcs_unk_proc_1(index, fcs->fcs_data->item_ptr, 
+		fcs->fcs_data->unk1+1, fcs->fcs_data->unk2);
+	unlock();
+}
+
+void SimonState::setup_hitarea_from_pos(uint x, uint y, uint mode) {
+	HitArea *best_ha;
+
+	if (_game & GAME_SIMON2) {
+		if (_bit_array[4]&0x8000 || y < 134) {
+			x += _x_scroll * 8;
+		}
+	}
+
+	{
+		HitArea *ha = _hit_areas;
+		uint count = ARRAYSIZE(_hit_areas);
+		uint16 layer = 0;
+		const uint16 x_ = x;
+		const uint16 y_ = y;
+
+		best_ha = NULL;
+
+		do{
+			if (ha->flags & 0x20) {
+				if (!(ha->flags & 0x40)) {
+					if (x_ >= ha->x && y_ >= ha->y && 
+							x_ - ha->x < ha->width && y_- ha->y < ha->height && 
+							layer <= ha->layer) {
+							layer = ha->layer;
+							best_ha = ha;
+					} else {
+						if (ha->flags & 2) {
+							hitarea_leave(ha);
+							ha->flags &=~2;
+						}
+					}
+				} else {
+					ha->flags &= ~2;
+				}
+			}
+		} while(ha++,--count);
+	}
+
+	if (best_ha == NULL) {
+		defocusHitarea();
+		return;
+	}
+
+	if (mode != 0 && mode != 3) {
+		_last_hitarea = best_ha;
+		_variableArray[1] = x;
+		_variableArray[2] = y;
+	}
+
+	if (best_ha->flags&4) {
+		defocusHitarea();
+	} else if (best_ha != _last_hitarea_2_ptr) {
+		new_current_hitarea(best_ha);
+	}
+
+	if (best_ha->flags&8  && !(best_ha->flags&2)) {
+		hitarea_leave(best_ha);
+		best_ha->flags |= 2;
+	}
+
+	return;
+}
+
+void SimonState::new_current_hitarea(HitArea *ha) {
+	bool result;
+
+	hitareaChangedHelper();
+	if (ha->flags & 1) {
+		result = hitarea_proc_2(ha->flags>>8);
+	} else {
+		result = hitarea_proc_3(ha->item_ptr);
+	}	
+
+	if (result)
+		_last_hitarea_2_ptr = ha;
+}
+
+bool SimonState::hitarea_proc_2(uint a) {
+	uint x;
+	const byte *string_ptr;
+
+	if (_game & GAME_SIMON2) {
+		if (_bit_array[4]&0x8000) {
+			Subroutine *sub;
+			_variableArray[0xA8/2] = a;
+			sub = getSubroutineByID(5003);
+			if (sub != NULL)
+				startSubroutineEx(sub);
+			return true;
+		}
+	}
+
+	if (a >= 20)
+		return false;
+
+	string_ptr = getStringPtrByID(_stringid_array_2[a]);
+	x = (53 - (strlen((const char*)string_ptr) - 1)) * 3;
+	showActionString(x, string_ptr);
+
+	return true;
+}
+
+bool SimonState::hitarea_proc_3(Item *item) {
+	Child2 *child2;
+	uint x;
+	const byte *string_ptr;
+
+	if (item == 0 || item==&_dummy_item_2 || item == &_dummy_item_3)
+		return false;
+
+	child2 = findChildOfType2(item);
+	if (child2 == NULL)
+		return false;
+
+	string_ptr = getStringPtrByID(child2->string_id);
+	x = (53 - (strlen((const char*)string_ptr) - 1)) * 3;
+	showActionString(x, string_ptr);
+	return true;
+}
+
+uint SimonState::get_fcs_ptr_3_index(FillOrCopyStruct *fcs) {
+	uint i;
+
+	for(i=0; i!=ARRAYSIZE(_fcs_ptr_array_3); i++)
+		if (_fcs_ptr_array_3[i] == fcs)
+			return i;
+
+	error("get_fcs_ptr_3_index: not found");
+}
+
+/* Used only in Simon1 */
+void SimonState::o_read_vgares_328() {
+	if (_vga_res_328_loaded == false) {
+		_vga_res_328_loaded = true;
+		_lock_word |= 0x4000;
+		read_vga_from_datfile_1(328);
+		_lock_word &= ~0x4000;
+	}
+}
+
+/* Used only in Simon1 */
+void SimonState::o_read_vgares_23() {
+	if (_vga_res_328_loaded == true) {
+		_vga_res_328_loaded = false;
+		_lock_word |= 0x4000;
+		read_vga_from_datfile_1(23);
+		_lock_word &= ~0x4000;
+	}
+}
+
+
+void SimonState::lock() {
+	_lock_counter++;
+}
+
+void SimonState::unlock() {
+	_lock_word |= 1;
+
+	if (_lock_counter != 0) {
+		if (_lock_counter==1) {
+			GetAsyncKeyState(VK_LBUTTON);
+		}
+		_lock_counter--;
+	}
+	_lock_word &= ~1;
+}
+
+void SimonState::handle_mouse_moved() {
+	uint x;
+
+	if (_lock_counter)
+		return;
+
+	pollMouseXY();
+
+	if (_mouse_x >= 32768)
+		_mouse_x = 0;
+	if (_mouse_x >= 638/2)
+		_mouse_x = 638/2;
+
+	if (_mouse_y >= 32768)
+		_mouse_y = 0;
+	if (_mouse_y >= 199)
+		_mouse_y = 199;
+
+	if (_hitarea_unk_4) {
+		uint id = 101;
+		if (_mouse_y >= 136)
+			id = 102;
+		if (_hitarea_unk_4 != id)
+			hitarea_proc_1();
+	}
+
+
+	if (_game & GAME_SIMON2) {
+		if (_bit_array[4]&0x8000) {
+			if (!_vga_var9) {
+				if (_mouse_x >= 630/2 || _mouse_x < 9)
+					goto get_out2;
+				_vga_var9 = 1;
+			}
+			if (_vga_var2==0) {
+				if (_mouse_x >= 631/2) {
+					if (_x_scroll != _vga_var1)
+						_vga_var3 = 1;
+				} else if (_mouse_x < 8) {
+					if (_x_scroll != 0)
+						_vga_var3 = -1;
+				}
+			}
+		} else {
+	get_out2:;
+			_vga_var9 = 0;
+		}
+	}
+
+
+	if (_mouse_x != _mouse_x_old || _mouse_y != _mouse_y_old)
+		_need_hitarea_recalc++;
+
+	x = 0;
+	if (_last_hitarea_3 == 0 && _left_button_down != 0) {
+		_left_button_down = 0;
+		x = 1;
+	} else {
+		if (_hitarea_unk_3==0 && _need_hitarea_recalc==0) goto get_out;
+	}
+
+	setup_hitarea_from_pos(_mouse_x, _mouse_y, x);
+	_last_hitarea_3 = _last_hitarea;
+	if (x==1 && _last_hitarea==NULL)
+		_last_hitarea_3 = (HitArea*)-1;
+
+get_out:
+	draw_mouse_pointer();
+	_need_hitarea_recalc = 0;
+}
+
+void SimonState::fcs_unk_proc_1(uint fcs_index, Item *item_ptr, int unk1, int unk2) {
+	Item *item_ptr_org = item_ptr;
+	FillOrCopyStruct *fcs_ptr;
+	uint width_div_3, height_div_3;
+	uint j,k,i,num_sibs_with_flag;
+	bool item_again;
+	uint x_pos, y_pos;
+
+	fcs_ptr = _fcs_ptr_array_3[fcs_index&7];
+
+	if (!(_game & GAME_SIMON2)) {
+		width_div_3 = fcs_ptr->width / 3;
+		height_div_3 = fcs_ptr->height / 3;
+	} else {
+		width_div_3 = 100;
+		height_div_3 = 40;
+	}
+
+	i = 0;
+
+	if (fcs_ptr == NULL)
+		return;
+
+	if (fcs_ptr->fcs_data)
+		fcs_unk1(fcs_index);
+
+	fcs_ptr->fcs_data = (FillOrCopyData*)malloc(sizeof(FillOrCopyData));
+	fcs_ptr->fcs_data->item_ptr = item_ptr;
+	fcs_ptr->fcs_data->unk3 = -1;
+	fcs_ptr->fcs_data->unk4 = -1;
+	fcs_ptr->fcs_data->unk1 = unk1;
+	fcs_ptr->fcs_data->unk2 = unk2;
+
+	item_ptr = derefItem(item_ptr->child);
+
+	while (item_ptr && unk1-- != 0) {
+		num_sibs_with_flag = 0;
+		while (item_ptr && width_div_3 > num_sibs_with_flag) {
+			if ((unk2==0 || item_ptr->unk4&unk2) && has_item_childflag_0x10(item_ptr)) 
+				if (!(_game & GAME_SIMON2)) {
+					num_sibs_with_flag++;
+				} else {
+					num_sibs_with_flag+=20;
+				}
+			item_ptr = derefItem(item_ptr->sibling);
+		}
+	}
+
+	if (item_ptr == NULL) {
+		fcs_ptr->fcs_data->unk1 = 0;
+		item_ptr = derefItem(item_ptr_org->child);
+	}
+
+	x_pos = 0;
+	y_pos = 0;
+	item_again = false;
+	k = 0;
+	j = 0;
+
+	while (item_ptr) {
+		if ((unk2==0 || item_ptr->unk4&unk2) &&  has_item_childflag_0x10(item_ptr)) {
+			if (item_again == false) {
+				fcs_ptr->fcs_data->e[k].item = item_ptr;
+				if (!(_game & GAME_SIMON2)) {
+					draw_icon_c(fcs_ptr, item_get_icon_number(item_ptr), x_pos*3, y_pos);
+					fcs_ptr->fcs_data->e[k].hit_area = 
+						setup_icon_hit_area(fcs_ptr, x_pos*3, y_pos, 
+							item_get_icon_number(item_ptr), item_ptr);
+				} else {
+					draw_icon_c(fcs_ptr, item_get_icon_number(item_ptr), x_pos, y_pos);
+					fcs_ptr->fcs_data->e[k].hit_area = 
+						setup_icon_hit_area(fcs_ptr, x_pos, y_pos, 
+							item_get_icon_number(item_ptr), item_ptr);
+				}
+				k++;
+			} else {
+				fcs_ptr->fcs_data->e[k].item = NULL;
+				j = 1;
+			}
+			x_pos+= (_game & GAME_SIMON2) ? 20 : 1;
+
+			if (x_pos >= width_div_3) {
+				x_pos = 0;
+
+				y_pos+= (_game & GAME_SIMON2) ? 20 : 1;
+				if (y_pos >= height_div_3)
+					item_again = true;
+			}
+		}
+		item_ptr = derefItem(item_ptr->sibling);
+	}
+
+	fcs_ptr->fcs_data->e[k].item = NULL;
+	
+	if (j!=0 || fcs_ptr->fcs_data->unk1!=0) {
+		fcs_unk_proc_2(fcs_ptr, fcs_index);
+	}
+}
+
+void SimonState::fcs_unk_proc_2(FillOrCopyStruct *fcs, uint fcs_index) {
+	setup_hit_areas(fcs, fcs_index);
+
+	fcs->fcs_data->unk3 = _scroll_up_hit_area;
+	fcs->fcs_data->unk4 = _scroll_down_hit_area;
+}
+
+void SimonState::setup_hit_areas(FillOrCopyStruct *fcs, uint fcs_index) {
+	HitArea *ha;
+
+	ha = findEmptyHitArea();
+	_scroll_up_hit_area = ha - _hit_areas;
+	if (!(_game & GAME_SIMON2)) {
+		ha->x = 308;
+		ha->y = 149;
+		ha->width = 12;
+		ha->height = 17;
+		ha->flags = 0x24;
+		ha->id = 0x7FFB;
+		ha->layer = 100;
+		ha->fcs = fcs;
+		ha->unk3 = 1;
+	} else {
+		ha->x = 81;
+		ha->y = 158;
+		ha->width = 12;
+		ha->height = 26;
+		ha->flags = 36;
+		ha->id = 0x7FFB;
+		ha->layer = 100;
+		ha->fcs = fcs;
+		ha->unk3 = 1;
+	}
+
+	ha = findEmptyHitArea();
+	_scroll_down_hit_area = ha - _hit_areas;
+
+	if (!(_game & GAME_SIMON2)) {
+		ha->x = 308;
+		ha->y = 176;
+		ha->width = 12;
+		ha->height = 17;
+		ha->flags = 0x24;
+		ha->id = 0x7FFC;
+		ha->layer = 100;
+		ha->fcs = fcs;
+		ha->unk3 = 1;
+
+		/* Simon1 specific */
+		o_unk_99_simon1(0x80);
+		start_vga_code(0, 1, 0x80, 0, 0, 0xE);
+	} else {
+		ha->x = 227;
+		ha->y = 162;
+		ha->width = 12;
+		ha->height = 26;
+		ha->flags = 36;
+		ha->id = 0x7FFC;
+		ha->layer = 100;
+		ha->fcs = fcs;
+		ha->unk3 = 1;
+	}
+}
+
+
+bool SimonState::has_item_childflag_0x10(Item *item) {
+	Child2 *child = findChildOfType2(item);
+	return child && (child->avail_props & 0x10) != 0;
+}
+
+uint SimonState::item_get_icon_number(Item *item) {
+	Child2 *child = findChildOfType2(item);
+	uint offs;
+
+	if (child==NULL || !(child->avail_props & 0x10))
+		return 0;
+
+	offs = getOffsetOfChild2Param(child, 0x10);
+	return child->array[offs];
+}
+
+void SimonState::loadIconFile() {
+	FILE *in = fopen("icon.dat", "rb");
+	uint size;
+
+	if (in==NULL)
+		error("Cannot open icon.dat");
+	
+	fseek(in, 0, SEEK_END);
+	size = ftell(in);
+
+	_icon_file_ptr = (byte*)malloc(size);
+	if (_icon_file_ptr == NULL)
+		error("Out of icon memory");
+
+	rewind(in);
+
+	fread(_icon_file_ptr, size, 1, in);
+	fclose(in);
+}
+
+
+uint SimonState::setup_icon_hit_area(FillOrCopyStruct *fcs,uint x, uint y, uint icon_number, Item *item_ptr) {
+	HitArea *ha;
+
+	ha = findEmptyHitArea();
+
+	if (!(_game & GAME_SIMON2)) {
+		ha->x = (x+fcs->x) << 3;
+		ha->y = y*25 + fcs->y;
+		ha->item_ptr = item_ptr;
+		ha->width = 24;
+		ha->height = 24;
+		ha->flags = 0xB0;
+		ha->id = 0x7FFD;
+		ha->layer = 100;
+		ha->unk3 = 0xD0;
+	} else {
+		ha->x = x + 110;
+		ha->y = fcs->y + y;
+		ha->item_ptr = item_ptr;
+		ha->width = 20;
+		ha->height = 20;
+		ha->flags = 0xB0;
+		ha->id = 0x7FFD;
+		ha->layer = 100;
+		ha->unk3 = 0xD0;
+	}
+
+	return ha - _hit_areas;
+}
+
+void SimonState::hitarea_stuff() {
+	HitArea *ha;
+	uint id;
+
+	_left_button_down = 0;
+	_last_hitarea = 0;
+	_verb_hitarea = 0;
+	_hitarea_subject_item = NULL;
+	_hitarea_object_item = NULL;
+
+	hitarea_proc_1();
+
+startOver:
+	for(;;) {
+		_last_hitarea = NULL;
+		_last_hitarea_3 = NULL;
+		for(;;) {
+			processSpecialKeys();
+			if (_last_hitarea_3 == (HitArea*)0xFFFFFFFF) goto startOver;	
+			if (_last_hitarea_3 != 0)
+				break;
+			hitarea_stuff_helper();
+			delay(100);
+		}
+
+		ha = _last_hitarea;
+
+		if (ha == NULL) {
+		} else if(ha->id == 0x7FFB) {
+			handle_unk2_hitarea(ha->fcs);
+		} else if (ha->id == 0x7FFC) {
+			handle_unk_hitarea(ha->fcs);
+		} else if (ha->id>=101 && ha->id<113) {
+			_verb_hitarea = ha->unk3;
+			handle_verb_hitarea(ha);
+			_hitarea_unk_4 = 0;
+		} else {
+			if ( (_verb_hitarea != 0 || _hitarea_subject_item != ha->item_ptr && ha->flags&0x80) &&
+					 ha->item_ptr) {
+if_1:;
+				_hitarea_subject_item = ha->item_ptr;
+				id = 0xFFFF;
+				if (ha->flags&1)
+					id = ha->flags>>8;
+				_variableArray[0x78/2] = id;
+				new_current_hitarea(ha);
+				if (_verb_hitarea != 0)
+					break;
+			} else {
+				/* else 1 */
+				if (ha->unk3 == 0) {
+					if(ha->item_ptr) goto if_1;
+				} else {
+					_verb_hitarea = ha->unk3 & 0xBFFF;
+					if (ha->unk3 & 0x4000) {
+						_hitarea_subject_item = ha->item_ptr;
+						break;
+					}
+					if (_hitarea_subject_item != NULL)
+						break;
+				}
+			}
+		}
+	}
+
+	_need_hitarea_recalc++;
+}
+
+void SimonState::hitarea_stuff_helper() {
+	time_t cur_time;
+
+	if (!(_game & GAME_SIMON2)) {
+		uint subr_id = _variableArray[0x1FC/2];
+		if (subr_id != 0) {
+			Subroutine *sub = getSubroutineByID(subr_id);
+			if (sub != NULL) {
+				startSubroutineEx(sub);
+				startUp_helper_2();
+			}
+			_variableArray[0x1FC/2] = 0;
+			_run_script_return_1 = false;
+		}
+	} else {
+		if (_variableArray[0x1FC/2] || _variableArray[0x1F2/2]) {
+			hitarea_stuff_helper_2();
+		}
+	}
+
+	time(&cur_time);
+	if ((uint)cur_time != _last_time) {
+		_last_time = cur_time;
+		if (kickoffTimeEvents())
+			startUp_helper_2();
+	}
+}
+
+/* Simon 2 specific */
+void SimonState::hitarea_stuff_helper_2() {
+	uint subr_id;
+	Subroutine *sub;
+
+	subr_id = _variableArray[0x1F2/2];
+	if (subr_id != 0) {
+		sub = getSubroutineByID(subr_id);
+		if (sub != NULL) {
+			_variableArray[0x1F2/2] = 0;
+			startSubroutineEx(sub);
+			startUp_helper_2();
+		}
+		_variableArray[0x1F2/2] = 0;
+	}
+
+	subr_id = _variableArray[0x1FC/2];
+	if (subr_id != 0) {
+		sub = getSubroutineByID(subr_id);
+		if (sub != NULL) {
+			_variableArray[0x1FC/2] = 0;
+			startSubroutineEx(sub);
+			startUp_helper_2();
+		}
+		_variableArray[0x1FC/2] = 0;
+	}
+
+	_run_script_return_1 = false;
+}
+
+
+void SimonState::startUp_helper_2() {
+	if (!_mortal_flag) {
+		_mortal_flag = true;
+		startUp_helper_3();
+		_fcs_unk_1 = 0;
+		if(_fcs_ptr_array_3[0]!=0) {
+			_fcs_ptr_1 = _fcs_ptr_array_3[0];
+			showmessage_helper_3(_fcs_ptr_1->unk6, _fcs_ptr_1->unk7);
+		}
+		_mortal_flag = false;
+	}
+}
+
+void SimonState::startUp_helper_3() {
+	showmessage_print_char(0);
+}
+
+void SimonState::showmessage_helper_3(uint a, uint b) {
+	_print_char_unk_1 = a;
+	_print_char_unk_2 = b;
+	_num_letters_to_print = 0;
+}
+
+void SimonState::pollMouseXY() {
+	_mouse_x = sdl_mouse_x;
+	_mouse_y = sdl_mouse_y;
+}
+
+void SimonState::handle_verb_clicked(uint verb) {
+	Subroutine *sub;
+	int result;
+
+	_item_1_ptr = _item_1;
+
+	_object_item = _hitarea_object_item;
+	if (_object_item == &_dummy_item_2) {
+		_object_item = getItem1Ptr();
+	}
+	if (_object_item == &_dummy_item_3) {
+		_object_item = derefItem(getItem1Ptr()->parent);
+	}
+
+	_subject_item = _hitarea_subject_item;
+	if (_subject_item == &_dummy_item_2) {
+		_subject_item = getItem1Ptr();
+	}
+	if (_subject_item == &_dummy_item_3) {
+		_subject_item = derefItem(getItem1Ptr()->parent);
+	}
+
+	if (_subject_item) {
+		_script_cond_b = _subject_item->unk1;
+	} else {
+		_script_cond_b = -1;
+	}
+
+	if (_object_item) {
+		_script_cond_c = _object_item->unk1;
+	} else {
+		_script_cond_c = -1;
+	}
+
+	_script_cond_a = _verb_hitarea;
+
+	sub = getSubroutineByID(0);
+	if (sub==NULL)
+		return;
+
+	result = startSubroutine(sub);
+	if (result == -1)
+		showMessageFormat("I don't understand");
+
+	_run_script_return_1 = false;
+
+	sub = getSubroutineByID(100);
+	if(sub) startSubroutine(sub);
+
+	if (_game & GAME_SIMON2)
+		_run_script_return_1 = false;
+
+	startUp_helper_2();
+}
+
+void SimonState::o_print_str() {
+	uint num_1 = getVarOrByte();
+	uint num_2 = getVarOrByte();
+	uint string_id = getNextStringID();
+	const byte *string_ptr;
+	uint speech_id;
+	ThreeValues *tv;
+
+
+	switch(_game) {
+	case GAME_SIMON1WIN:
+		if (string_id != 0xFFFF)
+			string_ptr = getStringPtrByID(string_id);
+		else
+			string_ptr = NULL;
+
+		speech_id = (uint16)getNextWord();
+		break;
+
+	case GAME_SIMON2WIN:
+		if (string_id != 0xFFFF)
+			string_ptr = getStringPtrByID(string_id);
+		else
+			string_ptr = NULL;
+
+		speech_id = (uint16)getNextWord();
+		break;
+
+	case GAME_SIMON1DOS:
+		string_ptr = getStringPtrByID(string_id);
+		break;
+	}
+
+	switch(num_1) {
+	case 1:		tv = &_threevalues_1; break;
+	case 2:		tv = &_threevalues_2; break;
+	case 101: tv = &_threevalues_3; break;
+	case 102: tv = &_threevalues_4; break;
+	default:
+		error("o_print_str, invalid value %d", num_1);
+	}
+
+
+	switch(_game) {
+	case GAME_SIMON1WIN:
+#ifdef USE_TEXT_HACK
+		if (speech_id != 0) {
+			if (string_ptr==NULL)
+				talk_with_speech(speech_id, num_1);
+			else if(speech_id!=9999)
+				playVoice(speech_id);
+		}
+		
+		if (string_ptr != NULL) {
+			talk_with_text(num_1, num_2, (char*)string_ptr, tv->a, tv->b, tv->c);
+		}
+#else
+		if (speech_id != 0) {
+			talk_with_speech(speech_id, num_1);
+		} else if(string_ptr  != NULL) {
+			talk_with_text(num_1, num_2, (char*)string_ptr, tv->a, tv->b, tv->c);
+		}
+#endif
+		break;
+
+	case GAME_SIMON1DOS:
+		talk_with_text(num_1, num_2, (char*)string_ptr, tv->a, tv->b, tv->c);	
+		break;
+
+	case GAME_SIMON2WIN:
+		if (speech_id!=0 && num_1 == 1 && !_vk_t_toggle)
+			talk_with_speech(speech_id, num_1);
+
+		if (speech_id != 0 && !_vk_t_toggle)
+			return;
+
+		if (speech_id == 0)
+			o_unk_99_simon2(2, num_1+2);
+
+		talk_with_text(num_1, num_2, (char*)string_ptr, tv->a, tv->b, tv->c);	
+		break;		
+	}
+}
+
+void SimonState::ensureVgaResLoadedC(uint vga_res) {
+	_lock_word |= 0x80;
+	ensureVgaResLoaded(vga_res);
+	_lock_word &= ~0x80;
+}
+
+void SimonState::ensureVgaResLoaded(uint vga_res) {
+	VgaPointersEntry *vpe;
+	
+	CHECK_BOUNDS(vga_res, _vga_buffer_pointers);
+
+	vpe = _vga_buffer_pointers + vga_res;
+	if (vpe->vgaFile1 != NULL)
+		return;
+
+	vpe->vgaFile2 = read_vga_from_datfile_2(vga_res*2+1);
+	vpe->vgaFile1 = read_vga_from_datfile_2(vga_res*2);
+	
+}
+
+byte *SimonState::setup_vga_destination(uint32 size) {
+	byte *dest, *end;
+
+	_video_var_4 = 0;
+
+	for(;;) {
+		dest = _vga_buf_free_start;
+
+		end = dest + size;
+
+		if (end >= _vga_buf_end) {
+			_vga_buf_free_start = _vga_buf_start;
+		} else {
+			_video_var_5 = false;
+			vga_buf_unk_proc3(end);
+			if (_video_var_5)
+				continue;
+			vga_buf_unk_proc1(end);
+			if (_video_var_5)
+				continue;
+			delete_memptr_range(end);
+			_vga_buf_free_start = end;
+			return dest;
+		}
+	}
+}
+
+void SimonState::setup_vga_file_buf_pointers() {
+	byte *alloced;
+
+	alloced = (byte*)malloc(gss->VGA_MEM_SIZE);
+	
+	_vga_buf_free_start = alloced;
+	_vga_buf_start = alloced;
+	_vga_file_buf_org = alloced;
+	_vga_file_buf_org_2 = alloced;
+	_vga_buf_end = alloced + gss->VGA_MEM_SIZE;
+}
+
+void SimonState::vga_buf_unk_proc3(byte *end) {
+	VgaPointersEntry *vpe;
+	
+	if (_video_var_7==0xFFFF)
+		return;
+	
+	if (_video_var_4 == 2)
+		error("vga_buf_unk_proc3: _video_var_4 == 2");
+
+	vpe = &_vga_buffer_pointers[_video_var_7];
+
+	if (_vga_buf_free_start <= vpe->vgaFile1 && end >= vpe->vgaFile1 ||
+		  _vga_buf_free_start <= vpe->vgaFile2 && end >= vpe->vgaFile2) {
+		_video_var_5 = 1;
+		_video_var_4++;
+		_vga_buf_free_start = vpe->vgaFile1 + 0x5000;
+	} else {
+		_video_var_5 = 0;
+	}
+}
+
+void SimonState::vga_buf_unk_proc1(byte *end) {
+	VgaSprite *vsp;
+	if (_lock_word & 0x20)
+		return;
+
+	for(vsp = _vga_sprites; vsp->id; vsp++) {
+		vga_buf_unk_proc2(vsp->unk7, end);
+		if (_video_var_5 == true)
+			return;
+	}
+}
+
+void SimonState::delete_memptr_range(byte *end) {
+	uint count = ARRAYSIZE(_vga_buffer_pointers);
+	VgaPointersEntry *vpe = _vga_buffer_pointers;
+	do {
+		if (_vga_buf_free_start <= vpe->vgaFile1 && end >= vpe->vgaFile1 ||
+			_vga_buf_free_start <= vpe->vgaFile2 && end >= vpe->vgaFile2) {
+				vpe->dd = NULL;
+				vpe->vgaFile1 = NULL;
+				vpe->vgaFile2 = NULL;
+		}
+
+	} while (++vpe,--count);
+}
+
+void SimonState::vga_buf_unk_proc2(uint a, byte *end) {
+	VgaPointersEntry *vpe;
+	
+	vpe = &_vga_buffer_pointers[a];
+
+	if (_vga_buf_free_start <= vpe->vgaFile1 && end >= vpe->vgaFile1 ||
+		  _vga_buf_free_start <= vpe->vgaFile2 && end >= vpe->vgaFile2) {
+		_video_var_5 = true;
+		_video_var_4++;
+		_vga_buf_free_start = vpe->vgaFile1 + 0x5000;
+	} else {
+		_video_var_5 = false;
+	}
+}
+
+void SimonState::o_unk_138() {
+	_vga_buf_start = _vga_buf_free_start;
+	_vga_file_buf_org = _vga_buf_free_start;
+}
+
+void SimonState::o_unk_186() {
+	_vga_buf_free_start = _vga_file_buf_org_2;
+	_vga_buf_start = _vga_file_buf_org_2;
+	_vga_file_buf_org = _vga_file_buf_org_2;
+}
+
+void SimonState::o_unk_175() {
+	_vga_buf_start = _vga_buf_free_start;
+}
+
+void SimonState::o_unk_176() {
+	_vga_buf_free_start = _vga_file_buf_org;
+	_vga_buf_start = _vga_file_buf_org;
+}
+
+void SimonState::o_clear_vgapointer_entry(uint a) {
+	VgaPointersEntry *vpe;
+	
+	vpe = &_vga_buffer_pointers[a];
+
+	vpe->dd = NULL;
+	vpe->vgaFile1 = NULL;
+	vpe->vgaFile2 = NULL;
+}
+
+void SimonState::o_set_video_mode(uint mode, uint vga_res) {
+	if (mode == 4)
+		vc_29_stop_all_sounds();
+
+	if (_lock_word & 0x10) {
+		error("o_set_video_mode_ex: _lock_word & 0x10");
+//		_unk21_word_array[a] = b; 
+	} else {
+		set_video_mode(mode,vga_res);
+	}
+}
+
+void SimonState::set_video_mode_internal(uint mode, uint vga_res_id) {
+	uint num;
+	VgaPointersEntry *vpe;
+	byte *bb,*b;
+	uint16 c;
+	byte *vc_ptr_org;
+
+	warning("Set video mode internal: %d, %d", mode, vga_res_id);
+
+	_video_palette_mode = mode;
+	_lock_word |= 0x20;
+
+	if (vga_res_id == 0) {
+
+		if (!(_game & GAME_SIMON2)) {
+			_unk_pal_flag = true;
+		} else {
+			_dx_use_3_or_4_for_lock = true;
+			_vga_var6 = true;
+		}
+	}
+
+	_vga_cur_file_2 = num = vga_res_id / 100;
+
+	for(;;) {
+		vpe = &_vga_buffer_pointers[num];
+
+		_cur_vga_file_1 = vpe->vgaFile1;
+		_cur_vga_file_2 = vpe->vgaFile2;
+
+		if (vpe->vgaFile1 != NULL)
+			break;
+
+		ensureVgaResLoaded(num);
+	}
+
+	/* ensure flipping complete */
+
+	bb = _cur_vga_file_1;
+	b = bb + swap16(((VgaFile1Header*)bb)->hdr2_start);
+	c = swap16(((VgaFile1Header2*)b)->unk1);
+	b = bb + swap16(((VgaFile1Header2*)b)->unk2_offs);
+
+	while (swap16(((VgaFile1Struct0x8*)b)->id) != vga_res_id)
+		b += sizeof(VgaFile1Struct0x8);
+
+	if (!(_game & GAME_SIMON2)) {
+		if (num == 16300) {
+			dx_clear_attached_from_top(134);
+			_use_palette_delay = true;
+		}
+	} else {
+		_x_scroll = 0;
+		_vga_var1 = 0;
+		_vga_var2 = 0;
+		_vga_var3 = 0;
+		_vga_var5 = 134;
+		if(_variableArray[34] != -1)
+			_variableArray[502/2] = 0;
+	}
+
+	vc_ptr_org = _vc_ptr;
+
+	_vc_ptr = _cur_vga_file_1 + swap16(((VgaFile1Struct0x8*)b)->script_offs);
+//	dump_vga_script(_vc_ptr, num, vga_res_id);
+	run_vga_script();
+	_vc_ptr = vc_ptr_org;
+
+
+	if (_game & GAME_SIMON2) {
+		if (!_dx_use_3_or_4_for_lock) {
+			uint num_lines = 	_video_palette_mode==4 ? 134: 200;
+			_vga_var8 = num_lines;
+			dx_copy_from_attached_to_2(0, 0, 320, num_lines);
+			dx_copy_from_attached_to_3(num_lines);
+			_sync_flag_2 = 1;
+		}
+		_dx_use_3_or_4_for_lock = false;
+	} else {
+		uint num_lines = 	_video_palette_mode==4 ? 134: 200;
+		dx_copy_from_attached_to_2(0, 0, 320, num_lines);
+		dx_copy_from_attached_to_3(num_lines);
+		_sync_flag_2 = 1;
+		_timer_5 = 0;
+	}
+	
+	_lock_word &= ~0x20;
+	/* XXX: fix */
+
+
+	if (!(_game & GAME_SIMON2)) {
+		if (_unk_pal_flag) {
+			_unk_pal_flag = false;
+			while (*(volatile int*)&_palette_color_count!=0) {
+				delay(10);
+			}
+		}
+	}
+}
+
+void SimonState::set_video_mode(uint mode, uint vga_res_id) {
+	
+	if (_lock_counter == 0) {
+		lock();
+		if (_lock_word == 0) {
+			_sync_flag_1 = true;
+			while ((*(volatile bool*)&_sync_flag_1) == true) {
+				delay(10);
+			}
+		}
+	}
+
+	_lock_word |= 0x20;
+
+//	while ((*(volatile uint16*)&_lock_word) & 2) {
+//		delay(10);
+//	}
+
+	unlock();
+
+	set_video_mode_internal(mode, vga_res_id);
+}
+
+
+
+typedef void (SimonState::*VgaOpcodeProc)();
+
+static const uint16 vc_get_out_of_code = 0;
+
+void SimonState::run_vga_script() {
+	static const VgaOpcodeProc vga_opcode_table[] = {
+		NULL,
+		&SimonState::vc_1,
+		&SimonState::vc_2,
+		&SimonState::vc_3,
+		&SimonState::vc_4,
+		&SimonState::vc_5,
+		&SimonState::vc_6_maybe_skip_3_inv,
+		&SimonState::vc_7_maybe_skip_3,
+		&SimonState::vc_8_maybe_skip_2,
+		&SimonState::vc_9_maybe_skip,
+		&SimonState::vc_10,
+		&SimonState::vc_11_clear_pathfind_array,
+		&SimonState::vc_12_sleep_variable,
+		&SimonState::vc_13_offset_x,
+		&SimonState::vc_14_offset_y,
+		&SimonState::vc_15_start_funkystruct_by_id,
+		&SimonState::vc_16_setup_funkystruct,
+		&SimonState::vc_17_set_pathfind_item,
+		&SimonState::vc_18_jump_rel,
+		&SimonState::vc_19,
+		&SimonState::vc_20,
+		&SimonState::vc_21,
+		&SimonState::vc_22,
+		&SimonState::vc_23_set_pri,
+		&SimonState::vc_24_set_image_xy,
+		&SimonState::vc_25_del_sprite_and_get_out,
+		&SimonState::vc_26,
+		&SimonState::vc_27_reset,
+		&SimonState::vc_28,
+		&SimonState::vc_29_stop_all_sounds,
+		&SimonState::vc_30_set_base_delay,
+		&SimonState::vc_31_set_palette_mode,
+		&SimonState::vc_32_copy_var,
+		&SimonState::vc_33,
+		&SimonState::vc_34,
+		&SimonState::vc_35,
+		&SimonState::vc_36,
+		&SimonState::vc_37_sprite_unk3_add,
+		&SimonState::vc_38_skip_if_var_zero,
+		&SimonState::vc_39_set_var,
+		&SimonState::vc_40_var_add,
+		&SimonState::vc_41_var_sub,
+		&SimonState::vc_42_delay_if_not_eq,
+		&SimonState::vc_43_skip_if_bit_clear,
+		&SimonState::vc_44_skip_if_bit_set,
+		&SimonState::vc_45_set_x,
+		&SimonState::vc_46_set_y,
+		&SimonState::vc_47_add_var_f,
+		&SimonState::vc_48,
+		&SimonState::vc_49_set_bit,
+		&SimonState::vc_50_clear_bit,
+		&SimonState::vc_51_clear_hitarea_bit_0x40,
+		&SimonState::vc_52,
+//#ifdef SIMON2
+//		NULL,
+//		NULL,
+//#endif
+//#ifdef SIMON1
+		&SimonState::vc_53_no_op,
+		&SimonState::vc_54_no_op,
+//#endif
+		&SimonState::vc_55_offset_hit_area,
+		&SimonState::vc_56_no_op,
+		&SimonState::vc_57_no_op,
+//#ifdef SIMON2
+		&SimonState::vc_58,
+//#endif
+//#ifdef SIMON1
+//		NULL,
+//#endif
+		&SimonState::vc_59,
+		&SimonState::vc_60,
+		&SimonState::vc_61_sprite_change,
+		&SimonState::vc_62,
+		&SimonState::vc_63,
+
+//#ifdef SIMON2
+		&SimonState::vc_64,
+		&SimonState::vc_65,
+		&SimonState::vc_66,
+		&SimonState::vc_67,
+		&SimonState::vc_68,
+		&SimonState::vc_69,
+		&SimonState::vc_70,
+		&SimonState::vc_71,
+		&SimonState::vc_72,
+		&SimonState::vc_73,
+		&SimonState::vc_74,
+//#endif
+	};
+
+
+	for(;;) {
+		uint opcode;
+
+#ifdef DUMP_CONTINOUS_VGASCRIPT
+		if ((void*)_vc_ptr != (void*)&vc_get_out_of_code) {
+			fprintf(_dump_file,"%.5X: %5d %4d ", _vc_ptr -_cur_vga_file_1, _vga_cur_sprite_id, _vga_cur_file_id);
+			dump_video_script(_vc_ptr, true);
+		}
+#endif
+
+		if (!(_game & GAME_SIMON2)) {
+			opcode = swap16(*(uint16*)_vc_ptr);
+			_vc_ptr += 2;
+		} else {
+			opcode = *_vc_ptr++;
+		}
+
+		if (opcode >= gss->NUM_VIDEO_OP_CODES)
+			error("Invalid VGA opcode '%d' encountered", opcode);
+
+		if (opcode == 0)
+			return;
+
+		(this->*vga_opcode_table[opcode])();
+	}
+}
+
+int SimonState::vc_read_var_or_word(void *ptr) {
+	int16 var = swap16(*(uint16*)ptr);
+	if (var < 0)
+		var = vc_read_var(-var);
+	return var;
+}
+
+uint SimonState::vc_read_next_word() {
+	uint a = swap16(*(uint16*)_vc_ptr);
+	_vc_ptr += 2;
+	return a;
+}
+
+uint SimonState::vc_read_next_byte() {
+	return *_vc_ptr++;
+}
+
+
+void SimonState::vc_skip_next_instruction() {
+	static const byte opcode_param_len_simon1[] = {
+		0, 6, 2,10, 6, 4, 2, 2,
+		4, 4,10, 0, 2, 2, 2, 2,
+		2, 0, 2, 0, 4, 2, 4, 2,
+		8, 0,10, 0, 8, 0, 2, 2,
+		4, 0, 0, 4, 4, 2, 2, 4,
+		4, 4, 4, 2, 2, 2, 2, 4,
+		0, 2, 2, 2, 2, 4, 6, 6,
+		0, 0, 0, 0, 2, 6, 0, 0,
+	};
+
+	static const byte opcode_param_len_simon2[] = {
+		0, 6, 2, 12, 6, 4, 2, 2,
+		4, 4, 9, 0, 1, 2, 2, 2,
+		2, 0, 2, 0, 4, 2, 4, 2,
+		7, 0, 10, 0, 8, 0, 2, 2,
+		4, 0, 0, 4, 4, 2, 2, 4,
+		4, 4, 4, 2, 2, 2, 2, 4,
+		0, 2, 2, 2, 2, 4, 6, 6,
+		2, 0, 6, 6, 4, 6, 0, 0,
+		0, 0, 4, 4, 4, 4, 4, 0,
+		4, 2, 2
+	};
+
+	if (_game & GAME_SIMON2) {
+		uint opcode = vc_read_next_byte();
+		_vc_ptr += opcode_param_len_simon2[opcode];
+	} else {
+		uint opcode = vc_read_next_word();
+		_vc_ptr += opcode_param_len_simon1[opcode];
+	}
+
+#ifdef DUMP_CONTINOUS_VGASCRIPT
+	fprintf(_dump_file,"; skipped\n");
+#endif
+}
+
+void SimonState::vc_1() {
+	/* dummy opcode */
+	_vc_ptr += 6;
+}
+
+void SimonState::vc_2() {
+	VgaPointersEntry *vpe;
+	uint num;
+	uint res;
+	byte *old_file_1, *old_file_2;
+	byte *b,*bb, *vc_ptr_org;
+
+	num = vc_read_var_or_word(_vc_ptr);
+
+	old_file_1 = _cur_vga_file_1;
+	old_file_2 = _cur_vga_file_2;
+
+	for(;;) {
+		res = num / 100;
+		vpe = &_vga_buffer_pointers[res];
+
+		_cur_vga_file_1 = vpe->vgaFile1;
+		_cur_vga_file_2 = vpe->vgaFile2;
+		if (vpe->vgaFile1 != NULL)
+			break;
+		if (_vga_cur_file_2 != res)
+			_video_var_7 = _vga_cur_file_2;
+
+		ensureVgaResLoaded(res);
+		_video_var_7 = 0xFFFF;
+	}	
+
+	
+	bb = _cur_vga_file_1;
+	b = bb + swap16(((VgaFile1Header*)bb)->hdr2_start);
+	b = bb + swap16(((VgaFile1Header2*)b)->unk2_offs);
+
+	while (swap16(((VgaFile1Struct0x8*)b)->id) != num)
+		b += sizeof(VgaFile1Struct0x8);
+
+	vc_ptr_org = _vc_ptr;
+
+	_vc_ptr = _cur_vga_file_1 + swap16(((VgaFile1Struct0x8*)b)->script_offs);
+	
+	
+//	dump_vga_script(_vc_ptr, res, num);
+	run_vga_script();
+	
+	_cur_vga_file_1 = old_file_1;
+	_cur_vga_file_2 = old_file_2;
+
+	_vc_ptr = vc_ptr_org + 2;
+}
+
+void SimonState::vc_3() {
+	uint16 a,b,c,d,e,f;
+	uint16 res;
+	VgaSprite *vsp;
+	VgaPointersEntry *vpe;
+	byte *p,*pp;
+
+	a = vc_read_next_word(); /* 0 */
+
+	if (_game & GAME_SIMON2) {
+		f = vc_read_next_word(); /* 0 */
+		b = vc_read_next_word(); /* 2 */
+	} else {
+		b = vc_read_next_word(); /* 2 */
+		f = b / 100;
+	}
+
+	c = vc_read_next_word(); /* 4 */
+	d = vc_read_next_word(); /* 6 */
+	e = vc_read_next_word(); /* 8 */
+
+	/* 2nd param ignored with simon1 */
+	if (has_vgastruct_with_id(b,f))
+		return;
+
+	vsp = _vga_sprites;
+	while (vsp->id) vsp++;
+
+	vsp->base_color = e;
+	vsp->unk6 = a;
+	vsp->unk5 = 0;
+	vsp->unk4 = 0;
+	vsp->image = 0;
+	vsp->x = c;
+	vsp->y = d;
+	vsp->id = b;
+	vsp->unk7 = res = f;
+
+	for(;;) {
+		vpe = &_vga_buffer_pointers[res];
+		_cur_vga_file_1 = vpe->vgaFile1;
+
+		if (vpe->vgaFile1 != NULL)
+			break;
+		if (res != _vga_cur_file_2)
+			_video_var_7 = res;
+
+		ensureVgaResLoaded(res);
+		_video_var_7 = 0xFFFF;
+	}
+
+	pp = _cur_vga_file_1;
+	p = pp + swap16(((VgaFile1Header*)pp)->hdr2_start);
+	p = pp + swap16(((VgaFile1Header2*)p)->id_table);
+	
+	while (swap16(((VgaFile1Struct0x6*)p)->id) != b)
+		p += sizeof(VgaFile1Struct0x6);
+
+#ifdef DUMP_FILE_NR
+{
+	static bool dumped=false;
+	if (res == DUMP_FILE_NR && !dumped) {
+		dumped = true;
+		dump_vga_file(_cur_vga_file_1);
+	}
+}
+#endif
+
+#ifdef DUMP_BITMAPS_FILE_NR
+{
+	static bool dumped=false;
+	if (res == DUMP_BITMAPS_FILE_NR && !dumped) {
+		dumped = true;
+		dump_vga_bitmaps(_cur_vga_file_2, _cur_vga_file_1, res);
+	}
+}
+#endif
+
+	dump_vga_script(_cur_vga_file_1 + swap16(((VgaFile1Struct0x6*)p)->script_offs), res, b);
+
+	add_vga_timer(gss->VGA_DELAY_BASE, 
+		_cur_vga_file_1 + swap16(((VgaFile1Struct0x6*)p)->script_offs),b , res);
+}
+
+void SimonState::vc_4() {
+	/* dummy opcode */
+	_vc_ptr += 6;
+}
+
+void SimonState::vc_5() {
+	uint var = vc_read_next_word();
+	uint value = vc_read_next_word();
+	if (vc_read_var(var) != value)
+		vc_skip_next_instruction();
+}
+
+void SimonState::vc_6_maybe_skip_3_inv() {
+	if (!vc_maybe_skip_proc_3(vc_read_next_word()))
+		vc_skip_next_instruction();
+}
+
+void SimonState::vc_7_maybe_skip_3() {
+	if (vc_maybe_skip_proc_3(vc_read_next_word()))
+		vc_skip_next_instruction();
+}
+
+void SimonState::vc_8_maybe_skip_2() {
+	uint a = vc_read_next_word();
+	uint b = vc_read_next_word();
+	if (!vc_maybe_skip_proc_2(a,b))
+		vc_skip_next_instruction();
+}
+
+void SimonState::vc_9_maybe_skip() {
+	uint a = vc_read_next_word();
+	uint b = vc_read_next_word();
+	if (!vc_maybe_skip_proc_1(a,b))
+		vc_skip_next_instruction();
+}
+
+struct VC10_state {
+	int image;
+	uint16 e;
+	int x,y;
+
+	byte base_color;
+
+	uint draw_width, draw_height;
+	uint x_skip, y_skip;
+
+	byte *surf2_addr;
+	uint surf2_pitch;
+
+	byte *surf_addr;
+	uint surf_pitch;
+
+	byte dl,dh;
+
+	byte *depack_src;
+	int8 depack_cont;
+
+	byte depack_dest[200];
+};
+
+byte *vc_10_depack_column(VC10_state *vs) {
+	int8 a = vs->depack_cont;
+	byte *src = vs->depack_src;
+	byte *dst = vs->depack_dest;
+	byte dh = vs->dh;
+	byte color;
+
+	if (a != -0x80)
+		goto start_here;
+
+	for(;;) {
+		a = *src++;
+start_here:;
+		if (a>=0) {
+			color = *src++;
+			do {
+				*dst++ = color;
+				if (!--dh) {
+					if (--a<0)
+						a = -0x80;
+					else
+						src--;
+					goto get_out;
+				}
+			} while(--a>=0);
+		} else {
+			do {
+				*dst++ = *src++;
+				if (!--dh) {
+					if (++a==0)
+						a = -0x80;
+					goto get_out;
+				}
+			} while (++a!=0);
+		}
+	}
+
+get_out:;
+	vs->depack_src = src;
+	vs->depack_cont = a;
+	return vs->depack_dest + vs->y_skip;
+}
+
+void vc_10_skip_cols(VC10_state *vs) {
+	vs->depack_cont = -0x80;
+	while(vs->x_skip) {
+		vc_10_depack_column(vs);
+		vs->x_skip--;
+	}
+}
+
+byte *SimonState::vc_10_depack_swap(byte *src, uint w, uint h) {
+	w<<=3;
+
+	{
+		byte *dst_org = _video_buf_1 + w;
+		byte color;
+		int8 cur = -0x80;
+		uint w_cur = w;
+
+		do {
+			byte *dst = dst_org;
+			uint h_cur = h;
+			
+			if (cur == -0x80)
+				cur = *src++;
+			
+			for(;;) {
+				if (cur >= 0) {
+					/* rle_same */
+					color = *src++;
+					do {
+						*dst = color;
+						dst += w;
+						if (!--h_cur) {
+							if (--cur<0)
+								cur = -0x80;
+							else
+								src--;
+							goto next_line;
+						}
+					} while (--cur>=0);
+				} else {
+					/* rle_diff */
+					do {
+						*dst = *src++;
+						dst += w;
+						if (!--h_cur) {
+							if (++cur == 0)
+								cur = -0x80;
+							goto next_line;
+						}
+					} while (++cur != 0);
+				}
+				cur = *src++;
+			}
+	next_line:
+			dst_org++;
+		} while(--w_cur);
+	}
+
+	{
+		byte *dst_org, *src_org;
+		uint i;
+	
+		src_org = dst_org = _video_buf_1 + w;
+
+		do {
+			byte *dst = dst_org;
+			for(i=0; i!=w; ++i) {
+				byte b = src_org[i];
+				b = (b>>4) | (b<<4);
+				*--dst = b;
+			}
+
+			src_org += w;
+			dst_org += w;
+		} while (--h);
+
+	}
+
+	return _video_buf_1;
+
+}
+
+byte *vc_10_no_depack_swap(byte *src) {
+	error("vc_10_no_depack_swap unimpl");
+}
+
+/* must not be const */
+static uint16 _video_windows[128] = {
+	0, 0, 20, 200,
+	0, 0,  3, 136,
+	17,0,  3, 136,
+	0, 0, 20, 200,
+	0, 0, 20, 134
+};
+
+/* simon2 specific */
+void SimonState::vc_10_helper_8(byte *dst, byte *src) {
+	const uint pitch = _dx_surface_pitch;
+	int8 reps = (int8)0x80;
+	byte color;
+	byte *dst_org = dst;
+	uint h = _vga_var5, w = 8;
+	
+	for(;;) {
+		reps = *src++;
+		if (reps >= 0) {
+			color = *src++;
+			
+			do {	
+				*dst = color;
+				dst += pitch;
+
+				/* reached bottom? */
+				if (--h == 0) {
+					/* reached right edge? */				
+					if (--w == 0)
+						return;
+					dst = ++dst_org;
+					h = _vga_var5;
+				}
+			} while (--reps >=0);
+		} else {
+			
+			do {	
+				*dst = *src++;
+				dst += pitch;
+
+				/* reached bottom? */
+				if (--h == 0) {
+					/* reached right edge? */				
+					if (--w == 0)
+						return;
+					dst = ++dst_org;
+					h = _vga_var5;
+				}
+			} while (++reps != 0);
+		}
+	}
+}
+
+void SimonState::vc_10() {
+	byte *p2;
+	uint width,height;
+	byte flags;
+	const uint16 *vlut;
+	VC10_state state;
+	
+	int cur;
+
+	state.image = (int16)vc_read_next_word();
+	if (state.image==0)
+		return;
+
+//	if (_vga_cur_sprite_id != 802)
+//		return;
+
+	state.base_color = (_vc_ptr[1]<<4);
+	_vc_ptr += 2;
+	state.x = (int16)vc_read_next_word();
+	if (_game & GAME_SIMON2) {
+		state.x -= _x_scroll;
+	}
+	state.y = (int16)vc_read_next_word();
+
+	if (!(_game & GAME_SIMON2)) {
+		state.e = vc_read_next_word();
+	} else {
+		state.e = vc_read_next_byte();
+	}
+
+	if (state.image < 0)
+		state.image = vc_read_var(-state.image);
+
+	p2 = _cur_vga_file_2 + state.image * 8;
+	state.depack_src = _cur_vga_file_2 + swap32(*(uint32*)p2);
+
+	width = swap16(*(uint16*)(p2+6))>>4;
+	height = p2[5];
+	flags = p2[4];
+
+	if (height==0 || width==0)
+		return;
+
+#ifdef DUMP_DRAWN_BITMAPS
+	dump_single_bitmap(_vga_cur_file_id, state.image, state.depack_src, width*16, height, state.base_color);
+#endif
+
+	if (flags&0x80 && !(state.e&0x10)) {
+		if (state.e&1) {
+			state.e&=~1;
+			state.e|=0x10;
+		} else {
+			state.e|=0x8;
+		}
+	}
+
+	if (_game & GAME_SIMON2 && width>=21) {
+		byte *src,*dst;
+		uint w;
+
+		_vga_var1 = width*2-40;
+		_vga_var7 = state.depack_src;
+		_vga_var5 = height;
+		if (_variableArray[34]==-1)
+			state.x = _variableArray[502/2];
+
+		_x_scroll = state.x;
+
+		vc_write_var(0xfb, _x_scroll);
+
+		dst = dx_lock_attached();
+		src = state.depack_src + _x_scroll * 4;
+		
+		w = 40;
+		do {
+			vc_10_helper_8(dst, src + swap32(*(uint32*)src));
+			dst += 8;
+			src += 4;
+		} while (--w);
+		
+		dx_unlock_attached();
+
+	
+		return;	
+	}
+
+	if (state.e&0x10)
+		state.depack_src = vc_10_depack_swap(state.depack_src, width, height);
+	else if (state.e&1)
+		state.depack_src = vc_10_no_depack_swap(state.depack_src);
+
+
+	vlut = &_video_windows[_video_palette_mode * 4];
+
+	state.draw_width = width << 1; /* cl */
+	state.draw_height = height;    /* ch */
+
+	state.x_skip = 0; /* colums to skip = bh */
+	state.y_skip = 0; /* rows to skip   = bl */
+	
+	cur = state.x;
+	if (cur < 0) {
+		do {
+			if (!--state.draw_width) return;
+			state.x_skip++;
+		} while(++cur);
+	}
+	state.x = cur;
+
+	cur += state.draw_width - (vlut[2]<<1);
+	if (cur > 0) {
+		do {
+			if (!--state.draw_width) return;
+		} while (--cur);
+	}
+	
+	cur = state.y;
+	if (cur < 0) {
+		do {
+			if (!--state.draw_height) return;
+			state.y_skip++;
+		} while(++cur);
+	}
+	state.y = cur;
+
+	cur += state.draw_height - vlut[3];
+	if (cur > 0) {
+		do {
+			if (!--state.draw_height) return;
+		} while (--cur);
+	}
+
+	assert(state.draw_width!=0 && state.draw_height!=0);
+
+	state.draw_width<<=2;
+
+	state.surf2_addr = dx_lock_2();
+	state.surf2_pitch = _dx_surface_pitch;
+
+	state.surf_addr = dx_lock_attached();
+	state.surf_pitch = _dx_surface_pitch;
+
+	{
+		uint offs = ((vlut[0] - _video_windows[16])*2 + state.x) * 8;
+		uint offs2 = (vlut[1] - _video_windows[17] + state.y);
+
+		state.surf2_addr += offs + offs2 * state.surf2_pitch;
+		state.surf_addr += offs + offs2 * state.surf_pitch;
+	}
+
+	if (state.e & 0x20) {
+		byte *mask, *src, *dst;
+		byte h;
+		uint w;
+
+		state.x_skip<<=2;
+		state.dl = width;
+		state.dh = height;
+		
+		vc_10_skip_cols(&state);
+		
+		/* XXX: implement transparency */
+
+		w = 0;
+		do {
+			mask = vc_10_depack_column(&state); /* esi */
+			src = state.surf2_addr + w*2; /* ebx */
+			dst = state.surf_addr + w*2;  /* edi */
+
+			h = state.draw_height;
+			do {
+				if (mask[0] & 0xF0) dst[0] = src[0];
+				if (mask[0] & 0x0F) dst[1] = src[1];
+				mask++;
+				dst += state.surf_pitch;
+				src += state.surf2_pitch;
+			} while(--h);
+		} while(++w != state.draw_width);
+
+		/* vc_10_helper_5 */
+	} else if (_lock_word&0x20 && state.base_color==0 || state.base_color==0xC0) {
+		byte *src,*dst;
+		uint h,i;
+	
+		if (!(state.e&8)) {
+			src = state.depack_src + (width * state.y_skip<<4) + (state.x_skip<<3);
+			dst = state.surf_addr;
+
+			state.draw_width *= 2;
+			
+			if(state.e&2) {
+				/* no transparency */
+				h = state.draw_height;
+				do {
+					memcpy(dst,src,state.draw_width);
+					dst += 320;
+					src += width * 16;
+				} while(--h);
+			} else {
+				/* transparency */
+				h = state.draw_height;
+				do {
+					for(i=0; i!=state.draw_width; i++)
+						if(src[i])
+							dst[i] = src[i];
+					dst += 320;
+					src += width * 16;
+				} while(--h);
+			}
+
+		} else {
+			byte *dst_org = state.surf_addr;
+			src = state.depack_src;
+			/* AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD EEEEEEEE
+			 * aaaaabbb bbcccccd ddddeeee efffffgg ggghhhhh
+			 */
+			
+			if (state.e & 2) {
+				/* no transparency */
+				do {
+					uint count = state.draw_width>>2;
+					
+					dst = dst_org;
+					do {
+						uint32 bits = (src[0]<<24) | (src[1]<<16) | (src[2]<<8) | (src[3]);
+						
+						dst[0] = (byte)((bits >> (32-5)) & 31);
+						dst[1] = (byte)((bits >> (32-10)) & 31);
+						dst[2] = (byte)((bits >> (32-15)) & 31);
+						dst[3] = (byte)((bits >> (32-20)) & 31);
+						dst[4] = (byte)((bits >> (32-25)) & 31);
+						dst[5] = (byte)((bits >> (32-30)) & 31);
+
+						bits = (bits<<8) | src[4];
+
+						dst[6] = (byte)((bits >> (40-35)) & 31);
+						dst[7] = (byte)((bits) & 31);
+
+						dst += 8;
+						src += 5;
+					} while (--count);
+					dst_org += 320;
+				} while (--state.draw_height);
+			} else {
+				/* transparency */
+				do {
+					uint count = state.draw_width>>2;
+					
+					dst = dst_org;
+					do {
+						uint32 bits = (src[0]<<24) | (src[1]<<16) | (src[2]<<8) | (src[3]);
+						byte tmp;
+						
+						tmp = (byte)((bits >> (32-5)) & 31); if (tmp) dst[0] = tmp;
+						tmp = (byte)((bits >> (32-10)) & 31); if (tmp) dst[1] = tmp;
+						tmp = (byte)((bits >> (32-15)) & 31); if (tmp) dst[2] = tmp;
+						tmp = (byte)((bits >> (32-20)) & 31); if (tmp) dst[3] = tmp;
+						tmp = (byte)((bits >> (32-25)) & 31); if (tmp) dst[4] = tmp;
+						tmp = (byte)((bits >> (32-30)) & 31); if (tmp) dst[5] = tmp;
+
+						bits = (bits<<8) | src[4];
+
+						tmp = (byte)((bits >> (40-35)) & 31); if (tmp) dst[6] = tmp;
+						tmp = (byte)((bits) & 31); if (tmp) dst[7] = tmp;
+
+						dst += 8;
+						src += 5;
+						} while (--count);
+					dst_org += 320;
+				} while (--state.draw_height);
+			}
+		}
+		/* vc_10_helper_4 */
+	} else {
+		if (_game&GAME_SIMON2 && state.e&0x4 && _bit_array[10]&0x800) {
+			state.surf_addr = state.surf2_addr;
+			state.surf_pitch = state.surf2_pitch;
+			warning("vc_10: (state.e&0x4)");
+		}	
+		
+		if (state.e & 0x8) {
+			uint w,h;
+			byte *src, *dst,*dst_org;
+
+			state.x_skip <<= 2; /* reached */
+			state.dl = width;
+			state.dh = height;
+
+			vc_10_skip_cols(&state);
+
+			if (state.e&2) {
+				dst_org = state.surf_addr;
+				w = 0;
+				do {
+					src = vc_10_depack_column(&state);
+					dst = dst_org;
+					
+					h = 0;
+					do {
+						dst[0] = (*src >> 4) | state.base_color;
+						dst[1] = (*src&15) | state.base_color;
+						dst += 320;
+						src++;
+					} while (++h != state.draw_height);
+					dst_org += 2;
+				} while (++w != state.draw_width);
+			} else {
+				dst_org = state.surf_addr;
+				if (state.e & 0x40) { /* reached */
+					dst_org += vc_read_var(252);
+				}
+				w = 0;
+				do {
+					byte color;
+
+					src = vc_10_depack_column(&state);
+					dst = dst_org;
+					
+					h = 0;
+					do {
+						color = (*src >> 4);
+						if (color) dst[0] = color | state.base_color;
+						color = (*src&15);
+						if (color) dst[1] = color | state.base_color;
+						dst += 320;
+						src++;
+					} while (++h != state.draw_height);
+					dst_org += 2;
+				} while (++w != state.draw_width);			
+			}
+			/* vc_10_helper_6 */
+		} else {
+			byte *src,*dst;
+			uint count;
+
+			src = state.depack_src + (width * state.y_skip) * 8;
+			dst = state.surf_addr;
+			state.x_skip <<= 2;
+			if (state.e&2) {
+				do {
+					for(count=0; count!=state.draw_width; count++) {
+						dst[count*2] = (src[count+state.x_skip]>>4) | state.base_color;
+						dst[count*2+1] = (src[count+state.x_skip]&15) | state.base_color;
+					}
+					dst += 320;
+					src += width * 8;
+				} while (--state.draw_height);
+			} else {
+				do {
+					for(count=0; count!=state.draw_width; count++) {
+						byte color;
+						color = (src[count+state.x_skip]>>4);
+						if(color) dst[count*2] = color | state.base_color;
+						color = (src[count+state.x_skip]&15);
+						if (color) dst[count*2+1] = color | state.base_color;
+					}
+					dst += 320;
+					src += width * 8;
+				} while (--state.draw_height);
+
+			}
+
+			/* vc_10_helper_7 */
+		}
+	}
+
+	dx_unlock_2();
+	dx_unlock_attached();
+
+}
+
+void SimonState::vc_11_clear_pathfind_array() {
+	memset(&_pathfind_array, 0, sizeof(_pathfind_array));
+}
+
+void SimonState::vc_12_sleep_variable() {
+	uint num;
+
+	if (!(_game & GAME_SIMON2)) {
+		num = vc_read_var_or_word(_vc_ptr);
+		_vc_ptr += 2;
+	} else {
+		num = vc_read_next_byte() * _vga_base_delay;
+	}
+
+	add_vga_timer(num + gss->VGA_DELAY_BASE, _vc_ptr, _vga_cur_sprite_id, _vga_cur_file_id);
+	_vc_ptr = (byte*)&vc_get_out_of_code;
+}
+
+void SimonState::vc_13_offset_x() {
+	VgaSprite *vsp = find_cur_sprite();
+	int16 a = vc_read_next_word();
+	vsp->x += a;
+	_vga_sprite_changed++;
+}
+
+void SimonState::vc_14_offset_y() {
+	VgaSprite *vsp = find_cur_sprite();
+	int16 a = vc_read_next_word();
+	vsp->y += a;
+	_vga_sprite_changed++;
+}
+
+/* wakeup_id */
+void SimonState::vc_15_start_funkystruct_by_id() {
+	VgaSleepStruct *vfs = _vga_sleep_structs, *vfs_tmp;
+	uint16 id = vc_read_next_word();
+	while (vfs->ident != 0) {
+		if (vfs->ident == id) {
+			add_vga_timer(gss->VGA_DELAY_BASE, vfs->code_ptr, vfs->sprite_id, vfs->cur_vga_file);
+			vfs_tmp = vfs;
+			do {
+				memcpy(vfs_tmp, vfs_tmp + 1, sizeof(VgaSleepStruct));
+				vfs_tmp++;
+			} while (vfs_tmp->ident != 0);
+		} else {
+			vfs++;
+		}
+	}
+
+	/* clear a wait event */
+	if (id == _vga_wait_for)
+		_vga_wait_for = 0;
+}
+
+
+/* sleep_on_id */
+void SimonState::vc_16_setup_funkystruct() {
+	VgaSleepStruct *vfs = _vga_sleep_structs;
+	while (vfs->ident)
+		vfs++;
+
+	vfs->ident = vc_read_next_word();
+	vfs->code_ptr = _vc_ptr;
+	vfs->sprite_id = _vga_cur_sprite_id;
+	vfs->cur_vga_file = _vga_cur_file_id;
+	
+	_vc_ptr = (byte*)&vc_get_out_of_code;
+}
+
+void SimonState::vc_17_set_pathfind_item() {
+	uint a = vc_read_next_word();
+	_pathfind_array[a - 1] = (uint16*)_vc_ptr;
+	while ( *(uint16*)_vc_ptr != 0xE703) /* this is a byte swapped 999 */
+		_vc_ptr += 4;
+	_vc_ptr += 2;
+}
+
+void SimonState::vc_18_jump_rel() {
+	int16 offs = vc_read_next_word();
+	_vc_ptr += offs;
+}
+
+/* chain to script? */
+void SimonState::vc_19() {
+ /* XXX: not implemented */
+	error("vc_19: chain to script not implemented");
+}
+
+void SimonState::vc_20() {
+	/* no idea what's going on */
+	uint16 a = vc_read_next_word();
+	*(uint16*)_vc_ptr = a;
+	_vc_ptr += 2;
+}
+
+void SimonState::vc_21() {
+	if (!(_game & GAME_SIMON2)) {
+		int16 a = vc_read_next_word();
+		uint16 *tmp = (uint16*)(_vc_ptr + a);
+
+		if (tmp[2] != 0) {
+			tmp[2]--;
+			_vc_ptr = (byte*)tmp + 6;
+		}
+	} else {
+		int16 a = vc_read_next_word();
+		byte *tmp = _vc_ptr + a;
+
+		if (*(uint16*)(tmp+3) != 0) {
+			(*(uint16*)(tmp+3))--;
+			_vc_ptr = (byte*)tmp + 5;
+		}
+	}
+}
+
+void SimonState::vc_22() {
+	uint a = vc_read_next_word();
+	uint b = vc_read_next_word();
+	uint num = a==0 ? 0x20 : 0x10;
+	byte *palptr, *src;
+	
+	palptr = &_palette[(a<<6)];
+
+	src = _cur_vga_file_1 + 6 + b*96;
+	
+	do {
+		palptr[0] = src[0]<<2;
+		palptr[1] = src[1]<<2;
+		palptr[2] = src[2]<<2;
+		palptr[3] = 0;
+
+		palptr += 4;
+		src += 3;
+	} while (--num);
+
+	_video_var_9 = 2;
+	_vga_sprite_changed++;
+}
+
+void SimonState::vc_23_set_pri() {
+	VgaSprite *vsp = find_cur_sprite(), *vus2;
+	uint16 pri = vc_read_next_word();
+	VgaSprite bak;
+
+	if (vsp->id == 0) {
+		warning("tried to set pri for unknown id %d", _vga_cur_sprite_id);
+		return;
+	}
+	
+	memcpy(&bak, vsp, sizeof(bak));
+	bak.unk5 = pri;
+	bak.unk6 |= 0x8000;
+
+	vus2 = vsp;
+
+	if (vsp != _vga_sprites && pri < vsp[-1].unk5) {
+		do {
+			vsp--;
+		} while (vsp != _vga_sprites && pri < vsp[-1].unk5);
+		do {
+			memcpy(vus2, vus2-1, sizeof(VgaSprite));	
+		} while (--vus2 != vsp);
+		memcpy(vus2, &bak, sizeof(VgaSprite));
+	} else if (vsp[1].id!=0 && pri >= vsp[1].unk5) {
+		do {
+			vsp++;
+		} while (vsp[1].id!=0 && pri >= vsp[1].unk5);
+		do {
+			memcpy(vus2, vus2+1,sizeof(VgaSprite));
+		} while (++vus2 != vsp);
+		memcpy(vus2, &bak, sizeof(VgaSprite));
+	} else {
+		vsp->unk5 = pri;
+	}
+	_vga_sprite_changed++;
+}
+
+void SimonState::vc_24_set_image_xy() {
+	VgaSprite *vsp = find_cur_sprite();
+	vsp->image = vc_read_var_or_word(_vc_ptr);
+	_vc_ptr += 2;
+
+	if (vsp->id==0) {
+		warning("Trying to set XY of nonexistent sprite '%d'", _vga_cur_sprite_id);
+	}
+
+	vsp->x += (int16)vc_read_next_word();
+	vsp->y += (int16)vc_read_next_word();
+	if (!(_game & GAME_SIMON2)) {
+		vsp->unk4 = vc_read_next_word();
+	} else {
+		vsp->unk4 = vc_read_next_byte();
+	}
+
+	_vga_sprite_changed++;
+}
+
+void SimonState::vc_25_del_sprite_and_get_out() {
+	VgaSprite *vsp = find_cur_sprite();
+	while (vsp->id != 0) {
+		memcpy(vsp,vsp+1,sizeof(VgaSprite));
+		vsp++;
+	}
+	_vc_ptr = (byte*)&vc_get_out_of_code;
+	_vga_sprite_changed++;
+}
+
+void SimonState::vc_26() {
+	uint16 *as = &_video_windows[vc_read_next_word()*4];
+	as[0] = vc_read_next_word();
+	as[1] = vc_read_next_word();
+	as[2] = vc_read_next_word();
+	as[3] = vc_read_next_word();
+}
+
+void SimonState::vc_27_reset_simon1() {
+	VgaSprite bak,*vsp;
+	VgaSleepStruct *vfs;
+	VgaTimerEntry *vte,*vte2;
+
+	_lock_word |= 8;
+
+	memset(&bak,0,sizeof(bak));
+
+	vsp = _vga_sprites;
+	while (vsp->id) {
+		if (vsp->id == 128) {
+			memcpy(&bak,vsp,sizeof(VgaSprite));
+		}
+		vsp->id = 0;
+		vsp++;
+	}
+
+	if (bak.id != 0)
+		memcpy(_vga_sprites, &bak, sizeof(VgaSprite));
+
+	vfs = _vga_sleep_structs;
+	while (vfs->ident) {
+		vfs->ident = 0;
+		vfs++;
+	}
+
+	
+	vte = _vga_timer_list;
+	while (vte->delay) {
+		if (vte->sprite_id != 0x80) {
+			vte2 = vte;
+			while (vte2->delay) {
+				memcpy(vte2,vte2+1,sizeof(VgaTimerEntry));
+				vte2++;
+			}
+		} else {
+			vte++;
+		}
+	}
+
+	vc_write_var(0xFE, 0);
+	
+	_lock_word &= ~8;
+}
+
+
+void SimonState::vc_27_reset_simon2() {
+	_lock_word |= 8;
+	
+	{
+		VgaSprite *vsp = _vga_sprites;
+		while (vsp->id) {
+			vsp->id = 0;
+			vsp++;
+		}
+	}
+
+	{
+		VgaSleepStruct *vfs = _vga_sleep_structs;
+		while (vfs->ident) {
+			vfs->ident = 0;
+			vfs++;
+		}
+	}
+
+	{	
+		VgaTimerEntry *vte = _vga_timer_list;
+		while (vte->delay) {
+			VgaTimerEntry *vte2 = vte;
+			while (vte2->delay) {
+				memcpy(vte2,vte2+1,sizeof(VgaTimerEntry));
+				vte2++;
+			}
+		}
+	}
+
+	vc_write_var(0xFE, 0);
+	
+	_lock_word &= ~8;
+}
+
+void SimonState::vc_27_reset() {
+	if (!(_game & GAME_SIMON2))
+		vc_27_reset_simon1();
+	else
+		vc_27_reset_simon2();
+}
+
+void SimonState::vc_28() {
+	/* dummy opcode */
+	_vc_ptr += 8;
+}
+
+void SimonState::vc_29_stop_all_sounds() {
+	/* XXX: implement */
+//	warning("vc_29_stop_all_sounds unimplemented");
+	
+	_voice_size = 0;
+	_sound_size = 0;
+}
+
+void SimonState::vc_30_set_base_delay() {
+	_vga_base_delay = vc_read_next_word();
+}
+
+void SimonState::vc_31_set_palette_mode() {
+	_video_palette_mode = vc_read_next_word();
+}
+
+uint SimonState::vc_read_var(uint var) {
+	assert(var<255);
+	return (uint16)_variableArray[var];
+}
+
+void SimonState::vc_write_var(uint var, int16 value) {
+	_variableArray[var] = value;
+}
+
+void SimonState::vc_32_copy_var() {
+	uint16 a = vc_read_var(vc_read_next_word());
+	vc_write_var(vc_read_next_word(), a);
+}
+
+void SimonState::vc_33() {
+	if (_lock_counter != 0) {
+		_lock_counter = 1;
+		unlock();
+	}
+}
+
+void SimonState::vc_34() {
+	lock();
+	_lock_counter = 200;
+	_left_button_down = 0;
+}
+
+void SimonState::vc_35() {
+	/* not used? */
+	_vc_ptr += 4;
+	_vga_sprite_changed++;
+}
+
+void SimonState::vc_36() {
+	uint vga_res = vc_read_next_word();
+	uint mode = vc_read_next_word();
+
+	if (!(_game & GAME_SIMON2)) {
+		if (mode == 16) {
+			_copy_partial_mode = 2;
+		} else {
+			set_video_mode_internal(mode,vga_res);
+		}
+	} else {
+		set_video_mode_internal(mode,vga_res);
+	}
+}
+
+void SimonState::vc_37_sprite_unk3_add() {
+	VgaSprite *vsp = find_cur_sprite();
+	vsp->y += vc_read_var(vc_read_next_word());
+	_vga_sprite_changed++; 
+}
+
+void SimonState::vc_38_skip_if_var_zero() {
+	uint var = vc_read_next_word();
+	if (vc_read_var(var) == 0)
+		vc_skip_next_instruction();
+}
+
+void SimonState::vc_39_set_var() {
+	uint var = vc_read_next_word();
+	int16 value = vc_read_next_word();
+	vc_write_var(var,value);
+}
+
+void SimonState::vc_40_var_add() {
+	uint var = vc_read_next_word();
+	int16 value = vc_read_var(var) + vc_read_next_word();
+
+	if (_game&GAME_SIMON2 && var==0xF && !(_bit_array[5]&1)) {
+		int16 tmp;
+
+		if (_vga_var2!=0) {
+			if (_vga_var2>=0) goto no_scroll;
+			_vga_var2 = 0;
+		} else {
+			if (_vga_var3 != 0) goto no_scroll;
+		}
+
+		if (value - _x_scroll >= 30) {
+			_vga_var2 = 20;
+			tmp = _vga_var1 - _x_scroll;
+			if (tmp < 20)
+				_vga_var2 = tmp;
+			add_vga_timer(10, NULL, 0, 0); /* special timer */
+		}
+	}
+no_scroll:;
+
+	vc_write_var(var, value);
+}
+
+void SimonState::vc_41_var_sub() {
+	uint var = vc_read_next_word();
+	int16 value = vc_read_var(var) - vc_read_next_word();
+
+	if (_game&GAME_SIMON2 && var==0xF && !(_bit_array[5]&1)) {
+		int16 tmp;
+
+		if (_vga_var2!=0) {
+			if (_vga_var2<0) goto no_scroll;
+			_vga_var2 = 0;
+		} else {
+			if (_vga_var3 != 0) goto no_scroll;
+		}
+
+		if ((uint16)(value - _x_scroll) < 11) {
+			_vga_var2 = -20;
+			tmp = _vga_var1 - _x_scroll;
+			if (_x_scroll < 20)
+				_vga_var2 = -_x_scroll;
+			add_vga_timer(10, NULL, 0, 0); /* special timer */
+		}
+	}
+no_scroll:;
+
+	vc_write_var(var, value);
+}
+
+void SimonState::vc_42_delay_if_not_eq() {
+	uint val = vc_read_var(vc_read_next_word());
+	if (val == vc_read_next_word()) {
+		
+		add_vga_timer(_vga_base_delay + 1, _vc_ptr - 4, _vga_cur_sprite_id, _vga_cur_file_id);
+		_vc_ptr = (byte*)&vc_get_out_of_code;
+	}
+}
+
+void SimonState::vc_43_skip_if_bit_clear() {
+	if (!vc_get_bit(vc_read_next_word())) {
+		vc_skip_next_instruction();
+	}
+}
+
+void SimonState::vc_44_skip_if_bit_set() {
+	if (vc_get_bit(vc_read_next_word())) {
+		vc_skip_next_instruction();
+	}
+}
+
+void SimonState::vc_45_set_x() {
+	VgaSprite *vsp = find_cur_sprite();
+	vsp->x = vc_read_var(vc_read_next_word());
+	_vga_sprite_changed++;
+}
+
+void SimonState::vc_46_set_y() {
+	VgaSprite *vsp = find_cur_sprite();
+	vsp->y = vc_read_var(vc_read_next_word());
+	_vga_sprite_changed++;
+}
+
+void SimonState::vc_47_add_var_f() {
+	uint var = vc_read_next_word();
+	vc_write_var(var, vc_read_var(var) + vc_read_var(vc_read_next_word()));
+}
+
+void SimonState::vc_48() {
+	uint a = (uint16)_variableArray[12];
+	uint b = (uint16)_variableArray[13];
+	int c = _variableArray[14];
+	uint16 *p = _pathfind_array[a-1];
+	int step;
+	int y1,y2;
+	int16 *vp;
+
+	p += b*2 + 1;
+
+	step = 2;
+	if (c<0) {
+		c = -c;
+		step = -2;
+	}
+
+	vp = &_variableArray[20];
+
+	do{
+		y2 = swap16(*p);
+		p += step;
+		y1 = swap16(*p) - y2;
+
+//		assert(swap16(p[1]) != 999);
+
+		vp[0] = y1>>1;
+		vp[1] = y1 - (y1>>1);
+
+		vp += 2;
+	} while (--c);
+
+}
+
+void SimonState::vc_set_bit_to(uint bit, bool value) {
+	uint16 *bits = &_bit_array[bit>>4];
+	*bits = (*bits & ~(1<<(bit&15))) | (value << (bit&15));
+}
+
+bool SimonState::vc_get_bit(uint bit) {
+	uint16 *bits = &_bit_array[bit>>4];
+	return (*bits & (1<<(bit&15))) != 0;
+}
+
+void SimonState::vc_49_set_bit() {
+	vc_set_bit_to(vc_read_next_word(), true);
+}
+
+void SimonState::vc_50_clear_bit() {
+	vc_set_bit_to(vc_read_next_word(), false);
+}
+
+void SimonState::vc_51_clear_hitarea_bit_0x40() {
+	clear_hitarea_bit_0x40(vc_read_next_word());
+}
+
+void SimonState::vc_52() {
+	uint16 a = vc_read_next_word();
+
+	if (!(_game & GAME_SIMON2)) {
+		playSound(a);
+	} else {
+		if (a >= 0x8000) {
+			a = -a;
+			warning("vc_52(%d): unimpl");		
+		} else {
+			playSound(a);
+		}
+	}
+}
+
+void SimonState::vc_53_no_op() {
+	/* no op */
+}
+
+void SimonState::vc_54_no_op() {
+	/* no op */
+}
+
+void SimonState::vc_55_offset_hit_area() {
+	HitArea *ha = _hit_areas;
+	uint count = ARRAYSIZE(_hit_areas);
+	uint16 id = vc_read_next_word();
+	int16 x = vc_read_next_word();
+	int16 y = vc_read_next_word();
+
+	for(;;) {
+		if (ha->id == id) {
+			ha->x += x;
+			ha->y += y;
+			break;
+		}
+		ha++;
+		if (!--count)
+			break;
+	}
+	
+	_need_hitarea_recalc++;
+}
+
+void SimonState::vc_56_no_op() {
+	/* No-Op in simon1 */
+	if (_game & GAME_SIMON2) {
+		uint num = vc_read_var_or_word(_vc_ptr) * _vga_base_delay;
+		_vc_ptr += 2;
+		add_vga_timer(num + gss->VGA_DELAY_BASE, _vc_ptr, _vga_cur_sprite_id, _vga_cur_file_id);
+		_vc_ptr = (byte*)&vc_get_out_of_code;
+	}
+}
+
+void SimonState::vc_59() {
+	if (_game & GAME_SIMON2) {
+		uint file = vc_read_next_word();
+		uint start = vc_read_next_word();
+		uint end = vc_read_next_word() + 1;
+		
+		do {
+			vc_kill_thread(file, start);
+		} while (++start != end);
+	} else {
+		if (vc_59_helper())
+			vc_skip_next_instruction();
+	}
+}
+
+void SimonState::vc_58() {
+	uint sprite = _vga_cur_sprite_id;
+	uint file = _vga_cur_file_id;
+	byte *vc_ptr;
+	uint16 tmp;
+		
+	_vga_cur_file_id = vc_read_next_word();
+	_vga_cur_sprite_id = vc_read_next_word();
+
+	tmp = swap16(vc_read_next_word());
+	
+	vc_ptr = _vc_ptr;
+	_vc_ptr = (byte*)&tmp;
+	vc_23_set_pri();
+
+	_vc_ptr = vc_ptr;
+	_vga_cur_sprite_id = sprite;
+	_vga_cur_file_id = file;
+}
+
+void SimonState::vc_57_no_op() {
+	/* no op */
+	
+}
+
+void SimonState::vc_kill_thread(uint file, uint sprite) {
+	uint16 old_sprite_id, old_cur_file_id;
+	VgaSleepStruct *vfs;
+	VgaSprite *vsp;
+	VgaTimerEntry *vte;
+	byte *vc_org;
+
+	old_sprite_id = _vga_cur_sprite_id;
+	old_cur_file_id = _vga_cur_file_id;
+	vc_org = _vc_ptr;
+	
+	_vga_cur_file_id = file;
+	_vga_cur_sprite_id = sprite;
+		
+	vfs = _vga_sleep_structs;
+	while (vfs->ident != 0) {
+		if (vfs->sprite_id == _vga_cur_sprite_id
+			 && (vfs->cur_vga_file == _vga_cur_file_id || !(_game & GAME_SIMON2))
+		) {
+			while (vfs->ident != 0){
+				memcpy(vfs, vfs+1, sizeof(VgaSleepStruct));
+				vfs++;
+			}
+			break;
+		}
+		vfs++;
+	}
+
+	vsp = find_cur_sprite();	
+	if (vsp->id) {
+		vc_25_del_sprite_and_get_out();
+
+		vte = _vga_timer_list;
+		while (vte->delay != 0) {
+			if (vte->sprite_id == _vga_cur_sprite_id
+			 && (vte->cur_vga_file == _vga_cur_file_id || !(_game & GAME_SIMON2) )
+			) {
+				delete_vga_timer(vte);
+				break;
+			}
+			vte++;
+		}
+	}
+
+	_vga_cur_file_id = old_cur_file_id;
+	_vga_cur_sprite_id = old_sprite_id;
+	_vc_ptr = vc_org;
+}
+
+
+/* kill thread */
+void SimonState::vc_60() {
+	uint file;
+
+	if (_game & GAME_SIMON2) {
+		file = vc_read_next_word();
+	} else {
+		file = _vga_cur_file_id;
+	}
+	uint sprite = vc_read_next_word();
+	vc_kill_thread(file, sprite);
+}
+
+void SimonState::vc_61_sprite_change() {
+	VgaSprite *vsp = find_cur_sprite();	
+
+	vsp->image = vc_read_var_or_word(_vc_ptr);
+	_vc_ptr += 2;
+
+	vsp->x += vc_read_next_word();
+	vsp->y += vc_read_next_word();
+	vsp->unk4 = 36;
+
+	_vga_sprite_changed++;
+}
+
+void SimonState::vc_62() {
+	uint i;
+	byte *vc_ptr_org = _vc_ptr;
+
+
+	vc_29_stop_all_sounds();
+	
+//	if (!_video_var_3) {
+		_video_var_3 = true;
+		_video_num_pal_colors = 256;
+		if (_video_palette_mode == 4)
+			_video_num_pal_colors = 208;
+//	}
+
+	memcpy(_video_buf_1, _palette_backup, _video_num_pal_colors * sizeof(uint32));
+	for(i=NUM_PALETTE_FADEOUT;i!=0;--i) {
+		palette_fadeout((uint32*)_video_buf_1, _video_num_pal_colors);
+		_system->set_palette(_video_buf_1, 0, _video_num_pal_colors);
+		_system->update_screen();
+		delay(5);
+	}
+
+	if (!(_game & GAME_SIMON2))	{
+		uint16 params[5]; /* parameters to vc_10 */
+		VgaSprite *vsp;
+		VgaPointersEntry *vpe;
+
+		vsp = _vga_sprites;
+		while (vsp->id != 0) {
+			if (vsp->id == 128) {
+				byte *f1 = _cur_vga_file_1;
+				byte *f2 = _cur_vga_file_2;
+				uint palmode = _video_palette_mode;
+
+				vpe = &_vga_buffer_pointers[vsp->unk7];
+				_cur_vga_file_1 = vpe->vgaFile1;
+				_cur_vga_file_2 = vpe->vgaFile2;
+				_video_palette_mode = vsp->unk6;
+
+				params[0] = swap16(vsp->image);
+				params[1] = swap16(vsp->base_color);
+				params[2] = swap16(vsp->x);
+				params[3] = swap16(vsp->y);
+				params[4] = swap16(vsp->unk4);
+				_vc_ptr = (byte*)params;
+				vc_10();
+
+				_video_palette_mode = palmode;
+				_cur_vga_file_1 = f1;
+				_cur_vga_file_2 = f2;
+				break;
+			}
+			vsp++;
+		}
+	}
+
+	dx_clear_surfaces(_video_palette_mode==4 ? 134 : 200);
+
+	_vc_ptr = vc_ptr_org;
+}
+
+void SimonState::vc_63() {
+	_palette_color_count = 208;
+	if(_video_palette_mode != 4) {
+		_palette_color_count = 256;
+	}
+	_video_var_3 = false;
+}
+
+/* Simon2 specific */
+void SimonState::vc_64() {
+	if (vc_59_helper())
+		vc_skip_next_instruction();
+
+}
+
+/* Simon2 specific */
+void SimonState::vc_65() {
+	error("vc_65 unimplemented");
+}
+
+/* Simon2 specific */
+void SimonState::vc_66() {
+	uint a = vc_read_next_word();
+	uint b = vc_read_next_word();
+
+	if (vc_read_var(a) != vc_read_var(b))
+		vc_skip_next_instruction();
+}
+
+/* Simon2 specific */
+void SimonState::vc_67() {
+	uint a = vc_read_next_word();
+	uint b = vc_read_next_word();
+
+	if (vc_read_var(a) >= vc_read_var(b))
+		vc_skip_next_instruction();
+}
+
+/* Simon2 specific */
+void SimonState::vc_68() {
+	uint a = vc_read_next_word();
+	uint b = vc_read_next_word();
+
+	if (vc_read_var(a) <= vc_read_var(b))
+		vc_skip_next_instruction();
+}
+
+/* Simon2 specific */
+void SimonState::vc_69() {
+	uint16 a = vc_read_next_word();
+	uint16 b = vc_read_next_word();
+
+	warning("vc_69(%d,%d): music stuff?", a, b);
+}
+
+/* Simon2 specific */
+void SimonState::vc_70() {
+	uint16 a = vc_read_next_word();
+	uint16 b = vc_read_next_word();
+
+	_vc70_var1 = a;
+	_vc70_var2 = b;
+	
+	warning("vc_70(%d,%d): music stuff?", a, b);
+}
+
+/* Simon2 specific */
+void SimonState::vc_71() {
+	if (_vc72_var3==0xFFFF && _vc72_var1==0xFFFF)
+		vc_skip_next_instruction();
+}
+
+/* Simon2 specific */
+void SimonState::vc_72() {
+	uint16 a = vc_read_next_word();
+	uint16 b = vc_read_next_word();
+	if (a != _vc72_var1) {
+		_vc72_var2 = b;
+		_vc72_var3 = a;
+	}
+
+	warning("vc_72(%d,%d): music stuff?", a, b);
+}
+
+/* Simon2 specific */
+void SimonState::vc_73() {
+	vc_read_next_byte();
+	_op_189_flags |= 1<<vc_read_next_byte();
+}
+
+/* Simon2 specific */
+void SimonState::vc_74() {
+	vc_read_next_byte();
+	_op_189_flags &= ~(1<<vc_read_next_byte());
+}
+
+
+void SimonState::o_fade_to_black() {
+	uint i;
+
+	memcpy(_video_buf_1, _palette_backup, 256*sizeof(uint32));
+
+	i = NUM_PALETTE_FADEOUT;
+	do {
+		palette_fadeout((uint32*)_video_buf_1, 32);
+		palette_fadeout((uint32*)_video_buf_1 + 32+16, 144);
+		palette_fadeout((uint32*)_video_buf_1 + 32+16+144+16, 48);
+
+		_system->set_palette(_video_buf_1, 0, 256);
+		_system->update_screen();
+		delay(5);
+	} while (--i);
+
+	memcpy(_palette_backup, _video_buf_1, 256*sizeof(uint32));
+	memcpy(_palette, _video_buf_1, 256*sizeof(uint32));
+}
+
+void SimonState::delete_vga_timer(VgaTimerEntry *vte) {
+	_lock_word |= 1;
+	
+	if (vte+1 <= _next_vga_timer_to_process) {
+		_next_vga_timer_to_process--;
+	}
+
+	do {
+		memcpy(vte,vte+1,sizeof(VgaTimerEntry));
+		vte++;
+	} while (vte->delay);
+	
+	_lock_word &= ~1;
+}
+
+void SimonState::expire_vga_timers() {
+	if (_game & GAME_SIMON2) {
+		VgaTimerEntry *vte = _vga_timer_list;
+		
+		_vga_tick_counter++;
+		
+		while (vte->delay) {
+			/* not quite ok, good enough */
+			if ((int16)(vte->delay-=5)<=0) {
+				uint16 cur_file = vte->cur_vga_file;
+				uint16 cur_unk = vte->sprite_id;
+				byte *script_ptr = vte->script_pointer;
+			
+				_next_vga_timer_to_process = vte+1;
+				delete_vga_timer(vte);
+
+				if (script_ptr == NULL) {
+					/* special scroll timer */
+					scroll_timeout();
+				} else {
+					vc_resume_thread(script_ptr, cur_file, cur_unk);
+				}
+				vte = _next_vga_timer_to_process;
+			} else {
+				vte++;
+			}
+		}
+	} else {
+		VgaTimerEntry *vte = _vga_timer_list;
+		
+		_vga_tick_counter++;
+		
+		while (vte->delay) {
+			if (!--vte->delay) {
+				uint16 cur_file = vte->cur_vga_file;
+				uint16 cur_unk = vte->sprite_id;
+				byte *script_ptr = vte->script_pointer;
+			
+				_next_vga_timer_to_process = vte+1;
+				delete_vga_timer(vte);
+
+				vc_resume_thread(script_ptr, cur_file, cur_unk);
+				vte = _next_vga_timer_to_process;
+			} else {
+				vte++;
+			}
+		}
+	}
+}
+
+/* Simon2 specific */
+void SimonState::scroll_timeout() {
+	if (_vga_var2 == 0)
+		return;
+		
+	if (_vga_var2 < 0) {
+		if (_vga_var3!=-1) {
+			_vga_var3 = -1;
+			if (++_vga_var2 == 0)
+				return;
+		}
+	} else {
+		if (_vga_var3!=1) {
+			_vga_var3 = 1;
+			if (--_vga_var2 == 0)
+				return;
+		}
+	}	
+
+	add_vga_timer(10, NULL, 0, 0);
+}
+
+void SimonState::vc_resume_thread(byte *code_ptr, uint16 cur_file, uint16 cur_sprite) {
+	VgaPointersEntry *vpe;
+
+	_vga_cur_sprite_id = cur_sprite;
+	
+	_vga_cur_file_id = cur_file;
+	_vga_cur_file_2 = cur_file;
+	vpe = &_vga_buffer_pointers[cur_file];
+
+	_cur_vga_file_1 = vpe->vgaFile1;
+	_cur_vga_file_2 = vpe->vgaFile2;
+
+	_vc_ptr = code_ptr;
+
+	run_vga_script();
+}
+
+
+void SimonState::add_vga_timer(uint num, byte *code_ptr, uint cur_sprite, uint cur_file) {
+	VgaTimerEntry *vte;
+
+//	assert( (uint)swap16(*(uint16*)code_ptr) <= 63);
+
+	_lock_word |= 1;
+
+	for(vte = _vga_timer_list; vte->delay; vte++) { }
+
+	vte->delay = num;
+	vte->script_pointer = code_ptr;
+	vte->sprite_id = cur_sprite;
+	vte->cur_vga_file = cur_file;
+
+	_lock_word &= ~1;
+}
+
+void SimonState::o_force_unlock() {
+	if (_game&GAME_SIMON2 && _bit_array[4]&0x8000)
+		_mouse_cursor = 0;
+	_lock_counter = 0;
+}
+
+void SimonState::o_force_lock() {
+	_lock_word |= 0x4000;
+	vc_34();
+	_lock_word &= ~0x4000;
+}
+
+void SimonState::o_save_game() {
+	if (!save_game(123, "TEST"))
+		error("save failed");
+//	error("o_save_game: not implemented yet");
+}
+
+void SimonState::o_load_game() {
+	if (!load_game(123))
+		error("load failed");
+}
+
+void SimonState::o_unk_127() {
+	if (_game & GAME_SIMON2) {
+		uint a = getVarOrWord();
+		uint b = getVarOrWord();
+		uint c = getVarOrByte();
+
+		warning("o_unk_127(%d,%d,%d) not implemented properly", a, b, c);	
+
+		if (a!=_last_music_played) {
+			_last_music_played = a;
+			playMusic(a);
+		}
+	} else {
+		uint a = getVarOrWord();
+		uint b = getVarOrWord();
+
+		if (a!=_last_music_played) {
+			_last_music_played = a;
+			playMusic(a);
+		}
+	}
+}
+
+void SimonState::o_unk_120(uint a) {
+	uint16 id = swap16(a);
+	_lock_word |= 0x4000;
+	_vc_ptr = (byte*)&id;
+	vc_15_start_funkystruct_by_id();
+	_lock_word &= ~0x4000;
+}
+
+void SimonState::o_wait_for_vga(uint a) {
+	_vga_wait_for = a;
+	_timer_1 = 0;
+	_exit_cutscene = false;
+	while (_vga_wait_for != 0) {
+		if (_exit_cutscene) {
+			if (vc_get_bit(9)) {
+				startSubroutine170();
+				break;
+			}
+		} else {
+			processSpecialKeys();
+		}
+
+		delay(10);
+	
+//		if (_timer_1 >= 500) {
+//			warning("wait timed out");
+//			break;
+//		}
+			
+	}
+//	warning("waiting on %d done", a);
+}
+
+void SimonState::timer_vga_sprites() {
+	VgaSprite *vsp;
+	VgaPointersEntry *vpe;
+	byte *vc_ptr_org = _vc_ptr;
+	uint16 params[5]; /* parameters to vc_10 */
+
+	if (_video_var_9 == 2)
+		_video_var_9 = 1;
+
+#ifdef DRAW_THREE_STARS
+	fprintf(_dump_file,"***\n");
+#endif
+
+	if (_game&GAME_SIMON2 && _vga_var3) {
+		timer_vga_sprites_helper();
+	}
+
+	vsp = _vga_sprites;
+	while (vsp->id != 0) {
+		vsp->unk6 &= 0x7FFF;
+
+		vpe = &_vga_buffer_pointers[vsp->unk7];
+		_cur_vga_file_1 = vpe->vgaFile1;
+		_cur_vga_file_2 = vpe->vgaFile2;
+		_video_palette_mode = vsp->unk6;
+		_vga_cur_sprite_id = vsp->id;
+
+		params[0] = swap16(vsp->image);
+		params[1] = swap16(vsp->base_color);
+		params[2] = swap16(vsp->x);
+		params[3] = swap16(vsp->y);
+
+		if(_game & GAME_SIMON2) {
+			*(byte*)(&params[4]) = (byte)vsp->unk4;
+		} else {
+			params[4] = swap16(vsp->unk4);
+		}
+
+		_vc_ptr = (byte*)params;
+		vc_10();
+
+		vsp++;
+	}
+
+#ifdef DRAW_IMAGES_DEBUG
+	memset(sdl_buf_attached, 0, 320*200);
+#endif
+	_video_var_8++;
+	_vc_ptr = vc_ptr_org;
+}
+
+void SimonState::timer_vga_sprites_helper() {
+	byte *dst = dx_lock_2(), *src;
+	uint x;
+
+	if (_vga_var3<0) {
+		memmove(dst+8,dst,320*_vga_var5-8);
+	} else {
+		memmove(dst, dst+8, 320*_vga_var5-8);
+	}
+
+	x = _x_scroll-1;
+
+	if (_vga_var3>0) {
+		dst += 320-8;
+		x += 41;
+	}
+
+	src = _vga_var7 + x*4;
+	vc_10_helper_8(dst,src+swap32(*((uint32*)src)));
+
+	dx_unlock_2();
+
+
+	memcpy(sdl_buf_attached, sdl_buf, 320*200);
+	dx_copy_from_attached_to_3(_vga_var5);
+
+
+	_x_scroll += _vga_var3;
+
+	vc_write_var(0xfB, _x_scroll);
+
+	_vga_var3 = 0;
+}
+
+#ifdef DRAW_IMAGES_DEBUG
+void SimonState::timer_vga_sprites_2() {
+	VgaSprite *vsp;
+	VgaPointersEntry *vpe;
+	byte *vc_ptr_org = _vc_ptr;
+	uint16 params[5]; /* parameters to vc_10 */
+
+	if (_video_var_9 == 2)
+		_video_var_9 = 1;
+
+	vsp = _vga_sprites;
+	while (vsp->id != 0) {
+		vsp->unk6 &= 0x7FFF;
+
+		vpe = &_vga_buffer_pointers[vsp->unk7];
+		_cur_vga_file_1 = vpe->vgaFile1;
+		_cur_vga_file_2 = vpe->vgaFile2;
+		_video_palette_mode = vsp->unk6;
+		_vga_cur_sprite_id = vsp->id;
+
+		if (vsp->image)
+			fprintf(_dump_file,"id:%5d image:%3d base-color:%3d x:%3d y:%3d flags:%x\n", 
+				vsp->id, vsp->image, vsp->base_color, vsp->x, vsp->y, vsp->unk4 );
+		params[0] = swap16(vsp->image);
+		params[1] = swap16(vsp->base_color);
+		params[2] = swap16(vsp->x);
+		params[3] = swap16(vsp->y);
+		params[4] = swap16(vsp->unk4);
+		_vc_ptr = (byte*)params;
+		vc_10();
+
+		vsp++;
+	}
+
+#ifdef DRAW_THREE_STARS
+	fprintf(_dump_file,"***\n");
+#endif
+
+	_video_var_8++;
+	_vc_ptr = vc_ptr_org;
+}
+#endif
+
+void SimonState::timer_proc1() {
+	_timer_4++;
+	
+	if(_lock_word & 0xC0E9 || _lock_word & 2)
+		return;
+
+	_timer_1++;
+	
+	_lock_word |= 2;
+
+	if (!(_lock_word&0x10)) {
+		if (!(_game & GAME_SIMON2)) {
+			expire_vga_timers();
+			expire_vga_timers();
+			_cepe_flag^=1;
+			if (!_cepe_flag)
+				expire_vga_timers();
+
+			_sync_flag_2 ^= 1;
+		} else {
+			_sync_flag_2^=1;
+
+			if (!_sync_flag_2)
+				expire_vga_timers();
+			
+			if (_lock_counter!=0 && !_sync_flag_2) {
+				_lock_word &= ~2;
+				return;
+			}
+		}
+
+//		if (_lock_counter !=0 && _sync_flag_2==1) {
+//			printf("skipping draw...\n");
+//			goto get_out;
+//		}
+	}
+	
+	timer_vga_sprites();
+#ifdef DRAW_IMAGES_DEBUG
+	timer_vga_sprites_2();
+#endif
+
+	if (!(_game&GAME_SIMON2) && _copy_partial_mode==2) {
+		/* copy partial from attached to 2 */
+		dx_copy_from_attached_to_2(176, 61, 320-176, 134-61);
+		_copy_partial_mode = 0;
+	}
+
+	/* XXX: more stuff here */
+	if (_video_var_8){
+		handle_mouse_moved();
+		/* XXX: more stuff here */
+		dx_update_screen_and_palette();
+		_sync_flag_1 = false;
+		_video_var_8 = false;
+	}
+
+
+	_lock_word &= ~2;	
+}
+
+void SimonState::timer_callback() {
+//	uint32 start, end;
+
+	if (_timer_5 != 0) {
+		_sync_flag_2 = true;
+		_timer_5 --;
+	} else {
+//		start = timeGetTime();
+		timer_proc1();
+//		end = timeGetTime();
+
+//		if (start + 45 < end) {
+//			_timer_5 = (uint16)( (end - start) / 45);
+//		}
+	}
+}
+
+void SimonState::checkTimerCallback() {
+	if (_invoke_timer_callback && !_in_callback) {
+		_in_callback = true;
+		_invoke_timer_callback = 0;
+		timer_callback();
+		_in_callback = false;
+	}
+}
+
+
+void SimonState::o_unk_163(uint a) {
+	playSound(a);
+}
+
+void SimonState::o_unk_160(uint a) {
+	fcs_proc_1(_fcs_ptr_array_3[_fcs_unk_1], a);
+}
+
+void SimonState::fcs_proc_1(FillOrCopyStruct *fcs, uint value) {
+	fcs->text_color = value;
+}
+
+void SimonState::o_unk_103() {
+	lock();
+	fcs_unk1(_fcs_unk_1);
+	showMessageFormat("\x0C");
+	unlock();
+}
+
+void SimonState::o_vga_reset() {
+	_lock_word |= 0x4000;
+	vc_27_reset();
+	_lock_word &= ~0x4000;
+}
+
+void SimonState::o_unk_99_simon1(uint a) {
+	uint16 b = swap16(a);
+	_lock_word |= 0x4000;
+	_vc_ptr = (byte*)&b;
+	vc_60();
+	_lock_word &= ~0x4000;
+}
+
+void SimonState::o_unk_99_simon2(uint a, uint b) {
+	uint16 items[2];
+	
+	items[0] = swap16(a);
+	items[1] = swap16(b);
+
+	_lock_word |= 0x4000;
+	_vc_ptr = (byte*)&items;
+	vc_60();
+	_lock_word &= ~0x4000;
+}
+
+bool SimonState::vc_maybe_skip_proc_3(uint16 a) {
+	Item *item;
+
+	CHECK_BOUNDS(a, _vc_item_array);
+
+	item = _vc_item_array[a];
+	if (item == NULL)
+		return true;
+
+	return getItem1Ptr()->parent == item->parent;
+}
+
+bool SimonState::vc_maybe_skip_proc_2(uint16 a, uint16 b) {
+	Item *item_a, *item_b;
+
+	CHECK_BOUNDS(a, _vc_item_array);
+	CHECK_BOUNDS(b, _vc_item_array);
+
+	item_a = _vc_item_array[a];
+	item_b = _vc_item_array[b];
+
+	if (item_a == NULL || item_b == NULL)
+		return true;
+
+	return derefItem(item_a->parent) == item_b;
+}
+
+bool SimonState::vc_maybe_skip_proc_1(uint16 a, int16 b) {
+	Item *item;
+
+	CHECK_BOUNDS(a, _vc_item_array);
+
+	item = _vc_item_array[a];
+	if (item == NULL)
+		return true;
+	return item->unk3 == b;
+}
+
+
+/* OK */
+void SimonState::fcs_delete(uint a) {
+	if (_fcs_ptr_array_3[a] == NULL)
+		return;
+	fcs_unk1(a);
+	video_copy_if_flag_0x8_c(_fcs_ptr_array_3[a]);
+	_fcs_ptr_array_3[a] = NULL;
+	if (_fcs_unk_1 == a) {
+		_fcs_ptr_1 = NULL;
+		fcs_unk_2(0);
+	}
+}
+
+/* OK */
+void SimonState::fcs_unk_2(uint a) {
+	a &= 7;
+
+	if (_fcs_ptr_array_3[a] == NULL || _fcs_unk_1 == a)
+		return;
+
+	_fcs_unk_1 = a;
+	startUp_helper_3();
+	_fcs_ptr_1 = _fcs_ptr_array_3[a];
+	
+	showmessage_helper_3(_fcs_ptr_1->unk6, _fcs_ptr_1->unk7);
+}
+
+/* OK */
+void SimonState::o_unk26_helper(uint a, uint b, uint c, uint d, uint e, uint f, uint g, uint h) {
+	a &= 7;
+
+	if (_fcs_ptr_array_3[a])
+		fcs_delete(a);
+
+	_fcs_ptr_array_3[a] = fcs_alloc(b,c,d,e,f,g,h);
+	
+	if (a == _fcs_unk_1) {
+		_fcs_ptr_1 = _fcs_ptr_array_3[a];
+		showmessage_helper_3(_fcs_ptr_1->unk6, _fcs_ptr_1->unk7);
+	}
+}
+
+/* OK */
+FillOrCopyStruct *SimonState::fcs_alloc(uint x, uint y, uint w, uint h, uint flags, uint fill_color, uint unk4) {
+	FillOrCopyStruct *fcs;
+	
+	fcs = _fcs_list;
+	while(fcs->mode != 0) fcs++;
+
+	fcs->mode = 2;
+	fcs->x = x;
+	fcs->y = y;
+	fcs->width = w;
+	fcs->height = h;
+	fcs->flags = flags;
+	fcs->fill_color = fill_color;
+	fcs->text_color = unk4;
+	fcs->unk1 = 0;
+	fcs->unk2 = 0;
+	fcs->unk3 = 0;
+	fcs->unk7 = fcs->width * 8 / 6;
+	return fcs;
+}
+
+Item *SimonState::derefItem(uint item) {
+	if (item >= _itemarray_size)
+		error("derefItem: invalid item %d", item);
+	return _itemarray_ptr[item];
+}
+
+uint SimonState::itemPtrToID(Item *id) {
+	uint i;
+	for(i = 0; i!=_itemarray_size; i++)
+		if (_itemarray_ptr[i] == id)
+			return i;
+	error("itemPtrToID: not found");
+}
+
+void SimonState::o_pathfind(int x,int y,uint var_1,uint var_2) {
+	uint16 *p;
+	uint i, j;
+	uint prev_i;
+	uint x_diff, y_diff;
+	uint best_i, best_j, best_dist = 0xFFFFFFFF;
+
+	prev_i = 21 - _variableArray[12];
+	for(i=20; i!=0; --i) {
+		p = (uint16*)_pathfind_array[20-i];
+		if (!p)
+			continue;
+		for(j=0; p[0] != 0xE703; j++,p+=2) { /* 0xE703 = byteswapped 999 */
+			x_diff = abs(swap16(p[0]) - x);
+			y_diff = abs(swap16(p[1]) - 12 - y);
+
+			if (x_diff < y_diff) {
+				x_diff >>= 2;
+				y_diff <<= 2;
+			}
+			x_diff += y_diff >> 2;
+
+			if (x_diff < best_dist || x_diff==best_dist && prev_i==i) {
+				best_dist = x_diff;
+				best_i = 21 - i;
+				best_j = j;
+			}
+		}
+	}
+	
+	_variableArray[var_1] = best_i;
+	_variableArray[var_2] = best_j;
+}
+
+
+/* ok */
+void SimonState::fcs_unk1(uint fcs_index) {
+	FillOrCopyStruct *fcs;
+	uint16 fcsunk1;
+	uint16 i;
+
+	fcs = _fcs_ptr_array_3[fcs_index&7];
+	fcsunk1 = _fcs_unk_1;
+	
+	if (fcs==NULL || fcs->fcs_data==NULL)
+		return;
+
+	fcs_unk_2(fcs_index);
+	fcs_putchar(12);
+	fcs_unk_2(fcsunk1);
+	
+	for(i = 0;fcs->fcs_data->e[i].item != NULL;i++) {
+		delete_hitarea_by_index(fcs->fcs_data->e[i].hit_area);
+	}
+
+	if (fcs->fcs_data->unk3 != -1) {
+		delete_hitarea_by_index(fcs->fcs_data->unk3);
+	}
+
+	if (fcs->fcs_data->unk4 != -1) {
+		delete_hitarea_by_index(fcs->fcs_data->unk4);
+		fcs_unk_5(fcs, fcs_index);
+	}
+
+	free(fcs->fcs_data);
+	fcs->fcs_data = NULL;
+
+	_fcs_data_1[fcs_index] = 0;
+	_fcs_data_2[fcs_index] = 0;
+}
+
+/* ok */
+void SimonState::fcs_unk_5(FillOrCopyStruct *fcs, uint fcs_index) {
+	if (!(_game & GAME_SIMON2)) {
+		o_unk_99_simon1(0x80);
+	}
+}
+
+void SimonState::delete_hitarea_by_index(uint index) {
+	CHECK_BOUNDS(index, _hit_areas);
+	_hit_areas[index].flags = 0;
+}
+
+/* ok */
+void SimonState::fcs_putchar(uint a) {
+	if (_fcs_ptr_1 != _fcs_ptr_array_3[0])
+		video_putchar(_fcs_ptr_1, a);
+}
+
+/* ok */
+void SimonState::video_fill_or_copy_from_3_to_2(FillOrCopyStruct *fcs) {
+	if (fcs->flags & 0x10)
+		copy_img_from_3_to_2(fcs);
+	else
+		video_erase(fcs);
+
+	fcs->unk1 = 0;
+	fcs->unk2 = 0;
+	fcs->unk3 = 0;
+	fcs->unk6 = 0;
+}
+
+/* ok */
+void SimonState::copy_img_from_3_to_2(FillOrCopyStruct *fcs) {
+	_lock_word |= 0x8000;
+
+	if (!(_game & GAME_SIMON2)) {
+		dx_copy_rgn_from_3_to_2(
+			fcs->y + fcs->height*8 + ((fcs==_fcs_ptr_array_3[2])?1:0), 
+			(fcs->x+fcs->width)*8,
+			fcs->y,
+			fcs->x*8);
+	} else {
+		if (_vga_var6 && _fcs_ptr_array_3[2]==fcs) {
+			fcs = _fcs_ptr_array_3[0x18/4];
+			_vga_var6 = 0;
+		}
+
+		dx_copy_rgn_from_3_to_2(
+			fcs->y + fcs->height*8,
+			(fcs->x+fcs->width)*8,
+			fcs->y,
+			fcs->x*8);
+	}
+
+	_lock_word &= ~0x8000;
+}
+
+void SimonState::video_erase(FillOrCopyStruct *fcs) {
+	byte *dst;
+	uint h;
+	
+	_lock_word |= 0x8000;
+
+	dst = dx_lock_2();
+	dst += _dx_surface_pitch * fcs->y + fcs->x*8;
+
+	h = fcs->height * 8;
+	do {
+		memset(dst, fcs->fill_color, fcs->width*8);
+		dst += _dx_surface_pitch;
+	} while (--h);
+
+	dx_unlock_2();
+	_lock_word &= ~0x8000;
+}
+
+VgaSprite *SimonState::find_cur_sprite() {
+	if (_game & GAME_SIMON2) {
+		VgaSprite *vsp = _vga_sprites;
+		while (vsp->id) {
+			if (vsp->id == _vga_cur_sprite_id
+				&& vsp->unk7 == _vga_cur_file_id)
+				break;
+			vsp++;
+		}
+		return vsp;
+	} else {
+		VgaSprite *vsp = _vga_sprites;
+		while (vsp->id) {
+			if (vsp->id == _vga_cur_sprite_id)
+				break;
+			vsp++;
+		}
+		return vsp;
+	}
+}
+
+bool SimonState::has_vgastruct_with_id(uint16 id, uint16 file) {
+	if (_game & GAME_SIMON2) {
+		VgaSprite *vsp = _vga_sprites;
+		while (vsp->id) {
+			if (vsp->id == id	&& vsp->unk7==file)
+				return true;
+			vsp++;
+		}
+		return false;
+	} else {
+		VgaSprite *vsp = _vga_sprites;
+		while (vsp->id) {
+			if (vsp->id == id)
+				return true;
+			vsp++;
+		}
+		return false;
+	}
+}
+
+void SimonState::processSpecialKeys() {
+}
+
+void SimonState::draw_mouse_pointer() {
+}
+
+
+void decompress_icon(byte *dst, byte *src, uint w, uint h_org, byte base, uint pitch) {
+	int8 reps;
+	byte color_1, color_2;
+	byte *dst_org = dst;
+	uint h = h_org;
+
+	for(;;) {
+		reps = *src++;
+		if (reps < 0) {
+			reps--;
+			color_1 = *src >> 4;
+			if (color_1 != 0) color_1 |= base;
+			color_2 = *src++ & 0xF;
+			if (color_2 != 0) color_2 |= base;
+			
+			do {	
+				if (color_1 != 0) *dst = color_1;
+				dst += pitch;
+				if (color_2 != 0) *dst = color_2;
+				dst += pitch;
+
+				/* reached bottom? */
+				if (--h == 0) {
+					/* reached right edge? */				
+					if (--w == 0)
+						return;
+					dst = ++dst_org;
+					h = h_org;
+				}
+			} while (++reps != 0);
+		} else {
+			do {	
+				color_1 = *src >> 4;
+				if (color_1 != 0) *dst = color_1 | base;
+				dst += pitch;
+
+				color_2 = *src++ & 0xF;
+				if (color_2 != 0) *dst = color_2 | base;
+				dst += pitch;
+
+				/* reached bottom? */
+				if (--h == 0) {
+					/* reached right edge? */				
+					if (--w == 0)
+						return;
+					dst = ++dst_org;
+					h = h_org;
+				}
+			} while (--reps >= 0);
+		}
+	}
+}
+
+
+void SimonState::draw_icon_c(FillOrCopyStruct *fcs, uint icon, uint x, uint y) {
+	byte *dst;
+	byte *src;
+
+	if (!(_game & GAME_SIMON2)) {
+		_lock_word |= 0x8000;
+
+		dst = dx_lock_2();
+		dst += (x + fcs->x) * 8;
+		dst += (y*25 + fcs->y) * _dx_surface_pitch;
+
+		src = _icon_file_ptr;
+		src += ((uint16*)src)[icon];
+
+		decompress_icon(dst, src, 24, 12, 0xE0,_dx_surface_pitch);
+
+		dx_unlock_2();
+		_lock_word &= ~0x8000;
+	} else {
+		_lock_word |= 0x8000;	
+		dst = dx_lock_2();
+
+		dst += 110;
+		dst += x;
+		dst += (y+fcs->y)*_dx_surface_pitch;
+
+		src = _icon_file_ptr;
+		src += ((uint16*)src)[icon*2+0];
+		decompress_icon(dst, src, 20, 10, 0xE0,_dx_surface_pitch);
+
+		src = _icon_file_ptr;
+		src += ((uint16*)src)[icon*2+1];
+		decompress_icon(dst, src, 20, 10, 0xD0,_dx_surface_pitch);
+
+		dx_unlock_2();
+		_lock_word &= ~0x8000;
+	}
+}
+
+void SimonState::video_toggle_colors(HitArea *ha, byte a, byte b, byte c, byte d) {
+	byte *src, color;
+	uint w,h,i;
+
+	_lock_word |= 0x8000;
+	src = dx_lock_2() + ha->y*_dx_surface_pitch + ha->x;
+
+	w = ha->width;
+	h = ha->height;
+
+	if(!(h>0 && w>0 && ha->x + w<=320 && ha->y+h<=200)) {
+		warning("Invalid coordinates in video_toggle_colors (%d,%d,%d,%d)", ha->x, ha->y,ha->width, ha->height);
+		return;
+	}
+
+	do {
+		for(i=0; i!=w; ++i) {
+			color = src[i];
+			if (a>=color && b<color) {
+				if (c >= color)
+					color += d;
+				else
+					color -= d;
+				src[i] = color;
+			}
+		}
+		src += _dx_surface_pitch;
+	} while(--h);
+
+
+	dx_unlock_2();
+	_lock_word &= ~0x8000;
+}
+
+bool SimonState::vc_59_helper() {
+#ifdef USE_TEXT_HACK
+	return true;
+#else
+	if (_voice_file==NULL)
+		return false;
+	return _voice_size == 0;
+#endif
+}
+
+void SimonState::video_copy_if_flag_0x8_c(FillOrCopyStruct *fcs) {
+	if (fcs->flags&8)
+		copy_img_from_3_to_2(fcs);
+	fcs->mode = 0;
+}
+
+void SimonState::showMessageFormat(const char *s, ...) {
+	char buf[1024],*str;
+	va_list va;
+
+	va_start(va, s);
+	vsprintf(buf, s, va);
+	va_end(va);
+
+	if (!_fcs_data_1[_fcs_unk_1]) {
+		showmessage_helper_2();
+		if (!_showmessage_flag) {
+			_fcs_ptr_array_3[0] = _fcs_ptr_1;
+			showmessage_helper_3(_fcs_ptr_1->unk6, _fcs_ptr_1->unk7);
+		}
+		_showmessage_flag = true;
+		_fcs_data_1[_fcs_unk_1] = 1;
+	}
+
+	for(str=buf;*str;str++)
+		showmessage_print_char(*str);
+}
+
+void SimonState::showmessage_helper_2() {
+	if (_fcs_ptr_1)
+		return;
+
+	_fcs_ptr_1 = fcs_alloc(8, 0x90, 0x18, 6, 1, 0, 0xF);
+}
+
+void SimonState::readSfxFile(const char *filename) {
+	if (!(_game & GAME_SIMON2)) {
+		FILE *in;
+		uint32 size;
+
+		in = fopen(filename, "rb");
+
+		if(in==NULL) {
+			warning("readSfxFile: Cannot load sfx file %s", filename);
+			return;
+		}
+
+		fseek(in, 0, SEEK_END);
+		size = ftell(in);
+
+		rewind(in);
+		
+		/* if a sound is playing, stop it */
+		_sound_size = 0;
+
+
+		if (_sfx_heap) free(_sfx_heap);
+
+		_sfx_heap = (byte*)malloc(size);
+
+		if (_sfx_heap == NULL)
+			error("readSfxFile: Not enough SFX memory");
+
+		fread(_sfx_heap, size, 1, in);
+
+		fclose(in);
+	} else {
+		int res;
+		uint32 offs;
+		int size;
+
+		vc_29_stop_all_sounds();
+
+		/* if a sound is playing, stop it */
+		_sound_size = 0;
+
+
+		if (_sfx_heap) free(_sfx_heap);
+
+		res = atoi(filename + 6) + gss->SOUND_INDEX_BASE - 1;
+		offs = _game_offsets_ptr[res];
+		size = _game_offsets_ptr[res+1] - offs;
+
+		if (size == 0)
+			return;
+
+		_sfx_heap = (byte*)malloc(size);
+
+		resfile_read(_sfx_heap, offs, size);
+	}
+}
+
+void SimonState::video_putchar(FillOrCopyStruct *fcs, byte c) {
+	if (c == 0xC) {
+		video_fill_or_copy_from_3_to_2(fcs);
+	} else if (c == 0xD || c==0xA) {
+		video_putchar_helper(fcs);
+	} else if (c==8 || c==1) {
+		int8 val = (c==8) ? 6 : 4;
+		if (fcs->unk6!=0) {
+			fcs->unk6--;
+			fcs->unk3 -= val;
+			if ((int8)fcs->unk3 < val) {
+				fcs->unk3 += 8;
+				fcs->unk1--;
+			}
+		}
+	} else if (c>=0x20) {
+		if (fcs->unk6 == fcs->unk7) {
+			video_putchar_helper(fcs);
+		} else if (fcs->unk2 == fcs->height) {
+			video_putchar_helper(fcs);
+			fcs->unk2--;
+		}
+
+		video_putchar_helper_2(fcs, fcs->unk1 + fcs->x, fcs->unk2 * 8 + fcs->y, c);
+
+		fcs->unk6++;
+		fcs->unk3 += 4;
+		if (c != 'i' && c != 'l')
+			fcs->unk3 += 2;
+
+		if (fcs->unk3 >= 8) {
+			fcs->unk3 -= 8;
+			fcs->unk1++;
+		}
+	}
+}
+
+void SimonState::video_putchar_helper(FillOrCopyStruct *fcs) {
+	fcs->unk3 = 0;
+	fcs->unk6 = 0;
+	fcs->unk1 = 0;
+
+	if (fcs->unk2 != fcs->height)
+		fcs->unk2++;
+}
+
+static const byte video_font[] = {
+  0,  0,  0,  0,  0,  0,  0,  0,
+ 32,112,112, 32, 32,  0, 32,  0,
+ 48, 48, 96,  0,  0,  0,  0,  0,
+  0,144,  0, 96,144,144,104,  0,
+  0,144,  0, 96,144,144, 96,  0,
+  0,144,  0,144,144,144, 96,  0,
+  0, 16, 40, 16, 42, 68, 58,  0,
+ 48, 48, 96,  0,  0,  0,  0,  0,
+  0,  4,  8,  8,  8,  8,  4,  0,
+  0, 32, 16, 16, 16, 16, 32,  0,
+  0,  0, 20,  8, 62,  8, 20,  0,
+  0,112,136,240,136,136,240,  0,
+  0,  0,  0,  0,  0, 48, 48, 96,
+  0,  0,  0,240,  0,  0,  0,  0,
+  0,  0,  0,  0,  0, 48, 48,  0,
+ 16, 32,  0,120,112, 64, 56,  0,
+112,136,152,168,200,136,112,  0,
+ 32, 96, 32, 32, 32, 32,112,  0,
+112,136,  8, 48, 64,136,248,  0,
+112,136,  8, 48,  8,136,112,  0,
+ 16, 48, 80,144,248, 16, 56,  0,
+248,128,240,  8,  8,136,112,  0,
+ 48, 64,128,240,136,136,112,  0,
+248,136,  8, 16, 32, 32, 32,  0,
+112,136,136,112,136,136,112,  0,
+112,136,136,120,  8, 16, 96,  0,
+  0,  0, 48, 48,  0, 48, 48,  0,
+ 32, 16,  0,112,  8,248,120,  0,
+ 32, 80,  0,144,144,144,104,  0,
+ 32, 16,  0,112,248,128,112,  0,
+ 32, 80,  0,112,248,128,112,  0,
+112,136,  8, 16, 32,  0, 32,  0,
+ 32, 80,  0,192, 64, 64,224,  0,
+112,136,136,248,136,136,136,  0,
+240, 72, 72,112, 72, 72,240,  0,
+ 48, 72,128,128,128, 72, 48,  0,
+224, 80, 72, 72, 72, 80,224,  0,
+248, 72, 64,112, 64, 72,248,  0,
+248, 72, 64,112, 64, 64,224,  0,
+ 48, 72,128,152,136, 72, 56,  0,
+136,136,136,248,136,136,136,  0,
+248, 32, 32, 32, 32, 32,248,  0,
+ 24,  8,  8,  8,136,136,112,  0,
+200, 72, 80, 96, 80, 72,200,  0,
+224, 64, 64, 64, 64, 72,248,  0,
+136,216,168,168,136,136,136,  0,
+136,200,168,152,136,136,136,  0,
+112,136,136,136,136,136,112,  0,
+240, 72, 72,112, 64, 64,224,  0,
+112,136,136,136,136,168,112,  8,
+240, 72, 72,112, 72, 72,200,  0,
+112,136,128,112,  8,136,112,  0,
+248,168, 32, 32, 32, 32,112,  0,
+136,136,136,136,136,136,120,  0,
+136,136,136, 80, 80, 32, 32,  0,
+136,136,136,136,168,216,136,  0,
+136,136, 80, 32, 80,136,136,  0,
+136,136,136,112, 32, 32,112,  0,
+248,136, 16, 32, 64,136,248,  0,
+  0, 14,  8,  8,  8,  8, 14,  0,
+  0,128, 64, 32, 16,  8,  4,  0,
+  0,112, 16, 16, 16, 16,112,  0,
+  0, 48, 72, 64, 72, 48, 16, 48,
+  0, 80,  0, 96, 32, 40, 48,  0,
+ 32, 16,  0,152,144,144,232,  0,
+  0,  0,112,  8,120,136,120,  0,
+192, 64, 80,104, 72, 72,112,  0,
+  0,  0,112,136,128,136,112,  0,
+ 24, 16, 80,176,144,144,112,  0,
+  0,  0,112,136,248,128,112,  0,
+ 48, 72, 64,224, 64, 64,224,  0,
+  0,  0,104,144,144,112,136,112,
+192, 64, 80,104, 72, 72,200,  0,
+ 64,  0,192, 64, 64, 64,224,  0,
+  8,  0,  8,  8,  8,  8,136,112,
+192, 64, 72, 80, 96, 80,200,  0,
+192, 64, 64, 64, 64, 64,224,  0,
+  0,  0,144,216,168,136,136,  0,
+  0,  0,240,136,136,136,136,  0,
+  0,  0,112,136,136,136,112,  0,
+  0,  0,176, 72, 72,112, 64,224,
+  0,  0,104,144,144,112, 16, 56,
+  0,  0,176, 72, 72, 64,224,  0,
+  0,  0,120,128,112,  8,240,  0,
+ 64, 64,240, 64, 64, 72, 48,  0,
+  0,  0,144,144,144,144,104,  0,
+  0,  0,136,136,136, 80, 32,  0,
+  0,  0,136,136,168,216,144,  0,
+  0,  0,136, 80, 32, 80,136,  0,
+  0,  0,136,136,136,112, 32,192,
+  0,  0,248,144, 32, 72,248,  0,
+ 32, 80,  0, 96,144,144, 96,  0,
+  0, 14,  8, 48,  8,  8, 14,  0,
+  0,  8,  8,  8,  8,  8,  8,  0,
+  0,112, 16, 12, 16, 16,112,  0,
+  0,  0,  0,  0,  0,  0,248,  0,
+252,252,252,252,252,252,252,252,
+240,240,240,240,240,240,240,240,
+};
+
+void SimonState::video_putchar_helper_2(FillOrCopyStruct *fcs, uint x, uint y, byte chr) {
+	const byte *src;
+	byte color, *dst;
+	uint h,i;
+
+	_lock_word |= 0x8000;
+
+	dst = dx_lock_2();
+	dst += y * _dx_surface_pitch + x*8 + fcs->unk3;
+
+	src = video_font + (chr-0x20) * 8;
+
+	color = fcs->text_color;
+
+	h = 8;
+	do {
+		int8 b = *src++;
+		i = 0;
+		do {
+			if (b<0) dst[i] = color;
+			b<<=1;
+		} while (++i!=6);
+		dst += _dx_surface_pitch;
+	} while (--h);
+
+	dx_unlock_2();
+	_lock_word &= ~0x8000;
+}
+
+void SimonState::start_vga_code(uint b, uint vga_res, uint vga_struct_id,
+																		uint c, uint d, uint f) {
+	VgaSprite *vsp;
+	VgaPointersEntry *vpe;
+	byte *p,*pp;
+	uint count;
+	
+	_lock_word |= 0x40;
+
+	if (has_vgastruct_with_id(vga_struct_id,vga_res))
+		return;
+
+	vsp = _vga_sprites;
+	while(vsp->id!=0) vsp++;
+
+	vsp->unk6 = b;
+	vsp->unk5 = 0;
+	vsp->unk4 = 0;
+
+	vsp->y = d;
+	vsp->x = c;
+	vsp->image = 0;
+	vsp->base_color = f;
+	vsp->id = vga_struct_id;
+	vsp->unk7 = vga_res;
+
+	for(;;) {
+		vpe = &_vga_buffer_pointers[vga_res];
+		_vga_cur_file_2 = vga_res;
+		_cur_vga_file_1 = vpe->vgaFile1;
+		if (vpe->vgaFile1 != NULL)
+			break;
+		ensureVgaResLoaded(vga_res);
+	}
+	
+	pp = _cur_vga_file_1;
+	p = pp + swap16(((VgaFile1Header*)pp)->hdr2_start);
+
+	count = swap16(((VgaFile1Header2*)p)->id_count);
+	p = pp + swap16(((VgaFile1Header2*)p)->id_table);
+	
+	for(;;) {
+		if (swap16(((VgaFile1Struct0x6*)p)->id) == vga_struct_id) {
+			
+			dump_vga_script(pp + swap16(((VgaFile1Struct0x6*)p)->script_offs), vga_res, vga_struct_id);
+
+			add_vga_timer(gss->VGA_DELAY_BASE, 
+				pp + swap16(((VgaFile1Struct0x6*)p)->script_offs),
+				vga_struct_id, vga_res);
+			break;
+		}
+		p += sizeof(VgaFile1Struct0x6);
+		if (!--count) {
+			vsp->id = 0;
+			break;
+		}
+	}
+
+	_lock_word &= ~0x40;
+}
+
+void SimonState::dump_vga_script_always(byte *ptr, uint res, uint sprite_id) {
+	fprintf(_dump_file,"; address=%x, vgafile=%d  vgasprite=%d\n", 
+		ptr - _vga_buffer_pointers[res].vgaFile1, res, sprite_id);
+	dump_video_script(ptr, false);
+	fprintf(_dump_file,"; end\n");
+}
+
+void SimonState::dump_vga_script(byte *ptr, uint res, uint sprite_id) {
+#ifdef DUMP_START_VGASCRIPT
+	dump_Vga_script_always(ptr,res,sprite_id);
+#endif
+}
+
+void SimonState::talk_with_speech(uint speech_id, uint num_1) {
+	if (!(_game & GAME_SIMON2)) {
+		if (speech_id == 9999) {
+			if (!(_bit_array[0] & 0x4000) && !(_bit_array[1]&0x1000)) {
+				_bit_array[0]|=0x4000;
+				_variableArray[0xc8/2] = 0xF;
+				start_vga_code(4, 1, 0x82, 0, 0, 0);
+				o_wait_for_vga(0x82);
+			}
+			_skip_vga_wait = true;
+			return;
+		}
+
+		if (num_1 < 100) {
+			o_unk_99_simon1(num_1 + 201);
+		}
+
+		playVoice(speech_id);
+
+		if (num_1 < 100) {
+			start_vga_code(4, 2, num_1+201,0,0,0);
+		}
+	} else {
+		if (speech_id  == 0xFFFF) {
+			if (_vk_t_toggle)
+				return;
+			if (!(_bit_array[0] & 0x4000 || _bit_array[1] & 0x1000)) {			
+				_bit_array[0] |= 0x4000;
+		
+				start_vga_code(4, 1, 0x1e, 0, 0, 0);
+				o_wait_for_vga(0x82);
+			}
+			_skip_vga_wait = true;
+		} else {
+			if (_vk_t_toggle && _scriptvar_2) {
+				start_vga_code(4, 2, 5, 0, 0, 0);
+				o_wait_for_vga(0xcd);
+				o_unk_99_simon2(2,5);
+			}
+			o_unk_99_simon2(2,num_1+2);
+			playVoice(speech_id);
+
+			start_vga_code(4, 2, num_1+2, 0, 0, 0);
+		}
+	}
+}
+
+void SimonState::talk_with_text(uint num_1, uint num_2, const char *string_ptr, uint threeval_a, int threeval_b, uint width) {
+	char print_str_buf[0x140];
+	char *char_buf;
+	const char *string_ptr_2, *string_ptr_3;
+	int j;
+	uint letters_per_row, len_div_3, num_of_rows;
+	uint m, n;
+	uint height;
+
+	char_buf = print_str_buf;
+	string_ptr_3 = string_ptr_2 = string_ptr;
+
+	height = 10;
+	j = 0;
+
+	letters_per_row = width / 6;
+
+	len_div_3 = (strlen(string_ptr) + 3) / 3;
+
+	if (_variableArray[0x11a/2] == 0)
+		_variableArray[0x11a/2] = 9;
+
+	_variableArray[0xAA/2] = _variableArray[0x11A/2] * len_div_3;
+	num_of_rows = strlen(string_ptr) / letters_per_row;
+
+	while(num_of_rows==1 && j!=-1) {
+		m = strlen(string_ptr) >> 1;
+		m -= j;
+		string_ptr_2 += m;
+
+		while (*string_ptr_2++ != ' ' && m <= letters_per_row) m++;
+
+		if (m <= letters_per_row && strlen(string_ptr_2) < letters_per_row) {
+			/* if_1 */
+			n = (letters_per_row - m + 1) >> 1;
+
+			while (n != 0) {
+				*char_buf++ = ' ';
+				n--;
+			}
+			strncpy(char_buf, string_ptr, m);
+			char_buf += m;
+			*char_buf++= 10;
+
+			height += 10;
+			threeval_b -= 10;
+
+			if (threeval_b < 2)
+				threeval_b = 2;
+			j = -1;
+		} else {
+			/* else_1 */
+			j -= 4;
+			if (j == -12) {
+				j = 0;
+				num_of_rows = 2;
+			}
+			string_ptr_2 = string_ptr_3;
+		}
+	}
+
+	if (j != -1 && width*30 > 8000)
+		num_of_rows = 4;
+
+	while (num_of_rows==2 && j!=-1) {
+		m = strlen(string_ptr) / 3;
+		m += j;
+		string_ptr_2 += m;
+
+		while (*string_ptr_2++ != ' ' && m <= letters_per_row) m++;
+
+		if (m <= letters_per_row) {
+			/* if_4 */
+			n = (letters_per_row - m + 1) >> 1;
+			while (n) {
+				*char_buf++ = ' ';
+				n--;
+			}
+			strncpy(char_buf, string_ptr, m);
+			char_buf += m;
+			*char_buf++= 10;
+
+			string_ptr = string_ptr_2;
+			string_ptr_2 += m;
+
+			while (*string_ptr_2-- != ' ' && m > 0) m--;
+			/* while_6_end */
+
+			string_ptr_2 += 2;
+
+			if (strlen(string_ptr_2) <= m && m>0) {
+				/* if_6 */
+				n = (letters_per_row - m + 1) >> 1;
+				while (n) {
+					*char_buf++ = ' ';
+					n--;
+				}
+				strncpy(char_buf, string_ptr, m);
+				char_buf += m;
+				*char_buf++ = 10;
+				height += 20;
+				threeval_b -= 20;
+
+				if (threeval_b < 2) threeval_b = 2;
+				j = -1;
+			} else {
+				/* else_6 */
+				j += 2;
+				string_ptr_2 = string_ptr_3;
+				string_ptr = string_ptr_3;
+				char_buf = print_str_buf;
+			}
+		} else {
+			num_of_rows = 3;
+			string_ptr_2 = string_ptr_3;
+			string_ptr = string_ptr_3;
+			char_buf = print_str_buf;
+			j = 0;
+		}
+	}
+
+	if (j!=-1 && width*40 > 8000)
+		num_of_rows = 4;
+
+	/* while_8 */
+	while (num_of_rows==3 && j!=-1) {
+		m = strlen(string_ptr) >> 2;
+		m += j;
+		string_ptr_2 += m;
+		while (*string_ptr_2++ != ' ' && m <= letters_per_row) m++;
+
+		if (m <= letters_per_row) {
+			/* if_10 */
+			n = (letters_per_row - m + 1) >> 1;
+			while(n) {
+				*char_buf++ = ' ';
+				n--;
+			}
+			strncpy(char_buf, string_ptr, m);
+			char_buf += m;
+			*char_buf++ = ' ';
+			string_ptr = string_ptr_2;
+			string_ptr_2 += m;
+			while (*string_ptr_2-- != ' ' && m>0) m--;
+			string_ptr_2 += 2;
+
+			if (strlen(string_ptr_2) < m*2 && m>0) {
+				/* if_11 */
+				n = (letters_per_row - m + 1) >> 1;
+				while (n) {
+					*char_buf++ = ' ';
+					n--;
+				}
+				strncpy(char_buf, string_ptr, m);
+				char_buf += m;
+				*char_buf++ = 10;
+				string_ptr = string_ptr_2;
+				string_ptr_2 += m;
+
+				while(*string_ptr_2-- != ' ' && m>0) m--;
+				string_ptr_2 += 2;
+
+				if (strlen(string_ptr_2) <= m && m>0) {
+					/* if_15 */
+					n = (letters_per_row - m + 1) >> 1;
+					while (n) {
+						*char_buf++ = ' ';
+						n--;
+					}
+					strncpy(char_buf, string_ptr, m);
+					char_buf += m;
+					*char_buf++ = ' ';
+					height += 30;
+					threeval_b -= 30;
+					if (threeval_b < 2) threeval_b = 2;
+					j = -1;
+				} else {
+					/* else_15 */
+					j += 2;
+					string_ptr_2 = string_ptr_3;
+					string_ptr = string_ptr_3;
+					char_buf = print_str_buf;
+				}
+			} else {
+				/* else_11 */
+				j += 2;
+				string_ptr_2 = string_ptr_3;
+				string_ptr = string_ptr_3;
+				char_buf = print_str_buf;
+			}
+		} else {
+			/* else_10 */
+			num_of_rows = 4;
+			string_ptr = string_ptr_3;
+			string_ptr_2 = string_ptr_3;
+			char_buf = print_str_buf;
+		}
+	}
+
+	/* while_8_end */
+	if (num_of_rows == 4) {
+		while (strlen(string_ptr) > letters_per_row) {
+			m = letters_per_row;
+			string_ptr_2 += m;
+			while (*string_ptr_2-- != ' ') m--;
+			string_ptr_2 += 2;
+			n = (letters_per_row - m + 1) >> 1;
+			while (n) {
+				*char_buf++ = ' ';
+				n--;
+			}
+			strncpy(char_buf, string_ptr, m);
+			char_buf += m;
+			*char_buf++ = 10;
+			height += 10;
+			threeval_b -= 10;
+			if (threeval_b < 2) threeval_b = 2;
+			string_ptr = string_ptr_2;
+		}
+	}
+
+	n = (letters_per_row - strlen(string_ptr_2) + 1) >> 1;
+	while(n) {
+		*char_buf++ = ' ';
+		n--;
+	}
+
+	strcpy(char_buf, string_ptr_2);
+	if (!(_game & GAME_SIMON2)) {
+		o_unk_99_simon1(199 + num_1);
+	} else {
+		o_unk_99_simon2(2, num_1);
+	}
+	num_2 = num_2 * 3 + 192;
+
+	render_string(num_1, num_2, width, height, print_str_buf);
+	num_of_rows = 4;
+	if (!(_bit_array[8] & 0x20))
+		num_of_rows = 3;
+
+	if (!(_game & GAME_SIMON2)) {
+		start_vga_code(num_of_rows, 2, 199 + num_1, threeval_a >> 3, threeval_b, 12);
+	} else {
+		start_vga_code(num_of_rows, 2, num_1, threeval_a >> 3, threeval_b, 12);
+	}
+}
+
+void SimonState::render_string(uint num_1, uint color, uint width, uint height, const char *txt) {
+	VgaPointersEntry *vpe = &_vga_buffer_pointers[2];
+	byte *src,*dst,*p,*dst_org,chr;
+	uint count;
+
+	if (num_1 >= 100) {
+		num_1 -= 100;
+		vpe++;
+	}
+
+	src = dst = vpe->vgaFile2;
+
+	count = 4000;
+	if (num_1 == 1)
+		count *= 2;
+
+	p = dst + num_1 * 8;
+
+	*(uint16*)(p+4) = swap16(height);
+	*(uint16*)(p+6) = swap16(width);
+	dst += swap32(*(uint32*)p);
+
+	memset(dst, 0, count);
+
+	dst_org = dst;
+	while (chr=*txt++) {
+		if (chr == 10) {
+			dst_org += width * 10;
+			dst = dst_org;
+		} else if ((chr -= ' ') == 0) {
+			dst += 6;
+		} else {
+			byte *img_hdr = src + 48 + chr * 4;
+			uint img_height = img_hdr[2];
+			uint img_width = img_hdr[3],i;
+			byte *img = src + *(uint16*)img_hdr;
+			byte *cur_dst = dst;
+
+			assert(img_width > 0 && img_width < 50 && img_height>0 && img_height<50);
+
+			do {
+				for(i=0; i!=img_width; i++) {
+					chr = *img++;
+					if (chr) {
+						if (chr == 0xF) chr = 207; else chr += color;
+						cur_dst[i] = chr;
+					}
+				}
+				cur_dst += width;
+			} while(--img_height);
+
+			dst += img_width - 1;
+		}
+	}
+
+}
+
+void SimonState::showmessage_print_char(byte chr) {
+	if (chr == 12) {
+		_num_letters_to_print = 0;
+		_print_char_unk_1 = 0;
+		print_char_helper_1(&chr, 1);
+		print_char_helper_5(_fcs_ptr_1);
+	} else if (chr==0 || chr==' ' || chr==10) {
+		if (_print_char_unk_2 - _print_char_unk_1 >= _num_letters_to_print) {
+			_print_char_unk_1 += _num_letters_to_print;
+			print_char_helper_1(_letters_to_print_buf, _num_letters_to_print);
+			
+			if (_print_char_unk_1 == _print_char_unk_2) {
+				_print_char_unk_1 = 0;
+			} else {
+				if (chr)
+					print_char_helper_1(&chr, 1);
+				if (chr==10)
+					_print_char_unk_1 = 0;
+				else if (chr!=0)
+					_print_char_unk_1++;
+			}
+		} else {
+			const byte newline_character = 10;
+			_print_char_unk_1 = _num_letters_to_print;
+			print_char_helper_1(&newline_character, 1);
+			print_char_helper_1(_letters_to_print_buf, _num_letters_to_print);
+			if (chr == ' ') {
+				print_char_helper_1(&chr, 1);
+				_print_char_unk_1++;
+			} else {
+				print_char_helper_1(&chr,1);
+				_print_char_unk_1 = 0;
+			}
+		}
+		_num_letters_to_print = 0;
+	} else {
+		_letters_to_print_buf[_num_letters_to_print++] = chr;
+	}
+}
+
+void SimonState::print_char_helper_1(const byte *src, uint len) {
+	uint ind;
+
+	if (_fcs_ptr_1 == NULL)
+		return;
+
+	while (len-- != 0) {
+		if (*src != 12 && _fcs_ptr_1->fcs_data!=NULL && 
+			_fcs_data_1[ind=get_fcs_ptr_3_index(_fcs_ptr_1)]!=2) {
+
+			_fcs_data_1[ind] = 2;
+			_fcs_data_2[ind] = 1;
+		}
+
+		fcs_putchar(*src++);
+	}
+}
+
+void SimonState::print_char_helper_5(FillOrCopyStruct *fcs) {
+	uint index = get_fcs_ptr_3_index(fcs);
+	print_char_helper_6(index);
+	_fcs_data_1[index] = 0;
+}
+
+void SimonState::print_char_helper_6(uint i) {
+	FillOrCopyStruct *fcs;
+
+	if (_fcs_data_2[i]) {
+		lock();
+		fcs = _fcs_ptr_array_3[i];
+		fcs_unk_proc_1(i, fcs->fcs_data->item_ptr, fcs->fcs_data->unk1, fcs->fcs_data->unk2);
+		_fcs_data_2[i] = 0;
+		unlock();
+	}
+}
+
+void SimonState::read_vga_from_datfile_1(uint vga_id) {
+	if (_game == GAME_SIMON1DOS) {
+		FILE *in;
+		char buf[50];
+		uint32 size;
+
+		sprintf(buf, "%.3d%d.VGA", vga_id>>1, (vga_id&1)+1);
+
+		in = fopen(buf, "rb");
+		if (in==NULL)
+			error("read_vga_from_datfile_1: cannot open %s", buf);
+
+		fseek(in, 0, SEEK_END);
+		size = ftell(in);
+		rewind(in);
+
+		if (fread(_vga_buffer_pointers[11].vgaFile2, size, 1, in) != 1)
+			error("read_vga_from_datfile_1: read failed");
+
+		fclose(in);
+	} else {
+		uint32 offs_a = _game_offsets_ptr[vga_id];
+		uint32 size = _game_offsets_ptr[vga_id + 1] - offs_a;
+
+		resfile_read(_vga_buffer_pointers[11].vgaFile2, offs_a, size);
+	}
+}
+
+byte *SimonState::read_vga_from_datfile_2(uint id) {
+	if (_game == GAME_SIMON1DOS) {
+		FILE *in;
+		char buf[50];
+		uint32 size;
+		byte *dst;
+
+		sprintf(buf, "%.3d%d.VGA", id>>1, (id&1)+1);
+
+		in = fopen(buf, "rb");
+		if (in==NULL)
+			error("read_vga_from_datfile_2: cannot open %s", buf);
+
+		fseek(in, 0, SEEK_END);
+		size = ftell(in);
+		rewind(in);
+
+		dst = setup_vga_destination(size);
+
+		if (fread(dst, size, 1, in) != 1)
+			error("read_vga_from_datfile_2: read failed");
+
+		fclose(in);
+
+		return dst;
+	} else {
+		uint32 offs_a = _game_offsets_ptr[id];
+		uint32 size = _game_offsets_ptr[id + 1] - offs_a;
+		byte *dst;
+
+		dst = setup_vga_destination(size);
+		resfile_read(dst, offs_a, size);
+
+		return dst;
+	}
+}
+
+void SimonState::resfile_read(void *dst, uint32 offs, uint32 size) {
+	if (fseek(_game_file, offs, SEEK_SET) != 0)
+		error("resfile_read(%d,%d) seek failed", offs, size);
+	if (fread(dst, size, 1, _game_file)!=1)
+		error("resfile_read(%d,%d) read failed", offs, size);
+}
+
+
+void SimonState::openGameFile() {
+	if (_game != GAME_SIMON1DOS) {
+		_game_file = fopen(gss->gme_filename, "rb");
+
+		if (_game_file==NULL)
+			error("cannot open game file '%s'", gss->gme_filename);
+
+		_game_offsets_ptr = (uint32*)malloc(gss->NUM_GAME_OFFSETS*sizeof(uint32));
+		if (_game_offsets_ptr == NULL)
+			error("out of memory, game offsets");
+
+		resfile_read(_game_offsets_ptr, 0, gss->NUM_GAME_OFFSETS*sizeof(uint32));
+	}
+
+	loadIconFile();
+	
+	_system->init_size(320,200,OSystem::SOUND_8BIT);
+	
+	startUp(1);
+}
+
+void SimonState::startUp(uint a) {
+	if (a == 1)
+		startUp_helper();
+}
+
+void SimonState::startUp_helper() {
+	runSubroutine101();
+	startUp_helper_2();
+}	
+
+void SimonState::runSubroutine101() {
+	Subroutine *sub;
+
+	sub = getSubroutineByID(101);
+	if (sub != NULL)
+		startSubroutineEx(sub);
+	
+	startUp_helper_2();
+}
+
+void SimonState::generateSound(byte *ptr, int len) {
+	uint cur;
+
+	cur = _voice_size;
+	if (cur >	(uint)len) cur=(uint)len;
+	_voice_size -= cur;
+
+	if (cur!=0) {
+		fread(ptr, cur, 1, _voice_file);
+	}
+
+	memset(ptr + cur, 0x80, len - cur);
+
+	cur = _sound_size;
+	if (cur) {
+		uint i;
+
+		if (cur > (uint)len) cur = (uint)len;
+
+		for(i=0;i!=cur;i++) {
+			ptr[i] += _sound_ptr[i] ^0x80;
+		}
+		
+		_sound_size -= cur;
+		_sound_ptr += cur;
+	}
+}
+
+static void fill_sound(void *userdata, int16 *stream, int len) {
+	((SimonState*)userdata)->generateSound((byte*)stream, len*2);
+}
+
+void SimonState::dx_copy_rgn_from_3_to_2(uint b, uint r, uint y, uint x) {
+	byte *dst, *src;
+	uint i;
+	
+	dst = dx_lock_2();
+	src = sdl_buf_3;
+
+	dst += y * _dx_surface_pitch;
+	src += y * _dx_surface_pitch;
+
+	while (y < b) {
+		for(i=x; i<r; i++)
+			dst[i] = src[i];
+		y++;
+		dst += _dx_surface_pitch;
+		src += _dx_surface_pitch;
+	}
+	
+	dx_unlock_2();
+}
+
+void SimonState::dx_clear_surfaces(uint num_lines) {
+	memset(sdl_buf_attached, 0, num_lines*320);
+	
+	_system->copy_rect(sdl_buf_attached, 320, 0, 0, 320, 200);
+
+	if (_dx_use_3_or_4_for_lock) {
+		memset(sdl_buf, 0, num_lines*320);
+		memset(sdl_buf_3, 0, num_lines*320);
+	}
+}
+
+void SimonState::dx_clear_attached_from_top(uint lines) {
+	memset(sdl_buf_attached, 0, lines*320);
+}
+
+void SimonState::dx_copy_from_attached_to_2(uint x, uint y, uint w, uint h) {
+	uint offs = x + y*320;
+	byte *s = sdl_buf_attached + offs;
+	byte *d = sdl_buf + offs;
+	
+	do {
+		memcpy(d,s,w);
+		d+=320;
+		s+=320;
+	} while(--h);
+}
+
+
+void SimonState::dx_copy_from_attached_to_3(uint lines) {
+	memcpy(sdl_buf_3, sdl_buf_attached, lines*320);
+}
+
+void SimonState::dx_update_screen_and_palette() {
+	_num_screen_updates++;
+
+	if (_palette_color_count == 0 && _video_var_9==1) {
+		_video_var_9 = 0;
+		if (memcmp(_palette,_palette_backup,256*4)!=0) {
+			memcpy(_palette_backup, _palette, 256*4);
+			_system->set_palette(_palette, 0, 256);
+		}
+	}
+
+	if (!_fast_mode || !(rand()&7)) {
+		
+		if (_mouse_pos_changed) {
+			_mouse_pos_changed = false;
+			_system->set_mouse_pos(sdl_mouse_x, sdl_mouse_y);
+		}
+		_system->copy_rect(sdl_buf_attached, 320, 0, 0, 320, 200);
+		_system->update_screen();
+	}
+
+	memcpy(sdl_buf_attached, sdl_buf, 320*200);
+
+	if (_palette_color_count != 0) {
+		if (!(_game&GAME_SIMON2) && _use_palette_delay) {
+			delay(100);
+			_use_palette_delay = false;
+		}
+		realizePalette();
+	}
+}
+
+
+void SimonState::realizePalette() {
+	if (_palette_color_count&0x8000) {
+		error("_palette_color_count&0x8000");
+	}
+	_video_var_9 = false;
+	memcpy(_palette_backup, _palette, 256*4);
+
+	_system->set_palette(_palette, 0, _palette_color_count);
+	_palette_color_count = 0;
+
+}
+
+
+void SimonState::go(OSystem *syst) {
+	_system = syst;
+
+	if (!_dump_file)
+		_dump_file = stdout;
+
+	/* allocate buffers */
+	sdl_buf_3 = (byte*)calloc(320*200,1);
+	sdl_buf = (byte*)calloc(320*200,1);
+	sdl_buf_attached = (byte*)calloc(320*200,1);
+
+	if (_game & GAME_SIMON2) {
+		gss = &simon2_settings;
+	} else {
+		gss = &simon1_settings;
+	}
+
+	allocItemHeap();
+	allocTablesHeap();
+
+	setup_vga_file_buf_pointers();
+
+	initSound();
+	
+	if (!loadGamePcFile(gss->gamepc_filename))
+		error("Error loading gamepc file '%s' (or one of the files it depends on)", gss->gamepc_filename);
+
+	addTimeEvent(0, 1);
+	openGameFile();
+
+	_last_music_played = (uint)-1;
+	_vga_base_delay = 1;
+	_vk_t_toggle = true;
+
+	_system->set_param(OSystem::PARAM_SHOW_DEFAULT_CURSOR, 1);
+	_system->set_sound_proc(this, fill_sound);
+
+	while(1) {
+		hitarea_stuff();
+		handle_verb_clicked(_verb_hitarea);
+		delay(100);
+	}
+}
+
+void SimonState::shutdown() {
+	if (_game_file) {
+		fclose(_game_file);
+		_game_file = NULL;
+	}
+}
+
+void SimonState::delay(uint delay) {
+		OSystem::Event event;
+
+	uint32 start = _system->get_msecs();
+	uint32 cur = start;
+	const uint vga_period = _fast_mode ? 10 : 50;
+
+	do {
+		while (!_in_callback && cur >= _last_vga_tick + vga_period) {
+			_last_vga_tick += vga_period;
+			
+			/* don't get too many frames behind */
+			if (cur >= _last_vga_tick + vga_period*2) 
+				_last_vga_tick = cur;
+
+			_in_callback = true;
+			timer_callback();
+			_in_callback = false;
+		}
+
+		while (_system->poll_event(&event)) {
+			switch(event.event_code) {
+			case OSystem::EVENT_KEYDOWN:
+				if (event.kbd.keycode=='f' && event.kbd.flags==OSystem::KBD_CTRL) {
+					_fast_mode^=1;
+				} else if (event.kbd.keycode=='t') {
+					_vk_t_toggle ^= 1;
+				}	else if (event.kbd.keycode>='0' && event.kbd.keycode<='9' && 
+										event.kbd.flags == OSystem::KBD_ALT|OSystem::KBD_CTRL) {
+						if (!_system->set_param(OSystem::PARAM_HOTSWAP_GFX_MODE, event.kbd.keycode - '1'))
+							warning("Unable to hotswap graphics mode");
+				}
+
+				break;
+			case OSystem::EVENT_MOUSEMOVE:
+				sdl_mouse_x = event.mouse.x;
+				sdl_mouse_y = event.mouse.y;
+				_mouse_pos_changed = true;
+				break;
+
+			case OSystem::EVENT_LBUTTONDOWN:
+				_left_button_down++;
+				break;
+
+			case OSystem::EVENT_RBUTTONDOWN:
+				_exit_cutscene = true;
+				break;
+			}
+		}
+
+		if (delay==0) break;
+
+		_system->delay_msecs(_fast_mode ? 1 : 10);
+		cur = _system->get_msecs();
+	} while (cur < start + delay);
+}
+
+
+bool SimonState::save_game(uint slot, const char *caption) {
+	char filename[32];
+	FILE *f;
+	uint item_index, num_item, i;
+	TimeEvent *te;
+
+	_lock_word |= 0x100;
+
+	sprintf(filename, "SAVE.%.3d", slot);
+	
+	errno = 0;
+	
+	f = fopen(filename, "wb");
+	if (f==NULL)
+		return false;
+
+	fwrite(caption, 1, 0x12, f);
+
+	fileWriteBE32(f, _itemarray_inited-1);
+	fileWriteBE32(f, 0xFFFFFFFF);
+	fileWriteBE32(f, 0);
+	fileWriteBE32(f, 0);
+
+	i=0;
+	for(te = _first_time_struct; te; te = te->next)
+		i++;
+
+	fileWriteBE32(f, i);
+	for(te = _first_time_struct; te; te = te->next) {
+		fileWriteBE32(f, te->time + _base_time);
+		fileWriteBE16(f, te->subroutine_id);
+	}
+
+	item_index = 1;
+	for(num_item = _itemarray_inited-1; num_item; num_item--) {
+		Item *item = _itemarray_ptr[item_index++];
+
+		fileWriteBE16(f, item->parent);
+		fileWriteBE16(f, item->sibling);
+		fileWriteBE16(f, item->unk3);
+		fileWriteBE16(f, item->unk4);
+
+		{
+			Child1 *child1 = findChildOfType1(item);
+			if (child1) {
+				fileWriteBE16(f, child1->fr2);
+			}
+		}
+
+		{
+			Child2 *child2 = findChildOfType2(item);
+			uint i,j;
+
+			if (child2) {
+				fileWriteBE32(f, child2->avail_props);
+				i = child2->avail_props&1;
+
+				for(j=1; j<16; j++) {
+					if ((1<<j) & child2->avail_props) {
+						fileWriteBE16(f, child2->array[i++]);
+					}
+				}
+			}
+		}
+
+		{
+			Child9 *child9 = (Child9*)findChildOfType(item, 9);
+			if (child9) {
+				uint i;
+				for(i=0; i!=4; i++) {
+					fileWriteBE16(f, child9->array[i]);
+				}
+			}
+		}
+	}
+
+	/* write the 255 variables */
+	for(i=0; i!=255; i++) {
+		fileWriteBE16(f, readVariable(i));
+	}
+
+	/* write the items in array 6 */
+	for(i=0; i!=10; i++) {
+		fileWriteBE16(f, itemPtrToID(_item_array_6[i]));
+	}
+
+	/* Write the bits in array 1 & 2*/
+	for(i=0; i!=32; i++)
+		fileWriteBE16(f, _bit_array[i]);
+	
+	fclose(f);
+
+	_lock_word &= ~0x100;
+
+	return true;
+}
+
+bool SimonState::load_game(uint slot) {
+	char filename[32];
+	char ident[18];
+	FILE *f;
+	uint num, item_index, i;
+	
+	_lock_word |= 0x100;
+		
+	sprintf(filename, "SAVE.%.3d", slot);
+
+	errno = 0;
+
+	f = fopen(filename, "rb");
+	if (f==NULL)
+		return false;
+
+	fread(ident, 1, 18, f);
+	
+	num = fileReadBE32(f);
+
+	if (fileReadBE32(f) != 0xFFFFFFFF || num != _itemarray_inited-1) {
+		fclose(f);
+		return false;
+	}
+
+	fileReadBE32(f);
+	fileReadBE32(f);
+
+	_no_parent_notify = true;
+
+	
+	/* add all timers */
+	killAllTimers();
+	for(num = fileReadBE32(f);num;num--) {
+		uint32 timeout = fileReadBE32(f);
+		uint16 func_to_call = fileReadBE16(f);
+		addTimeEvent(timeout, func_to_call);
+	}
+
+	item_index = 1;
+	for(num=_itemarray_inited-1; num; num--) {
+		Item *item = _itemarray_ptr[item_index++], *parent_item;
+
+		uint parent = fileReadBE16(f);
+		uint sibling = fileReadBE16(f);
+
+		parent_item = derefItem(parent);
+
+		setItemParent(item, parent_item);
+
+		if (parent_item == NULL) {
+			item->parent = parent;
+			item->sibling = sibling;
+		}
+
+		item->unk3 = fileReadBE16(f);
+		item->unk4 = fileReadBE16(f);
+
+		{
+			Child1 *child1 = findChildOfType1(item);
+			if (child1 != NULL) {
+				child1->fr2 = fileReadBE16(f);
+			}
+		}
+
+		{
+			Child2 *child2 = findChildOfType2(item);
+			uint i,j;
+			if (child2 != NULL) {
+				child2->avail_props = fileReadBE32(f);
+				i = child2->avail_props&1;
+
+				for(j=1; j<16; j++) {
+					if ((1<<j) & child2->avail_props) {
+						child2->array[i++] = fileReadBE16(f);
+					}
+				}
+			}
+		}
+
+		{
+			Child9 *child9 = (Child9*)findChildOfType(item, 9);
+			if (child9) {
+				uint i;
+				for(i=0; i!=4; i++) {
+					child9->array[i] = fileReadBE16(f);
+				}
+			}
+		}
+	}
+
+	
+	/* read the 255 variables */
+	for(i=0; i!=255; i++) {
+		writeVariable(i, fileReadBE16(f));
+	}
+
+	/* write the items in array 6 */
+	for(i=0; i!=10; i++) {
+		_item_array_6[i] = derefItem(fileReadBE16(f));
+	}
+
+	/* Write the bits in array 1 & 2*/
+	for(i=0; i!=32; i++)
+		_bit_array[i] = fileReadBE16(f);
+	
+	fclose(f);
+
+	_no_parent_notify = false;
+
+	_lock_word &= ~0x100;
+
+	if (errno != 0)
+		error("load failed");
+
+	return true;
+}
+
+void SimonState::initSound() {
+	const char *s = gss->wav_filename;
+
+	_voice_offsets = NULL;
+
+	_voice_file = fopen(s, "rb");
+	if (_voice_file == NULL) {
+		warning("Cannot open %s",s);
+		return;
+	}
+
+	_voice_offsets = (uint32*)malloc(gss->NUM_VOICE_RESOURCES * sizeof(uint32));
+	if (_voice_offsets == NULL)
+		error("Out of memory for voice offsets");
+
+	if (fread(_voice_offsets, gss->NUM_VOICE_RESOURCES * sizeof(uint32), 1, _voice_file) != 1)
+		error("Cannot read voice offsets");
+}
+
+struct WaveHeader {
+	uint32 riff;
+	uint32 unk;
+	uint32 wave;
+	uint32 fmt;
+
+  uint32 size;
+
+	uint16 format_tag;
+	uint16 channels;
+	uint32 samples_per_sec;
+	uint32 avg_bytes;
+
+	uint16 block_align;
+	uint16 bits_per_sample;
+};
+
+void SimonState::playVoice(uint voice) {
+	WaveHeader wave_hdr;
+	uint32 data[2];
+
+//	assert(voice < 14496/4);
+
+	_voice_size = 0;
+
+	if (_voice_offsets == NULL)
+		return;
+
+	fseek(_voice_file, _voice_offsets[voice], SEEK_SET);
+
+	if (fread(&wave_hdr, sizeof(wave_hdr), 1, _voice_file)!=1 ||
+		wave_hdr.riff!='FFIR' || wave_hdr.wave!='EVAW' || wave_hdr.fmt!=' tmf' ||
+		wave_hdr.format_tag!=1 || wave_hdr.channels!=1 || wave_hdr.bits_per_sample!=8) {
+			warning("playVoice(%d): cannot read RIFF header", voice);
+			return;
+		}
+
+	fseek(_voice_file, wave_hdr.size - sizeof(wave_hdr) + 20, SEEK_CUR);
+
+	if (fread(data, sizeof(data), 1, _voice_file) != 1 ||
+		data[0] != 'atad' ) {
+			warning("playVoice(%d): cannot read data header",voice);
+			return;
+		}
+
+	_voice_size = data[1];
+}
+
+
+void SimonState::playSound(uint sound) {
+	if (_game & GAME_WIN) {
+		byte *p;
+		
+		/* stop any currently playing sound */
+		_sound_size = 0;
+		
+		p = _sfx_heap + ((uint32*)_sfx_heap)[sound];
+
+		for(;;) {
+			p = (byte*)memchr(p, 'd', 1000);
+			if (!p) {
+				error("playSound(%d): didn't find", sound);
+				return;
+			}
+			if (p[1]=='a' && p[2]=='t' && p[3]=='a')
+				break;
+
+			p++;
+		}
+
+		_sound_ptr = p + 8;
+		_sound_size = ((uint32*)p)[1];
+	} else {
+		warning("playSound(%d)", sound);
+	}
+}
+
+void SimonState::playMusic(uint music) {
+	FILE *f;
+
+	midi.shutdown();
+
+	/* FIXME: not properly implemented */
+	if (_game & GAME_WIN) {
+		fseek(_game_file, _game_offsets_ptr[gss->MUSIC_INDEX_BASE + music],SEEK_SET);
+		f = _game_file;
+	
+		midi.read_all_songs(f);
+	} else {
+		char buf[50];
+		sprintf(buf, "mod%d.mus", music);
+		f = fopen(buf, "rb");
+		if (f==NULL) {
+			warning("Cannot load music from '%s'", buf);
+			return;
+		}
+		midi.read_all_songs_old(f);
+		fclose(f);
+	}
+
+	midi.initialize();
+	midi.play();
+}
+
+byte *SimonState::dx_lock_2() {
+	_dx_surface_pitch = 320;
+	return sdl_buf;
+}
+
+void SimonState::dx_unlock_2() {
+}
+
+byte *SimonState::dx_lock_attached() {
+	_dx_surface_pitch = 320;
+	return _dx_use_3_or_4_for_lock ? sdl_buf_3 : sdl_buf_attached;
+}
+
+void SimonState::dx_unlock_attached() {
+}
+
+
+
+/**********************************************************************/
+/**********************************************************************/
+/**********************************************************************/
+/**********************************************************************/
+
+void decompressIcon(byte *dst, byte *src, uint pitch, byte base) {
+	int8 reps = (int8)0x80;
+	byte color_1, color_2;
+	byte *dst_org = dst;
+	uint h = 12, w = 24;
+
+	for(;;) {
+		reps = *src++;
+		if (reps < 0) {
+			color_1 = *src & 0xF;
+			if (color_1 != 0) color_1 += base;
+			color_2 = *src++ >> 4;
+			if (color_2 != 0) color_2 += base;
+			
+			do {	
+				if (color_1 != 0) *dst = color_1;
+				dst += pitch;
+				if (color_2 != 0) *dst = color_2;
+				dst += pitch;
+
+				/* reached bottom? */
+				if (--h == 0) {
+					/* reached right edge? */				
+					if (--w == 0)
+						return;
+					dst = ++dst_org;
+					h = 12;
+				}
+			} while (++reps != 0);
+		} else {
+			
+			do {	
+				color_1 = *src & 0xF;
+				if (color_1 != 0) *dst = color_1 | base;
+				dst += pitch;
+
+				color_2 = *src++ >> 4;
+				if (color_2 != 0) *dst = color_2 | base;
+				dst += pitch;
+
+				/* reached bottom? */
+				if (--h == 0) {
+					/* reached right edge? */				
+					if (--w == 0)
+						return;
+					dst = ++dst_org;
+					h = 12;
+				}
+			} while (--reps >= 0);
+		}
+	}
+}
+
+static const char * const opcode_name_table[256] = {
+	/* 0 */
+	"|INV_COND",
+	"IJ|PTRA_PARENT_IS",
+	"IJ|PTRA_PARENT_ISNOT",
+	NULL,
+	/* 4 */
+	NULL,
+	"IJ|PARENT_IS_1",
+	"IJ|PARENT_ISNOT_1",
+	"IIJ|PARENT_IS",
+	/* 8 */
+	NULL,
+	NULL,
+	NULL,
+	"VJ|IS_ZERO",
+	/* 12 */
+	"VJ|ISNOT_ZERO",
+	"VWJ|IS_EQ",
+	"VWJ|IS_NEQ",
+	"VWJ|IS_LE",
+	/* 16 */
+	"VWJ|IS_GE",
+	"VVJ|IS_EQF",
+	"VVJ|IS_NEQF",
+	"VVJ|IS_LEF",
+	/* 20 */
+	"VVJ|IS_GEF",
+	NULL,
+	NULL,
+	"WJ|UNK23",
+	/* 24 */
+	NULL,
+	"IJ|HAS_CHILD_1",
+	"IJ|HAS_CHILD_2",
+	"IWJ|ITEM_UNK3_IS",
+	/* 28 */
+	"IBJ|CHILD_HAS_FLAG",
+	NULL,
+	NULL,
+	"I|SET_NO_PARENT",
+	/* 32 */
+	NULL,
+	"II|SET_PARENT",
+	NULL,
+	NULL,
+	/* 36 */
+	"VV|MOVE",
+	NULL,
+	NULL,
+	NULL,
+	/* 40 */
+	NULL,
+	"V|ZERO",
+	"VW|SET",
+	"VW|ADD",
+	/* 44 */
+	"VW|SUB",
+	"VV|ADDF",
+	"VV|SUBF",
+	"VW|MUL",
+	/* 48 */
+	"VW|DIV",
+	"VV|MULF",
+	"VV|DIVF",
+	"VW|MOD",
+	/* 52 */
+	"VV|MODF",
+	"VW|RANDOM",
+	NULL,
+	"I|SET_A_PARENT",
+	/* 56 */
+	"IB|SET_CHILD2_BIT",
+	"IB|CLEAR_CHILD2_BIT",
+	"II|MAKE_SIBLING",
+	"I|INC_UNK3",
+	/* 60 */
+	"I|DEC_UNK3",
+	"IW|SET_UNK3",
+	"V|SHOW_INT",
+	"T|SHOW_STRING_NL",
+	/* 64 */
+	"T|SHOW_STRING",
+	"WWWWWB|ADD_HITAREA",
+	"BT|SET_ITEM_NAME",
+#if defined SIMON1WIN || defined SIMON2
+	"BTw|SET_ITEM_DESC",
+#endif
+#ifdef SIMON1DOS
+	"BT|SET_ITEM_DESC",
+#endif
+	/* 68 */
+	"x|HALT",
+	"x|RET1",
+	"V|SHOW_STRING_AR3",
+	"W|START_SUB",
+	/* 72 */
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	/* 76 */
+	"WW|ADD_TIMEOUT",
+	"J|IS_M1_EMPTY",
+	"J|IS_M3_EMPTY",
+	"ITJ|CHILD_FR2_IS",
+	/* 80 */
+	"IIJ|IS_ITEM_EQ",
+	NULL,
+	"B|UNK82",
+	"|RETM10",
+	/* 84 */
+	NULL,
+	NULL,
+	NULL,
+	"W|UNK87",
+	/* 88 */
+	"|OR_SCRIPT_WORD_10",
+	"|AND_SCRIPT_WORD_10",
+	"IB|SET_M_TO_PARENT",
+	"IB|SET_M_TO_SIBLING",
+	/* 92 */
+	"IB|SET_M_TO_CHILD",
+	NULL,
+	NULL,
+	NULL,
+	/* 96 */
+	"WB|UNK96",
+	"W|LOAD_VGA",
+#ifdef SIMON2
+	"WWBWWW|START_VGA",
+#else
+	"WBWWW|START_VGA",
+#endif
+#ifdef SIMON2
+	"WW|KILL_THREAD",
+#else
+	"W|KILL_THREAD",
+#endif
+	/* 100 */
+	"|VGA_RESET",
+	"BWWWWWW|UNK101",
+	"B|UNK102",
+	"|UNK103",
+	/* 104 */
+	"B|UNK104",
+	NULL,
+	NULL,
+	"WWWWWIW|ADD_ITEM_HITAREA",
+	/* 108 */
+	"W|DEL_HITAREA",
+	"W|CLEAR_HITAREA_0x40",
+	"W|SET_HITAREA_0x40",
+	"WWW|SET_HITAREA_XY",
+	/* 112 */
+	NULL,
+	NULL,
+	"IB|UNK114",
+	"IBJ|HAS_FLAG",
+	/* 116 */
+	"IB|SET_FLAG",
+	"IB|CLEAR_FLAG",
+	NULL,
+	"W|WAIT_VGA",
+	/* 120 */
+	"W|UNK120",
+	"BI|SET_VGA_ITEM",
+	NULL,
+	NULL,
+	/* 124 */
+	NULL,
+	"IJ|IS_SIBLING_WITH_A",
+	"IBB|UNK126",
+	"WW|UNK127",
+	/* 128 */
+	"W|GET_DUMMY_WORD",
+	"W|GET_WORD_COND_TRUE",
+	"Bww|UNK131",
+	NULL,	/* opcode 131 doesn't exist */
+	/* 132 */
+	"|SAVE_GAME",
+	"|LOAD_GAME",
+	"|DUMMYPROC_134",
+	"|QUIT_IF_USER_PRESSES_Y",
+	/* 136 */
+	"IV|GET_ITEM_UNK3",
+	"B|UNK137",
+	"|VGA_POINTER_OP_4",
+	"II|SET_PARENT_SPECIAL",
+	/* 140 */
+	"|DEL_TE_AND_ADD_ONE",
+	"BI|SET_M1_OR_M3",
+	"WJ|IS_HITAREA_0x40_CLEAR",
+	"I|START_ITEM_SUB",
+	/* 144 */
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	/* 148 */
+	NULL,
+	NULL,
+	NULL,
+	"BI|SET_ARRAY6_TO",
+	/* 152 */
+	"BB|SET_M1_M3_TO_ARRAY6",
+	"B|SET_BIT",
+	"B|CLEAR_BIT",
+	"BJ|IS_BIT_CLEAR",
+	/* 156 */
+	"BJ|IS_BIT_SET",
+	"IBB|GET_ITEM_PROP",
+	"IBW|SET_ITEM_PROP",
+	NULL,
+	/* 160 */
+	"B|UNK160",
+	"BWBW|SETUP_TEXT",
+#if defined SIMON1WIN || defined SIMON2
+	"BBTW|PRINT_STR",
+#endif
+#ifdef SIMON1DOS
+	"BBT|PRINT_STR",
+#endif
+	"W|SOUND_1",
+	/* 164 */
+	"|UNK164",
+	"IWWJ|ITEM_UNK1_UNK2_IS",
+	"B|SET_BIT2",
+	"B|CLEAR_BIT2",
+	/* 168 */
+	"BJ|IS_BIT2_CLEAR",
+	"BJ|IS_BIT2_SET",
+	NULL,
+	NULL,
+	/* 172 */
+	NULL,
+	NULL,
+	NULL,
+	"|VGA_POINTER_OP_1",
+	/* 176 */
+	"|VGA_POINTER_OP_2",
+	"BBI|UNK177",
+	"WWBB|PATHFIND",
+	"BBB|UNK179",
+	/* 180 */
+	"|FORCE_UNLOCK",
+	"|FORCE_LOCK",
+	"|READ_VGARES_328",
+	"|READ_VGARES_23",
+	/* 184 */
+	"W|CLEAR_VGAPOINTER_ENTRY",
+	"W|DUMMY_185",
+	"|VGA_POINTER_OP_3",
+	"|FADE_TO_BLACK",
+#ifdef SIMON2
+	/* 188 */
+	"BSJ|STRING2_IS",
+	"|UNK189",
+	"B|UNK190",
+#endif
+};
+
+byte *SimonState::dumpOpcode(byte *p) {
+	byte opcode;	
+	const char *s, *st;
+
+	opcode = *p++;
+	if (opcode == 255)
+		return NULL;
+	st = s = opcode_name_table[opcode];
+	if (s == NULL) {
+		error("INVALID OPCODE %d\n", opcode);
+		return NULL;
+	}
+	while (*st != '|') st++;
+	fprintf(_dump_file,"%s ", st+1);
+
+	for(;;) {
+		switch(*s++) {
+		case 'x':
+			fprintf(_dump_file,"\n");
+			return NULL;
+		case '|':
+			fprintf(_dump_file,"\n");
+			return p;
+		case 'B': {
+			byte b = *p++;
+			if (b==255)
+				fprintf(_dump_file,"[%d] ", *p++);
+			else
+				fprintf(_dump_file,"%d ", b);
+			break;
+		}
+		case 'V': {
+			byte b = *p++;
+			if (b==255)
+				fprintf(_dump_file,"[[%d]] ", *p++);
+			else
+				fprintf(_dump_file,"[%d] ", b);
+			break;
+		}
+
+		case 'W': {
+			int n = (int16)((p[0]<<8)|p[1]);
+			p+=2;
+			if (n>=30000 && n<30512)
+				fprintf(_dump_file,"[%d] ", n - 30000);
+			else
+				fprintf(_dump_file,"%d ", n);
+			break;
+		}
+
+		case 'w': {
+			int n = (int16)((p[0]<<8)|p[1]);
+			p+=2;
+			fprintf(_dump_file,"%d ", n);
+			break;
+		}
+
+		case 'I': {
+			int n = (int16)((p[0]<<8)|p[1]);;
+			p+=2;
+			if (n == -1)
+				fprintf(_dump_file,"ITEM_M1 ");
+			else if (n == -3)
+				fprintf(_dump_file,"ITEM_M3 ");
+			else if (n == -5)
+				fprintf(_dump_file,"ITEM_1 ");
+			else if (n == -7)
+				fprintf(_dump_file,"ITEM_0 ");
+			else if (n == -9)
+				fprintf(_dump_file,"ITEM_A_PARENT ");
+			else
+				fprintf(_dump_file,"<%d> ", n);
+			break;
+		}
+		case 'J': {
+			fprintf(_dump_file,"-> ");
+		} break;
+
+
+		case 'T': {
+			uint n = ((p[0]<<8)|p[1]);
+			p+=2;
+			if (n != 0xFFFF)
+				fprintf(_dump_file,"\"%s\"(%d) ", getStringPtrByID(n), n);
+			else
+				fprintf(_dump_file,"NULL_STRING ");
+		} break;
+		}
+	}
+}
+
+void SimonState::dumpSubroutineLine(SubroutineLine *sl, Subroutine *sub) {
+	byte *p;
+	
+	
+	printf("; ****\n");
+
+	p = (byte*)sl + SUBROUTINE_LINE_SMALL_SIZE;
+	if (sub->id == 0) {
+		fprintf(_dump_file,"; cond_a=%d, cond_b=%d, cond_c=%d\n", sl->cond_a, sl->cond_b, sl->cond_c);
+		p = (byte*)sl + SUBROUTINE_LINE_BIG_SIZE;
+	}
+
+	for(;;) {
+		p = dumpOpcode(p);
+		if (p==NULL)
+			break;
+	}
+}
+
+void SimonState::dumpSubroutine(Subroutine *sub) {
+	SubroutineLine *sl;
+
+	fprintf(_dump_file,"\n******************************************\n;Subroutine, ID=%d:\nSUB_%d:\n", sub->id, sub->id);
+	sl = (SubroutineLine*) ((byte*)sub + sub->first);
+	for(;(byte*)sl != (byte*)sub; sl = (SubroutineLine*) ((byte*)sub + sl->next) ) {
+		dumpSubroutineLine(sl, sub);
+	}
+	fprintf(_dump_file,"\nEND ******************************************\n");
+	fflush(_dump_file);
+}
+
+void SimonState::dumpSubroutines() {
+	Subroutine *sub = _subroutine_list;
+	for(;sub;sub = sub->next) {
+		dumpSubroutine(sub);
+	}
+}
+
+
+
+const char * const video_opcode_name_table[] = {
+	/* 0 */
+	"x|RET",
+	"ddd|DUMMY",
+	"d|CALL",
+	"ddddd|NEW_THREAD",
+	/* 4 */
+	"ddd|DUMMY_2",
+	"vd|SKIP_IF_NEQ",
+	"d|SKIP_IFN_SIB_WITH_A",
+	"d|SKIP_IF_SIB_WITH_A",
+	/* 8 */
+	"dd|SKIP_IF_PARENT_IS",
+	"dd|SKIP_IF_UNK3_IS",
+#ifdef SIMON2
+	"ddddb|DRAW",
+#else
+	"ddddd|DRAW",
+#endif
+	"|CLEAR_PATHFIND_ARRAY",
+	/* 12 */
+#ifdef SIMON2
+	"b|DELAY",
+#else
+	"d|DELAY",
+#endif
+	"d|OFFSET_X",
+	"d|OFFSET_Y",
+	"d|IDENT_WAKEUP",
+	/* 16 */
+	"d|IDENT_SLEEP",
+	"dq|SET_PATHFIND_ITEM",
+	"i|JUMP_REL",
+	"|CHAIN_TO",
+	/* 20 */
+	"dd|SET_CODE_WORD",
+	"i|JUMP_IF_CODE_WORD",
+	"dd|SET_PAL",
+	"d|SET_PRI",
+	/* 24 */
+	"diid|SET_IMG_XY",
+	"x|HALT_THREAD",
+	"ddddd|SET_WINDOW",
+	"|RESET",
+	/* 28 */
+	"dddd|DUMMY_3",
+	"|STOP_ALL_SOUNDS",
+	"d|SET_BASE_DELAY",
+	"d|SET_PALETTE_MODE",
+	/* 32 */
+	"vv|COPY_VAR",
+	"|FORCE_UNLOCK",
+	"|FORCE_LOCK",
+	"dd|DUMMY_4",
+	/* 36 */
+	"dd|SAVELOAD_THING",
+	"v|OFFSET_Y_F",
+	"v|SKIP_IF_VAR_ZERO",
+	"vd|SET_VAR",
+	/* 40 */
+	"vd|ADD_VAR",
+	"vd|SUB_VAR",
+	"vd|SLEEP_UNTIL_SET",
+	"d|SKIP_IF_BIT_CLEAR",
+	/* 44 */
+	"d|SKIP_IF_BIT_SET",	
+	"v|SET_X_F",
+	"v|SET_Y_F",
+	"vv|ADD_VAR_F",
+	/* 48 */
+	"|VC_48",
+	"d|SET_BIT",
+	"d|CLEAR_BIT",
+	"d|CLEAR_HITAREA_BIT_0x40",
+	/* 52 */
+	"d|VC_52",
+	"dd|DUMMY_5",
+	"ddd|DUMMY_6",
+	"ddd|OFFSET_HIT_AREA",
+	/* 56 */
+#ifdef SIMON2
+	"d|SLEEP_EX",
+#else
+	"|DUMMY_7",
+#endif
+	"|DUMMY_8",
+	"|DUMMY_9",
+#ifdef SIMON2
+	"ddd|KILL_MULTI_THREAD",
+#else
+	"|SKIP_IF_SOUND??",
+#endif
+	/* 60 */
+#ifdef SIMON2
+	"dd|KILL_THREAD",
+#else
+	"d|KILL_THREAD",
+#endif
+	"ddd|INIT_SPRITE",
+	"|PALETTE_THING",
+	"|PALETTE_THING_2",
+#ifdef SIMON2
+	/* 64 */
+	"|UNK64",
+	"|UNK65",
+	"|UNK66",
+	"|UNK67",
+	/* 68 */
+	"|UNK68",
+	"dd|UNK69",
+	"dd|UNK70",
+	"|UNK71",
+	/* 72 */
+	"dd|UNK72",
+	"bb|UNK73",
+	"bb|UNK74",
+#endif
+};
+
+void SimonState::dump_video_script(byte *src, bool one_opcode_only) {
+	uint opcode;
+	const char *str, *strn;
+
+	do {
+		if (!(_game & GAME_SIMON2)) {
+			opcode = swap16(*(uint16*)src);
+			src+=2;
+		} else {
+			opcode = *src++;
+		}
+
+		if (opcode >= gss->NUM_VIDEO_OP_CODES) {
+			error("Invalid opcode %x\n", opcode);
+			return;
+		}
+
+		strn = str = video_opcode_name_table[opcode];
+		while (*strn != '|') strn++;
+		fprintf(_dump_file,"%.2d: %s ", opcode, strn + 1);
+
+		for (;*str != '|';str++) {
+			switch(*str) {
+			case 'x': fprintf(_dump_file,"\n"); return;
+			case 'b':	fprintf(_dump_file,"%d ", *src++); break;
+			case 'd':	fprintf(_dump_file,"%d ", swap16(*(uint16*)src)); src+=2; break;
+			case 'v':	fprintf(_dump_file,"[%d] ", swap16(*(uint16*)src)); src+=2; break;
+			case 'i':	fprintf(_dump_file,"%d ", (int16)swap16(*(uint16*)src)); src+=2; break;
+			case 'q': 
+				while (*(uint16*)src != 0xE703) {
+					fprintf(_dump_file,"(%d,%d) ", swap16(((uint16*)src)[0]), swap16(((uint16*)src)[1]));
+					src += 4;
+				}
+				src++;
+				break;
+			default:
+				error("Invalid fmt string '%c' in decompile VGA", *str);
+			}
+		}
+
+		fprintf(_dump_file,"\n");
+	} while(!one_opcode_only);
+}
+
+void SimonState::dump_vga_file(byte *vga) {
+	{
+		byte *pp;
+		byte *p;
+		int count;
+
+		pp = vga;
+		p = pp + swap16(((VgaFile1Header*)pp)->hdr2_start);
+		count = swap16(((VgaFile1Header2*)p)->id_count);
+		p = pp + swap16(((VgaFile1Header2*)p)->id_table);
+		while (--count >= 0) {
+			int id = swap16(((VgaFile1Struct0x6*)p)->id);
+
+			dump_vga_script_always(vga + swap16(((VgaFile1Struct0x6*)p)->script_offs), id/100, id);
+			p += sizeof(VgaFile1Struct0x6);
+		}
+	}
+
+	{
+		byte *bb, *b;
+		int c;
+
+		bb = vga;
+		b = bb + swap16(((VgaFile1Header*)bb)->hdr2_start);
+		c = swap16(((VgaFile1Header2*)b)->unk1);
+		b = bb + swap16(((VgaFile1Header2*)b)->unk2_offs);
+
+		while (--c >= 0) {
+			int id = swap16(((VgaFile1Struct0x8*)b)->id);
+
+			dump_vga_script_always(vga + swap16(((VgaFile1Struct0x8*)b)->script_offs), id/100, id);
+			b += sizeof(VgaFile1Struct0x8);
+		}
+	}
+}
+
+
+
+const byte bmp_hdr[] = {
+0x42,0x4D,
+0x9E,0x14,0x00,0x00, /* offset 2, file size */
+0x00,0x00,0x00,0x00,
+0x36,0x04,0x00,0x00,
+0x28,0x00,0x00,0x00,
+
+0x3C,0x00,0x00,0x00, /* image width */
+0x46,0x00,0x00,0x00, /* image height */
+0x01,0x00,0x08,0x00,0x00,0x00,0x00,0x00,
+0x00,0x00,0x00,0x00,
+0x00,0x00,0x00,0x00,
+0x00,0x00,0x00,0x00,
+
+0x00,0x01,0x00,0x00,
+0x00,0x01,0x00,0x00,
+};
+
+void dump_bmp(const char *filename, int w, int h, const byte *bytes, const uint32 *palette) {
+	FILE *out = fopen(filename, "wb");
+	byte my_hdr[sizeof(bmp_hdr)];
+	int i;
+
+	if (out == NULL) {
+		printf("DUMP ERROR\n");
+		return;
+	}
+
+	memcpy(my_hdr, bmp_hdr, sizeof(bmp_hdr));
+
+	*(uint32*)(my_hdr + 2) = w*h + 1024 + sizeof(bmp_hdr);
+	*(uint32*)(my_hdr + 18) = w;
+	*(uint32*)(my_hdr + 22) = h;
+
+	
+	fwrite(my_hdr, 1, sizeof(my_hdr), out);
+	
+	for(i=0; i!=256; i++,palette++) {
+		byte color[4];
+		color[0] = (byte)(*palette >> 16);
+		color[1] = (byte)(*palette >> 8);
+		color[2] = (byte)(*palette);
+		color[3] = 0;
+		fwrite(color, 1, 4, out);
+	}
+
+	while (--h >= 0) {
+		fwrite(bytes + h * ((w+3)&~3), ((w+3)&~3), 1, out);
+	}
+
+	fclose(out);
+}
+
+void dump_bitmap(const char *filename, byte *offs, int w, int h, int flags, const byte *palette, byte base) {
+	/* allocate */
+	byte *b = (byte*)malloc(w*h);
+	int i,j;
+
+	VC10_state state;
+
+	state.depack_cont = -0x80;
+	state.depack_src = offs;
+	state.dh = h;
+	state.y_skip = 0;
+
+	for(i=0; i!=w; i+=2) {
+		byte *c = vc_10_depack_column(&state);
+		for(j=0;j!=h;j++) {
+			byte pix = c[j];
+			b[j*w+i] = (pix>>4)|base;
+			b[j*w+i+1] = (pix&0xF)|base;
+
+		}
+	}
+
+	dump_bmp(filename, w, h, b, (uint32*)palette);
+	free(b);
+}
+
+void SimonState::dump_single_bitmap(int file, int image, byte *offs, int w, int h, byte base) {
+	char buf[255], buf2[255];
+	struct stat statbuf;
+
+	sprintf(buf, "bmp_%d\\%d.bmp", file, image);
+
+	if (stat(buf, &statbuf) == 0)
+		return;
+
+	sprintf(buf2, "bmp_%d", file);
+	mkdir(buf2);
+
+	dump_bitmap(buf, offs, w, h, 0, _palette, base);
+}
+
+SimonState *SimonState::create() {
+	return new SimonState;
+}
+
+#if 0
+
+
+void pal_load(byte *pal, const byte *vga1, int a, int b) {
+	uint num = a==0 ? 0x20 : 0x10;
+	byte *palptr;
+	const byte *src;
+	
+	palptr = (byte*)&pal[a<<4];
+
+	src = vga1 + 6 + b*96;
+	
+	do {
+		palptr[0] = src[0]<<2;
+		palptr[1] = src[1]<<2;
+		palptr[2] = src[2]<<2;
+		palptr[3] = 0;
+
+		palptr += 4;
+		src += 3;
+	} while (--num);
+}
+
+void SimonState::dump_vga_bitmaps(byte *vga, byte *vga1, int res) {
+	int i;
+	uint32 offs;
+	byte *p2;
+
+	byte pal[768];
+
+	{
+		memset(pal, 0, sizeof(pal));
+		pal_load(pal, vga1, 2, 0);
+		pal_load(pal, vga1, 3, 1);
+		pal_load(pal, vga1, 4, 2);
+		pal_load(pal, vga1, 5, 3);
+	}
+
+	
+	{
+		char buf[255];
+		sprintf(buf, "bmp_%d", res);
+		mkdir(buf2);
+	}
+
+
+	int width, height, flags;
+	
+//	i = 538;
+
+	for(i=1; ; i++) {
+		p2 = vga + i * 8;
+		offs = swap32(*(uint32*)p2);
+
+		/* try to detect end of images.
+		 * assume the end when offset >= 200kb */
+		if (offs >= 200*1024)
+			return;
+		
+		width = swap16(*(uint16*)(p2+6));
+		height = p2[5];
+		flags = p2[4];
+
+		fprintf(_dump_file, "Image %d. Width=%d, Height=%d, Flags=0x%X\n", i, width, height, flags);
+		fflush(_dump_file);
+
+		/* dump bitmap */
+		{
+			char buf[255];
+			sprintf(buf, "bmp_%d\\%d.bmp", res, i);
+
+			dump_bitmap(buf, vga + offs, width, height, flags, pal, 0);
+		}
+	}
+}
+#endif
+	
\ No newline at end of file
diff --git a/simon/simon.h b/simon/simon.h
new file mode 100644
index 0000000000..ead19c42cb
--- /dev/null
+++ b/simon/simon.h
@@ -0,0 +1,1069 @@
+/* Copyright ©2002, The ScummVM Team.
+ *
+ * Current status:
+ * Save/Load dialog doesn't work. You can still save, but only to ONE slot.
+ * There is possibly one or two problems that makes it impossible to finish SIMON1WIN.
+ * Sound & Music only works with SIMON1WIN.
+ * SIMON1DOS works, but without sound & music.
+ * Simon 2 works a little.
+ * The code only compiles in win32. It's currently not alignment safe and not endian safe.
+ */
+
+/* GFX Settings. Sound & Music only works properly with SIMON1WIN */
+#define USE_SOUND
+#define USE_MUSIC
+
+/* Various other settings */
+//#define DUMP_CONTINOUS_MAINSCRIPT
+//#define DUMP_START_MAINSCRIPT
+//#define DUMP_CONTINOUS_VGASCRIPT
+//#define USE_TEXT_HACK
+//#define DRAW_IMAGES_DEBUG
+//#define DRAW_THREE_STARS
+//#define DUMP_START_VGASCRIPT
+//#define DUMP_FILE_NR 8
+//#define DUMP_BITMAPS_FILE_NR 8
+//#define DUMP_DRAWN_BITMAPS
+
+uint fileReadByte(FILE *in);
+uint fileReadBE16(FILE *in);
+uint fileReadLE16(FILE *in);
+uint32 fileReadBE32(FILE *in);
+uint32 fileReadLE32(FILE *in);
+void fileWriteBE32(FILE *in, uint32 value);
+void fileWriteBE16(FILE *in, uint16 value);
+
+
+#define ARRAYSIZE(x) (sizeof(x)/sizeof(x[0]))
+#define CHECK_BOUNDS(x,y) assert((uint)(x)<ARRAYSIZE(y))
+
+#ifdef WIN32
+/* don't complain about zero sized arrays */
+#pragma warning (disable: 4200)
+#endif
+
+struct Child {
+	Child *next;
+	uint16 type;
+};
+
+struct Child2 {
+	Child hdr;
+
+	uint16 string_id;
+	uint32 avail_props;
+	int16 array[0];
+};
+
+struct Child1 {
+	Child hdr;
+
+	uint16 subroutine_id;
+	uint16 fr2;
+	uint16 array[0];
+};
+
+struct Child9 {
+	Child hdr;
+	
+	uint16 array[4];
+};
+
+struct Child3 {
+	Child hdr;
+};
+
+struct ThreeValues {
+	uint16 a, b, c;
+};
+
+
+struct Item {
+	uint16 parent;
+	uint16 child;
+	uint16 sibling;
+	int16 unk1;
+	int16 unk2;
+	int16 unk3; /* signed int */
+	uint16 unk4;
+	uint16 xxx_1; /* unused? */
+	Child *children;
+};
+
+struct Subroutine {
+	uint16 id;				/* subroutine ID */
+	uint16 first;			/* offset from subroutine start to first subroutine line */
+	Subroutine *next;	/* next subroutine in linked list */
+};
+
+struct FillOrCopyDataEntry {
+	Item *item;
+	uint16 hit_area;
+	uint16 xxx_1;
+};
+
+struct FillOrCopyData {
+	int16 unk1;
+	Item *item_ptr;
+	FillOrCopyDataEntry e[64];
+	int16 unk3, unk4;
+	uint16 unk2;
+};
+
+struct FillOrCopyStruct {
+	byte mode;
+	byte flags;
+	uint16 x, y;
+	uint16 width,height;
+	uint16 unk1, unk2;
+	uint8 unk3, unk6, unk7, fill_color, text_color, unk5;
+	FillOrCopyData *fcs_data;
+};
+
+
+enum {
+	SUBROUTINE_LINE_SMALL_SIZE = 2,
+	SUBROUTINE_LINE_BIG_SIZE = 8,
+};
+
+struct SubroutineLine {
+	uint16 next;
+	int16 cond_a;
+	int16 cond_b;
+	int16 cond_c;
+};
+
+struct TimeEvent {
+	uint32 time;
+	uint16 subroutine_id;
+	TimeEvent *next;
+};
+
+struct HitArea {
+	uint16 x, y;
+	uint16 width, height;
+	uint16 flags;
+	uint16 id;
+	FillOrCopyStruct *fcs;
+	Item *item_ptr;
+	uint16 unk3;
+	uint16 layer;
+};
+
+struct VgaPointersEntry {
+	byte *vgaFile1;
+	byte *vgaFile2;
+	uint32 dd;
+};
+
+struct VgaSprite {
+	uint16 id;
+	uint16 image;
+	uint16 base_color;
+	uint16 x,y; /* actually signed numbers */
+	uint16 unk4,unk5,unk6,unk7;
+};
+
+struct VgaSleepStruct {
+	uint16 ident;
+	byte *code_ptr;
+	uint16 sprite_id;
+	uint16 cur_vga_file;
+};
+
+struct VgaTimerEntry {
+	uint16 delay;
+	byte *script_pointer;
+	uint16 sprite_id;
+	uint16 cur_vga_file;
+};
+
+struct VgaFile1Header {
+	uint16 x_1, x_2;
+	uint16 hdr2_start;
+	uint16 x_3, x_4;
+};
+
+struct VgaFile1Header2 {
+	uint16 x_1;
+	uint16 unk1;
+	uint16 x_2;
+	uint16 id_count;
+	uint16 x_3;
+	uint16 unk2_offs;
+	uint16 x_4;
+	uint16 id_table;
+	uint16 x_5;
+};
+
+struct VgaFile1Struct0x8 {
+	uint16 id;
+	uint16 x_1;
+	uint16 x_2;
+	uint16 script_offs;
+};
+
+struct VgaFile1Struct0x6 {
+	uint16 id;
+	uint16 x_2;
+	uint16 script_offs;
+};
+
+/* dummy typedefs to make it compile in *nix */
+#ifdef UNIX
+typedef void* HMIDISTRM;
+typedef void* HMIDIOUT;
+typedef uint32 UINT;
+typedef void* MIDIHDR;
+typedef uint32 MMRESULT;
+#define CALLBACK
+typedef uint32 DWORD;
+
+enum {
+	VK_F5 = 1,
+	VK_LBUTTON = 2,
+	VK_SHIFT = 3,
+
+};
+
+int GetAsyncKeyState(int key);
+
+#endif
+
+
+class MidiPlayer {
+public:
+	void read_all_songs(FILE *in);
+	void read_all_songs_old(FILE *in);
+	void initialize();
+	void shutdown();
+	void play();
+	
+private:
+	struct Track {
+		uint32 a;
+		uint32 data_size;
+		uint32 data_cur_size;
+		byte *data_ptr;
+		byte *data_cur_ptr;
+		uint32 delay;
+		byte last_cmd;
+	};
+
+	struct Song {
+		uint ppqn;
+		uint midi_format;
+		uint num_tracks;
+		Track *tracks;
+	};
+
+	struct MyMidiHdr {
+		MIDIHDR hdr;
+		uint32 a;
+		uint32 size;
+		uint32 b;
+		uint32 c;
+		uint32 d;
+	};
+
+	struct NoteRec {
+#ifdef WIN32
+		uint32 delay;
+		union {
+			struct {
+				byte cmd;
+				byte param_1;
+				byte param_2;
+			};
+			uint32 big_cmd;
+		};
+		uint cmd_length;
+		byte *sysex_data;
+#endif
+	};
+
+	enum {
+		NumPreparedHeaders = 2,
+	};
+
+	FILE *_input;
+
+	HMIDISTRM _midi_stream_handle;
+	UINT _midi_device_id;
+
+	uint _midi_var10, _midi_5;
+	bool _midi_var9;
+	byte _midi_var1;
+	bool _shutting_down;
+	uint _midi_var8;
+
+	uint _midi_var11;
+
+	uint _midi_num_sysex;
+
+	uint32 _midi_tempo;
+	
+	Track *_midi_tick_track_ptr;
+	Track *_midi_track_ptr;
+	int16 _midi_song_id;
+	int16 _midi_song_id_2;
+	int16 _midi_var2;
+
+	Song *_midi_cur_song_ptr;
+
+	NoteRec _midi_tmp_note_rec;
+	
+	uint32 _midi_volume_table[16];
+
+	Song _midi_songs[8];
+	MyMidiHdr _prepared_headers[NumPreparedHeaders];
+
+	void read_mthd(Song *s, bool old);
+
+	void read_from_file(void *dst, uint size);
+	void read_one_song(Song *s);
+	byte read_byte_from_file();
+	uint32 read_uint32_from_file();
+	uint16 read_uint16_from_file();
+
+	static uint32 track_read_gamma(Track *t);
+	static byte track_read_byte(Track *t);
+
+	static void check_error(MMRESULT result);
+
+	int fill(uint x, MyMidiHdr *mmh);
+	int fill_helper(NoteRec *nr, MyMidiHdr *mmh);
+
+	void reset_tracks();
+	void read_next_note(Track *t, NoteRec *nr);
+
+	static void CALLBACK midi_callback(HMIDIOUT hmo, UINT wMsg,
+		DWORD dwInstance, DWORD dwParam1, DWORD dwParam2);
+
+
+	void unload();
+	void unprepare();
+
+	void add_finished_hdrs();
+
+};
+
+
+struct GameSpecificSettings {
+	uint VGA_DELAY_BASE;
+	uint TABLE_INDEX_BASE;
+	uint TEXT_INDEX_BASE;
+	uint NUM_GAME_OFFSETS;
+	uint NUM_VIDEO_OP_CODES;
+	uint VGA_MEM_SIZE;
+	uint TABLES_MEM_SIZE;
+	uint NUM_VOICE_RESOURCES;
+	uint MUSIC_INDEX_BASE;
+	uint SOUND_INDEX_BASE;
+	const char *gme_filename;
+	const char *wav_filename;
+	const char *gamepc_filename;
+};
+
+
+class SimonState {
+public:
+	OSystem *_system;
+
+	byte *_vc_ptr; /* video code ptr */
+
+	uint32 *_game_offsets_ptr;
+
+	const GameSpecificSettings *gss;
+
+	byte _game;
+
+	enum {
+		GAME_SIMON2 = 1,
+		GAME_WIN = 2,
+
+		GAME_SIMON1DOS = 0,
+		GAME_SIMON1WIN = 2,
+		GAME_SIMON2DOS = 1,
+		GAME_SIMON2WIN = 3,
+	};
+
+
+	FILE *_game_file;
+	FILE *_voice_file;
+	uint32 *_voice_offsets;
+
+	byte *_stripped_txt_mem;
+	uint _text_size;
+	uint _stringtab_num, _stringtab_pos, _stringtab_numalloc;
+	byte **_stringtab_ptr;
+
+	Item **_itemarray_ptr;
+	uint _itemarray_size;
+	uint _itemarray_inited;
+
+	byte *_itemheap_ptr;
+	uint _itemheap_curpos;
+	uint _itemheap_size;
+
+	byte *_icon_file_ptr;
+
+	byte *_tbl_list;
+
+	byte *_code_ptr;
+
+	byte **_local_stringtable;
+	uint _string_id_local_min, _string_id_local_max;
+
+	byte *_tablesheap_ptr, *_tablesheap_ptr_org, *_tablesheap_ptr_new;
+	uint _tablesheap_size,_tablesheap_curpos,_tablesheap_curpos_org;
+	uint _tablesheap_curpos_new;
+
+	Subroutine *_subroutine_list, *_subroutine_list_org;
+
+	uint _dx_surface_pitch;
+
+	uint _recursion_depth;
+
+	uint32 _last_vga_tick;
+
+//#ifdef SIMON2
+	uint16 _op_189_flags;
+//#endif
+
+	bool _scriptvar_2;
+	bool _run_script_return_1;
+	bool _skip_vga_wait;
+	bool _no_parent_notify;
+	bool _vga_res_328_loaded;
+	bool _hitarea_unk_3;
+	bool _mortal_flag;
+	bool _sync_flag_1;
+	bool _video_var_8;
+	bool _use_palette_delay;
+	bool _sync_flag_2;
+	bool _hitarea_unk_6;
+	bool _in_callback;
+	bool _cepe_flag;
+	byte _copy_partial_mode;
+	bool _fast_mode;
+	bool _dx_use_3_or_4_for_lock;
+
+	bool _mouse_pos_changed;
+
+//#ifdef SIMON2
+	bool _vk_t_toggle;
+	byte _mouse_cursor;
+	bool _vga_var9;
+//#endif
+
+//#ifdef SIMON2
+	int16 _script_unk_1;
+	bool _vga_var6;
+	int _x_scroll,_vga_var1,_vga_var2,_vga_var3,_vga_var5;
+	byte _vga_var8;
+
+	uint16 _vc72_var1, _vc72_var2, _vc72_var3;
+	uint16 _vc70_var1, _vc70_var2;
+	byte *_vga_var7;
+//#else
+//	int _script_unk_1;
+//#endif
+
+	int16 _script_cond_a, _script_cond_b, _script_cond_c;
+
+	uint16 _fcs_unk_1;
+	FillOrCopyStruct *_fcs_ptr_1;
+
+	Item *_subject_item, *_object_item;
+	Item *_item_1_ptr, *_item_ptr_B;
+	Item *_item_1;
+
+	byte *_sfx_heap;
+
+	Item *_hitarea_object_item;
+	HitArea *_last_hitarea;
+	HitArea*_last_hitarea_2_ptr;
+	HitArea*_last_hitarea_3;
+	byte _left_button_down;
+	Item *_hitarea_subject_item;
+	HitArea *_hitarea_ptr_5, *_hitarea_ptr_7;
+	uint _need_hitarea_recalc;
+	uint _verb_hitarea;
+	uint16 _hitarea_unk_4;
+	uint _lock_counter;
+
+	uint16 _video_palette_mode;
+
+	uint _print_char_unk_1, _print_char_unk_2;
+	uint _num_letters_to_print;
+
+	uint _last_time;
+
+	TimeEvent *_first_time_struct, *_pending_delete_time_event;
+
+	uint _base_time;
+
+	uint _mouse_x, _mouse_y;
+	uint _mouse_x_old, _mouse_y_old;
+
+	Item _dummy_item_1;
+	Item _dummy_item_2;
+	Item _dummy_item_3;
+
+	uint16 _lock_word;
+	uint16 _scroll_up_hit_area;
+	uint16 _scroll_down_hit_area;
+
+	uint16 _video_var_7;
+	uint16 _palette_color_count;
+
+	byte _video_var_4;
+	bool _video_var_5;
+	bool _video_var_3;
+	bool _unk_pal_flag;
+	bool _exit_cutscene;
+	byte _video_var_9;
+
+	uint _last_music_played;
+
+	bool _show_preposition;
+	bool _showmessage_flag;
+
+	uint _video_num_pal_colors;
+
+	uint _invoke_timer_callback;
+
+	uint32 _voice_size;
+	
+	uint32 _sound_size;
+	byte *_sound_ptr;
+
+	uint _vga_sprite_changed;
+	
+	byte *_vga_buf_free_start, *_vga_buf_end, *_vga_buf_start;
+	byte *_vga_file_buf_org, *_vga_file_buf_org_2;
+
+	byte *_cur_vga_file_1;
+	byte *_cur_vga_file_2;
+
+	uint16 _timer_1, _timer_5, _timer_4;
+
+	uint16 _vga_base_delay;
+
+	uint16 _vga_cur_file_2;
+	uint16 _vga_wait_for, _vga_cur_file_id;
+	uint16 _vga_cur_sprite_id;
+
+	VgaTimerEntry *_next_vga_timer_to_process;
+	
+	Item *_vc_item_array[20];
+	Item *_item_array_6[20];
+
+	uint16 _stringid_array_2[20];
+	uint16 _stringid_array_3[20];
+	uint16 _array_4[20];
+
+	uint16 _bit_array[32];
+	int16 _variableArray[256];
+
+	FillOrCopyStruct *_fcs_ptr_array_3[8];
+
+	byte _fcs_data_1[8];
+	bool _fcs_data_2[8];
+
+	ThreeValues _threevalues_1, _threevalues_2, _threevalues_3, _threevalues_4;
+
+	int _free_string_slot;
+
+	byte _stringReturnBuffer[2][180];
+
+	HitArea _hit_areas[90];
+
+	VgaPointersEntry _vga_buffer_pointers[180];
+	VgaSprite _vga_sprites[180]; 
+	VgaSleepStruct _vga_sleep_structs[30];
+
+//	uint16 _unk21_word_array[32]; /* should be initialized to ones */
+
+	uint16 *_pathfind_array[20];
+
+	uint8 _palette_backup[1024];
+	uint8 _palette[1024];
+
+	byte _video_buf_1[3000];
+
+	VgaTimerEntry _vga_timer_list[95];
+
+	FillOrCopyStruct _fcs_list[16];
+
+	byte _letters_to_print_buf[80];
+
+	MidiPlayer midi;
+
+	int _num_screen_updates;
+	int _vga_tick_counter;
+
+	int _timer_id;
+
+	FILE *_dump_file;
+
+	int allocGamePcVars(FILE *in);
+	Item *allocItem1();
+	void loginPlayerHelper(Item *item, int a, int b);
+	void loginPlayer();
+	void allocateStringTable(int num);
+	void setupStringTable(byte *mem, int num);
+	void setupLocalStringTable(byte *mem, int num);
+	void readGamePcText(FILE *in);
+	void readItemChildren(FILE *in, Item *item, uint tmp);
+	void readItemFromGamePc(FILE *in, Item *item);
+	bool loadGamePcFile(const char *filename);
+
+	byte *allocateItem(uint size);
+	byte *allocateTable(uint size);
+
+	Child *findChildOfType(Item *i, uint child);
+	Child *allocateChildBlock(Item *i, uint type, uint size);
+
+	void allocItemHeap();
+	void allocTablesHeap();
+
+	Subroutine *createSubroutine(uint a);
+	void readSubroutine(FILE *in, Subroutine *sub);
+	SubroutineLine *createSubroutineLine(Subroutine *sub, int a);
+	void readSubroutineLine(FILE *in, SubroutineLine *new_table, Subroutine *sub);
+	byte *readSingleOpcode(FILE *in, byte *ptr);
+	void readSubroutineBlock(FILE *in);
+
+	Subroutine *getSubroutineByID(uint subroutine_id);
+
+	/* used in debugger */
+	void dumpSubroutines();
+	void dumpSubroutine(Subroutine *sub);
+	void dumpSubroutineLine(SubroutineLine *sl, Subroutine *sub);
+	byte *dumpOpcode(byte *p);
+
+	int startSubroutine(Subroutine *sub);
+	int startSubroutineEx(Subroutine *sub);
+
+	bool checkIfToRunSubroutineLine(SubroutineLine *sl, Subroutine *sub);
+
+	int runScript();
+
+	Item *getNextItemPtr();
+	uint getNextItemID();
+	uint getItem1ID() { return 1; }
+	Item *getItem1Ptr();
+	Item *getItemPtrB();
+
+	byte getByte();
+	int getNextWord();
+
+	uint getNextVarContents();
+	uint getVarOrWord();
+	uint getVarOrByte();
+	uint readVariable(uint variable);
+	void writeNextVarContents(uint16 contents);
+	void writeVariable(uint variable, uint16 contents);
+
+	void setItemParent(Item *item, Item *parent);
+
+	uint itemPtrToID(Item *id);
+
+	Item *derefItem(uint item);
+	void setItemUnk3(Item *item, int value);
+
+	void showMessageFormat(const char *s, ...);
+	const byte *getStringPtrByID(uint string_id);
+	const byte *getLocalStringByID(uint string_id);
+	uint getNextStringID();
+
+	void addTimeEvent(uint timeout, uint subroutine_id);
+	void delTimeEvent(TimeEvent *te);
+
+	bool hasChildOfType1(Item *item);
+	bool hasChildOfType2(Item *item);
+
+	Child1 *findChildOfType1(Item *item);
+	Child2 *findChildOfType2(Item *item);
+	Child3 *findChildOfType3(Item *item);
+
+	void itemChildrenChanged(Item *item);
+	void unlinkItem(Item *item);
+	void linkItem(Item *item, Item *parent);
+
+	bool o_unk_23(uint a);
+
+	void o_unk_99_simon1(uint a);
+	void o_unk_99_simon2(uint a, uint b);
+
+	void o_vga_reset();
+	void o_unk_101();
+	void fcs_unk_2(uint a);
+	void o_unk_103();
+	void fcs_delete(uint a);
+	void o_unk_108(uint a);
+	void clear_hitarea_bit_0x40(uint hitarea);
+	void set_hitarea_bit_0x40(uint hitarea);
+	void set_hitarea_x_y(uint hitarea, int x, int y);
+	bool is_hitarea_0x40_clear(uint hitarea);
+	void delete_hitarea(uint hitarea);
+	void addNewHitArea(int id, int x, int y, int width, int height, 
+		int flags, int unk3,Item *item_ptr);
+	HitArea *findEmptyHitArea();
+	void hitarea_proc_1();
+	void handle_verb_hitarea(HitArea *ha);
+	void hitarea_leave(HitArea *ha);
+	void leaveHitAreaById(uint hitarea_id);
+
+	void o_unk_114();
+	void o_wait_for_vga(uint a);
+	void o_unk_120(uint a);
+	void o_unk_126();
+	void o_unk_127();
+	void o_save_game();
+	void o_load_game();
+	void o_unk_137(uint a);
+	void o_unk_138();
+	void killAllTimers();
+	
+	uint getOffsetOfChild2Param(Child2 *child, uint prop);
+	void o_unk_160(uint a);
+	void o_unk_163(uint a);
+	void o_unk_175();
+	void o_unk_176();
+	void o_pathfind(int x,int y,uint var_1,uint var_2);
+	void o_unk_179();
+	void o_force_unlock();
+	void o_force_lock();
+	void o_read_vgares_328();
+	void o_read_vgares_23();
+	void o_clear_vgapointer_entry(uint a);
+	void o_unk_186();
+	void o_fade_to_black();
+	void o_print_str();
+	void o_setup_cond_c();
+	void setup_cond_c_helper();
+
+	void o_177();
+
+	void lock();
+	void unlock();
+
+	void fcs_unk_proc_1(uint i, Item *item_ptr, int unk1, int unk2);
+
+	void loadTextIntoMem(uint string_id);
+	void loadTablesIntoMem(uint subr_id);
+
+
+	uint loadTextFile(const char *filename, byte *dst);
+	FILE *openTablesFile(const char *filename);
+	void closeTablesFile(FILE *in);
+
+	uint loadTextFile_simon1(const char *filename, byte *dst);
+	FILE *openTablesFile_simon1(const char *filename);
+	void closeTablesFile_simon1(FILE *in);
+
+	uint loadTextFile_gme(const char *filename, byte *dst);
+	FILE *openTablesFile_gme(const char *filename);
+	void closeTablesFile_gme(FILE *in);
+
+	void readSfxFile(const char *filename);
+
+	void invokeTimeEvent(TimeEvent *te);
+	bool kickoffTimeEvents();
+
+	void defocusHitarea();
+	void startSubroutine170();
+	void runSubroutine101();
+	void handle_unk2_hitarea(FillOrCopyStruct *fcs);
+	void handle_unk_hitarea(FillOrCopyStruct *fcs);
+	void hitareaChangedHelper();
+	void focusVerb(uint hitarea_id);
+	HitArea *findHitAreaByID(uint hitarea_id);
+
+	void showActionString(uint x, const byte *string);
+	void video_putchar(FillOrCopyStruct *fcs, byte c);
+	void video_fill_or_copy_from_3_to_2(FillOrCopyStruct *fcs);
+	void video_toggle_colors(HitArea *ha, byte a, byte b, byte c, byte d);
+
+	void read_vga_from_datfile_1(uint vga_id);
+
+	uint get_fcs_ptr_3_index(FillOrCopyStruct *fcs);
+
+	void setup_hitarea_from_pos(uint x, uint y, uint mode);
+	void new_current_hitarea(HitArea *ha);
+	bool hitarea_proc_2(uint a);
+	bool hitarea_proc_3(Item *item);
+	void hitarea_stuff();
+
+	void handle_mouse_moved();
+	void pollMouseXY();
+	void draw_mouse_pointer();
+
+	void fcs_unk1(uint fcs_index);
+	void draw_icon_c(FillOrCopyStruct *fcs, uint icon, uint x, uint y);
+	bool has_item_childflag_0x10(Item *item);
+	uint item_get_icon_number(Item *item);
+	uint setup_icon_hit_area(FillOrCopyStruct *fcs,uint x, uint y, uint icon_number, Item *item_ptr);
+	void fcs_unk_proc_2(FillOrCopyStruct *fcs, uint fcs_index);
+
+	void loadIconFile();
+	void processSpecialKeys();
+	void hitarea_stuff_helper();
+
+	void startUp(uint a);
+	void startUp_helper_2();
+	void startUp_helper_3();
+	void startUp_helper();
+	void showmessage_helper_3(uint a, uint b);
+	void showmessage_print_char(byte chr);
+
+	void handle_verb_clicked(uint verb);
+
+	void o_set_video_mode(uint mode, uint vga_res);
+	void set_video_mode(uint a, uint b);
+	void set_video_mode_internal(uint mode, uint vga_res_id);
+	
+	void ensureVgaResLoadedC(uint vga_res);
+	void ensureVgaResLoaded(uint vga_res);
+
+	void start_vga_code(uint b, uint vga_res, uint vga_struct_id, uint c, uint d, uint f);
+	void o_unk26_helper(uint a, uint b, uint c, uint d, uint e, uint f, uint g, uint h);
+	void talk_with_speech(uint speech_id, uint num_1);
+	void talk_with_text(uint num_1, uint num_2, const char *string_ptr, uint a, int b, uint c);
+	FillOrCopyStruct *fcs_alloc(uint x, uint y, uint w, uint h, uint flags, uint fill_color, uint unk4);
+	
+	void render_string(uint num_1, uint color, uint width, uint height, const char *txt);
+
+	void setup_hit_areas(FillOrCopyStruct *fcs, uint fcs_index);
+
+	byte *setup_vga_destination(uint32 size);
+	void vga_buf_unk_proc3(byte *end);
+	void vga_buf_unk_proc1(byte *end);
+	void vga_buf_unk_proc2(uint a,byte *end);
+	void delete_memptr_range(byte *end);
+
+	void setup_vga_file_buf_pointers();
+
+	void run_vga_script();
+
+	void vc_1();
+	void vc_2();
+	void vc_3();
+	void vc_4();
+	void vc_5();
+	void vc_6_maybe_skip_3_inv();
+	void vc_7_maybe_skip_3();
+	void vc_8_maybe_skip_2();
+	void vc_9_maybe_skip();
+	void vc_10();
+	void vc_11_clear_pathfind_array();
+	void vc_12_sleep_variable();
+	void vc_13_offset_x();
+	void vc_14_offset_y();
+	void vc_15_start_funkystruct_by_id();
+	void vc_16_setup_funkystruct();
+	void vc_17_set_pathfind_item();
+	void vc_18_jump_rel();
+	void vc_19();
+	void vc_20();
+	void vc_21();
+	void vc_22();
+	void vc_23_set_pri();
+	void vc_24_set_image_xy();
+	void vc_25_del_sprite_and_get_out();
+	void vc_26();
+	void vc_27_reset();
+	void vc_27_reset_simon1();
+	void vc_27_reset_simon2();
+	void vc_28();
+	void vc_29_stop_all_sounds();
+	void vc_30_set_base_delay();
+	void vc_31_set_palette_mode();
+	void vc_32_copy_var();
+	void vc_33();
+	void vc_34();
+	void vc_35();
+	void vc_36();
+	void vc_37_sprite_unk3_add();
+	void vc_38_skip_if_var_zero();
+	void vc_39_set_var();
+	void vc_40_var_add();
+	void vc_41_var_sub();
+	void vc_42_delay_if_not_eq();
+	void vc_43_skip_if_bit_clear();
+	void vc_44_skip_if_bit_set();
+	void vc_45_set_x();
+	void vc_46_set_y();
+	void vc_47_add_var_f();
+	void vc_48();
+	void vc_49_set_bit();
+	void vc_50_clear_bit();
+	void vc_51_clear_hitarea_bit_0x40();
+	void vc_52();
+	void vc_53_no_op();
+	void vc_54_no_op();
+	void vc_55_offset_hit_area();
+	void vc_56_no_op();
+	void vc_57_no_op();
+	void vc_59();
+	void vc_60();
+	void vc_61_sprite_change();
+	void vc_62();
+	void vc_63();
+
+//#ifdef SIMON2
+	void vc_64();
+	void vc_65();
+	void vc_66();
+	void vc_67();
+	void vc_68();
+	void vc_69();
+	void vc_70();
+	void vc_71();
+	void vc_72();
+	void vc_73();
+	void vc_74();
+//#endif
+
+	void delete_vga_timer(VgaTimerEntry *vte);
+	void vc_resume_thread(byte *code_ptr, uint16 cur_file, uint16 cur_sprite);
+	int vc_read_var_or_word(void *ptr);
+	uint vc_read_next_word();
+	uint vc_read_next_byte();
+	uint vc_read_var(uint var);
+	void vc_write_var(uint var, int16 value);
+	void vc_skip_next_instruction();
+
+	bool vc_maybe_skip_proc_3(uint16 val);
+	bool vc_maybe_skip_proc_2(uint16 a, uint16 b);
+	bool vc_maybe_skip_proc_1(uint16 a, int16 b);
+
+	void add_vga_timer(uint num, byte *code_ptr, uint cur_sprite, uint cur_file);
+	VgaSprite *find_cur_sprite();
+	void vc_set_bit_to(uint bit, bool value);
+
+	bool vc_59_helper();
+	void expire_vga_timers();
+
+	bool has_vgastruct_with_id(uint16 id, uint16 file);
+
+	bool vc_get_bit(uint bit);
+
+	void fcs_proc_1(FillOrCopyStruct *fcs, uint value);
+
+	void video_copy_if_flag_0x8_c(FillOrCopyStruct *fcs);
+	void delete_hitarea_by_index(uint index);
+
+	void fcs_unk_5(FillOrCopyStruct *fcs, uint fcs_index);
+	void fcs_putchar(uint a);
+
+	void copy_img_from_3_to_2(FillOrCopyStruct *fcs);
+	void video_erase(FillOrCopyStruct *fcs);
+
+	void dx_copy_rgn_from_3_to_2(uint b, uint r, uint y, uint x);
+
+	byte *dx_lock_2();
+	void dx_unlock_2();
+
+	byte *dx_lock_attached();
+	void dx_unlock_attached();
+
+	byte *read_vga_from_datfile_2(uint id);
+
+	void resfile_read(void *dst, uint32 offs, uint32 size);
+
+	void go(OSystem *syst);
+	void openGameFile();
+
+	static int CDECL game_thread_proc(void *param);
+
+	void timer_callback();
+	void timer_proc1();
+
+	void timer_vga_sprites();
+	void timer_vga_sprites_2();
+
+	void dx_clear_surfaces(uint num_lines);
+	void dx_update_screen_and_palette();
+
+	void dump_video_script(byte *src, bool one_opcode_only);
+	void dump_vga_file(byte *vga);
+	void dump_vga_bitmaps(byte *vga, byte *vga1, int res);
+	void dump_single_bitmap(int file, int image, byte *offs, int w, int h, byte base);
+	
+	void dx_clear_attached_from_top(uint lines);
+	void dx_copy_from_attached_to_2(uint x, uint y, uint w, uint h);
+	void dx_copy_from_attached_to_3(uint lines);
+
+	void print_char_helper_1(const byte *src, uint len);
+	void print_char_helper_5(FillOrCopyStruct *fcs);
+
+	void shutdown();
+
+	byte *vc_10_depack_swap(byte *src, uint w, uint h);
+
+	void dump_vga_script(byte *ptr, uint res, uint sprite_id);
+	void dump_vga_script_always(byte *ptr, uint res, uint sprite_id);
+
+	Item *getNextItemPtrStrange();
+
+	bool save_game(uint slot, const char *caption);
+	bool load_game(uint slot);
+
+	void showmessage_helper_2();
+	void print_char_helper_6(uint i);
+
+	void video_putchar_helper(FillOrCopyStruct *fcs);
+	void video_putchar_helper_2(FillOrCopyStruct *fcs, uint x, uint y, byte chr);
+
+	void initSound();
+	void playVoice(uint voice);
+	void playSound(uint sound);
+
+	void generateSound(byte *ptr, int len);
+
+	void playMusic(uint music);
+
+	void checkTimerCallback();
+
+	void delay(uint delay);
+
+//#ifdef SIMON2
+	void o_190_helper(uint i);
+	void vc_58();
+	void timer_vga_sprites_helper();
+
+	void vc_10_helper_8(byte *dst, byte *src);
+	void scroll_timeout();
+	void hitarea_stuff_helper_2();
+//#endif
+	void realizePalette();
+
+	void vc_kill_thread(uint file, uint sprite);
+
+	static SimonState *create();
+
+	void set_dummy_cursor();
+};
+
+	
+void NORETURN CDECL error(const char *errmsg, ...);
+void CDECL warning(const char *errmsg, ...);
+
+uint16 swap16(uint16 a);
+uint32 swap32(uint32 a);
+
+
+void _2xSaI (uint8 *srcPtr, uint32 srcPitch, uint8 *deltaPtr, uint8 *dstPtr, uint32 dstPitch, int width, int height);
+int Init_2xSaI (uint32 BitFormat);
+void Super2xSaI (uint8 *srcPtr, uint32 srcPitch,
+		 uint8 *deltaPtr, uint8 *dstPtr, uint32 dstPitch,
+		 int width, int height);
+void initializeHardware();
+void dx_set_palette(uint32 *colors, uint num);
+
+//extern byte *sdl_buf;
+//extern byte *sdl_buf_attached;
diff --git a/simon/simonsys.cpp b/simon/simonsys.cpp
new file mode 100644
index 0000000000..b0bfff7722
--- /dev/null
+++ b/simon/simonsys.cpp
@@ -0,0 +1,130 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+
+#include "stdafx.h"
+#include "scummsys.h"
+#include "system.h"
+#include "simon.h"
+
+#include <stdarg.h>
+
+#ifdef WIN32
+#include <conio.h>
+#endif
+
+uint16 swap16(uint16 a) {
+	return (a>>8)|(a<<8);
+}
+
+uint32 swap32(uint32 a) {
+	return (a>>24)|(a>>8)&0xFF00|(a<<8)&0xFF0000|(a<<24);
+}
+
+
+uint fileReadByte(FILE *in) {
+	byte b;
+	fread(&b, sizeof(b), 1, in);
+	return b;
+}
+
+uint fileReadBE16(FILE *in) {
+	byte b[2];
+	fread(b, sizeof(b), 1, in);
+	return (b[0]<<8) | b[1];
+}
+
+uint fileReadLE16(FILE *in) {
+	byte b[2];
+	fread(b, sizeof(b), 1, in);
+	return (b[1]<<8) | b[0];
+}
+
+uint32 fileReadBE32(FILE *in) {
+	byte b[4];
+	fread(b, sizeof(b), 1, in);
+	return (b[0]<<24)|(b[1]<<16)|(b[2]<<8)|b[3];
+}
+
+uint32 fileReadLE32(FILE *in) {
+	byte b[4];
+	fread(b, sizeof(b), 1, in);
+	return (b[3]<<24)|(b[2]<<16)|(b[1]<<8)|b[0];
+}
+
+
+void fileWriteBE32(FILE *in, uint32 value) {
+	value = swap32(value);	
+	fwrite(&value, sizeof(value), 1, in);
+}
+
+void fileWriteBE16(FILE *in, uint16 value) {
+	value = swap16(value);
+	fwrite(&value, sizeof(value), 1, in);
+}
+
+
+
+#if 0
+void NORETURN CDECL error(const char *s, ...) {
+	char buf[1024];
+	va_list va;
+
+	va_start(va, s);
+	vsprintf(buf, s, va);
+	va_end(va);
+#ifdef WIN32
+	fprintf(stderr, "Error: %s!\nPress a key to quit.\n", buf);
+	_getch();
+#else
+	fprintf(stderr, "Error: %s!\n", buf);
+#endif
+	exit(1);
+
+}
+
+void CDECL warning(const char *s, ...) {
+	char buf[1024];
+	va_list va;
+
+	va_start(va, s);
+	vsprintf(buf, s, va);
+	va_end(va);
+	fprintf(stdout, "Warning: %s!\n", buf);
+}
+#endif
+
+
+/* Dummy midiplayer for unix */
+#ifdef UNIX
+void MidiPlayer::shutdown() {}
+void MidiPlayer::read_all_songs(FILE *in) {}
+void MidiPlayer::initialize() {}
+void MidiPlayer::play() {}
+
+
+/* GetAsyncKeyState for unix */
+int GetAsyncKeyState(int key) {
+	return 0;
+}
+
+
+#endif
\ No newline at end of file