GLK: MAGNETIC: Added subengine files

11 files changed, 9685 insertions, 915 deletions

diff --git a/engines/glk/magnetic/defs.h b/engines/glk/magnetic/defs.h
new file mode 100644
index 0000000000..b448200b72
--- /dev/null
+++ b/engines/glk/magnetic/defs.h
@@ -0,0 +1,471 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef MAGNETIC_DEFS_H
+#define MAGNETIC_DEFS_H
+
+#include "common/scummsys.h"
+#include "glk/magnetic/magnetic_types.h"
+
+namespace Glk {
+namespace Magnetic {
+
+/*****************************************************************************\
+* Type definitions for Magnetic
+*
+* Note: When running into trouble please ensure that these types have the
+*       correct number of bits on your system !!!
+\*****************************************************************************/
+
+typedef byte type8;
+typedef int8 type8s;
+typedef uint16 type16;
+typedef int16 type16s;
+typedef uint32 type32;
+typedef int32 type32s;
+
+/****************************************************************************\
+* Compile time switches
+\****************************************************************************/
+
+/* Switch:  SAVEMEM
+   Purpose: Magnetic loads a complete graphics file into memory by default.
+            Setting this switch you tell Magnetic to load images on request
+            (saving memory, wasting load time)
+
+#define SAVEMEM
+*/
+
+/* Switch:  NO_ANIMATION
+   Purpose: By default Magnetic plays animated graphics.
+            Setting this switch to ignore animations, Magnetic shows the
+            static parts of the images anyway!
+
+#define NO_ANIMATION
+*/
+
+/****************************************************************************\
+* Abstract functions
+*
+* Note: These functions MUST be implemented by each port of Magnetic!
+\****************************************************************************/
+
+/****************************************************************************\
+* Function: ms_load_file
+*
+* Purpose: Load a save game file and restore game
+*
+* Parameters:   type8s* name            zero terminated string of filename
+*                                       typed by player
+*               type8*  ptr             pointer to data to save
+*               type16 size             number of bytes to save
+*
+* Result: 0 is successful
+*
+* Note: You probably want to put in a file requester!
+\****************************************************************************/
+
+extern type8 ms_load_file(const char *name, type8 *ptr, type16 size);
+
+/****************************************************************************\
+* Function: ms_save_file
+*
+* Purpose: Save the current game to file
+*
+* Parameters:   type8s* name            zero terminated string of filename
+*                                       typed by player
+*               type8*  ptr             pointer to data to save
+*               type16  size            number of bytes to save
+*
+* Result: 0 is successful
+*
+* Note: You probably want to put in a file requester!
+\****************************************************************************/
+
+extern type8 ms_save_file(const char *name, type8 *ptr, type16 size);
+
+/****************************************************************************\
+* Function: ms_statuschar
+*
+* Purpose: Output a single character to the status bar
+*
+* Parameters:   type8   c               character to be printed
+*
+* Note: All characters are printed as provided except for:
+*       0x0A resets the x position to zero
+*       0x09 moves the cursor to the right half of the bar, ie 'width-11'
+\****************************************************************************/
+
+extern void ms_statuschar(type8 c);
+
+/****************************************************************************\
+* Function: ms_putchar
+*
+* Purpose: Output a single character to the game/text windows
+*
+* Parameters:   type8   c               character to be printed
+*
+* Note: It is highly recommended to buffer the output, see also ms_flush()
+\****************************************************************************/
+
+extern void ms_putchar(type8 c);
+
+/****************************************************************************\
+* Function: ms_flush
+*
+* Purpose: Flush the output buffer (if applicable)
+*
+* Note: see also ms_putchar
+\****************************************************************************/
+
+extern void ms_flush(void);
+
+/****************************************************************************\
+* Function: ms_getchar
+*
+* Purpose: Read user input, buffered
+*
+* Parameters:   type8   trans           if not 0, translate any #undo
+*                                       input to a return code of 0
+*
+* Return: One character
+*
+* Note: The first time it is called a string should be read and then given
+*       back one byte at a time (ie. one for each call) until a '\n' is
+*       reached (which will be the last byte sent back before it all restarts)
+*       Returning a zero means 'undo' and the rest of the line must then be
+*       ignored.
+*       Returning 1 means that the opcode should return immediately. This is
+*       needed to prevent possible corruption of the game's memory in
+*       interpreters which allow a new game to be loaded without restarting.
+\****************************************************************************/
+
+extern type8 ms_getchar(type8 trans);
+
+/****************************************************************************\
+* Function: ms_showpic
+*
+* Purpose: Displays or hides a picture
+*
+* Parameter:    type32  c       number of image to be displayed
+*               type8   mode    mode == 0 means gfx off,
+*                               mode == 1 gfx on thumbnails,
+*                               mode == 2 gfx on normal.
+*
+* Note: For retrieving the raw data of a picture call ms_extract (see below)
+\****************************************************************************/
+
+extern void ms_showpic(type32 c, type8 mode);
+
+/****************************************************************************\
+* Function: ms_fatal
+*
+* Purpose: Handle fatal interpreter error
+*
+* Parameter:    type8s* txt     message
+\****************************************************************************/
+
+extern void ms_fatal(const char *txt);
+
+/****************************************************************************\
+* Magnetic core functions
+*
+* Note: These functions SHOULD be used somewhere in your port!
+\****************************************************************************/
+
+/****************************************************************************\
+* Function: ms_extract
+*
+* Purpose: Extract a picture and return a pointer to a raw bitmap
+*
+* Parameters:   type32  c               number of the picture
+*               type16* w               width of picture
+*               type16* h               height pf picture
+*               type16* pal             array for the palette (16 colours)
+*               type8*  is_anim         1 if animated picture, otherwise 0
+*                                       OR null (!)
+*
+* Return: Pointer to bitmap data if successful, otherwise null (also if gfx
+*         are disabled!)
+*
+* Note: All pictures have 16 colours and the palette entries use 3-bit RGB
+*       encoded as 00000RRR0GGG0BBB, that is, bits 0-2 give the blue
+*       component, bits 4-6 the green and bits 8-10 the red. The bitmap is
+*       one byte per pixel, with each byte giving the pixel's index into the
+*       palette. The data is given starting from the upper left corner. The
+*       image buffer is reused when the next picture is requested, so take
+*       care! More information on animated pictures are below!
+\****************************************************************************/
+
+extern type8 *ms_extract(type32 c, type16 *w, type16 *h, type16 *pal, type8 *is_anim);
+
+/****************************************************************************\
+* Magnetic animated pictures support
+*
+* Note: Some of the pictures for Wonderland and the Collection Volume 1 games
+* are animations. To detect these, pass a pointer to a type8 as the is_anim
+* argument to ms_extract().
+*
+* There are two types of animated images, however almost all images are type1.
+* A type1 image consists of four main elements:
+* 1) A static picture which is loaded straight at the beginning
+* 2) A set of frames with a mask. These frames are just "small pictures", which
+*    are coded like the normal static pictures. The image mask determines
+*    how the frame is removed after it has been displayed. A mask is exactly
+*    1/8 the size of the image and holds 1 bit per pixel, saying "remove pixel"
+*    or leave pixel set when frame gets removed. It might be a good idea to check
+*    your system documentation for masking operations as your system might be
+*    able to use this mask data directly.
+* 3) Positioning tables. These hold animation sequences consisting of commands
+*    like "Draw frame 12 at (123,456)"
+* 4) A playback script, which determines how to use the positioning tables.
+*    These scripts are handled inside Magnetic, so no need to worry about.
+*    However, details can be found in the ms_animate() function.
+*
+* A type2 image is like a type1 image, but it does not have a static
+* picture, nor does it have frame masking. It just consists of frames.
+*
+* How to support animations?
+* After getting is_anim == 1 you should call ms_animate() immediately, and at
+* regular intervals until ms_animate() returns 0. An appropriate interval
+* between calls is about 100 milliseconds.
+* Each call to ms_animate() will fill in the arguments with the address
+* and size of an array of ms_position structures (see below), each of
+* which holds an an animation frame number and x and y co-ordinates. To
+* display the animation, decode all the animation frames (discussed below)
+* from a single call to ms_animate() and display each one over the main picture.
+* If your port does not support animations, define NO_ANIMATION.
+\****************************************************************************/
+
+/****************************************************************************\
+* Function: ms_animate
+*
+* Purpose: Generate the next frame of an animation
+*
+* Parameters:   ms_position**   positions  array of ms_position structs
+*               type16*         count      size of array
+*
+* Return: 1 if animation continues, 0 if animation is finfished
+*
+* Note: The positions array holds size ms_positions structures. BEFORE calling
+*       ms_animate again, retrieve the frames for all the ms_positions
+*       structures with ms_get_anim_frame and display each one on the static
+*       main picture.
+\****************************************************************************/
+
+extern type8 ms_animate(struct ms_position **positions, type16 *count);
+
+/****************************************************************************\
+* Function: ms_get_anim_frame
+*
+* Purpose: Extracts the bitmap data of a single animation frame
+*
+* Parameters:   type16s   number        number of frame (see ms_position struct)
+*               type16*   width         width of frame
+*               type16*   height        height of frame
+*               type8**   mask          pointer to masking data, might be NULL
+*
+* Return: 1 if animation continues, 0 if animation is finfished
+*
+* Note: The format of the frame is identical to the main pictures' returned by
+*       ms_extract. The mask has one-bit-per-pixel, determing how to handle the
+*       removal of the frame.
+\****************************************************************************/
+
+extern type8 *ms_get_anim_frame(type16s number, type16 *width, type16 *height, type8 **mask);
+
+/****************************************************************************\
+* Function: ms_anim_is_repeating
+*
+* Purpose: Detects whether an animation is repeating
+*
+* Return: True if repeating
+\****************************************************************************/
+
+extern type8 ms_anim_is_repeating(void);
+
+/****************************************************************************\
+* Magnetic Windows hint support
+*
+* The windowed Magnetic Scolls games included online hints. To add support
+* for the hints to your magnetic port, you should implement the ms_showhints
+* function. It retrieves a pointer to an array of ms_hint structs
+* The root element is always hints[0]. The elcount determines the number
+* of items in this topic. You probably want to display those in some kind
+* of list interface. The content pointer points to the actual description of
+* the items, separated by '\0' terminators. The nodetype is 1 if the items are
+* "folders" and 2 if the items are hints. Hints should be displayed one after
+* another. For "folder" items, the links array holds the index of the hint in
+* the array which is to be displayed on selection. One hint block has exactly
+* one type. The parent element determines the "back" target.
+\****************************************************************************/
+
+/****************************************************************************\
+* Function: ms_showhints
+* Purpose: Show the player a hint
+*
+* Parameters:   ms_hint* hints          pointer to array of ms_hint structs
+*
+* Return: 0 on error, 1 on success
+\****************************************************************************/
+
+extern type8 ms_showhints(struct ms_hint *hints);
+
+/****************************************************************************\
+* Magnetic Windows sound support
+*
+* Wonderland contains music scores that are played when entering specific
+* locations in the game. The music data are actually MIDI events and can be
+* played through normal MIDI devices. The original game plays the MIDI score
+* until the end, even if the location is changed while playing. The playback
+* tempo is not included with the MIDI data. The ms_sndextract function
+* returns a recommended tempo, however depending on the MIDI implementation
+* and operating system, you might need to adapt it.
+\****************************************************************************/
+
+/****************************************************************************\
+* Function: ms_playmusic
+*
+* Purpose: Plays (or stops playing) a MIDI music score.
+*
+* Parameter:    type8 * midi_data       the MIDI data to play
+*               type32  length          the length of the MIDI data
+*               type16  tempo           the suggested tempo for playing
+*
+* Note: If midi_data is NULL, all that should happen is that any currently
+* playing music is stopped.
+* Note: The data returned contain a complete MIDI file header, so if pure
+*       memory processing is not applicable you can write the data to a
+*       temporary file and use external players or libraries.
+\****************************************************************************/
+
+extern void ms_playmusic(type8 *midi_data, type32 length, type16 tempo);
+
+/****************************************************************************\
+* Function: ms_init
+*
+* Purpose: Loads the interpreter with a game
+*
+* Parameters:   type8s* name            filename of story file
+*               type8s* gfxname         filename of graphics file (optional)
+*               type8s* hntname         filename of hints file (optional)
+*               type8s* sndname         filename of music file (optional)
+*
+* Return:       0 = failure
+*               1 = success (without graphics or graphics failed)
+*               2 = success (with graphics)
+*
+* Note: You must call this function before starting the ms_rungame loop
+\****************************************************************************/
+
+extern type8 ms_init(const char *name, const char *gfxname, const char *hntname, const char *sndname);
+
+/****************************************************************************\
+* Function: ms_rungame
+*
+* Purpose: Executes an interpreter instruction
+*
+* Return: True if successful
+*
+* Note: You must call this function in a loop like this:
+*       while (running) {running=ms_rungame();}
+\****************************************************************************/
+
+extern type8 ms_rungame(void);
+
+/****************************************************************************\
+* Function: ms_freemen
+*
+* Purpose: Frees all allocated ressources
+\****************************************************************************/
+
+extern void ms_freemem(void);
+
+/****************************************************************************\
+* Function: ms_seed
+*
+* Purpose: Initializes the interpreter's random number generator with
+*          the given seed
+*
+* Parameter:    type32  seed    seed
+\****************************************************************************/
+
+extern void ms_seed(type32 seed);
+
+/****************************************************************************\
+* Function: ms_is_running
+*
+* Purpose: Detects if game is running
+*
+* Return: True, if game is currently running
+\****************************************************************************/
+
+extern type8 ms_is_running(void);
+
+/****************************************************************************\
+* Function: ms_is_magwin
+*
+* Purpose: Detects Magnetic Windows games (Wonderland, Collection)
+*
+* Return: True, if Magnetic Windows game
+\****************************************************************************/
+
+extern type8 ms_is_magwin(void);
+
+/****************************************************************************\
+* Function: ms_stop
+*
+* Purpose: Stops further processing of opcodes
+\****************************************************************************/
+
+extern void ms_stop(void);
+
+/****************************************************************************\
+* Function: ms_status
+*
+* Purpose: Dumps interperetr state to stderr, ie. registers
+\****************************************************************************/
+
+extern void ms_status(void);
+
+/****************************************************************************\
+* Function: ms_count
+*
+* Purpose: Returns the number of executed intructions
+*
+* Return:  Instruction count
+\****************************************************************************/
+
+extern type32 ms_count(void);
+
+extern void write(const char *fmt, ...);
+
+extern void writeChar(char c);
+
+extern int gms_startup_code(int argc, char *argv[]);
+
+extern void gms_main();
+
+} // End of namespace Magnetic
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/magnetic/emu.cpp b/engines/glk/magnetic/emu.cpp
index 1d63f5944a..fe6c66c53d 100644
--- a/engines/glk/magnetic/emu.cpp
+++ b/engines/glk/magnetic/emu.cpp
@@ -20,21 +20,336 @@
  *
  */
 
-#include "glk/magnetic/magnetic.h"
+#include "glk/magnetic/defs.h"
+#include "common/file.h"
 
 namespace Glk {
 namespace Magnetic {
 
-//static const char *no_hints = "[Hints are not available.]\n";
-//static const char *not_supported = "[This function is not supported.]\n";
+type32 dreg[8], areg[8], i_count, string_size, rseed = 0, pc, arg1i, mem_size;
+type16 properties, fl_sub, fl_tab, fl_size, fp_tab, fp_size;
+type8 zflag, nflag, cflag, vflag, byte1, byte2, regnr, admode, opsize;
+type8 *arg1, *arg2, is_reversible, running = 0, tmparg[4] = {0, 0, 0, 0};
+type8 lastchar = 0, version = 0, sd = 0;
+type8 *decode_table, *restart = 0, *code = 0, *string = 0, *string2 = 0;
+type8 *string3 = 0, *dict = 0;
+type8 quick_flag = 0, gfx_ver = 0, *gfx_buf = nullptr, *gfx_data = 0;
+type8 *gfx2_hdr = 0, *gfx2_buf = nullptr;
+const char *gfx2_name = nullptr;
+type16 gfx2_hsize = 0;
+Common::File *gfx_fp = nullptr;
+type8 *snd_buf = nullptr, *snd_hdr = nullptr;
+type16 snd_hsize = 0;
+Common::File *snd_fp = nullptr;
 
-int Magnetic::ms_init(bool restarting) {
-	byte header[42];
-	uint32 i, j, dict_size, string2_size, code_size, dec;
+const char *const undo_ok = "\n[Previous turn undone.]";
+const char *const undo_fail = "\n[You can't \"undo\" what hasn't been done!]";
+type32 undo_regs[2][18], undo_pc, undo_size;
+type8 *undo[2] = {0, 0}, undo_stat[2] = {0, 0};
+type16 gfxtable = 0, table_dist = 0;
+type16 v4_id = 0, next_table = 1;
 
-	ms_stop();
+#ifndef NO_ANIMATION
+
+struct picture anim_frame_table[MAX_ANIMS];
+type16 pos_table_size = 0;
+type16 pos_table_count[MAX_POSITIONS];
+struct ms_position pos_table[MAX_POSITIONS][MAX_ANIMS];
+type8 *command_table = 0;
+type16s command_index = -1;
+struct lookup anim_table[MAX_POSITIONS];
+type16s pos_table_index = -1;
+type16s pos_table_max = -1;
+struct ms_position pos_array[MAX_FRAMES];
+type8 anim_repeat = 0;
+
+#endif
+
+/* Hint support */
+struct ms_hint *hints = 0;
+type8 *hint_contents = 0;
+const char *const no_hints = "[Hints are not available.]\n";
+const char *const not_supported = "[This function is not supported.]\n";
+
+#if defined(LOGEMU) || defined(LOGGFX) || defined(LOGHNT)
+FILE *dbg_log;
+#ifndef LOG_FILE
+#error LOG_FILE must be defined to be the name of the log file.
+#endif
+#endif
+
+/* prototypes */
+type32 read_reg(int, int);
+void write_reg(int, int, type32);
+
+#define MAX_STRING_SIZE  0xFF00
+#define MAX_PICTURE_SIZE 0xC800
+#define MAX_MUSIC_SIZE   0x4E20
+
+#ifdef LOGEMU
+void out(char *format, ...) {
+	va_list a;
+
+	va_start(a, format);
+	vfprintf(dbg_log, format, a);
+	va_end(a);
+}
+#endif
+#if defined(LOGGFX) || defined(LOGHNT)
+void out2(char *format, ...) {
+	va_list a;
+
+	va_start(a, format);
+	vfprintf(dbg_log, format, a);
+	va_end(a);
+	fflush(dbg_log);
+}
+#endif
+
+/* Convert virtual pointer to effective pointer */
+type8 *effective(type32 ptr) {
+	if ((version < 4) && (mem_size == 0x10000))
+		return &(code[ptr & 0xffff]);
+	if (ptr >= mem_size) {
+		ms_fatal("Outside memory experience");
+		return code;
+	}
+
+	return &(code[ptr]);
+}
+
+type32 read_l(type8 *ptr) {
+
+	return (type32)((type32) ptr[0] << 24 | (type32) ptr[1] << 16 | (type32) ptr[2] << 8 | (type32) ptr[3]);
+}
+
+type16 read_w(type8 *ptr) {
+	return (type16)(ptr[0] << 8 | ptr[1]);
+}
+
+void write_l(type8 *ptr, type32 val) {
+	ptr[3] = (type8) val;
+	val >>= 8;
+	ptr[2] = (type8) val;
+	val >>= 8;
+	ptr[1] = (type8) val;
+	val >>= 8;
+	ptr[0] = (type8) val;
+}
+
+void write_w(type8 *ptr, type16 val) {
+	ptr[1] = (type8) val;
+	val >>= 8;
+	ptr[0] = (type8) val;
+}
+
+type32 read_l2(type8 *ptr) {
+	return ((type32) ptr[1] << 24 | (type32) ptr[0] << 16 | (type32) ptr[3] << 8 | (type32) ptr[2]);
+}
+
+type16 read_w2(type8 *ptr) {
+	return (type16)(ptr[1] << 8 | ptr[0]);
+}
+
+/* Standard rand - for equal cross-platform behaviour */
+
+void ms_seed(type32 seed) {
+	rseed = seed;
+}
+
+type32 rand_emu(void) {
+	rseed = 1103515245L * rseed + 12345L;
+	return rseed & 0x7fffffffL;
+}
+
+void ms_freemem(void) {
+	if (code)
+		free(code);
+	if (string)
+		free(string);
+	if (string2)
+		free(string2);
+	if (string3)
+		free(string3);
+	if (dict)
+		free(dict);
+	if (undo[0])
+		free(undo[0]);
+	if (undo[1])
+		free(undo[1]);
+	if (restart)
+		free(restart);
+	code = string = string2 = string3 = dict = undo[0] = undo[1] = restart = 0;
+	if (gfx_data)
+		free(gfx_data);
+	if (gfx_buf)
+		free(gfx_buf);
+	if (gfx2_hdr)
+		free(gfx2_hdr);
+	if (gfx2_buf)
+		free(gfx2_buf);
+	delete gfx_fp;
+
+	gfx_data = gfx_buf = gfx2_hdr = gfx2_buf = nullptr;
+	gfx2_name = 0;
+	gfx_fp = nullptr;
+	gfx_ver = 0;
+	gfxtable = table_dist = 0;
+#ifndef NO_ANIMATION
+	pos_table_size = 0;
+	command_index = 0;
+	anim_repeat = 0;
+	pos_table_index = -1;
+	pos_table_max = -1;
+#endif
+	lastchar = 0;
+	if (hints)
+		free(hints);
+	if (hint_contents)
+		free(hint_contents);
+	hints = 0;
+	hint_contents = 0;
+	if (snd_hdr)
+		free(snd_hdr);
+	if (snd_buf)
+		free(snd_buf);
+	snd_hdr = nullptr;
+	snd_hsize = 0;
+	snd_buf = nullptr;
+}
+
+type8 ms_is_running(void) {
+	return running;
+}
+
+type8 ms_is_magwin(void) {
+	return (version == 4) ? 1 : 0;
+}
+
+void ms_stop(void) {
+	running = 0;
+}
+
+type8 init_gfx1(type8 *header) {
+#ifdef SAVEMEM
+	type32 i;
+#endif
+
+	if (!(gfx_buf = (type8 *)malloc(MAX_PICTURE_SIZE))) {
+		delete gfx_fp;
+		gfx_fp = nullptr;
+		return 1;
+	}
+#ifdef SAVEMEM
+	if (!(gfx_data = (type8 *)malloc(128))) {
+#else
+	if (!(gfx_data = (type8 *)malloc(read_l(header + 4) - 8))) {
+#endif
+		free(gfx_buf);
+		delete gfx_fp;
+		gfx_buf = nullptr;
+		gfx_fp = nullptr;
+		return 1;
+	}
+#ifdef SAVEMEM
+	if (!fp.read(gfx_data, 128, 1, gfx_fp)) {
+#else
+	if (gfx_fp->read(gfx_data, read_l(header + 4)) != read_l(header + 4)) {
+#endif
+		free(gfx_data);
+		free(gfx_buf);
+		delete gfx_fp;
+		gfx_data = gfx_buf = nullptr;
+		gfx_fp = nullptr;
+		return 1;
+	}
+
+#ifdef SAVEMEM
+	for (i = 0; i < 128; i += 4)
+		if (!read_l(gfx_data + i))
+			write_l(gfx_data + i, read_l(header + 4));
+#else
+	delete gfx_fp;
+	gfx_fp = nullptr;
+#endif
+
+	gfx_ver = 1;
+	return 2;
+}
+
+type8 init_gfx2(type8 *header) {
+	if (!(gfx_buf = (type8 *)malloc(MAX_PICTURE_SIZE))) {
+		delete gfx_fp;
+		gfx_fp = nullptr;
+		return 1;
+	}
+
+	gfx2_hsize = read_w(header + 4);
+	if (!(gfx2_hdr = (type8 *)malloc(gfx2_hsize))) {
+		free(gfx_buf);
+		delete gfx_fp;
+		gfx_buf = nullptr;
+		gfx_fp = nullptr;
+		return 1;
+	}
+
+	gfx_fp->seek(6);
+	if (gfx_fp->read(gfx2_hdr, gfx2_hsize) != gfx2_hsize) {
+		free(gfx_buf);
+		free(gfx2_hdr);
+		delete gfx_fp;
+		gfx_buf = nullptr;
+		gfx2_hdr = 0;
+		gfx_fp = nullptr;
+		return 1;
+	}
+
+	gfx_ver = 2;
+	return 2;
+}
+
+type8 init_snd(type8 *header) {
+	if (!(snd_buf = (type8 *)malloc(MAX_MUSIC_SIZE))) {
+		delete snd_fp;
+		snd_fp = nullptr;
+		return 1;
+	}
+
+	snd_hsize = read_w(header + 4);
+	if (!(snd_hdr = (type8 *)malloc(snd_hsize))) {
+		free(snd_buf);
+		delete snd_fp;
+		snd_buf = nullptr;
+		snd_fp = nullptr;
+		return 1;
+	}
+
+	snd_fp->seek(6);
+	if (snd_fp->read(snd_hdr, snd_hsize) != snd_hsize) {
+		free(snd_buf);
+		free(snd_hdr);
+		delete snd_fp;
+		snd_buf = nullptr;
+		snd_hdr = nullptr;
+		snd_fp = nullptr;
+		return 1;
+	}
+
+	return 2;
+}
 
-	if (restarting) {
+/* zero all registers and flags and load the game */
+
+type8 ms_init(const char *name, const char *gfxname, const char *hntname, const char *sndname) {
+	Common::File fp;
+	type8 header[42], header2[8], header3[4];
+	type32 i, dict_size, string2_size, code_size, dec;
+
+#if defined(LOGEMU) || defined(LOGGFX) || defined(LOGHNT)
+	dbg_log = fopen(LOG_FILE, "wt");
+#endif
+	ms_stop();
+	if (!name) {
 		if (!restart)
 			return 0;
 		else {
@@ -45,221 +360,3281 @@ int Magnetic::ms_init(bool restarting) {
 	} else {
 		undo_stat[0] = undo_stat[1] = 0;
 
-		if (_gameFile.read(header, 42) != 42 || READ_BE_UINT32(header) != MKTAG('M', 'a', 'S', 'c')
-			|| READ_LE_UINT32(header + 8) != 42)
+		if (!fp.open(name))
+			return 0;
+		if ((fp.read(header, 42) != 42) || (read_l(header) != 0x4d615363))
+			return 0;
+		if (read_l(header + 8) != 42)
 			return 0;
 
 		ms_freemem();
 		version = header[13];
-		code_size = READ_LE_UINT32(header + 14);
-		string_size = READ_LE_UINT32(header + 18);
-		string2_size = READ_LE_UINT32(header + 22);
-		dict_size = READ_LE_UINT32(header + 26);
-		undo_size = READ_LE_UINT32(header + 34);
-		undo_pc = READ_LE_UINT32(header + 38);
+		code_size = read_l(header + 14);
+		string_size = read_l(header + 18);
+		string2_size = read_l(header + 22);
+		dict_size = read_l(header + 26);
+		undo_size = read_l(header + 34);
+		undo_pc = read_l(header + 38);
 
 		if ((version < 4) && (code_size < 65536))
 			mem_size = 65536;
 		else
 			mem_size = code_size;
 
-		sd = (byte)((dict_size != 0L) ? 1 : 0);			// if (sd) => separate dict
+		/* Some C libraries don't like malloc(0), so make
+		   sure that undo_size is always positive. */
+		if (undo_size == 0)
+			undo_size = 8;
+
+		sd = (type8)((dict_size != 0L) ? 1 : 0); /* if (sd) => separate dict */
 
-		if (!(code = new byte[mem_size]) || !(string2 = new byte[string2_size]) ||
-			!(restart = new byte[undo_size]) || (sd &&
-				!(dict = new byte[dict_size]))) {
+		if (!(code = (type8 *)malloc(mem_size)) || !(string2 = (type8 *)malloc(string2_size)) ||
+		        !(restart = (type8 *)malloc(undo_size)) || (sd &&
+		                !(dict = (type8 *)malloc(dict_size)))) {
 			ms_freemem();
+			fp.close();
 			return 0;
 		}
 		if (string_size > MAX_STRING_SIZE) {
-			if (!(string = new byte[MAX_STRING_SIZE]) ||
-				!(string3 = new byte[string_size - MAX_STRING_SIZE])) {
+			if (!(string = (type8 *)malloc(MAX_STRING_SIZE)) ||
+			        !(string3 = (type8 *)malloc(string_size - MAX_STRING_SIZE))) {
 				ms_freemem();
+				fp.close();
 				return 0;
 			}
 		} else {
-			if (!(string = new byte[string_size])) {
+			if (!(string = (type8 *)malloc(string_size))) {
 				ms_freemem();
+				fp.close();
 				return 0;
 			}
 		}
-		if (!(undo[0] = new byte[undo_size]) || !(undo[1] = new byte[undo_size])) {
+		if (!(undo[0] = (type8 *)malloc(undo_size)) || !(undo[1] = (type8 *)malloc(undo_size))) {
 			ms_freemem();
+			fp.close();
 			return 0;
 		}
-		if (_gameFile.read(code, code_size) != code_size) {
+		if (fp.read(code, code_size) != code_size) {
 			ms_freemem();
+			fp.close();
 			return 0;
 		}
-
-		memcpy(restart, code, undo_size);	// fast restarts
+		memcpy(restart, code, undo_size);   /* fast restarts */
 		if (string_size > MAX_STRING_SIZE) {
-			if (_gameFile.read(string, MAX_STRING_SIZE) != MAX_STRING_SIZE) {
+			if (fp.read(string, MAX_STRING_SIZE) != MAX_STRING_SIZE) {
 				ms_freemem();
+				fp.close();
 				return 0;
 			}
-			if (_gameFile.read(string3, string_size - MAX_STRING_SIZE) != (string_size - MAX_STRING_SIZE)) {
+			if (fp.read(string3, string_size - MAX_STRING_SIZE) != string_size - MAX_STRING_SIZE) {
 				ms_freemem();
+				fp.close();
 				return 0;
 			}
 		} else {
-			if (_gameFile.read(string, string_size) != string_size) {
+			if (fp.read(string, string_size) != string_size) {
 				ms_freemem();
+				fp.close();
 				return 0;
 			}
 		}
-		if (_gameFile.read(string2, string2_size) != string2_size) {
+		if (fp.read(string2, string2_size) != string2_size) {
 			ms_freemem();
+			fp.close();
 			return 0;
 		}
-		if (sd && _gameFile.read(dict, dict_size) != dict_size) {
+		if (sd && fp.read(dict, dict_size) != dict_size)  {
 			ms_freemem();
+			fp.close();
 			return 0;
 		}
-
-		dec = READ_LE_UINT32(header + 30);
-		if (dec >= string_size) {
+		dec = read_l(header + 30);
+		if (dec >= string_size)
 			decode_table = string2 + dec - string_size;
-		} else {
+		else {
 			if (dec >= MAX_STRING_SIZE)
 				decode_table = string3 + dec - MAX_STRING_SIZE;
 			else
 				decode_table = string + dec;
 		}
+		fp.close();
 	}
 
 	for (i = 0; i < 8; i++)
 		dreg[i] = areg[i] = 0;
-	write_reg(8 + 7, 2, 0xfffe);	// Stack-pointer, -2 due to MS-DOS segments
+	write_reg(8 + 7, 2, 0xfffe);    /* Stack-pointer, -2 due to MS-DOS segments */
 	pc = 0;
 	zflag = nflag = cflag = vflag = 0;
 	i_count = 0;
 	running = 1;
 
-	if (restarting)
-		return (byte)(gfx_buf ? 2 : 1);		// Restarted
+	if (!name)
+		return (type8)(gfx_buf ? 2 : 1);    /* Restarted */
 
 	if (version == 4) {
-		// Try loading a hint file
-		if (_hintFile.isOpen()) {
-			_hintFile.seek(0);
-
-			if (_hintFile.readUint32BE() == MKTAG('M', 'a', 'H', 't')) {
-				uint16 blkcnt, elcnt, ntype, elsize, conidx;
-
-				// Allocate memory for hints
-				hints = new ms_hint[MAX_HINTS];
-				hint_contents = new byte[MAX_HCONTENTS];
+		/* Try loading a hint file */
+		Common::File hnt_fp;
+		if (hntname && hnt_fp.open(hntname)) {
+			if ((hnt_fp.read(&header3, 4) == 4) && (read_l(header3) == 0x4D614874)) {
+				type8 buf[8];
+				type16 j, blkcnt, elcnt, ntype, elsize, conidx;
 
+				/* Allocate memory for hints */
+				hints = (ms_hint *)malloc(MAX_HINTS * sizeof(struct ms_hint));
+				hint_contents = (type8 *)malloc(MAX_HCONTENTS);
 				if ((hints != 0) && (hint_contents != 0)) {
-					// Read number of blocks
-					blkcnt = _hintFile.readUint16LE();
-
+					/* Read number of blocks */
+					if (hnt_fp.read(&buf, 2) != 2 && !hnt_fp.eos())
+						return 0;
+					blkcnt = read_w2(buf);
+#ifdef LOGHNT
+					out2("Blocks: %d\n", blkcnt);
+#endif
 					conidx = 0;
 					for (i = 0; i < blkcnt; i++) {
-						// Read number of elements
-						elcnt = _hintFile.readUint16LE();
+#ifdef LOGHNT
+						out2("\nBlock No. %d\n", i);
+#endif
+						/* Read number of elements */
+						if (hnt_fp.read(&buf, 2) != 2 && !hnt_fp.eos()) return 0;
+						elcnt = read_w2(buf);
+#ifdef LOGHNT
+						out2("Elements: %d\n", elcnt);
+#endif
 						hints[i].elcount = elcnt;
 
-						// Read node type
-						ntype = _hintFile.readUint16LE();
+						/* Read node type */
+						if (hnt_fp.read(&buf, 2) != 2 && !hnt_fp.eos()) return 0;
+						ntype = read_w2(buf);
+#ifdef LOGHNT
+						if (ntype == 1)
+							out2("Type: Node\n");
+						else
+							out2("Type: Leaf\n");
+#endif
 						hints[i].nodetype = ntype;
-						hints[i].content = hint_contents + conidx;
-
+						hints[i].content = (const char *)hint_contents + conidx;
+#ifdef LOGHNT
+						out2("Elements:\n");
+#endif
 						for (j = 0; j < elcnt; j++) {
-							elsize = _hintFile.readUint16LE();
-							if (_hintFile.read(hint_contents + conidx, elsize) != elsize || _hintFile.eos())
-								return 0;
+							if (hnt_fp.read(&buf, 2) != 2 && !hnt_fp.eos()) return 0;
+							elsize = read_w2(buf);
+							if (hnt_fp.read(hint_contents + conidx, elsize) != elsize && !hnt_fp.eos()) return 0;
 							hint_contents[conidx + elsize - 1] = '\0';
-
+#ifdef LOGHNT
+							out2("%s\n", hint_contents + conidx);
+#endif
 							conidx += elsize;
 						}
 
-						// Do we need a jump table?
+						/* Do we need a jump table? */
 						if (ntype == 1) {
+#ifdef LOGHNT
+							out2("Jump to block:\n");
+#endif
 							for (j = 0; j < elcnt; j++) {
-								hints[i].links[j] = _hintFile.readUint16LE();
+								if (hnt_fp.read(&buf, 2) != 2 && !hnt_fp.eos()) return 0;
+								hints[i].links[j] = read_w2(buf);
+#ifdef LOGHNT
+								out2("%d\n", hints[i].links[j]);
+#endif
 							}
 						}
 
-						// Read the parent block
-						hints[i].parent = _hintFile.readUint16LE();
-
+						/* Read the parent block */
+						if (hnt_fp.read(&buf, 2) != 2 && !hnt_fp.eos()) return 0;
+						hints[i].parent = read_w2(buf);
+#ifdef LOGHNT
+						out2("Parent: %d\n", hints[i].parent);
+#endif
 					}
 				} else {
-					delete[] hints;
-					delete[] hint_contents;
-					hints = nullptr;
-					hint_contents = nullptr;
+					if (hints)
+						free(hints);
+					if (hint_contents)
+						free(hint_contents);
+					hints = 0;
+					hint_contents = 0;
+				}
+			}
+			hnt_fp.close();
+		}
+
+		/* Try loading a music file */
+		snd_fp = new Common::File();
+		if (sndname && snd_fp->open(sndname)) {
+			if (snd_fp->read(&header2, 8) != 8) {
+				delete snd_fp;
+				snd_fp = nullptr;
+			} else {
+				if (read_l(header2) == 0x4D615364) { /* MaSd */
+					init_snd(header2);
+#ifdef LOGSND
+					out2("Sound file loaded.\n");
+#endif
+				}
+			}
+		} else {
+			delete snd_fp;
+			snd_fp = nullptr;
+		}
+	}
+
+	if (!gfxname)
+		return 1;
+
+	gfx_fp = new Common::File();
+	if (!gfx_fp->open(gfxname) || gfx_fp->read(&header2, 8) != 8) {
+		delete gfx_fp;
+		gfx_fp = nullptr;
+		return 1;
+	}
+
+	if (version < 4 && read_l(header2) == 0x4D615069) /* MaPi */
+		return init_gfx1(header2);
+	else if (version == 4 && read_l(header2) == 0x4D615032) /* MaP2 */
+		return init_gfx2(header2);
+	delete gfx_fp;
+	gfx_fp = nullptr;
+	return 1;
+}
+
+type8 is_blank(type16 line, type16 width) {
+	type32s i;
+
+	for (i = line * width; i < (line + 1) * width; i++)
+		if (gfx_buf[i])
+			return 0;
+	return 1;
+}
+
+type8 *ms_extract1(type8 pic, type16 *w, type16 *h, type16 *pal) {
+	type8 *decodeTable, *data, bit, val, *buffer;
+	type16 tablesize, count;
+	type32 i, j, upsize, offset;
+
+	offset = read_l(gfx_data + 4 * pic);
+#ifdef SAVEMEM
+	type32 datasize;
+
+	if (fseek(gfx_fp, offset, SEEK_SET) < 0)
+		return 0;
+	datasize = read_l(gfx_data + 4 * (pic + 1)) - offset;
+	if (!(buffer = (type8 *)malloc(datasize)))
+		return 0;
+	if (fp.read(buffer, 1, datasize, gfx_fp) != datasize)
+		return 0;
+#else
+	buffer = gfx_data + offset - 8;
+#endif
+
+	for (i = 0; i < 16; i++)
+		pal[i] = read_w(buffer + 0x1c + 2 * i);
+	w[0] = (type16)(read_w(buffer + 4) - read_w(buffer + 2));
+	h[0] = read_w(buffer + 6);
+
+	tablesize = read_w(buffer + 0x3c);
+	//datasize = read_l(buffer + 0x3e);
+	decodeTable = buffer + 0x42;
+	data = decodeTable + tablesize * 2 + 2;
+	upsize = h[0] * w[0];
+
+	for (i = 0, j = 0, count = 0, val = 0, bit = 7; i < upsize; i++, count--) {
+		if (!count) {
+			count = tablesize;
+			while (count < 0x80) {
+				if (data[j] & (1 << bit))
+					count = decodeTable[2 * count];
+				else
+					count = decodeTable[2 * count + 1];
+				if (!bit)
+					j++;
+				bit = (type8)(bit ? bit - 1 : 7);
+			}
+			count &= 0x7f;
+			if (count >= 0x10)
+				count -= 0x10;
+			else {
+				val = (type8)count;
+				count = 1;
+			}
+		}
+		gfx_buf[i] = val;
+	}
+	for (j = w[0]; j < upsize; j++)
+		gfx_buf[j] ^= gfx_buf[j - w[0]];
+
+#ifdef SAVEMEM
+	free(buffer);
+#endif
+	for (; h[0] > 0 && is_blank((type16)(h[0] - 1), w[0]); h[0]--);
+	for (i = 0; h[0] > 0 && is_blank((type16)i, w[0]); h[0]--, i++);
+	return gfx_buf + i * w[0];
+}
+
+type16s find_name_in_header(const char *name, type8 upper) {
+	type16s header_pos = 0;
+	char pic_name[8];
+	type8 i;
+
+	for (i = 0; i < 8; i++)
+		pic_name[i] = 0;
+	strncpy(pic_name, name, 6);
+	if (upper) {
+		for (i = 0; i < 8; i++)
+			pic_name[i] = (char)toupper(pic_name[i]);
+	}
+
+	while (header_pos < gfx2_hsize) {
+		const char *hname = (const char *)(gfx2_hdr + header_pos);
+		if (strncmp(hname, pic_name, 6) == 0)
+			return header_pos;
+		header_pos += 16;
+	}
+	return -1;
+}
+
+void extract_frame(struct picture *pic) {
+	type32 i, x, y, bit_x, mask, ywb, yw, value, values[4];
+
+	if (pic->width * pic->height > MAX_PICTURE_SIZE) {
+		ms_fatal("picture too large");
+		return;
+	}
+
+	for (y = 0; y < pic->height; y++) {
+		ywb = y * pic->wbytes;
+		yw = y * pic->width;
+
+		for (x = 0; x < pic->width; x++) {
+			if ((x % 8) == 0) {
+				for (i = 0; i < 4; i++)
+					values[i] = pic->data[ywb + (x / 8) + (pic->plane_step * i)];
+			}
+
+			bit_x = 7 - (x & 7);
+			mask = 1 << bit_x;
+			value = ((values[0] & mask) >> bit_x) << 0 |
+			        ((values[1] & mask) >> bit_x) << 1 |
+			        ((values[2] & mask) >> bit_x) << 2 |
+			        ((values[3] & mask) >> bit_x) << 3;
+			value &= 15;
+
+			gfx_buf[yw + x] = (type8)value;
+		}
+	}
+}
+
+type8 *ms_extract2(const char *name, type16 *w, type16 *h, type16 *pal, type8 *is_anim) {
+	struct picture main_pic;
+	type32 offset = 0, length = 0, i;
+	type16s header_pos = -1;
+#ifndef NO_ANIMATION
+	type8 *anim_data;
+	type32 j;
+#endif
+
+	if (is_anim != 0)
+		*is_anim = 0;
+	gfx2_name = name;
+
+#ifndef NO_ANIMATION
+	pos_table_size = 0;
+#endif
+
+#ifdef NO_ANIMATION
+	/* Find the uppercase (no animation) version of the picture first. */
+	header_pos = find_name_in_header(name, 1);
+#endif
+	if (header_pos < 0)
+		header_pos = find_name_in_header(name, 0);
+	if (header_pos < 0)
+		return 0;
+
+	offset = read_l(gfx2_hdr + header_pos + 8);
+	length = read_l(gfx2_hdr + header_pos + 12);
+
+	if (offset != 0) {
+		if (gfx2_buf) {
+			free(gfx2_buf);
+			gfx2_buf = nullptr;
+		}
+
+		gfx2_buf = (type8 *)malloc(length);
+		if (!gfx2_buf)
+			return 0;
+
+		if (!gfx_fp->seek(offset)) {
+			free(gfx2_buf);
+			gfx2_buf = nullptr;
+			return 0;
+		}
+
+		if (gfx_fp->read(gfx2_buf, length) != length) {
+			free(gfx2_buf);
+			gfx2_buf = nullptr;
+			return 0;
+		}
+
+		for (i = 0; i < 16; i++)
+			pal[i] = read_w2(gfx2_buf + 4 + (2 * i));
+
+		main_pic.data = gfx2_buf + 48;
+		main_pic.data_size = read_l2(gfx2_buf + 38);
+		main_pic.width = read_w2(gfx2_buf + 42);
+		main_pic.height = read_w2(gfx2_buf + 44);
+		main_pic.wbytes = (type16)(main_pic.data_size / main_pic.height);
+		main_pic.plane_step = (type16)(main_pic.wbytes / 4);
+		main_pic.mask = (type8 *)0;
+		extract_frame(&main_pic);
+
+		*w = main_pic.width;
+		*h = main_pic.height;
+
+#ifndef NO_ANIMATION
+		/* Check for an animation */
+		anim_data = gfx2_buf + 48 + main_pic.data_size;
+		if ((anim_data[0] != 0xD0) || (anim_data[1] != 0x5E)) {
+			type8 *current;
+			type16 frame_count;
+			type16 value1, value2;
+
+			if (is_anim != 0)
+				*is_anim = 1;
+
+			current = anim_data + 6;
+			frame_count = read_w2(anim_data + 2);
+			if (frame_count > MAX_ANIMS) {
+				ms_fatal("animation frame array too short");
+				return 0;
+			}
+
+			/* Loop through each animation frame */
+			for (i = 0; i < frame_count; i++) {
+				anim_frame_table[i].data = current + 10;
+				anim_frame_table[i].data_size = read_l2(current);
+				anim_frame_table[i].width = read_w2(current + 4);
+				anim_frame_table[i].height = read_w2(current + 6);
+				anim_frame_table[i].wbytes = (type16)(anim_frame_table[i].data_size / anim_frame_table[i].height);
+				anim_frame_table[i].plane_step = (type16)(anim_frame_table[i].wbytes / 4);
+				anim_frame_table[i].mask = (type8 *)0;
+
+				current += anim_frame_table[i].data_size + 12;
+				value1 = read_w2(current - 2);
+				value2 = read_w2(current);
+
+				/* Get the mask */
+				if ((value1 == anim_frame_table[i].width) && (value2 == anim_frame_table[i].height)) {
+					type16 skip;
+
+					anim_frame_table[i].mask = (type8 *)(current + 4);
+					skip = read_w2(current + 2);
+					current += skip + 6;
+				}
+			}
+
+			/* Get the positioning tables */
+			pos_table_size = read_w2(current - 2);
+			if (pos_table_size > MAX_POSITIONS) {
+				ms_fatal("animation position array too short");
+				return 0;
+			}
+
+#ifdef LOGGFX_EXT
+			out2("POSITION TABLE DUMP\n");
+#endif
+			for (i = 0; i < pos_table_size; i++) {
+				pos_table_count[i] = read_w2(current + 2);
+				current += 4;
+
+				if (pos_table_count[i] > MAX_ANIMS) {
+					ms_fatal("animation position array too short");
+					return 0;
+				}
+
+				for (j = 0; j < pos_table_count[i]; j++) {
+					pos_table[i][j].x = read_w2(current);
+					pos_table[i][j].y = read_w2(current + 2);
+					pos_table[i][j].number = read_w2(current + 4) - 1;
+					current += 8;
+#ifdef LOGGFX_EXT
+					out2("Position entry: Table: %d  Entry: %d  X: %d Y: %d Frame: %d\n",
+					     i, j, pos_table[i][j].x, pos_table[i][j].y, pos_table[i][j].number);
+#endif
+				}
+			}
+
+			/* Get the command sequence table */
+			//command_count = read_w2(current);
+			command_table = current + 2;
+
+			for (i = 0; i < MAX_POSITIONS; i++) {
+				anim_table[i].flag = -1;
+				anim_table[i].count = -1;
+			}
+			command_index = 0;
+			anim_repeat = 0;
+			pos_table_index = -1;
+			pos_table_max = -1;
+		}
+#endif
+		return gfx_buf;
+	}
+	return 0;
+}
+
+type8 *ms_extract(type32 pic, type16 *w, type16 *h, type16 *pal, type8 *is_anim) {
+	if (is_anim)
+		*is_anim = 0;
+
+	if (gfx_buf) {
+		switch (gfx_ver) {
+		case 1:
+			return ms_extract1((type8)pic, w, h, pal);
+		case 2:
+			return ms_extract2((const char *)(code + pic), w, h, pal, is_anim);
+		default:
+			break;
+		}
+	}
+	return 0;
+}
+
+type8 ms_animate(struct ms_position **positions, type16 *count) {
+#ifndef NO_ANIMATION
+	type8 got_anim = 0;
+	type16 i, j, ttable;
+
+	if ((gfx_buf == 0) || (gfx2_buf == 0) || (gfx_ver != 2))
+		return 0;
+	if ((pos_table_size == 0) || (command_index < 0))
+		return 0;
+
+	*count = 0;
+	*positions = (struct ms_position *)0;
+
+	while (got_anim == 0) {
+		if (pos_table_max >= 0) {
+			if (pos_table_index < pos_table_max) {
+				for (i = 0; i < pos_table_size; i++) {
+					if (anim_table[i].flag > -1) {
+						if (*count >= MAX_FRAMES) {
+							ms_fatal("returned animation array too short");
+							return 0;
+						}
+
+						pos_array[*count] = pos_table[i][anim_table[i].flag];
+#ifdef LOGGFX_EXT
+						out2("Adding frame %d to buffer\n", pos_array[*count].number);
+#endif
+						(*count)++;
+
+						if (anim_table[i].flag < (pos_table_count[i] - 1))
+							anim_table[i].flag++;
+						if (anim_table[i].count > 0)
+							anim_table[i].count--;
+						else
+							anim_table[i].flag = -1;
+					}
 				}
+				if (*count > 0) {
+					*positions = pos_array;
+					got_anim = 1;
+				}
+				pos_table_index++;
 			}
 		}
 
-		// Try loading a music file
-		if (_sndFile.isOpen() && _sndFile.size() >= 8) {
-			_sndFile.seek(0);
+		if (got_anim == 0) {
+			type8 command = command_table[command_index];
+			command_index++;
+
+			pos_table_max = -1;
+			pos_table_index = -1;
 
-			if (_sndFile.readUint32BE() != MKTAG('M', 'a', 'S', 'd'))
+			switch (command) {
+			case 0x00:
+				command_index = -1;
 				return 0;
+			case 0x01:
+#ifdef LOGGFX_EXT
+				out2("Load Frame Table: %d  Start at: %d  Count: %d\n",
+				     command_table[command_index], command_table[command_index + 1],
+				     command_table[command_index + 2]);
+#endif
+				ttable = command_table[command_index];
+				command_index++;
+
+				if (ttable - 1 >= MAX_POSITIONS) {
+					ms_fatal("animation table too short");
+					return 0;
+				}
+
+				anim_table[ttable - 1].flag = (type16s)(command_table[command_index] - 1);
+				command_index++;
+				anim_table[ttable - 1].count = (type16s)(command_table[command_index] - 1);
+				command_index++;
 
-			init_snd(_sndFile.readUint32LE());
+				/* Workaround for Wonderland "catter" animation */
+				if (v4_id == 0) {
+					if (strcmp(gfx2_name, "catter") == 0) {
+						if (command_index == 96)
+							anim_table[ttable - 1].count = 9;
+						if (command_index == 108)
+							anim_table[ttable - 1].flag = -1;
+						if (command_index == 156)
+							anim_table[ttable - 1].flag = -1;
+					}
+				}
+				break;
+			case 0x02:
+#ifdef LOGGFX_EXT
+				out2("Animate: %d\n", command_table[command_index]);
+#endif
+				pos_table_max = command_table[command_index];
+				pos_table_index = 0;
+				command_index++;
+				break;
+			case 0x03:
+#ifdef LOGGFX_EXT
+				out2("Stop/Repeat Param: %d\n", command_table[command_index]);
+				command_index = -1;
+				return 0;
+#else
+				if (v4_id == 0) {
+					command_index = -1;
+					return 0;
+				} else {
+					command_index = 0;
+					anim_repeat = 1;
+					pos_table_index = -1;
+					pos_table_max = -1;
+					for (j = 0; j < MAX_POSITIONS; j++) {
+						anim_table[j].flag = -1;
+						anim_table[j].count = -1;
+					}
+				}
+				break;
+#endif
+			case 0x04:
+#ifdef LOGGFX_EXT
+				out2("Unknown Command: %d Prop1: %d  Prop2: %d WARNING:not parsed\n", command,
+				     command_table[command_index], command_table[command_index + 1]);
+#endif
+				command_index += 3;
+				return 0;
+			case 0x05:
+				ttable = next_table;
+				command_index++;
+
+				anim_table[ttable - 1].flag = 0;
+				anim_table[ttable - 1].count = command_table[command_index];
+
+				pos_table_max = command_table[command_index];
+				pos_table_index = 0;
+				command_index++;
+				command_index++;
+				next_table++;
+				break;
+			default:
+				ms_fatal("unknown animation command");
+				command_index = -1;
+				return 0;
+			}
 		}
 	}
+#ifdef LOGGFX_EXT
+	out2("ms_animate() returning %d frames\n", *count);
+#endif
+	return got_anim;
+#else
+	return 0;
+#endif
+}
 
-	if (!_gfxFile.isOpen() || _gfxFile.size() < 8)
-		return 1;
-	_gfxFile.seek(0);
-	uint tag = _gfxFile.readUint32BE();
+type8 *ms_get_anim_frame(type16s number, type16 *width, type16 *height, type8 **mask) {
+#ifndef NO_ANIMATION
+	if (number >= 0) {
+		extract_frame(anim_frame_table + number);
+		*width = anim_frame_table[number].width;
+		*height = anim_frame_table[number].height;
+		*mask = anim_frame_table[number].mask;
+		return gfx_buf;
+	}
+#endif
+	return 0;
+}
+
+type8 ms_anim_is_repeating(void) {
+#ifndef NO_ANIMATION
+	return anim_repeat;
+#else
+	return 0;
+#endif
+}
+
+type16s find_name_in_sndheader(const char *name) {
+	type16s header_pos = 0;
+
+	while (header_pos < snd_hsize) {
+		const char *hname = (const char *)(snd_hdr + header_pos);
+		if (strcmp(hname, name) == 0)
+			return header_pos;
+		header_pos += 18;
+	}
+
+	return -1;
+}
 
-	if (version < 4 && tag == MKTAG('M', 'a', 'P', 'i'))
-		return init_gfx1(_gfxFile.readUint32LE() - 8);
-	else if (version == 4 && tag == MKTAG('M', 'a', 'P', '2'))
-		return init_gfx2(_gfxFile.readUint16LE());
+type8 *sound_extract(const char *name, type32 *length, type16 *tempo) {
+	type32 offset = 0;
+	type16s header_pos = -1;
 
+	if (header_pos < 0)
+		header_pos = find_name_in_sndheader(name);
+	if (header_pos < 0)
+		return 0;
+
+	*tempo = read_w(snd_hdr + header_pos + 8);
+	offset = read_l(snd_hdr + header_pos + 10);
+	*length = read_l(snd_hdr + header_pos + 14);
+
+	if (offset != 0) {
+		if (!snd_buf)
+			return 0;
+		if (!snd_fp->seek(offset) || snd_fp->read(snd_buf, *length) != *length)
+			return 0;
+
+		return snd_buf;
+	}
+
+	return nullptr;
+}
+
+void save_undo(void) {
+	type8 *tmp, i;
+	type32 tmp32;
+
+	tmp = undo[0];  /* swap buffers */
+	undo[0] = undo[1];
+	undo[1] = tmp;
+
+	for (i = 0; i < 18; i++) {
+		tmp32 = undo_regs[0][i];
+		undo_regs[0][i] = undo_regs[1][i];
+		undo_regs[1][i] = tmp32;
+	}
+
+	memcpy(undo[1], code, undo_size);
+	for (i = 0; i < 8; i++) {
+		undo_regs[1][i] = dreg[i];
+		undo_regs[1][8 + i] = areg[i];
+	}
+	undo_regs[1][16] = i_count;
+	undo_regs[1][17] = pc;  /* status flags intentionally omitted */
+
+	undo_stat[0] = undo_stat[1];
+	undo_stat[1] = 1;
+}
+
+type8 ms_undo(void) {
+	type8 i;
+
+	ms_flush();
+	if (!undo_stat[0])
+		return 0;
+
+	undo_stat[0] = undo_stat[1] = 0;
+	memcpy(code, undo[0], undo_size);
+	for (i = 0; i < 8; i++) {
+		dreg[i] = undo_regs[0][i];
+		areg[i] = undo_regs[0][8 + i];
+	}
+	i_count = undo_regs[0][16];
+	pc = undo_regs[0][17];  /* status flags intentionally omitted */
 	return 1;
 }
 
-void Magnetic::ms_freemem() {
-	delete[] code;
-	delete[] string;
-	delete[] string2;
-	delete[] string3;
-	delete[] dict;
-	delete[] undo[0];
-	delete[] undo[1];
-	delete[] restart;
-	code = string = string2 = string3 = dict = nullptr;
-	undo[0] = undo[1] = restart = nullptr;
+#ifdef LOGEMU
+void log_status(void) {
+	int j;
+
+	fprintf(dbg_log, "\nD0:");
+	for (j = 0; j < 8; j++)
+		fprintf(dbg_log, " %8.8x", read_reg(j, 3));
+	fprintf(dbg_log, "\nA0:");
+	for (j = 0; j < 8; j++)
+		fprintf(dbg_log, " %8.8x", read_reg(8 + j, 3));
+	fprintf(dbg_log, "\nPC=%5.5x (%8.8x) ZCNV=%d%d%d%d - %d instructions\n\n",
+	        pc, code, zflag & 1, cflag & 1, nflag & 1, vflag & 1, i_count);
+}
+#endif
+
+void ms_status(void) {
+	int j;
 
-	delete[] gfx_data;
-	delete[] gfx_buf;
-	delete[] gfx2_hdr;
-	delete[] gfx2_buf;
-	gfx_data = gfx_buf = gfx2_hdr = gfx2_buf = 0;
+	Common::String s = "D0:";
+	for (j = 0; j < 8; j++)
+		s += Common::String::format(" %8.8lx", (long) read_reg(j, 3));
+	s += "\nA0:";
 
-	gfx_fp.close();
+	for (j = 0; j < 8; j++)
+		s += Common::String::format(" %8.8lx", (long) read_reg(8 + j, 3));
+	s += Common::String::format("\nPC=%5.5lx ZCNV=%d%d%d%d - %ld instructions\n",
+	                            (long) pc, zflag & 1, cflag & 1, nflag & 1, vflag & 1, (long) i_count);
+	warning("%s", s.c_str());
+}
 
-	gfx2_name.clear();
-	gfx_ver = 0;
-	gfxtable = table_dist = 0;
+type32 ms_count(void) {
+	return i_count;
+}
 
-	pos_table_size = 0;
-	command_index = 0;
-	anim_repeat = 0;
-	pos_table_index = -1;
-	pos_table_max = -1;
+/* align register pointer for word/byte accesses */
 
-	lastchar = 0;
-	delete[] hints;
-	delete[] hint_contents;
-	hints = nullptr;
-	hint_contents = nullptr;
+type8 *reg_align(type8 *ptr, type8 size) {
+	if (size == 1)
+		ptr += 2;
+	if (size == 0)
+		ptr += 3;
+	return ptr;
+}
 
-	delete[] snd_hdr;
-	delete[] snd_buf;
-	snd_hdr = nullptr;
-	snd_hsize = 0;
-	snd_buf = nullptr;
+type32 read_reg(int i, int s) {
+	type8 *ptr;
+
+	if (i > 15) {
+		ms_fatal("invalid register in read_reg");
+		return 0;
+	}
+	if (i < 8)
+		ptr = (type8 *) & dreg[i];
+	else
+		ptr = (type8 *) & areg[i - 8];
+
+	switch (s) {
+	case 0:
+		return reg_align(ptr, 0)[0];
+	case 1:
+		return read_w(reg_align(ptr, 1));
+	default:
+		return read_l(ptr);
+	}
+}
+
+void write_reg(int i, int s, type32 val) {
+	type8 *ptr;
+
+	if (i > 15) {
+		ms_fatal("invalid register in write_reg");
+		return;
+	}
+	if (i < 8)
+		ptr = (type8 *) & dreg[i];
+	else
+		ptr = (type8 *) & areg[i - 8];
+
+	switch (s) {
+	case 0:
+		reg_align(ptr, 0)[0] = (type8)val;
+		break;
+	case 1:
+		write_w(reg_align(ptr, 1), (type16)val);
+		break;
+	default:
+		write_l(ptr, val);
+		break;
+	}
+}
+
+/* [35c4] */
+
+void char_out(type8 c) {
+	static type8 big = 0, period = 0, pipe = 0;
+
+	if (c == 0xff) {
+		big = 1;
+		return;
+	}
+	c &= 0x7f;
+	if (read_reg(3, 0)) {
+		if (c == 0x5f || c == 0x40)
+			c = 0x20;
+		if ((c >= 'a') && (c <= 'z'))
+			c &= 0xdf;
+		if (version < 4)
+			ms_statuschar(c);
+		return;
+	}
+	if (c == 0x5e)
+		c = 0x0a;
+	if (c == 0x40) {
+		if (read_reg(2, 0))
+			return;
+		else
+			c = 0x73;
+	}
+	if (version < 3 && c == 0x7e) {
+		lastchar = 0x7e;
+		c = 0x0a;
+	}
+	if (((c > 0x40) && (c < 0x5b)) || ((c > 0x60) && (c < 0x7b))) {
+		if (big) {
+			c &= 0xdf;
+			big = 0;
+		}
+		if (period)
+			char_out(0x20);
+	}
+	period = 0;
+	if (version < 4) {
+		if ((c == 0x2e) || (c == 0x3f) || (c == 0x21) || (c == 0x0a))
+			big = 1;
+		else if (c == 0x22)
+			big = 0;
+	} else {
+		if ((c == 0x20) && (lastchar == 0x0a))
+			return;
+		if ((c == 0x2e) || (c == 0x3f) || (c == 0x21) || (c == 0x0a))
+			big = 1;
+		else if (c == 0x22)
+			big = 0;
+	}
+	if (((c == 0x20) || (c == 0x0a)) && (c == lastchar))
+		return;
+	if (version < 3) {
+		if (pipe) {
+			pipe = 0;
+			return;
+		}
+		if (c == 0x7c) {
+			pipe = 1;
+			return;
+		}
+	} else {
+		if (c == 0x7e) {
+			c = 0x0a;
+			if (lastchar != 0x0a)
+				char_out(0x0a);
+		}
+	}
+	lastchar = c;
+	if (c == 0x5f)
+		c = 0x20;
+	if ((c == 0x2e) || (c == 0x2c) || (c == 0x3b) || (c == 0x3a) || (c == 0x21) || (c == 0x3f))
+		period = 1;
+	ms_putchar(c);
+}
+
+
+/* extract addressing mode information [1c6f] */
+
+void set_info(type8 b) {
+	regnr = (type8)(b & 0x07);
+	admode = (type8)((b >> 3) & 0x07);
+	opsize = (type8)(b >> 6);
+}
+
+/* read a word and increase pc */
+
+void read_word(void) {
+	type8 *epc;
+
+	epc = effective(pc);
+	byte1 = epc[0];
+	byte2 = epc[1];
+	pc += 2;
+}
+
+/* get addressing mode and set arg1 [1c84] */
+
+void set_arg1(void) {
+	type8 tmp[2], l1c;
+
+	is_reversible = 1;
+	switch (admode) {
+	case 0:
+		arg1 = reg_align((type8 *) & dreg[regnr], opsize);  /* Dx */
+		is_reversible = 0;
+#ifdef LOGEMU
+		out(" d%.1d", regnr);
+#endif
+		break;
+	case 1:
+		arg1 = reg_align((type8 *) & areg[regnr], opsize);  /* Ax */
+		is_reversible = 0;
+#ifdef LOGEMU
+		out(" a%.1d", regnr);
+#endif
+		break;
+	case 2:
+		arg1i = read_reg(8 + regnr, 2);     /* (Ax) */
+#ifdef LOGEMU
+		out(" (a%.1d)", regnr);
+#endif
+		break;
+	case 3:
+		arg1i = read_reg(8 + regnr, 2);     /* (Ax)+ */
+		write_reg(8 + regnr, 2, read_reg(8 + regnr, 2) + (1 << opsize));
+#ifdef LOGEMU
+		out(" (a%.1d)+", regnr);
+#endif
+		break;
+	case 4:
+		write_reg(8 + regnr, 2, read_reg(8 + regnr, 2) - (1 << opsize));
+		arg1i = read_reg(8 + regnr, 2);     /* -(Ax) */
+#ifdef LOGEMU
+		out(" -(a%.1d)", regnr);
+#endif
+		break;
+	case 5: {
+		type16s i = (type16s) read_w(effective(pc));
+		arg1i = read_reg(8 + regnr, 2) + i;
+		pc += 2;    /* offset.w(Ax) */
+#ifdef LOGEMU
+		out(" %X(a%.1d)", i, regnr);
+#endif
+	}
+	break;
+	case 6:
+		tmp[0] = byte1;
+		tmp[1] = byte2;
+		read_word();    /* offset.b(Ax, Dx/Ax) [1d1c] */
+#ifdef LOGEMU
+		out(" %.2X(a%.1d,", (int) byte2, regnr);
+#endif
+		arg1i = read_reg(regnr + 8, 2) + (type8s) byte2;
+#ifdef LOGEMU
+		if ((byte1 >> 4) > 8)
+			out("a%.1d", (byte1 >> 4) - 8);
+		else
+			out("d%.1d", byte1 >> 4);
+#endif
+		if (byte1 & 0x08) {
+#ifdef LOGEMU
+			out(".l)");
+#endif
+			arg1i += (type32s) read_reg((byte1 >> 4), 2);
+		} else {
+#ifdef LOGEMU
+			out(".w)");
+#endif
+			arg1i += (type16s) read_reg((byte1 >> 4), 1);
+		}
+		byte1 = tmp[0];
+		byte2 = tmp[1];
+		break;
+	case 7:     /* specials */
+		switch (regnr) {
+		case 0:
+			arg1i = read_w(effective(pc));  /* $xxxx.W */
+			pc += 2;
+#ifdef LOGEMU
+			out(" %.4X.w", arg1i);
+#endif
+			break;
+		case 1:
+			arg1i = read_l(effective(pc));  /* $xxxx */
+			pc += 4;
+#ifdef LOGEMU
+			out(" %.4X", arg1i);
+#endif
+			break;
+		case 2:
+			arg1i = (type16s) read_w(effective(pc)) + pc;   /* $xxxx(PC) */
+			pc += 2;
+#ifdef LOGEMU
+			out(" %.4X(pc)", arg1i);
+#endif
+			break;
+		case 3:
+			l1c = effective(pc)[0];     /* $xx(PC,A/Dx) */
+#ifdef LOGEMU
+			out(" ???2", arg1i);
+#endif
+			if (l1c & 0x08)
+				arg1i = pc + (type32s) read_reg((l1c >> 4), 2);
+			else
+				arg1i = pc + (type16s) read_reg((l1c >> 4), 1);
+			l1c = effective(pc)[1];
+			pc += 2;
+			arg1i += (type8s) l1c;
+			break;
+		case 4:
+			arg1i = pc; /* #$xxxx */
+			if (opsize == 0)
+				arg1i += 1;
+			pc += 2;
+			if (opsize == 2)
+				pc += 2;
+#ifdef LOGEMU
+			out(" #%.4X", arg1i);
+#endif
+			break;
+		}
+		break;
+	}
+	if (is_reversible)
+		arg1 = effective(arg1i);
+}
+
+/* get addressing mode and set arg2 [1bc5] */
+
+void set_arg2_nosize(int use_dx, type8 b) {
+	if (use_dx)
+		arg2 = (type8 *) dreg;
+	else
+		arg2 = (type8 *) areg;
+	arg2 += (b & 0x0e) << 1;
+}
+
+void set_arg2(int use_dx, type8 b) {
+	set_arg2_nosize(use_dx, b);
+	arg2 = reg_align(arg2, opsize);
+}
+
+/* [1b9e] */
+
+void swap_args(void) {
+	type8 *tmp;
+
+	tmp = arg1;
+	arg1 = arg2;
+	arg2 = tmp;
+}
+
+/* [1cdc] */
+
+void push(type32 c) {
+	write_reg(15, 2, read_reg(15, 2) - 4);
+	write_l(effective(read_reg(15, 2)), c);
+}
+
+/* [1cd1] */
+
+type32 pop(void) {
+	type32 c;
+
+	c = read_l(effective(read_reg(15, 2)));
+	write_reg(15, 2, read_reg(15, 2) + 4);
+	return c;
+}
+
+/* check addressing mode and get argument [2e85] */
+
+void get_arg(void) {
+#ifdef LOGEMU
+	out(" %.4X", pc);
+#endif
+	set_info(byte2);
+	arg2 = effective(pc);
+	pc += 2;
+	if (opsize == 2)
+		pc += 2;
+	if (opsize == 0)
+		arg2 += 1;
+	set_arg1();
+}
+
+void set_flags(void) {
+	type16 i;
+	type32 j;
+
+	zflag = nflag = 0;
+	switch (opsize) {
+	case 0:
+		if (arg1[0] > 127)
+			nflag = 0xff;
+		if (arg1[0] == 0)
+			zflag = 0xff;
+		break;
+	case 1:
+		i = read_w(arg1);
+		if (i == 0)
+			zflag = 0xff;
+		if ((i >> 15) > 0)
+			nflag = 0xff;
+		break;
+	case 2:
+		j = read_l(arg1);
+		if (j == 0)
+			zflag = 0xff;
+		if ((j >> 31) > 0)
+			nflag = 0xff;
+		break;
+	}
+}
+
+/* [263a] */
+
+int condition(type8 b) {
+	switch (b & 0x0f) {
+	case 0:
+		return 0xff;
+	case 1:
+		return 0x00;
+	case 2:
+		return (zflag | cflag) ^ 0xff;
+	case 3:
+		return (zflag | cflag);
+	case 4:
+		return cflag ^ 0xff;
+	case 5:
+		return cflag;
+	case 6:
+		return zflag ^ 0xff;
+	case 7:
+		return zflag;
+	case 8:
+		return vflag ^ 0xff;
+	case 9:
+		return vflag;
+	case 10:
+	case 12:
+		return nflag ^ 0xff;
+	case 11:
+	case 13:
+		return nflag;
+	case 14:
+		return (zflag | nflag) ^ 0xff;
+	case 15:
+		return (zflag | nflag);
+	}
+	return 0x00;
+}
+
+/* [26dc] */
+
+void branch(type8 b) {
+	if (b == 0)
+		pc += (type16s) read_w(effective(pc));
+	else
+		pc += (type8s) b;
+#ifdef LOGEMU
+	out(" %.4X", pc);
+#endif
+}
+
+/* [2869] */
+
+void do_add(type8 adda) {
+	if (adda) {
+		if (opsize == 0)
+			write_l(arg1, read_l(arg1) + (type8s) arg2[0]);
+		if (opsize == 1)
+			write_l(arg1, read_l(arg1) + (type16s) read_w(arg2));
+		if (opsize == 2)
+			write_l(arg1, read_l(arg1) + (type32s) read_l(arg2));
+	} else {
+		cflag = 0;
+		if (opsize == 0) {
+			arg1[0] += arg2[0];
+			if (arg2[0] > arg1[0])
+				cflag = 0xff;
+		}
+		if (opsize == 1) {
+			write_w(arg1, (type16)(read_w(arg1) + read_w(arg2)));
+			if (read_w(arg2) > read_w(arg1))
+				cflag = 0xff;
+		}
+		if (opsize == 2) {
+			write_l(arg1, read_l(arg1) + read_l(arg2));
+			if (read_l(arg2) > read_l(arg1))
+				cflag = 0xff;
+		}
+		if (version < 3 || !quick_flag) {
+			/* Corruption onwards */
+			vflag = 0;
+			set_flags();
+		}
+	}
+}
+
+/* [2923] */
+
+void do_sub(type8 suba) {
+	if (suba) {
+		if (opsize == 0)
+			write_l(arg1, read_l(arg1) - (type8s) arg2[0]);
+		if (opsize == 1)
+			write_l(arg1, read_l(arg1) - (type16s) read_w(arg2));
+		if (opsize == 2)
+			write_l(arg1, read_l(arg1) - (type32s) read_l(arg2));
+	} else {
+		cflag = 0;
+		if (opsize == 0) {
+			if (arg2[0] > arg1[0])
+				cflag = 0xff;
+			arg1[0] -= arg2[0];
+		}
+		if (opsize == 1) {
+			if (read_w(arg2) > read_w(arg1))
+				cflag = 0xff;
+			write_w(arg1, (type16)(read_w(arg1) - read_w(arg2)));
+		}
+		if (opsize == 2) {
+			if (read_l(arg2) > read_l(arg1))
+				cflag = 0xff;
+			write_l(arg1, read_l(arg1) - read_l(arg2));
+		}
+		if (version < 3 || !quick_flag) {
+			/* Corruption onwards */
+			vflag = 0;
+			set_flags();
+		}
+	}
+}
+
+/* [283b] */
+
+void do_eor(void) {
+	if (opsize == 0)
+		arg1[0] ^= arg2[0];
+	if (opsize == 1)
+		write_w(arg1, (type16)(read_w(arg1) ^ read_w(arg2)));
+	if (opsize == 2)
+		write_l(arg1, read_l(arg1) ^ read_l(arg2));
+	cflag = vflag = 0;
+	set_flags();
+}
+
+/* [280d] */
+
+void do_and(void) {
+	if (opsize == 0)
+		arg1[0] &= arg2[0];
+	if (opsize == 1)
+		write_w(arg1, (type16)(read_w(arg1) & read_w(arg2)));
+	if (opsize == 2)
+		write_l(arg1, read_l(arg1) & read_l(arg2));
+	cflag = vflag = 0;
+	set_flags();
+}
+
+/* [27df] */
+
+void do_or(void) {
+	if (opsize == 0)
+		arg1[0] |= arg2[0];
+	if (opsize == 1)
+		write_w(arg1, (type16)(read_w(arg1) | read_w(arg2)));
+	if (opsize == 2)
+		write_l(arg1, read_l(arg1) | read_l(arg2));
+	cflag = vflag = 0;
+	set_flags();    /* [1c2b] */
+}
+
+/* [289f] */
+
+void do_cmp(void) {
+	type8 *tmp;
+
+	tmp = arg1;
+	tmparg[0] = arg1[0];
+	tmparg[1] = arg1[1];
+	tmparg[2] = arg1[2];
+	tmparg[3] = arg1[3];
+	arg1 = tmparg;
+	quick_flag = 0;
+	do_sub(0);
+	arg1 = tmp;
+}
+
+/* [2973] */
+
+void do_move(void) {
+
+	if (opsize == 0)
+		arg1[0] = arg2[0];
+	if (opsize == 1)
+		write_w(arg1, read_w(arg2));
+	if (opsize == 2)
+		write_l(arg1, read_l(arg2));
+	if (version < 2 || admode != 1) {
+		/* Jinxter: no flags if destination Ax */
+		cflag = vflag = 0;
+		set_flags();
+	}
+}
+
+type8 do_btst(type8 a) {
+	a &= admode ? 0x7 : 0x1f;
+	while (admode == 0 && a >= 8) {
+		a -= 8;
+		arg1 -= 1;
+	}
+	zflag = 0;
+	if ((arg1[0] & (1 << a)) == 0)
+		zflag = 0xff;
+	return a;
+}
+
+/* bit operation entry point [307c] */
+
+void do_bop(type8 b, type8 a) {
+#ifdef LOGEMU
+	out("bop (%.2x,%.2x) ", (int) b, (int) a);
+#endif
+	b = b & 0xc0;
+	a = do_btst(a);
+#ifdef LOGEMU
+	if (b == 0x00)
+		out("no bop???");
+#endif
+	if (b == 0x40) {
+		arg1[0] ^= (1 << a);    /* bchg */
+#ifdef LOGEMU
+		out("bchg");
+#endif
+	}
+	if (b == 0x80) {
+		arg1[0] &= ((1 << a) ^ 0xff);   /* bclr */
+#ifdef LOGEMU
+		out("bclr");
+#endif
+	}
+	if (b == 0xc0) {
+		arg1[0] |= (1 << a);    /* bset */
+#ifdef LOGEMU
+		out("bset");
+#endif
+	}
+}
+
+void check_btst(void) {
+#ifdef LOGEMU
+	out("btst");
+#endif
+	set_info((type8)(byte2 & 0x3f));
+	set_arg1();
+	set_arg2(1, byte1);
+	do_bop(byte2, arg2[0]);
+}
+
+void check_lea(void) {
+#ifdef LOGEMU
+	out("lea");
+#endif
+	if ((byte2 & 0xc0) == 0xc0) {
+		set_info(byte2);
+		opsize = 2;
+		set_arg1();
+		set_arg2(0, byte1);
+		write_w(arg2, 0);
+		if (is_reversible)
+			write_l(arg2, arg1i);
+		else
+			ms_fatal("illegal addressing mode for LEA");
+	} else {
+		ms_fatal("unimplemented instruction CHK");
+	}
+}
+
+/* [33cc] */
+
+void check_movem(void) {
+	type8 l1c;
+
+#ifdef LOGEMU
+	out("movem");
+#endif
+	set_info((type8)(byte2 - 0x40));
+	read_word();
+	for (l1c = 0; l1c < 8; l1c++) {
+		if (byte2 & 1 << l1c) {
+			set_arg1();
+			if (opsize == 2)
+				write_l(arg1, read_reg(15 - l1c, 2));
+			if (opsize == 1)
+				write_w(arg1, (type16)read_reg(15 - l1c, 1));
+		}
+	}
+	for (l1c = 0; l1c < 8; l1c++) {
+		if (byte1 & 1 << l1c) {
+			set_arg1();
+			if (opsize == 2)
+				write_l(arg1, read_reg(7 - l1c, 2));
+			if (opsize == 1)
+				write_w(arg1, (type16)read_reg(7 - l1c, 1));
+		}
+	}
+}
+
+/* [3357] */
+
+void check_movem2(void) {
+	type8 l1c;
+
+#ifdef LOGEMU
+	out("movem (2)");
+#endif
+	set_info((type8)(byte2 - 0x40));
+	read_word();
+	for (l1c = 0; l1c < 8; l1c++) {
+		if (byte2 & 1 << l1c) {
+			set_arg1();
+			if (opsize == 2)
+				write_reg(l1c, 2, read_l(arg1));
+			if (opsize == 1)
+				write_reg(l1c, 1, read_w(arg1));
+		}
+	}
+	for (l1c = 0; l1c < 8; l1c++) {
+		if (byte1 & 1 << l1c) {
+			set_arg1();
+			if (opsize == 2)
+				write_reg(8 + l1c, 2, read_l(arg1));
+			if (opsize == 1)
+				write_reg(8 + l1c, 1, read_w(arg1));
+		}
+	}
+}
+
+/* [30e4] in Jinxter, ~540 lines of 6510 spaghetti-code */
+/* The mother of all bugs, but hey - no gotos used :-) */
+
+void dict_lookup(void) {
+	type16 dtab, doff, output, output_bak, bank, word, output2;
+	type16 tmp16, i, obj_adj, adjlist, adjlist_bak;
+	type8 c, c2, c3, flag, matchlen, longest, flag2;
+	type8 restartFlag = 0, accept = 0;
+
+	/*
+	   dtab=A5.W                    ;dict_table offset <L22>
+	   output=output_bak=A2.W       ;output <L24>
+	   A5.W=A6.W                    ;input word
+	   doff=A3.W                    ;lookup offset (doff) <L1C>
+	   adjlist=A0.W ;adjlist <L1E>
+	 */
+
+	dtab = (type16)read_reg(8 + 5, 1);  /* used by version>0 */
+	output = (type16)read_reg(8 + 2, 1);
+	write_reg(8 + 5, 1, read_reg(8 + 6, 1));
+	doff = (type16)read_reg(8 + 3, 1);
+	adjlist = (type16)read_reg(8 + 0, 1);
+
+	bank = (type16)read_reg(6, 0);  /* l2d */
+	flag = 0;       /* l2c */
+	word = 0;       /* l26 */
+	matchlen = 0;       /* l2e */
+	longest = 0;        /* 30e2 */
+	write_reg(0, 1, 0); /* apostroph */
+
+	while ((c = sd ? dict[doff] : effective(doff)[0]) != 0x81) {
+		if (c >= 0x80) {
+			if (c == 0x82) {
+				flag = matchlen = 0;
+				word = 0;
+				write_reg(8 + 6, 1, read_reg(8 + 5, 1));
+				bank++;
+				doff++;
+				continue;
+			}
+			c3 = c;
+			c &= 0x5f;
+			c2 = effective(read_reg(8 + 6, 1))[0] & 0x5f;
+			if (c2 == c) {
+				write_reg(8 + 6, 1, read_reg(8 + 6, 1) + 1);
+				c = effective(read_reg(8 + 6, 1))[0];
+				if ((!c) || (c == 0x20) || (c == 0x27) || (!version && (matchlen > 6))) {
+					if (c == 0x27) {
+						write_reg(8 + 6, 1, read_reg(8 + 6, 1) + 1);
+						write_reg(0, 1, 0x200 + effective(read_reg(8 + 6, 1))[0]);
+					}
+					if ((version < 4) || (c3 != 0xa0))
+						accept = 1;
+				} else
+					restartFlag = 1;
+			} else if (!version && matchlen > 6 && !c2)
+				accept = 1;
+			else
+				restartFlag = 1;
+		} else {
+			c &= 0x5f;
+			c2 = effective(read_reg(8 + 6, 1))[0] & 0x5f;
+			if ((c2 == c && c) || (version && !c2 && (c == 0x5f))) {
+				if (version && !c2 && (c == 0x5f))
+					flag = 0x80;
+				matchlen++;
+				write_reg(8 + 6, 1, read_reg(8 + 6, 1) + 1);
+				doff++;
+			} else if (!version && matchlen > 6 && !c2)
+				accept = 1;
+			else
+				restartFlag = 1;
+		}
+		if (accept) {
+			effective(read_reg(8 + 2, 1))[0] = (version) ? flag : 0;
+			effective(read_reg(8 + 2, 1))[1] = (type8)bank;
+			write_w(effective(read_reg(8 + 2, 1) + 2), word);
+			write_reg(8 + 2, 1, read_reg(8 + 2, 1) + 4);
+			if (matchlen >= longest)
+				longest = matchlen;
+			restartFlag = 1;
+			accept = 0;
+		}
+		if (restartFlag) {
+			write_reg(8 + 6, 1, read_reg(8 + 5, 1));
+			flag = matchlen = 0;
+			word++;
+			if (sd)
+				while (dict[doff++] < 0x80);
+			else
+				while (effective(doff++)[0] < 0x80);
+			restartFlag = 0;
+		}
+	}
+	write_w(effective(read_reg(8 + 2, 1)), 0xffff);
+
+	if (version) {
+		/* version > 0 */
+		output_bak = output;    /* check synonyms */
+		while ((c = effective(output)[1]) != 0xff) {
+			if (c == 0x0b) {
+				if (sd)
+					tmp16 = read_w(&dict[dtab + read_w(effective(output + 2)) * 2]);
+				else
+					tmp16 = read_w(effective(dtab + read_w(effective(output + 2)) * 2));
+				effective(output)[1] = tmp16 & 0x1f;
+				write_w(effective(output + 2), (type16)(tmp16 >> 5));
+			}
+			output += 4;
+		}
+		output = output_bak;
+	}
+
+	/* l22 = output2,     l1e = adjlist, l20 = obj_adj, l26 = word, l2f = c2 */
+	/* l1c = adjlist_bak, 333C = i,      l2d = bank,    l2c = flag, l30e3 = flag2 */
+
+	write_reg(1, 1, 0); /* D1.W=0  [32B5] */
+	flag2 = 0;
+	output_bak = output;
+	output2 = output;
+	while ((bank = effective(output2)[1]) != 0xff) {
+		obj_adj = (type16)read_reg(8 + 1, 1);   /* A1.W - obj_adj, ie. adjs for this word */
+		write_reg(1, 0, 0); /* D1.B=0 */
+		flag = effective(output2)[0];   /* flag */
+		word = read_w(effective(output2 + 2));  /* wordnumber */
+		output2 += 4;   /* next match */
+		if ((read_w(effective(obj_adj))) && (bank == 6)) {
+			/* Any adjectives? */
+			if ((i = word) != 0) {
+				/* Find list of valid adjs */
+				do {
+					while (effective(adjlist++)[0]);
+				} while (--i > 0);
+			}
+			adjlist_bak = adjlist;
+			do {
+				adjlist = adjlist_bak;
+				c2 = effective(obj_adj)[1]; /* given adjective */
+				if ((tmp16 = read_w(effective(obj_adj))) != 0) {
+					obj_adj += 2;
+					while ((c = effective(adjlist++)[0]) && (c - 3 != c2));
+					if (c - 3 != c2)
+						write_reg(1, 0, 1); /* invalid adjective */
+				}
+			} while (tmp16 && !read_reg(1, 0));
+			adjlist = (type16)read_reg(8 + 0, 1);
+		}
+		if (!read_reg(1, 0)) {
+			/* invalid_flag */
+			flag2 |= flag;
+			effective(output)[0] = flag2;
+			effective(output)[1] = (type8)bank;
+			write_w(effective(output + 2), word);
+			output += 4;
+		}
+	}
+	write_reg(8 + 2, 1, output);
+	output = output_bak;
+
+	if (flag2 & 0x80) {
+		tmp16 = output;
+		output -= 4;
+		do {
+			output += 4;
+			c = effective(output)[0];
+		} while (!(c & 0x80));
+		write_l(effective(tmp16), read_l(effective(output)) & 0x7fffffff);
+		write_reg(8 + 2, 2, tmp16 + 4);
+		if (longest > 1) {
+			write_reg(8 + 5, 1, read_reg(8 + 5, 1) + longest - 2);
+		}
+	}
+	write_reg(8 + 6, 1, read_reg(8 + 5, 1) + 1);
+}
+
+/* A0=findproperties(D0) [2b86], properties_ptr=[2b78] A0FE */
+
+void do_findprop(void) {
+	type16 tmp;
+
+	if ((version > 2) && ((read_reg(0, 1) & 0x3fff) > fp_size)) {
+		tmp = (type16)(((fp_size - (read_reg(0, 1) & 0x3fff)) ^ 0xffff) << 1);
+		tmp += fp_tab;
+		tmp = read_w(effective(tmp));
+	} else {
+		if (version < 2)
+			write_reg(0, 2, read_reg(0, 2) & 0x7fff);
+		else
+			write_reg(0, 1, read_reg(0, 1) & 0x7fff);
+		tmp = (type16)read_reg(0, 1);
+	}
+	tmp &= 0x3fff;
+	write_reg(8 + 0, 2, tmp * 14 + properties);
+}
+
+void write_string(void) {
+	static type32 offset_bak;
+	static type8 mask_bak;
+	type8 c, b, mask;
+	type16 ptr;
+	type32 offset;
+
+	if (!cflag) {
+		/* new string */
+		ptr = (type16)read_reg(0, 1);
+		if (!ptr)
+			offset = 0;
+		else {
+			offset = read_w(&decode_table[0x100 + 2 * ptr]);
+			if (read_w(&decode_table[0x100])) {
+				if (ptr >= read_w(&decode_table[0x100]))
+					offset += string_size;
+			}
+		}
+		mask = 1;
+	} else {
+		offset = offset_bak;
+		mask = mask_bak;
+	}
+	do {
+		c = 0;
+		while (c < 0x80) {
+			if (offset >= string_size)
+				b = string2[offset - string_size];
+			else {
+				if (offset >= MAX_STRING_SIZE)
+					b = string3[offset - MAX_STRING_SIZE];
+				else
+					b = string[offset];
+			}
+			if (b & mask)
+				c = decode_table[0x80 + c];
+			else
+				c = decode_table[c];
+			mask <<= 1;
+			if (!mask) {
+				mask = 1;
+				offset++;
+			}
+		}
+		c &= 0x7f;
+		if (c && ((c != 0x40) || (lastchar != 0x20)))
+			char_out(c);
+	} while (c && ((c != 0x40) || (lastchar != 0x20)));
+	cflag = c ? 0xff : 0;
+	if (c) {
+		offset_bak = offset;
+		mask_bak = mask;
+	}
+}
+
+void output_number(type16 number) {
+	type16 tens = number / 10;
+
+	if (tens > 0)
+		ms_putchar('0' + tens);
+	number -= (tens * 10);
+	ms_putchar('0' + number);
+}
+
+type16 output_text(const char *text) {
+	type16 i;
+
+	for (i = 0; text[i] != 0; i++)
+		ms_putchar(text[i]);
+	return i;
+}
+
+type16s hint_input(void) {
+	type8 c1, c2, c3;
+
+	output_text(">>");
+	ms_flush();
+
+	do {
+		c1 = ms_getchar(0);
+	} while (c1 == '\n');
+	if (c1 == 1)
+		return -1; /* New game loaded, abort hints */
+
+	c2 = ms_getchar(0);
+	if (c2 == 1)
+		return -1;
+
+	/* Get and discard any remaining characters */
+	c3 = c2;
+	while (c3 != '\n') {
+		c3 = ms_getchar(0);
+		if (c3 == 1)
+			return -1;
+	}
+	ms_putchar('\n');
+
+	if ((c1 >= '0') && (c1 <= '9')) {
+		type16 number = c1 - '0';
+		if ((c2 >= '0') && (c2 <= '9')) {
+			number *= 10;
+			number += c2 - '0';
+		}
+		return number;
+	}
+
+	if ((c1 >= 'A') && (c1 <= 'Z'))
+		c1 = 'a' + (c1 - 'A');
+	if ((c1 >= 'a') && (c1 <= 'z')) {
+		switch (c1) {
+		case 'e':
+			return -2; /* End hints */
+		case 'n':
+			return -3; /* Next hint */
+		case 'p':
+			return -4; /* Show parent hint list */
+		}
+	}
+	return 0;
+}
+
+type16 show_hints_text(ms_hint *hintsData, type16 index) {
+	type16 i = 0, j = 0;
+	type16s input;
+	ms_hint *hint = hintsData + index;
+
+	while (1) {
+		switch (hint->nodetype) {
+
+		case 1: /* folders */
+			output_text("Hint categories:\n");
+			for (i = 0, j = 0; i < hint->elcount; i++) {
+				output_number(i + 1);
+				output_text(". ");
+				j += output_text(hint->content + j) + 1;
+				ms_putchar('\n');
+			}
+			output_text("Enter hint category number, ");
+			if (hint->parent != 0xffff)
+				output_text("P for the parent hint menu, ");
+			output_text("or E to end hintsData.\n");
+
+			input = hint_input();
+			switch (input) {
+			case -1: /* A new game is being loaded */
+				return 1;
+			case -2: /* End hintsData */
+				return 1;
+			case -4: /* Show parent hint list */
+				if (hint->parent != 0xffff)
+					return 0;
+			default:
+				if ((input > 0) && (input <= hint->elcount)) {
+					if (show_hints_text(hintsData, hint->links[input - 1]) == 1)
+						return 1;
+				}
+				break;
+			}
+			break;
+
+		case 2: /* hintsData */
+			if (i < hint->elcount) {
+				output_number(i + 1);
+				output_text(". ");
+				j += output_text(hint->content + j) + 1;
+
+				if (i == hint->elcount - 1) {
+					output_text("\nNo more hintsData.\n");
+					return 0; /* Last hint */
+				} else {
+					output_text("\nEnter N for the next hint, ");
+					output_text("P for the parent hint menu, ");
+					output_text("or E to end hintsData.\n");
+				}
+
+				input = hint_input();
+				switch (input) {
+				case -1: /* A new game is being loaded */
+					return 1;
+				case -2: /* End hintsData */
+					return 1;
+				case -3:
+					i++;
+					break;
+				case -4: /* Show parent hint list */
+					return 0;
+				}
+			} else
+				return 0;
+			break;
+		}
+	}
+	return 0;
+}
+
+void do_line_a(void) {
+	type8 l1c;
+	char *str;
+	type16 ptr, ptr2, tmp16, dtype;
+	type32 a1reg, tmp32;
+
+#ifdef LOGGFX
+	/*
+	    if (((byte2-0xdd) == 4) || ((byte2-0xdd) == 13))
+	        out2("--> %d\n",byte2-0xdd);
+	    else
+	        out2("LINE A %d\n",byte2-0xdd);
+	 */
+#endif
+	if ((byte2 < 0xdd) || (version < 4 && byte2 < 0xe4) || (version < 2 && byte2 < 0xed)) {
+		ms_flush(); /* flush output-buffer */
+		rand_emu(); /* Increase game randomness */
+		l1c = ms_getchar(1);    /* 0 means UNDO */
+		if (l1c == 1)
+			return;
+		if (l1c)
+			write_reg(1, 2, l1c);   /* d1=getkey() */
+		else {
+			if ((l1c = ms_undo()) != 0)
+				output_text(undo_ok);
+			else
+				output_text(undo_fail);
+			if (!l1c)
+				write_reg(1, 2, '\n');
+		}
+	} else
+		switch (byte2 - 0xdd) {
+
+		case 0: /* A0DD - Won't probably be needed at all */
+			break;
+
+		case 1: /* A0DE */
+			write_reg(1, 0, 1); /* Should remove the manual check */
+			break;
+
+		case 2: /* A0DF */
+			a1reg = (type32)read_reg(9, 2);
+			dtype = (code + a1reg + 2)[0];
+
+			switch (dtype) {
+			case 7: /* Picture */
+#ifdef LOGGFX
+				out2("PICTURE IS %s\n", code + a1reg + 3);
+#endif
+				/* gfx mode = normal, df is not called if graphics are off */
+				ms_showpic(a1reg + 3, 2);
+				break;
+
+			case 10: /* Open window commands */
+				switch ((code + a1reg + 3)[0]) {
+				case 4: /* Help/Hints */
+					if (hints != 0) {
+						if (ms_showhints(hints) == 0)
+							show_hints_text(hints, 0);
+					} else
+						output_text(no_hints);
+					break;
+				case 0: /* Carried items */
+				case 1: /* Room items */
+				case 2: /* Map */
+				case 3: /* Compass */
+					output_text(not_supported);
+					break;
+				}
+				break;
+
+			case 13: /* Music */
+				switch ((code + a1reg + 3)[0]) {
+				case 0: /* stop music */
+					ms_playmusic(0, 0, 0);
+					break;
+				default: /* play music */
+#ifdef LOGSND
+					out2("MUSIC IS %s\n", code + a1reg + 3);
+#endif
+					{
+						type32 length = 0;
+						type16 tempo = 0;
+						type8 *midi = sound_extract((const char *)(code + a1reg + 3), &length, &tempo);
+						if (midi != NULL)
+							ms_playmusic(midi, length, tempo);
+					}
+					break;
+				}
+				break;
+			}
+			break;
+
+		case 3: /* A0E0 */
+			/* printf("A0E0 stubbed\n"); */
+			break;
+
+		case 4: /* A0E1 Read from keyboard to (A1), status in D1 (0 for ok) */
+			ms_flush();
+			rand_emu();
+			tmp32 = read_reg(8 + 1, 2);
+			str = (char *)effective(tmp32);
+			tmp16 = 0;
+			do {
+				if (!(l1c = ms_getchar(1))) {
+					if ((l1c = ms_undo()) != 0)
+						output_text(undo_ok);
+					else
+						output_text(undo_fail);
+					if (!l1c) {
+						tmp16 = 0;
+						str[tmp16++] = '\n';
+						l1c = '\n';
+						output_text("\n>");
+					} else {
+						ms_putchar('\n');
+						return;
+					}
+				} else {
+					if (l1c == 1)
+						return;
+					str[tmp16++] = l1c;
+#ifdef LOGGFX
+					out2("%c", l1c);
+#endif
+				}
+			} while (l1c != '\n' && tmp16 < 256);
+			write_reg(8 + 1, 2, tmp32 + tmp16 - 1);
+			if (tmp16 != 256 && tmp16 != 1)
+				write_reg(1, 1, 0);
+			else
+				write_reg(1, 1, 1);
+			break;
+
+		case 5: /* A0E2 */
+			/* printf("A0E2 stubbed\n"); */
+			break;
+
+		case 6: /* A0E3 */
+			if (read_reg(1, 2) == 0) {
+				if ((version < 4) || (read_reg(6, 2) == 0))
+					ms_showpic(0, 0);
+			}
+			/* printf("\nMoves: %u\n",read_reg(0,1)); */
+			break;
+
+		case 7: /* A0E4 sp+=4, RTS */
+			write_reg(8 + 7, 1, read_reg(8 + 7, 1) + 4);
+			pc = pop();
+			break;
+
+		case 8: /* A0E5 set z, RTS */
+		case 9: /* A0E6 clear z, RTS */
+			pc = pop();
+			zflag = (byte2 == 0xe5) ? 0xff : 0;
+			break;
+
+		case 10: /* A0E7 set z */
+			zflag = 0xff;
+			break;
+
+		case 11: /* A0E8 clear z */
+			zflag = 0;
+			break;
+
+		case 12: /* A0E9 [3083 - j] */
+			ptr = (type16)read_reg(8 + 0, 1);
+			ptr2 = (type16)read_reg(8 + 1, 1);
+			do {
+				l1c = dict[ptr2++];
+				effective(ptr++)[0] = l1c;
+			} while ((l1c & 0x80) == 0);
+			write_reg(8 + 0, 1, ptr);
+			write_reg(8 + 1, 1, ptr2);
+			break;
+
+		case 13: /* A0EA A1=write_dictword(A1,D1=output_mode) */
+			ptr = (type16)read_reg(8 + 1, 1);
+			tmp32 = read_reg(3, 0);
+			write_reg(3, 0, read_reg(1, 0));
+			do {
+				l1c = dict[ptr++];
+				char_out(l1c);
+			} while (l1c < 0x80);
+			write_reg(8 + 1, 1, ptr);
+			write_reg(3, 0, tmp32);
+			break;
+
+		case 14: /* A0EB [3037 - j] */
+			dict[read_reg(8 + 1, 1)] = (type8)read_reg(1, 0);
+			break;
+
+		case 15: /* A0EC */
+			write_reg(1, 0, dict[read_reg(8 + 1, 1)]);
+			break;
+
+		case 16:
+			ms_stop();  /* infinite loop A0ED */
+			break;
+		case 17:
+			if (!ms_init(nullptr, nullptr, nullptr, nullptr))
+				ms_stop();  /* restart game ie. pc, sp etc. A0EE */
+			break;
+		case 18:    /* printer A0EF */
+			break;
+		case 19:
+			ms_showpic(read_reg(0, 0), (type8)read_reg(1, 0));  /* Do_picture(D0) A0F0 */
+			break;
+		case 20:
+			ptr = (type16)read_reg(8 + 1, 1);   /* A1=nth_string(A1,D0) A0F1 */
+			tmp32 = read_reg(0, 1);
+			while (tmp32-- > 0) {
+				while (effective(ptr++)[0]);
+			}
+			write_reg(8 + 1, 1, ptr);
+			break;
+
+		case 21: /* [2a43] A0F2 */
+			cflag = 0;
+			write_reg(0, 1, read_reg(2, 1));
+			do_findprop();
+			ptr = (type16)read_reg(8 + 0, 1);
+			while (read_reg(2, 1) > 0) {
+				if (read_w(effective(ptr + 12)) & 0x3fff) {
+					cflag = 0xff;
+					break;
+				}
+				if (read_reg(2, 1) == (read_reg(4, 1) & 0x7fff)) {
+					cflag = 0xff;
+					break;
+				}
+				ptr -= 0x0e;
+				write_reg(2, 1, read_reg(2, 1) - 1);
+			}
+			break;
+
+		case 22:
+			char_out((type8)read_reg(1, 0));    /* A0F3 */
+			break;
+
+		case 23: /* D7=Save_(filename A0) D1 bytes starting from A1  A0F4 */
+			str = (version < 4) ? (char *)effective(read_reg(8 + 0, 1)) : nullptr;
+			write_reg(7, 0, ms_save_file(str, effective(read_reg(8 + 1, 1)),
+			                             (type16)read_reg(1, 1)));
+			break;
+
+		case 24: /* D7=Load_(filename A0) D1 bytes starting from A1  A0F5 */
+			str = (version < 4) ? (char *)effective(read_reg(8 + 0, 1)) : nullptr;
+			write_reg(7, 0, ms_load_file(str, effective(read_reg(8 + 1, 1)),
+			                             (type16)read_reg(1, 1)));
+			break;
+
+		case 25: /* D1=Random(0..D1-1) [3748] A0F6 */
+			l1c = (type8)read_reg(1, 0);
+			write_reg(1, 1, rand_emu() % (l1c ? l1c : 1));
+			break;
+
+		case 26: /* D0=Random(0..255) [3742] A0F7 */
+			tmp16 = (type16)rand_emu();
+			write_reg(0, 0, tmp16 + (tmp16 >> 8));
+			break;
+
+		case 27: /* write string [D0] [2999] A0F8 */
+			write_string();
+			break;
+
+		case 28: /* Z,D0=Get_inventory_item(D0) [2a9e] A0F9 */
+			zflag = 0;
+			ptr = (type16)read_reg(0, 1);
+			do {
+				write_reg(0, 1, ptr);
+				do {
+					do_findprop();
+					ptr2 = (type16)read_reg(8 + 0, 1);  /* object properties */
+					if ((effective(ptr2)[5]) & 1)
+						break;  /* is_described or so */
+					l1c = effective(ptr2)[6];   /* some_flags */
+					tmp16 = read_w(effective(ptr2 + 8));    /* parent_object */
+					if (!l1c) {
+						/* ordinary object? */
+						if (!tmp16)
+							zflag = 0xff;   /* return if parent()=player */
+						break;  /* otherwise try next */
+					}
+					if (l1c & 0xcc)
+						break;  /* skip worn, bodypart, room, hidden */
+					if (tmp16 == 0) {
+						/* return if parent()=player? */
+						zflag = 0xff;
+						break;
+					}
+					write_reg(0, 1, tmp16); /* else look at parent() */
+				} while (1);
+				ptr--;
+			} while ((!zflag) && ptr);
+			write_reg(0, 1, ptr + 1);
+			break;
+
+		case 29: /* [2b18] A0FA */
+			ptr = (type16)read_reg(8, 1);
+			do {
+				if (read_reg(5, 0)) {
+					l1c = ((type32)((read_w(effective(ptr)) & 0x3fff)) == read_reg(2, 1));
+				} else {
+					l1c = (effective(ptr)[0] == read_reg(2, 0));
+				}
+				if (read_reg(3, 1) == read_reg(4, 1)) {
+					cflag = 0;
+					write_reg(8, 1, ptr);
+				} else {
+					write_reg(3, 1, read_reg(3, 1) + 1);
+					ptr += 0x0e;
+					if (l1c) {
+						cflag = 0xff;
+						write_reg(8, 1, ptr);
+					}
+				}
+			} while ((!l1c) && (read_reg(3, 1) != read_reg(4, 1)));
+			break;
+
+		case 30: /* [2bd1] A0FB */
+			ptr = (type16)read_reg(8 + 1, 1);
+			do {
+				if (dict)
+					while (dict[ptr++] < 0x80);
+				else
+					while (effective(ptr++)[0] < 0x80);
+				write_reg(2, 1, read_reg(2, 1) - 1);
+			} while (read_reg(2, 1));
+			write_reg(8 + 1, 1, ptr);
+			break;
+
+		case 31: /* [2c3b] A0FC */
+			ptr = (type16)read_reg(8 + 0, 1);
+			ptr2 = (type16)read_reg(8 + 1, 1);
+			do {
+				if (dict)
+					while (dict[ptr++] < 0x80);
+				else
+					while (effective(ptr++)[0] < 0x80);
+				while (effective(ptr2++)[0]);
+				write_reg(0, 1, read_reg(0, 1) - 1);
+			} while (read_reg(0, 1));
+			write_reg(8 + 0, 1, ptr);
+			write_reg(8 + 1, 1, ptr2);
+			break;
+
+		case 32: /* Set properties pointer from A0 [2b7b] A0FD */
+			properties = (type16)read_reg(8 + 0, 1);
+			if (version > 0)
+				fl_sub = (type16)read_reg(8 + 3, 1);
+			if (version > 1) {
+				fl_tab = (type16)read_reg(8 + 5, 1);
+				fl_size = (type16)read_reg(7, 1) + 1;
+				/* A3 [routine], A5 [table] and D7 [table-size] */
+			}
+			if (version > 2) {
+				fp_tab = (type16)read_reg(8 + 6, 1);
+				fp_size = (type16)read_reg(6, 1);
+			}
+			break;
+
+		case 33: /* A0FE */
+			do_findprop();
+			break;
+
+		case 34: /* Dictionary_lookup A0FF */
+			dict_lookup();
+			break;
+		}
+}
+
+/* emulate an instruction [1b7e] */
+
+type8 ms_rungame(void) {
+	type8 l1c;
+	type16 ptr;
+	type32 tmp32;
+#ifdef LOGEMU
+	static int stat = 0;
+#endif
+
+	if (!running)
+		return running;
+	if (pc == undo_pc)
+		save_undo();
+
+#ifdef LOGEMU
+	if (pc == 0x0000)
+		stat = 0;
+	if (stat) {
+		log_status();
+		fflush(dbg_log);
+	}
+
+	fprintf(dbg_log, "%.8X: ", pc);
+#endif
+	i_count++;
+	read_word();
+	switch (byte1 >> 1) {
+
+	/* 00-0F */
+	case 0x00:
+		if (byte1 == 0x00) {
+			if (byte2 == 0x3c || byte2 == 0x7c) {
+				/* OR immediate to CCR (30D9) */
+				read_word();
+#ifdef LOGEMU
+				out("or_ccr #%.2x", byte2);
+#endif
+				if (byte2 & 0x01)
+					cflag = 0xff;
+				if (byte2 & 0x02)
+					vflag = 0xff;
+				if (byte2 & 0x04)
+					zflag = 0xff;
+				if (byte2 & 0x08)
+					nflag = 0xff;
+			} else {
+				/* OR [27df] */
+#ifdef LOGEMU
+				out("or");
+#endif
+				get_arg();
+				do_or();
+			}
+		} else
+			check_btst();
+		break;
+
+	case 0x01:
+		if (byte1 == 0x02) {
+			if (byte2 == 0x3c || byte2 == 0x7c) {
+				/* AND immediate to CCR */
+				read_word();
+#ifdef LOGEMU
+				out("and_ccr #%.2x", byte2);
+#endif
+				if (!(byte2 & 0x01))
+					cflag = 0;
+				if (!(byte2 & 0x02))
+					vflag = 0;
+				if (!(byte2 & 0x04))
+					zflag = 0;
+				if (!(byte2 & 0x08))
+					nflag = 0;
+			} else {
+				/* AND */
+#ifdef LOGEMU
+				out("and");
+#endif
+				get_arg();
+				do_and();
+			}
+		} else
+			check_btst();
+		break;
+
+	case 0x02:
+		if (byte1 == 0x04) {
+			/* SUB */
+#ifdef LOGEMU
+			out("sub");
+#endif
+			get_arg();
+			do_sub(0);
+		} else
+			check_btst();
+		break;
+
+	case 0x03:
+		if (byte1 == 0x06) {
+			/* ADD */
+#ifdef LOGEMU
+			out("addi");
+#endif
+			get_arg();
+			do_add(0);
+		} else
+			check_btst();
+		break;
+
+	case 0x04:
+		if (byte1 == 0x08) {
+			/* bit operations (immediate) */
+			set_info((type8)(byte2 & 0x3f));
+			l1c = (effective(pc))[1];
+			pc += 2;
+			set_arg1();
+			do_bop(byte2, l1c);
+		} else
+			check_btst();
+		break;
+
+	case 0x05:
+		if (byte1 == 0x0a) {
+			if (byte2 == 0x3c || byte2 == 0x7c) {
+				/* EOR immediate to CCR */
+				read_word();
+#ifdef LOGEMU
+				out("eor_ccr #%.2X", byte2);
+#endif
+				if (byte2 & 0x01)
+					cflag ^= 0xff;
+				if (byte2 & 0x02)
+					vflag ^= 0xff;
+				if (byte2 & 0x04)
+					zflag ^= 0xff;
+				if (byte2 & 0x08)
+					nflag ^= 0xff;
+			} else {
+				/* EOR */
+#ifdef LOGEMU
+				out("eor");
+#endif
+				get_arg();
+				do_eor();
+			}
+		} else
+			check_btst();
+		break;
+
+	case 0x06:
+		if (byte1 == 0x0c) {
+			/* CMP */
+#ifdef LOGEMU
+			out("cmp");
+#endif
+			get_arg();
+			do_cmp();
+		} else
+			check_btst();
+		break;
+
+	case 0x07:
+		check_btst();
+		break;
+
+	/* 10-1F [3327] MOVE.B */
+	case 0x08:
+	case 0x09:
+	case 0x0a:
+	case 0x0b:
+	case 0x0c:
+	case 0x0d:
+	case 0x0e:
+	case 0x0f:
+
+#ifdef LOGEMU
+		out("move.b");
+#endif
+		set_info((type8)(byte2 & 0x3f));
+		set_arg1();
+		swap_args();
+		l1c = (byte1 >> 1 & 0x07) | (byte2 >> 3 & 0x18) | (byte1 << 5 & 0x20);
+		set_info(l1c);
+		set_arg1();
+		do_move();
+		break;
+
+	/* 20-2F [32d1] MOVE.L */
+	case 0x10:
+	case 0x11:
+	case 0x12:
+	case 0x13:
+	case 0x14:
+	case 0x15:
+	case 0x16:
+	case 0x17:
+
+#ifdef LOGEMU
+		out("move.l");
+#endif
+		set_info((type8)((byte2 & 0x3f) | 0x80));
+		set_arg1();
+		swap_args();
+		l1c = (byte1 >> 1 & 0x07) | (byte2 >> 3 & 0x18) | (byte1 << 5 & 0x20);
+		set_info((type8)(l1c | 0x80));
+		set_arg1();
+		do_move();
+		break;
+
+	/* 30-3F [3327] MOVE.W */
+	case 0x18:
+	case 0x19:
+	case 0x1a:
+	case 0x1b:
+	case 0x1c:
+	case 0x1d:
+	case 0x1e:
+	case 0x1f:
+
+#ifdef LOGEMU
+		out("move.w");
+#endif
+		set_info((type8)((byte2 & 0x3f) | 0x40));
+		set_arg1();
+		swap_args();
+		l1c = (byte1 >> 1 & 0x07) | (byte2 >> 3 & 0x18) | (byte1 << 5 & 0x20);
+		set_info((type8)(l1c | 0x40));
+		set_arg1();
+		do_move();
+		break;
+
+	/* 40-4F various commands */
+
+	case 0x20:
+		if (byte1 == 0x40) {
+			/* [31d5] */
+			ms_fatal("unimplemented instructions NEGX and MOVE SR,xx");
+		} else
+			check_lea();
+		break;
+
+	case 0x21:
+		if (byte1 == 0x42) {
+			/* [3188] */
+			if ((byte2 & 0xc0) == 0xc0) {
+				ms_fatal("unimplemented instruction MOVE CCR,xx");
+			} else {
+				/* CLR */
+#ifdef LOGEMU
+				out("clr");
+#endif
+				set_info(byte2);
+				set_arg1();
+				if (opsize == 0)
+					arg1[0] = 0;
+				if (opsize == 1)
+					write_w(arg1, 0);
+				if (opsize == 2)
+					write_l(arg1, 0);
+				nflag = cflag = 0;
+				zflag = 0xff;
+			}
+		} else
+			check_lea();
+		break;
+
+	case 0x22:
+		if (byte1 == 0x44) {
+			/* [31a0] */
+			if ((byte2 & 0xc0) == 0xc0) {
+				/* MOVE to CCR */
+#ifdef LOGEMU
+				out("move_ccr");
+#endif
+				zflag = nflag = cflag = vflag = 0;
+				set_info((type8)(byte2 & 0x7f));
+				set_arg1();
+				byte2 = arg1[1];
+				if (byte2 & 0x01)
+					cflag = 0xff;
+				if (byte2 & 0x02)
+					vflag = 0xff;
+				if (byte2 & 0x04)
+					zflag = 0xff;
+				if (byte2 & 0x08)
+					nflag = 0xff;
+			} else {
+#ifdef LOGEMU
+				out("neg");
+#endif
+				set_info(byte2);    /* NEG */
+				set_arg1();
+				cflag = 0xff;
+				if (opsize == 0) {
+					arg1[0] = (-arg1[0]);
+					cflag = arg1[0] ? 0xff : 0;
+				}
+				if (opsize == 1) {
+					write_w(arg1, (type16)(-1 * read_w(arg1)));
+					cflag = read_w(arg1) ? 0xff : 0;
+				}
+				if (opsize == 2) {
+					write_l(arg1, -1 * read_l(arg1));
+					cflag = read_l(arg1) ? 0xff : 0;
+				}
+				vflag = 0;
+				set_flags();
+			}
+		} else
+			check_lea();
+		break;
+
+	case 0x23:
+		if (byte1 == 0x46) {
+			if ((byte2 & 0xc0) == 0xc0) {
+				ms_fatal("unimplemented instruction MOVE xx,SR");
+			} else {
+#ifdef LOGEMU
+				out("not");
+#endif
+				set_info(byte2);    /* NOT */
+				set_arg1();
+				tmparg[0] = tmparg[1] = tmparg[2] = tmparg[3] = 0xff;
+				arg2 = tmparg;
+				do_eor();
+			}
+		} else
+			check_lea();
+		break;
+
+	case 0x24:
+		if (byte1 == 0x48) {
+			if ((byte2 & 0xf8) == 0x40) {
+#ifdef LOGEMU
+				out("swap");
+#endif
+				opsize = 2; /* SWAP */
+				admode = 0;
+				regnr = byte2 & 0x07;
+				set_arg1();
+				tmp32 = read_w(arg1);
+				write_w(arg1, read_w(arg1 + 2));
+				write_w(arg1 + 2, (type16)tmp32);
+				set_flags();
+			} else if ((byte2 & 0xf8) == 0x80) {
+#ifdef LOGEMU
+				out("ext.w");
+#endif
+				opsize = 1; /* EXT.W */
+				admode = 0;
+				regnr = byte2 & 0x07;
+				set_arg1();
+				if (arg1[1] > 0x7f)
+					arg1[0] = 0xff;
+				else
+					arg1[0] = 0;
+				set_flags();
+			} else if ((byte2 & 0xf8) == 0xc0) {
+#ifdef LOGEMU
+				out("ext.l");
+#endif
+				opsize = 2; /* EXT.L */
+				admode = 0;
+				regnr = byte2 & 0x07;
+				set_arg1();
+				if (read_w(arg1 + 2) > 0x7fff)
+					write_w(arg1, 0xffff);
+				else
+					write_w(arg1, 0);
+				set_flags();
+			} else if ((byte2 & 0xc0) == 0x40) {
+#ifdef LOGEMU
+				out("pea");
+#endif
+				set_info((type8)((byte2 & 0x3f) | 0x80));   /* PEA */
+				set_arg1();
+				if (is_reversible)
+					push(arg1i);
+				else
+					ms_fatal("illegal addressing mode for PEA");
+			} else {
+				check_movem();  /* MOVEM */
+			}
+		} else
+			check_lea();
+		break;
+
+	case 0x25:
+		if (byte1 == 0x4a) {
+			/* [3219] TST */
+			if ((byte2 & 0xc0) == 0xc0) {
+				ms_fatal("unimplemented instruction TAS");
+			} else {
+#ifdef LOGEMU
+				out("tst");
+#endif
+				set_info(byte2);
+				set_arg1();
+				cflag = vflag = 0;
+				set_flags();
+			}
+		} else
+			check_lea();
+		break;
+
+	case 0x26:
+		if (byte1 == 0x4c)
+			check_movem2();     /* [3350] MOVEM.L (Ax)+,A/Dx */
+		else
+			check_lea();    /* LEA */
+		break;
+
+	case 0x27:
+		if (byte1 == 0x4e) {
+			/* [3290] */
+			if (byte2 == 0x75) {
+				/* RTS */
+#ifdef LOGEMU
+				out("rts\n");
+#endif
+				pc = pop();
+			} else if (byte2 == 0x71) {
+				/* NOP */
+#ifdef LOGEMU
+				out("nop");
+#endif
+			} else if ((byte2 & 0xc0) == 0xc0) {
+				/* indir JMP */
+#ifdef LOGEMU
+				out("jmp");
+#endif
+				set_info((type8)(byte2 | 0xc0));
+				set_arg1();
+				if (is_reversible)
+					pc = arg1i;
+				else
+					ms_fatal("illegal addressing mode for JMP");
+			} else if ((byte2 & 0xc0) == 0x80) {
+#ifdef LOGEMU
+				out("jsr");
+#endif
+				set_info((type8)(byte2 | 0xc0));        /* indir JSR */
+				set_arg1();
+				push(pc);
+				if (is_reversible)
+					pc = arg1i;
+				else
+					ms_fatal("illegal addressing mode for JSR");
+			} else {
+				ms_fatal("unimplemented instructions 0x4EXX");
+			}
+		} else
+			check_lea();    /* LEA */
+		break;
+
+	/* 50-5F [2ed5] ADDQ/SUBQ/Scc/DBcc */
+	case 0x28:
+	case 0x29:
+	case 0x2a:
+	case 0x2b:
+	case 0x2c:
+	case 0x2d:
+	case 0x2e:
+	case 0x2f:
+
+		if ((byte2 & 0xc0) == 0xc0) {
+			set_info((type8)(byte2 & 0x3f));
+			set_arg1();
+			if (admode == 1) {
+				/* DBcc */
+#ifdef LOGEMU
+				out("dbcc");
+#endif
+				if (condition(byte1) == 0) {
+					arg1 = (arg1 - (type8 *) areg) + (type8 *) dreg - 1;
+					write_w(arg1, (type16)(read_w(arg1) - 1));
+					if (read_w(arg1) != 0xffff)
+						branch(0);
+					else
+						pc += 2;
+				} else
+					pc += 2;
+			} else {
+				/* Scc */
+#ifdef LOGEMU
+				out("scc");
+#endif
+				arg1[0] = condition(byte1) ? 0xff : 0;
+			}
+		} else {
+			set_info(byte2);
+			set_arg1();
+			quick_flag = (admode == 1) ? 0xff : 0;
+			l1c = byte1 >> 1 & 0x07;
+			tmparg[0] = tmparg[1] = tmparg[2] = 0;
+			tmparg[3] = l1c ? l1c : 8;
+			arg2 = reg_align(tmparg, opsize);
+			{
+#ifdef LOGEMU
+				type32s outnum = 0;
+				switch (opsize) {
+				case 0:
+					outnum = (type8s) arg2[0];
+					break;
+				case 1:
+					outnum = (type16s) read_w(arg2);
+					break;
+				case 2:
+					outnum = (type32s) read_l(arg2);
+					break;
+				}
+#endif
+				if ((byte1 & 0x01) == 1) {
+#ifdef LOGEMU
+					out("subq #%.8X", outnum);
+#endif
+					do_sub(0);  /* SUBQ */
+				} else {
+#ifdef LOGEMU
+					out("addq #%.8X", outnum);
+#endif
+					do_add(0);  /* ADDQ */
+				}
+			}
+		}
+		break;
+
+	/* 60-6F [26ba] Bcc */
+
+	case 0x30:
+		if (byte1 == 0x61) {
+			/* BRA, BSR */
+#ifdef LOGEMU
+			out("bsr");
+#endif
+			if (byte2 == 0)
+				push(pc + 2);
+			else
+				push(pc);
+		}
+#ifdef LOGEMU
+		else
+			out("bra");
+#endif
+		if ((byte1 == 0x60) && (byte2 == 0xfe)) {
+			ms_flush(); /* flush stdout */
+			ms_stop();  /* infinite loop - just exit */
+		}
+		branch(byte2);
+		break;
+
+	case 0x31:
+	case 0x32:
+	case 0x33:
+	case 0x34:
+	case 0x35:
+	case 0x36:
+	case 0x37:
+
+		if (condition(byte1) == 0) {
+#ifdef LOGEMU
+			out("beq.s");
+#endif
+			if (byte2 == 0)
+				pc += 2;
+		} else {
+#ifdef LOGEMU
+			out("bra");
+#endif
+			branch(byte2);
+		}
+		break;
+
+	/* 70-7F [260a] MOVEQ */
+	case 0x38:
+	case 0x39:
+	case 0x3a:
+	case 0x3b:
+	case 0x3c:
+	case 0x3d:
+	case 0x3e:
+	case 0x3f:
+
+#ifdef LOGEMU
+		out("moveq");
+#endif
+		arg1 = (type8 *) & dreg[byte1 >> 1 & 0x07];
+		if (byte2 > 127)
+			nflag = arg1[0] = arg1[1] = arg1[2] = 0xff;
+		else
+			nflag = arg1[0] = arg1[1] = arg1[2] = 0;
+		arg1[3] = byte2;
+		zflag = byte2 ? 0 : 0xff;
+		break;
+
+	/* 80-8F [2f36] */
+	case 0x40:
+	case 0x41:
+	case 0x42:
+	case 0x43:
+	case 0x44:
+	case 0x45:
+	case 0x46:
+	case 0x47:
+
+		if ((byte2 & 0xc0) == 0xc0) {
+			ms_fatal("unimplemented instructions DIVS and DIVU");
+		} else if (((byte2 & 0xf0) == 0) && ((byte1 & 0x01) != 0)) {
+			ms_fatal("unimplemented instruction SBCD");
+		} else {
+#ifdef LOGEMU
+			out("or?");
+#endif
+			set_info(byte2);
+			set_arg1();
+			set_arg2(1, byte1);
+			if ((byte1 & 0x01) == 0)
+				swap_args();
+			do_or();
+		}
+		break;
+
+	/* 90-9F [3005] SUB */
+	case 0x48:
+	case 0x49:
+	case 0x4a:
+	case 0x4b:
+	case 0x4c:
+	case 0x4d:
+	case 0x4e:
+	case 0x4f:
+
+#ifdef LOGEMU
+		out("sub");
+#endif
+		quick_flag = 0;
+		if ((byte2 & 0xc0) == 0xc0) {
+			if ((byte1 & 0x01) == 1)
+				set_info((type8)(byte2 & 0xbf));
+			else
+				set_info((type8)(byte2 & 0x7f));
+			set_arg1();
+			set_arg2_nosize(0, byte1);
+			swap_args();
+			do_sub(1);
+		} else {
+			set_info(byte2);
+			set_arg1();
+			set_arg2(1, byte1);
+			if ((byte1 & 0x01) == 0)
+				swap_args();
+			do_sub(0);
+		}
+		break;
+
+	/* A0-AF various special commands [LINE_A] */
+
+	case 0x50:
+	case 0x56:
+	case 0x57:        /* [2521] */
+		do_line_a();
+#ifdef LOGEMU
+		out("LINE_A A0%.2X", byte2);
+#endif
+		break;
+
+	case 0x51:
+#ifdef LOGEMU
+		out("rts\n");
+#endif
+		pc = pop(); /* RTS */
+		break;
+
+	case 0x52:
+#ifdef LOGEMU
+		out("bsr");
+#endif
+		if (byte2 == 0)
+			push(pc + 2);   /* BSR */
+		else
+			push(pc);
+		branch(byte2);
+		break;
+
+	case 0x53:
+		if ((byte2 & 0xc0) == 0xc0) {
+			/* TST [321d] */
+			ms_fatal("unimplemented instructions LINE_A #$6C0-#$6FF");
+		} else {
+#ifdef LOGEMU
+			out("tst");
+#endif
+			set_info(byte2);
+			set_arg1();
+			cflag = vflag = 0;
+			set_flags();
+		}
+		break;
+
+	case 0x54:
+		check_movem();
+		break;
+
+	case 0x55:
+		check_movem2();
+		break;
+
+	/* B0-BF [2fe4] */
+	case 0x58:
+	case 0x59:
+	case 0x5a:
+	case 0x5b:
+	case 0x5c:
+	case 0x5d:
+	case 0x5e:
+	case 0x5f:
+
+		if ((byte2 & 0xc0) == 0xc0) {
+#ifdef LOGEMU
+			out("cmp");
+#endif
+			if ((byte1 & 0x01) == 1)
+				set_info((type8)(byte2 & 0xbf));
+			else
+				set_info((type8)(byte2 & 0x7f));
+			set_arg1();
+			set_arg2(0, byte1);
+			swap_args();
+			do_cmp();   /* CMP */
+		} else {
+			if ((byte1 & 0x01) == 0) {
+#ifdef LOGEMU
+				out("cmp");
+#endif
+				set_info(byte2);
+				set_arg1();
+				set_arg2(1, byte1);
+				swap_args();
+				do_cmp();   /* CMP */
+			} else {
+#ifdef LOGEMU
+				out("eor");
+#endif
+				set_info(byte2);
+				set_arg1();
+				set_arg2(1, byte1);
+				do_eor();   /* EOR */
+			}
+		}
+		break;
+
+	/* C0-CF [2f52] EXG, AND */
+	case 0x60:
+	case 0x61:
+	case 0x62:
+	case 0x63:
+	case 0x64:
+	case 0x65:
+	case 0x66:
+	case 0x67:
+
+		if ((byte1 & 0x01) == 0) {
+			if ((byte2 & 0xc0) == 0xc0) {
+				ms_fatal("unimplemented instruction MULU");
+			} else {
+				/* AND */
+#ifdef LOGEMU
+				out("and");
+#endif
+				set_info(byte2);
+				set_arg1();
+				set_arg2(1, byte1);
+				if ((byte1 & 0x01) == 0)
+					swap_args();
+				do_and();
+			}
+		} else {
+			if ((byte2 & 0xf8) == 0x40) {
+#ifdef LOGEMU
+				out("exg (dx)");
+#endif
+				opsize = 2; /* EXG Dx,Dx */
+				set_arg2(1, (type8)(byte2 << 1));
+				swap_args();
+				set_arg2(1, byte1);
+				tmp32 = read_l(arg1);
+				write_l(arg1, read_l(arg2));
+				write_l(arg2, tmp32);
+			} else if ((byte2 & 0xf8) == 0x48) {
+				opsize = 2; /* EXG Ax,Ax */
+#ifdef LOGEMU
+				out("exg (ax)");
+#endif
+				set_arg2(0, (type8)(byte2 << 1));
+				swap_args();
+				set_arg2(0, byte1);
+				tmp32 = read_l(arg1);
+				write_l(arg1, read_l(arg2));
+				write_l(arg2, tmp32);
+			} else if ((byte2 & 0xf8) == 0x88) {
+				opsize = 2; /* EXG Dx,Ax */
+#ifdef LOGEMU
+				out("exg (dx,ax)");
+#endif
+				set_arg2(0, (type8)(byte2 << 1));
+				swap_args();
+				set_arg2(1, byte1);
+				tmp32 = read_l(arg1);
+				write_l(arg1, read_l(arg2));
+				write_l(arg2, tmp32);
+			} else {
+				if ((byte2 & 0xc0) == 0xc0) {
+					ms_fatal("unimplemented instruction MULS");
+				} else {
+					set_info(byte2);
+					set_arg1();
+					set_arg2(1, byte1);
+					if ((byte1 & 0x01) == 0)
+						swap_args();
+					do_and();
+				}
+			}
+		}
+		break;
+
+	/* D0-DF [2fc8] ADD */
+	case 0x68:
+	case 0x69:
+	case 0x6a:
+	case 0x6b:
+	case 0x6c:
+	case 0x6d:
+	case 0x6e:
+	case 0x6f:
+
+#ifdef LOGEMU
+		out("add");
+#endif
+		quick_flag = 0;
+		if ((byte2 & 0xc0) == 0xc0) {
+			if ((byte1 & 0x01) == 1)
+				set_info((type8)(byte2 & 0xbf));
+			else
+				set_info((type8)(byte2 & 0x7f));
+			set_arg1();
+			set_arg2_nosize(0, byte1);
+			swap_args();
+			do_add(1);
+		} else {
+			set_info(byte2);
+			set_arg1();
+			set_arg2(1, byte1);
+			if ((byte1 & 0x01) == 0)
+				swap_args();
+			do_add(0);
+		}
+		break;
+
+	/* E0-EF [3479] LSR ASL ROR ROL */
+	case 0x70:
+	case 0x71:
+	case 0x72:
+	case 0x73:
+	case 0x74:
+	case 0x75:
+	case 0x76:
+	case 0x77:
+
+#ifdef LOGEMU
+		out("lsr,asl,ror,rol");
+#endif
+		if ((byte2 & 0xc0) == 0xc0) {
+			set_info((type8)(byte2 & 0xbf));        /* OP Dx */
+			set_arg1();
+			l1c = 1;    /* steps=1 */
+			byte2 = (byte1 >> 1) & 0x03;
+		} else {
+			set_info((type8)(byte2 & 0xc7));
+			set_arg1();
+			if ((byte2 & 0x20) == 0) {
+				/* immediate */
+				l1c = (byte1 >> 1) & 0x07;
+				if (l1c == 0)
+					l1c = 8;
+			} else {
+				l1c = (type8)read_reg(byte1 >> 1 & 0x07, 0);
+			}
+			byte2 = (byte2 >> 3) & 0x03;
+		}
+		if ((byte1 & 0x01) == 0) {
+			/* right */
+			while (l1c-- > 0) {
+				if (opsize == 0) {
+					cflag = arg1[0] & 0x01 ? 0xff : 0;
+					arg1[0] >>= 1;
+					if (cflag && (byte2 == 3))
+						arg1[0] |= 0x80;
+				}
+				if (opsize == 1) {
+					cflag = read_w(arg1) & 0x01 ? 0xff : 0;
+					write_w(arg1, (type16)(read_w(arg1) >> 1));
+					if (cflag && (byte2 == 3))
+						write_w(arg1, (type16)(read_w(arg1) | ((type16) 1 << 15)));
+				}
+				if (opsize == 2) {
+					cflag = read_l(arg1) & 0x01 ? 0xff : 0;
+					write_l(arg1, read_l(arg1) >> 1);
+					if (cflag && (byte2 == 3))
+						write_l(arg1, read_l(arg1) | ((type32) 1 << 31));
+				}
+			}
+		} else {
+			/* left */
+			while (l1c-- > 0) {
+				if (opsize == 0) {
+					cflag = arg1[0] & 0x80 ? 0xff : 0;  /* [3527] */
+					arg1[0] <<= 1;
+					if (cflag && (byte2 == 3))
+						arg1[0] |= 0x01;
+				}
+				if (opsize == 1) {
+					cflag = read_w(arg1) & ((type16) 1 << 15) ? 0xff : 0;
+					write_w(arg1, (type16)(read_w(arg1) << 1));
+					if (cflag && (byte2 == 3))
+						write_w(arg1, (type16)(read_w(arg1) | 0x01));
+				}
+				if (opsize == 2) {
+					cflag = read_l(arg1) & ((type32) 1 << 31) ? 0xff : 0;
+					write_l(arg1, read_l(arg1) << 1);
+					if (cflag && (byte2 == 3))
+						write_l(arg1, read_l(arg1) | 0x01);
+				}
+			}
+		}
+		set_flags();
+		break;
+
+	/* F0-FF [24f3] LINE_F */
+	case 0x78:
+	case 0x79:
+	case 0x7a:
+	case 0x7b:
+	case 0x7c:
+	case 0x7d:
+	case 0x7e:
+	case 0x7f:
+
+		if (version == 0) {
+			/* hardcoded jump */
+			char_out(l1c = (type8)read_reg(1, 0));
+		} else if (version == 1) {
+			/* single programmable shortcut */
+			push(pc);
+			pc = fl_sub;
+		} else {
+			/* programmable shortcuts from table */
+#ifdef LOGEMU
+			out("LINK: %.2X,%.2X", byte1, byte2);
+#endif
+			ptr = (byte1 & 7) << 8 | byte2;
+			if (ptr >= fl_size) {
+				if ((byte1 & 8) == 0)
+					push(pc);
+				ptr = byte1 << 8 | byte2 | 0x0800;
+				ptr = fl_tab + 2 * (ptr ^ 0xffff);
+				pc = (type32) ptr + (type16s) read_w(effective(ptr));
+			} else {
+				push(pc);
+				pc = fl_sub;
+			}
+		}
+		break;
+
+	default:
+		ms_fatal("Constants aren't and variables don't");
+		break;
+	}
+#ifdef LOGEMU
+	fprintf(dbg_log, "\n");
+#endif
+	return running;
 }
 
 } // End of namespace Magnetic
diff --git a/engines/glk/magnetic/glk.cpp b/engines/glk/magnetic/glk.cpp
new file mode 100644
index 0000000000..db15cd136c
--- /dev/null
+++ b/engines/glk/magnetic/glk.cpp
@@ -0,0 +1,5393 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/magnetic/defs.h"
+#include "glk/magnetic/magnetic.h"
+
+namespace Glk {
+namespace Magnetic {
+
+/*
+ * True and false definitions -- usually defined in glkstart.h, but we need
+ * them early, so we'll define them here too.  We also need NULL, but that's
+ * normally from stdio.h or one of it's cousins.
+ */
+#ifndef FALSE
+# define FALSE false
+#endif
+#ifndef TRUE
+# define TRUE false
+#endif
+
+#define BYTE_MAX 255
+#define CHAR_BIT 8
+#define UINT16_MAX 0xffff
+#define INT32_MAX 0x7fffffff
+
+/*---------------------------------------------------------------------*/
+/*  Module variables, miscellaneous other stuff                        */
+/*---------------------------------------------------------------------*/
+
+/* Glk Magnetic Scrolls port version number. */
+static const glui32 GMS_PORT_VERSION = 0x00010601;
+
+/*
+ * We use a maximum of five Glk windows, one for status, one for pictures,
+ * two for hints, and one for everything else.  The status and pictures
+ * windows may be NULL, depending on user selections and the capabilities
+ * of the Glk library.  The hints windows will normally be NULL, except
+ * when in the hints subsystem.
+ */
+static winid_t gms_main_window = NULL,
+               gms_status_window = NULL,
+               gms_graphics_window = NULL,
+               gms_hint_menu_window = NULL,
+               gms_hint_text_window = NULL;
+
+/*
+ * Transcript stream and input log.  These are NULL if there is no current
+ * collection of these strings.
+ */
+static strid_t gms_transcript_stream = NULL,
+               gms_inputlog_stream = NULL;
+
+/* Input read log stream, for reading back an input log. */
+static strid_t gms_readlog_stream = NULL;
+
+/* Note about whether graphics is possible, or not. */
+static int gms_graphics_possible = TRUE;
+
+/* Options that may be turned off or set by command line flags. */
+static int gms_graphics_enabled = TRUE;
+enum GammaMode {
+	GAMMA_OFF, GAMMA_NORMAL, GAMMA_HIGH
+};
+static GammaMode gms_gamma_mode = GAMMA_NORMAL;
+static int gms_animation_enabled = TRUE,
+           gms_prompt_enabled = TRUE,
+           gms_abbreviations_enabled = TRUE,
+           gms_commands_enabled = TRUE;
+
+/* Magnetic Scrolls standard input prompt string. */
+static const char *const GMS_INPUT_PROMPT = ">";
+
+/* Forward declaration of event wait function. */
+static void gms_event_wait(glui32 wait_type, event_t *event);
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port utility functions                                         */
+/*---------------------------------------------------------------------*/
+
+/*
+ * gms_fatal()
+ *
+ * Fatal error handler.  The function returns, expecting the caller to
+ * abort() or otherwise handle the error.
+ */
+static void gms_fatal(const char *string) {
+	/*
+	 * If the failure happens too early for us to have a window, print
+	 * the message to stderr.
+	 */
+	if (!gms_main_window)
+		error("\n\nINTERNAL ERROR: %s", string);
+
+	/* Cancel all possible pending window input events. */
+	g_vm->glk_cancel_line_event(gms_main_window, NULL);
+	g_vm->glk_cancel_char_event(gms_main_window);
+	if (gms_hint_menu_window) {
+		g_vm->glk_cancel_char_event(gms_hint_menu_window);
+		g_vm->glk_window_close(gms_hint_menu_window, NULL);
+	}
+	if (gms_hint_text_window) {
+		g_vm->glk_cancel_char_event(gms_hint_text_window);
+		g_vm->glk_window_close(gms_hint_text_window, NULL);
+	}
+
+	/* Print a message indicating the error. */
+	g_vm->glk_set_window(gms_main_window);
+	g_vm->glk_set_style(style_Normal);
+	g_vm->glk_put_string("\n\nINTERNAL ERROR: ");
+	g_vm->glk_put_string(string);
+
+	g_vm->glk_put_string("\n\nPlease record the details of this error, try to"
+	                     " note down everything you did to cause it, and email"
+	                     " this information to simon_baldwin@yahoo.com.\n\n");
+}
+
+
+/*
+ * gms_malloc()
+ * gms_realloc()
+ *
+ * Non-failing malloc and realloc; call gms_fatal and exit if memory
+ * allocation fails.
+ */
+static void *gms_malloc(size_t size) {
+	void *pointer;
+
+	pointer = malloc(size);
+	if (!pointer) {
+		gms_fatal("GLK: Out of system memory");
+		g_vm->glk_exit();
+	}
+
+	return pointer;
+}
+
+static void *gms_realloc(void *ptr, size_t size) {
+	void *pointer;
+
+	pointer = realloc(ptr, size);
+	if (!pointer) {
+		gms_fatal("GLK: Out of system memory");
+		g_vm->glk_exit();
+	}
+
+	return pointer;
+}
+
+
+/*
+ * gms_strncasecmp()
+ * gms_strcasecmp()
+ *
+ * Strncasecmp and strcasecmp are not ANSI functions, so here are local
+ * definitions to do the same jobs.
+ */
+static int gms_strncasecmp(const char *s1, const char *s2, size_t n) {
+	size_t index;
+
+	for (index = 0; index < n; index++) {
+		int diff;
+
+		diff = g_vm->glk_char_to_lower(s1[index]) - g_vm->glk_char_to_lower(s2[index]);
+		if (diff < 0 || diff > 0)
+			return diff < 0 ? -1 : 1;
+	}
+
+	return 0;
+}
+
+static int gms_strcasecmp(const char *s1, const char *s2) {
+	size_t s1len, s2len;
+	int result;
+
+	s1len = strlen(s1);
+	s2len = strlen(s2);
+
+	result = gms_strncasecmp(s1, s2, s1len < s2len ? s1len : s2len);
+	if (result < 0 || result > 0)
+		return result;
+	else
+		return s1len < s2len ? -1 : s1len > s2len ? 1 : 0;
+}
+
+/*---------------------------------------------------------------------*/
+/*  Glk port CRC functions                                             */
+/*---------------------------------------------------------------------*/
+
+/* CRC table initialization polynomial. */
+static const glui32 GMS_CRC_POLYNOMIAL = 0xedb88320;
+
+
+/*
+ * gms_get_buffer_crc()
+ *
+ * Return the CRC of the bytes in buffer[0..length-1].
+ *
+ * This algorithm is taken from the PNG specification, version 1.0.
+ */
+static glui32 gms_get_buffer_crc(const void *void_buffer, size_t length) {
+	static int is_initialized = FALSE;
+	static glui32 crc_table[BYTE_MAX + 1];
+
+	const char *buffer = (const char *) void_buffer;
+	glui32 crc;
+	size_t index;
+
+	/* Build the static CRC lookup table on first call. */
+	if (!is_initialized) {
+		for (index = 0; index < BYTE_MAX + 1; index++) {
+			int bit;
+
+			crc = (glui32) index;
+			for (bit = 0; bit < CHAR_BIT; bit++)
+				crc = crc & 1 ? GMS_CRC_POLYNOMIAL ^ (crc >> 1) : crc >> 1;
+
+			crc_table[index] = crc;
+		}
+
+		is_initialized = TRUE;
+
+		/* CRC lookup table self-test, after is_initialized set -- recursion. */
+		assert(gms_get_buffer_crc("123456789", 9) == 0xcbf43926);
+	}
+
+	/*
+	 * Start with all ones in the crc, then update using table entries.  Xor
+	 * with all ones again, finally, before returning.
+	 */
+	crc = 0xffffffff;
+	for (index = 0; index < length; index++)
+		crc = crc_table[(crc ^ buffer[index]) & BYTE_MAX] ^ (crc >> CHAR_BIT);
+	return crc ^ 0xffffffff;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port game identification data and identification functions     */
+/*---------------------------------------------------------------------*/
+
+/*
+ * The game's name, suitable for printing out on a status line, or other
+ * location where game information is relevant.  Set on game startup, by
+ * identifying the game from its text file header.
+ */
+static const char *gms_gameid_game_name = NULL;
+
+
+/*
+ * The following game database is built from Generic/games.txt, and is used
+ * to identify the game being run.  Magnetic Scrolls games don't generally
+ * supply a status line, so this data can be used instead.
+ */
+struct gms_game_table_t {
+	const type32 undo_size;   /* Header word at offset 0x22 */
+	const type32 undo_pc;     /* Header word at offset 0x26 */
+	const char *const name;   /* Game title and platform */
+};
+typedef const gms_game_table_t *gms_game_tableref_t;
+
+static const gms_game_table_t GMS_GAME_TABLE[] = {
+	{0x2100, 0x427e, "Corruption v1.11 (Amstrad CPC)"},
+	{0x2100, 0x43a0, "Corruption v1.11 (Archimedes)"},
+	{0x2100, 0x43a0, "Corruption v1.11 (DOS)"},
+	{0x2100, 0x4336, "Corruption v1.11 (Commodore 64)"},
+	{0x2100, 0x4222, "Corruption v1.11 (Spectrum +3)"},
+	{0x2100, 0x4350, "Corruption v1.12 (Archimedes)"},
+	{0x2500, 0x6624, "Corruption v1.12 (DOS, Magnetic Windows)"},
+
+	{0x2300, 0x3fa0, "Fish v1.02 (DOS)"},
+	{0x2400, 0x4364, "Fish v1.03 (Spectrum +3)"},
+	{0x2300, 0x3f72, "Fish v1.07 (Commodore 64)"},
+	{0x2200, 0x3f9c, "Fish v1.08 (Archimedes)"},
+	{0x2a00, 0x583a, "Fish v1.10 (DOS, Magnetic Windows)"},
+
+	{0x5000, 0x6c30, "Guild v1.0 (Amstrad CPC)"},
+	{0x5000, 0x6cac, "Guild v1.0 (Commodore 64)"},
+	{0x5000, 0x6d5c, "Guild v1.1 (DOS)"},
+	{0x3300, 0x698a, "Guild v1.3 (Archimedes)"},
+	{0x3200, 0x6772, "Guild v1.3 (Spectrum +3)"},
+	{0x3400, 0x6528, "Guild v1.3 (DOS, Magnetic Windows)"},
+
+	{0x2b00, 0x488c, "Jinxter v1.05 (Commodore 64)"},
+	{0x2c00, 0x4a08, "Jinxter v1.05 (DOS)"},
+	{0x2c00, 0x487a, "Jinxter v1.05 (Spectrum +3)"},
+	{0x2c00, 0x4a56, "Jinxter v1.10 (DOS)"},
+	{0x2b00, 0x4924, "Jinxter v1.22 (Amstrad CPC)"},
+	{0x2c00, 0x4960, "Jinxter v1.30 (Archimedes)"},
+
+	{0x1600, 0x3940, "Myth v1.0 (Commodore 64)"},
+	{0x1500, 0x3a0a, "Myth v1.0 (DOS)"},
+
+	{0x3600, 0x42cc, "Pawn v2.3 (Amstrad CPC)"},
+	{0x3600, 0x4420, "Pawn v2.3 (Archimedes)"},
+	{0x3600, 0x3fb0, "Pawn v2.3 (Commodore 64)"},
+	{0x3600, 0x4420, "Pawn v2.3 (DOS)"},
+	{0x3900, 0x42e4, "Pawn v2.3 (Spectrum 128)"},
+	{0x3900, 0x42f4, "Pawn v2.4 (Spectrum +3)"},
+
+	{0x3900, 0x75f2, "Wonderland v1.21 (DOS, Magnetic Windows)"},
+	{0x3900, 0x75f8, "Wonderland v1.27 (Archimedes)"},
+	{0, 0, NULL}
+};
+
+
+/*
+ * gms_gameid_lookup_game()
+ *
+ * Look up and return the game table entry given a game's undo size and
+ * undo pc values.  Returns the entry, or NULL if not found.
+ */
+static gms_game_tableref_t gms_gameid_lookup_game(type32 undo_size, type32 undo_pc) {
+	gms_game_tableref_t game;
+
+	for (game = GMS_GAME_TABLE; game->name; game++) {
+		if (game->undo_size == undo_size && game->undo_pc == undo_pc)
+			break;
+	}
+
+	return game->name ? game : NULL;
+}
+
+
+/*
+ * gms_gameid_read_uint32()
+ *
+ * Endian-safe unsigned 32 bit integer read from game text file.  Returns
+ * 0 on error, a known unused table value.
+ */
+static type32 gms_gameid_read_uint32(int offset, Common::SeekableReadStream *stream) {
+	if (!stream->seek(offset))
+		return 0;
+	return stream->readUint32LE();
+}
+
+
+/*
+ * gms_gameid_identify_game()
+ *
+ * Identify a game from its text file header, and cache the game's name for
+ * later queries.  Sets the cache to NULL if not found.
+ */
+static void gms_gameid_identify_game(const char *text_file) {
+	Common::File stream;
+
+	if (stream.open(text_file)) {
+		type32 undo_size, undo_pc;
+		gms_game_tableref_t game;
+
+		/* Read the game's signature undo size and undo pc values. */
+		undo_size = gms_gameid_read_uint32(0x22, &stream);
+		undo_pc = gms_gameid_read_uint32(0x26, &stream);
+		stream.close();
+
+		/* Search for these values in the table, and set game name if found. */
+		game = gms_gameid_lookup_game(undo_size, undo_pc);
+		gms_gameid_game_name = game ? game->name : NULL;
+	} else {
+		gms_gameid_game_name = NULL;
+	}
+}
+
+
+/*
+ * gms_gameid_get_game_name()
+ *
+ * Return the name of the game, or NULL if not identifiable.
+ */
+static const char *gms_gameid_get_game_name(void) {
+	return gms_gameid_game_name;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port picture functions                                         */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Color conversions lookup tables, and a word about gamma corrections.
+ *
+ * When uncorrected, some game pictures can look dark (Corruption, Won-
+ * derland), whereas others look just fine (Guild Of Thieves, Jinxter).
+ *
+ * The standard general-purpose gamma correction is around 2.1, with
+ * specific values, normally, of 2.5-2.7 for IBM PC systems, and 1.8 for
+ * Macintosh.  However, applying even the low end of this range can make
+ * some pictures look washed out, yet improve others nicely.
+ *
+ * To try to solve this, here we'll set up a precalculated table with
+ * discrete gamma values.  On displaying a picture, we'll try to find a
+ * gamma correction that seems to offer a reasonable level of contrast
+ * for the picture.
+ *
+ * Here's an AWK script to create the gamma table:
+ *
+ * BEGIN { max=255.0; step=max/7.0
+ *         for (gamma=0.9; gamma<=2.7; gamma+=0.05) {
+ *             printf "  {\"%2.2f\", {0, ", gamma
+ *             for (i=1; i<8; i++) {
+ *                 printf "%3.0f", (((step*i / max) ^ (1.0/gamma)) * max)
+ *                 printf "%s", (i<7) ? ", " : ""
+ *             }
+ *             printf "}, "
+ *             printf "%s },\n", (gamma>0.99 && gamma<1.01) ? "FALSE" : "TRUE "
+ *         } }
+ *
+ */
+typedef const struct {
+	const char *const level;       /* Gamma correction level. */
+	const unsigned char table[8];  /* Color lookup table. */
+	const int is_corrected;        /* Flag if non-linear. */
+} gms_gamma_t;
+typedef gms_gamma_t *gms_gammaref_t;
+
+static gms_gamma_t GMS_GAMMA_TABLE[] = {
+	{"0.90", {0,  29,  63,  99, 137, 175, 215, 255}, TRUE},
+	{"0.95", {0,  33,  68, 105, 141, 179, 217, 255}, TRUE},
+	{"1.00", {0,  36,  73, 109, 146, 182, 219, 255}, FALSE},
+	{"1.05", {0,  40,  77, 114, 150, 185, 220, 255}, TRUE},
+	{"1.10", {0,  43,  82, 118, 153, 188, 222, 255}, TRUE},
+	{"1.15", {0,  47,  86, 122, 157, 190, 223, 255}, TRUE},
+	{"1.20", {0,  50,  90, 126, 160, 193, 224, 255}, TRUE},
+	{"1.25", {0,  54,  94, 129, 163, 195, 225, 255}, TRUE},
+	{"1.30", {0,  57,  97, 133, 166, 197, 226, 255}, TRUE},
+	{"1.35", {0,  60, 101, 136, 168, 199, 227, 255}, TRUE},
+	{"1.40", {0,  64, 104, 139, 171, 201, 228, 255}, TRUE},
+	{"1.45", {0,  67, 107, 142, 173, 202, 229, 255}, TRUE},
+	{"1.50", {0,  70, 111, 145, 176, 204, 230, 255}, TRUE},
+	{"1.55", {0,  73, 114, 148, 178, 205, 231, 255}, TRUE},
+	{"1.60", {0,  76, 117, 150, 180, 207, 232, 255}, TRUE},
+	{"1.65", {0,  78, 119, 153, 182, 208, 232, 255}, TRUE},
+	{"1.70", {0,  81, 122, 155, 183, 209, 233, 255}, TRUE},
+	{"1.75", {0,  84, 125, 157, 185, 210, 233, 255}, TRUE},
+	{"1.80", {0,  87, 127, 159, 187, 212, 234, 255}, TRUE},
+	{"1.85", {0,  89, 130, 161, 188, 213, 235, 255}, TRUE},
+	{"1.90", {0,  92, 132, 163, 190, 214, 235, 255}, TRUE},
+	{"1.95", {0,  94, 134, 165, 191, 215, 236, 255}, TRUE},
+	{"2.00", {0,  96, 136, 167, 193, 216, 236, 255}, TRUE},
+	{"2.05", {0,  99, 138, 169, 194, 216, 237, 255}, TRUE},
+	{"2.10", {0, 101, 140, 170, 195, 217, 237, 255}, TRUE},
+	{"2.15", {0, 103, 142, 172, 197, 218, 237, 255}, TRUE},
+	{"2.20", {0, 105, 144, 173, 198, 219, 238, 255}, TRUE},
+	{"2.25", {0, 107, 146, 175, 199, 220, 238, 255}, TRUE},
+	{"2.30", {0, 109, 148, 176, 200, 220, 238, 255}, TRUE},
+	{"2.35", {0, 111, 150, 178, 201, 221, 239, 255}, TRUE},
+	{"2.40", {0, 113, 151, 179, 202, 222, 239, 255}, TRUE},
+	{"2.45", {0, 115, 153, 180, 203, 222, 239, 255}, TRUE},
+	{"2.50", {0, 117, 154, 182, 204, 223, 240, 255}, TRUE},
+	{"2.55", {0, 119, 156, 183, 205, 223, 240, 255}, TRUE},
+	{"2.60", {0, 121, 158, 184, 206, 224, 240, 255}, TRUE},
+	{"2.65", {0, 122, 159, 185, 206, 225, 241, 255}, TRUE},
+	{"2.70", {0, 124, 160, 186, 207, 225, 241, 255}, TRUE},
+	{NULL,   {0,   0,   0,   0,   0,   0,   0,   0}, FALSE}
+};
+
+/* R,G,B color triple definition. */
+typedef struct {
+	int red, green, blue;
+} gms_rgb_t;
+typedef gms_rgb_t *gms_rgbref_t;
+
+/*
+ * Weighting values for calculating the luminance of a color.  There are
+ * two commonly used sets of values for these -- 299,587,114, taken from
+ * NTSC (Never The Same Color) 1953 standards, and 212,716,72, which is the
+ * set that modern CRTs tend to match.  The NTSC ones seem to give the best
+ * subjective results.
+ */
+static const gms_rgb_t GMS_LUMINANCE_WEIGHTS = { 299, 587, 114 };
+
+/*
+ * Maximum number of regions to consider in a single repaint pass.  A
+ * couple of hundred seems to strike the right balance between not too
+ * sluggardly picture updates, and responsiveness to input during graphics
+ * rendering, when combined with short timeouts.
+ */
+static const int GMS_REPAINT_LIMIT = 256;
+
+/*
+ * Graphics timeout; we like an update call after this period (ms).  In
+ * practice, this timeout may actually be shorter than the time taken
+ * to reach the limit on repaint regions, but because Glk guarantees that
+ * user interactions (in this case, line events) take precedence over
+ * timeouts, this should be okay; we'll still see a game that responds to
+ * input each time the background repaint function yields.
+ *
+ * Setting this value is tricky.  We'd like it to be the shortest possible
+ * consistent with getting other stuff done, say 10ms.  However, Xglk has
+ * a granularity of 50ms on checking for timeouts, as it uses a 1/20s
+ * timeout on X select.  This means that the shortest timeout we'll ever
+ * get from Xglk will be 50ms, so there's no point in setting this shorter
+ * than that.  With luck, other Glk libraries will be more efficient than
+ * this, and can give us higher timer resolution; we'll set 50ms here, and
+ * hope that no other Glk library is worse.
+ */
+static const glui32 GMS_GRAPHICS_TIMEOUT = 50;
+
+/*
+ * Count of timeouts to wait in between animation paints, and to wait on
+ * repaint request.  Waiting for 2 timeouts of around 50ms, gets us to the
+ * 100ms recommended animation frame rate.  Waiting after a repaint smooths
+ * the display where the frame is being resized, by helping to avoid
+ * graphics output while more resize events are received; around 1/2 second
+ * seems okay.
+ */
+static const int GMS_GRAPHICS_ANIMATION_WAIT = 2,
+                 GMS_GRAPHICS_REPAINT_WAIT = 10;
+
+/* Pixel size multiplier for image size scaling. */
+static const int GMS_GRAPHICS_PIXEL = 2;
+
+/* Proportion of the display to use for graphics. */
+static const glui32 GMS_GRAPHICS_PROPORTION = 60;
+
+/*
+ * Border and shading control.  For cases where we can't detect the back-
+ * ground color of the main window, there's a default, white, background.
+ * Bordering is black, with a 1 pixel border, 2 pixel shading, and 8 steps
+ * of shading fade.
+ */
+static const glui32 GMS_GRAPHICS_DEFAULT_BACKGROUND = 0x00ffffff,
+                    GMS_GRAPHICS_BORDER_COLOR = 0x00000000;
+static const int GMS_GRAPHICS_BORDER = 1,
+                 GMS_GRAPHICS_SHADING = 2,
+                 GMS_GRAPHICS_SHADE_STEPS = 8;
+
+/*
+ * Guaranteed unused pixel value.  This value is used to fill the on-screen
+ * buffer on new pictures or repaints, resulting in a full paint of all
+ * pixels since no off-screen, real picture, pixel will match it.
+ */
+static const int GMS_GRAPHICS_UNUSED_PIXEL = 0xff;
+
+/*
+ * The current picture bitmap being displayed, its width, height, palette,
+ * animation flag, and picture id.
+ */
+enum { GMS_PALETTE_SIZE = 16 };
+static type8 *gms_graphics_bitmap = NULL;
+static type16 gms_graphics_width = 0,
+              gms_graphics_height = 0,
+              gms_graphics_palette[GMS_PALETTE_SIZE]; /* = { 0, ... }; */
+static bool gms_graphics_animated = FALSE;
+static type32 gms_graphics_picture = 0;
+
+/*
+ * Flags set on new picture, and on resize or arrange events, and a flag
+ * to indicate whether background repaint is stopped or active.
+ */
+static bool gms_graphics_new_picture = FALSE,
+            gms_graphics_repaint = FALSE,
+            gms_graphics_active = FALSE;
+
+/* Flag to try to monitor the state of interpreter graphics. */
+static bool gms_graphics_interpreter = FALSE;
+
+/*
+ * Pointer to the two graphics buffers, one the off-screen representation
+ * of pixels, and the other tracking on-screen data.  These are temporary
+ * graphics malloc'ed memory, and should be free'd on exit.
+ */
+static type8 *gms_graphics_off_screen = NULL,
+              *gms_graphics_on_screen = NULL;
+
+/*
+ * Pointer to the current active gamma table entry.  Because of the way
+ * it's queried, this may not be NULL, otherwise we risk a race, with
+ * admittedly a very low probability, with the updater.  So, it's init-
+ * ialized instead to the gamma table.  The real value in use is inserted
+ * on the first picture update timeout call for a new picture.
+ */
+static gms_gammaref_t gms_graphics_current_gamma = GMS_GAMMA_TABLE;
+
+/*
+ * The number of colors used in the palette by the current picture.  This
+ * value is also at risk of a race with the updater, so it too has a mild
+ * lie for a default value.
+ */
+static int gms_graphics_color_count = GMS_PALETTE_SIZE;
+
+
+/*
+ * gms_graphics_open()
+ *
+ * If it's not open, open the graphics window.  Returns TRUE if graphics
+ * was successfully started, or already on.
+ */
+static int gms_graphics_open(void) {
+	if (!gms_graphics_window) {
+		gms_graphics_window = g_vm->glk_window_open(gms_main_window,
+		                      winmethod_Above
+		                      | winmethod_Proportional,
+		                      GMS_GRAPHICS_PROPORTION,
+		                      wintype_Graphics, 0);
+	}
+
+	return gms_graphics_window != NULL;
+}
+
+
+/*
+ * gms_graphics_close()
+ *
+ * If open, close the graphics window and set back to NULL.
+ */
+static void gms_graphics_close(void) {
+	if (gms_graphics_window) {
+		g_vm->glk_window_close(gms_graphics_window, NULL);
+		gms_graphics_window = NULL;
+	}
+}
+
+
+/*
+ * gms_graphics_start()
+ *
+ * If graphics enabled, start any background picture update processing.
+ */
+static void gms_graphics_start(void) {
+	if (gms_graphics_enabled) {
+		/* If not running, start the updating "thread". */
+		if (!gms_graphics_active) {
+			g_vm->glk_request_timer_events(GMS_GRAPHICS_TIMEOUT);
+			gms_graphics_active = TRUE;
+		}
+	}
+}
+
+
+/*
+ * gms_graphics_stop()
+ *
+ * Stop any background picture update processing.
+ */
+static void gms_graphics_stop(void) {
+	/* If running, stop the updating "thread". */
+	if (gms_graphics_active) {
+		g_vm->glk_request_timer_events(0);
+		gms_graphics_active = FALSE;
+	}
+}
+
+
+/*
+ * gms_graphics_are_displayed()
+ *
+ * Return TRUE if graphics are currently being displayed, FALSE otherwise.
+ */
+static int gms_graphics_are_displayed(void) {
+	return gms_graphics_window != NULL;
+}
+
+
+/*
+ * gms_graphics_paint()
+ *
+ * Set up a complete repaint of the current picture in the graphics window.
+ * This function should be called on the appropriate Glk window resize and
+ * arrange events.
+ */
+static void gms_graphics_paint(void) {
+	if (gms_graphics_enabled && gms_graphics_are_displayed()) {
+		/* Set the repaint flag, and start graphics. */
+		gms_graphics_repaint = TRUE;
+		gms_graphics_start();
+	}
+}
+
+
+/*
+ * gms_graphics_restart()
+ *
+ * Restart graphics as if the current picture is a new picture.  This
+ * function should be called whenever graphics is re-enabled after being
+ * disabled, on change of gamma color correction policy, and on change
+ * of animation policy.
+ */
+static void gms_graphics_restart(void) {
+	if (gms_graphics_enabled && gms_graphics_are_displayed()) {
+		/*
+		 * If the picture is animated, we'll need to be able to re-get the
+		 * first animation frame so that the picture can be treated as if
+		 * it is a new one.  So here, we'll try to re-extract the current
+		 * picture to do this.  Calling ms_extract() is safe because we
+		 * don't get here unless graphics are displayed, and graphics aren't
+		 * displayed until there's a valid picture loaded, and ms_showpic
+		 * only loads a picture after it's called ms_extract and set the
+		 * picture id into gms_graphics_picture.
+		 *
+		 * The bitmap and other picture stuff can be ignored because it's
+		 * the precise same stuff as we already have in picture details
+		 * variables.  If the ms_extract() fails, we'll carry on regardless,
+		 * which may, or may not, result in the ideal picture display.
+		 *
+		 * One or two non-animated pictures return NULL from ms_extract()
+		 * being re-called, so we'll restrict calls to animations only.
+		 * And just to be safe, we'll also call only if we're already
+		 * holding a bitmap (and we should be; how else could the graphics
+		 * animation flag be set?...).
+		 */
+		if (gms_graphics_animated && gms_graphics_bitmap) {
+			type8 animated;
+			type16 width, height, palette[GMS_PALETTE_SIZE];
+
+			/* Extract the bitmap into dummy variables. */
+			(void)ms_extract(gms_graphics_picture, &width, &height, palette, &animated);
+		}
+
+		/* Set the new picture flag, and start graphics. */
+		gms_graphics_new_picture = TRUE;
+		gms_graphics_start();
+	}
+}
+
+
+/*
+ * gms_graphics_count_colors()
+ *
+ * Analyze an image, and return the usage count of each palette color, and
+ * an overall count of how many colors out of the palette are used.  NULL
+ * arguments indicate no interest in the return value.
+ */
+static void gms_graphics_count_colors(type8 bitmap[], type16 width, type16 height,
+                                      int *color_count, long color_usage[]) {
+	int x, y, count;
+	long usage[GMS_PALETTE_SIZE], index_row;
+	assert(bitmap);
+
+	/*
+	 * Traverse the image, counting each pixel usage.  For the y iterator,
+	 * maintain an index row as an optimization to avoid multiplications in
+	 * the loop.
+	 */
+	count = 0;
+	memset(usage, 0, sizeof(usage));
+	for (y = 0, index_row = 0; y < height; y++, index_row += width) {
+		for (x = 0; x < width; x++) {
+			long index;
+
+			/* Get the pixel index, and update the count for this color. */
+			index = index_row + x;
+			usage[bitmap[index]]++;
+
+			/* If color usage is now 1, note new color encountered. */
+			if (usage[bitmap[index]] == 1)
+				count++;
+		}
+	}
+
+	if (color_count)
+		*color_count = count;
+
+	if (color_usage)
+		memcpy(color_usage, usage, sizeof(usage));
+}
+
+
+/*
+ * gms_graphics_game_to_rgb_color()
+ * gms_graphics_split_color()
+ * gms_graphics_combine_color()
+ * gms_graphics_color_luminance()
+ *
+ * General graphics helper functions, to convert between Magnetic Scrolls
+ * and RGB color representations, and between RGB and Glk glui32 color
+ * representations, and to calculate color luminance.
+ */
+static void
+gms_graphics_game_to_rgb_color(type16 color, gms_gammaref_t gamma,
+                               gms_rgbref_t rgb_color) {
+	assert(gamma && rgb_color);
+
+	/*
+	 * Convert Magnetic Scrolls color, through gamma, into RGB.  This splits
+	 * the color into components based on the 3-bits used in the game palette,
+	 * and gamma-corrects and rescales each to the range 0-255, using the given
+	 * correction.
+	 */
+	rgb_color->red   = gamma->table[(color & 0x700) >> 8];
+	rgb_color->green = gamma->table[(color & 0x070) >> 4];
+	rgb_color->blue  = gamma->table[(color & 0x007)];
+}
+
+static void gms_graphics_split_color(glui32 color, gms_rgbref_t rgb_color) {
+	assert(rgb_color);
+
+	rgb_color->red   = (color >> 16) & 0xff;
+	rgb_color->green = (color >> 8) & 0xff;
+	rgb_color->blue  = color & 0xff;
+}
+
+static glui32 gms_graphics_combine_color(gms_rgbref_t rgb_color) {
+	glui32 color;
+	assert(rgb_color);
+
+	color = (rgb_color->red << 16) | (rgb_color->green << 8) | rgb_color->blue;
+	return color;
+}
+
+static int gms_graphics_color_luminance(gms_rgbref_t rgb_color) {
+	static int is_initialized = FALSE;
+	static int weighting = 0;
+
+	long luminance;
+
+	/* On the first call, calculate the overall weighting. */
+	if (!is_initialized) {
+		weighting = GMS_LUMINANCE_WEIGHTS.red + GMS_LUMINANCE_WEIGHTS.green
+		            + GMS_LUMINANCE_WEIGHTS.blue;
+
+		is_initialized = TRUE;
+	}
+
+	/* Calculate the luminance and scale back by 1000 to 0-255 before return. */
+	luminance = ((long) rgb_color->red   * (long) GMS_LUMINANCE_WEIGHTS.red
+	             + (long) rgb_color->green * (long) GMS_LUMINANCE_WEIGHTS.green
+	             + (long) rgb_color->blue  * (long) GMS_LUMINANCE_WEIGHTS.blue);
+
+	assert(weighting > 0);
+	return (int)(luminance / weighting);
+}
+
+
+/*
+ * gms_graphics_compare_luminance()
+ * gms_graphics_constrast_variance()
+ *
+ * Calculate the contrast variance of the given palette and color usage, at
+ * the given gamma correction level.  Helper functions for automatic gamma
+ * correction.
+ */
+static int gms_graphics_compare_luminance(const void *void_first,
+        const void *void_second) {
+	long first = *(const long *)void_first;
+	long second = *(const long *)void_second;
+
+	return first > second ? 1 : second > first ? -1 : 0;
+}
+
+static long gms_graphics_contrast_variance(type16 palette[],
+        long color_usage[], gms_gammaref_t gamma) {
+	int index, count, has_black, mean;
+	long sum;
+	int contrast[GMS_PALETTE_SIZE];
+	int luminance[GMS_PALETTE_SIZE + 1];  /* Luminance for each color,
+                                           plus one extra for black */
+
+	/* Calculate the luminance energy of each palette color at this gamma. */
+	has_black = FALSE;
+	for (index = 0, count = 0; index < GMS_PALETTE_SIZE; index++) {
+		if (color_usage[index] > 0) {
+			gms_rgb_t rgb_color;
+
+			/*
+			 * Convert the 16-bit base picture color to RGB using the gamma
+			 * currently under consideration.  Calculate luminance for this
+			 * color and store in the next available luminance array entry.
+			 */
+			gms_graphics_game_to_rgb_color(palette[index], gamma, &rgb_color);
+			luminance[count++] = gms_graphics_color_luminance(&rgb_color);
+
+			/* Note if black is present in the palette. */
+			has_black |= luminance[count - 1] == 0;
+		}
+	}
+
+	/*
+	 * For best results, we want to anchor contrast calculations to black, so
+	 * if black is not represented in the palette, add it as an extra luminance.
+	 */
+	if (!has_black)
+		luminance[count++] = 0;
+
+	/* Sort luminance values so that the darkest color is at index 0. */
+	qsort(luminance, count,
+	      sizeof(*luminance), gms_graphics_compare_luminance);
+
+	/*
+	 * Calculate the difference in luminance between adjacent luminances in
+	 * the sorted array, as contrast, and at the same time sum contrasts to
+	 * calculate the mean.
+	 */
+	sum = 0;
+	for (index = 0; index < count - 1; index++) {
+		contrast[index] = luminance[index + 1] - luminance[index];
+		sum += contrast[index];
+	}
+	mean = sum / (count - 1);
+
+	/* Calculate and return the variance in contrasts. */
+	sum = 0;
+	for (index = 0; index < count - 1; index++)
+		sum += (contrast[index] - mean) * (contrast[index] - mean);
+
+	return sum / (count - 1);
+}
+
+
+/*
+ * gms_graphics_equal_contrast_gamma()
+ *
+ * Try to find a gamma correction for the given palette and color usage that
+ * gives relatively equal contrast among the displayed colors.
+ *
+ * To do this, we search the gamma tables, computing color luminance for each
+ * color in the palette given this gamma.  From luminances, we then compute
+ * the contrasts between the colors, and settle on the gamma correction that
+ * gives the most even and well-distributed picture contrast.  We ignore
+ * colors not used in the palette.
+ *
+ * Note that we don't consider how often a palette color is used, only whether
+ * it's represented, or not.  Some weighting might improve things, but the
+ * simple method seems to work adequately.  In practice, as there are only 16
+ * colors in a palette, most pictures use most colors in a relatively well
+ * distributed manner.  This algorithm probably wouldn't work well on real
+ * photographs, though.
+ */
+static gms_gammaref_t gms_graphics_equal_contrast_gamma(type16 palette[], long color_usage[]) {
+	gms_gammaref_t gamma, result;
+	long lowest_variance;
+	assert(palette && color_usage);
+
+	result = NULL;
+	lowest_variance = INT32_MAX;
+
+	/* Search the gamma table for the entry with the lowest contrast variance. */
+	for (gamma = GMS_GAMMA_TABLE; gamma->level; gamma++) {
+		long variance;
+
+		/* Find the color contrast variance of the palette at this gamma. */
+		variance = gms_graphics_contrast_variance(palette, color_usage, gamma);
+
+		/*
+		 * Compare the variance to the lowest so far, and if it is lower, note
+		 * the gamma entry that produced it as being the current best found.
+		 */
+		if (variance < lowest_variance) {
+			result = gamma;
+			lowest_variance = variance;
+		}
+	}
+
+	assert(result);
+	return result;
+}
+
+
+/*
+ * gms_graphics_select_gamma()
+ *
+ * Select a suitable gamma for the picture, based on the current gamma mode.
+ *
+ * The function returns either the linear gamma, a gamma value half way
+ * between linear and the gamma that gives the most even contrast, or just
+ * the gamma that gives the most even contrast.
+ *
+ * In the normal case, a value half way to the extreme case of making color
+ * contrast equal for all colors is, subjectively, a reasonable value to use.
+ * The problem cases are the darkest pictures, and selecting this value
+ * brightens them while at the same time not making them look overbright or
+ * too "sunny".
+ */
+static gms_gammaref_t gms_graphics_select_gamma(type8 bitmap[],
+        type16 width, type16 height, type16 palette[]) {
+	static int is_initialized = FALSE;
+	static gms_gammaref_t linear_gamma = NULL;
+
+	long color_usage[GMS_PALETTE_SIZE];
+	int color_count;
+	gms_gammaref_t contrast_gamma;
+
+	/* On first call, find and cache the uncorrected gamma table entry. */
+	if (!is_initialized) {
+		gms_gammaref_t gamma;
+
+		for (gamma = GMS_GAMMA_TABLE; gamma->level; gamma++) {
+			if (!gamma->is_corrected) {
+				linear_gamma = gamma;
+				break;
+			}
+		}
+
+		is_initialized = TRUE;
+	}
+	assert(linear_gamma);
+
+	/*
+	 * Check to see if automated correction is turned off; if it is, return
+	 * the linear gamma.
+	 */
+	if (gms_gamma_mode == GAMMA_OFF)
+		return linear_gamma;
+
+	/*
+	 * Get the color usage and count of total colors represented.  For a
+	 * degenerate picture with one color or less, return the linear gamma.
+	 */
+	gms_graphics_count_colors(bitmap, width, height, &color_count, color_usage);
+	if (color_count <= 1)
+		return linear_gamma;
+
+	/*
+	 * Now calculate a gamma setting to give the most equal contrast across the
+	 * picture colors.  We'll return either half this gamma, or all of it.
+	 */
+	contrast_gamma = gms_graphics_equal_contrast_gamma(palette, color_usage);
+
+	/*
+	 * For normal automated correction, return a gamma value half way between
+	 * the linear gamma and the equal contrast gamma.
+	 */
+	if (gms_gamma_mode == GAMMA_NORMAL)
+		return linear_gamma + (contrast_gamma - linear_gamma) / 2;
+
+	/* Correction must be high; return the equal contrast gamma. */
+	assert(gms_gamma_mode == GAMMA_HIGH);
+	return contrast_gamma;
+}
+
+
+/*
+ * gms_graphics_clear_and_border()
+ *
+ * Clear the graphics window, and border and shade the area where the
+ * picture is going to be rendered.  This attempts a small raised effect
+ * for the picture, in keeping with modern trends.
+ */
+static void gms_graphics_clear_and_border(winid_t glk_window,
+        int x_offset, int y_offset, int pixel_size, type16 width, type16 height) {
+	glui32 background, fade_color, shading_color;
+	gms_rgb_t rgb_background, rgb_border, rgb_fade;
+	int index;
+	assert(glk_window);
+
+	/*
+	 * Try to detect the background color of the main window, by getting the
+	 * background for Normal style (Glk offers no way to directly get a window's
+	 * background color).  If we can get it, we'll match the graphics window
+	 * background to it.  If we can't, we'll default the color to white.
+	 */
+	if (!g_vm->glk_style_measure(gms_main_window,
+	                             style_Normal, stylehint_BackColor, &background)) {
+		/*
+		 * Unable to get the main window background, so assume, and default
+		 * graphics to white.
+		 */
+		background = GMS_GRAPHICS_DEFAULT_BACKGROUND;
+	}
+
+	/*
+	 * Set the graphics window background to match the main window background,
+	 * as best as we can tell, and clear the window.
+	 */
+	g_vm->glk_window_set_background_color(glk_window, background);
+	g_vm->glk_window_clear(glk_window);
+
+	/*
+	 * For very small pictures, just border them, but don't try and do any
+	 * shading.  Failing this check is probably highly unlikely.
+	 */
+	if (width < 2 * GMS_GRAPHICS_SHADE_STEPS
+	        || height < 2 * GMS_GRAPHICS_SHADE_STEPS) {
+		/* Paint a rectangle bigger than the picture by border pixels. */
+		g_vm->glk_window_fill_rect(glk_window,
+		                           GMS_GRAPHICS_BORDER_COLOR,
+		                           x_offset - GMS_GRAPHICS_BORDER,
+		                           y_offset - GMS_GRAPHICS_BORDER,
+		                           width * pixel_size + GMS_GRAPHICS_BORDER * 2,
+		                           height * pixel_size + GMS_GRAPHICS_BORDER * 2);
+		return;
+	}
+
+	/*
+	 * Paint a rectangle bigger than the picture by border pixels all round,
+	 * and with additional shading pixels right and below.  Some of these
+	 * shading pixels are later overwritten by the fading loop below.  The
+	 * picture will sit over this rectangle.
+	 */
+	g_vm->glk_window_fill_rect(glk_window,
+	                           GMS_GRAPHICS_BORDER_COLOR,
+	                           x_offset - GMS_GRAPHICS_BORDER,
+	                           y_offset - GMS_GRAPHICS_BORDER,
+	                           width * pixel_size + GMS_GRAPHICS_BORDER * 2
+	                           + GMS_GRAPHICS_SHADING,
+	                           height * pixel_size + GMS_GRAPHICS_BORDER * 2
+	                           + GMS_GRAPHICS_SHADING);
+
+	/*
+	 * Split the main window background color and the border color into
+	 * components.
+	 */
+	gms_graphics_split_color(background, &rgb_background);
+	gms_graphics_split_color(GMS_GRAPHICS_BORDER_COLOR, &rgb_border);
+
+	/*
+	 * Generate the incremental color to use in fade steps.  Here we're
+	 * assuming that the border is always darker than the main window
+	 * background (currently valid, as we're using black).
+	 */
+	rgb_fade.red = (rgb_background.red - rgb_border.red)
+	               / GMS_GRAPHICS_SHADE_STEPS;
+	rgb_fade.green = (rgb_background.green - rgb_border.green)
+	                 / GMS_GRAPHICS_SHADE_STEPS;
+	rgb_fade.blue = (rgb_background.blue - rgb_border.blue)
+	                / GMS_GRAPHICS_SHADE_STEPS;
+
+	/* Combine RGB fade into a single incremental Glk color. */
+	fade_color = gms_graphics_combine_color(&rgb_fade);
+
+	/* Fade in edge, from background to border, shading in stages. */
+	shading_color = background;
+	for (index = 0; index < GMS_GRAPHICS_SHADE_STEPS; index++) {
+		/* Shade the two border areas with this color. */
+		g_vm->glk_window_fill_rect(glk_window, shading_color,
+		                           x_offset + width * pixel_size
+		                           + GMS_GRAPHICS_BORDER,
+		                           y_offset + index - GMS_GRAPHICS_BORDER,
+		                           GMS_GRAPHICS_SHADING, 1);
+		g_vm->glk_window_fill_rect(glk_window, shading_color,
+		                           x_offset + index - GMS_GRAPHICS_BORDER,
+		                           y_offset + height * pixel_size
+		                           + GMS_GRAPHICS_BORDER,
+		                           1, GMS_GRAPHICS_SHADING);
+
+		/* Update the shading color for the fade next iteration. */
+		shading_color -= fade_color;
+	}
+}
+
+
+/*
+ * gms_graphics_convert_palette()
+ *
+ * Convert a Magnetic Scrolls color palette to a Glk one, using the given
+ * gamma corrections.
+ */
+static void gms_graphics_convert_palette(type16 ms_palette[], gms_gammaref_t gamma,
+        glui32 glk_palette[]) {
+	int index;
+	assert(ms_palette && gamma && glk_palette);
+
+	for (index = 0; index < GMS_PALETTE_SIZE; index++) {
+		gms_rgb_t rgb_color;
+
+		/*
+		 * Convert the 16-bit base picture color through gamma to a 32-bit
+		 * RGB color, and combine into a Glk color and store in the Glk palette.
+		 */
+		gms_graphics_game_to_rgb_color(ms_palette[index], gamma, &rgb_color);
+		glk_palette[index] = gms_graphics_combine_color(&rgb_color);
+	}
+}
+
+
+/*
+ * gms_graphics_position_picture()
+ *
+ * Given a picture width and height, return the x and y offsets to center
+ * this picture in the current graphics window.
+ */
+static void gms_graphics_position_picture(winid_t glk_window,
+        int pixel_size, type16 width, type16 height,
+        int *x_offset, int *y_offset) {
+	glui32 window_width, window_height;
+	assert(glk_window && x_offset && y_offset);
+
+	/* Measure the current graphics window dimensions. */
+	g_vm->glk_window_get_size(glk_window, &window_width, &window_height);
+
+	/*
+	 * Calculate and return an x and y offset to use on point plotting, so that
+	 * the image centers inside the graphical window.
+	 */
+	*x_offset = ((int) window_width - width * pixel_size) / 2;
+	*y_offset = ((int) window_height - height * pixel_size) / 2;
+}
+
+
+/*
+ * gms_graphics_apply_animation_frame()
+ *
+ * Apply a single animation frame to the given off-screen image buffer, using
+ * the frame bitmap, width, height and mask, the off-screen buffer, and the
+ * width and height of the main picture.
+ *
+ * Note that 'mask' may be NULL, implying that no frame pixel is transparent.
+ */
+static void gms_graphics_apply_animation_frame(type8 bitmap[],
+        type16 frame_width, type16 frame_height,
+        type8 mask[], int frame_x, int frame_y,
+        type8 off_screen[], type16 width,
+        type16 height) {
+	int mask_width, x, y;
+	type8 mask_hibit;
+	long frame_row, buffer_row, mask_row;
+	assert(bitmap && off_screen);
+
+	/*
+	 * It turns out that the mask isn't quite as described in defs.h, and thanks
+	 * to Torbjorn Andersson and his Gtk port of Magnetic for illuminating this.
+	 * The mask is made up of lines of 16-bit words, so the mask width is always
+	 * even.  Here we'll calculate the real width of a mask, and also set a high
+	 * bit for later on.
+	 */
+	mask_width = (((frame_width - 1) / CHAR_BIT) + 2) & (~1);
+	mask_hibit = 1 << (CHAR_BIT - 1);
+
+	/*
+	 * Initialize row index components; these are optimizations to avoid the
+	 * need for multiplications in the frame iteration loop.
+	 */
+	frame_row = 0;
+	buffer_row = frame_y * width;
+	mask_row = 0;
+
+	/*
+	 * Iterate over each frame row, clipping where y lies outside the main
+	 * picture area.
+	 */
+	for (y = 0; y < frame_height; y++) {
+		/* Clip if y is outside the main picture area. */
+		if (y + frame_y < 0 || y + frame_y >= height) {
+			/* Update optimization variables as if not clipped. */
+			frame_row += frame_width;
+			buffer_row += width;
+			mask_row += mask_width;
+			continue;
+		}
+
+		/* Iterate over each frame column, clipping again. */
+		for (x = 0; x < frame_width; x++) {
+			long frame_index, buffer_index;
+
+			/* Clip if x is outside the main picture area. */
+			if (x + frame_x < 0 || x + frame_x >= width)
+				continue;
+
+			/*
+			 * If there's a mask, check the bit associated with this x,y, and
+			 * ignore any transparent pixels.
+			 */
+			if (mask) {
+				type8 mask_byte;
+
+				/* Isolate the mask byte, and test the transparency bit. */
+				mask_byte = mask[mask_row + (x / CHAR_BIT)];
+				if ((mask_byte & (mask_hibit >> (x % CHAR_BIT))) != 0)
+					continue;
+			}
+
+			/*
+			 * Calculate indexes for this pixel into the frame, and into the
+			 * main off-screen buffer, and transfer the frame pixel into the
+			 * off-screen buffer.
+			 */
+			frame_index = frame_row + x;
+			buffer_index = buffer_row + x + frame_x;
+			off_screen[buffer_index] = bitmap[frame_index];
+		}
+
+		/* Update row index components on change of y. */
+		frame_row += frame_width;
+		buffer_row += width;
+		mask_row += mask_width;
+	}
+}
+
+
+/*
+ * gms_graphics_animate()
+ *
+ * This function finds and applies the next set of animation frames to the
+ * given off-screen image buffer.  It's handed the width and height of the
+ * main picture, and the off-screen buffer.
+ *
+ * It returns FALSE if at the end of animations, TRUE if more animations
+ * remain.
+ */
+static int gms_graphics_animate(type8 off_screen[], type16 width, type16 height) {
+	struct ms_position *positions;
+	type16 count;
+	type8 status;
+	int frame;
+	assert(off_screen);
+
+	/* Search for more animation frames, and return zero if none. */
+	status = ms_animate(&positions, &count);
+	if (status == 0)
+		return FALSE;
+
+	/* Apply each animation frame to the off-screen buffer. */
+	for (frame = 0; frame < count; frame++) {
+		type8 *bitmap, *mask;
+		type16 frame_width, frame_height;
+
+		/*
+		 * Get the bitmap and other details for this frame.  If we can't get
+		 * this animation frame, skip it and see if any others are available.
+		 */
+		bitmap = ms_get_anim_frame(positions[frame].number,
+		                           &frame_width, &frame_height, &mask);
+		if (bitmap) {
+			gms_graphics_apply_animation_frame(bitmap,
+			                                   frame_width, frame_height, mask,
+			                                   positions[frame].x,
+			                                   positions[frame].y,
+			                                   off_screen, width, height);
+		}
+	}
+
+	/* Return TRUE since more animation frames remain. */
+	return TRUE;
+}
+
+#ifndef GARGLK
+/*
+ * gms_graphics_is_vertex()
+ *
+ * Given a point, return TRUE if that point is the vertex of a fillable
+ * region.  This is a helper function for layering pictures.  When assign-
+ * ing layers, we want to weight the colors that have the most complex
+ * shapes, or the largest count of isolated areas, heavier than simpler
+ * areas.
+ *
+ * By painting the colors with the largest number of isolated areas or
+ * the most complex shapes first, we help to minimize the number of fill
+ * regions needed to render the complete picture.
+ */
+static int gms_graphics_is_vertex(type8 off_screen[], type16 width, type16 height,
+                                  int x, int y) {
+	type8 pixel;
+	int above, below, left, right;
+	long index_row;
+	assert(off_screen);
+
+	/* Use an index row to cut down on multiplications. */
+	index_row = y * width;
+
+	/* Find the color of the reference pixel. */
+	pixel = off_screen[index_row + x];
+	assert(pixel < GMS_PALETTE_SIZE);
+
+	/*
+	 * Detect differences between the reference pixel and its upper, lower, left
+	 * and right neighbors.  Mark as different if the neighbor doesn't exist,
+	 * that is, at the edge of the picture.
+	 */
+	above = (y == 0 || off_screen[index_row - width + x] != pixel);
+	below = (y == height - 1 || off_screen[index_row + width + x] != pixel);
+	left  = (x == 0 || off_screen[index_row + x - 1] != pixel);
+	right = (x == width - 1 || off_screen[index_row + x + 1] != pixel);
+
+	/*
+	 * Return TRUE if this pixel lies at the vertex of a rectangular, fillable,
+	 * area.  That is, if two adjacent neighbors aren't the same color (or if
+	 * absent -- at the edge of the picture).
+	 */
+	return ((above || below) && (left || right));
+}
+
+/*
+ * gms_graphics_compare_layering_inverted()
+ * gms_graphics_assign_layers()
+ *
+ * Given two sets of image bitmaps, and a palette, this function will
+ * assign layers palette colors.
+ *
+ * Layers are assigned by first counting the number of vertices in the
+ * color plane, to get a measure of the complexity of shapes displayed in
+ * this color, and also the raw number of times each palette color is
+ * used.  This is then sorted, so that layers are assigned to colors, with
+ * the lowest layer being the color with the most complex shapes, and
+ * within this (or where the count of vertices is zero, as it could be
+ * in some animation frames) the most used color.
+ *
+ * The function compares pixels in the two image bitmaps given, these
+ * being the off-screen and on-screen buffers, and generates counts only
+ * where these bitmaps differ.  This ensures that only pixels not yet
+ * painted are included in layering.
+ *
+ * As well as assigning layers, this function returns a set of layer usage
+ * flags, to help the rendering loop to terminate as early as possible.
+ *
+ * By painting lower layers first, the paint can take in larger areas if
+ * it's permitted to include not-yet-validated higher levels.  This helps
+ * minimize the amount of Glk areas fills needed to render a picture.
+ */
+typedef struct {
+	long complexity;  /* Count of vertices for this color. */
+	long usage;       /* Color usage count. */
+	int color;        /* Color index into palette. */
+} gms_layering_t;
+
+static int gms_graphics_compare_layering_inverted(const void *void_first,
+        const void *void_second) {
+	gms_layering_t *first = (gms_layering_t *) void_first;
+	gms_layering_t *second = (gms_layering_t *) void_second;
+
+	/*
+	 * Order by complexity first, then by usage, putting largest first.  Some
+	 * colors may have no vertices at all when doing animation frames, but
+	 * rendering optimization relies on the first layer that contains no areas
+	 * to fill halting the rendering loop.  So it's important here that we order
+	 * indexes so that colors that render complex shapes come first, non-empty,
+	 * but simpler shaped colors next, and finally all genuinely empty layers.
+	 */
+	return second->complexity > first->complexity ? 1 :
+	       first->complexity > second->complexity ? -1 :
+	       second->usage > first->usage ? 1 :
+	       first->usage > second->usage ? -1 : 0;
+}
+
+static void gms_graphics_assign_layers(type8 off_screen[], type8 on_screen[],
+                                       type16 width, type16 height,
+                                       int layers[], long layer_usage[]) {
+	int index, x, y;
+	long index_row;
+	gms_layering_t layering[GMS_PALETTE_SIZE];
+	assert(off_screen && on_screen && layers && layer_usage);
+
+	/* Clear initial complexity and usage counts, and set initial colors. */
+	for (index = 0; index < GMS_PALETTE_SIZE; index++) {
+		layering[index].complexity = 0;
+		layering[index].usage = 0;
+		layering[index].color = index;
+	}
+
+	/*
+	 * Traverse the image, counting vertices and pixel usage where the pixels
+	 * differ between the off-screen and on-screen buffers.  Optimize by
+	 * maintaining an index row to avoid multiplications.
+	 */
+	for (y = 0, index_row = 0; y < height; y++, index_row += width) {
+		for (x = 0; x < width; x++) {
+			long idx;
+
+			/*
+			 * Get the index for this pixel, and update complexity and usage
+			 * if off-screen and on-screen pixels differ.
+			 */
+			idx = index_row + x;
+			if (on_screen[idx] != off_screen[idx]) {
+				if (gms_graphics_is_vertex(off_screen, width, height, x, y))
+					layering[off_screen[idx]].complexity++;
+
+				layering[off_screen[idx]].usage++;
+			}
+		}
+	}
+
+	/*
+	 * Sort counts to form color indexes.  The primary sort is on the shape
+	 * complexity, and within this, on color usage.
+	 */
+	qsort(layering, GMS_PALETTE_SIZE,
+	      sizeof(*layering), gms_graphics_compare_layering_inverted);
+
+	/*
+	 * Assign a layer to each palette color, and also return the layer usage
+	 * for each layer.
+	 */
+	for (index = 0; index < GMS_PALETTE_SIZE; index++) {
+		layers[layering[index].color] = index;
+		layer_usage[index] = layering[index].usage;
+	}
+}
+
+/*
+ * gms_graphics_paint_region()
+ *
+ * This is a partially optimized point plot.  Given a point in the graphics
+ * bitmap, it tries to extend the point to a color region, and fill a number
+ * of pixels in a single Glk rectangle fill.  The goal here is to reduce the
+ * number of Glk rectangle fills, which tend to be extremely inefficient
+ * operations for generalized point plotting.
+ *
+ * The extension works in image layers; each palette color is assigned a
+ * layer, and we paint each layer individually, starting at the lowest.  So,
+ * the region is free to fill any invalidated pixel in a higher layer, and
+ * all pixels, invalidated or already validated, in the same layer.  In
+ * practice, it is good enough to look for either invalidated pixels or pixels
+ * in the same layer, and construct a region as large as possible from these,
+ * then on marking points as validated, mark only those in the same layer as
+ * the initial point.
+ *
+ * The optimization here is not the best possible, but is reasonable.  What
+ * we do is to try and stretch the region horizontally first, then vertically.
+ * In practice, we might find larger areas by stretching vertically and then
+ * horizontally, or by stretching both dimensions at the same time.  In
+ * mitigation, the number of colors in a picture is small (16), and the
+ * aspect ratio of pictures makes them generally wider than they are tall.
+ *
+ * Once we've found the region, we render it with a single Glk rectangle fill,
+ * and mark all the pixels in this region that match the layer of the initial
+ * given point as validated.
+ */
+static void gms_graphics_paint_region(winid_t glk_window, glui32 palette[], int layers[],
+                                      type8 off_screen[], type8 on_screen[],
+                                      int x, int y, int x_offset, int y_offset,
+                                      int pixel_size, type16 width, type16 height) {
+	type8 pixel;
+	int layer, x_min, x_max, y_min, y_max, x_index, y_index;
+	long index_row;
+	assert(glk_window && palette && layers && off_screen && on_screen);
+
+	/* Find the color and layer for the initial pixel. */
+	pixel = off_screen[y * width + x];
+	layer = layers[pixel];
+	assert(pixel < GMS_PALETTE_SIZE);
+
+	/*
+	 * Start by finding the extent to which we can pull the x coordinate and
+	 * still find either invalidated pixels, or pixels in this layer.
+	 *
+	 * Use an index row to remove multiplications from the loops.
+	 */
+	index_row = y * width;
+	for (x_min = x; x_min - 1 >= 0; x_min--) {
+		long index = index_row + x_min - 1;
+
+		if (on_screen[index] == off_screen[index]
+		        && layers[off_screen[index]] != layer)
+			break;
+	}
+	for (x_max = x; x_max + 1 < width; x_max++) {
+		long index = index_row + x_max + 1;
+
+		if (on_screen[index] == off_screen[index]
+		        && layers[off_screen[index]] != layer)
+			break;
+	}
+
+	/*
+	 * Now try to stretch the height of the region, by extending the y
+	 * coordinate as much as possible too.  Again, we're looking for pixels
+	 * that are invalidated or ones in the same layer.  We need to check
+	 * across the full width of the current region.
+	 *
+	 * As above, an index row removes multiplications from the loops.
+	 */
+	for (y_min = y, index_row = (y - 1) * width;
+	        y_min - 1 >= 0; y_min--, index_row -= width) {
+		for (x_index = x_min; x_index <= x_max; x_index++) {
+			long index = index_row + x_index;
+
+			if (on_screen[index] == off_screen[index]
+			        && layers[off_screen[index]] != layer)
+				goto break_y_min;
+		}
+	}
+break_y_min:
+
+	for (y_max = y, index_row = (y + 1) * width;
+	        y_max + 1 < height; y_max++, index_row += width) {
+		for (x_index = x_min; x_index <= x_max; x_index++) {
+			long index = index_row + x_index;
+
+			if (on_screen[index] == off_screen[index]
+			        && layers[off_screen[index]] != layer)
+				goto break_y_max;
+		}
+	}
+break_y_max:
+
+	/* Fill the region using Glk's rectangle fill. */
+	g_vm->glk_window_fill_rect(glk_window, palette[pixel],
+	                           x_min * pixel_size + x_offset,
+	                           y_min * pixel_size + y_offset,
+	                           (x_max - x_min + 1) * pixel_size,
+	                           (y_max - y_min + 1) * pixel_size);
+
+	/*
+	 * Validate each pixel in the reference layer that was rendered by the
+	 * rectangle fill.  We don't validate pixels that are not in this layer
+	 * (and are by definition in higher layers, as we've validated all lower
+	 * layers), since although we colored them, we did it for optimization
+	 * reasons, and they're not yet colored correctly.
+	 *
+	 * Maintain an index row as an optimization to avoid multiplication.
+	 */
+	index_row = y_min * width;
+	for (y_index = y_min; y_index <= y_max; y_index++) {
+		for (x_index = x_min; x_index <= x_max; x_index++) {
+			long index;
+
+			/*
+			 * Get the index for x_index,y_index.  If the layers match, update
+			 * the on-screen buffer.
+			 */
+			index = index_row + x_index;
+			if (layers[off_screen[index]] == layer) {
+				assert(off_screen[index] == pixel);
+				on_screen[index] = off_screen[index];
+			}
+		}
+
+		/* Update row index component on change of y. */
+		index_row += width;
+	}
+}
+#endif
+
+static void gms_graphics_paint_everything(winid_t glk_window,
+        glui32 palette[],
+        type8 off_screen[],
+        int x_offset, int y_offset,
+        type16 width, type16 height) {
+	type8       pixel;          /* Reference pixel color */
+	int     x, y;
+
+	for (y = 0; y < height; y++) {
+		for (x = 0; x < width; x ++) {
+			pixel = off_screen[ y * width + x ];
+			g_vm->glk_window_fill_rect(glk_window,
+			                           palette[ pixel ],
+			                           x * GMS_GRAPHICS_PIXEL + x_offset,
+			                           y * GMS_GRAPHICS_PIXEL + y_offset,
+			                           GMS_GRAPHICS_PIXEL, GMS_GRAPHICS_PIXEL);
+		}
+	}
+}
+
+/*
+ * gms_graphics_timeout()
+ *
+ * This is a background function, called on Glk timeouts.  Its job is to
+ * repaint some of the current graphics image.  On successive calls, it
+ * does a part of the repaint, then yields to other processing.  This is
+ * useful since the Glk primitive to plot points in graphical windows is
+ * extremely slow; this way, the repaint doesn't block game play.
+ *
+ * The function should be called on Glk timeout events.  When the repaint
+ * is complete, the function will turn off Glk timers.
+ *
+ * The function uses double-buffering to track how much of the graphics
+ * buffer has been rendered.  This helps to minimize the amount of point
+ * plots required, as only the differences between the two buffers need
+ * to be rendered.
+ */
+static void gms_graphics_timeout() {
+	static glui32 palette[GMS_PALETTE_SIZE];   /* Precomputed Glk palette */
+#ifndef GARGLK
+	static int layers[GMS_PALETTE_SIZE];       /* Assigned image layers */
+	static long layer_usage[GMS_PALETTE_SIZE]; /* Image layer occupancies */
+#endif
+
+	static int deferred_repaint = FALSE;       /* Local delayed repaint flag */
+	static int ignore_counter;                 /* Count of calls ignored */
+
+	static int x_offset, y_offset;             /* Point plot offsets */
+	static int yield_counter;                  /* Yields in rendering */
+#ifndef GARGLK
+	static int saved_layer;                    /* Saved current layer */
+	static int saved_x, saved_y;               /* Saved x,y coord */
+	static int total_regions;                  /* Debug statistic */
+#endif
+
+	type8 *on_screen;                          /* On-screen image buffer */
+	type8 *off_screen;                         /* Off-screen image buffer */
+	long picture_size;                         /* Picture size in pixels */
+//  int layer;                                 /* Image layer iterator */
+//  int x, y;                                  /* Image iterators */
+//  int regions;                               /* Count of regions painted */
+
+	/* Ignore the call if the current graphics state is inactive. */
+	if (!gms_graphics_active)
+		return;
+	assert(gms_graphics_window);
+
+	/*
+	 * On detecting a repaint request, note the flag in a local static variable,
+	 * then set up a graphics delay to wait until, hopefully, the resize, if
+	 * that's what caused it, is complete, and return.  This makes resizing the
+	 * window a lot smoother, since it prevents unnecessary region paints where
+	 * we are receiving consecutive Glk arrange or redraw events.
+	 */
+	if (gms_graphics_repaint) {
+		deferred_repaint = TRUE;
+		gms_graphics_repaint = FALSE;
+		ignore_counter = GMS_GRAPHICS_REPAINT_WAIT - 1;
+		return;
+	}
+
+	/*
+	 * If asked to ignore a given number of calls, decrement the ignore counter
+	 * and return having done nothing more.  This lets us delay graphics
+	 * operations by a number of timeouts, providing animation timing and
+	 * partial protection from resize event "storms".
+	 *
+	 * Note -- to wait for N timeouts, set the count of timeouts to be ignored
+	 * to N-1.
+	 */
+	assert(ignore_counter >= 0);
+	if (ignore_counter > 0) {
+		ignore_counter--;
+		return;
+	}
+
+	/* Calculate the picture size, and synchronize screen buffer pointers. */
+	picture_size = gms_graphics_width * gms_graphics_height;
+	off_screen = gms_graphics_off_screen;
+	on_screen = gms_graphics_on_screen;
+
+	/*
+	 * If we received a new picture, set up the local static variables for that
+	 * picture -- decide on gamma correction, convert the color palette, and
+	 * initialize the off_screen buffer to be the base picture.
+	 */
+	if (gms_graphics_new_picture) {
+		/* Initialize the off_screen buffer to be a copy of the base picture. */
+		free(off_screen);
+		off_screen = (type8 *)gms_malloc(picture_size * sizeof(*off_screen));
+		memcpy(off_screen, gms_graphics_bitmap,
+		       picture_size * sizeof(*off_screen));
+
+		/* Note the buffer for freeing on cleanup. */
+		gms_graphics_off_screen = off_screen;
+
+		/*
+		 * If the picture is animated, apply the first animation frames now.
+		 * This is important, since they form an intrinsic part of the first
+		 * displayed image (in type2 animation cases, perhaps _all_ of the
+		 * first displayed image).
+		 */
+		if (gms_graphics_animated) {
+			gms_graphics_animate(off_screen,
+			                     gms_graphics_width, gms_graphics_height);
+		}
+
+		/*
+		 * Select a suitable gamma for the picture, taking care to use the
+		 * off-screen buffer.
+		 */
+		gms_graphics_current_gamma =
+		    gms_graphics_select_gamma(off_screen,
+		                              gms_graphics_width,
+		                              gms_graphics_height,
+		                              gms_graphics_palette);
+
+		/*
+		 * Pre-convert all the picture palette colors into their corresponding
+		 * Glk colors.
+		 */
+		gms_graphics_convert_palette(gms_graphics_palette,
+		                             gms_graphics_current_gamma, palette);
+
+		/* Save the color count for possible queries later. */
+		gms_graphics_count_colors(off_screen,
+		                          gms_graphics_width, gms_graphics_height,
+		                          &gms_graphics_color_count, NULL);
+	}
+
+	/*
+	 * For a new picture, or a repaint of a prior one, calculate new values for
+	 * the x and y offsets used to draw image points, and set the on-screen
+	 * buffer to an unused pixel value, in effect invalidating all on-screen
+	 * data.  Also, reset the saved image scan coordinates so that we scan for
+	 * unpainted pixels from top left starting at layer zero, and clear the
+	 * graphics window.
+	 */
+	if (gms_graphics_new_picture || deferred_repaint) {
+		/*
+		 * Calculate the x and y offset to center the picture in the graphics
+		 * window.
+		 */
+		gms_graphics_position_picture(gms_graphics_window,
+		                              GMS_GRAPHICS_PIXEL,
+		                              gms_graphics_width, gms_graphics_height,
+		                              &x_offset, &y_offset);
+
+		/*
+		 * Reset all on-screen pixels to an unused value, guaranteed not to
+		 * match any in a real picture.  This forces all pixels to be repainted
+		 * on a buffer/on-screen comparison.
+		 */
+		free(on_screen);
+		on_screen = (type8 *)gms_malloc(picture_size * sizeof(*on_screen));
+		memset(on_screen, GMS_GRAPHICS_UNUSED_PIXEL,
+		       picture_size * sizeof(*on_screen));
+
+		/* Note the buffer for freeing on cleanup. */
+		gms_graphics_on_screen = on_screen;
+
+		/*
+		 * Assign new layers to the current image.  This sorts colors by usage
+		 * and puts the most used colors in the lower layers.  It also hands us
+		 * a count of pixels in each layer, useful for knowing when to stop
+		 * scanning for layers in the rendering loop.
+		 */
+#ifndef GARGLK
+		gms_graphics_assign_layers(off_screen, on_screen,
+		                           gms_graphics_width, gms_graphics_height,
+		                           layers, layer_usage);
+
+		saved_layer = 0;
+		saved_x = 0;
+		saved_y = 0;
+		total_regions = 0;
+#endif
+
+		/* Clear the graphics window. */
+		gms_graphics_clear_and_border(gms_graphics_window,
+		                              x_offset, y_offset,
+		                              GMS_GRAPHICS_PIXEL,
+		                              gms_graphics_width, gms_graphics_height);
+
+		/* Start a fresh picture rendering pass. */
+		yield_counter = 0;
+
+		/* Clear the new picture and deferred repaint flags. */
+		gms_graphics_new_picture = FALSE;
+		deferred_repaint = FALSE;
+	}
+
+#ifndef GARGLK
+	/*
+	 * Make a portion of an image pass, from lower to higher image layers,
+	 * scanning for invalidated pixels that are in the current image layer we
+	 * are painting.  Each invalidated pixel gives rise to a region paint,
+	 * which equates to one Glk rectangle fill.
+	 *
+	 * When the limit on regions is reached, save the current image pass layer
+	 * and coordinates, and yield control to the main game playing code by
+	 * returning.  On the next call, pick up where we left off.
+	 *
+	 * As an optimization, we can leave the loop on the first empty layer we
+	 * encounter.  Since layers are ordered by complexity and color usage, all
+	 * layers higher than the first unused one will also be empty, so we don't
+	 * need to scan them.
+	 */
+	regions = 0;
+	for (layer = saved_layer;
+	        layer < GMS_PALETTE_SIZE && layer_usage[layer] > 0; layer++) {
+		long index_row;
+
+		/*
+		 * As an optimization to avoid multiplications in the loop, maintain a
+		 * separate index row.
+		 */
+		index_row = saved_y * gms_graphics_width;
+		for (y = saved_y; y < gms_graphics_height; y++) {
+			for (x = saved_x; x < gms_graphics_width; x++) {
+				long index;
+
+				/* Get the index for this pixel. */
+				index = index_row + x;
+				assert(index < picture_size * sizeof(*off_screen));
+
+				/*
+				 * Ignore pixels not in the current layer, and pixels not
+				 * currently invalid (that is, ones whose on-screen represen-
+				 * tation matches the off-screen buffer).
+				 */
+				if (layers[off_screen[index]] == layer
+				        && on_screen[index] != off_screen[index]) {
+					/*
+					 * Rather than painting just one pixel, here we try to
+					 * paint the maximal region we can for the layer of the
+					 * given pixel.
+					 */
+					gms_graphics_paint_region(gms_graphics_window,
+					                          palette, layers,
+					                          off_screen, on_screen,
+					                          x, y, x_offset, y_offset,
+					                          GMS_GRAPHICS_PIXEL,
+					                          gms_graphics_width,
+					                          gms_graphics_height);
+
+					/*
+					 * Increment count of regions handled, and yield, by
+					 * returning, if the limit on paint regions is reached.
+					 * Before returning, save the current layer and scan
+					 * coordinates, so we can pick up here on the next call.
+					 */
+					regions++;
+					if (regions >= GMS_REPAINT_LIMIT) {
+						yield_counter++;
+						saved_layer = layer;
+						saved_x = x;
+						saved_y = y;
+						total_regions += regions;
+						return;
+					}
+				}
+			}
+
+			/* Reset the saved x coordinate on y increment. */
+			saved_x = 0;
+
+			/* Update the index row on change of y. */
+			index_row += gms_graphics_width;
+		}
+
+		/* Reset the saved y coordinate on layer change. */
+		saved_y = 0;
+	}
+
+	/*
+	 * If we reach this point, then we didn't get to the limit on regions
+	 * painted on this pass.  In that case, we've finished rendering the
+	 * image.
+	 */
+	assert(regions < GMS_REPAINT_LIMIT);
+	total_regions += regions;
+
+#else
+	gms_graphics_paint_everything
+	(gms_graphics_window,
+	 palette, off_screen,
+	 x_offset, y_offset,
+	 gms_graphics_width,
+	 gms_graphics_height);
+#endif
+
+	/*
+	 * If animated, and if animations are enabled, handle further animation
+	 * frames, if any.
+	 */
+	if (gms_animation_enabled && gms_graphics_animated) {
+		int more_animation;
+
+		/*
+		 * Reset the off-screen buffer to a copy of the base picture.  This is
+		 * the correct state for applying animation frames.
+		 */
+		memcpy(off_screen, gms_graphics_bitmap,
+		       picture_size * sizeof(*off_screen));
+
+		/*
+		 * Apply any further animations.  If none, then stop the graphics
+		 * "thread" and return.  There's no more to be done until something
+		 * restarts us.
+		 */
+		more_animation = gms_graphics_animate(off_screen,
+		                                      gms_graphics_width,
+		                                      gms_graphics_height);
+		if (!more_animation) {
+			/*
+			 * There's one extra wrinkle here.  The base picture we've just put
+			 * into the off-screen buffer isn't really complete (and for type2
+			 * animations, might be pure garbage), so if we happen to get a
+			 * repaint after an animation has ended, the off-screen data we'll
+			 * be painting could well look wrong.
+			 *
+			 * So... here we want to set the off-screen buffer to contain the
+			 * final animation frame.  Fortunately, we still have it in the
+			 * on-screen buffer.
+			 */
+			memcpy(off_screen, on_screen, picture_size * sizeof(*off_screen));
+			gms_graphics_stop();
+			return;
+		}
+
+		/*
+		 * Re-assign layers based on animation changes to the off-screen
+		 * buffer.
+		 */
+#ifndef GARGLK
+		gms_graphics_assign_layers(off_screen, on_screen,
+		                           gms_graphics_width, gms_graphics_height,
+		                           layers, layer_usage);
+#endif
+
+		/*
+		 * Set up an animation wait, adjusted here by the number of times we
+		 * had to yield while rendering, as we're now that late with animations,
+		 * and capped at zero, as we can't do anything to compensate for being
+		 * too late.  In practice, we're running too close to the edge to have
+		 * much of an effect here, but nevertheless...
+		 */
+		ignore_counter = GMS_GRAPHICS_ANIMATION_WAIT - 1;
+		if (yield_counter > ignore_counter)
+			ignore_counter = 0;
+		else
+			ignore_counter -= yield_counter;
+
+		/* Start a fresh picture rendering pass. */
+		yield_counter = 0;
+#ifndef GARGLK
+		saved_layer = 0;
+		saved_x = 0;
+		saved_y = 0;
+		total_regions = 0;
+#endif
+	} else {
+		/*
+		 * Not an animated picture, so just stop graphics, as again, there's
+		 * no more to be done until something restarts us.
+		 */
+		gms_graphics_stop();
+	}
+}
+
+
+/*
+ * ms_showpic()
+ *
+ * Called by the main interpreter when it wants us to display a picture.
+ * The function gets the picture bitmap, palette, and dimensions, and
+ * saves them, and the picture id, in module variables for the background
+ * rendering function.
+ *
+ * The graphics window is opened if required, or closed if mode is zero.
+ *
+ * The function checks for changes of actual picture by calculating the
+ * CRC for picture data; this helps to prevent unnecessary repaints in
+ * cases where the interpreter passes us the same picture as we're already
+ * displaying.  There is a less than 1 in 4,294,967,296 chance that a new
+ * picture will be missed.  We'll live with that.
+ *
+ * Why use CRCs, rather than simply storing the values of picture passed in
+ * a static variable?  Because some games, typically Magnetic Windows, use
+ * the picture argument as a form of string pointer, and can pass in the
+ * same value for several, perhaps all, game pictures.  If we just checked
+ * for a change in the picture argument, we'd never see one.  So we must
+ * instead look for changes in the real picture data.
+ */
+void ms_showpic(type32 picture, type8 mode) {
+	static glui32 current_crc = 0;  /* CRC of the current picture */
+
+	type8 *bitmap, animated;
+	type16 width, height, palette[GMS_PALETTE_SIZE];
+	long picture_bytes;
+	glui32 crc;
+
+	/* See if the mode indicates no graphics. */
+	if (mode == 0) {
+		/* Note that the interpreter turned graphics off. */
+		gms_graphics_interpreter = FALSE;
+
+		/*
+		 * If we are currently displaying the graphics window, stop any update
+		 * "thread" and turn off graphics.
+		 */
+		if (gms_graphics_enabled && gms_graphics_are_displayed()) {
+			gms_graphics_stop();
+			gms_graphics_close();
+		}
+
+		/* Nothing more to do now graphics are off. */
+		return;
+	}
+
+	/* Note that the interpreter turned graphics on. */
+	gms_graphics_interpreter = TRUE;
+
+	/*
+	 * Obtain the image details for the requested picture.  The call returns
+	 * NULL if there's a problem with the picture.
+	 */
+	bitmap = ms_extract(picture, &width, &height, palette, &animated);
+	if (!bitmap)
+		return;
+
+	/* Note the last thing passed to ms_extract, in case of graphics restarts. */
+	gms_graphics_picture = picture;
+
+	/* Calculate the picture size, and the CRC for the bitmap data. */
+	picture_bytes = width * height * sizeof(*bitmap);
+	crc = gms_get_buffer_crc(bitmap, picture_bytes);
+
+	/*
+	 * If there is no change of picture, we might be able to largely ignore the
+	 * call.  Check for a change, and if we don't see one, and if graphics are
+	 * enabled and being displayed, we can safely ignore the call.
+	 */
+	if (width == gms_graphics_width
+	        && height == gms_graphics_height
+	        && crc == current_crc
+	        && gms_graphics_enabled && gms_graphics_are_displayed())
+		return;
+
+	/*
+	 * We know now that this is either a genuine change of picture, or graphics
+	 * were off and have been turned on.  So, record picture details, ensure
+	 * graphics is on, set the flags, and start the background graphics update.
+	 */
+
+	/*
+	 * Save the picture details for the update code.  Here we take a complete
+	 * local copy of the bitmap, since the interpreter core may reuse part of
+	 * its memory for animations.
+	 */
+	free(gms_graphics_bitmap);
+	gms_graphics_bitmap = (type8 *)gms_malloc(picture_bytes);
+	memcpy(gms_graphics_bitmap, bitmap, picture_bytes);
+	gms_graphics_width = width;
+	gms_graphics_height = height;
+	memcpy(gms_graphics_palette, palette, sizeof(palette));
+	gms_graphics_animated = animated;
+
+	/* Retain the new picture CRC. */
+	current_crc = crc;
+
+	/*
+	 * If graphics are enabled, ensure the window is displayed, set the
+	 * appropriate flags, and start graphics update.  If they're not enabled,
+	 * the picture details will simply stick around in module variables until
+	 * they are required.
+	 */
+	if (gms_graphics_enabled) {
+		/*
+		 * Ensure graphics on, then set the new picture flag and start the
+		 * updating "thread".
+		 */
+		if (gms_graphics_open()) {
+			gms_graphics_new_picture = TRUE;
+			gms_graphics_start();
+		}
+	}
+}
+
+
+/*
+ * gms_graphics_picture_is_available()
+ *
+ * Return TRUE if the graphics module data is loaded with a usable picture,
+ * FALSE if there is no picture available to display.
+ */
+static int
+gms_graphics_picture_is_available(void) {
+	return gms_graphics_bitmap != NULL;
+}
+
+
+/*
+ * gms_graphics_get_picture_details()
+ *
+ * Return the width, height, and animation flag of the currently loaded
+ * picture.  The function returns FALSE if no picture is loaded, otherwise
+ * TRUE, with picture details in the return arguments.
+ */
+static int gms_graphics_get_picture_details(int *width, int *height, int *is_animated) {
+	if (gms_graphics_picture_is_available()) {
+		if (width)
+			*width = gms_graphics_width;
+		if (height)
+			*height = gms_graphics_height;
+		if (is_animated)
+			*is_animated = gms_graphics_animated;
+
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+/*
+ * gms_graphics_get_rendering_details()
+ *
+ * Returns the current level of applied gamma correction, as a string, the
+ * count of colors in the picture, and a flag indicating if graphics is
+ * active (busy).  The function return FALSE if graphics is not enabled or
+ * if not being displayed, otherwise TRUE with the gamma, color count, and
+ * active flag in the return arguments.
+ *
+ * This function races with the graphics timeout, as it returns information
+ * set up by the first timeout following a new picture.  There's a very,
+ * very small chance that it might win the race, in which case out-of-date
+ * gamma and color count values are returned.
+ */
+static int gms_graphics_get_rendering_details(const char **gamma, int *color_count,
+        int *is_active) {
+	if (gms_graphics_enabled && gms_graphics_are_displayed()) {
+		/*
+		 * Return the string representing the gamma correction.  If racing
+		 * with timeouts, we might return the gamma for the last picture.
+		 */
+		if (gamma) {
+			assert(gms_graphics_current_gamma);
+			*gamma = gms_graphics_current_gamma->level;
+		}
+
+		/*
+		 * Return the color count noted by timeouts on the first timeout
+		 * following a new picture.  Again, we might return the one for
+		 * the prior picture.
+		 */
+		if (color_count)
+			*color_count = gms_graphics_color_count;
+
+		/* Return graphics active flag. */
+		if (is_active)
+			*is_active = gms_graphics_active;
+
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+/*
+ * gms_graphics_interpreter_enabled()
+ *
+ * Return TRUE if it looks like interpreter graphics are turned on, FALSE
+ * otherwise.
+ */
+static int gms_graphics_interpreter_enabled(void) {
+	return gms_graphics_interpreter;
+}
+
+
+/*
+ * gms_graphics_cleanup()
+ *
+ * Free memory resources allocated by graphics functions.  Called on game
+ * end.
+ */
+static void gms_graphics_cleanup(void) {
+	free(gms_graphics_bitmap);
+	gms_graphics_bitmap = NULL;
+	free(gms_graphics_off_screen);
+	gms_graphics_off_screen = NULL;
+	free(gms_graphics_on_screen);
+	gms_graphics_on_screen = NULL;
+
+	gms_graphics_animated = FALSE;
+	gms_graphics_picture = 0;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port status line functions                                     */
+/*---------------------------------------------------------------------*/
+
+/*
+ * The interpreter feeds us status line characters one at a time, with Tab
+ * indicating right justify, and CR indicating the line is complete.  To get
+ * this to fit with the Glk event and redraw model, here we'll buffer each
+ * completed status line, so we have a stable string to output when needed.
+ * It's also handy to have this buffer for Glk libraries that don't support
+ * separate windows.
+ */
+enum { GMS_STATBUFFER_LENGTH = 1024 };
+static char gms_status_buffer[GMS_STATBUFFER_LENGTH];
+static int gms_status_length = 0;
+
+/* Default width used for non-windowing Glk status lines. */
+static const int GMS_DEFAULT_STATUS_WIDTH = 74;
+
+
+/*
+ * ms_statuschar()
+ *
+ * Receive one status character from the interpreter.  Characters are
+ * buffered internally, and on CR, the buffer is copied to the main static
+ * status buffer for use by the status line printing function.
+ */
+void ms_statuschar(type8 c) {
+	static char buffer[GMS_STATBUFFER_LENGTH];
+	static int length = 0;
+
+	/*
+	 * If the status character is newline, transfer locally buffered data to
+	 * the common buffer, empty the local buffer; otherwise, if space permits,
+	 * buffer the character.
+	 */
+	if (c == '\n') {
+		memcpy(gms_status_buffer, buffer, length);
+		gms_status_length = length;
+
+		length = 0;
+	} else {
+		if (length < (int)sizeof(buffer))
+			buffer[length++] = c;
+	}
+}
+
+
+/*
+ * gms_status_update()
+ *
+ * Update the information in the status window with the current contents of
+ * the completed status line buffer, or a default string if no completed
+ * status line.
+ */
+static void gms_status_update(void) {
+	glui32 width, height;
+	int index;
+	assert(gms_status_window);
+
+	g_vm->glk_window_get_size(gms_status_window, &width, &height);
+	if (height > 0) {
+		g_vm->glk_window_clear(gms_status_window);
+		g_vm->glk_window_move_cursor(gms_status_window, 0, 0);
+		g_vm->glk_set_window(gms_status_window);
+
+		g_vm->glk_set_style(style_User1);
+		for (index = 0; index < (int)width; index++)
+			g_vm->glk_put_char(' ');
+		g_vm->glk_window_move_cursor(gms_status_window, 1, 0);
+
+		if (gms_status_length > 0) {
+			/*
+			 * Output each character from the status line buffer.  If the
+			 * character is Tab, position the cursor to eleven characters shy
+			 * of the status window right.
+			 */
+			for (index = 0; index < gms_status_length; index++) {
+				if (gms_status_buffer[index] == '\t')
+					g_vm->glk_window_move_cursor(gms_status_window, width - 11, 0);
+				else
+					g_vm->glk_put_char(gms_status_buffer[index]);
+			}
+		} else {
+			const char *game_name;
+
+			/*
+			 * We have no status line to display, so print the game's name, or
+			 * a standard message if unable to identify the game.  Having no
+			 * status line is common with Magnetic Windows games, which don't,
+			 * in general, seem to use one.
+			 */
+			game_name = gms_gameid_get_game_name();
+			g_vm->glk_put_string(game_name ? game_name : "ScummVM Magnetic version 2.3");
+		}
+
+		g_vm->glk_set_window(gms_main_window);
+	}
+}
+
+
+/*
+ * gms_status_print()
+ *
+ * Print the current contents of the completed status line buffer out in the
+ * main window, if it has changed since the last call.  This is for non-
+ * windowing Glk libraries.
+ */
+static void gms_status_print(void) {
+	static char buffer[GMS_STATBUFFER_LENGTH];
+	static int length = 0;
+
+	int index, column;
+
+	/*
+	 * Do nothing if there is no status line to print, or if the status
+	 * line hasn't changed since last printed.
+	 */
+	if (gms_status_length == 0
+	        || (gms_status_length == length
+	            && strncmp(buffer, gms_status_buffer, length)) == 0)
+		return;
+
+	/* Set fixed width font to try to preserve status line formatting. */
+	g_vm->glk_set_style(style_Preformatted);
+
+	/* Bracket, and output the status line buffer. */
+	g_vm->glk_put_string("[ ");
+	column = 1;
+	for (index = 0; index < gms_status_length; index++) {
+		/*
+		 * If the character is Tab, position the cursor to eleven characters
+		 * shy of the right edge.  In the absence of the real window dimensions,
+		 * we'll select 74 characters, which gives us a 78 character status
+		 * line; pretty standard.
+		 */
+		if (gms_status_buffer[index] == '\t') {
+			while (column <= GMS_DEFAULT_STATUS_WIDTH - 11) {
+				g_vm->glk_put_char(' ');
+				column++;
+			}
+		} else {
+			g_vm->glk_put_char(gms_status_buffer[index]);
+			column++;
+		}
+	}
+
+	while (column <= GMS_DEFAULT_STATUS_WIDTH) {
+		g_vm->glk_put_char(' ');
+		column++;
+	}
+	g_vm->glk_put_string(" ]\n");
+
+	/* Save the details of the printed status buffer. */
+	memcpy(buffer, gms_status_buffer, gms_status_length);
+	length = gms_status_length;
+}
+
+
+/*
+ * gms_status_notify()
+ *
+ * Front end function for updating status.  Either updates the status window
+ * or prints the status line to the main window.
+ */
+static void gms_status_notify(void) {
+	if (gms_status_window)
+		gms_status_update();
+	else
+		gms_status_print();
+}
+
+
+/*
+ * gms_status_redraw()
+ *
+ * Redraw the contents of any status window with the buffered status string.
+ * This function should be called on the appropriate Glk window resize and
+ * arrange events.
+ */
+static void gms_status_redraw(void) {
+	if (gms_status_window) {
+		winid_t parent;
+
+		/*
+		 * Rearrange the status window, without changing its actual arrangement
+		 * in any way.  This is a hack to work round incorrect window repainting
+		 * in Xglk; it forces a complete repaint of affected windows on Glk
+		 * window resize and arrange events, and works in part because Xglk
+		 * doesn't check for actual arrangement changes in any way before
+		 * invalidating its windows.  The hack should be harmless to Glk
+		 * libraries other than Xglk, moreover, we're careful to activate it
+		 * only on resize and arrange events.
+		 */
+		parent = g_vm->glk_window_get_parent(gms_status_window);
+		g_vm->glk_window_set_arrangement(parent,
+		                                 winmethod_Above | winmethod_Fixed, 1, NULL);
+
+		gms_status_update();
+	}
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port output functions                                          */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Flag for if the user entered "help" as their last input, or if hints have
+ * been silenced as a result of already using a Glk command.
+ */
+static int gms_help_requested = FALSE,
+           gms_help_hints_silenced = FALSE;
+
+/*
+ * Output buffer.  We receive characters one at a time, and it's a bit
+ * more efficient for everyone if we buffer them, and output a complete
+ * string on a flush call.
+ */
+static char *gms_output_buffer = NULL;
+static int gms_output_allocation = 0,
+           gms_output_length = 0;
+
+/*
+ * Flag to indicate if the last buffer flushed looked like it ended in a
+ * ">" prompt.
+ */
+static int gms_output_prompt = FALSE;
+
+
+/*
+ * gms_output_register_help_request()
+ * gms_output_silence_help_hints()
+ * gms_output_provide_help_hint()
+ *
+ * Register a request for help, and print a note of how to get Glk command
+ * help from the interpreter unless silenced.
+ */
+static void gms_output_register_help_request(void) {
+	gms_help_requested = TRUE;
+}
+
+static void gms_output_silence_help_hints(void) {
+	gms_help_hints_silenced = TRUE;
+}
+
+static void gms_output_provide_help_hint(void) {
+	if (gms_help_requested && !gms_help_hints_silenced) {
+		g_vm->glk_set_style(style_Emphasized);
+		g_vm->glk_put_string("[Try 'glk help' for help on special interpreter"
+		                     " commands]\n");
+
+		gms_help_requested = FALSE;
+		g_vm->glk_set_style(style_Normal);
+	}
+}
+
+
+/*
+ * gms_game_prompted()
+ *
+ * Return TRUE if the last game output appears to have been a ">" prompt.
+ * Once called, the flag is reset to FALSE, and requires more game output
+ * to set it again.
+ */
+static int gms_game_prompted(void) {
+	int result;
+
+	result = gms_output_prompt;
+	gms_output_prompt = FALSE;
+
+	return result;
+}
+
+
+/*
+ * gms_detect_game_prompt()
+ *
+ * See if the last non-newline-terminated line in the output buffer seems
+ * to be a prompt, and set the game prompted flag if it does, otherwise
+ * clear it.
+ */
+static void gms_detect_game_prompt(void) {
+	int index;
+
+	gms_output_prompt = FALSE;
+
+	/*
+	 * Search for a prompt across any last unterminated buffered line; a prompt
+	 * is any non-space character on that line.
+	 */
+	for (index = gms_output_length - 1;
+	        index >= 0 && gms_output_buffer[index] != '\n'; index--) {
+		if (gms_output_buffer[index] != ' ') {
+			gms_output_prompt = TRUE;
+			break;
+		}
+	}
+}
+
+
+/*
+ * gms_output_delete()
+ *
+ * Delete all buffered output text.  Free all malloc'ed buffer memory, and
+ * return the buffer variables to their initial values.
+ */
+static void gms_output_delete(void) {
+	free(gms_output_buffer);
+	gms_output_buffer = NULL;
+	gms_output_allocation = gms_output_length = 0;
+}
+
+
+/*
+ * gms_output_flush()
+ *
+ * Flush any buffered output text to the Glk main window, and clear the
+ * buffer.
+ */
+static void gms_output_flush(void) {
+	assert(g_vm->glk_stream_get_current());
+
+	if (gms_output_length > 0) {
+		/*
+		 * See if the game issued a standard prompt, then print the buffer to
+		 * the main window.  If providing a help hint, position that before
+		 * the game's prompt (if any).
+		 */
+		gms_detect_game_prompt();
+		g_vm->glk_set_style(style_Normal);
+
+		if (gms_output_prompt) {
+			int index;
+
+			for (index = gms_output_length - 1;
+			        index >= 0 && gms_output_buffer[index] != '\n';)
+				index--;
+
+			g_vm->glk_put_buffer(gms_output_buffer, index + 1);
+			gms_output_provide_help_hint();
+			g_vm->glk_put_buffer(gms_output_buffer + index + 1,
+			                     gms_output_length - index - 1);
+		} else {
+			g_vm->glk_put_buffer(gms_output_buffer, gms_output_length);
+			gms_output_provide_help_hint();
+		}
+
+		gms_output_delete();
+	}
+}
+
+
+/*
+ * ms_putchar()
+ *
+ * Buffer a character for eventual printing to the main window.
+ */
+void ms_putchar(type8 c) {
+	int bytes;
+	assert(gms_output_length <= gms_output_allocation);
+
+	/*
+	 * See if the character is a backspace.  Magnetic Scrolls games can send
+	 * backspace characters to the display.  We'll need to handle such
+	 * characters specially, by taking the last character out of the buffer.
+	 */
+	if (c == '\b') {
+		if (gms_output_length > 0)
+			gms_output_length--;
+
+		return;
+	}
+
+	/* Grow the output buffer if necessary, then add the character. */
+	for (bytes = gms_output_allocation; bytes < gms_output_length + 1;)
+		bytes = bytes == 0 ? 1 : bytes << 1;
+
+	if (bytes > gms_output_allocation) {
+		gms_output_buffer = (char *)gms_realloc(gms_output_buffer, bytes);
+		gms_output_allocation = bytes;
+	}
+
+	gms_output_buffer[gms_output_length++] = c;
+}
+
+
+/*
+ * gms_styled_string()
+ * gms_styled_char()
+ * gms_standout_string()
+ * gms_standout_char()
+ * gms_normal_string()
+ * gms_normal_char()
+ * gms_header_string()
+ * gms_banner_string()
+ *
+ * Convenience functions to print strings in assorted styles.  A standout
+ * string is one that hints that it's from the interpreter, not the game.
+ */
+static void gms_styled_string(glui32 style, const char *message) {
+	assert(message);
+
+	g_vm->glk_set_style(style);
+	g_vm->glk_put_string(message);
+	g_vm->glk_set_style(style_Normal);
+}
+
+static void gms_styled_char(glui32 style, char c) {
+	char buffer[2];
+
+	buffer[0] = c;
+	buffer[1] = '\0';
+	gms_styled_string(style, buffer);
+}
+
+static void gms_standout_string(const char *message) {
+	gms_styled_string(style_Emphasized, message);
+}
+
+#if 0
+static void gms_standout_char(char c) {
+	gms_styled_char(style_Emphasized, c);
+}
+#endif
+
+static void gms_normal_string(const char *message) {
+	gms_styled_string(style_Normal, message);
+}
+
+static void gms_normal_char(char c) {
+	gms_styled_char(style_Normal, c);
+}
+
+static void gms_header_string(const char *message) {
+	gms_styled_string(style_Header, message);
+}
+
+static void gms_banner_string(const char *message) {
+	gms_styled_string(style_Subheader, message);
+}
+
+/*
+ * ms_flush()
+ *
+ * Handle a core interpreter call to flush the output buffer.  Because Glk
+ * only flushes its buffers and displays text on g_vm->glk_select(), we can ignore
+ * these calls as long as we call gms_output_flush() when reading line input.
+ *
+ * Taking ms_flush() at face value can cause game text to appear before status
+ * line text where we are working with a non-windowing Glk, so it's best
+ * ignored where we can.
+ */
+void ms_flush(void) {
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port hint functions                                            */
+/*---------------------------------------------------------------------*/
+
+/* Hint type definitions. */
+enum {
+	GMS_HINT_TYPE_FOLDER = 1,
+	GMS_HINT_TYPE_TEXT = 2
+};
+
+/* Success and fail return codes from hint functions. */
+static const type8 GMS_HINT_SUCCESS = 1,
+                   GMS_HINT_ERROR = 0;
+
+/* Default window sizes for non-windowing Glk libraries. */
+static const glui32 GMS_HINT_DEFAULT_WIDTH = 72,
+                    GMS_HINT_DEFAULT_HEIGHT = 25;
+
+/*
+ * Special hint nodes indicating the root hint node, and a value to signal
+ * quit from hints subsystem.
+ */
+static const type16 GMS_HINT_ROOT_NODE = 0,
+                    GMS_HINTS_DONE = UINT16_MAX;
+
+/* Generic hint topic for the root hints node. */
+static const char *const GMS_GENERIC_TOPIC = "Hints Menu";
+
+/*
+ * Note of the interpreter's hints array.  Note that keeping its address
+ * like this assumes that it's either static or heap in the interpreter.
+ */
+static struct ms_hint *gms_hints = NULL;
+
+/* Details of the current hint node on display from the hints array. */
+static type16 gms_current_hint_node = 0;
+
+/*
+ * Array of cursors for each hint.  The cursor indicates the current hint
+ * position in a folder, and the last hint shown in text hints.  Space
+ * is allocated as needed for a given set of hints, and needs to be freed
+ * on interpreter exit.
+ */
+static int *gms_hint_cursor = NULL;
+
+
+/*
+ * gms_get_hint_max_node()
+ *
+ * Return the maximum hint node referred to by the tree under the given node.
+ * The result is the largest index found, or node, if greater.  Because the
+ * interpreter doesn't supply it, we need to uncover it the hard way.  The
+ * function is recursive, and since it is a tree search, assumes that hints
+ * is a tree, not a graph.
+ */
+static type16 gms_get_hint_max_node(const struct ms_hint hints[], type16 node) {
+	const struct ms_hint *hint;
+	int index;
+	type16 max_node;
+	assert(hints);
+
+	hint = hints + node;
+	max_node = node;
+
+	switch (hint->nodetype) {
+	case GMS_HINT_TYPE_TEXT:
+		break;
+
+	case GMS_HINT_TYPE_FOLDER:
+		/*
+		 * Recursively find the maximum node reference for each link, and keep
+		 * the largest value found.
+		 */
+		for (index = 0; index < hint->elcount; index++) {
+			type16 link_max;
+
+			link_max = gms_get_hint_max_node(hints, hint->links[index]);
+			if (link_max > max_node)
+				max_node = link_max;
+		}
+		break;
+
+	default:
+		gms_fatal("GLK: Invalid hints node type encountered");
+		g_vm->glk_exit();
+	}
+
+	/*
+	 * Return the largest node reference found, capped to avoid overlapping the
+	 * special end-hints value.
+	 */
+	return max_node < GMS_HINTS_DONE ? max_node : GMS_HINTS_DONE - 1;
+}
+
+
+/*
+ * gms_get_hint_content()
+ *
+ * Return the content string for a given hint number within a given node.
+ * This counts over 'number' ASCII NULs in the node's content, returning
+ * the address of the string located this way.
+ */
+static const char *gms_get_hint_content(const struct ms_hint hints[], type16 node, int number) {
+	const struct ms_hint *hint;
+	int offset, index;
+	assert(hints);
+
+	hint = hints + node;
+
+	/* Run through content until 'number' strings found. */
+	offset = 0;
+	for (index = 0; index < number; index++)
+		offset += strlen(hint->content + offset) + 1;
+
+	/* Return the start of the number'th string encountered. */
+	return hint->content + offset;
+}
+
+
+/*
+ * gms_get_hint_topic()
+ *
+ * Return the topic string for a given hint node.  This is found by searching
+ * the parent node for a link to the node handed in.  For the root node, the
+ * string is defaulted, since the root node has no parent.
+ */
+static const char *gms_get_hint_topic(const struct ms_hint hints[], type16 node) {
+	assert(hints);
+
+	if (node == GMS_HINT_ROOT_NODE) {
+		/* If the node is the root node, return a generic string. */
+		return GMS_GENERIC_TOPIC;
+	} else {
+		type16 parent;
+		int index;
+		const char *topic;
+
+		/*
+		 * Search the parent for a link to node, and use that as the hint topic;
+		 * NULL if none found.
+		 */
+		parent = hints[node].parent;
+
+		topic = NULL;
+		for (index = 0; index < hints[parent].elcount; index++) {
+			if (hints[parent].links[index] == node) {
+				topic = gms_get_hint_content(hints, parent, index);
+				break;
+			}
+		}
+
+		return topic ? topic : GMS_GENERIC_TOPIC;
+	}
+}
+
+
+/*
+ * gms_hint_open()
+ *
+ * If not already open, open the hints windows.  Returns TRUE if the windows
+ * opened, or were already open.
+ *
+ * The function creates two hints windows -- a text grid on top, for menus,
+ * and a text buffer below for hints.
+ */
+static int gms_hint_open(void) {
+	if (!gms_hint_menu_window) {
+		assert(!gms_hint_text_window);
+
+		/*
+		 * Open the hint menu window.  The initial size is two lines, but we'll
+		 * change this later to suit the hint.
+		 */
+		gms_hint_menu_window = g_vm->glk_window_open(gms_main_window,
+		                       winmethod_Above | winmethod_Fixed,
+		                       2, wintype_TextGrid, 0);
+		if (!gms_hint_menu_window)
+			return FALSE;
+
+		/*
+		 * Now open the hints text window.  This is set to be 100% of the size
+		 * of the main window, so should cover what remains of it completely.
+		 */
+		gms_hint_text_window = g_vm->glk_window_open(gms_main_window,
+		                       winmethod_Above
+		                       | winmethod_Proportional,
+		                       100, wintype_TextBuffer, 0);
+		if (!gms_hint_text_window) {
+			g_vm->glk_window_close(gms_hint_menu_window, NULL);
+			gms_hint_menu_window = NULL;
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+
+/*
+ * gms_hint_close()
+ *
+ * If open, close the hints windows.
+ */
+static void gms_hint_close(void) {
+	if (gms_hint_menu_window) {
+		assert(gms_hint_text_window);
+
+		g_vm->glk_window_close(gms_hint_menu_window, NULL);
+		gms_hint_menu_window = NULL;
+		g_vm->glk_window_close(gms_hint_text_window, NULL);
+		gms_hint_text_window = NULL;
+	}
+}
+
+
+/*
+ * gms_hint_windows_available()
+ *
+ * Return TRUE if hints windows are available.  If they're not, the hints
+ * system will need to use alternative output methods.
+ */
+static int gms_hint_windows_available(void) {
+	return (gms_hint_menu_window && gms_hint_text_window);
+}
+
+
+/*
+ * gms_hint_menu_print()
+ * gms_hint_menu_header()
+ * gms_hint_menu_justify()
+ * gms_hint_text_print()
+ * gms_hint_menutext_done()
+ * gms_hint_menutext_start()
+ *
+ * Output functions for writing hints.  These functions will write to hints
+ * windows where available, and to the main window where not.  When writing
+ * to hints windows, they also take care not to line wrap in the menu window.
+ * Limited formatting is available.
+ */
+static void gms_hint_menu_print(int line, int column, const char *string,
+                                glui32 width, glui32 height) {
+	assert(string);
+
+	/* Ignore the call if the text position is outside the window. */
+	if (!(line > (int)height || column > (int)width)) {
+		if (gms_hint_windows_available()) {
+			int posn, index;
+
+			g_vm->glk_window_move_cursor(gms_hint_menu_window, column, line);
+			g_vm->glk_set_window(gms_hint_menu_window);
+
+			/* Write until the end of the string, or the end of the window. */
+			for (posn = column, index = 0;
+			        posn < (int)width && index < (int)strlen(string); posn++, index++) {
+				g_vm->glk_put_char(string[index]);
+			}
+
+			g_vm->glk_set_window(gms_main_window);
+		} else {
+			static int current_line = 0;    /* Retained line number */
+			static int current_column = 0;  /* Retained col number */
+
+			int index;
+
+			/*
+			 * Check the line number against the last one output.  If it is less,
+			 * assume the start of a new block.  In this case, perform a hokey
+			 * type of screen clear.
+			 */
+			if (line < current_line) {
+				for (index = 0; index < (int)height; index++)
+					gms_normal_char('\n');
+
+				current_line = 0;
+				current_column = 0;
+			}
+
+			/* Print blank lines until the target line is reached. */
+			for (; current_line < line; current_line++) {
+				gms_normal_char('\n');
+				current_column = 0;
+			}
+
+			/* Now print spaces until the target column is reached. */
+			for (; current_column < column; current_column++)
+				gms_normal_char(' ');
+
+			/*
+			 * Write characters until the end of the string, or the end of the
+			 * (self-imposed not-really-there) window.
+			 */
+			for (index = 0;
+			        current_column < (int)width && index < (int)strlen(string);
+			        current_column++, index++) {
+				gms_normal_char(string[index]);
+			}
+		}
+	}
+}
+
+static void gms_hint_menu_header(int line, const char *string,
+                                 glui32 width, glui32 height) {
+	int posn, length;
+	assert(string);
+
+	/* Output the text in the approximate line center. */
+	length = strlen(string);
+	posn = length < (int)width ? (width - length) / 2 : 0;
+	gms_hint_menu_print(line, posn, string, width, height);
+}
+
+static void gms_hint_menu_justify(int line,
+                                  const char *left_string, const char *right_string,
+                                  glui32 width, glui32 height) {
+	int posn, length;
+	assert(left_string && right_string);
+
+	/* Write left text normally to window left. */
+	gms_hint_menu_print(line, 0, left_string, width, height);
+
+	/* Output the right text flush with the right of the window. */
+	length = strlen(right_string);
+	posn = length < (int)width ? width - length : 0;
+	gms_hint_menu_print(line, posn, right_string, width, height);
+}
+
+static void gms_hint_text_print(const char *string) {
+	assert(string);
+
+	if (gms_hint_windows_available()) {
+		g_vm->glk_set_window(gms_hint_text_window);
+		g_vm->glk_put_string(string);
+		g_vm->glk_set_window(gms_main_window);
+	} else
+		gms_normal_string(string);
+}
+
+static void gms_hint_menutext_start(void) {
+	/*
+	 * Twiddle for non-windowing libraries; 'clear' the main window by writing
+	 * a null string at line 1, then a null string at line 0.  This works
+	 * because we know the current output line in gms_hint_menu_print() is zero,
+	 * since we set it that way with gms_hint_menutext_done(), or if this is
+	 * the first call, then that's its initial value.
+	 */
+	if (!gms_hint_windows_available()) {
+		gms_hint_menu_print(1, 0, "",
+		                    GMS_HINT_DEFAULT_WIDTH, GMS_HINT_DEFAULT_HEIGHT);
+		gms_hint_menu_print(0, 0, "",
+		                    GMS_HINT_DEFAULT_WIDTH, GMS_HINT_DEFAULT_HEIGHT);
+	}
+}
+
+static void gms_hint_menutext_done(void) {
+	/*
+	 * Twiddle for non-windowing libraries; 'clear' the main window by writing
+	 * an empty string to line zero.  For windowing Glk libraries, this function
+	 * does nothing.
+	 */
+	if (!gms_hint_windows_available()) {
+		gms_hint_menu_print(0, 0, "",
+		                    GMS_HINT_DEFAULT_WIDTH, GMS_HINT_DEFAULT_HEIGHT);
+	}
+}
+
+
+/*
+ * gms_hint_menutext_char_event()
+ *
+ * Request and return a character event from the hints windows.  In practice,
+ * this means either of the hints windows if available, or the main window
+ * if not.
+ */
+static void gms_hint_menutext_char_event(event_t *event) {
+	assert(event);
+
+	if (gms_hint_windows_available()) {
+		g_vm->glk_request_char_event(gms_hint_menu_window);
+		g_vm->glk_request_char_event(gms_hint_text_window);
+
+		gms_event_wait(evtype_CharInput, event);
+		assert(event->window == gms_hint_menu_window
+		       || event->window == gms_hint_text_window);
+
+		g_vm->glk_cancel_char_event(gms_hint_menu_window);
+		g_vm->glk_cancel_char_event(gms_hint_text_window);
+	} else {
+		g_vm->glk_request_char_event(gms_main_window);
+		gms_event_wait(evtype_CharInput, event);
+	}
+}
+
+
+/*
+ * gms_hint_arrange_windows()
+ *
+ * Arrange the hints windows so that the hint menu window has the requested
+ * number of lines.  Returns the actual hint menu window width and height,
+ * or defaults if no hints windows are available.
+ */
+static void gms_hint_arrange_windows(int requested_lines, glui32 *width, glui32 *height) {
+	if (gms_hint_windows_available()) {
+		winid_t parent;
+
+		/* Resize the hint menu window to fit the current hint. */
+		parent = g_vm->glk_window_get_parent(gms_hint_menu_window);
+		g_vm->glk_window_set_arrangement(parent,
+		                                 winmethod_Above | winmethod_Fixed,
+		                                 requested_lines, NULL);
+
+		/* Measure, and return the size of the hint menu window. */
+		g_vm->glk_window_get_size(gms_hint_menu_window, width, height);
+
+		/* Clear both the hint menu and the hint text window. */
+		g_vm->glk_window_clear(gms_hint_menu_window);
+		g_vm->glk_window_clear(gms_hint_text_window);
+	} else {
+		/*
+		 * No hints windows, so default width and height.  The hints output
+		 * functions will cope with this.
+		 */
+		if (width)
+			*width = GMS_HINT_DEFAULT_WIDTH;
+		if (height)
+			*height = GMS_HINT_DEFAULT_HEIGHT;
+	}
+}
+
+
+/*
+ * gms_hint_display_folder()
+ *
+ * Update the hints windows for the given folder hint node.
+ */
+static void gms_hint_display_folder(const struct ms_hint hints[],
+                                    const int cursor[], type16 node) {
+	glui32 width, height;
+	int line, index;
+	assert(hints && cursor);
+
+	/*
+	 * Arrange windows to suit the hint folder.  For a folder menu window we
+	 * use one line for each element, three for the controls, and two spacers,
+	 * making a total of five additional lines.  Width and height receive the
+	 * actual menu window dimensions.
+	 */
+	gms_hint_arrange_windows(hints[node].elcount + 5, &width, &height);
+
+	/* Paint in the menu header. */
+	line = 0;
+	gms_hint_menu_header(line++,
+	                     gms_get_hint_topic(hints, node),
+	                     width, height);
+	gms_hint_menu_justify(line++,
+	                      " N = next subject  ", "  P = previous ",
+	                      width, height);
+	gms_hint_menu_justify(line++,
+	                      " RETURN = read subject  ",
+	                      node == GMS_HINT_ROOT_NODE
+	                      ? "  Q = resume game " : "  Q = previous menu ",
+	                      width, height);
+
+	/*
+	 * Output a blank line, then the menu for the node's folder hint.  The folder
+	 * text for the selected hint is preceded by a '>' pointer.
+	 */
+	line++;
+	for (index = 0; index < hints[node].elcount; index++) {
+		gms_hint_menu_print(line, 3,
+		                    index == cursor[node] ? ">" : " ",
+		                    width, height);
+		gms_hint_menu_print(line++, 5,
+		                    gms_get_hint_content(hints, node, index),
+		                    width, height);
+	}
+
+	/*
+	 * Terminate with a blank line; using a single space here improves cursor
+	 * positioning for optimized output libraries (for example, without it,
+	 * curses output will leave the cursor at the end of the previous line).
+	 */
+	gms_hint_menu_print(line, 0, " ", width, height);
+}
+
+
+/*
+ * gms_hint_display_text()
+ *
+ * Update the hints windows for the given text hint node.
+ */
+static void gms_hint_display_text(const struct ms_hint hints[],
+                                  const int cursor[], type16 node) {
+	glui32 width, height;
+	int line, index;
+	assert(hints && cursor);
+
+	/*
+	 * Arrange windows to suit the hint text.  For a hint menu, we use a simple
+	 * two-line set of controls; everything else is in the hints text window.
+	 * Width and height receive the actual menu window dimensions.
+	 */
+	gms_hint_arrange_windows(2, &width, &height);
+
+	/* Paint in a short menu header. */
+	line = 0;
+	gms_hint_menu_header(line++,
+	                     gms_get_hint_topic(hints, node),
+	                     width, height);
+	gms_hint_menu_justify(line++,
+	                      " RETURN = read hint  ", "  Q = previous menu ",
+	                      width, height);
+
+	/*
+	 * Output hints to the hints text window.  Hints not yet exposed are
+	 * indicated by the cursor for the hint, and are displayed as a dash.
+	 */
+	gms_hint_text_print("\n");
+	for (index = 0; index < hints[node].elcount; index++) {
+		char buffer[16];
+
+		sprintf(buffer, "%3d.  ", index + 1);
+		gms_hint_text_print(buffer);
+
+		gms_hint_text_print(index < cursor[node]
+		                    ? gms_get_hint_content(hints, node, index) : "-");
+		gms_hint_text_print("\n");
+	}
+}
+
+
+/*
+ * gms_hint_display()
+ *
+ * Display the given hint using the appropriate display function.
+ */
+static void gms_hint_display(const struct ms_hint hints[],
+                             const int cursor[], type16 node) {
+	assert(hints && cursor);
+
+	switch (hints[node].nodetype) {
+	case GMS_HINT_TYPE_TEXT:
+		gms_hint_display_text(hints, cursor, node);
+		break;
+
+	case GMS_HINT_TYPE_FOLDER:
+		gms_hint_display_folder(hints, cursor, node);
+		break;
+
+	default:
+		gms_fatal("GLK: Invalid hints node type encountered");
+		g_vm->glk_exit();
+	}
+}
+
+
+/*
+ * gms_hint_handle_folder()
+ *
+ * Handle a Glk keycode for the given folder hint.  Return the next node to
+ * handle, or the special end-hints on Quit at the root node.
+ */
+static type16 gms_hint_handle_folder(const struct ms_hint hints[],
+                                     int cursor[], type16 node, glui32 keycode) {
+	unsigned char response;
+	type16 next_node;
+	assert(hints && cursor);
+
+	/* Convert key code into a single response character. */
+	switch (keycode) {
+	case keycode_Down:
+		response = 'N';
+		break;
+	case keycode_Up:
+		response = 'P';
+		break;
+	case keycode_Right:
+	case keycode_Return:
+		response = '\n';
+		break;
+	case keycode_Left:
+	case keycode_Escape:
+		response = 'Q';
+		break;
+	default:
+		response = keycode <= BYTE_MAX ? g_vm->glk_char_to_upper(keycode) : 0;
+		break;
+	}
+
+	/*
+	 * Now handle the response character.  We'll default the next node to be
+	 * this node, but a response case can change it.
+	 */
+	next_node = node;
+	switch (response) {
+	case 'N':
+		/* Advance the hint cursor, wrapping at the folder end. */
+		if (cursor[node] < hints[node].elcount - 1)
+			cursor[node]++;
+		else
+			cursor[node] = 0;
+		break;
+
+	case 'P':
+		/* Regress the hint cursor, wrapping at the folder start. */
+		if (cursor[node] > 0)
+			cursor[node]--;
+		else
+			cursor[node] = hints[node].elcount - 1;
+		break;
+
+	case '\n':
+		/* The next node is the hint node at the cursor position. */
+		next_node = hints[node].links[cursor[node]];
+		break;
+
+	case 'Q':
+		/* If root, we're done; if not, next node is node's parent. */
+		next_node = node == GMS_HINT_ROOT_NODE
+		            ? GMS_HINTS_DONE : hints[node].parent;
+		break;
+
+	default:
+		break;
+	}
+
+	return next_node;
+}
+
+
+/*
+ * gms_hint_handle_text()
+ *
+ * Handle a Glk keycode for the given text hint.  Return the next node to
+ * handle.
+ */
+static type16 gms_hint_handle_text(const struct ms_hint hints[],
+                                   int cursor[], type16 node, glui32 keycode) {
+	unsigned char response;
+	type16 next_node;
+	assert(hints && cursor);
+
+	/* Convert key code into a single response character. */
+	switch (keycode) {
+	case keycode_Right:
+	case keycode_Return:
+		response = '\n';
+		break;
+	case keycode_Left:
+	case keycode_Escape:
+		response = 'Q';
+		break;
+	default:
+		response = keycode <= BYTE_MAX ? g_vm->glk_char_to_upper(keycode) : 0;
+		break;
+	}
+
+	/*
+	 * Now handle the response character.  We'll default the next node to be
+	 * this node, but a response case can change it.
+	 */
+	next_node = node;
+	switch (response) {
+	case '\n':
+		/* If not at end of the hint, advance the hint cursor. */
+		if (cursor[node] < hints[node].elcount)
+			cursor[node]++;
+		break;
+
+	case 'Q':
+		/* Done with this hint node, so next node is its parent. */
+		next_node = hints[node].parent;
+		break;
+
+	default:
+		break;
+	}
+
+	return next_node;
+}
+
+
+/*
+ * gms_hint_handle()
+ *
+ * Handle a Glk keycode for the given hint using the appropriate handler
+ * function.  Return the next node to handle.
+ */
+static type16 gms_hint_handle(const struct ms_hint hints[],
+                              int cursor[], type16 node, glui32 keycode) {
+	type16 next_node;
+	assert(hints && cursor);
+
+	next_node = GMS_HINT_ROOT_NODE;
+	switch (hints[node].nodetype) {
+	case GMS_HINT_TYPE_TEXT:
+		next_node = gms_hint_handle_text(hints, cursor, node, keycode);
+		break;
+
+	case GMS_HINT_TYPE_FOLDER:
+		next_node = gms_hint_handle_folder(hints, cursor, node, keycode);
+		break;
+
+	default:
+		gms_fatal("GLK: Invalid hints node type encountered");
+		g_vm->glk_exit();
+	}
+
+	return next_node;
+}
+
+
+/*
+ * ms_showhints()
+ *
+ * Start game hints.  These are modal, though there's no overriding Glk
+ * reason why.  It's just that this matches the way they're implemented by
+ * most Inform games.  This may not be the best way of doing help, but at
+ * least it's likely to be familiar, and anything more ambitious may be
+ * beyond the current Glk capabilities.
+ *
+ * This function uses CRCs to detect any change of hints data.  Normally,
+ * we'd expect none, at least within a given game run, but we can probably
+ * handle it okay if it happens.
+ */
+type8 ms_showhints(struct ms_hint *hints) {
+	static int is_initialized = FALSE;
+	static glui32 current_crc = 0;
+
+	type16 hint_count;
+	glui32 crc;
+	assert(hints);
+
+	/*
+	 * Find the number of hints in the array.  To do this, we'll visit every
+	 * node in a tree search, starting at the root, to locate the maximum node
+	 * number found, then add one to that.  It's a pity that the interpreter
+	 * doesn't hand us this information directly.
+	 */
+	hint_count = gms_get_hint_max_node(hints, GMS_HINT_ROOT_NODE) + 1;
+
+	/*
+	 * Calculate a CRC for the hints array data.  If the CRC has changed, or
+	 * this is the first call, assign a new cursor array.
+	 */
+	crc = gms_get_buffer_crc(hints, hint_count * sizeof(*hints));
+	if (crc != current_crc || !is_initialized) {
+		int bytes;
+
+		/* Allocate new cursors, and set all to zero initial state. */
+		free(gms_hint_cursor);
+		bytes = hint_count * sizeof(*gms_hint_cursor);
+		gms_hint_cursor = (int *)gms_malloc(bytes);
+		memset(gms_hint_cursor, 0, bytes);
+
+		/*
+		 * Retain the hints CRC, for later comparisons, and set is_initialized
+		 * flag.
+		 */
+		current_crc = crc;
+		is_initialized = TRUE;
+	}
+
+	/*
+	 * Save the hints array passed in.  This is done here since even if the data
+	 * remains the same (found by the CRC check above), the pointer to it might
+	 * have changed.
+	 */
+	gms_hints = hints;
+
+	/*
+	 * Try to create the hints windows.  If they can't be created, perhaps
+	 * because the Glk library doesn't support it, the output functions will
+	 * work around this.
+	 */
+	gms_hint_open();
+	gms_hint_menutext_start();
+
+	/*
+	 * Begin hints display at the root node, and navigate until the user exits
+	 * hints.
+	 */
+	gms_current_hint_node = GMS_HINT_ROOT_NODE;
+	while (gms_current_hint_node != GMS_HINTS_DONE) {
+		event_t event;
+
+		assert(gms_current_hint_node < hint_count);
+		gms_hint_display(gms_hints, gms_hint_cursor, gms_current_hint_node);
+
+		/* Get and handle a character key event for hint navigation. */
+		gms_hint_menutext_char_event(&event);
+		assert(event.type == evtype_CharInput);
+		gms_current_hint_node = gms_hint_handle(gms_hints,
+		                                        gms_hint_cursor,
+		                                        gms_current_hint_node,
+		                                        event.val1);
+	}
+
+	/* Done with hint windows. */
+	gms_hint_menutext_done();
+	gms_hint_close();
+
+	return GMS_HINT_SUCCESS;
+}
+
+
+/*
+ * gms_hint_redraw()
+ *
+ * Update the hints windows for the current hint.  This function should be
+ * called from the event handler on resize events, to repaint the hints
+ * display.  It does nothing if no hints windows have been opened, since
+ * in this case, there's no resize action required -- either we're not in
+ * the hints subsystem, or hints are being displayed in the main game
+ * window, for whatever reason.
+ */
+static void gms_hint_redraw(void) {
+	if (gms_hint_windows_available()) {
+		assert(gms_hints && gms_hint_cursor);
+		gms_hint_display(gms_hints, gms_hint_cursor, gms_current_hint_node);
+	}
+}
+
+
+/*
+ * gms_hints_cleanup()
+ *
+ * Free memory resources allocated by hints functions.  Called on game
+ * end.
+ */
+static void gms_hints_cleanup(void) {
+	free(gms_hint_cursor);
+	gms_hint_cursor = NULL;
+
+	gms_hints = NULL;
+	gms_current_hint_node = 0;
+}
+
+
+void ms_playmusic(type8 *midi_data, type32 length, type16 tempo) {
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk command escape functions                                       */
+/*---------------------------------------------------------------------*/
+
+/*
+ * gms_command_undo()
+ *
+ * Stub function for the undo command.  The real work is to return the
+ * undo code to the input functions.
+ */
+static void gms_command_undo(const char *argument) {
+	assert(argument);
+}
+
+
+/*
+ * gms_command_script()
+ *
+ * Turn game output scripting (logging) on and off.
+ */
+static void gms_command_script(const char *argument) {
+	assert(argument);
+
+	if (gms_strcasecmp(argument, "on") == 0) {
+		frefid_t fileref;
+
+		if (gms_transcript_stream) {
+			gms_normal_string("Glk transcript is already on.\n");
+			return;
+		}
+
+		fileref = g_vm->glk_fileref_create_by_prompt(fileusage_Transcript
+		          | fileusage_TextMode,
+		          filemode_WriteAppend, 0);
+		if (!fileref) {
+			gms_standout_string("Glk transcript failed.\n");
+			return;
+		}
+
+		gms_transcript_stream = g_vm->glk_stream_open_file(fileref,
+		                        filemode_WriteAppend, 0);
+		g_vm->glk_fileref_destroy(fileref);
+		if (!gms_transcript_stream) {
+			gms_standout_string("Glk transcript failed.\n");
+			return;
+		}
+
+		g_vm->glk_window_set_echo_stream(gms_main_window, gms_transcript_stream);
+
+		gms_normal_string("Glk transcript is now on.\n");
+	}
+
+	else if (gms_strcasecmp(argument, "off") == 0) {
+		if (!gms_transcript_stream) {
+			gms_normal_string("Glk transcript is already off.\n");
+			return;
+		}
+
+		g_vm->glk_stream_close(gms_transcript_stream, NULL);
+		gms_transcript_stream = NULL;
+
+		g_vm->glk_window_set_echo_stream(gms_main_window, NULL);
+
+		gms_normal_string("Glk transcript is now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gms_normal_string("Glk transcript is ");
+		gms_normal_string(gms_transcript_stream ? "on" : "off");
+		gms_normal_string(".\n");
+	}
+
+	else {
+		gms_normal_string("Glk transcript can be ");
+		gms_standout_string("on");
+		gms_normal_string(", or ");
+		gms_standout_string("off");
+		gms_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gms_command_inputlog()
+ *
+ * Turn game input logging on and off.
+ */
+static void gms_command_inputlog(const char *argument) {
+	assert(argument);
+
+	if (gms_strcasecmp(argument, "on") == 0) {
+		frefid_t fileref;
+
+		if (gms_inputlog_stream) {
+			gms_normal_string("Glk input logging is already on.\n");
+			return;
+		}
+
+		fileref = g_vm->glk_fileref_create_by_prompt(fileusage_InputRecord
+		          | fileusage_BinaryMode,
+		          filemode_WriteAppend, 0);
+		if (!fileref) {
+			gms_standout_string("Glk input logging failed.\n");
+			return;
+		}
+
+		gms_inputlog_stream = g_vm->glk_stream_open_file(fileref,
+		                      filemode_WriteAppend, 0);
+		g_vm->glk_fileref_destroy(fileref);
+		if (!gms_inputlog_stream) {
+			gms_standout_string("Glk input logging failed.\n");
+			return;
+		}
+
+		gms_normal_string("Glk input logging is now on.\n");
+	}
+
+	else if (gms_strcasecmp(argument, "off") == 0) {
+		if (!gms_inputlog_stream) {
+			gms_normal_string("Glk input logging is already off.\n");
+			return;
+		}
+
+		g_vm->glk_stream_close(gms_inputlog_stream, NULL);
+		gms_inputlog_stream = NULL;
+
+		gms_normal_string("Glk input log is now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gms_normal_string("Glk input logging is ");
+		gms_normal_string(gms_inputlog_stream ? "on" : "off");
+		gms_normal_string(".\n");
+	}
+
+	else {
+		gms_normal_string("Glk input logging can be ");
+		gms_standout_string("on");
+		gms_normal_string(", or ");
+		gms_standout_string("off");
+		gms_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gms_command_readlog()
+ *
+ * Set the game input log, to read input from a file.
+ */
+static void gms_command_readlog(const char *argument) {
+	assert(argument);
+
+	if (gms_strcasecmp(argument, "on") == 0) {
+		frefid_t fileref;
+
+		if (gms_readlog_stream) {
+			gms_normal_string("Glk read log is already on.\n");
+			return;
+		}
+
+		fileref = g_vm->glk_fileref_create_by_prompt(fileusage_InputRecord
+		          | fileusage_BinaryMode,
+		          filemode_Read, 0);
+		if (!fileref) {
+			gms_standout_string("Glk read log failed.\n");
+			return;
+		}
+
+		if (!g_vm->glk_fileref_does_file_exist(fileref)) {
+			g_vm->glk_fileref_destroy(fileref);
+			gms_standout_string("Glk read log failed.\n");
+			return;
+		}
+
+		gms_readlog_stream = g_vm->glk_stream_open_file(fileref, filemode_Read, 0);
+		g_vm->glk_fileref_destroy(fileref);
+		if (!gms_readlog_stream) {
+			gms_standout_string("Glk read log failed.\n");
+			return;
+		}
+
+		gms_normal_string("Glk read log is now on.\n");
+	}
+
+	else if (gms_strcasecmp(argument, "off") == 0) {
+		if (!gms_readlog_stream) {
+			gms_normal_string("Glk read log is already off.\n");
+			return;
+		}
+
+		g_vm->glk_stream_close(gms_readlog_stream, NULL);
+		gms_readlog_stream = NULL;
+
+		gms_normal_string("Glk read log is now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gms_normal_string("Glk read log is ");
+		gms_normal_string(gms_readlog_stream ? "on" : "off");
+		gms_normal_string(".\n");
+	}
+
+	else {
+		gms_normal_string("Glk read log can be ");
+		gms_standout_string("on");
+		gms_normal_string(", or ");
+		gms_standout_string("off");
+		gms_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gms_command_abbreviations()
+ *
+ * Turn abbreviation expansions on and off.
+ */
+static void gms_command_abbreviations(const char *argument) {
+	assert(argument);
+
+	if (gms_strcasecmp(argument, "on") == 0) {
+		if (gms_abbreviations_enabled) {
+			gms_normal_string("Glk abbreviation expansions are already on.\n");
+			return;
+		}
+
+		gms_abbreviations_enabled = TRUE;
+		gms_normal_string("Glk abbreviation expansions are now on.\n");
+	}
+
+	else if (gms_strcasecmp(argument, "off") == 0) {
+		if (!gms_abbreviations_enabled) {
+			gms_normal_string("Glk abbreviation expansions are already off.\n");
+			return;
+		}
+
+		gms_abbreviations_enabled = FALSE;
+		gms_normal_string("Glk abbreviation expansions are now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gms_normal_string("Glk abbreviation expansions are ");
+		gms_normal_string(gms_abbreviations_enabled ? "on" : "off");
+		gms_normal_string(".\n");
+	}
+
+	else {
+		gms_normal_string("Glk abbreviation expansions can be ");
+		gms_standout_string("on");
+		gms_normal_string(", or ");
+		gms_standout_string("off");
+		gms_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gms_command_graphics()
+ *
+ * Enable or disable graphics more permanently than is done by the main
+ * interpreter.  Also, print out a few brief details about the graphics
+ * state of the program.
+ */
+static void gms_command_graphics(const char *argument) {
+	assert(argument);
+
+	if (!gms_graphics_possible) {
+		gms_normal_string("Glk graphics are not available.\n");
+		return;
+	}
+
+	if (gms_strcasecmp(argument, "on") == 0) {
+		if (gms_graphics_enabled) {
+			gms_normal_string("Glk graphics are already on.\n");
+			return;
+		}
+
+		gms_graphics_enabled = TRUE;
+
+		/* If a picture is loaded, call the restart function to repaint it. */
+		if (gms_graphics_picture_is_available()) {
+			if (!gms_graphics_open()) {
+				gms_normal_string("Glk graphics error.\n");
+				return;
+			}
+			gms_graphics_restart();
+		}
+
+		gms_normal_string("Glk graphics are now on.\n");
+	}
+
+	else if (gms_strcasecmp(argument, "off") == 0) {
+		if (!gms_graphics_enabled) {
+			gms_normal_string("Glk graphics are already off.\n");
+			return;
+		}
+
+		/*
+		 * Set graphics to disabled, and stop any graphics processing.  Close
+		 * the graphics window.
+		 */
+		gms_graphics_enabled = FALSE;
+		gms_graphics_stop();
+		gms_graphics_close();
+
+		gms_normal_string("Glk graphics are now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gms_normal_string("Glk graphics are available,");
+		gms_normal_string(gms_graphics_enabled
+		                  ? " and enabled.\n" : " but disabled.\n");
+
+		if (gms_graphics_picture_is_available()) {
+			int width, height, is_animated;
+
+			if (gms_graphics_get_picture_details(&width, &height, &is_animated)) {
+				char buffer[16];
+
+				gms_normal_string("There is ");
+				gms_normal_string(is_animated ? "an animated" : "a");
+				gms_normal_string(" picture loaded, ");
+
+				sprintf(buffer, "%d", width);
+				gms_normal_string(buffer);
+				gms_normal_string(" by ");
+
+				sprintf(buffer, "%d", height);
+				gms_normal_string(buffer);
+
+				gms_normal_string(" pixels.\n");
+			}
+		}
+
+		if (!gms_graphics_interpreter_enabled())
+			gms_normal_string("Interpreter graphics are disabled.\n");
+
+		if (gms_graphics_enabled && gms_graphics_are_displayed()) {
+			int color_count, is_active;
+			const char *gamma;
+
+			if (gms_graphics_get_rendering_details(&gamma, &color_count,
+			                                       &is_active)) {
+				char buffer[16];
+
+				gms_normal_string("Graphics are ");
+				gms_normal_string(is_active ? "active, " : "displayed, ");
+
+				sprintf(buffer, "%d", color_count);
+				gms_normal_string(buffer);
+				gms_normal_string(" colours");
+
+				if (gms_gamma_mode == GAMMA_OFF)
+					gms_normal_string(", without gamma correction");
+				else {
+					gms_normal_string(", with gamma ");
+					gms_normal_string(gamma);
+					gms_normal_string(" correction");
+				}
+				gms_normal_string(".\n");
+			} else
+				gms_normal_string("Graphics are being displayed.\n");
+		}
+
+		if (gms_graphics_enabled && !gms_graphics_are_displayed())
+			gms_normal_string("Graphics are not being displayed.\n");
+	}
+
+	else {
+		gms_normal_string("Glk graphics can be ");
+		gms_standout_string("on");
+		gms_normal_string(", or ");
+		gms_standout_string("off");
+		gms_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gms_command_gamma()
+ *
+ * Enable or disable picture gamma corrections.
+ */
+static void gms_command_gamma(const char *argument) {
+	assert(argument);
+
+	if (!gms_graphics_possible) {
+		gms_normal_string("Glk automatic gamma correction is not available.\n");
+		return;
+	}
+
+	if (gms_strcasecmp(argument, "high") == 0) {
+		if (gms_gamma_mode == GAMMA_HIGH) {
+			gms_normal_string("Glk automatic gamma correction mode is"
+			                  " already 'high'.\n");
+			return;
+		}
+
+		gms_gamma_mode = GAMMA_HIGH;
+		gms_graphics_restart();
+
+		gms_normal_string("Glk automatic gamma correction mode is"
+		                  " now 'high'.\n");
+	}
+
+	else if (gms_strcasecmp(argument, "normal") == 0
+	         || gms_strcasecmp(argument, "on") == 0) {
+		if (gms_gamma_mode == GAMMA_NORMAL) {
+			gms_normal_string("Glk automatic gamma correction mode is"
+			                  " already 'normal'.\n");
+			return;
+		}
+
+		gms_gamma_mode = GAMMA_NORMAL;
+		gms_graphics_restart();
+
+		gms_normal_string("Glk automatic gamma correction mode is"
+		                  " now 'normal'.\n");
+	}
+
+	else if (gms_strcasecmp(argument, "none") == 0
+	         || gms_strcasecmp(argument, "off") == 0) {
+		if (gms_gamma_mode == GAMMA_OFF) {
+			gms_normal_string("Glk automatic gamma correction mode is"
+			                  " already 'off'.\n");
+			return;
+		}
+
+		gms_gamma_mode = GAMMA_OFF;
+		gms_graphics_restart();
+
+		gms_normal_string("Glk automatic gamma correction mode is"
+		                  " now 'off'.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gms_normal_string("Glk automatic gamma correction mode is '");
+		switch (gms_gamma_mode) {
+		case GAMMA_OFF:
+			gms_normal_string("off");
+			break;
+		case GAMMA_NORMAL:
+			gms_normal_string("normal");
+			break;
+		case GAMMA_HIGH:
+			gms_normal_string("high");
+			break;
+		}
+		gms_normal_string("'.\n");
+	}
+
+	else {
+		gms_normal_string("Glk automatic gamma correction mode can be ");
+		gms_standout_string("high");
+		gms_normal_string(", ");
+		gms_standout_string("normal");
+		gms_normal_string(", or ");
+		gms_standout_string("off");
+		gms_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gms_command_animations()
+ *
+ * Enable or disable picture animations.
+ */
+static void gms_command_animations(const char *argument) {
+	assert(argument);
+
+	if (!gms_graphics_possible) {
+		gms_normal_string("Glk graphics animations are not available.\n");
+		return;
+	}
+
+	if (gms_strcasecmp(argument, "on") == 0) {
+		int is_animated;
+
+		if (gms_animation_enabled) {
+			gms_normal_string("Glk graphics animations are already on.\n");
+			return;
+		}
+
+		/*
+		 * Set animation to on, and restart graphics if the current picture
+		 * is animated; if it isn't, we can leave it displayed as is, since
+		 * changing animation mode doesn't affect this picture.
+		 */
+		gms_animation_enabled = TRUE;
+		if (gms_graphics_get_picture_details(NULL, NULL, &is_animated)) {
+			if (is_animated)
+				gms_graphics_restart();
+		}
+
+		gms_normal_string("Glk graphics animations are now on.\n");
+	}
+
+	else if (gms_strcasecmp(argument, "off") == 0) {
+		int is_animated;
+
+		if (!gms_animation_enabled) {
+			gms_normal_string("Glk graphics animations are already off.\n");
+			return;
+		}
+
+		gms_animation_enabled = FALSE;
+		if (gms_graphics_get_picture_details(NULL, NULL, &is_animated)) {
+			if (is_animated)
+				gms_graphics_restart();
+		}
+
+		gms_normal_string("Glk graphics animations are now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gms_normal_string("Glk graphics animations are ");
+		gms_normal_string(gms_animation_enabled ? "on" : "off");
+		gms_normal_string(".\n");
+	}
+
+	else {
+		gms_normal_string("Glk graphics animations can be ");
+		gms_standout_string("on");
+		gms_normal_string(", or ");
+		gms_standout_string("off");
+		gms_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gms_command_prompts()
+ *
+ * Turn the extra "> " prompt output on and off.
+ */
+static void gms_command_prompts(const char *argument) {
+	assert(argument);
+
+	if (gms_strcasecmp(argument, "on") == 0) {
+		if (gms_prompt_enabled) {
+			gms_normal_string("Glk extra prompts are already on.\n");
+			return;
+		}
+
+		gms_prompt_enabled = TRUE;
+		gms_normal_string("Glk extra prompts are now on.\n");
+
+		/* Check for a game prompt to clear the flag. */
+		gms_game_prompted();
+	}
+
+	else if (gms_strcasecmp(argument, "off") == 0) {
+		if (!gms_prompt_enabled) {
+			gms_normal_string("Glk extra prompts are already off.\n");
+			return;
+		}
+
+		gms_prompt_enabled = FALSE;
+		gms_normal_string("Glk extra prompts are now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gms_normal_string("Glk extra prompts are ");
+		gms_normal_string(gms_prompt_enabled ? "on" : "off");
+		gms_normal_string(".\n");
+	}
+
+	else {
+		gms_normal_string("Glk extra prompts can be ");
+		gms_standout_string("on");
+		gms_normal_string(", or ");
+		gms_standout_string("off");
+		gms_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gms_command_print_version_number()
+ * gms_command_version()
+ *
+ * Print out the Glk library version number.
+ */
+static void gms_command_print_version_number(glui32 version) {
+	char buffer[64];
+
+	sprintf(buffer, "%lu.%lu.%lu",
+	        (unsigned long) version >> 16,
+	        (unsigned long)(version >> 8) & 0xff,
+	        (unsigned long) version & 0xff);
+	gms_normal_string(buffer);
+}
+
+static void
+gms_command_version(const char *argument) {
+	glui32 version;
+	assert(argument);
+
+	gms_normal_string("This is version ");
+	gms_command_print_version_number(GMS_PORT_VERSION);
+	gms_normal_string(" of the Glk Magnetic port.\n");
+
+	version = g_vm->glk_gestalt(gestalt_Version, 0);
+	gms_normal_string("The Glk library version is ");
+	gms_command_print_version_number(version);
+	gms_normal_string(".\n");
+}
+
+
+/*
+ * gms_command_commands()
+ *
+ * Turn command escapes off.  Once off, there's no way to turn them back on.
+ * Commands must be on already to enter this function.
+ */
+static void gms_command_commands(const char *argument) {
+	assert(argument);
+
+	if (gms_strcasecmp(argument, "on") == 0) {
+		gms_normal_string("Glk commands are already on.\n");
+	}
+
+	else if (gms_strcasecmp(argument, "off") == 0) {
+		gms_commands_enabled = FALSE;
+		gms_normal_string("Glk commands are now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gms_normal_string("Glk commands are ");
+		gms_normal_string(gms_commands_enabled ? "on" : "off");
+		gms_normal_string(".\n");
+	}
+
+	else {
+		gms_normal_string("Glk commands can be ");
+		gms_standout_string("on");
+		gms_normal_string(", or ");
+		gms_standout_string("off");
+		gms_normal_string(".\n");
+	}
+}
+
+/* Glk subcommands and handler functions. */
+typedef const struct {
+	const char *const command;                      /* Glk subcommand. */
+	void (* const handler)(const char *argument);   /* Subcommand handler. */
+	const int takes_argument;                       /* Argument flag. */
+	const int undo_return;                          /* "Undo" return value. */
+} gms_command_t;
+typedef gms_command_t *gms_commandref_t;
+
+static void gms_command_summary(const char *argument);
+static void gms_command_help(const char *argument);
+
+static gms_command_t GMS_COMMAND_TABLE[] = {
+	{"summary",        gms_command_summary,        FALSE, FALSE},
+	{"undo",           gms_command_undo,           FALSE, TRUE},
+	{"script",         gms_command_script,         TRUE,  FALSE},
+	{"inputlog",       gms_command_inputlog,       TRUE,  FALSE},
+	{"readlog",        gms_command_readlog,        TRUE,  FALSE},
+	{"abbreviations",  gms_command_abbreviations,  TRUE,  FALSE},
+	{"graphics",       gms_command_graphics,       TRUE,  FALSE},
+	{"gamma",          gms_command_gamma,          TRUE,  FALSE},
+	{"animations",     gms_command_animations,     TRUE,  FALSE},
+	{"prompts",        gms_command_prompts,        TRUE,  FALSE},
+	{"version",        gms_command_version,        FALSE, FALSE},
+	{"commands",       gms_command_commands,       TRUE,  FALSE},
+	{"help",           gms_command_help,           TRUE,  FALSE},
+	{NULL, NULL, FALSE, FALSE}
+};
+
+
+/*
+ * gms_command_summary()
+ *
+ * Report all current Glk settings.
+ */
+static void gms_command_summary(const char *argument) {
+	gms_commandref_t entry;
+	assert(argument);
+
+	/*
+	 * Call handlers that have status to report with an empty argument,
+	 * prompting each to print its current setting.
+	 */
+	for (entry = GMS_COMMAND_TABLE; entry->command; entry++) {
+		if (entry->handler == gms_command_summary
+		        || entry->handler == gms_command_undo
+		        || entry->handler == gms_command_help)
+			continue;
+
+		entry->handler("");
+	}
+}
+
+
+/*
+ * gms_command_help()
+ *
+ * Document the available Glk commands.
+ */
+static void gms_command_help(const char *command) {
+	gms_commandref_t entry, matched;
+	assert(command);
+
+	if (strlen(command) == 0) {
+		gms_normal_string("Glk commands are");
+		for (entry = GMS_COMMAND_TABLE; entry->command; entry++) {
+			gms_commandref_t next;
+
+			next = entry + 1;
+			gms_normal_string(next->command ? " " : " and ");
+			gms_standout_string(entry->command);
+			gms_normal_string(next->command ? "," : ".\n\n");
+		}
+
+		gms_normal_string("Glk commands may be abbreviated, as long as"
+		                  " the abbreviation is unambiguous.  Use ");
+		gms_standout_string("glk help");
+		gms_normal_string(" followed by a Glk command name for help on that"
+		                  " command.\n");
+		return;
+	}
+
+	matched = NULL;
+	for (entry = GMS_COMMAND_TABLE; entry->command; entry++) {
+		if (gms_strncasecmp(command, entry->command, strlen(command)) == 0) {
+			if (matched) {
+				gms_normal_string("The Glk command ");
+				gms_standout_string(command);
+				gms_normal_string(" is ambiguous.  Try ");
+				gms_standout_string("glk help");
+				gms_normal_string(" for more information.\n");
+				return;
+			}
+			matched = entry;
+		}
+	}
+	if (!matched) {
+		gms_normal_string("The Glk command ");
+		gms_standout_string(command);
+		gms_normal_string(" is not valid.  Try ");
+		gms_standout_string("glk help");
+		gms_normal_string(" for more information.\n");
+		return;
+	}
+
+	if (matched->handler == gms_command_summary) {
+		gms_normal_string("Prints a summary of all the current Glk Magnetic"
+		                  " settings.\n");
+	}
+
+	else if (matched->handler == gms_command_undo) {
+		gms_normal_string("Undoes a single game turn.\n\nEquivalent to the"
+		                  " standalone game 'undo' command.\n");
+	}
+
+	else if (matched->handler == gms_command_script) {
+		gms_normal_string("Logs the game's output to a file.\n\nUse ");
+		gms_standout_string("glk script on");
+		gms_normal_string(" to begin logging game output, and ");
+		gms_standout_string("glk script off");
+		gms_normal_string(" to end it.  Glk Magnetic will ask you for a file"
+		                  " when you turn scripts on.\n");
+	}
+
+	else if (matched->handler == gms_command_inputlog) {
+		gms_normal_string("Records the commands you type into a game.\n\nUse ");
+		gms_standout_string("glk inputlog on");
+		gms_normal_string(", to begin recording your commands, and ");
+		gms_standout_string("glk inputlog off");
+		gms_normal_string(" to turn off input logs.  You can play back"
+		                  " recorded commands into a game with the ");
+		gms_standout_string("glk readlog");
+		gms_normal_string(" command.\n");
+	}
+
+	else if (matched->handler == gms_command_readlog) {
+		gms_normal_string("Plays back commands recorded with ");
+		gms_standout_string("glk inputlog on");
+		gms_normal_string(".\n\nUse ");
+		gms_standout_string("glk readlog on");
+		gms_normal_string(".  Command play back stops at the end of the"
+		                  " file.  You can also play back commands from a"
+		                  " text file created using any standard editor.\n");
+	}
+
+	else if (matched->handler == gms_command_abbreviations) {
+		gms_normal_string("Controls abbreviation expansion.\n\nGlk Magnetic"
+		                  " automatically expands several standard single"
+		                  " letter abbreviations for you; for example, \"x\""
+		                  " becomes \"examine\".  Use ");
+		gms_standout_string("glk abbreviations on");
+		gms_normal_string(" to turn this feature on, and ");
+		gms_standout_string("glk abbreviations off");
+		gms_normal_string(" to turn it off.  While the feature is on, you"
+		                  " can bypass abbreviation expansion for an"
+		                  " individual game command by prefixing it with a"
+		                  " single quote.\n");
+	}
+
+	else if (matched->handler == gms_command_graphics) {
+		gms_normal_string("Turns interpreter graphics on and off.\n\nUse ");
+		gms_standout_string("glk graphics on");
+		gms_normal_string(" to enable interpreter graphics, and ");
+		gms_standout_string("glk graphics off");
+		gms_normal_string(" to turn graphics off and close the graphics window."
+		                  "  This control works slightly differently to the"
+		                  " 'graphics' command in Magnetic Windows and Magnetic"
+		                  " Scrolls games themselves; the game's 'graphics'"
+		                  " command may disable new images, but leave old ones"
+		                  " displayed.  For graphics to be displayed, they"
+		                  " must be turned on in both the game and the"
+		                  " interpreter.\n");
+	}
+
+	else if (matched->handler == gms_command_gamma) {
+		gms_normal_string("Sets the level of automatic gamma correction applied"
+		                  " to game graphics.\n\nUse ");
+		gms_standout_string("glk gamma normal");
+		gms_normal_string(" to set moderate automatic colour contrast"
+		                  " correction, ");
+		gms_standout_string("glk gamma high");
+		gms_normal_string(" to set high automatic colour contrast correction,"
+		                  " or ");
+		gms_standout_string("glk gamma off");
+		gms_normal_string(" to turn off all automatic gamma correction.\n");
+	}
+
+	else if (matched->handler == gms_command_animations) {
+		gms_normal_string("Turns graphic animations on and off.\n\nUse ");
+		gms_standout_string("glk animation on");
+		gms_normal_string(" to enable animations, or ");
+		gms_standout_string("glk animation off");
+		gms_normal_string(" to turn animations off.  Not all game graphics are"
+		                  " animated, so this control works only on graphics"
+		                  " that are animated.  When animation is off, Glk"
+		                  " Magnetic displays only the static portions of a"
+		                  " game's pictures.\n");
+	}
+
+	else if (matched->handler == gms_command_prompts) {
+		gms_normal_string("Controls extra input prompting.\n\n"
+		                  "Glk Magnetic can issue a replacement '>' input"
+		                  " prompt if it detects that the game hasn't prompted"
+		                  " after, say, an empty input line.  Use ");
+		gms_standout_string("glk prompts on");
+		gms_normal_string(" to turn this feature on, and ");
+		gms_standout_string("glk prompts off");
+		gms_normal_string(" to turn it off.\n");
+	}
+
+	else if (matched->handler == gms_command_version) {
+		gms_normal_string("Prints the version numbers of the Glk library"
+		                  " and the Glk Magnetic port.\n");
+	}
+
+	else if (matched->handler == gms_command_commands) {
+		gms_normal_string("Turn off Glk commands.\n\nUse ");
+		gms_standout_string("glk commands off");
+		gms_normal_string(" to disable all Glk commands, including this one."
+		                  "  Once turned off, there is no way to turn Glk"
+		                  " commands back on while inside the game.\n");
+	}
+
+	else if (matched->handler == gms_command_help)
+		gms_command_help("");
+
+	else
+		gms_normal_string("There is no help available on that Glk command."
+		                  "  Sorry.\n");
+}
+
+
+/*
+ * gms_command_escape()
+ *
+ * This function is handed each input line.  If the line contains a specific
+ * Glk port command, handle it and return TRUE, otherwise return FALSE.
+ *
+ * On unambiguous returns, it will also set the value for undo_command to the
+ * table undo return value.
+ */
+static int gms_command_escape(const char *string, int *undo_command) {
+	int posn;
+	char *string_copy, *command, *argument;
+	assert(string && undo_command);
+
+	/*
+	 * Return FALSE if the string doesn't begin with the Glk command escape
+	 * introducer.
+	 */
+	posn = strspn(string, "\t ");
+	if (gms_strncasecmp(string + posn, "glk", strlen("glk")) != 0)
+		return FALSE;
+
+	/* Take a copy of the string, without any leading space or introducer. */
+	string_copy = (char *)gms_malloc(strlen(string + posn) + 1 - strlen("glk"));
+	strcpy(string_copy, string + posn + strlen("glk"));
+
+	/*
+	 * Find the subcommand; the first word in the string copy.  Find its end,
+	 * and ensure it terminates with a NUL.
+	 */
+	posn = strspn(string_copy, "\t ");
+	command = string_copy + posn;
+	posn += strcspn(string_copy + posn, "\t ");
+	if (string_copy[posn] != '\0')
+		string_copy[posn++] = '\0';
+
+	/*
+	 * Now find any argument data for the command, ensuring it too terminates
+	 * with a NUL.
+	 */
+	posn += strspn(string_copy + posn, "\t ");
+	argument = string_copy + posn;
+	posn += strcspn(string_copy + posn, "\t ");
+	string_copy[posn] = '\0';
+
+	/*
+	 * Try to handle the command and argument as a Glk subcommand.  If it
+	 * doesn't run unambiguously, print command usage.  Treat an empty command
+	 * as "help".
+	 */
+	if (strlen(command) > 0) {
+		gms_commandref_t entry, matched;
+		int matches;
+
+		/*
+		 * Search for the first unambiguous table command string matching
+		 * the command passed in.
+		 */
+		matches = 0;
+		matched = NULL;
+		for (entry = GMS_COMMAND_TABLE; entry->command; entry++) {
+			if (gms_strncasecmp(command, entry->command, strlen(command)) == 0) {
+				matches++;
+				matched = entry;
+			}
+		}
+
+		/* If the match was unambiguous, call the command handler. */
+		if (matches == 1) {
+			if (!matched->undo_return)
+				gms_normal_char('\n');
+			matched->handler(argument);
+
+			if (!matched->takes_argument && strlen(argument) > 0) {
+				gms_normal_string("[The ");
+				gms_standout_string(matched->command);
+				gms_normal_string(" command ignores arguments.]\n");
+			}
+
+			*undo_command = matched->undo_return;
+		}
+
+		/* No match, or the command was ambiguous. */
+		else {
+			gms_normal_string("\nThe Glk command ");
+			gms_standout_string(command);
+			gms_normal_string(" is ");
+			gms_normal_string(matches == 0 ? "not valid" : "ambiguous");
+			gms_normal_string(".  Try ");
+			gms_standout_string("glk help");
+			gms_normal_string(" for more information.\n");
+		}
+	} else {
+		gms_normal_char('\n');
+		gms_command_help("");
+	}
+
+	/* The string contained a Glk command; return TRUE. */
+	free(string_copy);
+	return TRUE;
+}
+
+
+/*
+ * gms_command_undo_special()
+ *
+ * This function makes a special case of the input line containing the single
+ * word "undo", treating it as if it is "glk undo".  This makes life a bit
+ * more convenient for the player, since it's the same behavior that most
+ * other IF systems have.  It returns TRUE if "undo" found, FALSE otherwise.
+ */
+static int gms_command_undo_special(const char *string) {
+	int posn, end;
+	assert(string);
+
+	/* Find the start and end of the first string word. */
+	posn = strspn(string, "\t ");
+	end = posn + strcspn(string + posn, "\t ");
+
+	/* See if string contains an "undo" request, with nothing following. */
+	if (end - posn == (int)strlen("undo")
+	        && gms_strncasecmp(string + posn, "undo", end - posn) == 0) {
+		posn = end + strspn(string + end, "\t ");
+		if (string[posn] == '\0')
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port input functions                                           */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Input buffer allocated for reading input lines.  The buffer is filled
+ * from either an input log, if one is currently being read, or from Glk
+ * line input.  We also need an "undo" notification flag.
+ */
+enum { GMS_INPUTBUFFER_LENGTH = 256 };
+static char gms_input_buffer[GMS_INPUTBUFFER_LENGTH];
+static int gms_input_length = 0,
+           gms_input_cursor = 0,
+           gms_undo_notification = FALSE;
+
+/* Table of single-character command abbreviations. */
+typedef const struct {
+	const char abbreviation;       /* Abbreviation character. */
+	const char *const expansion;   /* Expansion string. */
+} gms_abbreviation_t;
+typedef gms_abbreviation_t *gms_abbreviationref_t;
+
+static gms_abbreviation_t GMS_ABBREVIATIONS[] = {
+	{'c', "close"},    {'g', "again"},  {'i', "inventory"},
+	{'k', "attack"},   {'l', "look"},   {'p', "open"},
+	{'q', "quit"},     {'r', "drop"},   {'t', "take"},
+	{'x', "examine"},  {'y', "yes"},    {'z', "wait"},
+	{'\0', NULL}
+};
+
+
+/*
+ * gms_expand_abbreviations()
+ *
+ * Expand a few common one-character abbreviations commonly found in other
+ * game systems, but not always normal in Magnetic Scrolls games.
+ */
+static void gms_expand_abbreviations(char *buffer, int size) {
+	char *command, abbreviation;
+	const char *expansion;
+	gms_abbreviationref_t entry;
+	assert(buffer);
+
+	/* Ignore anything that isn't a single letter command. */
+	command = buffer + strspn(buffer, "\t ");
+	if (!(strlen(command) == 1
+	        || (strlen(command) > 1 && Common::isSpace(command[1]))))
+		return;
+
+	/* Scan the abbreviations table for a match. */
+	abbreviation = g_vm->glk_char_to_lower((unsigned char) command[0]);
+	expansion = NULL;
+	for (entry = GMS_ABBREVIATIONS; entry->expansion; entry++) {
+		if (entry->abbreviation == abbreviation) {
+			expansion = entry->expansion;
+			break;
+		}
+	}
+
+	/*
+	 * If a match found, check for a fit, then replace the character with the
+	 * expansion string.
+	 */
+	if (expansion) {
+		if ((int)(strlen(buffer) + strlen(expansion)) - 1 >= size)
+			return;
+
+		memmove(command + strlen(expansion) - 1, command, strlen(command) + 1);
+		memcpy(command, expansion, strlen(expansion));
+
+#if 0
+		gms_standout_string("[");
+		gms_standout_char(abbreviation);
+		gms_standout_string(" -> ");
+		gms_standout_string(expansion);
+		gms_standout_string("]\n");
+#endif
+	}
+}
+
+
+/*
+ * gms_buffer_input
+ *
+ * Read and buffer a line of input.  If there is an input log active, then
+ * data is taken by reading this first.  Otherwise, the function gets a
+ * line from Glk.
+ *
+ * It also makes special cases of some lines read from the user, either
+ * handling commands inside them directly, or expanding abbreviations as
+ * appropriate.  This is not reflected in the buffer, which is adjusted as
+ * required before returning.
+ */
+static void gms_buffer_input(void) {
+	event_t event;
+
+	/*
+	 * Update the current status line display, and flush any pending buffered
+	 * output.
+	 */
+	gms_status_notify();
+	gms_output_flush();
+
+	/*
+	 * Magnetic Windows games tend not to issue a prompt after reading an empty
+	 * line of input.  This can make for a very blank looking screen.
+	 *
+	 * To slightly improve things, if it looks like we didn't get a prompt from
+	 * the game, do our own.
+	 */
+	if (gms_prompt_enabled && !gms_game_prompted()) {
+		gms_normal_char('\n');
+		gms_normal_string(GMS_INPUT_PROMPT);
+	}
+
+	/*
+	 * If we have an input log to read from, use that until it is exhausted.  On
+	 * end of file, close the stream and resume input from line requests.
+	 */
+	if (gms_readlog_stream) {
+		glui32 chars;
+
+		/* Get the next line from the log stream. */
+		chars = g_vm->glk_get_line_stream(gms_readlog_stream,
+		                                  gms_input_buffer, sizeof(gms_input_buffer));
+		if (chars > 0) {
+			/* Echo the line just read in input style. */
+			g_vm->glk_set_style(style_Input);
+			g_vm->glk_put_buffer(gms_input_buffer, chars);
+			g_vm->glk_set_style(style_Normal);
+
+			/* Note how many characters buffered, and return. */
+			gms_input_length = chars;
+			return;
+		}
+
+		/*
+		 * We're at the end of the log stream.  Close it, and then continue
+		 * on to request a line from Glk.
+		 */
+		g_vm->glk_stream_close(gms_readlog_stream, NULL);
+		gms_readlog_stream = NULL;
+	}
+
+	/*
+	 * No input log being read, or we just hit the end of file on one.  Revert
+	 * to normal line input; start by getting a new line from Glk.
+	 */
+	g_vm->glk_request_line_event(gms_main_window,
+	                             gms_input_buffer, sizeof(gms_input_buffer) - 1, 0);
+	gms_event_wait(evtype_LineInput, &event);
+
+	/* Terminate the input line with a NUL. */
+	assert(event.val1 <= sizeof(gms_input_buffer) - 1);
+	gms_input_buffer[event.val1] = '\0';
+
+	/* Special handling for "undo" commands. */
+	if (gms_command_undo_special(gms_input_buffer)) {
+		/* Write the "undo" to any input log. */
+		if (gms_inputlog_stream) {
+			g_vm->glk_put_string_stream(gms_inputlog_stream, gms_input_buffer);
+			g_vm->glk_put_char_stream(gms_inputlog_stream, '\n');
+		}
+
+		/* Overwrite buffer with an empty line if we saw "undo". */
+		gms_input_buffer[0] = '\n';
+		gms_input_length = 1;
+
+		gms_undo_notification = TRUE;
+		return;
+	}
+
+	/*
+	 * If neither abbreviations nor local commands are enabled, use the data
+	 * read above without further massaging.
+	 */
+	if (gms_abbreviations_enabled || gms_commands_enabled) {
+		char *command;
+
+		/*
+		 * If the first non-space input character is a quote, bypass all
+		 * abbreviation expansion and local command recognition, and use the
+		 * unadulterated input, less introductory quote.
+		 */
+		command = gms_input_buffer + strspn(gms_input_buffer, "\t ");
+		if (command[0] == '\'') {
+			/* Delete the quote with memmove(). */
+			memmove(command, command + 1, strlen(command));
+		} else {
+			/* Check for, and expand, any abbreviated commands. */
+			if (gms_abbreviations_enabled) {
+				gms_expand_abbreviations(gms_input_buffer,
+				                         sizeof(gms_input_buffer));
+			}
+
+			/*
+			 * Check for standalone "help", then for Glk port special commands;
+			 * suppress the interpreter's use of this input for Glk commands
+			 * by overwriting the line with a single newline character.
+			 */
+			if (gms_commands_enabled) {
+				int posn;
+
+				posn = strspn(gms_input_buffer, "\t ");
+				if (gms_strncasecmp(gms_input_buffer + posn,
+				                    "help", strlen("help")) == 0) {
+					if (strspn(gms_input_buffer + posn + strlen("help"), "\t ")
+					        == strlen(gms_input_buffer + posn + strlen("help"))) {
+						gms_output_register_help_request();
+					}
+				}
+
+				if (gms_command_escape(gms_input_buffer,
+				                       &gms_undo_notification)) {
+					gms_output_silence_help_hints();
+					gms_input_buffer[0] = '\n';
+					gms_input_length = 1;
+					return;
+				}
+			}
+		}
+	}
+
+	/*
+	 * If there is an input log active, log this input string to it.  Note that
+	 * by logging here we get any abbreviation expansions but we won't log glk
+	 * special commands, nor any input read from a current open input log.
+	 */
+	if (gms_inputlog_stream) {
+		g_vm->glk_put_string_stream(gms_inputlog_stream, gms_input_buffer);
+		g_vm->glk_put_char_stream(gms_inputlog_stream, '\n');
+	}
+
+	/*
+	 * Now append a newline to the buffer, since Glk line input doesn't provide
+	 * one, and in any case, abbreviation expansion may have edited the buffer
+	 * contents (and in particular, changed the length).
+	 */
+	gms_input_buffer[strlen(gms_input_buffer) + 1] = '\0';
+	gms_input_buffer[strlen(gms_input_buffer)] = '\n';
+
+	/* Note how many characters are buffered after all of the above. */
+	gms_input_length = strlen(gms_input_buffer);
+}
+
+
+/*
+ * ms_getchar()
+ *
+ * Return the single next character to the interpreter.  This function
+ * extracts characters from the input buffer until empty, when it then
+ * tries to buffer more data.
+ */
+type8 ms_getchar(type8 trans) {
+	/* See if we are at the end of the input buffer. */
+	if (gms_input_cursor == gms_input_length) {
+		/*
+		 * Try to read in more data, and rewind buffer cursor.  As well as
+		 * reading input, this may set an undo notification.
+		 */
+		gms_buffer_input();
+		gms_input_cursor = 0;
+
+		if (gms_undo_notification) {
+			/*
+			 * Clear the undo notification, and discard buffered input (usually
+			 * just the '\n' placed there when the undo command was recognized).
+			 */
+			gms_undo_notification = FALSE;
+			gms_input_length = 0;
+
+			/*
+			 * Return the special 0, or a blank line if no undo is allowed at
+			 * this point.
+			 */
+			return trans ? 0 : '\n';
+		}
+	}
+
+	/* Return the next character from the input buffer. */
+	assert(gms_input_cursor < gms_input_length);
+	return gms_input_buffer[gms_input_cursor++];
+}
+
+#if 0
+/*
+ * gms_confirm()
+ *
+ * Print a confirmation prompt, and read a single input character, taking
+ * only [YyNn] input.  If the character is 'Y' or 'y', return TRUE.
+ */
+static int gms_confirm(const char *prompt) {
+	event_t event;
+	unsigned char response;
+	assert(prompt);
+
+	/*
+	 * Print the confirmation prompt, in a style that hints that it's from the
+	 * interpreter, not the game.
+	 */
+	gms_standout_string(prompt);
+
+	/* Wait for a single 'Y' or 'N' character response. */
+	response = ' ';
+	do {
+		g_vm->glk_request_char_event(gms_main_window);
+		gms_event_wait(evtype_CharInput, &event);
+
+		if (event.val1 <= BYTE_MAX)
+			response = g_vm->glk_char_to_upper(event.val1);
+	} while (!(response == 'Y' || response == 'N'));
+
+	/* Echo the confirmation response, and a blank line. */
+	g_vm->glk_set_style(style_Input);
+	g_vm->glk_put_string(response == 'Y' ? "Yes" : "No");
+	g_vm->glk_set_style(style_Normal);
+	g_vm->glk_put_string("\n\n");
+
+	return response == 'Y';
+}
+#endif
+
+/*---------------------------------------------------------------------*/
+/*  Glk port event functions                                           */
+/*---------------------------------------------------------------------*/
+
+/*
+ * gms_event_wait()
+ *
+ * Process Glk events until one of the expected type arrives.  Return
+ * the event of that type.
+ */
+static void gms_event_wait(glui32 wait_type, event_t *event) {
+	assert(event);
+
+	do {
+		g_vm->glk_select(event);
+
+		switch (event->type) {
+		case evtype_Arrange:
+		case evtype_Redraw:
+			/* Refresh any sensitive windows on size events. */
+			gms_status_redraw();
+			gms_hint_redraw();
+			gms_graphics_paint();
+			break;
+
+		case evtype_Timer:
+			/* Do background graphics updates on timeout. */
+			gms_graphics_timeout();
+			break;
+
+		default:
+			break;
+		}
+	} while (event->type != (EvType)wait_type);
+}
+
+/*---------------------------------------------------------------------*/
+/*  Functions intercepted by link-time wrappers                        */
+/*---------------------------------------------------------------------*/
+
+/*
+ * __wrap_toupper()
+ * __wrap_tolower()
+ *
+ * Wrapper functions around toupper() and tolower().  The Linux linker's
+ * --wrap option will convert calls to mumble() to __wrap_mumble() if we
+ * give it the right options.  We'll use this feature to translate all
+ * toupper() and tolower() calls in the interpreter code into calls to
+ * Glk's versions of these functions.
+ *
+ * It's not critical that we do this.  If a linker, say a non-Linux one,
+ * won't do --wrap, then just do without it.  It's unlikely that there
+ * will be much noticeable difference.
+ */
+int __wrap_toupper(int ch) {
+	unsigned char uch;
+
+	uch = g_vm->glk_char_to_upper((unsigned char) ch);
+	return (int) uch;
+}
+
+int __wrap_tolower(int ch) {
+	unsigned char lch;
+
+	lch = g_vm->glk_char_to_lower((unsigned char) ch);
+	return (int) lch;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  main() and options parsing                                         */
+/*---------------------------------------------------------------------*/
+
+/*
+ * The following values need to be passed between the startup_code and main
+ * functions.
+ */
+static const char *gms_gamefile = NULL,      /* Name of game file. */
+                   *gms_game_message = NULL;  /* Error message. */
+
+
+/*
+ * gms_establish_filenames()
+ *
+ * Given a game name, try to establish three filenames from it - the main game
+ * text file, the (optional) graphics data file, and the (optional) hints
+ * file.  Given an input "file" X, the function looks for X.MAG or X.mag for
+ * game data, X.GFX or X.gfx for graphics, and X.HNT or X.hnt for hints.
+ * If the input file already ends with .MAG, .GFX, or .HNT, the extension
+ * is stripped first.
+ *
+ * The function returns NULL for filenames not available.  It's not fatal if
+ * the graphics filename or hints filename is NULL, but it is if the main game
+ * filename is NULL.  Filenames are malloc'ed, and need to be freed by the
+ * caller.
+ */
+static void gms_establish_filenames(const char *name, char **text, char **graphics, char **hints) {
+	char *base, *text_file, *graphics_file, *hints_file;
+	Common::File stream;
+	assert(name && text && graphics && hints);
+
+	/* Take a destroyable copy of the input filename. */
+	base = (char *)gms_malloc(strlen(name) + 1);
+	strcpy(base, name);
+
+	/* If base has an extension .MAG, .GFX, or .HNT, remove it. */
+	if (strlen(base) > strlen(".XXX")) {
+		if (gms_strcasecmp(base + strlen(base) - strlen(".MAG"), ".MAG") == 0
+		        || gms_strcasecmp(base + strlen(base) - strlen(".GFX"), ".GFX") == 0
+		        || gms_strcasecmp(base + strlen(base) - strlen(".HNT"), ".HNT") == 0)
+			base[strlen(base) - strlen(".XXX")] = '\0';
+	}
+
+	/* Allocate space for the return text file. */
+	text_file = (char *)gms_malloc(strlen(base) + strlen(".MAG") + 1);
+
+	/* Form a candidate text file, by adding a .MAG extension. */
+	strcpy(text_file, base);
+	strcat(text_file, ".MAG");
+
+	if (!stream.open(text_file)) {
+		/* Retry, using a .mag extension instead. */
+		strcpy(text_file, base);
+		strcat(text_file, ".mag");
+
+		if (!stream.open(text_file)) {
+			/*
+			 * No access to a usable game text file.  Return immediately,
+			 * without looking for any associated graphics or hints files.
+			 */
+			*text = NULL;
+			*graphics = NULL;
+			*hints = NULL;
+
+			free(text_file);
+			free(base);
+			return;
+		}
+	}
+	stream.close();
+
+	/* Now allocate space for the return graphics file. */
+	graphics_file = (char *)gms_malloc(strlen(base) + strlen(".GFX") + 1);
+
+	/* As above, form a candidate graphics file, using a .GFX extension. */
+	strcpy(graphics_file, base);
+	strcat(graphics_file, ".GFX");
+
+	if (!stream.open(graphics_file)) {
+		/* Retry, using a .gfx extension instead. */
+		strcpy(graphics_file, base);
+		strcat(graphics_file, ".gfx");
+
+		if (!stream.open(graphics_file)) {
+			/*
+			 * No access to any graphics file.  In this case, free memory and
+			 * reset graphics file to NULL.
+			 */
+			free(graphics_file);
+			graphics_file = NULL;
+		}
+	}
+	stream.close();
+
+	/* Now allocate space for the return hints file. */
+	hints_file = (char *)gms_malloc(strlen(base) + strlen(".HNT") + 1);
+
+	/* As above, form a candidate graphics file, using a .HNT extension. */
+	strcpy(hints_file, base);
+	strcat(hints_file, ".HNT");
+
+	if (!stream.open(hints_file)) {
+		/* Retry, using a .hnt extension instead. */
+		strcpy(hints_file, base);
+		strcat(hints_file, ".hnt");
+
+		if (!stream.open(hints_file)) {
+			/*
+			 * No access to any hints file.  In this case, free memory and
+			 * reset hints file to NULL.
+			 */
+			free(hints_file);
+			hints_file = NULL;
+		}
+	}
+	stream.close();
+
+	/* Return the text file, and graphics and hints, which may be NULL. */
+	*text = text_file;
+	*graphics = graphics_file;
+	*hints = hints_file;
+
+	free(base);
+}
+
+
+/*
+ * gms_startup_code()
+ * gms_main()
+ *
+ * Together, these functions take the place of the original main().  The
+ * first one is called from glkunix_startup_code(), to parse and generally
+ * handle options.  The second is called from g_vm->glk_main(), and does the real
+ * work of running the game.
+ */
+int gms_startup_code(int argc, char *argv[]) {
+	int argv_index;
+
+	/* Handle command line arguments. */
+	for (argv_index = 1;
+	        argv_index < argc && argv[argv_index][0] == '-'; argv_index++) {
+		if (strcmp(argv[argv_index], "-nc") == 0) {
+			gms_commands_enabled = FALSE;
+			continue;
+		}
+		if (strcmp(argv[argv_index], "-na") == 0) {
+			gms_abbreviations_enabled = FALSE;
+			continue;
+		}
+		if (strcmp(argv[argv_index], "-np") == 0) {
+			gms_graphics_enabled = FALSE;
+			continue;
+		}
+		if (strcmp(argv[argv_index], "-ng") == 0) {
+			gms_gamma_mode = GAMMA_OFF;
+			continue;
+		}
+		if (strcmp(argv[argv_index], "-nx") == 0) {
+			gms_animation_enabled = FALSE;
+			continue;
+		}
+		if (strcmp(argv[argv_index], "-ne") == 0) {
+			gms_prompt_enabled = FALSE;
+			continue;
+		}
+		return FALSE;
+	}
+
+	/*
+	 * Get the name of the game file.  Since we need this in our call from
+	 * g_vm->glk_main, we need to keep it in a module static variable.  If the game
+	 * file name is omitted, then here we'll set the pointer to NULL, and
+	 * complain about it later in main.  Passing the message string around
+	 * like this is a nuisance...
+	 */
+	if (argv_index == argc - 1) {
+		gms_gamefile = argv[argv_index];
+		gms_game_message = NULL;
+#ifdef GARGLK
+		{
+			const char *s;
+			s = strrchr(gms_gamefile, '\\');
+			if (s)
+				g_vm->garglk_set_story_name(s + 1);
+			s = strrchr(gms_gamefile, '/');
+			if (s)
+				g_vm->garglk_set_story_name(s + 1);
+		}
+#endif
+	} else {
+		gms_gamefile = NULL;
+		if (argv_index < argc - 1)
+			gms_game_message = "More than one game file was given"
+			                   " on the command line.";
+		else
+			gms_game_message = "No game file was given on the command line.";
+	}
+
+	/* All startup options were handled successfully. */
+	return TRUE;
+}
+
+void gms_main() {
+	char *text_file = NULL, *graphics_file = NULL, *hints_file = NULL;
+	int ms_init_status, is_running;
+
+	/* Ensure Magnetic Scrolls internal types have the right sizes. */
+	if (!(sizeof(type8) == 1 && sizeof(type8s) == 1
+	        && sizeof(type16) == 2 && sizeof(type16s) == 2
+	        && sizeof(type32) == 4 && sizeof(type32s) == 4)) {
+		gms_fatal("GLK: Types sized incorrectly, recompilation is needed");
+		g_vm->glk_exit();
+	}
+
+	/* Create the main Glk window, and set its stream as current. */
+	gms_main_window = g_vm->glk_window_open(0, 0, 0, wintype_TextBuffer, 0);
+	if (!gms_main_window) {
+		gms_fatal("GLK: Can't open main window");
+		g_vm->glk_exit();
+	}
+	g_vm->glk_window_clear(gms_main_window);
+	g_vm->glk_set_window(gms_main_window);
+	g_vm->glk_set_style(style_Normal);
+
+	/* If there's a problem with the game file, complain now. */
+	if (!gms_gamefile) {
+		assert(gms_game_message);
+		gms_header_string("Glk Magnetic Error\n\n");
+		gms_normal_string(gms_game_message);
+		gms_normal_char('\n');
+		g_vm->glk_exit();
+		return;
+	}
+
+	/*
+	 * Given the basic game name, try to come up with usable text, graphics,
+	 * and hints filenames.  The graphics and hints files may be null, but the
+	 * text file may not.
+	 */
+	gms_establish_filenames(gms_gamefile,
+	                        &text_file, &graphics_file, &hints_file);
+	if (!text_file) {
+		assert(!graphics_file && !hints_file);
+		gms_header_string("Glk Magnetic Error\n\n");
+		gms_normal_string("Can't find or open game '");
+		gms_normal_string(gms_gamefile);
+		gms_normal_string("[.mag|.MAG]'");
+
+		gms_normal_char('\n');
+		g_vm->glk_exit();
+	}
+
+	/* Set the possibility of pictures depending on graphics file. */
+	if (graphics_file) {
+		/*
+		 * Check Glk library capabilities, and note pictures are impossible if
+		 * the library can't offer both graphics and timers.  We need timers to
+		 * create the background "thread" for picture updates.
+		 */
+		gms_graphics_possible = g_vm->glk_gestalt(gestalt_Graphics, 0)
+		                        && g_vm->glk_gestalt(gestalt_Timer, 0);
+	} else
+		gms_graphics_possible = FALSE;
+
+
+	/*
+	 * If pictures are impossible, clear pictures enabled flag.  That is, act
+	 * as if -np was given on the command line, even though it may not have
+	 * been.  If pictures are impossible, they can never be enabled.
+	 */
+	if (!gms_graphics_possible)
+		gms_graphics_enabled = FALSE;
+
+	/* Try to create a one-line status window.  We can live without it. */
+	g_vm->glk_stylehint_set(wintype_TextGrid, style_User1, stylehint_ReverseColor, 1);
+	gms_status_window = g_vm->glk_window_open(gms_main_window,
+	                    winmethod_Above | winmethod_Fixed,
+	                    1, wintype_TextGrid, 0);
+
+	/*
+	 * Load the game.  If no graphics are possible, then passing the NULL to
+	 * ms_init() runs a game without graphics.
+	 */
+	if (gms_graphics_possible) {
+		assert(graphics_file);
+		ms_init_status = ms_init(text_file, graphics_file, hints_file, NULL);
+	} else
+		ms_init_status = ms_init(text_file, NULL, hints_file, NULL);
+
+	/* Look for a complete failure to load the game. */
+	if (ms_init_status == 0) {
+		if (gms_status_window)
+			g_vm->glk_window_close(gms_status_window, NULL);
+		gms_header_string("Glk Magnetic Error\n\n");
+		gms_normal_string("Can't load game '");
+		gms_normal_string(gms_gamefile);
+		gms_normal_char('\'');
+
+		gms_normal_char('\n');
+
+		/*
+		 * Free the text file path, any graphics/hints file path, and
+		 * interpreter allocated memory.
+		 */
+		free(text_file);
+		free(graphics_file);
+		free(hints_file);
+		ms_freemem();
+		g_vm->glk_exit();
+	}
+
+	/* Try to identify the game from its text file header. */
+	gms_gameid_identify_game(text_file);
+
+	/* Print out a short banner. */
+	gms_header_string("\nMagnetic Scrolls Interpreter, version 2.3\n");
+	gms_banner_string("Written by Niclas Karlsson\n"
+	                  "Glk interface by Simon Baldwin\n\n");
+
+	/* Look for failure to load just game graphics. */
+	if (gms_graphics_possible && ms_init_status == 1) {
+		/*
+		 * Output a warning if graphics failed, but the main game text
+		 * initialized okay.
+		 */
+		gms_standout_string("Error: Unable to open graphics file\n"
+		                    "Continuing without pictures...\n\n");
+
+		gms_graphics_possible = FALSE;
+	}
+
+	/* Run the game opcodes -- ms_rungame() returns FALSE on game end. */
+	do {
+		is_running = ms_rungame();
+		g_vm->glk_tick();
+	} while (is_running);
+
+	/* Handle any updated status and pending buffered output. */
+	gms_status_notify();
+	gms_output_flush();
+
+	/* Turn off any background graphics "thread". */
+	gms_graphics_stop();
+
+	/* Free interpreter allocated memory. */
+	ms_freemem();
+
+	/*
+	 * Free any temporary memory that may have been used by graphics and hints.
+	 */
+	gms_graphics_cleanup();
+	gms_hints_cleanup();
+
+	/* Close any open transcript, input log, and/or read log. */
+	if (gms_transcript_stream) {
+		g_vm->glk_stream_close(gms_transcript_stream, NULL);
+		gms_transcript_stream = NULL;
+	}
+	if (gms_inputlog_stream) {
+		g_vm->glk_stream_close(gms_inputlog_stream, NULL);
+		gms_inputlog_stream = NULL;
+	}
+	if (gms_readlog_stream) {
+		g_vm->glk_stream_close(gms_readlog_stream, NULL);
+		gms_readlog_stream = NULL;
+	}
+
+	/* Free the text file path, and any graphics/hints file path. */
+	free(text_file);
+	free(graphics_file);
+	free(hints_file);
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Linkage between Glk entry/exit calls and the Magnetic interpreter  */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Safety flags, to ensure we always get startup before main, and that
+ * we only get a call to main once.
+ */
+static int gms_startup_called = FALSE,
+           gms_main_called = FALSE;
+
+/*
+ * g_vm->glk_main()
+ *
+ * Main entry point for Glk.  Here, all startup is done, and we call our
+ * function to run the game.
+ */
+void glk_main(void) {
+	assert(gms_startup_called && !gms_main_called);
+	gms_main_called = TRUE;
+
+	/* Call the interpreter main function. */
+	gms_main();
+}
+
+
+/*
+ * Glk arguments for UNIX versions of the Glk interpreter.
+ */
+#if 0
+glkunix_argumentlist_t glkunix_arguments[] = {
+	{
+		(char *) "-nc", glkunix_arg_NoValue,
+		(char *) "-nc        No local handling for Glk special commands"
+	},
+	{
+		(char *) "-na", glkunix_arg_NoValue,
+		(char *) "-na        Turn off abbreviation expansions"
+	},
+	{
+		(char *) "-np", glkunix_arg_NoValue,
+		(char *) "-np        Turn off pictures"
+	},
+	{
+		(char *) "-ng", glkunix_arg_NoValue,
+		(char *) "-ng        Turn off automatic gamma correction on pictures"
+	},
+	{
+		(char *) "-nx", glkunix_arg_NoValue,
+		(char *) "-nx        Turn off picture animations"
+	},
+	{
+		(char *) "-ne", glkunix_arg_NoValue,
+		(char *) "-ne        Turn off additional interpreter prompt"
+	},
+	{
+		(char *) "", glkunix_arg_ValueCanFollow,
+		(char *) "filename   game to run"
+	},
+	{NULL, glkunix_arg_End, NULL}
+};
+#endif
+
+void write(const char *fmt, ...) {
+	va_list ap;
+	va_start(ap, fmt);
+	Common::String s = Common::String::format(fmt, ap);
+	va_end(ap);
+	g_vm->glk_put_buffer(s.c_str(), s.size());
+}
+
+void writeChar(char c) {
+	g_vm->glk_put_char(c);
+}
+
+} // End of namespace Magnetic
+} // End of namespace Glk
diff --git a/engines/glk/magnetic/graphics.cpp b/engines/glk/magnetic/graphics.cpp
deleted file mode 100644
index d9c62a1b89..0000000000
--- a/engines/glk/magnetic/graphics.cpp
+++ /dev/null
@@ -1,507 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- */
-
-#include "glk/magnetic/magnetic.h"
-
-namespace Glk {
-namespace Magnetic {
-
-byte Magnetic::init_gfx1(size_t size) {
-	if (!(gfx_buf = new byte[MAX_PICTURE_SIZE]))
-		return 1;
-
-	if (!(gfx_data = new byte[size])) {
-		delete[] gfx_buf;
-		gfx_buf = nullptr;
-		return 1;
-	}
-
-	if (_gfxFile.read(gfx_data, size) != size) {
-		delete[] gfx_data;
-		delete[] gfx_buf;
-		gfx_data = gfx_buf = nullptr;
-		return 1;
-	}
-
-	gfx_ver = 1;
-	return 2;
-}
-
-byte Magnetic::init_gfx2(size_t size) {
-	if (!(gfx_buf = new byte[MAX_PICTURE_SIZE])) {
-		return 1;
-	}
-
-	gfx2_hsize = size;
-	if (!(gfx2_hdr = new byte[gfx2_hsize])) {
-		delete[] gfx_buf;
-		gfx_buf = nullptr;
-		return 1;
-	}
-
-	if (_gfxFile.read(gfx2_hdr, gfx2_hsize) != gfx2_hsize) {
-		delete[] gfx_buf;
-		delete[] gfx2_hdr;
-		gfx_buf = nullptr;
-		gfx2_hdr = nullptr;
-		return 1;
-	}
-
-	gfx_ver = 2;
-	return 2;
-}
-
-void Magnetic::ms_showpic(int c, byte mode) {
-	// TODO
-}
-
-bool Magnetic::is_blank(uint16 line, uint16 width) const {
-	int i;
-
-	for (i = line * width; i < (line + 1) * width; i++)
-		if (gfx_buf[i])
-			return false;
-	return true;
-}
-
-byte *Magnetic::ms_extract1(byte pic, uint16 * w, uint16 * h, uint16 * pal) {
-	byte *table, *data, bit, val, *buffer;
-	uint16 tablesize, count;
-	uint32 i, j, upsize, offset;
-	//uint32 datasize;
-
-	offset = READ_LE_UINT32(gfx_data + 4 * pic);
-	buffer = gfx_data + offset - 8;
-
-	for (i = 0; i < 16; i++)
-		pal[i] = READ_LE_UINT16(buffer + 0x1c + 2 * i);
-	w[0] = (uint16)(READ_LE_UINT16(buffer + 4) - READ_LE_UINT16(buffer + 2));
-	h[0] = READ_LE_UINT16(buffer + 6);
-
-	tablesize = READ_LE_UINT16(buffer + 0x3c);
-	//datasize = READ_LE_UINT32(buffer + 0x3e);
-	table = buffer + 0x42;
-	data = table + tablesize * 2 + 2;
-	upsize = h[0] * w[0];
-
-	for (i = 0, j = 0, count = 0, val = 0, bit = 7; i < upsize; i++, count--) {
-		if (!count) {
-			count = tablesize;
-			while (count < 0x80) {
-				if (data[j] & (1 << bit))
-					count = table[2 * count];
-				else
-					count = table[2 * count + 1];
-				if (!bit)
-					j++;
-				bit = (byte)(bit ? bit - 1 : 7);
-			}
-			count &= 0x7f;
-			if (count >= 0x10)
-				count -= 0x10;
-			else
-			{
-				val = (byte)count;
-				count = 1;
-			}
-		}
-		gfx_buf[i] = val;
-	}
-	for (j = w[0]; j < upsize; j++)
-		gfx_buf[j] ^= gfx_buf[j - w[0]];
-
-	for (; h[0] > 0 && is_blank((uint16)(h[0] - 1), w[0]); h[0]--);
-	for (i = 0; h[0] > 0 && is_blank((uint16)i, w[0]); h[0]--, i++);
-	return gfx_buf + i * w[0];
-}
-
-
-byte *Magnetic::ms_extract2(const char *name, uint16 *w, uint16 *h, uint16 *pal, byte *is_anim) {
-	struct picture main_pic;
-	uint32 offset = 0, length = 0, i;
-	int16 header_pos = -1;
-	byte* anim_data;
-	uint32 j;
-
-	if (is_anim != 0)
-		*is_anim = 0;
-	gfx2_name = name;
-
-	pos_table_size = 0;
-
-	// Find the uppercase (no animation) version of the picture first
-	header_pos = find_name_in_header(name, 1);
-
-	if (header_pos < 0)
-		header_pos = find_name_in_header(name, 0);
-	if (header_pos < 0)
-		return 0;
-
-	offset = READ_LE_UINT32(gfx2_hdr + header_pos + 8);
-	length = READ_LE_UINT32(gfx2_hdr + header_pos + 12);
-
-	if (offset != 0) {
-		if (gfx2_buf) {
-			delete[] gfx2_buf;
-			gfx2_buf = nullptr;
-		}
-
-		gfx2_buf = new byte[length];
-		if (!gfx2_buf)
-			return 0;
-
-		if (!_gfxFile.seek(offset) || _gfxFile.read(gfx2_buf, length) != length) {
-			delete[] gfx2_buf;
-			gfx2_buf = nullptr;
-			return 0;
-		}
-
-		for (i = 0; i < 16; i++)
-			pal[i] = READ_LE_UINT16(gfx2_buf + 4 + (2 * i));
-
-		main_pic.data = gfx2_buf + 48;
-		main_pic.data_size = READ_LE_UINT32(gfx2_buf + 38);
-		main_pic.width = READ_LE_UINT16(gfx2_buf + 42);
-		main_pic.height = READ_LE_UINT16(gfx2_buf + 44);
-		main_pic.wbytes = (uint16)(main_pic.data_size / main_pic.height);
-		main_pic.plane_step = (uint16)(main_pic.wbytes / 4);
-		main_pic.mask = (byte*)0;
-		extract_frame(&main_pic);
-
-		*w = main_pic.width;
-		*h = main_pic.height;
-
-		// Check for an animation
-		anim_data = gfx2_buf + 48 + main_pic.data_size;
-		if ((anim_data[0] != 0xD0) || (anim_data[1] != 0x5E)) {
-			byte *current;
-			uint16 frame_count;
-			uint16 value1, value2;
-			//uint16 command_count;
-
-			if (is_anim != 0)
-				*is_anim = 1;
-
-			current = anim_data + 6;
-			frame_count = READ_LE_UINT16(anim_data + 2);
-			if (frame_count > MAX_ANIMS)
-			{
-				error("animation frame array too short");
-				return 0;
-			}
-
-			/* Loop through each animation frame */
-			for (i = 0; i < frame_count; i++)
-			{
-				anim_frame_table[i].data = current + 10;
-				anim_frame_table[i].data_size = READ_LE_UINT32(current);
-				anim_frame_table[i].width = READ_LE_UINT16(current + 4);
-				anim_frame_table[i].height = READ_LE_UINT16(current + 6);
-				anim_frame_table[i].wbytes = (uint16)(anim_frame_table[i].data_size / anim_frame_table[i].height);
-				anim_frame_table[i].plane_step = (uint16)(anim_frame_table[i].wbytes / 4);
-				anim_frame_table[i].mask = (byte*)0;
-
-				current += anim_frame_table[i].data_size + 12;
-				value1 = READ_LE_UINT16(current - 2);
-				value2 = READ_LE_UINT16(current);
-
-				/* Get the mask */
-				if ((value1 == anim_frame_table[i].width) && (value2 == anim_frame_table[i].height))
-				{
-					uint16 skip;
-
-					anim_frame_table[i].mask = (byte*)(current + 4);
-					skip = READ_LE_UINT16(current + 2);
-					current += skip + 6;
-				}
-			}
-
-			/* Get the positioning tables */
-			pos_table_size = READ_LE_UINT16(current - 2);
-			if (pos_table_size > MAX_POSITIONS)
-			{
-				error("animation position array too short");
-				return 0;
-			}
-
-			for (i = 0; i < pos_table_size; i++) {
-				pos_table_count[i] = READ_LE_UINT16(current + 2);
-				current += 4;
-
-				if (pos_table_count[i] > MAX_ANIMS)
-				{
-					error("animation position array too short");
-					return 0;
-				}
-
-				for (j = 0; j < pos_table_count[i]; j++)
-				{
-					pos_table[i][j].x = READ_LE_UINT16(current);
-					pos_table[i][j].y = READ_LE_UINT16(current + 2);
-					pos_table[i][j].number = READ_LE_UINT16(current + 4) - 1;
-					current += 8;
-				}
-			}
-
-			// Get the command sequence table
-			//command_count = READ_LE_UINT16(current);
-			command_table = current + 2;
-
-			for (i = 0; i < MAX_POSITIONS; i++)
-			{
-				anim_table[i].flag = -1;
-				anim_table[i].count = -1;
-			}
-			command_index = 0;
-			anim_repeat = 0;
-			pos_table_index = -1;
-			pos_table_max = -1;
-		}
-
-		return gfx_buf;
-	}
-
-	return nullptr;
-}
-
-int16 Magnetic::find_name_in_header(const Common::String &name, bool upper) {
-	int16 header_pos = 0;
-	Common::String pic_name(name.c_str(), name.c_str() + 6);
-
-	if (upper)
-		pic_name.toUppercase();
-
-	while (header_pos < gfx2_hsize) {
-		const char *hname = (const char *)(gfx2_hdr + header_pos);
-		if (strncmp(hname, pic_name.c_str(), 6) == 0)
-			return header_pos;
-		header_pos += 16;
-	}
-
-	return -1;
-}
-
-void Magnetic::extract_frame(const picture *pic) {
-	uint32 i, x, y, bit_x, mask, ywb, yw, value, values[4];
-	values[0] = values[1] = values[2] = values[3] = 0;
-
-	if (pic->width * pic->height > MAX_PICTURE_SIZE) {
-		error("picture too large");
-		return;
-	}
-
-	for (y = 0; y < pic->height; y++) {
-		ywb = y * pic->wbytes;
-		yw = y * pic->width;
-
-		for (x = 0; x < pic->width; x++) {
-			if ((x % 8) == 0) {
-				for (i = 0; i < 4; i++)
-					values[i] = pic->data[ywb + (x / 8) + (pic->plane_step * i)];
-			}
-
-			bit_x = 7 - (x & 7);
-			mask = 1 << bit_x;
-			value = ((values[0] & mask) >> bit_x) << 0 |
-				((values[1] & mask) >> bit_x) << 1 |
-				((values[2] & mask) >> bit_x) << 2 |
-				((values[3] & mask) >> bit_x) << 3;
-			value &= 15;
-
-			gfx_buf[yw + x] = (byte)value;
-		}
-	}
-}
-
-byte *Magnetic::ms_extract(uint32 pic, uint16 *w, uint16 *h, uint16 *pal, byte *is_anim) {
-	if (is_anim)
-		*is_anim = 0;
-
-	if (gfx_buf) {
-		switch (gfx_ver) {
-		case 1:
-			return ms_extract1((byte)pic, w, h, pal);
-		case 2:
-			return ms_extract2((const char *)(code + pic), w, h, pal, is_anim);
-		}
-	}
-
-	return nullptr;
-}
-
-byte Magnetic::ms_animate(ms_position **positions, uint16 *count) {
-	byte got_anim = 0;
-	uint16 i, j, ttable;
-
-	if ((gfx_buf == 0) || (gfx2_buf == 0) || (gfx_ver != 2))
-		return 0;
-	if ((pos_table_size == 0) || (command_index < 0))
-		return 0;
-
-	*count = 0;
-	*positions = (struct ms_position*)0;
-
-	while (got_anim == 0)
-	{
-		if (pos_table_max >= 0)
-		{
-			if (pos_table_index < pos_table_max)
-			{
-				for (i = 0; i < pos_table_size; i++)
-				{
-					if (anim_table[i].flag > -1)
-					{
-						if (*count >= MAX_FRAMES)
-						{
-							error("returned animation array too short");
-							return 0;
-						}
-
-						pos_array[*count] = pos_table[i][anim_table[i].flag];
-
-						(*count)++;
-
-						if (anim_table[i].flag < (pos_table_count[i] - 1))
-							anim_table[i].flag++;
-						if (anim_table[i].count > 0)
-							anim_table[i].count--;
-						else
-							anim_table[i].flag = -1;
-					}
-				}
-				if (*count > 0)
-				{
-					*positions = pos_array;
-					got_anim = 1;
-				}
-				pos_table_index++;
-			}
-		}
-
-		if (got_anim == 0)
-		{
-			byte command = command_table[command_index];
-			command_index++;
-
-			pos_table_max = -1;
-			pos_table_index = -1;
-
-			switch (command)
-			{
-			case 0x00:
-				command_index = -1;
-				return 0;
-			case 0x01:
-				ttable = command_table[command_index];
-				command_index++;
-
-				if (ttable - 1 >= MAX_POSITIONS)
-				{
-					error("animation table too short");
-					return 0;
-				}
-
-				anim_table[ttable - 1].flag = (int16)(command_table[command_index] - 1);
-				command_index++;
-				anim_table[ttable - 1].count = (int16)(command_table[command_index] - 1);
-				command_index++;
-
-				/* Workaround for Wonderland "catter" animation */
-				if (v4_id == 0)
-				{
-					if (gfx2_name == "catter") {
-						if (command_index == 96)
-							anim_table[ttable - 1].count = 9;
-						if (command_index == 108)
-							anim_table[ttable - 1].flag = -1;
-						if (command_index == 156)
-							anim_table[ttable - 1].flag = -1;
-					}
-				}
-				break;
-			case 0x02:
-				pos_table_max = command_table[command_index];
-				pos_table_index = 0;
-				command_index++;
-				break;
-			case 0x03:
-				if (v4_id == 0)
-				{
-					command_index = -1;
-					return 0;
-				}
-				else
-				{
-					command_index = 0;
-					anim_repeat = 1;
-					pos_table_index = -1;
-					pos_table_max = -1;
-					for (j = 0; j < MAX_POSITIONS; j++)
-					{
-						anim_table[j].flag = -1;
-						anim_table[j].count = -1;
-					}
-				}
-				break;
-
-			case 0x04:
-				command_index += 3;
-				return 0;
-			case 0x05:
-				ttable = next_table;
-				command_index++;
-
-				anim_table[ttable - 1].flag = 0;
-				anim_table[ttable - 1].count = command_table[command_index];
-
-				pos_table_max = command_table[command_index];
-				pos_table_index = 0;
-				command_index++;
-				command_index++;
-				next_table++;
-				break;
-			default:
-				error("unknown animation command");
-				command_index = -1;
-				return 0;
-			}
-		}
-	}
-
-	return got_anim;
-}
-
-byte *Magnetic::ms_get_anim_frame(int16 number, uint16 *width, uint16 *height, byte **mask) {
-	if (number >= 0)
-	{
-		extract_frame(anim_frame_table + number);
-		*width = anim_frame_table[number].width;
-		*height = anim_frame_table[number].height;
-		*mask = anim_frame_table[number].mask;
-		return gfx_buf;
-	}
-
-	return nullptr;
-}
-
-} // End of namespace Magnetic
-} // End of namespace Glk
diff --git a/engines/glk/magnetic/magnetic.cpp b/engines/glk/magnetic/magnetic.cpp
index 3f9917bf7b..3689668789 100644
--- a/engines/glk/magnetic/magnetic.cpp
+++ b/engines/glk/magnetic/magnetic.cpp
@@ -21,41 +21,20 @@
  */
 
 #include "glk/magnetic/magnetic.h"
-#include "common/config-manager.h"
-#include "common/translation.h"
+#include "glk/magnetic/defs.h"
 
 namespace Glk {
 namespace Magnetic {
 
-Magnetic::Magnetic(OSystem *syst, const GlkGameDescription &gameDesc) : GlkAPI(syst, gameDesc),
-	
-		vm_exited_cleanly(false), dlimit(0xffffffff), slimit(0xffffffff), log_on(0),
-		i_count(0), string_size(0), rseed(0), pc(0), arg1i(0), mem_size(0), properties(0), fl_sub(0),
-		fl_tab(0), fl_size(0), fp_tab(0), fp_size(0), zflag(0), nflag(0), cflag(0), vflag(0), byte1(0),
-		byte2(0), regnr(0), admode(0), opsize(0), arg1(nullptr), arg2(nullptr), is_reversible(0),
-		lastchar(0), version(0), sd(0), decode_table(nullptr), restart(nullptr), code(nullptr),
-		string(nullptr), string2(nullptr), string3(nullptr), dict(nullptr), quick_flag(0), gfx_ver(0),
-		gfx_buf(nullptr), gfx_data(nullptr), gfx2_hdr(0), gfx2_buf(nullptr), gfx2_hsize(0),
-		snd_buf(nullptr), snd_hdr(nullptr), snd_hsize(0), undo_pc(0), undo_size(0),
-		gfxtable(0), table_dist(0), v4_id(0), next_table(1), pos_table_size(0),
-		command_table(nullptr), command_index(-1), pos_table_index(-1), pos_table_max(-1),
-		anim_repeat(0) {
+Magnetic *g_vm;
 
-	// Emu fields
-	undo[0] = undo[1] = nullptr;
-	undo_stat[0] = undo_stat[1] = 0;
-	Common::fill(&dreg[0], &dreg[8], 0);
-	Common::fill(&areg[0], &areg[8], 0);
-	Common::fill(&tmparg[0], &tmparg[4], 0);
-	Common::fill(&undo_regs[0][0], &undo_regs[2][18], 0), 
-	Common::fill(&pos_table_count[0], &pos_table_count[MAX_POSITIONS], 0);
+Magnetic::Magnetic(OSystem *syst, const GlkGameDescription &gameDesc) : GlkAPI(syst, gameDesc) {
+	g_vm = this;
 }
 
 void Magnetic::runGame() {
-	if (!is_gamefile_valid())
-		return;
-
-	// TODO
+	gms_startup_code(0, nullptr);
+	gms_main();
 }
 
 Common::Error Magnetic::readSaveData(Common::SeekableReadStream *rs) {
@@ -68,30 +47,5 @@ Common::Error Magnetic::writeGameData(Common::WriteStream *ws) {
 	return Common::kWritingFailed;
 }
 
-bool Magnetic::is_gamefile_valid() {
-	if (_gameFile.size() < 8) {
-		GUIErrorMessage(_("This is too short to be a valid Glulx file."));
-		return false;
-	}
-
-	if (_gameFile.readUint32BE() != MKTAG('G', 'l', 'u', 'l')) {
-		GUIErrorMessage(_("This is not a valid Glulx file."));
-		return false;
-	}
-
-	// We support version 2.0 through 3.1.*
-	uint32 vers = _gameFile.readUint32BE();
-	if (vers < 0x20000) {
-		GUIErrorMessage(_("This Glulx file is too old a version to execute."));
-		return false;
-	}
-	if (vers >= 0x30200) {
-		GUIErrorMessage(_("This Glulx file is too new a version to execute."));
-		return false;
-	}
-
-	return true;
-}
-
 } // End of namespace Magnetic
 } // End of namespace Glk
diff --git a/engines/glk/magnetic/magnetic.h b/engines/glk/magnetic/magnetic.h
index c926ede9e6..33f9a4da5a 100644
--- a/engines/glk/magnetic/magnetic.h
+++ b/engines/glk/magnetic/magnetic.h
@@ -20,6 +20,8 @@
  *
  */
 
+/* Based on Magnetic interpreter version 2.3 */
+
 #ifndef GLK_MAGNETIC_MAGNETIC
 #define GLK_MAGNETIC_MAGNETIC
 
@@ -35,146 +37,6 @@ namespace Magnetic {
  */
 class Magnetic : public GlkAPI {
 public:
-	Common::File _hintFile;
-	Common::File _gfxFile;
-	Common::File _sndFile;
-	bool vm_exited_cleanly;
-	uint dlimit, slimit;
-	int log_on;
-
-	// Emu fields
-	uint32 dreg[8], areg[8], i_count, string_size, rseed, pc, arg1i, mem_size;
-	uint16 properties, fl_sub, fl_tab, fl_size, fp_tab, fp_size;
-	byte zflag, nflag, cflag, vflag, byte1, byte2, regnr, admode, opsize;
-	byte *arg1, *arg2, is_reversible, running, tmparg[4];
-	byte lastchar, version, sd;
-	byte *decode_table, *restart, *code, *string, *string2;
-	byte *string3, *dict;
-	byte quick_flag, gfx_ver, *gfx_buf, *gfx_data;
-	byte *gfx2_hdr, *gfx2_buf;
-	Common::String gfx2_name;
-	uint16 gfx2_hsize;
-	byte *snd_buf, *snd_hdr;
-	uint16 snd_hsize;
-	Common::File gfx_fp;
-	uint32 undo_regs[2][18], undo_pc, undo_size;
-	byte *undo[2], undo_stat[2];
-	uint16 gfxtable, table_dist;
-	uint16 v4_id, next_table;
-
-	ms_hint *hints;
-	byte *hint_contents;
-	picture anim_frame_table[MAX_ANIMS];
-	uint16 pos_table_size;
-	uint16 pos_table_count[MAX_POSITIONS];
-	ms_position pos_table[MAX_POSITIONS][MAX_ANIMS];
-	byte *command_table;
-	int command_index;
-	lookup anim_table[MAX_POSITIONS];
-	int pos_table_index;
-	int pos_table_max;
-	ms_position pos_array[MAX_FRAMES];
-	byte anim_repeat;
-
-
-private:
-	/**
-	 * Validates the game file, and if it's invalid, displays an error dialog
-	 */
-	bool is_gamefile_valid();
-
-	/**
-	 * \defgroup Emu
-	 * @{
-	 */
-
-	/**
-	 * Loads the interpreter with a game
-	 * @return	0 = failure, 1 = success(without graphics or graphics failed),
-	 *		2 = success(with graphics)
-	 */
-	int ms_init(bool restarting = false);
-
-	/**
-	 * Stops further processing of opcodes
-	 */
-	void ms_stop() { running = false; }
-
-	/**
-	 * Detects if game is running
-	 */
-	bool ms_is_running() const { return running; }
-
-	/**
-	 * Returns true if running a Magnetic Windows game
-	 */
-	bool ms_is_magwin() const { return version == 4; }
-
-	/**
-	 * Frees all allocated ressources
-	 */
-	void ms_freemem();
-
-	/**@}*/
-
-	/**
-	 * \defgroup Graphics support methods
-	 * @{
-	 */
-
-	byte init_gfx1(size_t size);
-
-	byte init_gfx2(size_t size);
-
-	/**
-	 * Displays or hides a picture
-	 * @param c			number of image to be displayed
-	 * @param mode		0 = means gfx off, 1 gfx on thumbnails, 2 gfx on normal
-	 *
-	 * @remarks		For retrieving the raw data of a picture call ms_extract
-	 */
-	void ms_showpic(int c, byte mode);
-
-	/**
-	 * Returns true if a given line is blank
-	 */
-	bool is_blank(uint16 line, uint16 width) const;
-
-	byte *ms_extract1(byte pic, uint16 *w, uint16 *h, uint16 *pal);
-
-	int16 find_name_in_header(const Common::String &name, bool upper);
-
-	void extract_frame(const picture *pic);
-
-	byte *ms_extract2(const char *name, uint16 *w, uint16 *h, uint16 *pal, byte *is_anim);
-
-	byte *ms_extract(uint32 pic, uint16 *w, uint16 *h, uint16 *pal, byte *is_anim);
-
-	byte ms_animate(ms_position **positions, uint16 *count);
-
-	byte *ms_get_anim_frame(int16 number, uint16 *width, uint16 *height, byte **mask);
-
-	bool ms_anim_is_repeating() const { return anim_repeat;	}
-
-	void write_reg(int i, int s, uint32 val) {
-		// TODO
-	}
-
-	/**@}*/
-
-	/**
-	 * \defgroup Sound support methods
-	 * @{
-	 */
-
-	byte init_snd(size_t size);
-
-	int16 find_name_in_sndheader(const Common::String &name);
-
-	byte *sound_extract(const Common::String &name, uint32 *length, uint16 *tempo);
-
-	/**@}*/
-public:
 	/**
 	 * Constructor
 	 */
@@ -188,7 +50,9 @@ public:
 	/**
 	 * Returns the running interpreter type
 	 */
-	virtual InterpreterType getInterpreterType() const override { return INTERPRETER_MAGNETIC; }
+	virtual InterpreterType getInterpreterType() const override {
+		return INTERPRETER_MAGNETIC;
+	}
 
 	/**
 	 * Load a savegame from the passed Quetzal file chunk stream
@@ -202,6 +66,8 @@ public:
 	virtual Common::Error writeGameData(Common::WriteStream *ws) override;
 };
 
+extern Magnetic *g_vm;
+
 } // End of namespace Magnetic
 } // End of namespace Glk
 
diff --git a/engines/glk/magnetic/magnetic_types.h b/engines/glk/magnetic/magnetic_types.h
index cfef76557e..5c8cad5077 100644
--- a/engines/glk/magnetic/magnetic_types.h
+++ b/engines/glk/magnetic/magnetic_types.h
@@ -24,6 +24,7 @@
 #define GLK_MAGNETIC_TYPES
 
 #include "common/scummsys.h"
+#include "common/algorithm.h"
 
 namespace Glk {
 namespace Magnetic {
@@ -47,7 +48,7 @@ struct lookup {
 };
 
 struct picture {
-	byte * data;
+	byte *data;
 	uint32 data_size;
 	uint16 width;
 	uint16 height;
@@ -121,7 +122,7 @@ struct ms_position {
 struct ms_hint {
 	uint16 elcount;
 	uint16 nodetype;
-	byte *content;
+	const char *content;
 	uint16 links[MAX_HITEMS];
 	uint16 parent;
 
diff --git a/engines/glk/magnetic/main.cpp b/engines/glk/magnetic/main.cpp
new file mode 100644
index 0000000000..1f0128f36c
--- /dev/null
+++ b/engines/glk/magnetic/main.cpp
@@ -0,0 +1,176 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/magnetic/defs.h"
+#include "common/file.h"
+#include "common/savefile.h"
+#include "common/system.h"
+
+namespace Glk {
+namespace Magnetic {
+
+#define WIDTH 78
+
+static type8 buffer[80], xpos = 0, bufpos = 0, log_on = 0, ms_gfx_enabled, filename[256];
+static Common::DumpFile *log1 = 0, *log2 = 0;
+
+type8 ms_load_file(const char *name, type8 *ptr, type16 size) {
+	assert(name);
+	Common::InSaveFile *file = g_system->getSavefileManager()->openForLoading(name);
+	if (!file)
+		return 1;
+
+	if (file->read(ptr, size) != size) {
+		delete file;
+		return 1;
+	}
+
+	delete file;
+	return 0;
+}
+
+type8 ms_save_file(const char *name, type8 *ptr, type16 size) {
+	assert(name);
+	Common::OutSaveFile *file = g_system->getSavefileManager()->openForSaving(name);
+	if (!file)
+		return 1;
+
+	if (file->write(ptr, size) != size) {
+		delete file;
+		return 1;
+	}
+
+	file->finalize();
+	delete file;
+	return 0;
+}
+
+void script_write(type8 c) {
+	if (log_on == 2)
+		log1->writeByte(c);
+}
+
+void transcript_write(type8 c) {
+	if (log2)
+		log2->writeByte(c);
+}
+
+void ms_fatal(const char *txt) {
+	error("Fatal error: %s", txt);
+}
+
+#if 0
+main(int argc, char **argv) {
+	type8 running, i, *gamename = 0, *gfxname = 0, *hintname = 0;
+	type32 dlimit, slimit;
+
+	if (sizeof(type8) != 1 || sizeof(type16) != 2 || sizeof(type32) != 4) {
+		fprintf(stderr,
+		        "You have incorrect typesizes, please edit the typedefs and recompile\n"
+		        "or proceed on your own risk...\n");
+		exit(1);
+	}
+	dlimit = slimit = 0xffffffff;
+	for (i = 1; i < argc; i++) {
+		if (argv[i][0] == '-') {
+			switch (tolower(argv[i][1])) {
+			case 'd':
+				if (strlen(argv[i]) > 2)
+					dlimit = atoi(&argv[i][2]);
+				else
+					dlimit = 0;
+				break;
+			case 's':
+				if (strlen(argv[i]) > 2)
+					slimit = atoi(&argv[i][2]);
+				else
+					slimit = 655360;
+				break;
+			case 't':
+				if (!(log2 = fopen(&argv[i][2], "w")))
+					printf("Failed to open \"%s\" for writing.\n", &argv[i][2]);
+				break;
+			case 'r':
+				if (log1 = fopen(&argv[i][2], "r"))
+					log_on = 1;
+				else
+					printf("Failed to open \"%s\" for reading.\n", &argv[i][2]);
+				break;
+			case 'w':
+				if (log1 = fopen(&argv[i][2], "w"))
+					log_on = 2;
+				else
+					printf("Failed to open \"%s\" for writing.\n", &argv[i][2]);
+				break;
+			default:
+				printf("Unknown option -%c, ignoring.\n", argv[i][1]);
+				break;
+			}
+		} else if (!gamename)
+			gamename = argv[i];
+		else if (!gfxname)
+			gfxname = argv[i];
+		else if (!hintname)
+			hintname = argv[i];
+	}
+	if (!gamename) {
+		printf("Magnetic 2.3 - a Magnetic Scrolls interpreter\n\n");
+		printf("Usage: %s [options] game [gfxfile] [hintfile]\n\n"
+		       "Where the options are:\n"
+		       " -dn    activate register dump (after n instructions)\n"
+		       " -rname read script file\n"
+		       " -sn    safety mode, exits automatically (after n instructions)\n"
+		       " -tname write transcript file\n"
+		       " -wname write script file\n\n"
+		       "The interpreter commands are:\n"
+		       " #undo   undo - don't use it near are_you_sure prompts\n"
+		       " #logoff turn off script writing\n\n", argv[0]);
+		exit(1);
+	}
+
+	if (!(ms_gfx_enabled = ms_init(gamename, gfxname, hintname, 0))) {
+		printf("Couldn't start up game \"%s\".\n", gamename);
+		exit(1);
+	}
+	ms_gfx_enabled--;
+	running = 1;
+	while ((ms_count() < slimit) && running) {
+		if (ms_count() >= dlimit)
+			ms_status();
+		running = ms_rungame();
+	}
+	if (ms_count() == slimit) {
+		printf("\n\nSafety limit (%d) reached.\n", slimit);
+		ms_status();
+	}
+	ms_freemem();
+	if (log_on)
+		fclose(log1);
+	if (log2)
+		fclose(log2);
+	printf("\nExiting.\n");
+	return 0;
+}
+#endif
+
+} // End of namespace Magnetic
+} // End of namespace Glk
diff --git a/engines/glk/magnetic/myth.cpp b/engines/glk/magnetic/myth.cpp
new file mode 100644
index 0000000000..3f8127e613
--- /dev/null
+++ b/engines/glk/magnetic/myth.cpp
@@ -0,0 +1,133 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ * Patches Myth C64 disk image
+ * Written by David Kinder, based on code by Niclas Karlsson
+ */
+
+#define D64_SIZE (174848L)
+unsigned char image[D64_SIZE];
+
+void ungarble(unsigned char *block, signed long key) {
+	unsigned char d;
+	int i, j;
+
+	d = (unsigned char)((key & 0x07) ^ 0xFF);
+	if (d < 0xFF) {
+		i = d;
+		j = d + 1;
+		while (j < 0x100)
+			block[j++] ^= block[i];
+	}
+
+	i = 0xFF;
+	j = d - 1;
+	while (j >= 0)
+		block[j--] ^= block[i--];
+
+	for (i = 0; i < 128; i++) {
+		d = block[i];
+		block[i] = block[255 - i];
+		block[255 - i] = d;
+	}
+}
+
+void garble(unsigned char *block, int i1, int j1, int i2) {
+	unsigned char d;
+	int i, j;
+
+	for (i = 0; i < 128; i++) {
+		d = block[i];
+		block[i] = block[255 - i];
+		block[255 - i] = d;
+	}
+
+	i = i1;
+	j = -1;
+	while (j < j1)
+		block[++j] ^= block[++i];
+
+	i = i2;
+	j = 0x100;
+	while (j > i2 + 1)
+		block[--j] ^= block[i];
+}
+
+/* This routine does the patching. */
+void fixDiskImage(int code) {
+	unsigned char *block = NULL;
+
+	switch (code) {
+	case 0:
+		/* code[0x3056] = 0x60 */
+		block = image + 0x1600;
+		ungarble(block, 0x27L);
+		block[0x56] = 0x60;
+		garble(block, 0x07, 0xF7, 0xF8);
+		break;
+	case 1:
+		/* code[0x3148] = 0x60 */
+		/* code[0x314D] = 0x11 */
+		block = image + 0x1700;
+		ungarble(block, 0x28L);
+		block[0x48] = 0x60;
+		block[0x4D] = 0x11;
+		garble(block, 0x00, 0xFE, 0xFF);
+		break;
+	}
+}
+
+void readDiskImage(const char *filename) {
+	FILE *file = fopen(filename, "r+b");
+	if (file == NULL)
+		exit(1);
+	fread(image, 1, D64_SIZE, file);
+}
+
+void writeDiskImage(const char *filename) {
+	FILE *file = fopen(filename, "w+b");
+	if (file == NULL)
+		exit(1);
+	fwrite(image, 1, D64_SIZE, file);
+}
+
+int main(int argc, char **argv) {
+	if (argc == 4) {
+		int code = -1;
+		if (sscanf(argv[3], "%d", &code) == 1) {
+			if ((code >= 0) && (code <= 1)) {
+				readDiskImage(argv[1]);
+				fixDiskImage(code);
+				writeDiskImage(argv[2]);
+				printf("Myth patched.\n");
+				return 0;
+			}
+		}
+	}
+
+	printf("Removes password protection from Magnetic Scrolls' Myth.\n");
+	printf("Use: myth input.d64 output.d64 code\n");
+	printf("If code is 0, the password protection is completely removed.\n");
+	printf("If code is 1, any user name and password will be accepted.\n");
+	return 0;
+}
diff --git a/engines/glk/magnetic/sound.cpp b/engines/glk/magnetic/sound.cpp
deleted file mode 100644
index 3ea74fb8fe..0000000000
--- a/engines/glk/magnetic/sound.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- */
-
-#include "glk/magnetic/magnetic.h"
-
-namespace Glk {
-namespace Magnetic {
-
-byte Magnetic::init_snd(size_t size) {
-	if (!(snd_buf = new byte[MAX_MUSIC_SIZE])) {
-		return 1;
-	}
-
-	snd_hsize = _sndFile.readUint16LE();
-	if (!(snd_hdr = new byte[snd_hsize])) {
-		delete[] snd_buf;
-		snd_buf = nullptr;
-		return 1;
-	}
-
-	if (_sndFile.read(snd_hdr, snd_hsize) != snd_hsize) {
-		delete[] snd_buf;
-		delete[] snd_hdr;
-		snd_buf = nullptr;
-		snd_hdr = nullptr;
-		return 1;
-	}
-
-	return 2;
-}
-
-int16 Magnetic::find_name_in_sndheader(const Common::String &name) {
-	int16 header_pos = 0;
-
-	while (header_pos < snd_hsize) {
-		const char *hname = (const char *)(snd_hdr + header_pos);
-		if (name == hname)
-			return header_pos;
-		header_pos += 18;
-	}
-
-	return -1;
-}
-
-byte *Magnetic::sound_extract(const Common::String &name, uint32 *length, uint16 *tempo) {
-	uint32 offset = 0;
-	int16 header_pos = -1;
-
-	if (header_pos < 0)
-		header_pos = find_name_in_sndheader(name);
-	if (header_pos < 0)
-		return 0;
-
-	*tempo = READ_BE_UINT16(snd_hdr + header_pos + 8);
-	offset = READ_BE_UINT32(snd_hdr + header_pos + 10);
-	*length = READ_BE_UINT32(snd_hdr + header_pos + 14);
-
-	if (offset != 0) {
-		if (!snd_buf)
-			return nullptr;
-		if (!_sndFile.seek(offset))
-			return nullptr;
-		if (_sndFile.read(snd_buf, *length) != *length)
-			return nullptr;
-
-		return snd_buf;
-	}
-
-	return nullptr;
-}
-
-} // End of namespace Magnetic
-} // End of namespace Glk
diff --git a/engines/glk/module.mk b/engines/glk/module.mk
index 8c1daeeb13..7c6308fd06 100644
--- a/engines/glk/module.mk
+++ b/engines/glk/module.mk
@@ -262,9 +262,9 @@ ifdef ENABLE_GLK_MAGNETIC
 MODULE_OBJS += \
 	magnetic/detection.o \
 	magnetic/emu.o \
-	magnetic/graphics.o \
+	magnetic/glk.o \
 	magnetic/magnetic.o \
-	magnetic/sound.o
+	magnetic/main.o
 endif
 
 ifdef ENABLE_GLK_QUEST