260 files changed, 147263 insertions, 0 deletions

diff --git a/apps/plugins/CATEGORIES b/apps/plugins/CATEGORIES
index 28248802b7..4b1b8d635c 100644
--- a/apps/plugins/CATEGORIES
+++ b/apps/plugins/CATEGORIES
@@ -78,6 +78,7 @@ gif,viewers
 pong,games
 ppm,viewers
 properties,viewers
+puzzles,games
 random_folder_advance_config,apps
 remote_control,apps
 resistor,apps
@@ -92,6 +93,45 @@ rockpaint,apps
 search,viewers
 searchengine,viewers
 settings_dumper,apps
+sgt-blackbox,games
+sgt-bridges,games
+sgt-cube,games
+sgt-dominosa,games
+sgt-fifteen,games
+sgt-filling,games
+sgt-flip,games
+sgt-flood,games
+sgt-galaxies,games
+sgt-guess,games
+sgt-inertia,games
+sgt-keen,games
+sgt-lightup,games
+sgt-loopy,games
+sgt-magnets,games
+sgt-map,games
+sgt-mines,games
+sgt-net,games
+sgt-netslide,games
+sgt-palisade,games
+sgt-pattern,games
+sgt-pearl,games
+sgt-pegs,games
+sgt-range,games
+sgt-rect,games
+sgt-samegame,games
+sgt-signpost,games
+sgt-singles,games
+sgt-sixteen,games
+sgt-slant,games
+sgt-solo,games
+sgt-tents,games
+sgt-towers,games
+sgt-tracks,games
+sgt-twiddle,games
+sgt-undead,games
+sgt-unequal,games
+sgt-unruly,games
+sgt-untangle,games
 shopper,viewers
 shortcuts_append,viewers
 shortcuts_view,viewers
diff --git a/apps/plugins/SOURCES b/apps/plugins/SOURCES
index c7a8cb69f7..98e727dbd4 100644
--- a/apps/plugins/SOURCES
+++ b/apps/plugins/SOURCES
@@ -73,6 +73,10 @@ iriverify.c
 #if (CONFIG_PLATFORM & PLATFORM_NATIVE) /* those plugins only run on hardware */
 
 /* Overlays loaders */
+
+/* use this if you want a monolithic 'puzzles' */
+/*sgt-puzzles.c*/
+
 #if PLUGIN_BUFFER_SIZE <= 0x20000 && defined(HAVE_LCD_BITMAP)
 
 #if CONFIG_KEYPAD != ONDIO_PAD && CONFIG_KEYPAD != SANSA_M200_PAD \
diff --git a/apps/plugins/SUBDIRS b/apps/plugins/SUBDIRS
index d02073e29d..56ac665e40 100644
--- a/apps/plugins/SUBDIRS
+++ b/apps/plugins/SUBDIRS
@@ -16,6 +16,7 @@ clock
 #if defined(HAVE_LCD_COLOR) && \
     (!defined(LCD_STRIDEFORMAT) || (LCD_STRIDEFORMAT != VERTICAL_STRIDE))
 xworld
+puzzles
 #endif
 
 #if    (CONFIG_KEYPAD != ONDIO_PAD) /* not enough buttons */ \
diff --git a/apps/plugins/puzzles/Buildscr b/apps/plugins/puzzles/Buildscr
new file mode 100644
index 0000000000..910981f079
--- /dev/null
+++ b/apps/plugins/puzzles/Buildscr
@@ -0,0 +1,194 @@
+# -*- sh -*-
+# Build script to build Puzzles.
+
+module puzzles
+
+set Version $(!builddate).$(vcsid)
+
+# Start by substituting the right version number in configure.ac.
+in puzzles do perl -i~ -pe 's/6.66/$(Version)/' configure.ac
+in puzzles do rm configure.ac~
+
+# And put it into the documentation as a versionid.
+# use perl to avoid inconsistent behaviour of echo '\v'
+in puzzles do perl -e 'print "\n\\versionid Simon Tatham'\''s Portable Puzzle Collection, version $$ARGV[0]\n"' $(Version) >> puzzles.but
+in puzzles do perl -e 'print "\n\\versionid Simon Tatham'\''s Portable Puzzle Collection, version $$ARGV[0]\n"' $(Version) >> devel.but
+
+# Write out a version.h that contains the real version number.
+in puzzles do echo '/* Generated by automated build script */' > version.h
+in puzzles do echo '$#define VER "Version $(Version)"' >> version.h
+
+# And do the same substitution in the OS X metadata. (This is a bit
+# icky in principle because it presumes that my version numbers don't
+# need XML escaping, but frankly, if they ever do then I should fix
+# them!)
+in puzzles do perl -i -pe 's/Unidentified build/$(Version)/' osx-info.plist
+
+# First build some local binaries, to run the icon build.
+in puzzles do perl mkfiles.pl -U
+in puzzles do make
+
+# Now build the screenshots and icons.
+in puzzles/icons do xvfb-run -s "-screen 0 1024x768x24" make web winicons gtkicons
+
+# Destroy the local binaries and autoconf detritus, mostly to avoid
+# wasting network bandwidth by transferring them to the delegate
+# servers.
+in puzzles do make distclean
+
+# Re-run mkfiles.pl now that it knows the icons are there.
+in puzzles do perl mkfiles.pl
+
+# Rebuild the configure script.
+in puzzles do ./mkauto.sh
+
+# Build the OS X .dmg archive.
+delegate osx
+  in puzzles do make -f Makefile.osx clean
+  in puzzles do make -f Makefile.osx release VER=-DVER=$(Version)
+  return puzzles/Puzzles.dmg
+enddelegate
+
+# Build the Windows binaries and installer, and the CHM file.
+in puzzles do make -f Makefile.doc clean
+in puzzles do make -f Makefile.doc chm
+in puzzles do make -f Makefile.doc # build help file for installer
+in puzzles do mason.pl --args '{"version":"$(Version)","descfile":"gamedesc.txt"}' winwix.mc > puzzles.wxs
+in puzzles do perl winiss.pl $(Version) gamedesc.txt > puzzles.iss
+delegate windows
+  # Ignore the poorly controlled return value from HHC, and instead
+  # just test that the output file was generated.
+  in puzzles with htmlhelp do/win hhc puzzles.hhp & type puzzles.chm >nul
+  # FIXME: Cygwin alternative?
+  in puzzles with visualstudio do/win nmake -f Makefile.vc clean
+  in puzzles with visualstudio do/win nmake -f Makefile.vc VER=-DVER=$(Version)
+  # Code-sign the binaries, if the local bob config provides a script
+  # to do so. We assume here that the script accepts an -i option to
+  # provide a 'more info' URL, and an optional -n option to provide a
+  # program name, and that it can take multiple .exe filename
+  # arguments and sign them all in place.
+  ifneq "$(winsigncode)" "" in puzzles do $(winsigncode) -i http://www.chiark.greenend.org.uk/~sgtatham/puzzles/ *.exe
+  # Build installers.
+  in puzzles with wix do/win candle puzzles.wxs && light -ext WixUIExtension -sval puzzles.wixobj
+  in puzzles with innosetup do/win iscc puzzles.iss
+  ifneq "$(winsigncode)" "" in puzzles do $(winsigncode) -i http://www.chiark.greenend.org.uk/~sgtatham/puzzles/ -n "Simon Tatham's Portable Puzzle Collection Installer" puzzles.msi Output/installer.exe
+  return puzzles/puzzles.chm
+  return puzzles/*.exe
+  return puzzles/Output/installer.exe
+  return puzzles/puzzles.msi
+enddelegate
+in puzzles do chmod +x *.exe
+
+# Build the Pocket PC binaries and CAB.
+#
+# NOTE: This part of the build script requires the Windows delegate
+# server to have the cabwiz program on its PATH. This will
+# typically be at
+#
+#   C:\Program Files\Windows CE Tools\WCE420\POCKET PC 2003\Tools
+#
+# but it might not be if you've installed it somewhere else, or
+# have a different version.
+#
+# NOTE ALSO: This part of the build is commented out, for the
+# moment, because cabwiz does unhelpful things when run from within
+# a bob delegate process (or, more generally, when run from any
+# terminal-based remote login to a Windows machine, including
+# Cygwin opensshd and Windows Telnet). The symptom is that cabwiz
+# just beeps and sits there. Until I figure out how to build the
+# .cab from an automated process (and I'm willing to consider silly
+# approaches such as a third-party CAB generator), I don't think I
+# can sensibly enable this build.
+
+#in puzzles do perl wceinf.pl gamedesc.txt > puzzles.inf
+#delegate windows
+#  in puzzles do cmd /c 'wcearmv4 & nmake -f Makefile.wce clean'
+#  in puzzles do cmd /c 'wcearmv4 & nmake -f Makefile.wce VER=-DVER=$(Version)'
+#  # Nasty piece of sh here which saves the return code from cabwiz,
+#  # outputs its errors and/or warnings, and then propagates the
+#  # return code back to bob. If only cabwiz could output to
+#  # standard error LIKE EVERY OTHER COMMAND-LINE UTILITY IN THE
+#  # WORLD, I wouldn't have to do this.
+#  in puzzles do cat puzzles.inf
+#  in puzzles do cmd /c 'wcearmv4 & bash -c cabwiz puzzles.inf /err cabwiz.err /cpu ARMV4'; a=$$?; cat cabwiz.err; exit $$a
+#  return puzzles/puzzles.armv4.cab
+#enddelegate
+
+# Build the help file and the HTML docs.
+in puzzles do make -f Makefile.doc clean # remove CHM-target HTML
+in puzzles do make -f Makefile.doc # and rebuild help file...
+in puzzles do mkdir doc
+in puzzles do mkdir devel
+in puzzles/doc do halibut --html -Chtml-contents-filename:index.html -Chtml-index-filename:indexpage.html -Chtml-template-filename:%k.html -Chtml-template-fragment:%k ../puzzles.but
+in puzzles/devel do halibut --html -Chtml-contents-filename:index.html -Chtml-index-filename:indexpage.html -Chtml-template-filename:%k.html -Chtml-template-fragment:%k ../devel.but
+
+# Move the deliver-worthy Windows binaries (those specified in
+# gamedesc.txt, which is generated by mkfiles.pl and helpfully
+# excludes the command-line auxiliary utilities such as solosolver,
+# and nullgame.exe) into a subdirectory for easy access.
+in puzzles do mkdir winbin
+in puzzles do mv `cut -f2 -d: gamedesc.txt` winbin
+
+# Make a zip file of the Windows binaries and help files.
+in puzzles do zip -j puzzles.zip winbin/*.exe puzzles.chm puzzles.hlp puzzles.cnt
+
+# Create the source archive. (That writes the archive into the
+# _parent_ directory, so be careful when we deliver it.)
+in puzzles do ./makedist.sh $(Version)
+
+# Build the autogenerated pieces of the main web page.
+in puzzles do perl webpage.pl
+
+ifneq "$(JAVA_UNFINISHED)" "" in puzzles do perl -i~ -pe 'print "!srcdir unfinished/\n" if /!srcdir icons/' Recipe
+ifneq "$(JAVA_UNFINISHED)" "" in puzzles do ln -s unfinished/group.R .
+ifneq "$(JAVA_UNFINISHED)" "" in puzzles do perl mkfiles.pl
+
+# Build the Java applets.
+delegate nestedvm
+  in puzzles do make -f Makefile.nestedvm NESTEDVM="$$NESTEDVM" VER=-DVER=$(Version)
+  return puzzles/*.jar
+enddelegate
+
+# Build the Javascript applets. Since my master build machine doesn't
+# have the right dependencies installed for Emscripten, I do this by a
+# delegation.
+in puzzles do mkdir js # so we can tell output .js files from emcc*.js
+delegate emscripten
+  in puzzles do make -f Makefile.emcc OUTPREFIX=js/ clean
+  in puzzles do make -f Makefile.emcc OUTPREFIX=js/
+  return puzzles/js/*.js
+enddelegate
+
+# Set up .htaccess containing a redirect for the archive filename.
+in puzzles do echo "AddType application/octet-stream .chm" > .htaccess
+in puzzles do echo "AddType application/octet-stream .hlp" >> .htaccess
+in puzzles do echo "AddType application/octet-stream .cnt" >> .htaccess
+in . do set -- puzzles*.tar.gz; echo RedirectMatch temp '(.*/)'puzzles.tar.gz '$$1'"$$1" >> puzzles/.htaccess
+in puzzles do echo RedirectMatch temp '(.*/)'puzzles-installer.msi '$$1'puzzles-$(Version)-installer.msi >> .htaccess
+in puzzles do echo RedirectMatch temp '(.*/)'puzzles-installer.exe '$$1'puzzles-$(Version)-installer.exe >> .htaccess
+
+# Phew, we're done. Deliver everything!
+deliver puzzles/icons/*-web.png $@
+deliver puzzles/winbin/*.exe $@
+deliver puzzles/.htaccess $@
+deliver puzzles/doc/*.html doc/$@
+deliver puzzles/devel/*.html devel/$@
+deliver puzzles/Puzzles.dmg $@
+deliver puzzles/puzzles.chm $@
+deliver puzzles/puzzles.hlp $@
+deliver puzzles/puzzles.cnt $@
+deliver puzzles/puzzles.zip $@
+deliver puzzles/puzzles.msi puzzles-$(Version)-installer.msi
+deliver puzzles/Output/installer.exe puzzles-$(Version)-installer.exe
+deliver puzzles/*.jar java/$@
+deliver puzzles/js/*.js js/$@
+deliver puzzles/html/*.html html/$@
+deliver puzzles/html/*.pl html/$@
+deliver puzzles/wwwspans.html $@
+deliver puzzles/wwwlinks.html $@
+
+# deliver puzzles/puzzles.armv4.cab $@ # (not built at the moment)
+
+# This one isn't in the puzzles subdir, because makedist.sh left it
+# one level up.
+deliver puzzles*.tar.gz $@
diff --git a/apps/plugins/puzzles/CHECKLST.txt b/apps/plugins/puzzles/CHECKLST.txt
new file mode 100644
index 0000000000..2bef909e14
--- /dev/null
+++ b/apps/plugins/puzzles/CHECKLST.txt
@@ -0,0 +1,70 @@
+Useful checklists
+=================
+
+Things to remember when adding a new puzzle
+-------------------------------------------
+
+Write the source file for the new puzzle (duhh).
+
+Create a .R file for it which:
+ - defines a <puzzle>_EXTRA symbol for it if it requires auxiliary
+   object files (make sure that symbol doesn't contain the icon)
+ - adds it to the `ALL' definition, to ensure it is compiled into
+   the OS X binary
+ - adds it as a GTK build target, with the optional GTK icon
+ - adds it as a Windows build target, with the optional resource
+   file
+ - adds auxiliary solver binaries if any
+ - adds it to $(GAMES) in both the automake and GTK makefiles, for
+   `make install'
+ - adds it to list.c for the OS X binary
+ - adds it to gamedesc.txt, with its Windows executable name, display
+   name, and slightly longer description.
+
+If the puzzle is by a new author, modify the copyright notice in
+LICENCE and in puzzles.but. (Also in index.html, but that's listed
+below under website changes.)
+
+Double-check that the game structure name in the source file has
+been renamed from `nullgame', so that it'll work on OS X. Actually
+compiling it on OS X would be a good way to check this, if
+convenient.
+
+Add a documentation section in puzzles.but.
+
+Make sure there's a Windows help topic name defined in puzzles.but,
+and that it's referenced by the help topic field in the game
+structure in the source file.
+
+Check that REQUIRE_RBUTTON and/or REQUIRE_NUMPAD are set as
+appropriate.
+
+Add the new Unix binary name, and the names of any auxiliary solver
+binaries, to .gitignore.
+
+Write an instructions fragment for the webified puzzle pages, as
+html/<puzzlename>.html .
+
+Make a screenshot:
+ - create an appropriate save file in `icons'
+ - add the puzzle name to icons/Makefile
+ - set up a REDO property in icons/Makefile if the screenshot wants
+   to display a move halfway through an animation
+ - set up a CROP property in icons/Makefile if the icon wants to be
+   a sub-rectangle of the whole screenshot
+
+Don't forget to `git add' the new source file, the new .R file and the
+save file in `icons', the new .html file, and any other new files that
+might have been involved.
+
+Check in!
+
+Put the puzzle on the web:
+ - run puzzlesnap.sh
+ - adjust the copyright in index-mid.html if the puzzle is by a new
+   author
+ - check that the new puzzle has appeared on the staging web page
+ - test both Windows binary links, the docs link, the Javascript
+   version and the Java version
+ - run webupdate
+ - test all those things once more on the live website
diff --git a/apps/plugins/puzzles/LICENCE b/apps/plugins/puzzles/LICENCE
new file mode 100644
index 0000000000..4235005ea7
--- /dev/null
+++ b/apps/plugins/puzzles/LICENCE
@@ -0,0 +1,25 @@
+This software is copyright (c) 2004-2014 Simon Tatham.
+
+Portions copyright Richard Boulton, James Harvey, Mike Pinna, Jonas
+Kölker, Dariusz Olszewski, Michael Schierl, Lambros Lambrou, Bernd
+Schmidt, Steffen Bauer, Lennard Sprong and Rogier Goossens.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation files
+(the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/apps/plugins/puzzles/PuzzleApplet.java b/apps/plugins/puzzles/PuzzleApplet.java
new file mode 100644
index 0000000000..0b0648ce9b
--- /dev/null
+++ b/apps/plugins/puzzles/PuzzleApplet.java
@@ -0,0 +1,617 @@
+/*
+ * PuzzleApplet.java: NestedVM applet for the puzzle collection
+ */
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.BufferedImage;
+import java.util.*;
+import javax.swing.*;
+import javax.swing.border.BevelBorder;
+import javax.swing.Timer;
+import java.util.List;
+
+import org.ibex.nestedvm.Runtime;
+
+public class PuzzleApplet extends JApplet implements Runtime.CallJavaCB {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final int CFG_SETTINGS = 0, CFG_SEED = 1, CFG_DESC = 2,
+            LEFT_BUTTON = 0x0200, MIDDLE_BUTTON = 0x201, RIGHT_BUTTON = 0x202,
+            LEFT_DRAG = 0x203, MIDDLE_DRAG = 0x204, RIGHT_DRAG = 0x205,
+            LEFT_RELEASE = 0x206, CURSOR_UP = 0x209, CURSOR_DOWN = 0x20a,
+            CURSOR_LEFT = 0x20b, CURSOR_RIGHT = 0x20c, MOD_CTRL = 0x1000,
+            MOD_SHFT = 0x2000, MOD_NUM_KEYPAD = 0x4000, ALIGN_VCENTRE = 0x100,
+            ALIGN_HCENTRE = 0x001, ALIGN_HRIGHT = 0x002, C_STRING = 0,
+            C_CHOICES = 1, C_BOOLEAN = 2;
+
+    private JFrame mainWindow;
+
+    private JMenu typeMenu;
+    private JMenuItem solveCommand;
+    private Color[] colors;
+    private JLabel statusBar;
+    private PuzzlePanel pp;
+    private Runtime runtime;
+    private String[] puzzle_args;
+    private Graphics2D  gg;
+    private Timer timer;
+    private int xarg1, xarg2, xarg3;
+    private int[] xPoints, yPoints;
+    private BufferedImage[] blitters = new BufferedImage[512];
+    private ConfigDialog dlg;
+
+    static {
+        try {
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    public void init() {
+        try {
+            Container cp = getContentPane();
+            cp.setLayout(new BorderLayout());
+            runtime = (Runtime) Class.forName("PuzzleEngine").newInstance();
+            runtime.setCallJavaCB(this);
+            JMenuBar menubar = new JMenuBar();
+            JMenu jm;
+            menubar.add(jm = new JMenu("Game"));
+            addMenuItemWithKey(jm, "New", 'n');
+            addMenuItemCallback(jm, "Restart", "jcallback_restart_event");
+            addMenuItemCallback(jm, "Specific...", "jcallback_config_event", CFG_DESC);
+            addMenuItemCallback(jm, "Random Seed...", "jcallback_config_event", CFG_SEED);
+            jm.addSeparator();
+            addMenuItemWithKey(jm, "Undo", 'u');
+            addMenuItemWithKey(jm, "Redo", 'r');
+            jm.addSeparator();
+            solveCommand = addMenuItemCallback(jm, "Solve", "jcallback_solve_event");
+            solveCommand.setEnabled(false);
+            if (mainWindow != null) {
+                jm.addSeparator();
+                addMenuItemWithKey(jm, "Exit", 'q');
+            }
+            menubar.add(typeMenu = new JMenu("Type"));
+            typeMenu.setVisible(false);
+            menubar.add(jm = new JMenu("Help"));
+            addMenuItemCallback(jm, "About", "jcallback_about_event");
+            setJMenuBar(menubar);
+            cp.add(pp = new PuzzlePanel(), BorderLayout.CENTER);
+            pp.addKeyListener(new KeyAdapter() {
+                public void keyPressed(KeyEvent e) {
+                    int key = -1;
+                    int shift = e.isShiftDown() ? MOD_SHFT : 0;
+                    int ctrl = e.isControlDown() ? MOD_CTRL : 0;
+                    switch (e.getKeyCode()) {
+                    case KeyEvent.VK_LEFT:
+                    case KeyEvent.VK_KP_LEFT:
+                        key = shift | ctrl | CURSOR_LEFT;
+                        break;
+                    case KeyEvent.VK_RIGHT:
+                    case KeyEvent.VK_KP_RIGHT:
+                        key = shift | ctrl | CURSOR_RIGHT;
+                        break;
+                    case KeyEvent.VK_UP:
+                    case KeyEvent.VK_KP_UP:
+                        key = shift | ctrl | CURSOR_UP;
+                        break;
+                    case KeyEvent.VK_DOWN:
+                    case KeyEvent.VK_KP_DOWN:
+                        key = shift | ctrl | CURSOR_DOWN;
+                        break;
+                    case KeyEvent.VK_PAGE_UP:
+                        key = shift | ctrl | MOD_NUM_KEYPAD | '9';
+                        break;
+                    case KeyEvent.VK_PAGE_DOWN:
+                        key = shift | ctrl | MOD_NUM_KEYPAD | '3';
+                        break;
+                    case KeyEvent.VK_HOME:
+                        key = shift | ctrl | MOD_NUM_KEYPAD | '7';
+                        break;
+                    case KeyEvent.VK_END:
+                        key = shift | ctrl | MOD_NUM_KEYPAD | '1';
+                        break;
+                    default:
+                        if (e.getKeyCode() >= KeyEvent.VK_NUMPAD0 && e.getKeyCode() <=KeyEvent.VK_NUMPAD9) {
+                            key = MOD_NUM_KEYPAD | (e.getKeyCode() - KeyEvent.VK_NUMPAD0+'0');
+                        }
+                    break;
+                    }
+                    if (key != -1) {
+                        runtimeCall("jcallback_key_event", new int[] {0, 0, key});
+                    }
+                }
+                public void keyTyped(KeyEvent e) {
+                    runtimeCall("jcallback_key_event", new int[] {0, 0, e.getKeyChar()});
+                }
+            });
+            pp.addMouseListener(new MouseAdapter() {
+                public void mouseReleased(MouseEvent e) {
+                    mousePressedReleased(e, true);
+                }
+                public void mousePressed(MouseEvent e) {
+                    pp.requestFocus();
+                    mousePressedReleased(e, false);
+                }
+                private void mousePressedReleased(MouseEvent e, boolean released) {
+                    int button;
+                    if ((e.getModifiers() & (InputEvent.BUTTON2_MASK | InputEvent.SHIFT_MASK)) != 0)
+                        button = MIDDLE_BUTTON;
+                    else if ((e.getModifiers() & (InputEvent.BUTTON3_MASK | InputEvent.ALT_MASK)) != 0)
+                        button = RIGHT_BUTTON;
+                    else if ((e.getModifiers() & (InputEvent.BUTTON1_MASK)) != 0)
+                        button = LEFT_BUTTON;
+                    else
+                        return;
+                    if (released)
+                        button += LEFT_RELEASE - LEFT_BUTTON;
+                    runtimeCall("jcallback_key_event", new int[] {e.getX(), e.getY(), button});
+                }
+            });
+            pp.addMouseMotionListener(new MouseMotionAdapter() {
+                public void mouseDragged(MouseEvent e) {
+                    int button;
+                    if ((e.getModifiers() & (InputEvent.BUTTON2_MASK | InputEvent.SHIFT_MASK)) != 0)
+                        button = MIDDLE_DRAG;
+                    else if ((e.getModifiers() & (InputEvent.BUTTON3_MASK | InputEvent.ALT_MASK)) != 0)
+                        button = RIGHT_DRAG;
+                    else
+                        button = LEFT_DRAG;
+                    runtimeCall("jcallback_key_event", new int[] {e.getX(), e.getY(), button});
+                }
+            });
+            pp.addComponentListener(new ComponentAdapter() {
+                public void componentResized(ComponentEvent e) {
+                    handleResized();
+                }
+            });
+            pp.setFocusable(true);
+            pp.requestFocus();
+            timer = new Timer(20, new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    runtimeCall("jcallback_timer_func", new int[0]);
+                }
+            });
+            String gameid;
+            try {
+                gameid = getParameter("game_id");
+            } catch (java.lang.NullPointerException ex) {
+                gameid = null;
+            }
+            if (gameid == null) {
+                puzzle_args = null;
+            } else {
+                puzzle_args = new String[2];
+                puzzle_args[0] = "puzzle";
+                puzzle_args[1] = gameid;
+            }
+            SwingUtilities.invokeLater(new Runnable() {
+                public void run() {
+                    runtime.start(puzzle_args);
+                    runtime.execute();
+                }
+            });
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    public void destroy() {
+        SwingUtilities.invokeLater(new Runnable() {
+            public void run() {
+                runtime.execute();
+                if (mainWindow != null) {
+                    mainWindow.dispose();
+                    System.exit(0);
+                }
+            }
+        });
+    }
+
+    protected void handleResized() {
+        pp.createBackBuffer(pp.getWidth(), pp.getHeight(), colors[0]);
+        runtimeCall("jcallback_resize", new int[] {pp.getWidth(), pp.getHeight()});
+    }
+
+    private void addMenuItemWithKey(JMenu jm, String name, int key) {
+        addMenuItemCallback(jm, name, "jcallback_menu_key_event", key);
+    }
+
+    private JMenuItem addMenuItemCallback(JMenu jm, String name, final String callback, final int arg) {
+        return addMenuItemCallback(jm, name, callback, new int[] {arg});
+    }
+
+    private JMenuItem addMenuItemCallback(JMenu jm, String name, final String callback) {
+        return addMenuItemCallback(jm, name, callback, new int[0]);
+    }
+
+    private JMenuItem addMenuItemCallback(JMenu jm, String name, final String callback, final int[] args) {
+        JMenuItem jmi;
+        if (jm == typeMenu)
+            typeMenu.add(jmi = new JCheckBoxMenuItem(name));
+        else
+        jm.add(jmi = new JMenuItem(name));
+        jmi.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                runtimeCall(callback, args);
+            }
+        });
+        return jmi;
+    }
+
+    protected void runtimeCall(String func, int[] args) {
+        if (runtimeCallWithResult(func, args) == 42 && mainWindow != null) {
+            destroy();
+        }
+    }
+
+    protected int runtimeCallWithResult(String func, int[] args) {
+        try {
+            return runtime.call(func, args);
+        } catch (Runtime.CallException ex) {
+            ex.printStackTrace();
+            return 42;
+        }
+    }
+
+    private void buildConfigureMenuItem() {
+        if (typeMenu.isVisible()) {
+            typeMenu.addSeparator();
+        } else {
+            typeMenu.setVisible(true);
+        }
+        addMenuItemCallback(typeMenu, "Custom...", "jcallback_config_event", CFG_SETTINGS);
+    }
+
+    private void addTypeItem(String name, final int ptrGameParams) {
+        typeMenu.setVisible(true);
+        addMenuItemCallback(typeMenu, name, "jcallback_preset_event", ptrGameParams);
+    }
+
+    public int call(int cmd, int arg1, int arg2, int arg3) {
+        try {
+            switch(cmd) {
+            case 0: // initialize
+                if (mainWindow != null) mainWindow.setTitle(runtime.cstring(arg1));
+                if ((arg2 & 1) != 0) buildConfigureMenuItem();
+                if ((arg2 & 2) != 0) addStatusBar();
+                if ((arg2 & 4) != 0) solveCommand.setEnabled(true);
+                colors = new Color[arg3];
+                return 0;
+            case 1: // Type menu item
+                addTypeItem(runtime.cstring(arg1), arg2);
+                return 0;
+            case 2: // MessageBox
+                JOptionPane.showMessageDialog(this, runtime.cstring(arg2), runtime.cstring(arg1), arg3 == 0 ? JOptionPane.INFORMATION_MESSAGE : JOptionPane.ERROR_MESSAGE);
+                return 0;
+            case 3: // Resize
+                pp.setPreferredSize(new Dimension(arg1, arg2));
+                if (mainWindow != null) mainWindow.pack();
+                handleResized();
+                if (mainWindow != null) mainWindow.setVisible(true);
+                return 0;
+            case 4: // drawing tasks
+                switch(arg1) {
+                case 0:
+                    String text = runtime.cstring(arg2);
+                    if (text.equals("")) text = " ";
+                    statusBar.setText(text);
+                    break;
+                case 1:
+                    gg = pp.backBuffer.createGraphics();
+                    if (arg2 != 0 || arg3 != 0 ||
+                        arg2 + xarg2 != getWidth() ||
+                        arg3 + xarg3 != getHeight()) {
+                        int left = arg2, right = arg2 + xarg2;
+                        int top = arg3, bottom = arg3 + xarg3;
+                        int width = getWidth(), height = getHeight();
+                        gg.setColor(colors != null ? colors[0] : Color.black);
+                        gg.fillRect(0, 0, left, height);
+                        gg.fillRect(right, 0, width-right, height);
+                        gg.fillRect(0, 0, width, top);
+                        gg.fillRect(0, bottom, width, height-bottom);
+                        gg.setClip(left, top, right-left, bottom-top);
+                    }
+                    break;
+                case 2: gg.dispose(); pp.repaint(); break;
+                case 3: gg.setClip(arg2, arg3, xarg1, xarg2); break;
+                case 4:
+                    if (arg2 == 0 && arg3 == 0) {
+                        gg.setClip(0, 0, getWidth(), getHeight());
+                    } else {
+                        gg.setClip(arg2, arg3, getWidth()-2*arg2, getHeight()-2*arg3);
+                    }
+                    break;
+                case 5:
+                    gg.setColor(colors[xarg3]);
+                    gg.fillRect(arg2, arg3, xarg1, xarg2);
+                    break;
+                case 6:
+                    gg.setColor(colors[xarg3]);
+                    gg.drawLine(arg2, arg3, xarg1, xarg2);
+                    break;
+                case 7:
+                    xPoints = new int[arg2];
+                    yPoints = new int[arg2];
+                    break;
+                case 8:
+                    if (arg3 != -1) {
+                        gg.setColor(colors[arg3]);
+                        gg.fillPolygon(xPoints, yPoints, xPoints.length);
+                    }
+                    gg.setColor(colors[arg2]);
+                    gg.drawPolygon(xPoints, yPoints, xPoints.length);
+                    break;
+                case 9:
+                    if (arg3 != -1) {
+                        gg.setColor(colors[arg3]);
+                        gg.fillOval(xarg1-xarg3, xarg2-xarg3, xarg3*2, xarg3*2);
+                    }
+                    gg.setColor(colors[arg2]);
+                    gg.drawOval(xarg1-xarg3, xarg2-xarg3, xarg3*2, xarg3*2);
+                    break;
+                case 10:
+                    for(int i=0; i<blitters.length; i++) {
+                        if (blitters[i] == null) {
+                            blitters[i] = new BufferedImage(arg2, arg3, BufferedImage.TYPE_3BYTE_BGR);
+                            return i;
+                        }
+                    }
+                    throw new RuntimeException("No free blitter found!");
+                case 11: blitters[arg2] = null; break;
+                case 12:
+                    timer.start(); break;
+                case 13:
+                    timer.stop(); break;
+                }
+                return 0;
+            case 5: // more arguments
+                xarg1 = arg1;
+                xarg2 = arg2;
+                xarg3 = arg3;
+                return 0;
+            case 6: // polygon vertex
+                xPoints[arg1]=arg2;
+                yPoints[arg1]=arg3;
+                return 0;
+            case 7: // string
+                gg.setColor(colors[arg2]);
+                {
+                    String text = runtime.utfstring(arg3);
+                    Font ft = new Font((xarg3 & 0x10) != 0 ? "Monospaced" : "Dialog",
+                            Font.PLAIN, 100);
+                    int height100 = this.getFontMetrics(ft).getHeight();
+                    ft = ft.deriveFont(arg1 * 100 / (float)height100);
+                    FontMetrics fm = this.getFontMetrics(ft);
+                    int asc = fm.getAscent(), desc = fm.getDescent();
+                    if ((xarg3 & ALIGN_VCENTRE) != 0)
+                        xarg2 += asc - (asc+desc)/2;
+                    int wid = fm.stringWidth(text);
+                    if ((xarg3 & ALIGN_HCENTRE) != 0)
+                        xarg1 -= wid / 2;
+                    else if ((xarg3 & ALIGN_HRIGHT) != 0)
+                        xarg1 -= wid;
+                    gg.setFont(ft);
+                    gg.drawString(text, xarg1, xarg2);
+                }
+                return 0;
+            case 8: // blitter_save
+                Graphics g2 = blitters[arg1].createGraphics();
+                g2.drawImage(pp.backBuffer, 0, 0, blitters[arg1].getWidth(), blitters[arg1].getHeight(),
+                        arg2, arg3, arg2 + blitters[arg1].getWidth(), arg3 + blitters[arg1].getHeight(), this);
+                g2.dispose();
+                return 0;
+            case 9: // blitter_load
+                gg.drawImage(blitters[arg1], arg2, arg3, this);
+                return 0;
+            case 10: // dialog_init
+                dlg= new ConfigDialog(this, runtime.cstring(arg1));
+                return 0;
+            case 11: // dialog_add_control
+                {
+                    int sval_ptr = arg1;
+                    int ival = arg2;
+                    int ptr = xarg1;
+                    int type=xarg2;
+                    String name = runtime.cstring(xarg3);
+                    switch(type) {
+                    case C_STRING:
+                        dlg.addTextBox(ptr, name, runtime.cstring(sval_ptr));
+                        break;
+                    case C_BOOLEAN:
+                        dlg.addCheckBox(ptr, name, ival != 0);
+                        break;
+                    case C_CHOICES:
+                        dlg.addComboBox(ptr, name, runtime.cstring(sval_ptr), ival);
+                    }
+                }
+                return 0;
+            case 12:
+                dlg.finish();
+                dlg = null;
+                return 0;
+            case 13: // tick a menu item
+                if (arg1 < 0) arg1 = typeMenu.getItemCount() - 1;
+                for (int i = 0; i < typeMenu.getItemCount(); i++) {
+                    if (typeMenu.getMenuComponent(i) instanceof JCheckBoxMenuItem) {
+                        ((JCheckBoxMenuItem)typeMenu.getMenuComponent(i)).setSelected(arg1 == i);
+                    }
+                }
+                return 0;
+            default:
+                if (cmd >= 1024 && cmd < 2048) { // palette
+                    colors[cmd-1024] = new Color(arg1, arg2, arg3);
+                }
+            if (cmd == 1024) {
+                pp.setBackground(colors[0]);
+                if (statusBar != null) statusBar.setBackground(colors[0]);
+                this.setBackground(colors[0]);
+            }
+            return 0;
+            }
+        } catch (Throwable ex) {
+            ex.printStackTrace();
+            System.exit(-1);
+            return 0;
+        }
+    }
+
+    private void addStatusBar() {
+        statusBar = new JLabel("test");
+        statusBar.setBorder(new BevelBorder(BevelBorder.LOWERED));
+        getContentPane().add(BorderLayout.SOUTH,statusBar);
+    }
+
+    // Standalone runner
+    public static void main(String[] args) {
+        final PuzzleApplet a = new PuzzleApplet();
+        JFrame jf = new JFrame("Loading...");
+        jf.getContentPane().setLayout(new BorderLayout());
+        jf.getContentPane().add(a, BorderLayout.CENTER);
+        a.mainWindow=jf;
+        a.init();
+        a.start();
+        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        jf.addWindowListener(new WindowAdapter() {
+            public void windowClosing(WindowEvent e) {
+                a.stop();
+                a.destroy();
+            }
+        });
+        jf.setVisible(true);
+    }
+
+    public static class PuzzlePanel extends JPanel {
+
+        private static final long serialVersionUID = 1L;
+        protected BufferedImage backBuffer;
+
+        public PuzzlePanel() {
+            setPreferredSize(new Dimension(100,100));
+            createBackBuffer(100,100, Color.black);
+        }
+
+        public void createBackBuffer(int w, int h, Color bg) {
+            if (w > 0 && h > 0) {
+                backBuffer = new BufferedImage(w,h, BufferedImage.TYPE_3BYTE_BGR);
+                Graphics g = backBuffer.createGraphics();
+                g.setColor(bg);
+                g.fillRect(0, 0, w, h);
+                g.dispose();
+            }
+        }
+
+        protected void paintComponent(Graphics g) {
+            g.drawImage(backBuffer, 0, 0, this);
+        }
+    }
+
+    public static class ConfigComponent {
+        public int type;
+        public int configItemPointer;
+        public JComponent component;
+
+        public ConfigComponent(int type, int configItemPointer, JComponent component) {
+            this.type = type;
+            this.configItemPointer = configItemPointer;
+            this.component = component;
+        }
+    }
+
+    public class ConfigDialog extends JDialog {
+
+        private GridBagConstraints gbcLeft = new GridBagConstraints(
+                GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE, 1, 1,
+                0, 0, GridBagConstraints.WEST, GridBagConstraints.NONE,
+                new Insets(0, 0, 0, 0), 0, 0);
+        private GridBagConstraints gbcRight = new GridBagConstraints(
+                GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE,
+                GridBagConstraints.REMAINDER, 1, 1.0, 0,
+                GridBagConstraints.CENTER, GridBagConstraints.HORIZONTAL,
+                new Insets(5, 5, 5, 5), 0, 0);
+        private GridBagConstraints gbcBottom = new GridBagConstraints(
+                GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE,
+                GridBagConstraints.REMAINDER, GridBagConstraints.REMAINDER,
+                1.0, 1.0, GridBagConstraints.CENTER,
+                GridBagConstraints.HORIZONTAL, new Insets(5, 5, 5, 5), 0, 0);
+
+        private static final long serialVersionUID = 1L;
+        private List components = new ArrayList();
+
+        public ConfigDialog(JApplet parent, String title) {
+            super(JOptionPane.getFrameForComponent(parent), title, true);
+            getContentPane().setLayout(new GridBagLayout());
+        }
+
+        public void addTextBox(int ptr, String name, String value) {
+            getContentPane().add(new JLabel(name), gbcLeft);
+            JComponent c = new JTextField(value, 25);
+            getContentPane().add(c, gbcRight);
+            components.add(new ConfigComponent(C_STRING, ptr, c));
+        }
+
+
+        public void addCheckBox(int ptr, String name, boolean selected) {
+            JComponent c = new JCheckBox(name, selected);
+            getContentPane().add(c, gbcRight);
+            components.add(new ConfigComponent(C_BOOLEAN, ptr, c));
+        }
+
+        public void addComboBox(int ptr, String name, String values, int selected) {
+            getContentPane().add(new JLabel(name), gbcLeft);
+            StringTokenizer st = new StringTokenizer(values.substring(1), values.substring(0,1));
+            JComboBox c = new JComboBox();
+            c.setEditable(false);
+            while(st.hasMoreTokens())
+                c.addItem(st.nextToken());
+            c.setSelectedIndex(selected);
+            getContentPane().add(c, gbcRight);
+            components.add(new ConfigComponent(C_CHOICES, ptr, c));
+        }
+
+        public void finish() {
+            JPanel buttons = new JPanel(new GridLayout(1, 2, 5, 5));
+            getContentPane().add(buttons, gbcBottom);
+            JButton b;
+            buttons.add(b=new JButton("OK"));
+            b.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    save();
+                    dispose();
+                }
+            });
+            getRootPane().setDefaultButton(b);
+            buttons.add(b=new JButton("Cancel"));
+            b.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    dispose();
+                }
+            });
+            setDefaultCloseOperation(DISPOSE_ON_CLOSE);
+            pack();
+            setLocationRelativeTo(null);
+            setVisible(true);
+        }
+        private void save() {
+            for (int i = 0; i < components.size(); i++) {
+                ConfigComponent cc = (ConfigComponent) components.get(i);
+                switch(cc.type) {
+                case C_STRING:
+                    JTextField jtf = (JTextField)cc.component;
+                    runtimeCall("jcallback_config_set_string", new int[] {cc.configItemPointer, runtime.strdup(jtf.getText())});
+                    break;
+                case C_BOOLEAN:
+                    JCheckBox jcb = (JCheckBox)cc.component;
+                    runtimeCall("jcallback_config_set_boolean", new int[] {cc.configItemPointer, jcb.isSelected()?1:0});
+                    break;
+                case C_CHOICES:
+                    JComboBox jcm = (JComboBox)cc.component;
+                    runtimeCall("jcallback_config_set_choice", new int[] {cc.configItemPointer, jcm.getSelectedIndex()});
+                    break;
+                }
+            }
+            runtimeCall("jcallback_config_ok", new int[0]);
+        }
+    }
+}
diff --git a/apps/plugins/puzzles/README b/apps/plugins/puzzles/README
new file mode 100644
index 0000000000..890db56771
--- /dev/null
+++ b/apps/plugins/puzzles/README
@@ -0,0 +1,54 @@
+This is the README accompanying the source code to Simon Tatham's
+puzzle collection. The collection's web site is at
+<http://www.chiark.greenend.org.uk/~sgtatham/puzzles/>.
+
+If you've obtained the source code by downloading a .tar.gz archive
+from the Puzzles web site, you should find several Makefiles in the
+source code. However, if you've checked the source code out from the
+Puzzles git repository, you won't find the Makefiles: they're
+automatically generated by `mkfiles.pl', so run that to create them.
+
+The Makefiles include:
+
+ - `Makefile.am', together with the static `configure.ac', is intended
+   as input to automake. Run `mkauto.sh' to turn these into a
+   configure script and Makefile.in, after which you can then run
+   `./configure' to create an actual Unix Makefile.
+
+ - `Makefile.vc' should work under MS Visual C++ on Windows. Run
+   'nmake /f Makefile.vc' in a Visual Studio command prompt.
+
+ - `Makefile.cyg' should work under Cygwin / MinGW. With appropriate
+   tweaks and setting of TOOLPATH, it should work for both compiling
+   on Windows and cross-compiling on Unix.
+
+ - `Makefile.osx' should work under Mac OS X, provided the Xcode
+   tools are installed. It builds a single monolithic OS X
+   application capable of running any of the puzzles, or even more
+   than one of them at a time.
+
+ - `Makefile.wce' should work under MS eMbedded Visual C++ on
+   Windows and the Pocket PC SDK; it builds Pocket PC binaries.
+
+Many of these Makefiles build a program called `nullgame' in
+addition to the actual game binaries. This program doesn't do
+anything; it's just a template for people to start from when adding
+a new game to the collection, and it's compiled every time to ensure
+that it _does_ compile and link successfully (because otherwise it
+wouldn't be much use as a template). Once it's built, you can run it
+if you really want to (but it's very boring), and then you should
+ignore it.
+
+DO NOT EDIT THE MAKEFILES DIRECTLY, if you plan to send any changes
+back to the maintainer. The makefiles are generated automatically by
+the Perl script `mkfiles.pl' from the file `Recipe' and the various
+.R files. If you need to change the makefiles as part of a patch,
+you should change Recipe, *.R, and/or mkfiles.pl.
+
+The manual is provided in Windows Help format for the Windows build;
+in text format for anyone who needs it; and in HTML for the Mac OS X
+application and for the web site. It is generated from a Halibut
+source file (puzzles.but), which is the preferred form for
+modification. To generate the manual in other formats, rebuild it,
+or learn about Halibut, visit the Halibut website at
+<http://www.chiark.greenend.org.uk/~sgtatham/halibut/>.
diff --git a/apps/plugins/puzzles/Recipe b/apps/plugins/puzzles/Recipe
new file mode 100644
index 0000000000..ba8317f51a
--- /dev/null
+++ b/apps/plugins/puzzles/Recipe
@@ -0,0 +1,157 @@
+# -*- makefile -*-
+# 
+# This file describes which puzzle binaries are made up from which
+# object and resource files. It is processed into the various
+# Makefiles by means of a Perl script. Makefile changes should
+# really be made by editing this file and/or the Perl script, not
+# by editing the actual Makefiles.
+
+!name puzzles
+
+!makefile gtk Makefile.gtk
+!makefile am Makefile.am
+!makefile vc Makefile.vc
+!makefile wce Makefile.wce
+!makefile cygwin Makefile.cyg
+!makefile osx Makefile.osx
+!makefile gnustep Makefile.gnustep
+!makefile nestedvm Makefile.nestedvm
+!makefile emcc Makefile.emcc
+
+!srcdir icons/
+
+WINDOWS_COMMON = printing
+         + user32.lib gdi32.lib comctl32.lib comdlg32.lib winspool.lib
+WINDOWS  = windows WINDOWS_COMMON
+COMMON   = midend drawing misc malloc random version
+GTK      = gtk printing ps
+# Objects needed for auxiliary command-line programs.
+STANDALONE = nullfe random misc malloc
+
+ALL      = list
+
+# First half of list.c.
+!begin >list.c
+/*
+ * list.c: List of pointers to puzzle structures, for monolithic
+ * platforms.
+ *
+ * This file is automatically generated by mkfiles.pl. Do not edit
+ * it directly, or the changes will be lost next time mkfiles.pl runs.
+ * Instead, edit Recipe and/or its *.R subfiles.
+ */
+#include "puzzles.h"
+#define GAMELIST(A) \
+!end
+
+# Now each .R file adds part of the macro definition of GAMELIST to list.c.
+!include *.R
+
+# Then we finish up list.c as follows:
+!begin >list.c
+
+#define DECL(x) extern const game x;
+#define REF(x) &x,
+GAMELIST(DECL)
+const game *gamelist[] = { GAMELIST(REF) };
+const int gamecount = lenof(gamelist);
+!end
+
+# Unix standalone application for special-purpose obfuscation.
+obfusc : [U] obfusc STANDALONE
+
+puzzles  : [G] windows[COMBINED] WINDOWS_COMMON COMMON ALL noicon.res
+
+# Mac OS X unified application containing all the puzzles.
+Puzzles  : [MX] osx osx.icns osx-info.plist COMMON ALL
+# For OS X, we must create the online help and include it in the
+# application bundle.) Also we add -DCOMBINED to the compiler flags
+# so as to inform the code that we're building a single binary for
+# all the puzzles. Then I've also got some code in here to build a
+# distributable .dmg disk image.
+!begin osx
+Puzzles_extra = Puzzles.app/Contents/Resources/Help/index.html
+Puzzles.app/Contents/Resources/Help/index.html: \
+        Puzzles.app/Contents/Resources/Help osx-help.but puzzles.but
+        cd Puzzles.app/Contents/Resources/Help; \
+                halibut --html ../../../../osx-help.but ../../../../puzzles.but
+Puzzles.app/Contents/Resources/Help: Puzzles.app/Contents/Resources
+        mkdir -p Puzzles.app/Contents/Resources/Help
+
+release: Puzzles.dmg
+Puzzles.dmg: Puzzles
+        rm -f raw.dmg
+        hdiutil create -megabytes 5 -layout NONE raw.dmg
+        hdid -nomount raw.dmg > devicename
+        newfs_hfs -v "Simon Tatham's Puzzle Collection" `cat devicename`
+        hdiutil eject `cat devicename`
+        hdid raw.dmg | cut -f1 -d' ' > devicename
+        cp -R Puzzles.app /Volumes/"Simon Tatham's Puzzle Collection"
+        hdiutil eject `cat devicename`
+        rm -f Puzzles.dmg
+        hdiutil convert -format UDCO raw.dmg -o Puzzles.dmg
+        rm -f raw.dmg devicename
+!end
+
+!begin am
+bin_PROGRAMS = $(GAMES)
+!end
+!begin am_begin
+GAMES =
+!end
+
+# make install for Unix.
+!begin gtk
+install:
+        for i in $(GAMES); do \
+                $(INSTALL_PROGRAM) -m 755 $(BINPREFIX)$$i $(DESTDIR)$(gamesdir)/$(BINPREFIX)$$i \
+                || exit 1; \
+        done
+!end
+!begin nestedvm
+.PRECIOUS: %.class
+%.class: %.mips
+        java -cp $(NESTEDVM)/build:$(NESTEDVM)/upstream/build/classgen/build \
+                org.ibex.nestedvm.Compiler -outformat class -d . \
+                PuzzleEngine $<
+                mv PuzzleEngine.class $@
+
+org:
+        mkdir -p org/ibex/nestedvm/util
+        cp $(NESTEDVM)/build/org/ibex/nestedvm/Registers.class org/ibex/nestedvm
+        cp $(NESTEDVM)/build/org/ibex/nestedvm/UsermodeConstants.class org/ibex/nestedvm
+        cp $(NESTEDVM)/build/org/ibex/nestedvm/Runtime*.class org/ibex/nestedvm
+        cp $(NESTEDVM)/build/org/ibex/nestedvm/util/Platform*.class org/ibex/nestedvm/util
+        cp $(NESTEDVM)/build/org/ibex/nestedvm/util/Seekable*.class org/ibex/nestedvm/util
+        echo "Main-Class: PuzzleApplet" >applet.manifest
+
+PuzzleApplet.class: PuzzleApplet.java org
+        javac -source 1.3 -target 1.3 PuzzleApplet.java
+
+%.jar: %.class PuzzleApplet.class org
+        mv $< PuzzleEngine.class
+        jar cfm $@ applet.manifest PuzzleEngine.class PuzzleApplet*.class org
+        echo '<applet archive="'$@'" code="PuzzleApplet" width="700" height="500"></applet>' >$*.html
+        mv PuzzleEngine.class $<
+!end
+
+# A benchmarking and testing target for the GTK puzzles.
+!begin gtk
+test: benchmark.html benchmark.txt
+
+benchmark.html: benchmark.txt benchmark.pl
+        ./benchmark.pl benchmark.txt > $@
+
+benchmark.txt: benchmark.sh $(GAMES)
+        ./benchmark.sh > $@
+
+!end
+!begin am
+test: benchmark.html benchmark.txt
+
+benchmark.html: benchmark.txt benchmark.pl
+        ./benchmark.pl benchmark.txt > $@
+
+benchmark.txt: benchmark.sh $(GAMES)
+        ./benchmark.sh > $@
+!end
diff --git a/apps/plugins/puzzles/SOURCES b/apps/plugins/puzzles/SOURCES
new file mode 100644
index 0000000000..9c41a00358
--- /dev/null
+++ b/apps/plugins/puzzles/SOURCES
@@ -0,0 +1,26 @@
+rockbox.c
+rbwrappers.c
+
+combi.c
+divvy.c
+drawing.c
+dsf.c
+findloop.c
+grid.c
+latin.c
+laydomino.c
+loopgen.c
+malloc.c
+maxflow.c
+midend.c
+misc.c
+penrose.c
+printing.c
+random.c
+tdq.c
+tree234.c
+version.c
+
+#ifdef COMBINED
+list.c
+#endif
diff --git a/apps/plugins/puzzles/benchmark.pl b/apps/plugins/puzzles/benchmark.pl
new file mode 100755
index 0000000000..98763859e8
--- /dev/null
+++ b/apps/plugins/puzzles/benchmark.pl
@@ -0,0 +1,197 @@
+#!/usr/bin/perl
+
+# Process the raw output from benchmark.sh into Javascript-ified HTML.
+
+use strict;
+use warnings;
+
+my @presets = ();
+my %presets = ();
+my $maxval = 0;
+
+while (<>) {
+    chomp;
+    if (/^(.*)(#.*): ([\d\.]+)$/) {
+        push @presets, $1 unless defined $presets{$1};
+        push @{$presets{$1}}, $3;
+        $maxval = $3 if $maxval < $3;
+    }
+}
+
+print <<EOF;
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ASCII" />
+<title>Puzzle generation-time benchmarks</title>
+<script type="text/javascript">
+//<![CDATA[
+function choose_scale_ticks(scale) {
+    var nscale = 1, j = 0, factors = [2,2.5,2];
+    while (scale / nscale > 20) {
+        nscale *= factors[j];
+        j = (j+1) % factors.length;
+    } 
+    return nscale;
+}
+function initPlots() {
+    var canvases = document.getElementsByTagName('canvas');
+    for (var i = 0; i < canvases.length; i++) {
+        var canvas = canvases[i];
+        var scale = eval(canvas.getAttribute("data-scale"));
+        var add = 20.5, mult = (canvas.width - 2*add) / scale;
+        var data = eval(canvas.getAttribute("data-points"));
+        var ctx = canvas.getContext('2d');
+        ctx.lineWidth = '1px';
+        ctx.lineCap = 'round';
+        ctx.lineJoin = 'round';
+        ctx.strokeStyle = ctx.fillStyle = '#000000';
+        if (data === "scale") {
+            // Draw scale.
+            ctx.font = "16px sans-serif";
+            ctx.textAlign = "center";
+            ctx.textBaseline = "alphabetic";
+            var nscale = choose_scale_ticks(scale);
+            for (var x = 0; x <= scale; x += nscale) {
+                ctx.beginPath();
+                ctx.moveTo(add+mult*x, canvas.height);
+                ctx.lineTo(add+mult*x, canvas.height - 3);
+                ctx.stroke();
+                ctx.fillText(x + "s", add+mult*x, canvas.height - 6);
+            }
+        } else {
+            // Draw a box plot.
+            function quantile(x) {
+                var n = (data.length * x) | 0;
+                return (data[n-1] + data[n]) / 2;
+            }
+
+            var q1 = quantile(0.25), q2 = quantile(0.5), q3 = quantile(0.75);
+            var iqr = q3 - q1;
+            var top = 0.5, bot = canvas.height - 1.5, mid = (top+bot)/2;
+            var wlo = null, whi = null; // whisker ends
+
+            ctx.strokeStyle = '#bbbbbb';
+            var nscale = choose_scale_ticks(scale);
+            for (var x = 0; x <= scale; x += nscale) {
+                ctx.beginPath();
+                ctx.moveTo(add+mult*x, 0);
+                ctx.lineTo(add+mult*x, canvas.height);
+                ctx.stroke();
+            }
+            ctx.strokeStyle = '#000000';
+
+            for (var j in data) {
+                var x = data[j];
+                if (x >= q1 - 1.5 * iqr && x <= q3 + 1.5 * iqr) {
+                    if (wlo === null || wlo > x)
+                        wlo = x;
+                    if (whi === null || whi < x)
+                        whi = x;
+                } else {
+                    ctx.beginPath();
+                    ctx.arc(add+mult*x, mid, 2, 0, 2*Math.PI);
+                    ctx.stroke();
+                    if (x >= q1 - 3 * iqr && x <= q3 + 3 * iqr)
+                        ctx.fill();
+                }
+            }
+
+            ctx.beginPath();
+
+            // Box
+            ctx.moveTo(add+mult*q1, top);
+            ctx.lineTo(add+mult*q3, top);
+            ctx.lineTo(add+mult*q3, bot);
+            ctx.lineTo(add+mult*q1, bot);
+            ctx.closePath();
+
+            // Line at median
+            ctx.moveTo(add+mult*q2, top);
+            ctx.lineTo(add+mult*q2, bot);
+
+            // Lower whisker
+            ctx.moveTo(add+mult*q1, mid);
+            ctx.lineTo(add+mult*wlo, mid);
+            ctx.moveTo(add+mult*wlo, top);
+            ctx.lineTo(add+mult*wlo, bot);
+
+            // Upper whisker
+            ctx.moveTo(add+mult*q3, mid);
+            ctx.lineTo(add+mult*whi, mid);
+            ctx.moveTo(add+mult*whi, top);
+            ctx.lineTo(add+mult*whi, bot);
+
+            ctx.stroke();
+        }
+    }
+    document.getElementById('sort_orig').onclick = function() {
+        sort(function(e) {
+            return parseFloat(e.getAttribute("data-index"));
+        });
+    };
+    document.getElementById('sort_median').onclick = function() {
+        sort(function(e) {
+            return -parseFloat(e.getAttribute("data-median"));
+        });
+    };
+    document.getElementById('sort_mean').onclick = function() {
+        sort(function(e) {
+            return -parseFloat(e.getAttribute("data-mean"));
+        });
+    };
+}
+function sort(keyfn) {
+    var rows = document.getElementsByTagName("tr");
+    var trs = [];
+    for (var i = 0; i < rows.length; i++)
+        trs.push(rows[i]);
+    trs.sort(function(a,b) {
+        var akey = keyfn(a);
+        var bkey = keyfn(b);
+        return akey < bkey ? -1 : akey > bkey ? +1 : 0;
+    });
+    var parent = trs[0].parentElement;
+    for (var i = 0; i < trs.length; i++)
+        parent.removeChild(trs[i]);
+    for (var i = 0; i < trs.length; i++)
+        parent.appendChild(trs[i]);
+}
+//]]>
+</script>
+</head>
+<body onLoad="initPlots();">
+<h1 align=center>Puzzle generation-time benchmarks</h1>
+<p>Sort order:
+<button id="sort_orig">Original</button>
+<button id="sort_median">Median</button>
+<button id="sort_mean">Mean</button>
+<table>
+<tr><th>Preset</th><td><canvas width=700 height=30 data-points='"scale"' data-scale="$maxval"></td></tr>
+EOF
+
+my $index = 0;
+for my $preset (@presets) {
+    my @data = sort { $a <=> $b } @{$presets{$preset}};
+    my $median = ($#data % 2 ?
+                  ($data[($#data-1)/2]+$data[($#data+1)/2])/2 :
+                  $data[$#data/2]);
+    my $mean = 0; map { $mean += $_ } @data; $mean /= @data;
+    print "<tr data-index=\"$index\" data-mean=\"$mean\" data-median=\"$median\"><td>", &escape($preset), "</td><td><canvas width=700 height=15 data-points=\"[";
+    print join ",", @data;
+    print "]\" data-scale=\"$maxval\"></td></tr>\n";
+    $index++;
+}
+
+print <<EOF;
+</body>
+</html>
+EOF
+
+sub escape {
+    my ($text) = @_;
+    $text =~ s/&/&amp;/g;
+    $text =~ s/</&lt;/g;
+    $text =~ s/>/&gt;/g;
+    return $text;
+}
diff --git a/apps/plugins/puzzles/benchmark.sh b/apps/plugins/puzzles/benchmark.sh
new file mode 100755
index 0000000000..b3af27765e
--- /dev/null
+++ b/apps/plugins/puzzles/benchmark.sh
@@ -0,0 +1,27 @@
+#!/bin/sh
+
+# Run every puzzle in benchmarking mode, and generate a file of raw
+# data that benchmark.pl will format into a web page.
+
+# If any arguments are provided, use those as the list of games to
+# benchmark. Otherwise, read the full list from gamedesc.txt.
+if test $# = 0; then
+    set -- $(cut -f1 -d: < gamedesc.txt)
+fi
+
+failures=false
+
+for game in "$@"; do
+    # Use 'env -i' to suppress any environment variables that might
+    # change the preset list for a puzzle (e.g. user-defined extras)
+    presets=$(env -i ./$game --list-presets | cut -f1 -d' ')
+    for preset in $presets; do
+        if ! env -i ./$game --test-solve --time-generation \
+                            --generate 100 $preset;
+        then
+            echo "${game} ${preset} failed to generate" >&2
+        fi
+    done
+done
+
+if $failures; then exit 1; fi
diff --git a/apps/plugins/puzzles/blackbox.R b/apps/plugins/puzzles/blackbox.R
new file mode 100644
index 0000000000..116225206d
--- /dev/null
+++ b/apps/plugins/puzzles/blackbox.R
@@ -0,0 +1,19 @@
+# -*- makefile -*-
+
+blackbox : [X] GTK COMMON blackbox blackbox-icon|no-icon
+
+blackbox : [G] WINDOWS COMMON blackbox blackbox.res|noicon.res
+
+ALL += blackbox[COMBINED]
+
+!begin am gtk
+GAMES += blackbox
+!end
+
+!begin >list.c
+    A(blackbox) \
+!end
+
+!begin >gamedesc.txt
+blackbox:blackbox.exe:Black Box:Ball-finding puzzle:Find the hidden balls in the box by bouncing laser beams off them.
+!end
diff --git a/apps/plugins/puzzles/blackbox.c b/apps/plugins/puzzles/blackbox.c
new file mode 100644
index 0000000000..a4875e49d7
--- /dev/null
+++ b/apps/plugins/puzzles/blackbox.c
@@ -0,0 +1,1543 @@
+/*
+ * blackbox.c: implementation of 'Black Box'.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#define PREFERRED_TILE_SIZE 32
+#define FLASH_FRAME 0.2F
+
+/* Terminology, for ease of reading various macros scattered about the place.
+ *
+ * The 'arena' is the inner area where the balls are placed. This is
+ *   indexed from (0,0) to (w-1,h-1) but its offset in the grid is (1,1).
+ *
+ * The 'range' (firing range) is the bit around the edge where
+ *   the lasers are fired from. This is indexed from 0 --> (2*(w+h) - 1),
+ *   starting at the top left ((1,0) on the grid) and moving clockwise.
+ *
+ * The 'grid' is just the big array containing arena and range;
+ *   locations (0,0), (0,w+1), (h+1,w+1) and (h+1,0) are unused.
+ */
+
+enum {
+    COL_BACKGROUND, COL_COVER, COL_LOCK,
+    COL_TEXT, COL_FLASHTEXT,
+    COL_HIGHLIGHT, COL_LOWLIGHT, COL_GRID,
+    COL_BALL, COL_WRONG, COL_BUTTON,
+    COL_CURSOR,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h;
+    int minballs, maxballs;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 8;
+    ret->minballs = ret->maxballs = 5;
+
+    return ret;
+}
+
+static const game_params blackbox_presets[] = {
+    { 5, 5, 3, 3 },
+    { 8, 8, 5, 5 },
+    { 8, 8, 3, 6 },
+    { 10, 10, 5, 5 },
+    { 10, 10, 4, 10 }
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    char str[80];
+    game_params *ret;
+
+    if (i < 0 || i >= lenof(blackbox_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = blackbox_presets[i];
+
+    if (ret->minballs == ret->maxballs)
+        sprintf(str, "%dx%d, %d balls",
+                ret->w, ret->h, ret->minballs);
+    else
+        sprintf(str, "%dx%d, %d-%d balls",
+                ret->w, ret->h, ret->minballs, ret->maxballs);
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    char const *p = string;
+    game_params *defs = default_params();
+
+    *params = *defs; free_params(defs);
+
+    while (*p) {
+        switch (*p++) {
+        case 'w':
+            params->w = atoi(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+            break;
+
+        case 'h':
+            params->h = atoi(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+            break;
+
+        case 'm':
+            params->minballs = atoi(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+            break;
+
+        case 'M':
+            params->maxballs = atoi(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+            break;
+
+        default:
+            ;
+        }
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char str[256];
+
+    sprintf(str, "w%dh%dm%dM%d",
+            params->w, params->h, params->minballs, params->maxballs);
+    return dupstr(str);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "No. of balls";
+    ret[2].type = C_STRING;
+    if (params->minballs == params->maxballs)
+        sprintf(buf, "%d", params->minballs);
+    else
+        sprintf(buf, "%d-%d", params->minballs, params->maxballs);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+
+    /* Allow 'a-b' for a range, otherwise assume a single number. */
+    if (sscanf(cfg[2].sval, "%d-%d", &ret->minballs, &ret->maxballs) < 2)
+        ret->minballs = ret->maxballs = atoi(cfg[2].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 2 || params->h < 2)
+        return "Width and height must both be at least two";
+    /* next one is just for ease of coding stuff into 'char'
+     * types, and could be worked around if required. */
+    if (params->w > 255 || params->h > 255)
+        return "Widths and heights greater than 255 are not supported";
+    if (params->minballs > params->maxballs)
+        return "Minimum number of balls may not be greater than maximum";
+    if (params->minballs >= params->w * params->h)
+        return "Too many balls to fit in grid";
+    return NULL;
+}
+
+/*
+ * We store: width | height | ball1x | ball1y | [ ball2x | ball2y | [...] ]
+ * all stored as unsigned chars; validate_params has already
+ * checked this won't overflow an 8-bit char.
+ * Then we obfuscate it.
+ */
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int nballs = params->minballs, i;
+    char *grid, *ret;
+    unsigned char *bmp;
+
+    if (params->maxballs > params->minballs)
+        nballs += random_upto(rs, params->maxballs - params->minballs + 1);
+
+    grid = snewn(params->w*params->h, char);
+    memset(grid, 0, params->w * params->h * sizeof(char));
+
+    bmp = snewn(nballs*2 + 2, unsigned char);
+    memset(bmp, 0, (nballs*2 + 2) * sizeof(unsigned char));
+
+    bmp[0] = params->w;
+    bmp[1] = params->h;
+
+    for (i = 0; i < nballs; i++) {
+        int x, y;
+
+        do {
+            x = random_upto(rs, params->w);
+            y = random_upto(rs, params->h);
+        } while (grid[y*params->w + x]);
+
+        grid[y*params->w + x] = 1;
+
+        bmp[(i+1)*2 + 0] = x;
+        bmp[(i+1)*2 + 1] = y;
+    }
+    sfree(grid);
+
+    obfuscate_bitmap(bmp, (nballs*2 + 2) * 8, FALSE);
+    ret = bin2hex(bmp, nballs*2 + 2);
+    sfree(bmp);
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int nballs, dlen = strlen(desc), i;
+    unsigned char *bmp;
+    char *ret;
+
+    /* the bitmap is 2+(nballs*2) long; the hex version is double that. */
+    nballs = ((dlen/2)-2)/2;
+
+    if (dlen < 4 || dlen % 4 ||
+        nballs < params->minballs || nballs > params->maxballs)
+        return "Game description is wrong length";
+
+    bmp = hex2bin(desc, nballs*2 + 2);
+    obfuscate_bitmap(bmp, (nballs*2 + 2) * 8, TRUE);
+    ret = "Game description is corrupted";
+    /* check general grid size */
+    if (bmp[0] != params->w || bmp[1] != params->h)
+        goto done;
+    /* check each ball will fit on that grid */
+    for (i = 0; i < nballs; i++) {
+        int x = bmp[(i+1)*2 + 0], y = bmp[(i+1)*2 + 1];
+        if (x < 0 || y < 0 || x >= params->w || y >= params->h)
+            goto done;
+    }
+    ret = NULL;
+
+done:
+    sfree(bmp);
+    return ret;
+}
+
+#define BALL_CORRECT    0x01
+#define BALL_GUESS      0x02
+#define BALL_LOCK       0x04
+
+#define LASER_FLAGMASK  0x1f800
+#define LASER_OMITTED    0x0800
+#define LASER_REFLECT    0x1000
+#define LASER_HIT        0x2000
+#define LASER_WRONG      0x4000
+#define LASER_FLASHED    0x8000
+#define LASER_EMPTY      (~0)
+
+#define FLAG_CURSOR     0x10000 /* needs to be disjoint from both sets */
+
+struct game_state {
+    int w, h, minballs, maxballs, nballs, nlasers;
+    unsigned int *grid; /* (w+2)x(h+2), to allow for laser firing range */
+    unsigned int *exits; /* one per laser */
+    int done;           /* user has finished placing his own balls. */
+    int laserno;        /* number of next laser to be fired. */
+    int nguesses, reveal, justwrong, nright, nwrong, nmissed;
+};
+
+#define GRID(s,x,y) ((s)->grid[(y)*((s)->w+2) + (x)])
+
+#define RANGECHECK(s,x) ((x) >= 0 && (x) <= (s)->nlasers)
+
+/* specify numbers because they must match array indexes. */
+enum { DIR_UP = 0, DIR_RIGHT = 1, DIR_DOWN = 2, DIR_LEFT = 3 };
+
+struct offset { int x, y; };
+
+static const struct offset offsets[] = {
+    {  0, -1 }, /* up */
+    {  1,  0 }, /* right */
+    {  0,  1 }, /* down */
+    { -1,  0 }  /* left */
+};
+
+#ifdef DEBUGGING
+static const char *dirstrs[] = {
+    "UP", "RIGHT", "DOWN", "LEFT"
+};
+#endif
+
+static int range2grid(const game_state *state, int rangeno, int *x, int *y,
+                      int *direction)
+{
+    if (rangeno < 0)
+        return 0;
+
+    if (rangeno < state->w) {
+        /* top row; from (1,0) to (w,0) */
+        *x = rangeno + 1;
+        *y = 0;
+        *direction = DIR_DOWN;
+        return 1;
+    }
+    rangeno -= state->w;
+    if (rangeno < state->h) {
+        /* RHS; from (w+1, 1) to (w+1, h) */
+        *x = state->w+1;
+        *y = rangeno + 1;
+        *direction = DIR_LEFT;
+        return 1;
+    }
+    rangeno -= state->h;
+    if (rangeno < state->w) {
+        /* bottom row; from (1, h+1) to (w, h+1); counts backwards */
+        *x = (state->w - rangeno);
+        *y = state->h+1;
+        *direction = DIR_UP;
+        return 1;
+    }
+    rangeno -= state->w;
+    if (rangeno < state->h) {
+        /* LHS; from (0, 1) to (0, h); counts backwards */
+        *x = 0;
+        *y = (state->h - rangeno);
+        *direction = DIR_RIGHT;
+        return 1;
+    }
+    return 0;
+}
+
+static int grid2range(const game_state *state, int x, int y, int *rangeno)
+{
+    int ret, x1 = state->w+1, y1 = state->h+1;
+
+    if (x > 0 && x < x1 && y > 0 && y < y1) return 0; /* in arena */
+    if (x < 0 || x > x1 || y < 0 || y > y1) return 0; /* outside grid */
+
+    if ((x == 0 || x == x1) && (y == 0 || y == y1))
+        return 0; /* one of 4 corners */
+
+    if (y == 0) {               /* top line */
+        ret = x - 1;
+    } else if (x == x1) {       /* RHS */
+        ret = y - 1 + state->w;
+    } else if (y == y1) {       /* Bottom [and counts backwards] */
+        ret = (state->w - x) + state->w + state->h;
+    } else {                    /* LHS [and counts backwards ] */
+        ret = (state->h-y) + state->w + state->w + state->h;
+    }
+    *rangeno = ret;
+    debug(("grid2range: (%d,%d) rangeno = %d\n", x, y, ret));
+    return 1;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    int dlen = strlen(desc), i;
+    unsigned char *bmp;
+
+    state->minballs = params->minballs;
+    state->maxballs = params->maxballs;
+    state->nballs = ((dlen/2)-2)/2;
+
+    bmp = hex2bin(desc, state->nballs*2 + 2);
+    obfuscate_bitmap(bmp, (state->nballs*2 + 2) * 8, TRUE);
+
+    state->w = bmp[0]; state->h = bmp[1];
+    state->nlasers = 2 * (state->w + state->h);
+
+    state->grid = snewn((state->w+2)*(state->h+2), unsigned int);
+    memset(state->grid, 0, (state->w+2)*(state->h+2) * sizeof(unsigned int));
+
+    state->exits = snewn(state->nlasers, unsigned int);
+    memset(state->exits, LASER_EMPTY, state->nlasers * sizeof(unsigned int));
+
+    for (i = 0; i < state->nballs; i++) {
+        GRID(state, bmp[(i+1)*2 + 0]+1, bmp[(i+1)*2 + 1]+1) = BALL_CORRECT;
+    }
+    sfree(bmp);
+
+    state->done = state->nguesses = state->reveal = state->justwrong =
+        state->nright = state->nwrong = state->nmissed = 0;
+    state->laserno = 1;
+
+    return state;
+}
+
+#define XFER(x) ret->x = state->x
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    XFER(w); XFER(h);
+    XFER(minballs); XFER(maxballs);
+    XFER(nballs); XFER(nlasers);
+
+    ret->grid = snewn((ret->w+2)*(ret->h+2), unsigned int);
+    memcpy(ret->grid, state->grid, (ret->w+2)*(ret->h+2) * sizeof(unsigned int));
+    ret->exits = snewn(ret->nlasers, unsigned int);
+    memcpy(ret->exits, state->exits, ret->nlasers * sizeof(unsigned int));
+
+    XFER(done);
+    XFER(laserno);
+    XFER(nguesses);
+    XFER(reveal);
+    XFER(justwrong);
+    XFER(nright); XFER(nwrong); XFER(nmissed);
+
+    return ret;
+}
+
+#undef XFER
+
+static void free_game(game_state *state)
+{
+    sfree(state->exits);
+    sfree(state->grid);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return dupstr("S");
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+struct game_ui {
+    int flash_laserno;
+    int errors, newmove;
+    int cur_x, cur_y, cur_visible;
+    int flash_laser; /* 0 = never, 1 = always, 2 = if anim. */
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->flash_laserno = LASER_EMPTY;
+    ui->errors = 0;
+    ui->newmove = FALSE;
+
+    ui->cur_x = ui->cur_y = 1;
+    ui->cur_visible = 0;
+
+    ui->flash_laser = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    char buf[80];
+    /*
+     * The error counter needs preserving across a serialisation.
+     */
+    sprintf(buf, "E%d", ui->errors);
+    return dupstr(buf);
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+    sscanf(encoding, "E%d", &ui->errors);
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    /*
+     * If we've encountered a `justwrong' state as a result of
+     * actually making a move, increment the ui error counter.
+     */
+    if (newstate->justwrong && ui->newmove)
+        ui->errors++;
+    ui->newmove = FALSE;
+}
+
+#define OFFSET(gx,gy,o) do {                                    \
+    int off = (4 + (o) % 4) % 4;                                \
+    (gx) += offsets[off].x;                                     \
+    (gy) += offsets[off].y;                                     \
+} while(0)
+
+enum { LOOK_LEFT, LOOK_FORWARD, LOOK_RIGHT };
+
+/* Given a position and a direction, check whether we can see a ball in front
+ * of us, or to our front-left or front-right. */
+static int isball(game_state *state, int gx, int gy, int direction, int lookwhere)
+{
+    debug(("isball, (%d, %d), dir %s, lookwhere %s\n", gx, gy, dirstrs[direction],
+           lookwhere == LOOK_LEFT ? "LEFT" :
+           lookwhere == LOOK_FORWARD ? "FORWARD" : "RIGHT"));
+    OFFSET(gx,gy,direction);
+    if (lookwhere == LOOK_LEFT)
+        OFFSET(gx,gy,direction-1);
+    else if (lookwhere == LOOK_RIGHT)
+        OFFSET(gx,gy,direction+1);
+    else if (lookwhere != LOOK_FORWARD)
+        assert(!"unknown lookwhere");
+
+    debug(("isball, new (%d, %d)\n", gx, gy));
+
+    /* if we're off the grid (into the firing range) there's never a ball. */
+    if (gx < 1 || gy < 1 || gx > state->w || gy > state->h)
+        return 0;
+
+    if (GRID(state, gx,gy) & BALL_CORRECT)
+        return 1;
+
+    return 0;
+}
+
+static int fire_laser_internal(game_state *state, int x, int y, int direction)
+{
+    int unused, lno, tmp;
+
+    tmp = grid2range(state, x, y, &lno);
+    assert(tmp);
+
+    /* deal with strange initial reflection rules (that stop
+     * you turning down the laser range) */
+
+    /* I've just chosen to prioritise instant-hit over instant-reflection;
+     * I can't find anywhere that gives me a definite algorithm for this. */
+    if (isball(state, x, y, direction, LOOK_FORWARD)) {
+        debug(("Instant hit at (%d, %d)\n", x, y));
+        return LASER_HIT;              /* hit */
+    }
+
+    if (isball(state, x, y, direction, LOOK_LEFT) ||
+        isball(state, x, y, direction, LOOK_RIGHT)) {
+        debug(("Instant reflection at (%d, %d)\n", x, y));
+        return LASER_REFLECT;          /* reflection */
+    }
+    /* move us onto the grid. */
+    OFFSET(x, y, direction);
+
+    while (1) {
+        debug(("fire_laser: looping at (%d, %d) pointing %s\n",
+               x, y, dirstrs[direction]));
+        if (grid2range(state, x, y, &unused)) {
+            int exitno;
+
+            tmp = grid2range(state, x, y, &exitno);
+            assert(tmp);
+
+            return (lno == exitno ? LASER_REFLECT : exitno);
+        }
+        /* paranoia. This obviously should never happen */
+        assert(!(GRID(state, x, y) & BALL_CORRECT));
+
+        if (isball(state, x, y, direction, LOOK_FORWARD)) {
+            /* we're facing a ball; send back a reflection. */
+            debug(("Ball ahead of (%d, %d)", x, y));
+            return LASER_HIT;          /* hit */
+        }
+
+        if (isball(state, x, y, direction, LOOK_LEFT)) {
+            /* ball to our left; rotate clockwise and look again. */
+            debug(("Ball to left; turning clockwise.\n"));
+            direction += 1; direction %= 4;
+            continue;
+        }
+        if (isball(state, x, y, direction, LOOK_RIGHT)) {
+            /* ball to our right; rotate anti-clockwise and look again. */
+            debug(("Ball to rightl turning anti-clockwise.\n"));
+            direction += 3; direction %= 4;
+            continue;
+        }
+        /* ... otherwise, we have no balls ahead of us so just move one step. */
+        debug(("No balls; moving forwards.\n"));
+        OFFSET(x, y, direction);
+    }
+}
+
+static int laser_exit(game_state *state, int entryno)
+{
+    int tmp, x, y, direction;
+
+    tmp = range2grid(state, entryno, &x, &y, &direction);
+    assert(tmp);
+
+    return fire_laser_internal(state, x, y, direction);
+}
+
+static void fire_laser(game_state *state, int entryno)
+{
+    int tmp, exitno, x, y, direction;
+
+    tmp = range2grid(state, entryno, &x, &y, &direction);
+    assert(tmp);
+
+    exitno = fire_laser_internal(state, x, y, direction);
+
+    if (exitno == LASER_HIT || exitno == LASER_REFLECT) {
+        GRID(state, x, y) = state->exits[entryno] = exitno;
+    } else {
+        int newno = state->laserno++;
+        int xend, yend, unused;
+        tmp = range2grid(state, exitno, &xend, &yend, &unused);
+        assert(tmp);
+        GRID(state, x, y) = GRID(state, xend, yend) = newno;
+        state->exits[entryno] = exitno;
+        state->exits[exitno] = entryno;
+    }
+}
+
+/* Checks that the guessed balls in the state match up with the real balls
+ * for all possible lasers (i.e. not just the ones that the player might
+ * have already guessed). This is required because any layout with >4 balls
+ * might have multiple valid solutions. Returns non-zero for a 'correct'
+ * (i.e. consistent) layout. */
+static int check_guesses(game_state *state, int cagey)
+{
+    game_state *solution, *guesses;
+    int i, x, y, n, unused, tmp;
+    int ret = 0;
+
+    if (cagey) {
+        /*
+         * First, check that each laser the player has already
+         * fired is consistent with the layout. If not, show them
+         * one error they've made and reveal no further
+         * information.
+         *
+         * Failing that, check to see whether the player would have
+         * been able to fire any laser which distinguished the real
+         * solution from their guess. If so, show them one such
+         * laser and reveal no further information.
+         */
+        guesses = dup_game(state);
+        /* clear out BALL_CORRECT on guess, make BALL_GUESS BALL_CORRECT. */
+        for (x = 1; x <= state->w; x++) {
+            for (y = 1; y <= state->h; y++) {
+                GRID(guesses, x, y) &= ~BALL_CORRECT;
+                if (GRID(guesses, x, y) & BALL_GUESS)
+                    GRID(guesses, x, y) |= BALL_CORRECT;
+            }
+        }
+        n = 0;
+        for (i = 0; i < guesses->nlasers; i++) {
+            if (guesses->exits[i] != LASER_EMPTY &&
+                guesses->exits[i] != laser_exit(guesses, i))
+                n++;
+        }
+        if (n) {
+            /*
+             * At least one of the player's existing lasers
+             * contradicts their ball placement. Pick a random one,
+             * highlight it, and return.
+             *
+             * A temporary random state is created from the current
+             * grid, so that repeating the same marking will give
+             * the same answer instead of a different one.
+             */
+            random_state *rs = random_new((char *)guesses->grid,
+                                          (state->w+2)*(state->h+2) *
+                                          sizeof(unsigned int));
+            n = random_upto(rs, n);
+            random_free(rs);
+            for (i = 0; i < guesses->nlasers; i++) {
+                if (guesses->exits[i] != LASER_EMPTY &&
+                    guesses->exits[i] != laser_exit(guesses, i) &&
+                    n-- == 0) {
+                    state->exits[i] |= LASER_WRONG;
+                    tmp = laser_exit(state, i);
+                    if (RANGECHECK(state, tmp))
+                        state->exits[tmp] |= LASER_WRONG;
+                    state->justwrong = TRUE;
+                    free_game(guesses);
+                    return 0;
+                }
+            }
+        }
+        n = 0;
+        for (i = 0; i < guesses->nlasers; i++) {
+            if (guesses->exits[i] == LASER_EMPTY &&
+                laser_exit(state, i) != laser_exit(guesses, i))
+                n++;
+        }
+        if (n) {
+            /*
+             * At least one of the player's unfired lasers would
+             * demonstrate their ball placement to be wrong. Pick a
+             * random one, highlight it, and return.
+             *
+             * A temporary random state is created from the current
+             * grid, so that repeating the same marking will give
+             * the same answer instead of a different one.
+             */
+            random_state *rs = random_new((char *)guesses->grid,
+                                          (state->w+2)*(state->h+2) *
+                                          sizeof(unsigned int));
+            n = random_upto(rs, n);
+            random_free(rs);
+            for (i = 0; i < guesses->nlasers; i++) {
+                if (guesses->exits[i] == LASER_EMPTY &&
+                    laser_exit(state, i) != laser_exit(guesses, i) &&
+                    n-- == 0) {
+                    fire_laser(state, i);
+                    state->exits[i] |= LASER_OMITTED;
+                    tmp = laser_exit(state, i);
+                    if (RANGECHECK(state, tmp))
+                        state->exits[tmp] |= LASER_OMITTED;
+                    state->justwrong = TRUE;
+                    free_game(guesses);
+                    return 0;
+                }
+            }
+        }
+        free_game(guesses);
+    }
+
+    /* duplicate the state (to solution) */
+    solution = dup_game(state);
+
+    /* clear out the lasers of solution */
+    for (i = 0; i < solution->nlasers; i++) {
+        tmp = range2grid(solution, i, &x, &y, &unused);
+        assert(tmp);
+        GRID(solution, x, y) = 0;
+        solution->exits[i] = LASER_EMPTY;
+    }
+
+    /* duplicate solution to guess. */
+    guesses = dup_game(solution);
+
+    /* clear out BALL_CORRECT on guess, make BALL_GUESS BALL_CORRECT. */
+    for (x = 1; x <= state->w; x++) {
+        for (y = 1; y <= state->h; y++) {
+            GRID(guesses, x, y) &= ~BALL_CORRECT;
+            if (GRID(guesses, x, y) & BALL_GUESS)
+                GRID(guesses, x, y) |= BALL_CORRECT;
+        }
+    }
+
+    /* for each laser (on both game_states), fire it if it hasn't been fired.
+     * If one has been fired (or received a hit) and another hasn't, we know
+     * the ball layouts didn't match and can short-circuit return. */
+    for (i = 0; i < solution->nlasers; i++) {
+        if (solution->exits[i] == LASER_EMPTY)
+            fire_laser(solution, i);
+        if (guesses->exits[i] == LASER_EMPTY)
+            fire_laser(guesses, i);
+    }
+
+    /* check each game_state's laser against the other; if any differ, return 0 */
+    ret = 1;
+    for (i = 0; i < solution->nlasers; i++) {
+        tmp = range2grid(solution, i, &x, &y, &unused);
+        assert(tmp);
+
+        if (solution->exits[i] != guesses->exits[i]) {
+            /* If the original state didn't have this shot fired,
+             * and it would be wrong between the guess and the solution,
+             * add it. */
+            if (state->exits[i] == LASER_EMPTY) {
+                state->exits[i] = solution->exits[i];
+                if (state->exits[i] == LASER_REFLECT ||
+                    state->exits[i] == LASER_HIT)
+                    GRID(state, x, y) = state->exits[i];
+                else {
+                    /* add a new shot, incrementing state's laser count. */
+                    int ex, ey, newno = state->laserno++;
+                    tmp = range2grid(state, state->exits[i], &ex, &ey, &unused);
+                    assert(tmp);
+                    GRID(state, x, y) = newno;
+                    GRID(state, ex, ey) = newno;
+                }
+                state->exits[i] |= LASER_OMITTED;
+            } else {
+                state->exits[i] |= LASER_WRONG;
+            }
+            ret = 0;
+        }
+    }
+    if (ret == 0 ||
+        state->nguesses < state->minballs ||
+        state->nguesses > state->maxballs) goto done;
+
+    /* fix up original state so the 'correct' balls end up matching the guesses,
+     * as we've just proved that they were equivalent. */
+    for (x = 1; x <= state->w; x++) {
+        for (y = 1; y <= state->h; y++) {
+            if (GRID(state, x, y) & BALL_GUESS)
+                GRID(state, x, y) |= BALL_CORRECT;
+            else
+                GRID(state, x, y) &= ~BALL_CORRECT;
+        }
+    }
+
+done:
+    /* fill in nright and nwrong. */
+    state->nright = state->nwrong = state->nmissed = 0;
+    for (x = 1; x <= state->w; x++) {
+        for (y = 1; y <= state->h; y++) {
+            int bs = GRID(state, x, y) & (BALL_GUESS | BALL_CORRECT);
+            if (bs == (BALL_GUESS | BALL_CORRECT))
+                state->nright++;
+            else if (bs == BALL_GUESS)
+                state->nwrong++;
+            else if (bs == BALL_CORRECT)
+                state->nmissed++;
+        }
+    }
+    free_game(solution);
+    free_game(guesses);
+    state->reveal = 1;
+    return ret;
+}
+
+#define TILE_SIZE (ds->tilesize)
+
+#define TODRAW(x) ((TILE_SIZE * (x)) + (TILE_SIZE / 2))
+#define FROMDRAW(x) (((x) - (TILE_SIZE / 2)) / TILE_SIZE)
+
+#define CAN_REVEAL(state) ((state)->nguesses >= (state)->minballs && \
+                           (state)->nguesses <= (state)->maxballs && \
+                           !(state)->reveal && !(state)->justwrong)
+
+struct game_drawstate {
+    int tilesize, crad, rrad, w, h; /* w and h to make macros work... */
+    unsigned int *grid;          /* as the game_state grid */
+    int started, reveal;
+    int flash_laserno, isflash;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int gx = -1, gy = -1, rangeno = -1, wouldflash = 0;
+    enum { NONE, TOGGLE_BALL, TOGGLE_LOCK, FIRE, REVEAL,
+           TOGGLE_COLUMN_LOCK, TOGGLE_ROW_LOCK} action = NONE;
+    char buf[80], *nullret = NULL;
+
+    if (IS_CURSOR_MOVE(button)) {
+        int cx = ui->cur_x, cy = ui->cur_y;
+
+        move_cursor(button, &cx, &cy, state->w+2, state->h+2, 0);
+        if ((cx == 0 && cy == 0 && !CAN_REVEAL(state)) ||
+            (cx == 0 && cy == state->h+1) ||
+            (cx == state->w+1 && cy == 0) ||
+            (cx == state->w+1 && cy == state->h+1))
+            return NULL; /* disallow moving cursor to corners. */
+        ui->cur_x = cx;
+        ui->cur_y = cy;
+        ui->cur_visible = 1;
+        return "";
+    }
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        gx = FROMDRAW(x);
+        gy = FROMDRAW(y);
+        ui->cur_visible = 0;
+        wouldflash = 1;
+    } else if (button == LEFT_RELEASE) {
+        ui->flash_laser = 0;
+        return "";
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (ui->cur_visible) {
+            gx = ui->cur_x;
+            gy = ui->cur_y;
+            ui->flash_laser = 0;
+            wouldflash = 2;
+        } else {
+            ui->cur_visible = 1;
+            return "";
+        }
+        /* Fix up 'button' for the below logic. */
+        if (button == CURSOR_SELECT2) button = RIGHT_BUTTON;
+        else button = LEFT_BUTTON;
+    }
+
+    if (gx != -1 && gy != -1) {
+        if (gx == 0 && gy == 0 && button == LEFT_BUTTON)
+            action = REVEAL;
+        if (gx >= 1 && gx <= state->w && gy >= 1 && gy <= state->h) {
+            if (button == LEFT_BUTTON) {
+                if (!(GRID(state, gx,gy) & BALL_LOCK))
+                    action = TOGGLE_BALL;
+            } else
+                action = TOGGLE_LOCK;
+        }
+        if (grid2range(state, gx, gy, &rangeno)) {
+            if (button == LEFT_BUTTON)
+                action = FIRE;
+            else if (gy == 0 || gy > state->h)
+                action = TOGGLE_COLUMN_LOCK; /* and use gx */
+            else
+                action = TOGGLE_ROW_LOCK;    /* and use gy */
+        }
+    }
+
+    switch (action) {
+    case TOGGLE_BALL:
+        sprintf(buf, "T%d,%d", gx, gy);
+        break;
+
+    case TOGGLE_LOCK:
+        sprintf(buf, "LB%d,%d", gx, gy);
+        break;
+
+    case TOGGLE_COLUMN_LOCK:
+        sprintf(buf, "LC%d", gx);
+        break;
+
+    case TOGGLE_ROW_LOCK:
+        sprintf(buf, "LR%d", gy);
+        break;
+
+    case FIRE:
+        if (state->reveal && state->exits[rangeno] == LASER_EMPTY)
+            return nullret;
+        ui->flash_laserno = rangeno;
+        ui->flash_laser = wouldflash;
+        nullret = "";
+        if (state->exits[rangeno] != LASER_EMPTY)
+            return "";
+        sprintf(buf, "F%d", rangeno);
+        break;
+
+    case REVEAL:
+        if (!CAN_REVEAL(state)) return nullret;
+        if (ui->cur_visible == 1) ui->cur_x = ui->cur_y = 1;
+        sprintf(buf, "R");
+        break;
+
+    default:
+        return nullret;
+    }
+    if (state->reveal) return nullret;
+    ui->newmove = TRUE;
+    return dupstr(buf);
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    game_state *ret = dup_game(from);
+    int gx = -1, gy = -1, rangeno = -1;
+
+    if (ret->justwrong) {
+        int i;
+        ret->justwrong = FALSE;
+        for (i = 0; i < ret->nlasers; i++)
+            if (ret->exits[i] != LASER_EMPTY)
+                ret->exits[i] &= ~(LASER_OMITTED | LASER_WRONG);
+    }
+
+    if (!strcmp(move, "S")) {
+        check_guesses(ret, FALSE);
+        return ret;
+    }
+
+    if (from->reveal) goto badmove;
+    if (!*move) goto badmove;
+
+    switch (move[0]) {
+    case 'T':
+        sscanf(move+1, "%d,%d", &gx, &gy);
+        if (gx < 1 || gy < 1 || gx > ret->w || gy > ret->h)
+            goto badmove;
+        if (GRID(ret, gx, gy) & BALL_GUESS) {
+            ret->nguesses--;
+            GRID(ret, gx, gy) &= ~BALL_GUESS;
+        } else {
+            ret->nguesses++;
+            GRID(ret, gx, gy) |= BALL_GUESS;
+        }
+        break;
+
+    case 'F':
+        sscanf(move+1, "%d", &rangeno);
+        if (ret->exits[rangeno] != LASER_EMPTY)
+            goto badmove;
+        if (!RANGECHECK(ret, rangeno))
+            goto badmove;
+        fire_laser(ret, rangeno);
+        break;
+
+    case 'R':
+        if (ret->nguesses < ret->minballs ||
+            ret->nguesses > ret->maxballs)
+            goto badmove;
+        check_guesses(ret, TRUE);
+        break;
+
+    case 'L':
+        {
+            int lcount = 0;
+            if (strlen(move) < 2) goto badmove;
+            switch (move[1]) {
+            case 'B':
+                sscanf(move+2, "%d,%d", &gx, &gy);
+                if (gx < 1 || gy < 1 || gx > ret->w || gy > ret->h)
+                    goto badmove;
+                GRID(ret, gx, gy) ^= BALL_LOCK;
+                break;
+
+#define COUNTLOCK do { if (GRID(ret, gx, gy) & BALL_LOCK) lcount++; } while (0)
+#define SETLOCKIF(c) do {                                       \
+    if (lcount > (c)) GRID(ret, gx, gy) &= ~BALL_LOCK;          \
+    else              GRID(ret, gx, gy) |= BALL_LOCK;           \
+} while(0)
+
+            case 'C':
+                sscanf(move+2, "%d", &gx);
+                if (gx < 1 || gx > ret->w) goto badmove;
+                for (gy = 1; gy <= ret->h; gy++) { COUNTLOCK; }
+                for (gy = 1; gy <= ret->h; gy++) { SETLOCKIF(ret->h/2); }
+                break;
+
+            case 'R':
+                sscanf(move+2, "%d", &gy);
+                if (gy < 1 || gy > ret->h) goto badmove;
+                for (gx = 1; gx <= ret->w; gx++) { COUNTLOCK; }
+                for (gx = 1; gx <= ret->w; gx++) { SETLOCKIF(ret->w/2); }
+                break;
+
+#undef COUNTLOCK
+#undef SETLOCKIF
+
+            default:
+                goto badmove;
+            }
+        }
+        break;
+
+    default:
+        goto badmove;
+    }
+
+    return ret;
+
+badmove:
+    free_game(ret);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Border is ts/2, to make things easier.
+     * Thus we have (width) + 2 (firing range*2) + 1 (border*2) tiles
+     * across, and similarly height + 2 + 1 tiles down. */
+    *x = (params->w + 3) * tilesize;
+    *y = (params->h + 3) * tilesize;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+    ds->crad = (tilesize-1)/2;
+    ds->rrad = (3*tilesize)/8;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    ret[COL_BALL * 3 + 0] = 0.0F;
+    ret[COL_BALL * 3 + 1] = 0.0F;
+    ret[COL_BALL * 3 + 2] = 0.0F;
+
+    ret[COL_WRONG * 3 + 0] = 1.0F;
+    ret[COL_WRONG * 3 + 1] = 0.0F;
+    ret[COL_WRONG * 3 + 2] = 0.0F;
+
+    ret[COL_BUTTON * 3 + 0] = 0.0F;
+    ret[COL_BUTTON * 3 + 1] = 1.0F;
+    ret[COL_BUTTON * 3 + 2] = 0.0F;
+
+    ret[COL_CURSOR * 3 + 0] = 1.0F;
+    ret[COL_CURSOR * 3 + 1] = 0.0F;
+    ret[COL_CURSOR * 3 + 2] = 0.0F;
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_GRID * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 0.9F;
+        ret[COL_LOCK * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 0.7F;
+        ret[COL_COVER * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 0.5F;
+        ret[COL_TEXT * 3 + i] = 0.0F;
+    }
+
+    ret[COL_FLASHTEXT * 3 + 0] = 0.0F;
+    ret[COL_FLASHTEXT * 3 + 1] = 1.0F;
+    ret[COL_FLASHTEXT * 3 + 2] = 0.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->tilesize = 0;
+    ds->w = state->w; ds->h = state->h;
+    ds->grid = snewn((state->w+2)*(state->h+2), unsigned int);
+    memset(ds->grid, 0, (state->w+2)*(state->h+2)*sizeof(unsigned int));
+    ds->started = ds->reveal = 0;
+    ds->flash_laserno = LASER_EMPTY;
+    ds->isflash = 0;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+static void draw_square_cursor(drawing *dr, game_drawstate *ds, int dx, int dy)
+{
+    int coff = TILE_SIZE/8;
+    draw_rect_outline(dr, dx + coff, dy + coff,
+                      TILE_SIZE - coff*2,
+                      TILE_SIZE - coff*2,
+                      COL_CURSOR);
+}
+
+
+static void draw_arena_tile(drawing *dr, const game_state *gs,
+                            game_drawstate *ds, const game_ui *ui,
+                            int ax, int ay, int force, int isflash)
+{
+    int gx = ax+1, gy = ay+1;
+    int gs_tile = GRID(gs, gx, gy), ds_tile = GRID(ds, gx, gy);
+    int dx = TODRAW(gx), dy = TODRAW(gy);
+
+    if (ui->cur_visible && ui->cur_x == gx && ui->cur_y == gy)
+        gs_tile |= FLAG_CURSOR;
+
+    if (gs_tile != ds_tile || gs->reveal != ds->reveal || force) {
+        int bcol, ocol, bg;
+
+        bg = (gs->reveal ? COL_BACKGROUND :
+              (gs_tile & BALL_LOCK) ? COL_LOCK : COL_COVER);
+
+        draw_rect(dr, dx, dy, TILE_SIZE, TILE_SIZE, bg);
+        draw_rect_outline(dr, dx, dy, TILE_SIZE, TILE_SIZE, COL_GRID);
+
+        if (gs->reveal) {
+            /* Guessed balls are always black; if they're incorrect they'll
+             * have a red cross added later.
+             * Missing balls are red. */
+            if (gs_tile & BALL_GUESS) {
+                bcol = isflash ? bg : COL_BALL;
+            } else if (gs_tile & BALL_CORRECT) {
+                bcol = isflash ? bg : COL_WRONG;
+            } else {
+                bcol = bg;
+            }
+        } else {
+            /* guesses are black/black, all else background. */
+            if (gs_tile & BALL_GUESS) {
+                bcol = COL_BALL;
+            } else {
+                bcol = bg;
+            }
+        }
+        ocol = (gs_tile & FLAG_CURSOR && bcol != bg) ? COL_CURSOR : bcol;
+
+        draw_circle(dr, dx + TILE_SIZE/2, dy + TILE_SIZE/2, ds->crad-1,
+                    ocol, ocol);
+        draw_circle(dr, dx + TILE_SIZE/2, dy + TILE_SIZE/2, ds->crad-3,
+                    bcol, bcol);
+
+
+        if (gs_tile & FLAG_CURSOR && bcol == bg)
+            draw_square_cursor(dr, ds, dx, dy);
+
+        if (gs->reveal &&
+            (gs_tile & BALL_GUESS) &&
+            !(gs_tile & BALL_CORRECT)) {
+            int x1 = dx + 3, y1 = dy + 3;
+            int x2 = dx + TILE_SIZE - 3, y2 = dy + TILE_SIZE-3;
+            int coords[8];
+
+            /* Incorrect guess; draw a red cross over the ball. */
+            coords[0] = x1-1;
+            coords[1] = y1+1;
+            coords[2] = x1+1;
+            coords[3] = y1-1;
+            coords[4] = x2+1;
+            coords[5] = y2-1;
+            coords[6] = x2-1;
+            coords[7] = y2+1;
+            draw_polygon(dr, coords, 4, COL_WRONG, COL_WRONG);
+            coords[0] = x2+1;
+            coords[1] = y1+1;
+            coords[2] = x2-1;
+            coords[3] = y1-1;
+            coords[4] = x1-1;
+            coords[5] = y2-1;
+            coords[6] = x1+1;
+            coords[7] = y2+1;
+            draw_polygon(dr, coords, 4, COL_WRONG, COL_WRONG);
+        }
+        draw_update(dr, dx, dy, TILE_SIZE, TILE_SIZE);
+    }
+    GRID(ds,gx,gy) = gs_tile;
+}
+
+static void draw_laser_tile(drawing *dr, const game_state *gs,
+                            game_drawstate *ds, const game_ui *ui,
+                            int lno, int force)
+{
+    int gx, gy, dx, dy, unused;
+    int wrong, omitted, reflect, hit, laserval, flash = 0, tmp;
+    unsigned int gs_tile, ds_tile, exitno;
+
+    tmp = range2grid(gs, lno, &gx, &gy, &unused);
+    assert(tmp);
+    gs_tile = GRID(gs, gx, gy);
+    ds_tile = GRID(ds, gx, gy);
+    dx = TODRAW(gx);
+    dy = TODRAW(gy);
+
+    wrong = gs->exits[lno] & LASER_WRONG;
+    omitted = gs->exits[lno] & LASER_OMITTED;
+    exitno = gs->exits[lno] & ~LASER_FLAGMASK;
+
+    reflect = gs_tile & LASER_REFLECT;
+    hit = gs_tile & LASER_HIT;
+    laserval = gs_tile & ~LASER_FLAGMASK;
+
+    if (lno == ds->flash_laserno)
+        gs_tile |= LASER_FLASHED;
+    else if (!(gs->exits[lno] & (LASER_HIT | LASER_REFLECT))) {
+        if (exitno == ds->flash_laserno)
+            gs_tile |= LASER_FLASHED;
+    }
+    if (gs_tile & LASER_FLASHED) flash = 1;
+
+    gs_tile |= wrong | omitted;
+
+    if (ui->cur_visible && ui->cur_x == gx && ui->cur_y == gy)
+        gs_tile |= FLAG_CURSOR;
+
+    if (gs_tile != ds_tile || force) {
+        draw_rect(dr, dx, dy, TILE_SIZE, TILE_SIZE, COL_BACKGROUND);
+        draw_rect_outline(dr, dx, dy, TILE_SIZE, TILE_SIZE, COL_GRID);
+
+        if (gs_tile &~ (LASER_WRONG | LASER_OMITTED | FLAG_CURSOR)) {
+            char str[32];
+            int tcol = flash ? COL_FLASHTEXT : omitted ? COL_WRONG : COL_TEXT;
+
+            if (reflect || hit)
+                sprintf(str, "%s", reflect ? "R" : "H");
+            else
+                sprintf(str, "%d", laserval);
+
+            if (wrong) {
+                draw_circle(dr, dx + TILE_SIZE/2, dy + TILE_SIZE/2,
+                            ds->rrad,
+                            COL_WRONG, COL_WRONG);
+                draw_circle(dr, dx + TILE_SIZE/2, dy + TILE_SIZE/2,
+                            ds->rrad - TILE_SIZE/16,
+                            COL_BACKGROUND, COL_WRONG);
+            }
+
+            draw_text(dr, dx + TILE_SIZE/2, dy + TILE_SIZE/2,
+                      FONT_VARIABLE, TILE_SIZE/2, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                      tcol, str);
+        }
+        if (gs_tile & FLAG_CURSOR)
+            draw_square_cursor(dr, ds, dx, dy);
+
+        draw_update(dr, dx, dy, TILE_SIZE, TILE_SIZE);
+    }
+    GRID(ds, gx, gy) = gs_tile;
+}
+
+#define CUR_ANIM 0.2F
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int i, x, y, ts = TILE_SIZE, isflash = 0, force = 0;
+
+    if (flashtime > 0) {
+        int frame = (int)(flashtime / FLASH_FRAME);
+        isflash = (frame % 2) == 0;
+        debug(("game_redraw: flashtime = %f", flashtime));
+    }
+
+    if (!ds->started) {
+        int x0 = TODRAW(0)-1, y0 = TODRAW(0)-1;
+        int x1 = TODRAW(state->w+2), y1 = TODRAW(state->h+2);
+
+        draw_rect(dr, 0, 0,
+                  TILE_SIZE * (state->w+3), TILE_SIZE * (state->h+3),
+                  COL_BACKGROUND);
+
+        /* clockwise around the outline starting at pt behind (1,1). */
+        draw_line(dr, x0+ts, y0+ts, x0+ts, y0,    COL_HIGHLIGHT);
+        draw_line(dr, x0+ts, y0,    x1-ts, y0,    COL_HIGHLIGHT);
+        draw_line(dr, x1-ts, y0,    x1-ts, y0+ts, COL_LOWLIGHT);
+        draw_line(dr, x1-ts, y0+ts, x1,    y0+ts, COL_HIGHLIGHT);
+        draw_line(dr, x1,    y0+ts, x1,    y1-ts, COL_LOWLIGHT);
+        draw_line(dr, x1,    y1-ts, x1-ts, y1-ts, COL_LOWLIGHT);
+        draw_line(dr, x1-ts, y1-ts, x1-ts, y1,    COL_LOWLIGHT);
+        draw_line(dr, x1-ts, y1,    x0+ts, y1,    COL_LOWLIGHT);
+        draw_line(dr, x0+ts, y1,    x0+ts, y1-ts, COL_HIGHLIGHT);
+        draw_line(dr, x0+ts, y1-ts, x0,    y1-ts, COL_LOWLIGHT);
+        draw_line(dr, x0,    y1-ts, x0,    y0+ts, COL_HIGHLIGHT);
+        draw_line(dr, x0,    y0+ts, x0+ts, y0+ts, COL_HIGHLIGHT);
+        /* phew... */
+
+        draw_update(dr, 0, 0,
+                    TILE_SIZE * (state->w+3), TILE_SIZE * (state->h+3));
+        force = 1;
+        ds->started = 1;
+    }
+
+    if (isflash != ds->isflash) force = 1;
+
+    /* draw the arena */
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            draw_arena_tile(dr, state, ds, ui, x, y, force, isflash);
+        }
+    }
+
+    /* draw the lasers */
+    ds->flash_laserno = LASER_EMPTY;
+    if (ui->flash_laser == 1)
+        ds->flash_laserno = ui->flash_laserno;
+    else if (ui->flash_laser == 2 && animtime > 0)
+        ds->flash_laserno = ui->flash_laserno;
+
+    for (i = 0; i < 2*(state->w+state->h); i++) {
+        draw_laser_tile(dr, state, ds, ui, i, force);
+    }
+
+    /* draw the 'finish' button */
+    if (CAN_REVEAL(state)) {
+        int outline = (ui->cur_visible && ui->cur_x == 0 && ui->cur_y == 0)
+            ? COL_CURSOR : COL_BALL;
+        clip(dr, TODRAW(0)-1, TODRAW(0)-1, TILE_SIZE+1, TILE_SIZE+1);
+        draw_circle(dr, TODRAW(0) + ds->crad, TODRAW(0) + ds->crad, ds->crad,
+                    outline, outline);
+        draw_circle(dr, TODRAW(0) + ds->crad, TODRAW(0) + ds->crad, ds->crad-2,
+                    COL_BUTTON, COL_BUTTON);
+        unclip(dr);
+    } else {
+        draw_rect(dr, TODRAW(0)-1, TODRAW(0)-1,
+                  TILE_SIZE+1, TILE_SIZE+1, COL_BACKGROUND);
+    }
+    draw_update(dr, TODRAW(0), TODRAW(0), TILE_SIZE, TILE_SIZE);
+    ds->reveal = state->reveal;
+    ds->isflash = isflash;
+
+    {
+        char buf[256];
+
+        if (ds->reveal) {
+            if (state->nwrong == 0 &&
+                state->nmissed == 0 &&
+                state->nright >= state->minballs)
+                sprintf(buf, "CORRECT!");
+            else
+                sprintf(buf, "%d wrong and %d missed balls.",
+                        state->nwrong, state->nmissed);
+        } else if (state->justwrong) {
+            sprintf(buf, "Wrong! Guess again.");
+        } else {
+            if (state->nguesses > state->maxballs)
+                sprintf(buf, "%d too many balls marked.",
+                        state->nguesses - state->maxballs);
+            else if (state->nguesses <= state->maxballs &&
+                     state->nguesses >= state->minballs)
+                sprintf(buf, "Click button to verify guesses.");
+            else if (state->maxballs == state->minballs)
+                sprintf(buf, "Balls marked: %d / %d",
+                        state->nguesses, state->minballs);
+            else
+                sprintf(buf, "Balls marked: %d / %d-%d.",
+                        state->nguesses, state->minballs, state->maxballs);
+        }
+        if (ui->errors) {
+            sprintf(buf + strlen(buf), " (%d error%s)",
+                    ui->errors, ui->errors > 1 ? "s" : "");
+        }
+        status_bar(dr, buf);
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return (ui->flash_laser == 2) ? CUR_ANIM : 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->reveal && newstate->reveal)
+        return 4.0F * FLASH_FRAME;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    if (state->reveal) {
+        /*
+         * We return nonzero whenever the solution has been revealed,
+         * even (on spoiler grounds) if it wasn't guessed correctly.
+         */
+        if (state->nwrong == 0 &&
+            state->nmissed == 0 &&
+            state->nright >= state->minballs)
+            return +1;
+        else
+            return -1;
+    }
+    return 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame blackbox
+#endif
+
+const struct game thegame = {
+    "Black Box", "games.blackbox", "blackbox",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON,                   /* flags */
+};
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/bridges.R b/apps/plugins/puzzles/bridges.R
new file mode 100644
index 0000000000..75df309152
--- /dev/null
+++ b/apps/plugins/puzzles/bridges.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+BRIDGES_EXTRA = dsf findloop
+
+bridges  : [X] GTK COMMON bridges BRIDGES_EXTRA bridges-icon|no-icon
+
+bridges  : [G] WINDOWS COMMON bridges BRIDGES_EXTRA bridges.res|noicon.res
+
+ALL += bridges[COMBINED] BRIDGES_EXTRA
+
+!begin am gtk
+GAMES += bridges
+!end
+
+!begin >list.c
+    A(bridges) \
+!end
+
+!begin >gamedesc.txt
+bridges:bridges.exe:Bridges:Bridge-placing puzzle:Connect all the islands with a network of bridges.
+!end
diff --git a/apps/plugins/puzzles/bridges.c b/apps/plugins/puzzles/bridges.c
new file mode 100644
index 0000000000..05a9b16823
--- /dev/null
+++ b/apps/plugins/puzzles/bridges.c
@@ -0,0 +1,3262 @@
+/*
+ * bridges.c: Implementation of the Nikoli game 'Bridges'.
+ *
+ * Things still to do:
+ *
+ *  - The solver's algorithmic design is not really ideal. It makes
+ *    use of the same data representation as gameplay uses, which
+ *    often looks like a tempting reuse of code but isn't always a
+ *    good idea. In this case, it's unpleasant that each edge of the
+ *    graph ends up represented as multiple squares on a grid, with
+ *    flags indicating when edges and non-edges cross; that's useful
+ *    when the result can be directly translated into positions of
+ *    graphics on the display, but in purely internal work it makes
+ *    even simple manipulations during solving more painful than they
+ *    should be, and complex ones have no choice but to modify the
+ *    data structures temporarily, test things, and put them back. I
+ *    envisage a complete solver rewrite along the following lines:
+ *     + We have a collection of vertices (islands) and edges
+ *       (potential bridge locations, i.e. pairs of horizontal or
+ *       vertical islands with no other island in between).
+ *     + Each edge has an associated list of edges that cross it, and
+ *       hence with which it is mutually exclusive.
+ *     + For each edge, we track the min and max number of bridges we
+ *       currently think possible.
+ *     + For each vertex, we track the number of _liberties_ it has,
+ *       i.e. its clue number minus the min bridge count for each edge
+ *       out of it.
+ *     + We also maintain a dsf that identifies sets of vertices which
+ *       are connected components of the puzzle so far, and for each
+ *       equivalence class we track the total number of liberties for
+ *       that component. (The dsf mechanism will also already track
+ *       the size of each component, i.e. number of islands.)
+ *     + So incrementing the min for an edge requires processing along
+ *       the lines of:
+ *        - set the max for all edges crossing that one to zero
+ *        - decrement the liberty count for the vertex at each end,
+ *          and also for each vertex's equivalence class (NB they may
+ *          be the same class)
+ *        - unify the two equivalence classes if they're not already,
+ *          and if so, set the liberty count for the new class to be
+ *          the sum of the previous two.
+ *     + Decrementing the max is much easier, however.
+ *     + With this data structure the really fiddly stuff in stage3()
+ *       becomes more or less trivial, because it's now a quick job to
+ *       find out whether an island would form an isolated subgraph if
+ *       connected to a given subset of its neighbours:
+ *        - identify the connected components containing the test
+ *          vertex and its putative new neighbours (but be careful not
+ *          to count a component more than once if two or more of the
+ *          vertices involved are already in the same one)
+ *        - find the sum of those components' liberty counts, and also
+ *          the total number of islands involved
+ *        - if the total liberty count of the connected components is
+ *          exactly equal to twice the number of edges we'd be adding
+ *          (of course each edge destroys two liberties, one at each
+ *          end) then these components would become a subgraph with
+ *          zero liberties if connected together.
+ *        - therefore, if that subgraph also contains fewer than the
+ *          total number of islands, it's disallowed.
+ *        - As mentioned in stage3(), once we've identified such a
+ *          disallowed pattern, we have two choices for what to do
+ *          with it: if the candidate set of neighbours has size 1 we
+ *          can reduce the max for the edge to that one neighbour,
+ *          whereas if its complement has size 1 we can increase the
+ *          min for the edge to the _omitted_ neighbour.
+ *
+ *  - write a recursive solver?
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+/* Turn this on for hints about which lines are considered possibilities. */
+#undef DRAW_GRID
+
+/* --- structures for params, state, etc. --- */
+
+#define MAX_BRIDGES     4
+
+#define PREFERRED_TILE_SIZE 24
+#define TILE_SIZE       (ds->tilesize)
+#define BORDER          (TILE_SIZE / 2)
+
+#define COORD(x)  ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
+
+#define FLASH_TIME 0.50F
+
+enum {
+    COL_BACKGROUND,
+    COL_FOREGROUND,
+    COL_HIGHLIGHT, COL_LOWLIGHT,
+    COL_SELECTED, COL_MARK,
+    COL_HINT, COL_GRID,
+    COL_WARNING,
+    COL_CURSOR,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h, maxb;
+    int islands, expansion;     /* %age of island squares, %age chance of expansion */
+    int allowloops, difficulty;
+};
+
+/* general flags used by all structs */
+#define G_ISLAND        0x0001
+#define G_LINEV         0x0002     /* contains a vert. line */
+#define G_LINEH         0x0004     /* contains a horiz. line (mutex with LINEV) */
+#define G_LINE          (G_LINEV|G_LINEH)
+#define G_MARKV         0x0008
+#define G_MARKH         0x0010
+#define G_MARK          (G_MARKV|G_MARKH)
+#define G_NOLINEV       0x0020
+#define G_NOLINEH       0x0040
+#define G_NOLINE        (G_NOLINEV|G_NOLINEH)
+
+/* flags used by the error checker */
+#define G_WARN          0x0080
+
+/* flags used by the solver etc. */
+#define G_SWEEP         0x1000
+
+#define G_FLAGSH        (G_LINEH|G_MARKH|G_NOLINEH)
+#define G_FLAGSV        (G_LINEV|G_MARKV|G_NOLINEV)
+
+typedef unsigned int grid_type; /* change me later if we invent > 16 bits of flags. */
+
+struct solver_state {
+    int *dsf, *comptspaces;
+    int *tmpdsf, *tmpcompspaces;
+    int refcount;
+};
+
+/* state->gridi is an optimisation; it stores the pointer to the island
+ * structs indexed by (x,y). It's not strictly necessary (we could use
+ * find234 instead), but Purify showed that board generation (mostly the solver)
+ * was spending 60% of its time in find234. */
+
+struct surrounds { /* cloned from lightup.c */
+    struct { int x, y, dx, dy, off; } points[4];
+    int npoints, nislands;
+};
+
+struct island {
+  game_state *state;
+  int x, y, count;
+  struct surrounds adj;
+};
+
+struct game_state {
+    int w, h, completed, solved, allowloops, maxb;
+    grid_type *grid;
+    struct island *islands;
+    int n_islands, n_islands_alloc;
+    game_params params; /* used by the aux solver. */
+#define N_WH_ARRAYS 5
+    char *wha, *possv, *possh, *lines, *maxv, *maxh;
+    struct island **gridi;
+    struct solver_state *solver; /* refcounted */
+};
+
+#define GRIDSZ(s) ((s)->w * (s)->h * sizeof(grid_type))
+
+#define INGRID(s,x,y) ((x) >= 0 && (x) < (s)->w && (y) >= 0 && (y) < (s)->h)
+
+#define DINDEX(x,y) ((y)*state->w + (x))
+
+#define INDEX(s,g,x,y) ((s)->g[(y)*((s)->w) + (x)])
+#define IDX(s,g,i) ((s)->g[(i)])
+#define GRID(s,x,y) INDEX(s,grid,x,y)
+#define POSSIBLES(s,dx,x,y) ((dx) ? (INDEX(s,possh,x,y)) : (INDEX(s,possv,x,y)))
+#define MAXIMUM(s,dx,x,y) ((dx) ? (INDEX(s,maxh,x,y)) : (INDEX(s,maxv,x,y)))
+
+#define GRIDCOUNT(s,x,y,f) ((GRID(s,x,y) & (f)) ? (INDEX(s,lines,x,y)) : 0)
+
+#define WITHIN2(x,min,max) (((x) < (min)) ? 0 : (((x) > (max)) ? 0 : 1))
+#define WITHIN(x,min,max) ((min) > (max) ? \
+                           WITHIN2(x,max,min) : WITHIN2(x,min,max))
+
+/* --- island struct and tree support functions --- */
+
+#define ISLAND_ORTH(is,j,f,df) \
+    (is->f + (is->adj.points[(j)].off*is->adj.points[(j)].df))
+
+#define ISLAND_ORTHX(is,j) ISLAND_ORTH(is,j,x,dx)
+#define ISLAND_ORTHY(is,j) ISLAND_ORTH(is,j,y,dy)
+
+static void fixup_islands_for_realloc(game_state *state)
+{
+    int i;
+
+    for (i = 0; i < state->w*state->h; i++) state->gridi[i] = NULL;
+    for (i = 0; i < state->n_islands; i++) {
+        struct island *is = &state->islands[i];
+        is->state = state;
+        INDEX(state, gridi, is->x, is->y) = is;
+    }
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int x, y, len, nl;
+    char *ret, *p;
+    struct island *is;
+    grid_type grid;
+
+    len = (state->h) * (state->w+1) + 1;
+    ret = snewn(len, char);
+    p = ret;
+
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            grid = GRID(state,x,y);
+            nl = INDEX(state,lines,x,y);
+            is = INDEX(state, gridi, x, y);
+            if (is) {
+                *p++ = '0' + is->count;
+            } else if (grid & G_LINEV) {
+                *p++ = (nl > 1) ? '"' : (nl == 1) ? '|' : '!'; /* gaah, want a double-bar. */
+            } else if (grid & G_LINEH) {
+                *p++ = (nl > 1) ? '=' : (nl == 1) ? '-' : '~';
+            } else {
+                *p++ = '.';
+            }
+        }
+        *p++ = '\n';
+    }
+    *p++ = '\0';
+
+    assert(p - ret == len);
+    return ret;
+}
+
+static void debug_state(game_state *state)
+{
+    char *textversion = game_text_format(state);
+    debug(("%s", textversion));
+    sfree(textversion);
+}
+
+/*static void debug_possibles(game_state *state)
+{
+    int x, y;
+    debug(("possh followed by possv\n"));
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            debug(("%d", POSSIBLES(state, 1, x, y)));
+        }
+        debug((" "));
+        for (x = 0; x < state->w; x++) {
+            debug(("%d", POSSIBLES(state, 0, x, y)));
+        }
+        debug(("\n"));
+    }
+    debug(("\n"));
+        for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            debug(("%d", MAXIMUM(state, 1, x, y)));
+        }
+        debug((" "));
+        for (x = 0; x < state->w; x++) {
+            debug(("%d", MAXIMUM(state, 0, x, y)));
+        }
+        debug(("\n"));
+    }
+    debug(("\n"));
+}*/
+
+static void island_set_surrounds(struct island *is)
+{
+    assert(INGRID(is->state,is->x,is->y));
+    is->adj.npoints = is->adj.nislands = 0;
+#define ADDPOINT(cond,ddx,ddy) do {\
+    if (cond) { \
+        is->adj.points[is->adj.npoints].x = is->x+(ddx); \
+        is->adj.points[is->adj.npoints].y = is->y+(ddy); \
+        is->adj.points[is->adj.npoints].dx = (ddx); \
+        is->adj.points[is->adj.npoints].dy = (ddy); \
+        is->adj.points[is->adj.npoints].off = 0; \
+        is->adj.npoints++; \
+    } } while(0)
+    ADDPOINT(is->x > 0,                -1,  0);
+    ADDPOINT(is->x < (is->state->w-1), +1,  0);
+    ADDPOINT(is->y > 0,                 0, -1);
+    ADDPOINT(is->y < (is->state->h-1),  0, +1);
+}
+
+static void island_find_orthogonal(struct island *is)
+{
+    /* fills in the rest of the 'surrounds' structure, assuming
+     * all other islands are now in place. */
+    int i, x, y, dx, dy, off;
+
+    is->adj.nislands = 0;
+    for (i = 0; i < is->adj.npoints; i++) {
+        dx = is->adj.points[i].dx;
+        dy = is->adj.points[i].dy;
+        x = is->x + dx;
+        y = is->y + dy;
+        off = 1;
+        is->adj.points[i].off = 0;
+        while (INGRID(is->state, x, y)) {
+            if (GRID(is->state, x, y) & G_ISLAND) {
+                is->adj.points[i].off = off;
+                is->adj.nislands++;
+                /*debug(("island (%d,%d) has orth is. %d*(%d,%d) away at (%d,%d).\n",
+                       is->x, is->y, off, dx, dy,
+                       ISLAND_ORTHX(is,i), ISLAND_ORTHY(is,i)));*/
+                goto foundisland;
+            }
+            off++; x += dx; y += dy;
+        }
+foundisland:
+        ;
+    }
+}
+
+static int island_hasbridge(struct island *is, int direction)
+{
+    int x = is->adj.points[direction].x;
+    int y = is->adj.points[direction].y;
+    grid_type gline = is->adj.points[direction].dx ? G_LINEH : G_LINEV;
+
+    if (GRID(is->state, x, y) & gline) return 1;
+    return 0;
+}
+
+static struct island *island_find_connection(struct island *is, int adjpt)
+{
+    struct island *is_r;
+
+    assert(adjpt < is->adj.npoints);
+    if (!is->adj.points[adjpt].off) return NULL;
+    if (!island_hasbridge(is, adjpt)) return NULL;
+
+    is_r = INDEX(is->state, gridi,
+                 ISLAND_ORTHX(is, adjpt), ISLAND_ORTHY(is, adjpt));
+    assert(is_r);
+
+    return is_r;
+}
+
+static struct island *island_add(game_state *state, int x, int y, int count)
+{
+    struct island *is;
+    int realloced = 0;
+
+    assert(!(GRID(state,x,y) & G_ISLAND));
+    GRID(state,x,y) |= G_ISLAND;
+
+    state->n_islands++;
+    if (state->n_islands > state->n_islands_alloc) {
+        state->n_islands_alloc = state->n_islands * 2;
+        state->islands =
+            sresize(state->islands, state->n_islands_alloc, struct island);
+        realloced = 1;
+    }
+    is = &state->islands[state->n_islands-1];
+
+    memset(is, 0, sizeof(struct island));
+    is->state = state;
+    is->x = x;
+    is->y = y;
+    is->count = count;
+    island_set_surrounds(is);
+
+    if (realloced)
+        fixup_islands_for_realloc(state);
+    else
+        INDEX(state, gridi, x, y) = is;
+
+    return is;
+}
+
+
+/* n = -1 means 'flip NOLINE flags [and set line to 0].' */
+static void island_join(struct island *i1, struct island *i2, int n, int is_max)
+{
+    game_state *state = i1->state;
+    int s, e, x, y;
+
+    assert(i1->state == i2->state);
+    assert(n >= -1 && n <= i1->state->maxb);
+
+    if (i1->x == i2->x) {
+        x = i1->x;
+        if (i1->y < i2->y) {
+            s = i1->y+1; e = i2->y-1;
+        } else {
+            s = i2->y+1; e = i1->y-1;
+        }
+        for (y = s; y <= e; y++) {
+            if (is_max) {
+                INDEX(state,maxv,x,y) = n;
+            } else {
+                if (n < 0) {
+                    GRID(state,x,y) ^= G_NOLINEV;
+                } else if (n == 0) {
+                    GRID(state,x,y) &= ~G_LINEV;
+                } else {
+                    GRID(state,x,y) |= G_LINEV;
+                    INDEX(state,lines,x,y) = n;
+                }
+            }
+        }
+    } else if (i1->y == i2->y) {
+        y = i1->y;
+        if (i1->x < i2->x) {
+            s = i1->x+1; e = i2->x-1;
+        } else {
+            s = i2->x+1; e = i1->x-1;
+        }
+        for (x = s; x <= e; x++) {
+            if (is_max) {
+                INDEX(state,maxh,x,y) = n;
+            } else {
+                if (n < 0) {
+                    GRID(state,x,y) ^= G_NOLINEH;
+                } else if (n == 0) {
+                    GRID(state,x,y) &= ~G_LINEH;
+                } else {
+                    GRID(state,x,y) |= G_LINEH;
+                    INDEX(state,lines,x,y) = n;
+                }
+            }
+        }
+    } else {
+        assert(!"island_join: islands not orthogonal.");
+    }
+}
+
+/* Counts the number of bridges currently attached to the island. */
+static int island_countbridges(struct island *is)
+{
+    int i, c = 0;
+
+    for (i = 0; i < is->adj.npoints; i++) {
+        c += GRIDCOUNT(is->state,
+                       is->adj.points[i].x, is->adj.points[i].y,
+                       is->adj.points[i].dx ? G_LINEH : G_LINEV);
+    }
+    /*debug(("island count for (%d,%d) is %d.\n", is->x, is->y, c));*/
+    return c;
+}
+
+static int island_adjspace(struct island *is, int marks, int missing,
+                           int direction)
+{
+    int x, y, poss, curr, dx;
+    grid_type gline, mline;
+
+    x = is->adj.points[direction].x;
+    y = is->adj.points[direction].y;
+    dx = is->adj.points[direction].dx;
+    gline = dx ? G_LINEH : G_LINEV;
+
+    if (marks) {
+        mline = dx ? G_MARKH : G_MARKV;
+        if (GRID(is->state,x,y) & mline) return 0;
+    }
+    poss = POSSIBLES(is->state, dx, x, y);
+    poss = min(poss, missing);
+
+    curr = GRIDCOUNT(is->state, x, y, gline);
+    poss = min(poss, MAXIMUM(is->state, dx, x, y) - curr);
+
+    return poss;
+}
+
+/* Counts the number of bridge spaces left around the island;
+ * expects the possibles to be up-to-date. */
+static int island_countspaces(struct island *is, int marks)
+{
+    int i, c = 0, missing;
+
+    missing = is->count - island_countbridges(is);
+    if (missing < 0) return 0;
+
+    for (i = 0; i < is->adj.npoints; i++) {
+        c += island_adjspace(is, marks, missing, i);
+    }
+    return c;
+}
+
+static int island_isadj(struct island *is, int direction)
+{
+    int x, y;
+    grid_type gline, mline;
+
+    x = is->adj.points[direction].x;
+    y = is->adj.points[direction].y;
+
+    mline = is->adj.points[direction].dx ? G_MARKH : G_MARKV;
+    gline = is->adj.points[direction].dx ? G_LINEH : G_LINEV;
+    if (GRID(is->state, x, y) & mline) {
+        /* If we're marked (i.e. the thing to attach to is complete)
+         * only count an adjacency if we're already attached. */
+        return GRIDCOUNT(is->state, x, y, gline);
+    } else {
+        /* If we're unmarked, count possible adjacency iff it's
+         * flagged as POSSIBLE. */
+        return POSSIBLES(is->state, is->adj.points[direction].dx, x, y);
+    }
+    return 0;
+}
+
+/* Counts the no. of possible adjacent islands (including islands
+ * we're already connected to). */
+static int island_countadj(struct island *is)
+{
+    int i, nadj = 0;
+
+    for (i = 0; i < is->adj.npoints; i++) {
+        if (island_isadj(is, i)) nadj++;
+    }
+    return nadj;
+}
+
+static void island_togglemark(struct island *is)
+{
+    int i, j, x, y, o;
+    struct island *is_loop;
+
+    /* mark the island... */
+    GRID(is->state, is->x, is->y) ^= G_MARK;
+
+    /* ...remove all marks on non-island squares... */
+    for (x = 0; x < is->state->w; x++) {
+        for (y = 0; y < is->state->h; y++) {
+            if (!(GRID(is->state, x, y) & G_ISLAND))
+                GRID(is->state, x, y) &= ~G_MARK;
+        }
+    }
+
+    /* ...and add marks to squares around marked islands. */
+    for (i = 0; i < is->state->n_islands; i++) {
+        is_loop = &is->state->islands[i];
+        if (!(GRID(is_loop->state, is_loop->x, is_loop->y) & G_MARK))
+            continue;
+
+        for (j = 0; j < is_loop->adj.npoints; j++) {
+            /* if this direction takes us to another island, mark all
+             * squares between the two islands. */
+            if (!is_loop->adj.points[j].off) continue;
+            assert(is_loop->adj.points[j].off > 1);
+            for (o = 1; o < is_loop->adj.points[j].off; o++) {
+                GRID(is_loop->state,
+                     is_loop->x + is_loop->adj.points[j].dx*o,
+                     is_loop->y + is_loop->adj.points[j].dy*o) |=
+                    is_loop->adj.points[j].dy ? G_MARKV : G_MARKH;
+            }
+        }
+    }
+}
+
+static int island_impossible(struct island *is, int strict)
+{
+    int curr = island_countbridges(is), nspc = is->count - curr, nsurrspc;
+    int i, poss;
+    struct island *is_orth;
+
+    if (nspc < 0) {
+        debug(("island at (%d,%d) impossible because full.\n", is->x, is->y));
+        return 1;        /* too many bridges */
+    } else if ((curr + island_countspaces(is, 0)) < is->count) {
+        debug(("island at (%d,%d) impossible because not enough spaces.\n", is->x, is->y));
+        return 1;        /* impossible to create enough bridges */
+    } else if (strict && curr < is->count) {
+        debug(("island at (%d,%d) impossible because locked.\n", is->x, is->y));
+        return 1;        /* not enough bridges and island is locked */
+    }
+
+    /* Count spaces in surrounding islands. */
+    nsurrspc = 0;
+    for (i = 0; i < is->adj.npoints; i++) {
+        int ifree, dx = is->adj.points[i].dx;
+
+        if (!is->adj.points[i].off) continue;
+        poss = POSSIBLES(is->state, dx,
+                         is->adj.points[i].x, is->adj.points[i].y);
+        if (poss == 0) continue;
+        is_orth = INDEX(is->state, gridi,
+                        ISLAND_ORTHX(is,i), ISLAND_ORTHY(is,i));
+        assert(is_orth);
+
+        ifree = is_orth->count - island_countbridges(is_orth);
+        if (ifree > 0) {
+            /*
+             * ifree is the number of bridges unfilled in the other
+             * island, which is clearly an upper bound on the number
+             * of extra bridges this island may run to it.
+             *
+             * Another upper bound is the number of bridges unfilled
+             * on the specific line between here and there. We must
+             * take the minimum of both.
+             */
+            int bmax = MAXIMUM(is->state, dx,
+                               is->adj.points[i].x, is->adj.points[i].y);
+            int bcurr = GRIDCOUNT(is->state,
+                                  is->adj.points[i].x, is->adj.points[i].y,
+                                  dx ? G_LINEH : G_LINEV);
+            assert(bcurr <= bmax);
+            nsurrspc += min(ifree, bmax - bcurr);
+        }
+    }
+    if (nsurrspc < nspc) {
+        debug(("island at (%d,%d) impossible: surr. islands %d spc, need %d.\n",
+               is->x, is->y, nsurrspc, nspc));
+        return 1;       /* not enough spaces around surrounding islands to fill this one. */
+    }
+
+    return 0;
+}
+
+/* --- Game parameter functions --- */
+
+#define DEFAULT_PRESET 0
+
+const struct game_params bridges_presets[] = {
+  { 7, 7, 2, 30, 10, 1, 0 },
+  { 7, 7, 2, 30, 10, 1, 1 },
+  { 7, 7, 2, 30, 10, 1, 2 },
+  { 10, 10, 2, 30, 10, 1, 0 },
+  { 10, 10, 2, 30, 10, 1, 1 },
+  { 10, 10, 2, 30, 10, 1, 2 },
+  { 15, 15, 2, 30, 10, 1, 0 },
+  { 15, 15, 2, 30, 10, 1, 1 },
+  { 15, 15, 2, 30, 10, 1, 2 },
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+    *ret = bridges_presets[DEFAULT_PRESET];
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(bridges_presets))
+        return FALSE;
+
+    ret = default_params();
+    *ret = bridges_presets[i];
+    *params = ret;
+
+    sprintf(buf, "%dx%d %s", ret->w, ret->h,
+            ret->difficulty == 0 ? "easy" :
+            ret->difficulty == 1 ? "medium" : "hard");
+    *name = dupstr(buf);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+#define EATNUM(x) do { \
+    (x) = atoi(string); \
+    while (*string && isdigit((unsigned char)*string)) string++; \
+} while(0)
+
+static void decode_params(game_params *params, char const *string)
+{
+    EATNUM(params->w);
+    params->h = params->w;
+    if (*string == 'x') {
+        string++;
+        EATNUM(params->h);
+    }
+    if (*string == 'i') {
+        string++;
+        EATNUM(params->islands);
+    }
+    if (*string == 'e') {
+        string++;
+        EATNUM(params->expansion);
+    }
+    if (*string == 'm') {
+        string++;
+        EATNUM(params->maxb);
+    }
+    params->allowloops = 1;
+    if (*string == 'L') {
+        string++;
+        params->allowloops = 0;
+    }
+    if (*string == 'd') {
+        string++;
+        EATNUM(params->difficulty);
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[80];
+
+    if (full) {
+        sprintf(buf, "%dx%di%de%dm%d%sd%d",
+                params->w, params->h, params->islands, params->expansion,
+                params->maxb, params->allowloops ? "" : "L",
+                params->difficulty);
+    } else {
+        sprintf(buf, "%dx%dm%d%s", params->w, params->h,
+                params->maxb, params->allowloops ? "" : "L");
+    }
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(8, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Difficulty";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = ":Easy:Medium:Hard";
+    ret[2].ival = params->difficulty;
+
+    ret[3].name = "Allow loops";
+    ret[3].type = C_BOOLEAN;
+    ret[3].sval = NULL;
+    ret[3].ival = params->allowloops;
+
+    ret[4].name = "Max. bridges per direction";
+    ret[4].type = C_CHOICES;
+    ret[4].sval = ":1:2:3:4"; /* keep up-to-date with MAX_BRIDGES */
+    ret[4].ival = params->maxb - 1;
+
+    ret[5].name = "%age of island squares";
+    ret[5].type = C_CHOICES;
+    ret[5].sval = ":5%:10%:15%:20%:25%:30%";
+    ret[5].ival = (params->islands / 5)-1;
+
+    ret[6].name = "Expansion factor (%age)";
+    ret[6].type = C_CHOICES;
+    ret[6].sval = ":0%:10%:20%:30%:40%:50%:60%:70%:80%:90%:100%";
+    ret[6].ival = params->expansion / 10;
+
+    ret[7].name = NULL;
+    ret[7].type = C_END;
+    ret[7].sval = NULL;
+    ret[7].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w          = atoi(cfg[0].sval);
+    ret->h          = atoi(cfg[1].sval);
+    ret->difficulty = cfg[2].ival;
+    ret->allowloops = cfg[3].ival;
+    ret->maxb       = cfg[4].ival + 1;
+    ret->islands    = (cfg[5].ival + 1) * 5;
+    ret->expansion  = cfg[6].ival * 10;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 3 || params->h < 3)
+        return "Width and height must be at least 3";
+    if (params->maxb < 1 || params->maxb > MAX_BRIDGES)
+        return "Too many bridges.";
+    if (full) {
+        if (params->islands <= 0 || params->islands > 30)
+            return "%age of island squares must be between 1% and 30%";
+        if (params->expansion < 0 || params->expansion > 100)
+            return "Expansion factor must be between 0 and 100";
+    }
+    return NULL;
+}
+
+/* --- Game encoding and differences --- */
+
+static char *encode_game(game_state *state)
+{
+    char *ret, *p;
+    int wh = state->w*state->h, run, x, y;
+    struct island *is;
+
+    ret = snewn(wh + 1, char);
+    p = ret;
+    run = 0;
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            is = INDEX(state, gridi, x, y);
+            if (is) {
+                if (run) {
+                    *p++ = ('a'-1) + run;
+                    run = 0;
+                }
+                if (is->count < 10)
+                    *p++ = '0' + is->count;
+                else
+                    *p++ = 'A' + (is->count - 10);
+            } else {
+                if (run == 26) {
+                    *p++ = ('a'-1) + run;
+                    run = 0;
+                }
+                run++;
+            }
+        }
+    }
+    if (run) {
+        *p++ = ('a'-1) + run;
+        run = 0;
+    }
+    *p = '\0';
+    assert(p - ret <= wh);
+
+    return ret;
+}
+
+static char *game_state_diff(const game_state *src, const game_state *dest)
+{
+    int movesize = 256, movelen = 0;
+    char *move = snewn(movesize, char), buf[80];
+    int i, d, x, y, len;
+    grid_type gline, nline;
+    struct island *is_s, *is_d, *is_orth;
+
+#define APPEND do {                                     \
+    if (movelen + len >= movesize) {                    \
+        movesize = movelen + len + 256;                 \
+        move = sresize(move, movesize, char);           \
+    }                                                   \
+    strcpy(move + movelen, buf);                        \
+    movelen += len;                                     \
+} while(0)
+
+    move[movelen++] = 'S';
+    move[movelen] = '\0';
+
+    assert(src->n_islands == dest->n_islands);
+
+    for (i = 0; i < src->n_islands; i++) {
+        is_s = &src->islands[i];
+        is_d = &dest->islands[i];
+        assert(is_s->x == is_d->x);
+        assert(is_s->y == is_d->y);
+        assert(is_s->adj.npoints == is_d->adj.npoints); /* more paranoia */
+
+        for (d = 0; d < is_s->adj.npoints; d++) {
+            if (is_s->adj.points[d].dx == -1 ||
+                is_s->adj.points[d].dy == -1) continue;
+
+            x = is_s->adj.points[d].x;
+            y = is_s->adj.points[d].y;
+            gline = is_s->adj.points[d].dx ? G_LINEH : G_LINEV;
+            nline = is_s->adj.points[d].dx ? G_NOLINEH : G_NOLINEV;
+            is_orth = INDEX(dest, gridi,
+                            ISLAND_ORTHX(is_d, d), ISLAND_ORTHY(is_d, d));
+
+            if (GRIDCOUNT(src, x, y, gline) != GRIDCOUNT(dest, x, y, gline)) {
+                assert(is_orth);
+                len = sprintf(buf, ";L%d,%d,%d,%d,%d",
+                              is_s->x, is_s->y, is_orth->x, is_orth->y,
+                              GRIDCOUNT(dest, x, y, gline));
+                APPEND;
+            }
+            if ((GRID(src,x,y) & nline) != (GRID(dest, x, y) & nline)) {
+                assert(is_orth);
+                len = sprintf(buf, ";N%d,%d,%d,%d",
+                              is_s->x, is_s->y, is_orth->x, is_orth->y);
+                APPEND;
+            }
+        }
+        if ((GRID(src, is_s->x, is_s->y) & G_MARK) !=
+            (GRID(dest, is_d->x, is_d->y) & G_MARK)) {
+            len = sprintf(buf, ";M%d,%d", is_s->x, is_s->y);
+            APPEND;
+        }
+    }
+    return move;
+}
+
+/* --- Game setup and solving utilities --- */
+
+/* This function is optimised; a Quantify showed that lots of grid-generation time
+ * (>50%) was spent in here. Hence the IDX() stuff. */
+
+static void map_update_possibles(game_state *state)
+{
+    int x, y, s, e, bl, i, np, maxb, w = state->w, idx;
+    struct island *is_s = NULL, *is_f = NULL;
+
+    /* Run down vertical stripes [un]setting possv... */
+    for (x = 0; x < state->w; x++) {
+        idx = x;
+        s = e = -1;
+        bl = 0;
+        maxb = state->params.maxb;     /* placate optimiser */
+        /* Unset possible flags until we find an island. */
+        for (y = 0; y < state->h; y++) {
+            is_s = IDX(state, gridi, idx);
+            if (is_s) {
+                maxb = is_s->count;
+                break;
+            }
+
+            IDX(state, possv, idx) = 0;
+            idx += w;
+        }
+        for (; y < state->h; y++) {
+            maxb = min(maxb, IDX(state, maxv, idx));
+            is_f = IDX(state, gridi, idx);
+            if (is_f) {
+                assert(is_s);
+                np = min(maxb, is_f->count);
+
+                if (s != -1) {
+                    for (i = s; i <= e; i++) {
+                        INDEX(state, possv, x, i) = bl ? 0 : np;
+                    }
+                }
+                s = y+1;
+                bl = 0;
+                is_s = is_f;
+                maxb = is_s->count;
+            } else {
+                e = y;
+                if (IDX(state,grid,idx) & (G_LINEH|G_NOLINEV)) bl = 1;
+            }
+            idx += w;
+        }
+        if (s != -1) {
+            for (i = s; i <= e; i++)
+                INDEX(state, possv, x, i) = 0;
+        }
+    }
+
+    /* ...and now do horizontal stripes [un]setting possh. */
+    /* can we lose this clone'n'hack? */
+    for (y = 0; y < state->h; y++) {
+        idx = y*w;
+        s = e = -1;
+        bl = 0;
+        maxb = state->params.maxb;     /* placate optimiser */
+        for (x = 0; x < state->w; x++) {
+            is_s = IDX(state, gridi, idx);
+            if (is_s) {
+                maxb = is_s->count;
+                break;
+            }
+
+            IDX(state, possh, idx) = 0;
+            idx += 1;
+        }
+        for (; x < state->w; x++) {
+            maxb = min(maxb, IDX(state, maxh, idx));
+            is_f = IDX(state, gridi, idx);
+            if (is_f) {
+                assert(is_s);
+                np = min(maxb, is_f->count);
+
+                if (s != -1) {
+                    for (i = s; i <= e; i++) {
+                        INDEX(state, possh, i, y) = bl ? 0 : np;
+                    }
+                }
+                s = x+1;
+                bl = 0;
+                is_s = is_f;
+                maxb = is_s->count;
+            } else {
+                e = x;
+                if (IDX(state,grid,idx) & (G_LINEV|G_NOLINEH)) bl = 1;
+            }
+            idx += 1;
+        }
+        if (s != -1) {
+            for (i = s; i <= e; i++)
+                INDEX(state, possh, i, y) = 0;
+        }
+    }
+}
+
+static void map_count(game_state *state)
+{
+    int i, n, ax, ay;
+    grid_type flag, grid;
+    struct island *is;
+
+    for (i = 0; i < state->n_islands; i++) {
+        is = &state->islands[i];
+        is->count = 0;
+        for (n = 0; n < is->adj.npoints; n++) {
+            ax = is->adj.points[n].x;
+            ay = is->adj.points[n].y;
+            flag = (ax == is->x) ? G_LINEV : G_LINEH;
+            grid = GRID(state,ax,ay);
+            if (grid & flag) {
+                is->count += INDEX(state,lines,ax,ay);
+            }
+        }
+    }
+}
+
+static void map_find_orthogonal(game_state *state)
+{
+    int i;
+
+    for (i = 0; i < state->n_islands; i++) {
+        island_find_orthogonal(&state->islands[i]);
+    }
+}
+
+struct bridges_neighbour_ctx {
+    game_state *state;
+    int i, n, neighbours[4];
+};
+static int bridges_neighbour(int vertex, void *vctx)
+{
+    struct bridges_neighbour_ctx *ctx = (struct bridges_neighbour_ctx *)vctx;
+    if (vertex >= 0) {
+        game_state *state = ctx->state;
+        int w = state->w, x = vertex % w, y = vertex / w;
+        grid_type grid = GRID(state, x, y), gline = grid & G_LINE;
+        struct island *is;
+        int x1, y1, x2, y2, i;
+
+        ctx->i = ctx->n = 0;
+
+        is = INDEX(state, gridi, x, y);
+        if (is) {
+            for (i = 0; i < is->adj.npoints; i++) {
+                gline = is->adj.points[i].dx ? G_LINEH : G_LINEV;
+                if (GRID(state, is->adj.points[i].x,
+                         is->adj.points[i].y) & gline) {
+                    ctx->neighbours[ctx->n++] =
+                        (is->adj.points[i].y * w + is->adj.points[i].x);
+                }
+            }
+        } else if (gline) {
+            if (gline & G_LINEV) {
+                x1 = x2 = x;
+                y1 = y-1; y2 = y+1;
+            } else {
+                x1 = x-1; x2 = x+1;
+                y1 = y2 = y;
+            }
+            /* Non-island squares with edges in should never be
+             * pointing off the edge of the grid. */
+            assert(INGRID(state, x1, y1));
+            assert(INGRID(state, x2, y2));
+            if (GRID(state, x1, y1) & (gline | G_ISLAND))
+                ctx->neighbours[ctx->n++] = y1 * w + x1;
+            if (GRID(state, x2, y2) & (gline | G_ISLAND))
+                ctx->neighbours[ctx->n++] = y2 * w + x2;
+        }
+    }
+
+    if (ctx->i < ctx->n)
+        return ctx->neighbours[ctx->i++];
+    else
+        return -1;
+}
+
+static int map_hasloops(game_state *state, int mark)
+{
+    int x, y;
+    struct findloopstate *fls;
+    struct bridges_neighbour_ctx ctx;
+    int ret;
+
+    fls = findloop_new_state(state->w * state->h);
+    ctx.state = state;
+    ret = findloop_run(fls, state->w * state->h, bridges_neighbour, &ctx);
+
+    if (mark) {
+        for (y = 0; y < state->h; y++) {
+            for (x = 0; x < state->w; x++) {
+                int u, v;
+
+                u = y * state->w + x;
+                for (v = bridges_neighbour(u, &ctx); v >= 0;
+                     v = bridges_neighbour(-1, &ctx))
+                    if (findloop_is_loop_edge(fls, u, v))
+                        GRID(state,x,y) |= G_WARN;
+            }
+        }
+    }
+
+    findloop_free_state(fls);
+    return ret;
+}
+
+static void map_group(game_state *state)
+{
+    int i, wh = state->w*state->h, d1, d2;
+    int x, y, x2, y2;
+    int *dsf = state->solver->dsf;
+    struct island *is, *is_join;
+
+    /* Initialise dsf. */
+    dsf_init(dsf, wh);
+
+    /* For each island, find connected islands right or down
+     * and merge the dsf for the island squares as well as the
+     * bridge squares. */
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            GRID(state,x,y) &= ~(G_SWEEP|G_WARN); /* for group_full. */
+
+            is = INDEX(state, gridi, x, y);
+            if (!is) continue;
+            d1 = DINDEX(x,y);
+            for (i = 0; i < is->adj.npoints; i++) {
+                /* only want right/down */
+                if (is->adj.points[i].dx == -1 ||
+                    is->adj.points[i].dy == -1) continue;
+
+                is_join = island_find_connection(is, i);
+                if (!is_join) continue;
+
+                d2 = DINDEX(is_join->x, is_join->y);
+                if (dsf_canonify(dsf,d1) == dsf_canonify(dsf,d2)) {
+                    ; /* we have a loop. See comment in map_hasloops. */
+                    /* However, we still want to merge all squares joining
+                     * this side-that-makes-a-loop. */
+                }
+                /* merge all squares between island 1 and island 2. */
+                for (x2 = x; x2 <= is_join->x; x2++) {
+                    for (y2 = y; y2 <= is_join->y; y2++) {
+                        d2 = DINDEX(x2,y2);
+                        if (d1 != d2) dsf_merge(dsf,d1,d2);
+                    }
+                }
+            }
+        }
+    }
+}
+
+static int map_group_check(game_state *state, int canon, int warn,
+                           int *nislands_r)
+{
+    int *dsf = state->solver->dsf, nislands = 0;
+    int x, y, i, allfull = 1;
+    struct island *is;
+
+    for (i = 0; i < state->n_islands; i++) {
+        is = &state->islands[i];
+        if (dsf_canonify(dsf, DINDEX(is->x,is->y)) != canon) continue;
+
+        GRID(state, is->x, is->y) |= G_SWEEP;
+        nislands++;
+        if (island_countbridges(is) != is->count)
+            allfull = 0;
+    }
+    if (warn && allfull && nislands != state->n_islands) {
+        /* we're full and this island group isn't the whole set.
+         * Mark all squares with this dsf canon as ERR. */
+        for (x = 0; x < state->w; x++) {
+            for (y = 0; y < state->h; y++) {
+                if (dsf_canonify(dsf, DINDEX(x,y)) == canon) {
+                    GRID(state,x,y) |= G_WARN;
+                }
+            }
+        }
+
+    }
+    if (nislands_r) *nislands_r = nislands;
+    return allfull;
+}
+
+static int map_group_full(game_state *state, int *ngroups_r)
+{
+    int *dsf = state->solver->dsf, ngroups = 0;
+    int i, anyfull = 0;
+    struct island *is;
+
+    /* NB this assumes map_group (or sth else) has cleared G_SWEEP. */
+
+    for (i = 0; i < state->n_islands; i++) {
+        is = &state->islands[i];
+        if (GRID(state,is->x,is->y) & G_SWEEP) continue;
+
+        ngroups++;
+        if (map_group_check(state, dsf_canonify(dsf, DINDEX(is->x,is->y)),
+                            1, NULL))
+            anyfull = 1;
+    }
+
+    *ngroups_r = ngroups;
+    return anyfull;
+}
+
+static int map_check(game_state *state)
+{
+    int ngroups;
+
+    /* Check for loops, if necessary. */
+    if (!state->allowloops) {
+        if (map_hasloops(state, 1))
+            return 0;
+    }
+
+    /* Place islands into island groups and check for early
+     * satisfied-groups. */
+    map_group(state); /* clears WARN and SWEEP */
+    if (map_group_full(state, &ngroups)) {
+        if (ngroups == 1) return 1;
+    }
+    return 0;
+}
+
+static void map_clear(game_state *state)
+{
+    int x, y;
+
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            /* clear most flags; might want to be slightly more careful here. */
+            GRID(state,x,y) &= G_ISLAND;
+        }
+    }
+}
+
+static void solve_join(struct island *is, int direction, int n, int is_max)
+{
+    struct island *is_orth;
+    int d1, d2, *dsf = is->state->solver->dsf;
+    game_state *state = is->state; /* for DINDEX */
+
+    is_orth = INDEX(is->state, gridi,
+                    ISLAND_ORTHX(is, direction),
+                    ISLAND_ORTHY(is, direction));
+    assert(is_orth);
+    /*debug(("...joining (%d,%d) to (%d,%d) with %d bridge(s).\n",
+           is->x, is->y, is_orth->x, is_orth->y, n));*/
+    island_join(is, is_orth, n, is_max);
+
+    if (n > 0 && !is_max) {
+        d1 = DINDEX(is->x, is->y);
+        d2 = DINDEX(is_orth->x, is_orth->y);
+        if (dsf_canonify(dsf, d1) != dsf_canonify(dsf, d2))
+            dsf_merge(dsf, d1, d2);
+    }
+}
+
+static int solve_fillone(struct island *is)
+{
+    int i, nadded = 0;
+
+    debug(("solve_fillone for island (%d,%d).\n", is->x, is->y));
+
+    for (i = 0; i < is->adj.npoints; i++) {
+        if (island_isadj(is, i)) {
+            if (island_hasbridge(is, i)) {
+                /* already attached; do nothing. */;
+            } else {
+                solve_join(is, i, 1, 0);
+                nadded++;
+            }
+        }
+    }
+    return nadded;
+}
+
+static int solve_fill(struct island *is)
+{
+    /* for each unmarked adjacent, make sure we convert every possible bridge
+     * to a real one, and then work out the possibles afresh. */
+    int i, nnew, ncurr, nadded = 0, missing;
+
+    debug(("solve_fill for island (%d,%d).\n", is->x, is->y));
+
+    missing = is->count - island_countbridges(is);
+    if (missing < 0) return 0;
+
+    /* very like island_countspaces. */
+    for (i = 0; i < is->adj.npoints; i++) {
+        nnew = island_adjspace(is, 1, missing, i);
+        if (nnew) {
+            ncurr = GRIDCOUNT(is->state,
+                              is->adj.points[i].x, is->adj.points[i].y,
+                              is->adj.points[i].dx ? G_LINEH : G_LINEV);
+
+            solve_join(is, i, nnew + ncurr, 0);
+            nadded += nnew;
+        }
+    }
+    return nadded;
+}
+
+static int solve_island_stage1(struct island *is, int *didsth_r)
+{
+    int bridges = island_countbridges(is);
+    int nspaces = island_countspaces(is, 1);
+    int nadj = island_countadj(is);
+    int didsth = 0;
+
+    assert(didsth_r);
+
+    /*debug(("island at (%d,%d) filled %d/%d (%d spc) nadj %d\n",
+           is->x, is->y, bridges, is->count, nspaces, nadj));*/
+    if (bridges > is->count) {
+        /* We only ever add bridges when we're sure they fit, or that's
+         * the only place they can go. If we've added bridges such that
+         * another island has become wrong, the puzzle must not have had
+         * a solution. */
+        debug(("...island at (%d,%d) is overpopulated!\n", is->x, is->y));
+        return 0;
+    } else if (bridges == is->count) {
+        /* This island is full. Make sure it's marked (and update
+         * possibles if we did). */
+        if (!(GRID(is->state, is->x, is->y) & G_MARK)) {
+            debug(("...marking island (%d,%d) as full.\n", is->x, is->y));
+            island_togglemark(is);
+            didsth = 1;
+        }
+    } else if (GRID(is->state, is->x, is->y) & G_MARK) {
+        debug(("...island (%d,%d) is marked but unfinished!\n",
+               is->x, is->y));
+        return 0; /* island has been marked unfinished; no solution from here. */
+    } else {
+        /* This is the interesting bit; we try and fill in more information
+         * about this island. */
+        if (is->count == bridges + nspaces) {
+            if (solve_fill(is) > 0) didsth = 1;
+        } else if (is->count > ((nadj-1) * is->state->maxb)) {
+            /* must have at least one bridge in each possible direction. */
+            if (solve_fillone(is) > 0) didsth = 1;
+        }
+    }
+    if (didsth) {
+        map_update_possibles(is->state);
+        *didsth_r = 1;
+    }
+    return 1;
+}
+
+/* returns non-zero if a new line here would cause a loop. */
+static int solve_island_checkloop(struct island *is, int direction)
+{
+    struct island *is_orth;
+    int *dsf = is->state->solver->dsf, d1, d2;
+    game_state *state = is->state;
+
+    if (is->state->allowloops) return 0; /* don't care anyway */
+    if (island_hasbridge(is, direction)) return 0; /* already has a bridge */
+    if (island_isadj(is, direction) == 0) return 0; /* no adj island */
+
+    is_orth = INDEX(is->state, gridi,
+                    ISLAND_ORTHX(is,direction),
+                    ISLAND_ORTHY(is,direction));
+    if (!is_orth) return 0;
+
+    d1 = DINDEX(is->x, is->y);
+    d2 = DINDEX(is_orth->x, is_orth->y);
+    if (dsf_canonify(dsf, d1) == dsf_canonify(dsf, d2)) {
+        /* two islands are connected already; don't join them. */
+        return 1;
+    }
+    return 0;
+}
+
+static int solve_island_stage2(struct island *is, int *didsth_r)
+{
+    int added = 0, removed = 0, navail = 0, nadj, i;
+
+    assert(didsth_r);
+
+    for (i = 0; i < is->adj.npoints; i++) {
+        if (solve_island_checkloop(is, i)) {
+            debug(("removing possible loop at (%d,%d) direction %d.\n",
+                   is->x, is->y, i));
+            solve_join(is, i, -1, 0);
+            map_update_possibles(is->state);
+            removed = 1;
+        } else {
+            navail += island_isadj(is, i);
+            /*debug(("stage2: navail for (%d,%d) direction (%d,%d) is %d.\n",
+                   is->x, is->y,
+                   is->adj.points[i].dx, is->adj.points[i].dy,
+                   island_isadj(is, i)));*/
+        }
+    }
+
+    /*debug(("island at (%d,%d) navail %d: checking...\n", is->x, is->y, navail));*/
+
+    for (i = 0; i < is->adj.npoints; i++) {
+        if (!island_hasbridge(is, i)) {
+            nadj = island_isadj(is, i);
+            if (nadj > 0 && (navail - nadj) < is->count) {
+                /* we couldn't now complete the island without at
+                 * least one bridge here; put it in. */
+                /*debug(("nadj %d, navail %d, is->count %d.\n",
+                       nadj, navail, is->count));*/
+                debug(("island at (%d,%d) direction (%d,%d) must have 1 bridge\n",
+                       is->x, is->y,
+                       is->adj.points[i].dx, is->adj.points[i].dy));
+                solve_join(is, i, 1, 0);
+                added = 1;
+                /*debug_state(is->state);
+                debug_possibles(is->state);*/
+            }
+        }
+    }
+    if (added) map_update_possibles(is->state);
+    if (added || removed) *didsth_r = 1;
+    return 1;
+}
+
+static int solve_island_subgroup(struct island *is, int direction)
+{
+    struct island *is_join;
+    int nislands, *dsf = is->state->solver->dsf;
+    game_state *state = is->state;
+
+    debug(("..checking subgroups.\n"));
+
+    /* if is isn't full, return 0. */
+    if (island_countbridges(is) < is->count) {
+        debug(("...orig island (%d,%d) not full.\n", is->x, is->y));
+        return 0;
+    }
+
+    if (direction >= 0) {
+        is_join = INDEX(state, gridi,
+                        ISLAND_ORTHX(is, direction),
+                        ISLAND_ORTHY(is, direction));
+        assert(is_join);
+
+        /* if is_join isn't full, return 0. */
+        if (island_countbridges(is_join) < is_join->count) {
+            debug(("...dest island (%d,%d) not full.\n",
+                   is_join->x, is_join->y));
+            return 0;
+        }
+    }
+
+    /* Check group membership for is->dsf; if it's full return 1. */
+    if (map_group_check(state, dsf_canonify(dsf, DINDEX(is->x,is->y)),
+                        0, &nislands)) {
+        if (nislands < state->n_islands) {
+            /* we have a full subgroup that isn't the whole set.
+             * This isn't allowed. */
+            debug(("island at (%d,%d) makes full subgroup, disallowing.\n",
+                   is->x, is->y));
+            return 1;
+        } else {
+            debug(("...has finished puzzle.\n"));
+        }
+    }
+    return 0;
+}
+
+static int solve_island_impossible(game_state *state)
+{
+    struct island *is;
+    int i;
+
+    /* If any islands are impossible, return 1. */
+    for (i = 0; i < state->n_islands; i++) {
+        is = &state->islands[i];
+        if (island_impossible(is, 0)) {
+            debug(("island at (%d,%d) has become impossible, disallowing.\n",
+                   is->x, is->y));
+            return 1;
+        }
+    }
+    return 0;
+}
+
+/* Bear in mind that this function is really rather inefficient. */
+static int solve_island_stage3(struct island *is, int *didsth_r)
+{
+    int i, n, x, y, missing, spc, curr, maxb, didsth = 0;
+    int wh = is->state->w * is->state->h;
+    struct solver_state *ss = is->state->solver;
+
+    assert(didsth_r);
+
+    missing = is->count - island_countbridges(is);
+    if (missing <= 0) return 1;
+
+    for (i = 0; i < is->adj.npoints; i++) {
+        x = is->adj.points[i].x;
+        y = is->adj.points[i].y;
+        spc = island_adjspace(is, 1, missing, i);
+        if (spc == 0) continue;
+
+        curr = GRIDCOUNT(is->state, x, y,
+                         is->adj.points[i].dx ? G_LINEH : G_LINEV);
+        debug(("island at (%d,%d) s3, trying %d - %d bridges.\n",
+               is->x, is->y, curr+1, curr+spc));
+
+        /* Now we know that this island could have more bridges,
+         * to bring the total from curr+1 to curr+spc. */
+        maxb = -1;
+        /* We have to squirrel the dsf away and restore it afterwards;
+         * it is additive only, and can't be removed from. */
+        memcpy(ss->tmpdsf, ss->dsf, wh*sizeof(int));
+        for (n = curr+1; n <= curr+spc; n++) {
+            solve_join(is, i, n, 0);
+            map_update_possibles(is->state);
+
+            if (solve_island_subgroup(is, i) ||
+                solve_island_impossible(is->state)) {
+                maxb = n-1;
+                debug(("island at (%d,%d) d(%d,%d) new max of %d bridges:\n",
+                       is->x, is->y,
+                       is->adj.points[i].dx, is->adj.points[i].dy,
+                       maxb));
+                break;
+            }
+        }
+        solve_join(is, i, curr, 0); /* put back to before. */
+        memcpy(ss->dsf, ss->tmpdsf, wh*sizeof(int));
+
+        if (maxb != -1) {
+            /*debug_state(is->state);*/
+            if (maxb == 0) {
+                debug(("...adding NOLINE.\n"));
+                solve_join(is, i, -1, 0); /* we can't have any bridges here. */
+            } else {
+                debug(("...setting maximum\n"));
+                solve_join(is, i, maxb, 1);
+            }
+            didsth = 1;
+        }
+        map_update_possibles(is->state);
+    }
+
+    for (i = 0; i < is->adj.npoints; i++) {
+        /*
+         * Now check to see if any currently empty direction must have
+         * at least one bridge in order to avoid forming an isolated
+         * subgraph. This differs from the check above in that it
+         * considers multiple target islands. For example:
+         *
+         *   2   2    4
+         *                                  1     3     2
+         *       3
+         *                                        4
+         *
+         * The example on the left can be handled by the above loop:
+         * it will observe that connecting the central 2 twice to the
+         * left would form an isolated subgraph, and hence it will
+         * restrict that 2 to at most one bridge in that direction.
+         * But the example on the right won't be handled by that loop,
+         * because the deduction requires us to imagine connecting the
+         * 3 to _both_ the 1 and 2 at once to form an isolated
+         * subgraph.
+         *
+         * This pass is necessary _as well_ as the above one, because
+         * neither can do the other's job. In the left one,
+         * restricting the direction which _would_ cause trouble can
+         * be done even if it's not yet clear which of the remaining
+         * directions has to have a compensatory bridge; whereas the
+         * pass below that can handle the right-hand example does need
+         * to know what direction to point the necessary bridge in.
+         *
+         * Neither pass can handle the most general case, in which we
+         * observe that an arbitrary subset of an island's neighbours
+         * would form an isolated subgraph with it if it connected
+         * maximally to them, and hence that at least one bridge must
+         * point to some neighbour outside that subset but we don't
+         * know which neighbour. To handle that, we'd have to have a
+         * richer data format for the solver, which could cope with
+         * recording the idea that at least one of two edges must have
+         * a bridge.
+         */
+        int got = 0;
+        int before[4];
+        int j;
+
+        spc = island_adjspace(is, 1, missing, i);
+        if (spc == 0) continue;
+
+        for (j = 0; j < is->adj.npoints; j++)
+            before[j] = GRIDCOUNT(is->state,
+                                  is->adj.points[j].x,
+                                  is->adj.points[j].y,
+                                  is->adj.points[j].dx ? G_LINEH : G_LINEV);
+        if (before[i] != 0) continue;  /* this idea is pointless otherwise */
+
+        memcpy(ss->tmpdsf, ss->dsf, wh*sizeof(int));
+
+        for (j = 0; j < is->adj.npoints; j++) {
+            spc = island_adjspace(is, 1, missing, j);
+            if (spc == 0) continue;
+            if (j == i) continue;
+            solve_join(is, j, before[j] + spc, 0);
+        }
+        map_update_possibles(is->state);
+
+        if (solve_island_subgroup(is, -1))
+            got = 1;
+
+        for (j = 0; j < is->adj.npoints; j++)
+            solve_join(is, j, before[j], 0);
+        memcpy(ss->dsf, ss->tmpdsf, wh*sizeof(int));
+
+        if (got) {
+            debug(("island at (%d,%d) must connect in direction (%d,%d) to"
+                   " avoid full subgroup.\n",
+                   is->x, is->y, is->adj.points[i].dx, is->adj.points[i].dy));
+            solve_join(is, i, 1, 0);
+            didsth = 1;
+        }
+
+        map_update_possibles(is->state);
+    }
+
+    if (didsth) *didsth_r = didsth;
+    return 1;
+}
+
+#define CONTINUE_IF_FULL do {                           \
+if (GRID(state, is->x, is->y) & G_MARK) {            \
+    /* island full, don't try fixing it */           \
+    continue;                                        \
+} } while(0)
+
+static int solve_sub(game_state *state, int difficulty, int depth)
+{
+    struct island *is;
+    int i, didsth;
+
+    while (1) {
+        didsth = 0;
+
+        /* First island iteration: things we can work out by looking at
+         * properties of the island as a whole. */
+        for (i = 0; i < state->n_islands; i++) {
+            is = &state->islands[i];
+            if (!solve_island_stage1(is, &didsth)) return 0;
+        }
+        if (didsth) continue;
+        else if (difficulty < 1) break;
+
+        /* Second island iteration: thing we can work out by looking at
+         * properties of individual island connections. */
+        for (i = 0; i < state->n_islands; i++) {
+            is = &state->islands[i];
+            CONTINUE_IF_FULL;
+            if (!solve_island_stage2(is, &didsth)) return 0;
+        }
+        if (didsth) continue;
+        else if (difficulty < 2) break;
+
+        /* Third island iteration: things we can only work out by looking
+         * at groups of islands. */
+        for (i = 0; i < state->n_islands; i++) {
+            is = &state->islands[i];
+            if (!solve_island_stage3(is, &didsth)) return 0;
+        }
+        if (didsth) continue;
+        else if (difficulty < 3) break;
+
+        /* If we can be bothered, write a recursive solver to finish here. */
+        break;
+    }
+    if (map_check(state)) return 1; /* solved it */
+    return 0;
+}
+
+static void solve_for_hint(game_state *state)
+{
+    map_group(state);
+    solve_sub(state, 10, 0);
+}
+
+static int solve_from_scratch(game_state *state, int difficulty)
+{
+    map_clear(state);
+    map_group(state);
+    map_update_possibles(state);
+    return solve_sub(state, difficulty, 0);
+}
+
+/* --- New game functions --- */
+
+static game_state *new_state(const game_params *params)
+{
+    game_state *ret = snew(game_state);
+    int wh = params->w * params->h, i;
+
+    ret->w = params->w;
+    ret->h = params->h;
+    ret->allowloops = params->allowloops;
+    ret->maxb = params->maxb;
+    ret->params = *params;
+
+    ret->grid = snewn(wh, grid_type);
+    memset(ret->grid, 0, GRIDSZ(ret));
+
+    ret->wha = snewn(wh*N_WH_ARRAYS, char);
+    memset(ret->wha, 0, wh*N_WH_ARRAYS*sizeof(char));
+
+    ret->possv = ret->wha;
+    ret->possh = ret->wha + wh;
+    ret->lines = ret->wha + wh*2;
+    ret->maxv = ret->wha + wh*3;
+    ret->maxh = ret->wha + wh*4;
+
+    memset(ret->maxv, ret->maxb, wh*sizeof(char));
+    memset(ret->maxh, ret->maxb, wh*sizeof(char));
+
+    ret->islands = NULL;
+    ret->n_islands = 0;
+    ret->n_islands_alloc = 0;
+
+    ret->gridi = snewn(wh, struct island *);
+    for (i = 0; i < wh; i++) ret->gridi[i] = NULL;
+
+    ret->solved = ret->completed = 0;
+
+    ret->solver = snew(struct solver_state);
+    ret->solver->dsf = snew_dsf(wh);
+    ret->solver->tmpdsf = snewn(wh, int);
+
+    ret->solver->refcount = 1;
+
+    return ret;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+    int wh = state->w*state->h;
+
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->allowloops = state->allowloops;
+    ret->maxb = state->maxb;
+    ret->params = state->params;
+
+    ret->grid = snewn(wh, grid_type);
+    memcpy(ret->grid, state->grid, GRIDSZ(ret));
+
+    ret->wha = snewn(wh*N_WH_ARRAYS, char);
+    memcpy(ret->wha, state->wha, wh*N_WH_ARRAYS*sizeof(char));
+
+    ret->possv = ret->wha;
+    ret->possh = ret->wha + wh;
+    ret->lines = ret->wha + wh*2;
+    ret->maxv = ret->wha + wh*3;
+    ret->maxh = ret->wha + wh*4;
+
+    ret->islands = snewn(state->n_islands, struct island);
+    memcpy(ret->islands, state->islands, state->n_islands * sizeof(struct island));
+    ret->n_islands = ret->n_islands_alloc = state->n_islands;
+
+    ret->gridi = snewn(wh, struct island *);
+    fixup_islands_for_realloc(ret);
+
+    ret->solved = state->solved;
+    ret->completed = state->completed;
+
+    ret->solver = state->solver;
+    ret->solver->refcount++;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (--state->solver->refcount <= 0) {
+        sfree(state->solver->dsf);
+        sfree(state->solver->tmpdsf);
+        sfree(state->solver);
+    }
+
+    sfree(state->islands);
+    sfree(state->gridi);
+
+    sfree(state->wha);
+
+    sfree(state->grid);
+    sfree(state);
+}
+
+#define MAX_NEWISLAND_TRIES     50
+#define MIN_SENSIBLE_ISLANDS    3
+
+#define ORDER(a,b) do { if (a < b) { int tmp=a; int a=b; int b=tmp; } } while(0)
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    game_state *tobuild  = NULL;
+    int i, j, wh = params->w * params->h, x, y, dx, dy;
+    int minx, miny, maxx, maxy, joinx, joiny, newx, newy, diffx, diffy;
+    int ni_req = max((params->islands * wh) / 100, MIN_SENSIBLE_ISLANDS), ni_curr, ni_bad;
+    struct island *is, *is2;
+    char *ret;
+    unsigned int echeck;
+
+    /* pick a first island position randomly. */
+generate:
+    if (tobuild) free_game(tobuild);
+    tobuild = new_state(params);
+
+    x = random_upto(rs, params->w);
+    y = random_upto(rs, params->h);
+    island_add(tobuild, x, y, 0);
+    ni_curr = 1;
+    ni_bad = 0;
+    debug(("Created initial island at (%d,%d).\n", x, y));
+
+    while (ni_curr < ni_req) {
+        /* Pick a random island to try and extend from. */
+        i = random_upto(rs, tobuild->n_islands);
+        is = &tobuild->islands[i];
+
+        /* Pick a random direction to extend in. */
+        j = random_upto(rs, is->adj.npoints);
+        dx = is->adj.points[j].x - is->x;
+        dy = is->adj.points[j].y - is->y;
+
+        /* Find out limits of where we could put a new island. */
+        joinx = joiny = -1;
+        minx = is->x + 2*dx; miny = is->y + 2*dy; /* closest is 2 units away. */
+        x = is->x+dx; y = is->y+dy;
+        if (GRID(tobuild,x,y) & (G_LINEV|G_LINEH)) {
+            /* already a line next to the island, continue. */
+            goto bad;
+        }
+        while (1) {
+            if (x < 0 || x >= params->w || y < 0 || y >= params->h) {
+                /* got past the edge; put a possible at the island
+                 * and exit. */
+                maxx = x-dx; maxy = y-dy;
+                goto foundmax;
+            }
+            if (GRID(tobuild,x,y) & G_ISLAND) {
+                /* could join up to an existing island... */
+                joinx = x; joiny = y;
+                /* ... or make a new one 2 spaces away. */
+                maxx = x - 2*dx; maxy = y - 2*dy;
+                goto foundmax;
+            } else if (GRID(tobuild,x,y) & (G_LINEV|G_LINEH)) {
+                /* could make a new one 1 space away from the line. */
+                maxx = x - dx; maxy = y - dy;
+                goto foundmax;
+            }
+            x += dx; y += dy;
+        }
+
+foundmax:
+        debug(("Island at (%d,%d) with d(%d,%d) has new positions "
+               "(%d,%d) -> (%d,%d), join (%d,%d).\n",
+               is->x, is->y, dx, dy, minx, miny, maxx, maxy, joinx, joiny));
+        /* Now we know where we could either put a new island
+         * (between min and max), or (if loops are allowed) could join on
+         * to an existing island (at join). */
+        if (params->allowloops && joinx != -1 && joiny != -1) {
+            if (random_upto(rs, 100) < (unsigned long)params->expansion) {
+                is2 = INDEX(tobuild, gridi, joinx, joiny);
+                debug(("Joining island at (%d,%d) to (%d,%d).\n",
+                       is->x, is->y, is2->x, is2->y));
+                goto join;
+            }
+        }
+        diffx = (maxx - minx) * dx;
+        diffy = (maxy - miny) * dy;
+        if (diffx < 0 || diffy < 0)  goto bad;
+        if (random_upto(rs,100) < (unsigned long)params->expansion) {
+            newx = maxx; newy = maxy;
+            debug(("Creating new island at (%d,%d) (expanded).\n", newx, newy));
+        } else {
+            newx = minx + random_upto(rs,diffx+1)*dx;
+            newy = miny + random_upto(rs,diffy+1)*dy;
+            debug(("Creating new island at (%d,%d).\n", newx, newy));
+        }
+        /* check we're not next to island in the other orthogonal direction. */
+        if ((INGRID(tobuild,newx+dy,newy+dx) && (GRID(tobuild,newx+dy,newy+dx) & G_ISLAND)) ||
+            (INGRID(tobuild,newx-dy,newy-dx) && (GRID(tobuild,newx-dy,newy-dx) & G_ISLAND))) {
+            debug(("New location is adjacent to island, skipping.\n"));
+            goto bad;
+        }
+        is2 = island_add(tobuild, newx, newy, 0);
+        /* Must get is again at this point; the array might have
+         * been realloced by island_add... */
+        is = &tobuild->islands[i]; /* ...but order will not change. */
+
+        ni_curr++; ni_bad = 0;
+join:
+        island_join(is, is2, random_upto(rs, tobuild->maxb)+1, 0);
+        debug_state(tobuild);
+        continue;
+
+bad:
+        ni_bad++;
+        if (ni_bad > MAX_NEWISLAND_TRIES) {
+            debug(("Unable to create any new islands after %d tries; "
+                   "created %d [%d%%] (instead of %d [%d%%] requested).\n",
+                   MAX_NEWISLAND_TRIES,
+                   ni_curr, ni_curr * 100 / wh,
+                   ni_req, ni_req * 100 / wh));
+            goto generated;
+        }
+    }
+
+generated:
+    if (ni_curr == 1) {
+        debug(("Only generated one island (!), retrying.\n"));
+        goto generate;
+    }
+    /* Check we have at least one island on each extremity of the grid. */
+    echeck = 0;
+    for (x = 0; x < params->w; x++) {
+        if (INDEX(tobuild, gridi, x, 0))           echeck |= 1;
+        if (INDEX(tobuild, gridi, x, params->h-1)) echeck |= 2;
+    }
+    for (y = 0; y < params->h; y++) {
+        if (INDEX(tobuild, gridi, 0,           y)) echeck |= 4;
+        if (INDEX(tobuild, gridi, params->w-1, y)) echeck |= 8;
+    }
+    if (echeck != 15) {
+        debug(("Generated grid doesn't fill to sides, retrying.\n"));
+        goto generate;
+    }
+
+    map_count(tobuild);
+    map_find_orthogonal(tobuild);
+
+    if (params->difficulty > 0) {
+        if ((ni_curr > MIN_SENSIBLE_ISLANDS) &&
+            (solve_from_scratch(tobuild, params->difficulty-1) > 0)) {
+            debug(("Grid is solvable at difficulty %d (too easy); retrying.\n",
+                   params->difficulty-1));
+            goto generate;
+        }
+    }
+
+    if (solve_from_scratch(tobuild, params->difficulty) == 0) {
+        debug(("Grid not solvable at difficulty %d, (too hard); retrying.\n",
+               params->difficulty));
+        goto generate;
+    }
+
+    /* ... tobuild is now solved. We rely on this making the diff for aux. */
+    debug_state(tobuild);
+    ret = encode_game(tobuild);
+    {
+        game_state *clean = dup_game(tobuild);
+        map_clear(clean);
+        map_update_possibles(clean);
+        *aux = game_state_diff(clean, tobuild);
+        free_game(clean);
+    }
+    free_game(tobuild);
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int i, wh = params->w * params->h;
+
+    for (i = 0; i < wh; i++) {
+        if (*desc >= '1' && *desc <= '9')
+            /* OK */;
+        else if (*desc >= 'a' && *desc <= 'z')
+            i += *desc - 'a'; /* plus the i++ */
+        else if (*desc >= 'A' && *desc <= 'G')
+            /* OK */;
+        else if (*desc == 'V' || *desc == 'W' ||
+                 *desc == 'X' || *desc == 'Y' ||
+                 *desc == 'H' || *desc == 'I' ||
+                 *desc == 'J' || *desc == 'K')
+            /* OK */;
+        else if (!*desc)
+            return "Game description shorter than expected";
+        else
+            return "Game description contains unexpected character";
+        desc++;
+    }
+    if (*desc || i > wh)
+        return "Game description longer than expected";
+
+    return NULL;
+}
+
+static game_state *new_game_sub(const game_params *params, const char *desc)
+{
+    game_state *state = new_state(params);
+    int x, y, run = 0;
+
+    debug(("new_game[_sub]: desc = '%s'.\n", desc));
+
+    for (y = 0; y < params->h; y++) {
+        for (x = 0; x < params->w; x++) {
+            char c = '\0';
+
+            if (run == 0) {
+                c = *desc++;
+                assert(c != 'S');
+                if (c >= 'a' && c <= 'z')
+                    run = c - 'a' + 1;
+            }
+
+            if (run > 0) {
+                c = 'S';
+                run--;
+            }
+
+            switch (c) {
+            case '1': case '2': case '3': case '4':
+            case '5': case '6': case '7': case '8': case '9':
+                island_add(state, x, y, (c - '0'));
+                break;
+
+            case 'A': case 'B': case 'C': case 'D':
+            case 'E': case 'F': case 'G':
+                island_add(state, x, y, (c - 'A') + 10);
+                break;
+
+            case 'S':
+                /* empty square */
+                break;
+
+            default:
+                assert(!"Malformed desc.");
+                break;
+            }
+        }
+    }
+    if (*desc) assert(!"Over-long desc.");
+
+    map_find_orthogonal(state);
+    map_update_possibles(state);
+
+    return state;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    return new_game_sub(params, desc);
+}
+
+struct game_ui {
+    int dragx_src, dragy_src;   /* source; -1 means no drag */
+    int dragx_dst, dragy_dst;   /* src's closest orth island. */
+    grid_type todraw;
+    int dragging, drag_is_noline, nlines;
+
+    int cur_x, cur_y, cur_visible;      /* cursor position */
+    int show_hints;
+};
+
+static char *ui_cancel_drag(game_ui *ui)
+{
+    ui->dragx_src = ui->dragy_src = -1;
+    ui->dragx_dst = ui->dragy_dst = -1;
+    ui->dragging = 0;
+    return "";
+}
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui_cancel_drag(ui);
+    ui->cur_x = state->islands[0].x;
+    ui->cur_y = state->islands[0].y;
+    ui->cur_visible = 0;
+    ui->show_hints = 0;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int tilesize;
+    int w, h;
+    unsigned long *grid, *newgrid;
+    int *lv, *lh;
+    int started, dragging;
+};
+
+/*
+ * The contents of ds->grid are complicated, because of the circular
+ * islands which overlap their own grid square into neighbouring
+ * squares. An island square can contain pieces of the bridges in all
+ * directions, and conversely a bridge square can be intruded on by
+ * islands from any direction.
+ *
+ * So we define one group of flags describing what's important about
+ * an island, and another describing a bridge. Island squares' entries
+ * in ds->grid contain one of the former and four of the latter; bridge
+ * squares, four of the former and _two_ of the latter - because a
+ * horizontal and vertical 'bridge' can cross, when one of them is a
+ * 'no bridge here' pencil mark.
+ *
+ * Bridge flags need to indicate 0-4 actual bridges (3 bits), a 'no
+ * bridge' row of crosses, or a grey hint line; that's 7
+ * possibilities, so 3 bits suffice. But then we also need to vary the
+ * colours: the bridges can turn COL_WARNING if they're part of a loop
+ * in no-loops mode, COL_HIGHLIGHT during a victory flash, or
+ * COL_SELECTED if they're the bridge the user is currently dragging,
+ * so that's 2 more bits for foreground colour. Also bridges can be
+ * backed by COL_MARK if they're locked by the user, so that's one
+ * more bit, making 6 bits per bridge direction.
+ *
+ * Island flags omit the actual island clue (it never changes during
+ * the game, so doesn't have to be stored in ds->grid to check against
+ * the previous version), so they just need to include 2 bits for
+ * foreground colour (an island can be normal, COL_HIGHLIGHT during
+ * victory, COL_WARNING if its clue is unsatisfiable, or COL_SELECTED
+ * if it's part of the user's drag) and 2 bits for background (normal,
+ * COL_MARK for a locked island, COL_CURSOR for the keyboard cursor).
+ * That's 4 bits per island direction. We must also indicate whether
+ * no island is present at all (in the case where the island is
+ * potentially intruding into the side of a line square), which we do
+ * using the unused 4th value of the background field.
+ *
+ * So an island square needs 4 + 4*6 = 28 bits, while a bridge square
+ * needs 4*4 + 2*6 = 28 bits too. Both only just fit in 32 bits, which
+ * is handy, because otherwise we'd have to faff around forever with
+ * little structs!
+ */
+/* Flags for line data */
+#define DL_COUNTMASK    0x07
+#define DL_COUNT_CROSS  0x06
+#define DL_COUNT_HINT   0x07
+#define DL_COLMASK      0x18
+#define DL_COL_NORMAL   0x00
+#define DL_COL_WARNING  0x08
+#define DL_COL_FLASH    0x10
+#define DL_COL_SELECTED 0x18
+#define DL_LOCK         0x20
+#define DL_MASK         0x3F
+/* Flags for island data */
+#define DI_COLMASK      0x03
+#define DI_COL_NORMAL   0x00
+#define DI_COL_FLASH    0x01
+#define DI_COL_WARNING  0x02
+#define DI_COL_SELECTED 0x03
+#define DI_BGMASK       0x0C
+#define DI_BG_NO_ISLAND 0x00
+#define DI_BG_NORMAL    0x04
+#define DI_BG_MARK      0x08
+#define DI_BG_CURSOR    0x0C
+#define DI_MASK         0x0F
+/* Shift counts for the format of a 32-bit word in an island square */
+#define D_I_ISLAND_SHIFT 0
+#define D_I_LINE_SHIFT_L 4
+#define D_I_LINE_SHIFT_R 10
+#define D_I_LINE_SHIFT_U 16
+#define D_I_LINE_SHIFT_D 24
+/* Shift counts for the format of a 32-bit word in a line square */
+#define D_L_ISLAND_SHIFT_L 0
+#define D_L_ISLAND_SHIFT_R 4
+#define D_L_ISLAND_SHIFT_U 8
+#define D_L_ISLAND_SHIFT_D 12
+#define D_L_LINE_SHIFT_H 16
+#define D_L_LINE_SHIFT_V 22
+
+static char *update_drag_dst(const game_state *state, game_ui *ui,
+                             const game_drawstate *ds, int nx, int ny)
+{
+    int ox, oy, dx, dy, i, currl, maxb;
+    struct island *is;
+    grid_type gtype, ntype, mtype, curr;
+
+    if (ui->dragx_src == -1 || ui->dragy_src == -1) return NULL;
+
+    ui->dragx_dst = -1;
+    ui->dragy_dst = -1;
+
+    /* work out which of the four directions we're closest to... */
+    ox = COORD(ui->dragx_src) + TILE_SIZE/2;
+    oy = COORD(ui->dragy_src) + TILE_SIZE/2;
+
+    if (abs(nx-ox) < abs(ny-oy)) {
+        dx = 0;
+        dy = (ny-oy) < 0 ? -1 : 1;
+        gtype = G_LINEV; ntype = G_NOLINEV; mtype = G_MARKV;
+        maxb = INDEX(state, maxv, ui->dragx_src+dx, ui->dragy_src+dy);
+    } else {
+        dy = 0;
+        dx = (nx-ox) < 0 ? -1 : 1;
+        gtype = G_LINEH; ntype = G_NOLINEH; mtype = G_MARKH;
+        maxb = INDEX(state, maxh, ui->dragx_src+dx, ui->dragy_src+dy);
+    }
+    if (ui->drag_is_noline) {
+        ui->todraw = ntype;
+    } else {
+        curr = GRID(state, ui->dragx_src+dx, ui->dragy_src+dy);
+        currl = INDEX(state, lines, ui->dragx_src+dx, ui->dragy_src+dy);
+
+        if (curr & gtype) {
+            if (currl == maxb) {
+                ui->todraw = 0;
+                ui->nlines = 0;
+            } else {
+                ui->todraw = gtype;
+                ui->nlines = currl + 1;
+            }
+        } else {
+            ui->todraw = gtype;
+            ui->nlines = 1;
+        }
+    }
+
+    /* ... and see if there's an island off in that direction. */
+    is = INDEX(state, gridi, ui->dragx_src, ui->dragy_src);
+    for (i = 0; i < is->adj.npoints; i++) {
+        if (is->adj.points[i].off == 0) continue;
+        curr = GRID(state, is->x+dx, is->y+dy);
+        if (curr & mtype) continue; /* don't allow changes to marked lines. */
+        if (ui->drag_is_noline) {
+            if (curr & gtype) continue; /* no no-line where already a line */
+        } else {
+            if (POSSIBLES(state, dx, is->x+dx, is->y+dy) == 0) continue; /* no line if !possible. */
+            if (curr & ntype) continue; /* can't have a bridge where there's a no-line. */
+        }
+
+        if (is->adj.points[i].dx == dx &&
+            is->adj.points[i].dy == dy) {
+            ui->dragx_dst = ISLAND_ORTHX(is,i);
+            ui->dragy_dst = ISLAND_ORTHY(is,i);
+        }
+    }
+    /*debug(("update_drag src (%d,%d) d(%d,%d) dst (%d,%d)\n",
+           ui->dragx_src, ui->dragy_src, dx, dy,
+           ui->dragx_dst, ui->dragy_dst));*/
+    return "";
+}
+
+static char *finish_drag(const game_state *state, game_ui *ui)
+{
+    char buf[80];
+
+    if (ui->dragx_src == -1 || ui->dragy_src == -1)
+        return NULL;
+    if (ui->dragx_dst == -1 || ui->dragy_dst == -1)
+        return ui_cancel_drag(ui);
+
+    if (ui->drag_is_noline) {
+        sprintf(buf, "N%d,%d,%d,%d",
+                ui->dragx_src, ui->dragy_src,
+                ui->dragx_dst, ui->dragy_dst);
+    } else {
+        sprintf(buf, "L%d,%d,%d,%d,%d",
+                ui->dragx_src, ui->dragy_src,
+                ui->dragx_dst, ui->dragy_dst, ui->nlines);
+    }
+
+    ui_cancel_drag(ui);
+
+    return dupstr(buf);
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int gx = FROMCOORD(x), gy = FROMCOORD(y);
+    char buf[80], *ret;
+    grid_type ggrid = INGRID(state,gx,gy) ? GRID(state,gx,gy) : 0;
+    int shift = button & MOD_SHFT, control = button & MOD_CTRL;
+    button &= ~MOD_MASK;
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        if (!INGRID(state, gx, gy)) return NULL;
+        ui->cur_visible = 0;
+        if (ggrid & G_ISLAND) {
+            ui->dragx_src = gx;
+            ui->dragy_src = gy;
+            return "";
+        } else
+            return ui_cancel_drag(ui);
+    } else if (button == LEFT_DRAG || button == RIGHT_DRAG) {
+        if (INGRID(state, ui->dragx_src, ui->dragy_src)
+                && (gx != ui->dragx_src || gy != ui->dragy_src)
+                && !(GRID(state,ui->dragx_src,ui->dragy_src) & G_MARK)) {
+            ui->dragging = 1;
+            ui->drag_is_noline = (button == RIGHT_DRAG) ? 1 : 0;
+            return update_drag_dst(state, ui, ds, x, y);
+        } else {
+            /* cancel a drag when we go back to the starting point */
+            ui->dragx_dst = -1;
+            ui->dragy_dst = -1;
+            return "";
+        }
+    } else if (button == LEFT_RELEASE || button == RIGHT_RELEASE) {
+        if (ui->dragging) {
+            return finish_drag(state, ui);
+        } else {
+            if (!INGRID(state, ui->dragx_src, ui->dragy_src)
+                    || gx != ui->dragx_src || gy != ui->dragy_src) {
+                return ui_cancel_drag(ui);
+            }
+            ui_cancel_drag(ui);
+            if (!INGRID(state, gx, gy)) return NULL;
+            if (!(GRID(state, gx, gy) & G_ISLAND)) return NULL;
+            sprintf(buf, "M%d,%d", gx, gy);
+            return dupstr(buf);
+        }
+    } else if (button == 'h' || button == 'H') {
+        game_state *solved = dup_game(state);
+        solve_for_hint(solved);
+        ret = game_state_diff(state, solved);
+        free_game(solved);
+        return ret;
+    } else if (IS_CURSOR_MOVE(button)) {
+        ui->cur_visible = 1;
+        if (control || shift) {
+            ui->dragx_src = ui->cur_x;
+            ui->dragy_src = ui->cur_y;
+            ui->dragging = TRUE;
+            ui->drag_is_noline = !control;
+        }
+        if (ui->dragging) {
+            int nx = ui->cur_x, ny = ui->cur_y;
+
+            move_cursor(button, &nx, &ny, state->w, state->h, 0);
+            if (nx == ui->cur_x && ny == ui->cur_y)
+                return NULL;
+            update_drag_dst(state, ui, ds,
+                             COORD(nx)+TILE_SIZE/2,
+                             COORD(ny)+TILE_SIZE/2);
+            return finish_drag(state, ui);
+        } else {
+            int dx = (button == CURSOR_RIGHT) ? +1 : (button == CURSOR_LEFT) ? -1 : 0;
+            int dy = (button == CURSOR_DOWN)  ? +1 : (button == CURSOR_UP)   ? -1 : 0;
+            int dorthx = 1 - abs(dx), dorthy = 1 - abs(dy);
+            int dir, orth, nx = x, ny = y;
+
+            /* 'orthorder' is a tweak to ensure that if you press RIGHT and
+             * happen to move upwards, when you press LEFT you then tend
+             * downwards (rather than upwards again). */
+            int orthorder = (button == CURSOR_LEFT || button == CURSOR_UP) ? 1 : -1;
+
+            /* This attempts to find an island in the direction you're
+             * asking for, broadly speaking. If you ask to go right, for
+             * example, it'll look for islands to the right and slightly
+             * above or below your current horiz. position, allowing
+             * further above/below the further away it searches. */
+
+            assert(GRID(state, ui->cur_x, ui->cur_y) & G_ISLAND);
+            /* currently this is depth-first (so orthogonally-adjacent
+             * islands across the other side of the grid will be moved to
+             * before closer islands slightly offset). Swap the order of
+             * these two loops to change to breadth-first search. */
+            for (orth = 0; ; orth++) {
+                int oingrid = 0;
+                for (dir = 1; ; dir++) {
+                    int dingrid = 0;
+
+                    if (orth > dir) continue; /* only search in cone outwards. */
+
+                    nx = ui->cur_x + dir*dx + orth*dorthx*orthorder;
+                    ny = ui->cur_y + dir*dy + orth*dorthy*orthorder;
+                    if (INGRID(state, nx, ny)) {
+                        dingrid = oingrid = 1;
+                        if (GRID(state, nx, ny) & G_ISLAND) goto found;
+                    }
+
+                    nx = ui->cur_x + dir*dx - orth*dorthx*orthorder;
+                    ny = ui->cur_y + dir*dy - orth*dorthy*orthorder;
+                    if (INGRID(state, nx, ny)) {
+                        dingrid = oingrid = 1;
+                        if (GRID(state, nx, ny) & G_ISLAND) goto found;
+                    }
+
+                    if (!dingrid) break;
+                }
+                if (!oingrid) return "";
+            }
+            /* not reached */
+
+found:
+            ui->cur_x = nx;
+            ui->cur_y = ny;
+            return "";
+        }
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+        if (ui->dragging || button == CURSOR_SELECT2) {
+            ui_cancel_drag(ui);
+            if (ui->dragx_dst == -1 && ui->dragy_dst == -1) {
+                sprintf(buf, "M%d,%d", ui->cur_x, ui->cur_y);
+                return dupstr(buf);
+            } else
+                return "";
+        } else {
+            grid_type v = GRID(state, ui->cur_x, ui->cur_y);
+            if (v & G_ISLAND) {
+                ui->dragging = 1;
+                ui->dragx_src = ui->cur_x;
+                ui->dragy_src = ui->cur_y;
+                ui->dragx_dst = ui->dragy_dst = -1;
+                ui->drag_is_noline = (button == CURSOR_SELECT2) ? 1 : 0;
+                return "";
+            }
+        }
+    } else if ((button >= '0' && button <= '9') ||
+               (button >= 'a' && button <= 'f') ||
+               (button >= 'A' && button <= 'F')) {
+        /* jump to island with .count == number closest to cur_{x,y} */
+        int best_x = -1, best_y = -1, best_sqdist = -1, number = -1, i;
+
+        if (button >= '0' && button <= '9')
+            number = (button == '0' ? 16 : button - '0');
+        else if (button >= 'a' && button <= 'f')
+            number = 10 + button - 'a';
+        else if (button >= 'A' && button <= 'F')
+            number = 10 + button - 'A';
+
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+
+        for (i = 0; i < state->n_islands; ++i) {
+            int x = state->islands[i].x, y = state->islands[i].y;
+            int dx = x - ui->cur_x, dy = y - ui->cur_y;
+            int sqdist = dx*dx + dy*dy;
+
+            if (state->islands[i].count != number)
+                continue;
+            if (x == ui->cur_x && y == ui->cur_y)
+                continue;
+
+            /* new_game() reads the islands in row-major order, so by
+             * breaking ties in favor of `first in state->islands' we
+             * also break ties by `lexicographically smallest (y, x)'.
+             * Thus, there's a stable pattern to how ties are broken
+             * which the user can learn and use to navigate faster. */
+            if (best_sqdist == -1 || sqdist < best_sqdist) {
+                best_x = x;
+                best_y = y;
+                best_sqdist = sqdist;
+            }
+        }
+        if (best_x != -1 && best_y != -1) {
+            ui->cur_x = best_x;
+            ui->cur_y = best_y;
+            return "";
+        } else
+            return NULL;
+    } else if (button == 'g' || button == 'G') {
+        ui->show_hints = 1 - ui->show_hints;
+        return "";
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    game_state *ret = dup_game(state);
+    int x1, y1, x2, y2, nl, n;
+    struct island *is1, *is2;
+    char c;
+
+    debug(("execute_move: %s\n", move));
+
+    if (!*move) goto badmove;
+    while (*move) {
+        c = *move++;
+        if (c == 'S') {
+            ret->solved = TRUE;
+            n = 0;
+        } else if (c == 'L') {
+            if (sscanf(move, "%d,%d,%d,%d,%d%n",
+                       &x1, &y1, &x2, &y2, &nl, &n) != 5)
+                goto badmove;
+            if (!INGRID(ret, x1, y1) || !INGRID(ret, x2, y2))
+                goto badmove;
+            is1 = INDEX(ret, gridi, x1, y1);
+            is2 = INDEX(ret, gridi, x2, y2);
+            if (!is1 || !is2) goto badmove;
+            if (nl < 0 || nl > state->maxb) goto badmove;
+            island_join(is1, is2, nl, 0);
+        } else if (c == 'N') {
+            if (sscanf(move, "%d,%d,%d,%d%n",
+                       &x1, &y1, &x2, &y2, &n) != 4)
+                goto badmove;
+            if (!INGRID(ret, x1, y1) || !INGRID(ret, x2, y2))
+                goto badmove;
+            is1 = INDEX(ret, gridi, x1, y1);
+            is2 = INDEX(ret, gridi, x2, y2);
+            if (!is1 || !is2) goto badmove;
+            island_join(is1, is2, -1, 0);
+        } else if (c == 'M') {
+            if (sscanf(move, "%d,%d%n",
+                       &x1, &y1, &n) != 2)
+                goto badmove;
+            if (!INGRID(ret, x1, y1))
+                goto badmove;
+            is1 = INDEX(ret, gridi, x1, y1);
+            if (!is1) goto badmove;
+            island_togglemark(is1);
+        } else
+            goto badmove;
+
+        move += n;
+        if (*move == ';')
+            move++;
+        else if (*move) goto badmove;
+    }
+
+    map_update_possibles(ret);
+    if (map_check(ret)) {
+        debug(("Game completed.\n"));
+        ret->completed = 1;
+    }
+    return ret;
+
+badmove:
+    debug(("%s: unrecognised move.\n", move));
+    free_game(ret);
+    return NULL;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    char *ret;
+    game_state *solved;
+
+    if (aux) {
+        debug(("solve_game: aux = %s\n", aux));
+        solved = execute_move(state, aux);
+        if (!solved) {
+            *error = "Generated aux string is not a valid move (!).";
+            return NULL;
+        }
+    } else {
+        solved = dup_game(state);
+        /* solve with max strength... */
+        if (solve_from_scratch(solved, 10) == 0) {
+            free_game(solved);
+            *error = "Game does not have a (non-recursive) solution.";
+            return NULL;
+        }
+    }
+    ret = game_state_diff(currstate, solved);
+    free_game(solved);
+    debug(("solve_game: ret = %s\n", ret));
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = TILE_SIZE * params->w + 2 * BORDER;
+    *y = TILE_SIZE * params->h + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_FOREGROUND * 3 + i] = 0.0F;
+        ret[COL_HINT * 3 + i] = ret[COL_LOWLIGHT * 3 + i];
+        ret[COL_GRID * 3 + i] =
+            (ret[COL_HINT * 3 + i] + ret[COL_BACKGROUND * 3 + i]) * 0.5F;
+        ret[COL_MARK * 3 + i] = ret[COL_HIGHLIGHT * 3 + i];
+    }
+    ret[COL_WARNING * 3 + 0] = 1.0F;
+    ret[COL_WARNING * 3 + 1] = 0.25F;
+    ret[COL_WARNING * 3 + 2] = 0.25F;
+
+    ret[COL_SELECTED * 3 + 0] = 0.25F;
+    ret[COL_SELECTED * 3 + 1] = 1.00F;
+    ret[COL_SELECTED * 3 + 2] = 0.25F;
+
+    ret[COL_CURSOR * 3 + 0] = min(ret[COL_BACKGROUND * 3 + 0] * 1.4F, 1.0F);
+    ret[COL_CURSOR * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 0.8F;
+    ret[COL_CURSOR * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 0.8F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int wh = state->w*state->h;
+    int i;
+
+    ds->tilesize = 0;
+    ds->w = state->w;
+    ds->h = state->h;
+    ds->started = 0;
+    ds->dragging = 0;
+    ds->grid = snewn(wh, unsigned long);
+    for (i = 0; i < wh; i++)
+        ds->grid[i] = ~0UL;
+    ds->newgrid = snewn(wh, unsigned long);
+    ds->lv = snewn(wh, int);
+    ds->lh = snewn(wh, int);
+    memset(ds->lv, 0, wh*sizeof(int));
+    memset(ds->lh, 0, wh*sizeof(int));
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->lv);
+    sfree(ds->lh);
+    sfree(ds->newgrid);
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+#define LINE_WIDTH (TILE_SIZE/8)
+#define TS8(x) (((x)*TILE_SIZE)/8)
+
+#define OFFSET(thing) ((TILE_SIZE/2) - ((thing)/2))
+
+static int between_island(const game_state *state, int sx, int sy,
+                          int dx, int dy)
+{
+    int x = sx - dx, y = sy - dy;
+
+    while (INGRID(state, x, y)) {
+        if (GRID(state, x, y) & G_ISLAND) goto found;
+        x -= dx; y -= dy;
+    }
+    return 0;
+found:
+    x = sx + dx, y = sy + dy;
+    while (INGRID(state, x, y)) {
+        if (GRID(state, x, y) & G_ISLAND) return 1;
+        x += dx; y += dy;
+    }
+    return 0;
+}
+
+static void lines_lvlh(const game_state *state, const game_ui *ui,
+                       int x, int y, grid_type v, int *lv_r, int *lh_r)
+{
+    int lh = 0, lv = 0;
+
+    if (v & G_LINEV) lv = INDEX(state,lines,x,y);
+    if (v & G_LINEH) lh = INDEX(state,lines,x,y);
+
+    if (ui->show_hints) {
+        if (between_island(state, x, y, 0, 1) && !lv) lv = 1;
+        if (between_island(state, x, y, 1, 0) && !lh) lh = 1;
+    }
+    /*debug(("lvlh: (%d,%d) v 0x%x lv %d lh %d.\n", x, y, v, lv, lh));*/
+    *lv_r = lv; *lh_r = lh;
+}
+
+static void draw_cross(drawing *dr, game_drawstate *ds,
+                       int ox, int oy, int col)
+{
+    int off = TS8(2);
+    draw_line(dr, ox,     oy, ox+off, oy+off, col);
+    draw_line(dr, ox+off, oy, ox,     oy+off, col);
+}
+
+static void draw_general_line(drawing *dr, game_drawstate *ds,
+                              int ox, int oy, int fx, int fy, int ax, int ay,
+                              int len, unsigned long ldata, int which)
+{
+    /*
+     * Draw one direction of lines in a square. To permit the same
+     * code to handle horizontal and vertical lines, fx,fy are the
+     * 'forward' direction (along the lines) and ax,ay are the
+     * 'across' direction.
+     *
+     * We draw the white background for a locked bridge if (which &
+     * 1), and draw the bridges themselves if (which & 2). This
+     * permits us to get two overlapping locked bridges right without
+     * one of them erasing part of the other.
+     */
+    int fg;
+
+    fg = ((ldata & DL_COUNTMASK) == DL_COUNT_HINT ? COL_HINT :
+          (ldata & DL_COLMASK) == DL_COL_SELECTED ? COL_SELECTED :
+          (ldata & DL_COLMASK) == DL_COL_FLASH ? COL_HIGHLIGHT :
+          (ldata & DL_COLMASK) == DL_COL_WARNING ? COL_WARNING :
+          COL_FOREGROUND);
+
+    if ((ldata & DL_COUNTMASK) == DL_COUNT_CROSS) {
+        draw_cross(dr, ds,
+                   ox + TS8(1)*fx + TS8(3)*ax,
+                   oy + TS8(1)*fy + TS8(3)*ay, fg);
+        draw_cross(dr, ds,
+                   ox + TS8(5)*fx + TS8(3)*ax,
+                   oy + TS8(5)*fy + TS8(3)*ay, fg);
+    } else if ((ldata & DL_COUNTMASK) != 0) {
+        int lh, lw, gw, bw, i, loff;
+
+        lh = (ldata & DL_COUNTMASK);
+        if (lh == DL_COUNT_HINT)
+            lh = 1;
+
+        lw = gw = LINE_WIDTH;
+        while ((bw = lw * lh + gw * (lh+1)) > TILE_SIZE)
+            gw--;
+
+        loff = OFFSET(bw);
+
+        if (which & 1) {
+            if ((ldata & DL_LOCK) && fg != COL_HINT)
+                draw_rect(dr, ox + loff*ax, oy + loff*ay,
+                          len*fx+bw*ax, len*fy+bw*ay, COL_MARK);
+        }
+        if (which & 2) {
+            for (i = 0; i < lh; i++, loff += lw + gw)
+                draw_rect(dr, ox + (loff+gw)*ax, oy + (loff+gw)*ay,
+                          len*fx+lw*ax, len*fy+lw*ay, fg);
+        }
+    }
+}
+
+static void draw_hline(drawing *dr, game_drawstate *ds,
+                       int ox, int oy, int w, unsigned long vdata, int which)
+{
+    draw_general_line(dr, ds, ox, oy, 1, 0, 0, 1, w, vdata, which);
+}
+
+static void draw_vline(drawing *dr, game_drawstate *ds,
+                       int ox, int oy, int h, unsigned long vdata, int which)
+{
+    draw_general_line(dr, ds, ox, oy, 0, 1, 1, 0, h, vdata, which);
+}
+
+#define ISLAND_RADIUS ((TILE_SIZE*12)/20)
+#define ISLAND_NUMSIZE(clue) \
+    (((clue) < 10) ? (TILE_SIZE*7)/10 : (TILE_SIZE*5)/10)
+
+static void draw_island(drawing *dr, game_drawstate *ds,
+                        int ox, int oy, int clue, unsigned long idata)
+{
+    int half, orad, irad, fg, bg;
+
+    if ((idata & DI_BGMASK) == DI_BG_NO_ISLAND)
+        return;
+
+    half = TILE_SIZE/2;
+    orad = ISLAND_RADIUS;
+    irad = orad - LINE_WIDTH;
+    fg = ((idata & DI_COLMASK) == DI_COL_SELECTED ? COL_SELECTED :
+          (idata & DI_COLMASK) == DI_COL_WARNING ? COL_WARNING :
+          (idata & DI_COLMASK) == DI_COL_FLASH ? COL_HIGHLIGHT :
+          COL_FOREGROUND);
+    bg = ((idata & DI_BGMASK) == DI_BG_CURSOR ? COL_CURSOR :
+          (idata & DI_BGMASK) == DI_BG_MARK ? COL_MARK :
+          COL_BACKGROUND);
+
+    /* draw a thick circle */
+    draw_circle(dr, ox+half, oy+half, orad, fg, fg);
+    draw_circle(dr, ox+half, oy+half, irad, bg, bg);
+
+    if (clue > 0) {
+        char str[32];
+        int textcolour = (fg == COL_SELECTED ? COL_FOREGROUND : fg);
+        sprintf(str, "%d", clue);
+        draw_text(dr, ox+half, oy+half, FONT_VARIABLE, ISLAND_NUMSIZE(clue),
+                  ALIGN_VCENTRE | ALIGN_HCENTRE, textcolour, str);
+    }
+}
+
+static void draw_island_tile(drawing *dr, game_drawstate *ds,
+                             int x, int y, int clue, unsigned long data)
+{
+    int ox = COORD(x), oy = COORD(y);
+    int which;
+
+    clip(dr, ox, oy, TILE_SIZE, TILE_SIZE);
+    draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE, COL_BACKGROUND);
+
+    /*
+     * Because of the possibility of incoming bridges just about
+     * meeting at one corner, we must split the line-drawing into
+     * background and foreground segments.
+     */
+    for (which = 1; which <= 2; which <<= 1) {
+        draw_hline(dr, ds, ox, oy, TILE_SIZE/2,
+                   (data >> D_I_LINE_SHIFT_L) & DL_MASK, which);
+        draw_hline(dr, ds, ox + TILE_SIZE - TILE_SIZE/2, oy, TILE_SIZE/2,
+                   (data >> D_I_LINE_SHIFT_R) & DL_MASK, which);
+        draw_vline(dr, ds, ox, oy, TILE_SIZE/2,
+                   (data >> D_I_LINE_SHIFT_U) & DL_MASK, which);
+        draw_vline(dr, ds, ox, oy + TILE_SIZE - TILE_SIZE/2, TILE_SIZE/2,
+                   (data >> D_I_LINE_SHIFT_D) & DL_MASK, which);
+    }
+    draw_island(dr, ds, ox, oy, clue, (data >> D_I_ISLAND_SHIFT) & DI_MASK);
+
+    unclip(dr);
+    draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
+}
+
+static void draw_line_tile(drawing *dr, game_drawstate *ds,
+                           int x, int y, unsigned long data)
+{
+    int ox = COORD(x), oy = COORD(y);
+    unsigned long hdata, vdata;
+
+    clip(dr, ox, oy, TILE_SIZE, TILE_SIZE);
+    draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE, COL_BACKGROUND);
+
+    /*
+     * We have to think about which of the horizontal and vertical
+     * line to draw first, if both exist.
+     *
+     * The rule is that hint lines are drawn at the bottom, then
+     * NOLINE crosses, then actual bridges. The enumeration in the
+     * DL_COUNTMASK field is set up so that this drops out of a
+     * straight comparison between the two.
+     *
+     * Since lines crossing in this type of square cannot both be
+     * actual bridges, there's no need to pass a nontrivial 'which'
+     * parameter to draw_[hv]line.
+     */
+    hdata = (data >> D_L_LINE_SHIFT_H) & DL_MASK;
+    vdata = (data >> D_L_LINE_SHIFT_V) & DL_MASK;
+    if ((hdata & DL_COUNTMASK) > (vdata & DL_COUNTMASK)) {
+        draw_hline(dr, ds, ox, oy, TILE_SIZE, hdata, 3);
+        draw_vline(dr, ds, ox, oy, TILE_SIZE, vdata, 3);
+    } else {
+        draw_vline(dr, ds, ox, oy, TILE_SIZE, vdata, 3);
+        draw_hline(dr, ds, ox, oy, TILE_SIZE, hdata, 3);
+    }
+
+    /*
+     * The islands drawn at the edges of a line tile don't need clue
+     * numbers.
+     */
+    draw_island(dr, ds, ox - TILE_SIZE, oy, -1,
+                (data >> D_L_ISLAND_SHIFT_L) & DI_MASK);
+    draw_island(dr, ds, ox + TILE_SIZE, oy, -1,
+                (data >> D_L_ISLAND_SHIFT_R) & DI_MASK);
+    draw_island(dr, ds, ox, oy - TILE_SIZE, -1,
+                (data >> D_L_ISLAND_SHIFT_U) & DI_MASK);
+    draw_island(dr, ds, ox, oy + TILE_SIZE, -1,
+                (data >> D_L_ISLAND_SHIFT_D) & DI_MASK);
+
+    unclip(dr);
+    draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
+}
+
+static void draw_edge_tile(drawing *dr, game_drawstate *ds,
+                           int x, int y, int dx, int dy, unsigned long data)
+{
+    int ox = COORD(x), oy = COORD(y);
+    int cx = ox, cy = oy, cw = TILE_SIZE, ch = TILE_SIZE;
+
+    if (dy) {
+        if (dy > 0)
+            cy += TILE_SIZE/2;
+        ch -= TILE_SIZE/2;
+    } else {
+        if (dx > 0)
+            cx += TILE_SIZE/2;
+        cw -= TILE_SIZE/2;
+    }
+    clip(dr, cx, cy, cw, ch);
+    draw_rect(dr, cx, cy, cw, ch, COL_BACKGROUND);
+
+    draw_island(dr, ds, ox + TILE_SIZE*dx, oy + TILE_SIZE*dy, -1,
+                (data >> D_I_ISLAND_SHIFT) & DI_MASK);
+
+    unclip(dr);
+    draw_update(dr, cx, cy, cw, ch);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int x, y, lv, lh;
+    grid_type v, flash = 0;
+    struct island *is, *is_drag_src = NULL, *is_drag_dst = NULL;
+
+    if (flashtime) {
+        int f = (int)(flashtime * 5 / FLASH_TIME);
+        if (f == 1 || f == 3) flash = TRUE;
+    }
+
+    /* Clear screen, if required. */
+    if (!ds->started) {
+        draw_rect(dr, 0, 0,
+                  TILE_SIZE * ds->w + 2 * BORDER,
+                  TILE_SIZE * ds->h + 2 * BORDER, COL_BACKGROUND);
+#ifdef DRAW_GRID
+        draw_rect_outline(dr,
+                          COORD(0)-1, COORD(0)-1,
+                          TILE_SIZE * ds->w + 2, TILE_SIZE * ds->h + 2,
+                          COL_GRID);
+#endif
+        draw_update(dr, 0, 0,
+                    TILE_SIZE * ds->w + 2 * BORDER,
+                    TILE_SIZE * ds->h + 2 * BORDER);
+        ds->started = 1;
+    }
+
+    if (ui->dragx_src != -1 && ui->dragy_src != -1) {
+        ds->dragging = 1;
+        is_drag_src = INDEX(state, gridi, ui->dragx_src, ui->dragy_src);
+        assert(is_drag_src);
+        if (ui->dragx_dst != -1 && ui->dragy_dst != -1) {
+            is_drag_dst = INDEX(state, gridi, ui->dragx_dst, ui->dragy_dst);
+            assert(is_drag_dst);
+        }
+    } else
+        ds->dragging = 0;
+
+    /*
+     * Set up ds->newgrid with the current grid contents.
+     */
+    for (x = 0; x < ds->w; x++)
+        for (y = 0; y < ds->h; y++)
+            INDEX(ds,newgrid,x,y) = 0;
+
+    for (x = 0; x < ds->w; x++) {
+        for (y = 0; y < ds->h; y++) {
+            v = GRID(state, x, y);
+
+            if (v & G_ISLAND) {
+                /*
+                 * An island square. Compute the drawing data for the
+                 * island, and put it in this square and surrounding
+                 * squares.
+                 */
+                unsigned long idata = 0;
+
+                is = INDEX(state, gridi, x, y);
+
+                if (flash)
+                    idata |= DI_COL_FLASH;
+                if (is_drag_src && (is == is_drag_src ||
+                                    (is_drag_dst && is == is_drag_dst)))
+                    idata |= DI_COL_SELECTED;
+                else if (island_impossible(is, v & G_MARK) || (v & G_WARN))
+                    idata |= DI_COL_WARNING;
+                else
+                    idata |= DI_COL_NORMAL;
+
+                if (ui->cur_visible &&
+                    ui->cur_x == is->x && ui->cur_y == is->y)
+                    idata |= DI_BG_CURSOR;
+                else if (v & G_MARK)
+                    idata |= DI_BG_MARK;
+                else
+                    idata |= DI_BG_NORMAL;
+
+                INDEX(ds,newgrid,x,y) |= idata << D_I_ISLAND_SHIFT;
+                if (x > 0 && !(GRID(state,x-1,y) & G_ISLAND))
+                    INDEX(ds,newgrid,x-1,y) |= idata << D_L_ISLAND_SHIFT_R;
+                if (x+1 < state->w && !(GRID(state,x+1,y) & G_ISLAND))
+                    INDEX(ds,newgrid,x+1,y) |= idata << D_L_ISLAND_SHIFT_L;
+                if (y > 0 && !(GRID(state,x,y-1) & G_ISLAND))
+                    INDEX(ds,newgrid,x,y-1) |= idata << D_L_ISLAND_SHIFT_D;
+                if (y+1 < state->h && !(GRID(state,x,y+1) & G_ISLAND))
+                    INDEX(ds,newgrid,x,y+1) |= idata << D_L_ISLAND_SHIFT_U;
+            } else {
+                unsigned long hdata, vdata;
+                int selh = FALSE, selv = FALSE;
+
+                /*
+                 * A line (non-island) square. Compute the drawing
+                 * data for any horizontal and vertical lines in the
+                 * square, and put them in this square's entry and
+                 * optionally those for neighbouring islands too.
+                 */
+
+                if (is_drag_dst &&
+                    WITHIN(x,is_drag_src->x, is_drag_dst->x) &&
+                    WITHIN(y,is_drag_src->y, is_drag_dst->y)) {
+                    if (is_drag_src->x != is_drag_dst->x)
+                        selh = TRUE;
+                    else
+                        selv = TRUE;
+                }
+                lines_lvlh(state, ui, x, y, v, &lv, &lh);
+
+                hdata = (v & G_NOLINEH ? DL_COUNT_CROSS :
+                         v & G_LINEH ? lh :
+                         (ui->show_hints &&
+                          between_island(state,x,y,1,0)) ? DL_COUNT_HINT : 0);
+                vdata = (v & G_NOLINEV ? DL_COUNT_CROSS :
+                         v & G_LINEV ? lv :
+                         (ui->show_hints &&
+                          between_island(state,x,y,0,1)) ? DL_COUNT_HINT : 0);
+
+                hdata |= (flash ? DL_COL_FLASH :
+                          v & G_WARN ? DL_COL_WARNING :
+                          selh ? DL_COL_SELECTED :
+                          DL_COL_NORMAL);
+                vdata |= (flash ? DL_COL_FLASH :
+                          v & G_WARN ? DL_COL_WARNING :
+                          selv ? DL_COL_SELECTED :
+                          DL_COL_NORMAL);
+
+                if (v & G_MARKH)
+                    hdata |= DL_LOCK;
+                if (v & G_MARKV)
+                    vdata |= DL_LOCK;
+
+                INDEX(ds,newgrid,x,y) |= hdata << D_L_LINE_SHIFT_H;
+                INDEX(ds,newgrid,x,y) |= vdata << D_L_LINE_SHIFT_V;
+                if (x > 0 && (GRID(state,x-1,y) & G_ISLAND))
+                    INDEX(ds,newgrid,x-1,y) |= hdata << D_I_LINE_SHIFT_R;
+                if (x+1 < state->w && (GRID(state,x+1,y) & G_ISLAND))
+                    INDEX(ds,newgrid,x+1,y) |= hdata << D_I_LINE_SHIFT_L;
+                if (y > 0 && (GRID(state,x,y-1) & G_ISLAND))
+                    INDEX(ds,newgrid,x,y-1) |= vdata << D_I_LINE_SHIFT_D;
+                if (y+1 < state->h && (GRID(state,x,y+1) & G_ISLAND))
+                    INDEX(ds,newgrid,x,y+1) |= vdata << D_I_LINE_SHIFT_U;
+            }
+        }
+    }
+
+    /*
+     * Now go through and draw any changed grid square.
+     */
+    for (x = 0; x < ds->w; x++) {
+        for (y = 0; y < ds->h; y++) {
+            unsigned long newval = INDEX(ds,newgrid,x,y);
+            if (INDEX(ds,grid,x,y) != newval) {
+                v = GRID(state, x, y);
+                if (v & G_ISLAND) {
+                    is = INDEX(state, gridi, x, y);
+                    draw_island_tile(dr, ds, x, y, is->count, newval);
+
+                    /*
+                     * If this tile is right at the edge of the grid,
+                     * we must also draw the part of the island that
+                     * goes completely out of bounds. We don't bother
+                     * keeping separate entries in ds->newgrid for
+                     * these tiles; it's easier just to redraw them
+                     * iff we redraw their parent island tile.
+                     */
+                    if (x == 0)
+                        draw_edge_tile(dr, ds, x-1, y, +1, 0, newval);
+                    if (y == 0)
+                        draw_edge_tile(dr, ds, x, y-1, 0, +1, newval);
+                    if (x == state->w-1)
+                        draw_edge_tile(dr, ds, x+1, y, -1, 0, newval);
+                    if (y == state->h-1)
+                        draw_edge_tile(dr, ds, x, y+1, 0, -1, newval);
+                } else {
+                    draw_line_tile(dr, ds, x, y, newval);
+                }
+                INDEX(ds,grid,x,y) = newval;
+            }
+        }
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->solved && !newstate->solved)
+        return FLASH_TIME;
+
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /* 10mm squares by default. */
+    game_compute_size(params, 1000, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int ts)
+{
+    int ink = print_mono_colour(dr, 0);
+    int paper = print_mono_colour(dr, 1);
+    int x, y, cx, cy, i, nl;
+    int loff;
+    grid_type grid;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    ads.tilesize = ts;
+
+    /* I don't think this wants a border. */
+
+    /* Bridges */
+    loff = ts / (8 * sqrt((state->params.maxb - 1)));
+    print_line_width(dr, ts / 12);
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            cx = COORD(x); cy = COORD(y);
+            grid = GRID(state,x,y);
+            nl = INDEX(state,lines,x,y);
+
+            if (grid & G_ISLAND) continue;
+            if (grid & G_LINEV) {
+                for (i = 0; i < nl; i++)
+                    draw_line(dr, cx+ts/2+(2*i-nl+1)*loff, cy,
+                              cx+ts/2+(2*i-nl+1)*loff, cy+ts, ink);
+            }
+            if (grid & G_LINEH) {
+                for (i = 0; i < nl; i++)
+                    draw_line(dr, cx, cy+ts/2+(2*i-nl+1)*loff,
+                              cx+ts, cy+ts/2+(2*i-nl+1)*loff, ink);
+            }
+        }
+    }
+
+    /* Islands */
+    for (i = 0; i < state->n_islands; i++) {
+        char str[32];
+        struct island *is = &state->islands[i];
+        grid = GRID(state, is->x, is->y);
+        cx = COORD(is->x) + ts/2;
+        cy = COORD(is->y) + ts/2;
+
+        draw_circle(dr, cx, cy, ISLAND_RADIUS, paper, ink);
+
+        sprintf(str, "%d", is->count);
+        draw_text(dr, cx, cy, FONT_VARIABLE, ISLAND_NUMSIZE(is->count),
+                  ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str);
+    }
+}
+
+#ifdef COMBINED
+#define thegame bridges
+#endif
+
+const struct game thegame = {
+    "Bridges", "games.bridges", "bridges",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON,                   /* flags */
+};
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/chm.but b/apps/plugins/puzzles/chm.but
new file mode 100644
index 0000000000..e0237044e4
--- /dev/null
+++ b/apps/plugins/puzzles/chm.but
@@ -0,0 +1,21 @@
+\# File containing the magic HTML configuration directives to create
+\# an MS HTML Help project. We put this on the end of the Puzzles
+\# docs build command line to build the HHP and friends.
+
+\cfg{html-leaf-level}{infinite}
+\cfg{html-leaf-contains-contents}{false}
+\cfg{html-suppress-navlinks}{true}
+\cfg{html-suppress-address}{true}
+
+\cfg{html-contents-filename}{index.html}
+\cfg{html-template-filename}{%k.html}
+\cfg{html-template-fragment}{%k}
+
+\cfg{html-mshtmlhelp-chm}{puzzles.chm}
+\cfg{html-mshtmlhelp-project}{puzzles.hhp}
+\cfg{html-mshtmlhelp-contents}{puzzles.hhc}
+\cfg{html-mshtmlhelp-index}{puzzles.hhk}
+
+\cfg{html-body-end}{}
+
+\cfg{html-head-end}{<link rel="stylesheet" type="text/css" href="chm.css">}
diff --git a/apps/plugins/puzzles/chm.css b/apps/plugins/puzzles/chm.css
new file mode 100644
index 0000000000..d8c316bfc6
--- /dev/null
+++ b/apps/plugins/puzzles/chm.css
@@ -0,0 +1,7 @@
+/* Stylesheet for a Windows .CHM help file */
+
+body { font-size: 75%; font-family: Verdana, Arial, Helvetica, Sans-Serif; }
+
+h1 { font-weight: bold; font-size: 150%; }
+h2 { font-weight: bold; font-size: 130%; }
+h3 { font-weight: bold; font-size: 120%; }
diff --git a/apps/plugins/puzzles/combi.c b/apps/plugins/puzzles/combi.c
new file mode 100644
index 0000000000..d39e298405
--- /dev/null
+++ b/apps/plugins/puzzles/combi.c
@@ -0,0 +1,110 @@
+#include "rbassert.h"
+#include <string.h>
+
+#include "puzzles.h"
+
+/* horrific and doesn't check overflow. */
+static long factx(long x, long y)
+{
+    long acc = 1, i;
+
+    for (i = y; i <= x; i++)
+        acc *= i;
+    return acc;
+}
+
+void reset_combi(combi_ctx *combi)
+{
+    int i;
+    combi->nleft = combi->total;
+    for (i = 0; i < combi->r; i++)
+        combi->a[i] = i;
+}
+
+combi_ctx *new_combi(int r, int n)
+{
+    long nfr, nrf;
+    combi_ctx *combi;
+
+    assert(r <= n);
+    assert(n >= 1);
+
+    combi = snew(combi_ctx);
+    memset(combi, 0, sizeof(combi_ctx));
+    combi->r = r;
+    combi->n = n;
+
+    combi->a = snewn(r, int);
+    memset(combi->a, 0, r * sizeof(int));
+
+    nfr = factx(n, r+1);
+    nrf = factx(n-r, 1);
+    combi->total = (int)(nfr / nrf);
+
+    reset_combi(combi);
+    return combi;
+}
+
+/* returns NULL when we're done otherwise returns input. */
+combi_ctx *next_combi(combi_ctx *combi)
+{
+    int i = combi->r - 1, j;
+
+    if (combi->nleft == combi->total)
+        goto done;
+    else if (combi->nleft <= 0)
+        return NULL;
+
+    while (combi->a[i] == combi->n - combi->r + i)
+        i--;
+    combi->a[i] += 1;
+    for (j = i+1; j < combi->r; j++)
+        combi->a[j] = combi->a[i] + j - i;
+
+    done:
+    combi->nleft--;
+    return combi;
+}
+
+void free_combi(combi_ctx *combi)
+{
+    sfree(combi->a);
+    sfree(combi);
+}
+
+/* compile this with:
+ *   gcc -o combi.exe -DSTANDALONE_COMBI_TEST combi.c malloc.c
+ */
+#ifdef STANDALONE_COMBI_TEST
+
+#include <stdio.h>
+
+void fatal(char *fmt, ...)
+{
+    abort();
+}
+
+int main(int argc, char *argv[])
+{
+    combi_ctx *c;
+    int i, r, n;
+
+    if (argc < 3) {
+        fprintf(stderr, "Usage: combi R N\n");
+        exit(1);
+    }
+
+    r = atoi(argv[1]); n = atoi(argv[2]);
+    c = new_combi(r, n);
+    printf("combi %d of %d, %d elements.\n", c->r, c->n, c->total);
+
+    while (next_combi(c)) {
+        for (i = 0; i < c->r; i++) {
+            printf("%d ", c->a[i]);
+        }
+        printf("\n");
+    }
+    free_combi(c);
+}
+
+#endif
diff --git a/apps/plugins/puzzles/configure.ac b/apps/plugins/puzzles/configure.ac
new file mode 100644
index 0000000000..3a38c95602
--- /dev/null
+++ b/apps/plugins/puzzles/configure.ac
@@ -0,0 +1,85 @@
+dnl Configure script for the Unix GTK build of puzzles.
+
+AC_INIT([puzzles], [6.66], [anakin@pobox.com])
+AC_CONFIG_SRCDIR([midend.c])
+AM_INIT_AUTOMAKE([foreign])
+AC_PROG_CC
+
+AC_ARG_WITH([gtk],
+  [AS_HELP_STRING([--with-gtk=VER],
+                  [specify GTK version to use (`2' or `3')])],
+  [gtk_version_desired="$withval"],
+  [gtk_version_desired="any"])
+
+case "$gtk_version_desired" in
+  2 | 3 | any) ;;
+  yes) gtk_version_desired="any" ;;
+  *) AC_ERROR([Invalid GTK version specified])
+esac
+
+gtk=none
+
+case "$gtk_version_desired:$gtk" in
+  3:none | any:none)
+    ifdef([AM_PATH_GTK_3_0],[
+    AM_PATH_GTK_3_0([3.0.0], [gtk=3], [])
+    ],[AC_WARNING([generating configure script without GTK 3 autodetection])])
+    ;;
+esac
+
+case "$gtk_version_desired:$gtk" in
+  2:none | any:none)
+    ifdef([AM_PATH_GTK_2_0],[
+    AM_PATH_GTK_2_0([2.0.0], [gtk=2], [])
+    ],[AC_WARNING([generating configure script without GTK 2 autodetection])])
+    ;;
+esac
+
+if test "$gtk" = "none"; then
+   AC_MSG_ERROR([cannot build without GTK 2 or GTK 3])
+fi
+
+if test "x$GCC" = "xyes"; then
+  AC_MSG_CHECKING([for usable gcc warning flags])
+  gccwarningflags=
+  for flag in -Wall -Werror -std=c89 -pedantic; do
+    ac_save_CFLAGS="$CFLAGS"
+    ac_save_LIBS="$LIBS"
+    CFLAGS="$CFLAGS$gccwarningflags $flag $GTK_CFLAGS"
+    LIBS="$GTK_LIBS $LIBS"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
+        #include <stdio.h>
+        #include <assert.h>
+        #include <stdlib.h>
+        #include <time.h>
+        #include <stdarg.h>
+        #include <string.h>
+        #include <errno.h>
+        #include <math.h>
+
+        #include <sys/time.h>
+        #include <sys/resource.h>
+
+        #include <gtk/gtk.h>
+        #include <gdk/gdkkeysyms.h>
+
+        #include <gdk-pixbuf/gdk-pixbuf.h>
+
+        #include <gdk/gdkx.h>
+        #include <X11/Xlib.h>
+        #include <X11/Xutil.h>
+        #include <X11/Xatom.h>
+    ],[
+        return 0;
+    ])], [gccwarningflags="$gccwarningflags $flag"], [])
+    CFLAGS="$ac_save_CFLAGS"
+    LIBS="$ac_save_LIBS"
+  done
+  AC_MSG_RESULT($gccwarningflags)
+  CFLAGS="$CFLAGS$gccwarningflags"
+fi
+
+AC_PROG_RANLIB
+AC_PROG_INSTALL
+AC_CONFIG_FILES([Makefile])
+AC_OUTPUT
diff --git a/apps/plugins/puzzles/cube.R b/apps/plugins/puzzles/cube.R
new file mode 100644
index 0000000000..85b081ec76
--- /dev/null
+++ b/apps/plugins/puzzles/cube.R
@@ -0,0 +1,19 @@
+# -*- makefile -*-
+
+cube     : [X] GTK COMMON cube cube-icon|no-icon
+
+cube     : [G] WINDOWS COMMON cube cube.res|noicon.res
+
+ALL += cube[COMBINED]
+
+!begin am gtk
+GAMES += cube
+!end
+
+!begin >list.c
+    A(cube) \
+!end
+
+!begin >gamedesc.txt
+cube:cube.exe:Cube:Rolling cube puzzle:Pick up all the blue squares by rolling the cube over them.
+!end
diff --git a/apps/plugins/puzzles/cube.c b/apps/plugins/puzzles/cube.c
new file mode 100644
index 0000000000..5a09648226
--- /dev/null
+++ b/apps/plugins/puzzles/cube.c
@@ -0,0 +1,1774 @@
+/*
+ * cube.c: Cube game.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#define MAXVERTICES 20
+#define MAXFACES 20
+#define MAXORDER 4
+struct solid {
+    int nvertices;
+    float vertices[MAXVERTICES * 3];   /* 3*npoints coordinates */
+    int order;
+    int nfaces;
+    int faces[MAXFACES * MAXORDER];    /* order*nfaces point indices */
+    float normals[MAXFACES * 3];       /* 3*npoints vector components */
+    float shear;                       /* isometric shear for nice drawing */
+    float border;                      /* border required around arena */
+};
+
+static const struct solid s_tetrahedron = {
+    4,
+    {
+        0.0F, -0.57735026919F, -0.20412414523F,
+        -0.5F, 0.28867513459F, -0.20412414523F,
+        0.0F, -0.0F, 0.6123724357F,
+        0.5F, 0.28867513459F, -0.20412414523F,
+    },
+    3, 4,
+    {
+        0,2,1, 3,1,2, 2,0,3, 1,3,0
+    },
+    {
+        -0.816496580928F, -0.471404520791F, 0.333333333334F,
+        0.0F, 0.942809041583F, 0.333333333333F,
+        0.816496580928F, -0.471404520791F, 0.333333333334F,
+        0.0F, 0.0F, -1.0F,
+    },
+    0.0F, 0.3F
+};
+
+static const struct solid s_cube = {
+    8,
+    {
+        -0.5F,-0.5F,-0.5F, -0.5F,-0.5F,+0.5F,
+        -0.5F,+0.5F,-0.5F, -0.5F,+0.5F,+0.5F,
+        +0.5F,-0.5F,-0.5F, +0.5F,-0.5F,+0.5F,
+        +0.5F,+0.5F,-0.5F, +0.5F,+0.5F,+0.5F,
+    },
+    4, 6,
+    {
+        0,1,3,2, 1,5,7,3, 5,4,6,7, 4,0,2,6, 0,4,5,1, 3,7,6,2
+    },
+    {
+        -1.0F,0.0F,0.0F, 0.0F,0.0F,+1.0F,
+        +1.0F,0.0F,0.0F, 0.0F,0.0F,-1.0F,
+        0.0F,-1.0F,0.0F, 0.0F,+1.0F,0.0F
+    },
+    0.3F, 0.5F
+};
+
+static const struct solid s_octahedron = {
+    6,
+    {
+        -0.5F, -0.28867513459472505F, 0.4082482904638664F,
+        0.5F, 0.28867513459472505F, -0.4082482904638664F,
+        -0.5F, 0.28867513459472505F, -0.4082482904638664F,
+        0.5F, -0.28867513459472505F, 0.4082482904638664F,
+        0.0F, -0.57735026918945009F, -0.4082482904638664F,
+        0.0F, 0.57735026918945009F, 0.4082482904638664F,
+    },
+    3, 8,
+    {
+        4,0,2, 0,5,2, 0,4,3, 5,0,3, 1,4,2, 5,1,2, 4,1,3, 1,5,3
+    },
+    {
+        -0.816496580928F, -0.471404520791F, -0.333333333334F,
+        -0.816496580928F, 0.471404520791F, 0.333333333334F,
+        0.0F, -0.942809041583F, 0.333333333333F,
+        0.0F, 0.0F, 1.0F,
+        0.0F, 0.0F, -1.0F,
+        0.0F, 0.942809041583F, -0.333333333333F,
+        0.816496580928F, -0.471404520791F, -0.333333333334F,
+        0.816496580928F, 0.471404520791F, 0.333333333334F,
+    },
+    0.0F, 0.5F
+};
+
+static const struct solid s_icosahedron = {
+    12,
+    {
+        0.0F, 0.57735026919F, 0.75576131408F,
+        0.0F, -0.93417235896F, 0.17841104489F,
+        0.0F, 0.93417235896F, -0.17841104489F,
+        0.0F, -0.57735026919F, -0.75576131408F,
+        -0.5F, -0.28867513459F, 0.75576131408F,
+        -0.5F, 0.28867513459F, -0.75576131408F,
+        0.5F, -0.28867513459F, 0.75576131408F,
+        0.5F, 0.28867513459F, -0.75576131408F,
+        -0.80901699437F, 0.46708617948F, 0.17841104489F,
+        0.80901699437F, 0.46708617948F, 0.17841104489F,
+        -0.80901699437F, -0.46708617948F, -0.17841104489F,
+        0.80901699437F, -0.46708617948F, -0.17841104489F,
+    },
+    3, 20,
+    {
+        8,0,2,  0,9,2,  1,10,3, 11,1,3,  0,4,6,
+        4,1,6,  5,2,7,  3,5,7,  4,8,10,  8,5,10,
+        9,6,11, 7,9,11,  0,8,4,  9,0,6,  10,1,4,
+        1,11,6, 8,2,5,  2,9,7,  3,10,5, 11,3,7,
+    },
+    {
+        -0.356822089773F, 0.87267799625F, 0.333333333333F,
+        0.356822089773F, 0.87267799625F, 0.333333333333F,
+        -0.356822089773F, -0.87267799625F, -0.333333333333F,
+        0.356822089773F, -0.87267799625F, -0.333333333333F,
+        -0.0F, 0.0F, 1.0F,
+        0.0F, -0.666666666667F, 0.745355992501F,
+        0.0F, 0.666666666667F, -0.745355992501F,
+        0.0F, 0.0F, -1.0F,
+        -0.934172358963F, -0.12732200375F, 0.333333333333F,
+        -0.934172358963F, 0.12732200375F, -0.333333333333F,
+        0.934172358963F, -0.12732200375F, 0.333333333333F,
+        0.934172358963F, 0.12732200375F, -0.333333333333F,
+        -0.57735026919F, 0.333333333334F, 0.745355992501F,
+        0.57735026919F, 0.333333333334F, 0.745355992501F,
+        -0.57735026919F, -0.745355992501F, 0.333333333334F,
+        0.57735026919F, -0.745355992501F, 0.333333333334F,
+        -0.57735026919F, 0.745355992501F, -0.333333333334F,
+        0.57735026919F, 0.745355992501F, -0.333333333334F,
+        -0.57735026919F, -0.333333333334F, -0.745355992501F,
+        0.57735026919F, -0.333333333334F, -0.745355992501F,
+    },
+    0.0F, 0.8F
+};
+
+enum {
+    TETRAHEDRON, CUBE, OCTAHEDRON, ICOSAHEDRON
+};
+static const struct solid *solids[] = {
+    &s_tetrahedron, &s_cube, &s_octahedron, &s_icosahedron
+};
+
+enum {
+    COL_BACKGROUND,
+    COL_BORDER,
+    COL_BLUE,
+    NCOLOURS
+};
+
+enum { LEFT, RIGHT, UP, DOWN, UP_LEFT, UP_RIGHT, DOWN_LEFT, DOWN_RIGHT };
+
+#define PREFERRED_GRID_SCALE 48
+#define GRID_SCALE (ds->gridscale)
+#define ROLLTIME 0.13F
+
+#define SQ(x) ( (x) * (x) )
+
+#define MATMUL(ra,m,a) do { \
+    float rx, ry, rz, xx = (a)[0], yy = (a)[1], zz = (a)[2], *mat = (m); \
+    rx = mat[0] * xx + mat[3] * yy + mat[6] * zz; \
+    ry = mat[1] * xx + mat[4] * yy + mat[7] * zz; \
+    rz = mat[2] * xx + mat[5] * yy + mat[8] * zz; \
+    (ra)[0] = rx; (ra)[1] = ry; (ra)[2] = rz; \
+} while (0)
+
+#define APPROXEQ(x,y) ( SQ(x-y) < 0.1 )
+
+struct grid_square {
+    float x, y;
+    int npoints;
+    float points[8];                   /* maximum */
+    int directions[8];                 /* bit masks showing point pairs */
+    int flip;
+    int tetra_class;
+};
+
+struct game_params {
+    int solid;
+    /*
+     * Grid dimensions. For a square grid these are width and
+     * height respectively; otherwise the grid is a hexagon, with
+     * the top side and the two lower diagonals having length d1
+     * and the remaining three sides having length d2 (so that
+     * d1==d2 gives a regular hexagon, and d2==0 gives a triangle).
+     */
+    int d1, d2;
+};
+
+typedef struct game_grid game_grid;
+struct game_grid {
+    int refcount;
+    struct grid_square *squares;
+    int nsquares;
+};
+
+#define SET_SQUARE(state, i, val) \
+    ((state)->bluemask[(i)/32] &= ~(1 << ((i)%32)), \
+     (state)->bluemask[(i)/32] |= ((!!val) << ((i)%32)))
+#define GET_SQUARE(state, i) \
+    (((state)->bluemask[(i)/32] >> ((i)%32)) & 1)
+
+struct game_state {
+    struct game_params params;
+    const struct solid *solid;
+    int *facecolours;
+    game_grid *grid;
+    unsigned long *bluemask;
+    int current;                       /* index of current grid square */
+    int sgkey[2];                      /* key-point indices into grid sq */
+    int dgkey[2];                      /* key-point indices into grid sq */
+    int spkey[2];                      /* key-point indices into polyhedron */
+    int dpkey[2];                      /* key-point indices into polyhedron */
+    int previous;
+    float angle;
+    int completed;
+    int movecount;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->solid = CUBE;
+    ret->d1 = 4;
+    ret->d2 = 4;
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret = snew(game_params);
+    char *str;
+
+    switch (i) {
+      case 0:
+        str = "Cube";
+        ret->solid = CUBE;
+        ret->d1 = 4;
+        ret->d2 = 4;
+        break;
+      case 1:
+        str = "Tetrahedron";
+        ret->solid = TETRAHEDRON;
+        ret->d1 = 1;
+        ret->d2 = 2;
+        break;
+      case 2:
+        str = "Octahedron";
+        ret->solid = OCTAHEDRON;
+        ret->d1 = 2;
+        ret->d2 = 2;
+        break;
+      case 3:
+        str = "Icosahedron";
+        ret->solid = ICOSAHEDRON;
+        ret->d1 = 3;
+        ret->d2 = 3;
+        break;
+      default:
+        sfree(ret);
+        return FALSE;
+    }
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    switch (*string) {
+      case 't': ret->solid = TETRAHEDRON; string++; break;
+      case 'c': ret->solid = CUBE;        string++; break;
+      case 'o': ret->solid = OCTAHEDRON;  string++; break;
+      case 'i': ret->solid = ICOSAHEDRON; string++; break;
+      default: break;
+    }
+    ret->d1 = ret->d2 = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        ret->d2 = atoi(string);
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    assert(params->solid >= 0 && params->solid < 4);
+    sprintf(data, "%c%dx%d", "tcoi"[params->solid], params->d1, params->d2);
+
+    return dupstr(data);
+}
+typedef void (*egc_callback)(void *, struct grid_square *);
+
+static void enum_grid_squares(const game_params *params, egc_callback callback,
+                              void *ctx)
+{
+    const struct solid *solid = solids[params->solid];
+
+    if (solid->order == 4) {
+        int x, y;
+
+        for (y = 0; y < params->d2; y++)
+            for (x = 0; x < params->d1; x++) {
+                struct grid_square sq;
+
+                sq.x = (float)x;
+                sq.y = (float)y;
+                sq.points[0] = x - 0.5F;
+                sq.points[1] = y - 0.5F;
+                sq.points[2] = x - 0.5F;
+                sq.points[3] = y + 0.5F;
+                sq.points[4] = x + 0.5F;
+                sq.points[5] = y + 0.5F;
+                sq.points[6] = x + 0.5F;
+                sq.points[7] = y - 0.5F;
+                sq.npoints = 4;
+
+                sq.directions[LEFT]  = 0x03;   /* 0,1 */
+                sq.directions[RIGHT] = 0x0C;   /* 2,3 */
+                sq.directions[UP]    = 0x09;   /* 0,3 */
+                sq.directions[DOWN]  = 0x06;   /* 1,2 */
+                sq.directions[UP_LEFT] = 0;   /* no diagonals in a square */
+                sq.directions[UP_RIGHT] = 0;   /* no diagonals in a square */
+                sq.directions[DOWN_LEFT] = 0;   /* no diagonals in a square */
+                sq.directions[DOWN_RIGHT] = 0;   /* no diagonals in a square */
+
+                sq.flip = FALSE;
+
+                /*
+                 * This is supremely irrelevant, but just to avoid
+                 * having any uninitialised structure members...
+                 */
+                sq.tetra_class = 0;
+
+                callback(ctx, &sq);
+            }
+    } else {
+        int row, rowlen, other, i, firstix = -1;
+        float theight = (float)(sqrt(3) / 2.0);
+        //float theight = 0.8660254037844386467;
+
+        for (row = 0; row < params->d1 + params->d2; row++) {
+            if (row < params->d2) {
+                other = +1;
+                rowlen = row + params->d1;
+            } else {
+                other = -1;
+                rowlen = 2*params->d2 + params->d1 - row;
+            }
+
+            /*
+             * There are `rowlen' down-pointing triangles.
+             */
+            for (i = 0; i < rowlen; i++) {
+                struct grid_square sq;
+                int ix;
+                float x, y;
+
+                ix = (2 * i - (rowlen-1));
+                x = ix * 0.5F;
+                y = theight * row;
+                sq.x = x;
+                sq.y = y + theight / 3;
+                sq.points[0] = x - 0.5F;
+                sq.points[1] = y;
+                sq.points[2] = x;
+                sq.points[3] = y + theight;
+                sq.points[4] = x + 0.5F;
+                sq.points[5] = y;
+                sq.npoints = 3;
+
+                sq.directions[LEFT]  = 0x03;   /* 0,1 */
+                sq.directions[RIGHT] = 0x06;   /* 1,2 */
+                sq.directions[UP]    = 0x05;   /* 0,2 */
+                sq.directions[DOWN]  = 0;      /* invalid move */
+
+                /*
+                 * Down-pointing triangle: both the up diagonals go
+                 * up, and the down ones go left and right.
+                 */
+                sq.directions[UP_LEFT] = sq.directions[UP_RIGHT] =
+                    sq.directions[UP];
+                sq.directions[DOWN_LEFT] = sq.directions[LEFT];
+                sq.directions[DOWN_RIGHT] = sq.directions[RIGHT];
+
+                sq.flip = TRUE;
+
+                if (firstix < 0)
+                    firstix = ix & 3;
+                ix -= firstix;
+                sq.tetra_class = ((row+(ix&1)) & 2) ^ (ix & 3);
+
+                callback(ctx, &sq);
+            }
+
+            /*
+             * There are `rowlen+other' up-pointing triangles.
+             */
+            for (i = 0; i < rowlen+other; i++) {
+                struct grid_square sq;
+                int ix;
+                float x, y;
+
+                ix = (2 * i - (rowlen+other-1));
+                x = ix * 0.5F;
+                y = theight * row;
+                sq.x = x;
+                sq.y = y + 2*theight / 3;
+                sq.points[0] = x + 0.5F;
+                sq.points[1] = y + theight;
+                sq.points[2] = x;
+                sq.points[3] = y;
+                sq.points[4] = x - 0.5F;
+                sq.points[5] = y + theight;
+                sq.npoints = 3;
+
+                sq.directions[LEFT]  = 0x06;   /* 1,2 */
+                sq.directions[RIGHT] = 0x03;   /* 0,1 */
+                sq.directions[DOWN]  = 0x05;   /* 0,2 */
+                sq.directions[UP]    = 0;      /* invalid move */
+
+                /*
+                 * Up-pointing triangle: both the down diagonals go
+                 * down, and the up ones go left and right.
+                 */
+                sq.directions[DOWN_LEFT] = sq.directions[DOWN_RIGHT] =
+                    sq.directions[DOWN];
+                sq.directions[UP_LEFT] = sq.directions[LEFT];
+                sq.directions[UP_RIGHT] = sq.directions[RIGHT];
+
+                sq.flip = FALSE;
+
+                if (firstix < 0)
+                    firstix = (ix - 1) & 3;
+                ix -= firstix;
+                sq.tetra_class = ((row+(ix&1)) & 2) ^ (ix & 3);
+
+                callback(ctx, &sq);
+            }
+        }
+    }
+}
+
+static int grid_area(int d1, int d2, int order)
+{
+    /*
+     * An NxM grid of squares has NM squares in it.
+     * 
+     * A grid of triangles with dimensions A and B has a total of
+     * A^2 + B^2 + 4AB triangles in it. (You can divide it up into
+     * a side-A triangle containing A^2 subtriangles, a side-B
+     * triangle containing B^2, and two congruent parallelograms,
+     * each with side lengths A and B, each therefore containing AB
+     * two-triangle rhombuses.)
+     */
+    if (order == 4)
+        return d1 * d2;
+    else
+        return d1*d1 + d2*d2 + 4*d1*d2;
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret = snewn(4, config_item);
+    char buf[80];
+
+    ret[0].name = "Type of solid";
+    ret[0].type = C_CHOICES;
+    ret[0].sval = ":Tetrahedron:Cube:Octahedron:Icosahedron";
+    ret[0].ival = params->solid;
+
+    ret[1].name = "Width / top";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->d1);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Height / bottom";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->d2);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->solid = cfg[0].ival;
+    ret->d1 = atoi(cfg[1].sval);
+    ret->d2 = atoi(cfg[2].sval);
+
+    return ret;
+}
+
+static void count_grid_square_callback(void *ctx, struct grid_square *sq)
+{
+    int *classes = (int *)ctx;
+    int thisclass;
+
+    if (classes[4] == 4)
+        thisclass = sq->tetra_class;
+    else if (classes[4] == 2)
+        thisclass = sq->flip;
+    else
+        thisclass = 0;
+
+    classes[thisclass]++;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    int classes[5];
+    int i;
+
+    if (params->solid < 0 || params->solid >= lenof(solids))
+        return "Unrecognised solid type";
+
+    if (solids[params->solid]->order == 4) {
+        if (params->d1 <= 0 || params->d2 <= 0)
+            return "Both grid dimensions must be greater than zero";
+    } else {
+        if (params->d1 <= 0 && params->d2 <= 0)
+            return "At least one grid dimension must be greater than zero";
+    }
+
+    for (i = 0; i < 4; i++)
+        classes[i] = 0;
+    if (params->solid == TETRAHEDRON)
+        classes[4] = 4;
+    else if (params->solid == OCTAHEDRON)
+        classes[4] = 2;
+    else
+        classes[4] = 1;
+    enum_grid_squares(params, count_grid_square_callback, classes);
+
+    for (i = 0; i < classes[4]; i++)
+        if (classes[i] < solids[params->solid]->nfaces / classes[4])
+            return "Not enough grid space to place all blue faces";
+
+    if (grid_area(params->d1, params->d2, solids[params->solid]->order) <
+        solids[params->solid]->nfaces + 1)
+        return "Not enough space to place the solid on an empty square";
+
+    return NULL;
+}
+
+struct grid_data {
+    int *gridptrs[4];
+    int nsquares[4];
+    int nclasses;
+    int squareindex;
+};
+
+static void classify_grid_square_callback(void *ctx, struct grid_square *sq)
+{
+    struct grid_data *data = (struct grid_data *)ctx;
+    int thisclass;
+
+    if (data->nclasses == 4)
+        thisclass = sq->tetra_class;
+    else if (data->nclasses == 2)
+        thisclass = sq->flip;
+    else
+        thisclass = 0;
+
+    data->gridptrs[thisclass][data->nsquares[thisclass]++] =
+        data->squareindex++;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    struct grid_data data;
+    int i, j, k, m, area, facesperclass;
+    int *flags;
+    char *desc, *p;
+
+    /*
+     * Enumerate the grid squares, dividing them into equivalence
+     * classes as appropriate. (For the tetrahedron, there is one
+     * equivalence class for each face; for the octahedron there
+     * are two classes; for the other two solids there's only one.)
+     */
+
+    area = grid_area(params->d1, params->d2, solids[params->solid]->order);
+    if (params->solid == TETRAHEDRON)
+        data.nclasses = 4;
+    else if (params->solid == OCTAHEDRON)
+        data.nclasses = 2;
+    else
+        data.nclasses = 1;
+    data.gridptrs[0] = snewn(data.nclasses * area, int);
+    for (i = 0; i < data.nclasses; i++) {
+        data.gridptrs[i] = data.gridptrs[0] + i * area;
+        data.nsquares[i] = 0;
+    }
+    data.squareindex = 0;
+    enum_grid_squares(params, classify_grid_square_callback, &data);
+
+    facesperclass = solids[params->solid]->nfaces / data.nclasses;
+
+    for (i = 0; i < data.nclasses; i++)
+        assert(data.nsquares[i] >= facesperclass);
+    assert(data.squareindex == area);
+
+    /*
+     * So now we know how many faces to allocate in each class. Get
+     * on with it.
+     */
+    flags = snewn(area, int);
+    for (i = 0; i < area; i++)
+        flags[i] = FALSE;
+
+    for (i = 0; i < data.nclasses; i++) {
+        for (j = 0; j < facesperclass; j++) {
+            int n = random_upto(rs, data.nsquares[i]);
+
+            assert(!flags[data.gridptrs[i][n]]);
+            flags[data.gridptrs[i][n]] = TRUE;
+
+            /*
+             * Move everything else up the array. I ought to use a
+             * better data structure for this, but for such small
+             * numbers it hardly seems worth the effort.
+             */
+            while (n < data.nsquares[i]-1) {
+                data.gridptrs[i][n] = data.gridptrs[i][n+1];
+                n++;
+            }
+            data.nsquares[i]--;
+        }
+    }
+
+    /*
+     * Now we know precisely which squares are blue. Encode this
+     * information in hex. While we're looping over this, collect
+     * the non-blue squares into a list in the now-unused gridptrs
+     * array.
+     */
+    desc = snewn(area / 4 + 40, char);
+    p = desc;
+    j = 0;
+    k = 8;
+    m = 0;
+    for (i = 0; i < area; i++) {
+        if (flags[i]) {
+            j |= k;
+        } else {
+            data.gridptrs[0][m++] = i;
+        }
+        k >>= 1;
+        if (!k) {
+            *p++ = "0123456789ABCDEF"[j];
+            k = 8;
+            j = 0;
+        }
+    }
+    if (k != 8)
+        *p++ = "0123456789ABCDEF"[j];
+
+    /*
+     * Choose a non-blue square for the polyhedron.
+     */
+    sprintf(p, ",%d", data.gridptrs[0][random_upto(rs, m)]);
+
+    sfree(data.gridptrs[0]);
+    sfree(flags);
+
+    return desc;
+}
+
+static void add_grid_square_callback(void *ctx, struct grid_square *sq)
+{
+    game_grid *grid = (game_grid *)ctx;
+
+    grid->squares[grid->nsquares++] = *sq;   /* structure copy */
+}
+
+static int lowest_face(const struct solid *solid)
+{
+    int i, j, best;
+    float zmin;
+
+    best = 0;
+    zmin = 0.0;
+    for (i = 0; i < solid->nfaces; i++) {
+        float z = 0;
+
+        for (j = 0; j < solid->order; j++) {
+            int f = solid->faces[i*solid->order + j];
+            z += solid->vertices[f*3+2];
+        }
+
+        if (i == 0 || zmin > z) {
+            zmin = z;
+            best = i;
+        }
+    }
+
+    return best;
+}
+
+static int align_poly(const struct solid *solid, struct grid_square *sq,
+                      int *pkey)
+{
+    float zmin;
+    int i, j;
+    int flip = (sq->flip ? -1 : +1);
+
+    /*
+     * First, find the lowest z-coordinate present in the solid.
+     */
+    zmin = 0.0;
+    for (i = 0; i < solid->nvertices; i++)
+        if (zmin > solid->vertices[i*3+2])
+            zmin = solid->vertices[i*3+2];
+
+    /*
+     * Now go round the grid square. For each point in the grid
+     * square, we're looking for a point of the polyhedron with the
+     * same x- and y-coordinates (relative to the square's centre),
+     * and z-coordinate equal to zmin (near enough).
+     */
+    for (j = 0; j < sq->npoints; j++) {
+        int matches, index;
+
+        matches = 0;
+        index = -1;
+
+        for (i = 0; i < solid->nvertices; i++) {
+            float dist = 0;
+
+            dist += SQ(solid->vertices[i*3+0] * flip - sq->points[j*2+0] + sq->x);
+            dist += SQ(solid->vertices[i*3+1] * flip - sq->points[j*2+1] + sq->y);
+            dist += SQ(solid->vertices[i*3+2] - zmin);
+
+            if (dist < 0.1) {
+                matches++;
+                index = i;
+            }
+        }
+
+        if (matches != 1 || index < 0)
+            return FALSE;
+        pkey[j] = index;
+    }
+
+    return TRUE;
+}
+
+static void flip_poly(struct solid *solid, int flip)
+{
+    int i;
+
+    if (flip) {
+        for (i = 0; i < solid->nvertices; i++) {
+            solid->vertices[i*3+0] *= -1;
+            solid->vertices[i*3+1] *= -1;
+        }
+        for (i = 0; i < solid->nfaces; i++) {
+            solid->normals[i*3+0] *= -1;
+            solid->normals[i*3+1] *= -1;
+        }
+    }
+}
+
+static struct solid *transform_poly(const struct solid *solid, int flip,
+                                    int key0, int key1, float angle)
+{
+    struct solid *ret = snew(struct solid);
+    float vx, vy, ax, ay;
+    float vmatrix[9], amatrix[9], vmatrix2[9];
+    int i;
+
+    *ret = *solid;                     /* structure copy */
+
+    flip_poly(ret, flip);
+
+    /*
+     * Now rotate the polyhedron through the given angle. We must
+     * rotate about the Z-axis to bring the two vertices key0 and
+     * key1 into horizontal alignment, then rotate about the
+     * X-axis, then rotate back again.
+     */
+    vx = ret->vertices[key1*3+0] - ret->vertices[key0*3+0];
+    vy = ret->vertices[key1*3+1] - ret->vertices[key0*3+1];
+    assert(APPROXEQ(vx*vx + vy*vy, 1.0));
+
+    vmatrix[0] =  vx; vmatrix[3] = vy; vmatrix[6] = 0;
+    vmatrix[1] = -vy; vmatrix[4] = vx; vmatrix[7] = 0;
+    vmatrix[2] =   0; vmatrix[5] =  0; vmatrix[8] = 1;
+
+    ax = (float)cos(angle);
+    ay = (float)sin(angle);
+
+    amatrix[0] = 1; amatrix[3] =   0; amatrix[6] =  0;
+    amatrix[1] = 0; amatrix[4] =  ax; amatrix[7] = ay;
+    amatrix[2] = 0; amatrix[5] = -ay; amatrix[8] = ax;
+
+    memcpy(vmatrix2, vmatrix, sizeof(vmatrix));
+    vmatrix2[1] = vy;
+    vmatrix2[3] = -vy;
+
+    for (i = 0; i < ret->nvertices; i++) {
+        MATMUL(ret->vertices + 3*i, vmatrix, ret->vertices + 3*i);
+        MATMUL(ret->vertices + 3*i, amatrix, ret->vertices + 3*i);
+        MATMUL(ret->vertices + 3*i, vmatrix2, ret->vertices + 3*i);
+    }
+    for (i = 0; i < ret->nfaces; i++) {
+        MATMUL(ret->normals + 3*i, vmatrix, ret->normals + 3*i);
+        MATMUL(ret->normals + 3*i, amatrix, ret->normals + 3*i);
+        MATMUL(ret->normals + 3*i, vmatrix2, ret->normals + 3*i);
+    }
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int area = grid_area(params->d1, params->d2, solids[params->solid]->order);
+    int i, j;
+
+    i = (area + 3) / 4;
+    for (j = 0; j < i; j++) {
+        int c = desc[j];
+        if (c >= '0' && c <= '9') continue;
+        if (c >= 'A' && c <= 'F') continue;
+        if (c >= 'a' && c <= 'f') continue;
+        return "Not enough hex digits at start of string";
+        /* NB if desc[j]=='\0' that will also be caught here, so we're safe */
+    }
+
+    if (desc[i] != ',')
+        return "Expected ',' after hex digits";
+
+    i++;
+    do {
+        if (desc[i] < '0' || desc[i] > '9')
+            return "Expected decimal integer after ','";
+        i++;
+    } while (desc[i]);
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_grid *grid = snew(game_grid);
+    game_state *state = snew(game_state);
+    int area;
+
+    state->params = *params;           /* structure copy */
+    state->solid = solids[params->solid];
+
+    area = grid_area(params->d1, params->d2, state->solid->order);
+    grid->squares = snewn(area, struct grid_square);
+    grid->nsquares = 0;
+    enum_grid_squares(params, add_grid_square_callback, grid);
+    assert(grid->nsquares == area);
+    state->grid = grid;
+    grid->refcount = 1;
+
+    state->facecolours = snewn(state->solid->nfaces, int);
+    memset(state->facecolours, 0, state->solid->nfaces * sizeof(int));
+
+    state->bluemask = snewn((state->grid->nsquares + 31) / 32, unsigned long);
+    memset(state->bluemask, 0, (state->grid->nsquares + 31) / 32 *
+           sizeof(unsigned long));
+
+    /*
+     * Set up the blue squares and polyhedron position according to
+     * the game description.
+     */
+    {
+        const char *p = desc;
+        int i, j, v;
+
+        j = 8;
+        v = 0;
+        for (i = 0; i < state->grid->nsquares; i++) {
+            if (j == 8) {
+                v = *p++;
+                if (v >= '0' && v <= '9')
+                    v -= '0';
+                else if (v >= 'A' && v <= 'F')
+                    v -= 'A' - 10;
+                else if (v >= 'a' && v <= 'f')
+                    v -= 'a' - 10;
+                else
+                    break;
+            }
+            if (v & j)
+                SET_SQUARE(state, i, TRUE);
+            j >>= 1;
+            if (j == 0)
+                j = 8;
+        }
+
+        if (*p == ',')
+            p++;
+
+        state->current = atoi(p);
+        if (state->current < 0 || state->current >= state->grid->nsquares)
+            state->current = 0;        /* got to do _something_ */
+    }
+
+    /*
+     * Align the polyhedron with its grid square and determine
+     * initial key points.
+     */
+    {
+        int pkey[4];
+        int ret;
+
+        ret = align_poly(state->solid, &state->grid->squares[state->current], pkey);
+        assert(ret);
+
+        state->dpkey[0] = state->spkey[0] = pkey[0];
+        state->dpkey[1] = state->spkey[0] = pkey[1];
+        state->dgkey[0] = state->sgkey[0] = 0;
+        state->dgkey[1] = state->sgkey[0] = 1;
+    }
+
+    state->previous = state->current;
+    state->angle = 0.0;
+    state->completed = 0;
+    state->movecount = 0;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->params = state->params;           /* structure copy */
+    ret->solid = state->solid;
+    ret->facecolours = snewn(ret->solid->nfaces, int);
+    memcpy(ret->facecolours, state->facecolours,
+           ret->solid->nfaces * sizeof(int));
+    ret->current = state->current;
+    ret->grid = state->grid;
+    ret->grid->refcount++;
+    ret->bluemask = snewn((ret->grid->nsquares + 31) / 32, unsigned long);
+    memcpy(ret->bluemask, state->bluemask, (ret->grid->nsquares + 31) / 32 *
+           sizeof(unsigned long));
+    ret->dpkey[0] = state->dpkey[0];
+    ret->dpkey[1] = state->dpkey[1];
+    ret->dgkey[0] = state->dgkey[0];
+    ret->dgkey[1] = state->dgkey[1];
+    ret->spkey[0] = state->spkey[0];
+    ret->spkey[1] = state->spkey[1];
+    ret->sgkey[0] = state->sgkey[0];
+    ret->sgkey[1] = state->sgkey[1];
+    ret->previous = state->previous;
+    ret->angle = state->angle;
+    ret->completed = state->completed;
+    ret->movecount = state->movecount;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (--state->grid->refcount <= 0) {
+        sfree(state->grid->squares);
+        sfree(state->grid);
+    }
+    sfree(state->bluemask);
+    sfree(state->facecolours);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return NULL;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+static game_ui *new_ui(const game_state *state)
+{
+    return NULL;
+}
+
+static void free_ui(game_ui *ui)
+{
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    float gridscale;
+    int ox, oy;                        /* pixel position of float origin */
+};
+
+/*
+ * Code shared between interpret_move() and execute_move().
+ */
+static int find_move_dest(const game_state *from, int direction,
+                          int *skey, int *dkey)
+{
+    int mask, dest, i, j;
+    float points[4];
+
+    /*
+     * Find the two points in the current grid square which
+     * correspond to this move.
+     */
+    mask = from->grid->squares[from->current].directions[direction];
+    if (mask == 0)
+        return -1;
+    for (i = j = 0; i < from->grid->squares[from->current].npoints; i++)
+        if (mask & (1 << i)) {
+            points[j*2] = from->grid->squares[from->current].points[i*2];
+            points[j*2+1] = from->grid->squares[from->current].points[i*2+1];
+            skey[j] = i;
+            j++;
+        }
+    assert(j == 2);
+
+    /*
+     * Now find the other grid square which shares those points.
+     * This is our move destination.
+     */
+    dest = -1;
+    for (i = 0; i < from->grid->nsquares; i++)
+        if (i != from->current) {
+            int match = 0;
+            float dist;
+
+            for (j = 0; j < from->grid->squares[i].npoints; j++) {
+                dist = (SQ(from->grid->squares[i].points[j*2] - points[0]) +
+                        SQ(from->grid->squares[i].points[j*2+1] - points[1]));
+                if (dist < 0.1)
+                    dkey[match++] = j;
+                dist = (SQ(from->grid->squares[i].points[j*2] - points[2]) +
+                        SQ(from->grid->squares[i].points[j*2+1] - points[3]));
+                if (dist < 0.1)
+                    dkey[match++] = j;
+            }
+
+            if (match == 2) {
+                dest = i;
+                break;
+            }
+        }
+
+    return dest;
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int direction, mask, i;
+    int skey[2], dkey[2];
+
+    button = button & (~MOD_MASK | MOD_NUM_KEYPAD);
+
+    /*
+     * Moves can be made with the cursor keys or numeric keypad, or
+     * alternatively you can left-click and the polyhedron will
+     * move in the general direction of the mouse pointer.
+     */
+    if (button == CURSOR_UP || button == (MOD_NUM_KEYPAD | '8'))
+        direction = UP;
+    else if (button == CURSOR_DOWN || button == (MOD_NUM_KEYPAD | '2'))
+        direction = DOWN;
+    else if (button == CURSOR_LEFT || button == (MOD_NUM_KEYPAD | '4'))
+        direction = LEFT;
+    else if (button == CURSOR_RIGHT || button == (MOD_NUM_KEYPAD | '6'))
+        direction = RIGHT;
+    else if (button == (MOD_NUM_KEYPAD | '7'))
+        direction = UP_LEFT;
+    else if (button == (MOD_NUM_KEYPAD | '1'))
+        direction = DOWN_LEFT;
+    else if (button == (MOD_NUM_KEYPAD | '9'))
+        direction = UP_RIGHT;
+    else if (button == (MOD_NUM_KEYPAD | '3'))
+        direction = DOWN_RIGHT;
+    else if (button == LEFT_BUTTON) {
+        /*
+         * Find the bearing of the click point from the current
+         * square's centre.
+         */
+        int cx, cy;
+        double angle;
+
+        cx = (int)(state->grid->squares[state->current].x * GRID_SCALE) + ds->ox;
+        cy = (int)(state->grid->squares[state->current].y * GRID_SCALE) + ds->oy;
+
+        if (x == cx && y == cy)
+            return NULL;               /* clicked in exact centre!  */
+        angle = atan2(y - cy, x - cx);
+
+        /*
+         * There are three possibilities.
+         * 
+         *  - This square is a square, so we choose between UP,
+         *    DOWN, LEFT and RIGHT by dividing the available angle
+         *    at the 45-degree points.
+         * 
+         *  - This square is an up-pointing triangle, so we choose
+         *    between DOWN, LEFT and RIGHT by dividing into
+         *    120-degree arcs.
+         * 
+         *  - This square is a down-pointing triangle, so we choose
+         *    between UP, LEFT and RIGHT in the inverse manner.
+         * 
+         * Don't forget that since our y-coordinates increase
+         * downwards, `angle' is measured _clockwise_ from the
+         * x-axis, not anticlockwise as most mathematicians would
+         * instinctively assume.
+         */
+        if (state->grid->squares[state->current].npoints == 4) {
+            /* Square. */
+            if (fabs(angle) > 3*PI/4)
+                direction = LEFT;
+            else if (fabs(angle) < PI/4)
+                direction = RIGHT;
+            else if (angle > 0)
+                direction = DOWN;
+            else
+                direction = UP;
+        } else if (state->grid->squares[state->current].directions[UP] == 0) {
+            /* Up-pointing triangle. */
+            if (angle < -PI/2 || angle > 5*PI/6)
+                direction = LEFT;
+            else if (angle > PI/6)
+                direction = DOWN;
+            else
+                direction = RIGHT;
+        } else {
+            /* Down-pointing triangle. */
+            assert(state->grid->squares[state->current].directions[DOWN] == 0);
+            if (angle > PI/2 || angle < -5*PI/6)
+                direction = LEFT;
+            else if (angle < -PI/6)
+                direction = UP;
+            else
+                direction = RIGHT;
+        }
+    } else
+        return NULL;
+
+    mask = state->grid->squares[state->current].directions[direction];
+    if (mask == 0)
+        return NULL;
+
+    /*
+     * Translate diagonal directions into orthogonal ones.
+     */
+    if (direction > DOWN) {
+        for (i = LEFT; i <= DOWN; i++)
+            if (state->grid->squares[state->current].directions[i] == mask) {
+                direction = i;
+                break;
+            }
+        assert(direction <= DOWN);
+    }
+
+    if (find_move_dest(state, direction, skey, dkey) < 0)
+        return NULL;
+
+    if (direction == LEFT)  return dupstr("L");
+    if (direction == RIGHT) return dupstr("R");
+    if (direction == UP)    return dupstr("U");
+    if (direction == DOWN)  return dupstr("D");
+
+    return NULL;                       /* should never happen */
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    game_state *ret;
+    float angle;
+    struct solid *poly;
+    int pkey[2];
+    int skey[2], dkey[2];
+    int i, j, dest;
+    int direction;
+
+    switch (*move) {
+      case 'L': direction = LEFT; break;
+      case 'R': direction = RIGHT; break;
+      case 'U': direction = UP; break;
+      case 'D': direction = DOWN; break;
+      default: return NULL;
+    }
+
+    dest = find_move_dest(from, direction, skey, dkey);
+    if (dest < 0)
+        return NULL;
+
+    ret = dup_game(from);
+    ret->current = dest;
+
+    /*
+     * So we know what grid square we're aiming for, and we also
+     * know the two key points (as indices in both the source and
+     * destination grid squares) which are invariant between source
+     * and destination.
+     * 
+     * Next we must roll the polyhedron on to that square. So we
+     * find the indices of the key points within the polyhedron's
+     * vertex array, then use those in a call to transform_poly,
+     * and align the result on the new grid square.
+     */
+    {
+        int all_pkey[4];
+        align_poly(from->solid, &from->grid->squares[from->current], all_pkey);
+        pkey[0] = all_pkey[skey[0]];
+        pkey[1] = all_pkey[skey[1]];
+        /*
+         * Now pkey[0] corresponds to skey[0] and dkey[0], and
+         * likewise [1].
+         */
+    }
+
+    /*
+     * Now find the angle through which to rotate the polyhedron.
+     * Do this by finding the two faces that share the two vertices
+     * we've found, and taking the dot product of their normals.
+     */
+    {
+        int f[2], nf = 0;
+        float dp;
+
+        for (i = 0; i < from->solid->nfaces; i++) {
+            int match = 0;
+            for (j = 0; j < from->solid->order; j++)
+                if (from->solid->faces[i*from->solid->order + j] == pkey[0] ||
+                    from->solid->faces[i*from->solid->order + j] == pkey[1])
+                    match++;
+            if (match == 2) {
+                assert(nf < 2);
+                f[nf++] = i;
+            }
+        }
+
+        assert(nf == 2);
+
+        dp = 0;
+        for (i = 0; i < 3; i++)
+            dp += (from->solid->normals[f[0]*3+i] *
+                   from->solid->normals[f[1]*3+i]);
+        angle = (float)acos(dp);
+    }
+
+    /*
+     * Now transform the polyhedron. We aren't entirely sure
+     * whether we need to rotate through angle or -angle, and the
+     * simplest way round this is to try both and see which one
+     * aligns successfully!
+     * 
+     * Unfortunately, _both_ will align successfully if this is a
+     * cube, which won't tell us anything much. So for that
+     * particular case, I resort to gross hackery: I simply negate
+     * the angle before trying the alignment, depending on the
+     * direction. Which directions work which way is determined by
+     * pure trial and error. I said it was gross :-/
+     */
+    {
+        int all_pkey[4];
+        int success;
+
+        if (from->solid->order == 4 && direction == UP)
+            angle = -angle;            /* HACK */
+
+        poly = transform_poly(from->solid,
+                              from->grid->squares[from->current].flip,
+                              pkey[0], pkey[1], angle);
+        flip_poly(poly, from->grid->squares[ret->current].flip);
+        success = align_poly(poly, &from->grid->squares[ret->current], all_pkey);
+
+        if (!success) {
+            sfree(poly);
+            angle = -angle;
+            poly = transform_poly(from->solid,
+                                  from->grid->squares[from->current].flip,
+                                  pkey[0], pkey[1], angle);
+            flip_poly(poly, from->grid->squares[ret->current].flip);
+            success = align_poly(poly, &from->grid->squares[ret->current], all_pkey);
+        }
+
+        assert(success);
+    }
+
+    /*
+     * Now we have our rotated polyhedron, which we expect to be
+     * exactly congruent to the one we started with - but with the
+     * faces permuted. So we map that congruence and thereby figure
+     * out how to permute the faces as a result of the polyhedron
+     * having rolled.
+     */
+    {
+        int *newcolours = snewn(from->solid->nfaces, int);
+
+        for (i = 0; i < from->solid->nfaces; i++)
+            newcolours[i] = -1;
+
+        for (i = 0; i < from->solid->nfaces; i++) {
+            int nmatch = 0;
+
+            /*
+             * Now go through the transformed polyhedron's faces
+             * and figure out which one's normal is approximately
+             * equal to this one.
+             */
+            for (j = 0; j < poly->nfaces; j++) {
+                float dist;
+                int k;
+
+                dist = 0;
+
+                for (k = 0; k < 3; k++)
+                    dist += SQ(poly->normals[j*3+k] -
+                               from->solid->normals[i*3+k]);
+
+                if (APPROXEQ(dist, 0)) {
+                    nmatch++;
+                    newcolours[i] = ret->facecolours[j];
+                }
+            }
+
+            assert(nmatch == 1);
+        }
+
+        for (i = 0; i < from->solid->nfaces; i++)
+            assert(newcolours[i] != -1);
+
+        sfree(ret->facecolours);
+        ret->facecolours = newcolours;
+    }
+
+    ret->movecount++;
+
+    /*
+     * And finally, swap the colour between the bottom face of the
+     * polyhedron and the face we've just landed on.
+     * 
+     * We don't do this if the game is already complete, since we
+     * allow the user to roll the fully blue polyhedron around the
+     * grid as a feeble reward.
+     */
+    if (!ret->completed) {
+        i = lowest_face(from->solid);
+        j = ret->facecolours[i];
+        ret->facecolours[i] = GET_SQUARE(ret, ret->current);
+        SET_SQUARE(ret, ret->current, j);
+
+        /*
+         * Detect game completion.
+         */
+        j = 0;
+        for (i = 0; i < ret->solid->nfaces; i++)
+            if (ret->facecolours[i])
+                j++;
+        if (j == ret->solid->nfaces)
+            ret->completed = ret->movecount;
+    }
+
+    sfree(poly);
+
+    /*
+     * Align the normal polyhedron with its grid square, to get key
+     * points for non-animated display.
+     */
+    {
+        int pkey[4];
+        int success;
+
+        success = align_poly(ret->solid, &ret->grid->squares[ret->current], pkey);
+        assert(success);
+
+        ret->dpkey[0] = pkey[0];
+        ret->dpkey[1] = pkey[1];
+        ret->dgkey[0] = 0;
+        ret->dgkey[1] = 1;
+    }
+
+
+    ret->spkey[0] = pkey[0];
+    ret->spkey[1] = pkey[1];
+    ret->sgkey[0] = skey[0];
+    ret->sgkey[1] = skey[1];
+    ret->previous = from->current;
+    ret->angle = angle;
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+struct bbox {
+    float l, r, u, d;
+};
+
+static void find_bbox_callback(void *ctx, struct grid_square *sq)
+{
+    struct bbox *bb = (struct bbox *)ctx;
+    int i;
+
+    for (i = 0; i < sq->npoints; i++) {
+        if (bb->l > sq->points[i*2]) bb->l = sq->points[i*2];
+        if (bb->r < sq->points[i*2]) bb->r = sq->points[i*2];
+        if (bb->u > sq->points[i*2+1]) bb->u = sq->points[i*2+1];
+        if (bb->d < sq->points[i*2+1]) bb->d = sq->points[i*2+1];
+    }
+}
+
+static struct bbox find_bbox(const game_params *params)
+{
+    struct bbox bb;
+
+    /*
+     * These should be hugely more than the real bounding box will
+     * be.
+     */
+    bb.l = 2.0F * (params->d1 + params->d2);
+    bb.r = -2.0F * (params->d1 + params->d2);
+    bb.u = 2.0F * (params->d1 + params->d2);
+    bb.d = -2.0F * (params->d1 + params->d2);
+    enum_grid_squares(params, find_bbox_callback, &bb);
+
+    return bb;
+}
+
+#define XSIZE(gs, bb, solid) \
+    ((int)(((bb).r - (bb).l + 2*(solid)->border) * gs))
+#define YSIZE(gs, bb, solid) \
+    ((int)(((bb).d - (bb).u + 2*(solid)->border) * gs))
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    struct bbox bb = find_bbox(params);
+
+    *x = XSIZE(tilesize, bb, solids[params->solid]);
+    *y = YSIZE(tilesize, bb, solids[params->solid]);
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    struct bbox bb = find_bbox(params);
+
+    ds->gridscale = (float)tilesize;
+    ds->ox = (int)(-(bb.l - solids[params->solid]->border) * ds->gridscale);
+    ds->oy = (int)(-(bb.u - solids[params->solid]->border) * ds->gridscale);
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_BORDER * 3 + 0] = 0.0;
+    ret[COL_BORDER * 3 + 1] = 0.0;
+    ret[COL_BORDER * 3 + 2] = 0.0;
+
+    ret[COL_BLUE * 3 + 0] = 0.0;
+    ret[COL_BLUE * 3 + 1] = 0.0;
+    ret[COL_BLUE * 3 + 2] = 1.0;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->ox = ds->oy = 0;
+    ds->gridscale = 0.0F; /* not decided yet */
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int i, j;
+    struct bbox bb = find_bbox(&state->params);
+    struct solid *poly;
+    const int *pkey, *gkey;
+    float t[3];
+    float angle;
+    int square;
+
+    draw_rect(dr, 0, 0, XSIZE(GRID_SCALE, bb, state->solid),
+              YSIZE(GRID_SCALE, bb, state->solid), COL_BACKGROUND);
+
+    if (dir < 0) {
+        const game_state *t;
+
+        /*
+         * This is an Undo. So reverse the order of the states, and
+         * run the roll timer backwards.
+         */
+        assert(oldstate);
+
+        t = oldstate;
+        oldstate = state;
+        state = t;
+
+        animtime = ROLLTIME - animtime;
+    }
+
+    if (!oldstate) {
+        oldstate = state;
+        angle = 0.0;
+        square = state->current;
+        pkey = state->dpkey;
+        gkey = state->dgkey;
+    } else {
+        angle = state->angle * animtime / ROLLTIME;
+        square = state->previous;
+        pkey = state->spkey;
+        gkey = state->sgkey;
+    }
+    state = oldstate;
+
+    for (i = 0; i < state->grid->nsquares; i++) {
+        int coords[8];
+
+        for (j = 0; j < state->grid->squares[i].npoints; j++) {
+            coords[2*j] = ((int)(state->grid->squares[i].points[2*j] * GRID_SCALE)
+                           + ds->ox);
+            coords[2*j+1] = ((int)(state->grid->squares[i].points[2*j+1]*GRID_SCALE)
+                             + ds->oy);
+        }
+
+        draw_polygon(dr, coords, state->grid->squares[i].npoints,
+                     GET_SQUARE(state, i) ? COL_BLUE : COL_BACKGROUND,
+                     COL_BORDER);
+    }
+
+    /*
+     * Now compute and draw the polyhedron.
+     */
+    poly = transform_poly(state->solid, state->grid->squares[square].flip,
+                          pkey[0], pkey[1], angle);
+
+    /*
+     * Compute the translation required to align the two key points
+     * on the polyhedron with the same key points on the current
+     * face.
+     */
+    for (i = 0; i < 3; i++) {
+        float tc = 0.0;
+
+        for (j = 0; j < 2; j++) {
+            float grid_coord;
+
+            if (i < 2) {
+                grid_coord =
+                    state->grid->squares[square].points[gkey[j]*2+i];
+            } else {
+                grid_coord = 0.0;
+            }
+
+            tc += (grid_coord - poly->vertices[pkey[j]*3+i]);
+        }
+
+        t[i] = tc / 2;
+    }
+    for (i = 0; i < poly->nvertices; i++)
+        for (j = 0; j < 3; j++)
+            poly->vertices[i*3+j] += t[j];
+
+    /*
+     * Now actually draw each face.
+     */
+    for (i = 0; i < poly->nfaces; i++) {
+        float points[8];
+        int coords[8];
+
+        for (j = 0; j < poly->order; j++) {
+            int f = poly->faces[i*poly->order + j];
+            points[j*2] = (poly->vertices[f*3+0] -
+                           poly->vertices[f*3+2] * poly->shear);
+            points[j*2+1] = (poly->vertices[f*3+1] -
+                             poly->vertices[f*3+2] * poly->shear);
+        }
+
+        for (j = 0; j < poly->order; j++) {
+            coords[j*2] = (int)floor(points[j*2] * GRID_SCALE) + ds->ox;
+            coords[j*2+1] = (int)floor(points[j*2+1] * GRID_SCALE) + ds->oy;
+        }
+
+        /*
+         * Find out whether these points are in a clockwise or
+         * anticlockwise arrangement. If the latter, discard the
+         * face because it's facing away from the viewer.
+         *
+         * This would involve fiddly winding-number stuff for a
+         * general polygon, but for the simple parallelograms we'll
+         * be seeing here, all we have to do is check whether the
+         * corners turn right or left. So we'll take the vector
+         * from point 0 to point 1, turn it right 90 degrees,
+         * and check the sign of the dot product with that and the
+         * next vector (point 1 to point 2).
+         */
+        {
+            float v1x = points[2]-points[0];
+            float v1y = points[3]-points[1];
+            float v2x = points[4]-points[2];
+            float v2y = points[5]-points[3];
+            float dp = v1x * v2y - v1y * v2x;
+
+            if (dp <= 0)
+                continue;
+        }
+
+        draw_polygon(dr, coords, poly->order,
+                     state->facecolours[i] ? COL_BLUE : COL_BACKGROUND,
+                     COL_BORDER);
+    }
+    sfree(poly);
+
+    draw_update(dr, 0, 0, XSIZE(GRID_SCALE, bb, state->solid),
+                YSIZE(GRID_SCALE, bb, state->solid));
+
+    /*
+     * Update the status bar.
+     */
+    {
+        char statusbuf[256];
+
+        sprintf(statusbuf, "%sMoves: %d",
+                (state->completed ? "COMPLETED! " : ""),
+                (state->completed ? state->completed : state->movecount));
+
+        status_bar(dr, statusbuf);
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return ROLLTIME;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame cube
+#endif
+
+const struct game thegame = {
+    "Cube", "games.cube", "cube",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    FALSE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_GRID_SCALE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
diff --git a/apps/plugins/puzzles/desktop.pl b/apps/plugins/puzzles/desktop.pl
new file mode 100755
index 0000000000..204c0ce262
--- /dev/null
+++ b/apps/plugins/puzzles/desktop.pl
@@ -0,0 +1,52 @@
+#!/usr/bin/perl
+
+# Make .desktop files for the puzzles.
+#
+# At present, this script is intended for developer usage: if you're
+# working on the puzzles and want to play your bleeding-edge locally
+# modified and compiled versions, run this script and it will create a
+# collection of desktop files in ~/.local/share/applications where
+# XFCE can pick them up and add them to its main menu. (Be sure to run
+# 'xfdesktop --reload' after running this.)
+#
+# (If you don't use XFCE, patches to support other desktop
+# environments are welcome :-)
+
+use strict;
+use warnings;
+use Cwd 'abs_path';
+
+die "usage: desktop.pl [<outdir> [<bindir> <icondir>]]\n"
+    unless @ARGV == 0 or @ARGV == 1 or @ARGV == 3;
+
+my ($outdir, $bindir, $icondir) = @ARGV;
+$outdir = $ENV{'HOME'}."/.local/share/applications" unless defined $outdir;
+$bindir = "." unless defined $bindir;
+$icondir = "./icons" unless defined $icondir;
+$bindir = abs_path($bindir);
+$icondir = abs_path($icondir);
+
+open my $desc, "<", "gamedesc.txt"
+    or die "gamedesc.txt: open: $!\n";
+
+while (<$desc>) {
+    chomp;
+    my ($id, $win, $displayname, $description, $summary) = split /:/, $_;
+
+    open my $desktop, ">", "$outdir/$id.desktop"
+        or die "$outdir/$id.desktop: open: $!\n";
+
+    print $desktop "[Desktop Entry]\n";
+    print $desktop "Version=1.0\n";
+    print $desktop "Type=Application\n";
+    print $desktop "Name=$displayname\n";
+    print $desktop "Comment=$description\n";
+    print $desktop "Exec=$bindir/$id\n";
+    print $desktop "Icon=$icondir/$id-48d24.png\n";
+    print $desktop "StartupNotify=false\n";
+    print $desktop "Categories=Game;\n";
+    print $desktop "Terminal=false\n";
+
+    close $desktop
+        or die "$outdir/$id.desktop: close: $!\n";
+}
diff --git a/apps/plugins/puzzles/devel.but b/apps/plugins/puzzles/devel.but
new file mode 100644
index 0000000000..9befcadcb7
--- /dev/null
+++ b/apps/plugins/puzzles/devel.but
@@ -0,0 +1,4777 @@
+\cfg{text-indent}{0}
+\cfg{text-width}{72}
+\cfg{text-title-align}{left}
+\cfg{text-chapter-align}{left}
+\cfg{text-chapter-numeric}{true}
+\cfg{text-chapter-suffix}{. }
+\cfg{text-chapter-underline}{-}
+\cfg{text-section-align}{0}{left}
+\cfg{text-section-numeric}{0}{true}
+\cfg{text-section-suffix}{0}{. }
+\cfg{text-section-underline}{0}{-}
+\cfg{text-section-align}{1}{left}
+\cfg{text-section-numeric}{1}{true}
+\cfg{text-section-suffix}{1}{. }
+\cfg{text-section-underline}{1}{-}
+\cfg{text-versionid}{0}
+
+\cfg{html-contents-filename}{index.html}
+\cfg{html-template-filename}{%k.html}
+\cfg{html-index-filename}{docindex.html}
+\cfg{html-leaf-level}{1}
+\cfg{html-contents-depth-0}{1}
+\cfg{html-contents-depth-1}{3}
+\cfg{html-leaf-contains-contents}{true}
+
+\define{dash} \u2013{-}
+
+\title Developer documentation for Simon Tatham's puzzle collection
+
+This is a guide to the internal structure of Simon Tatham's Portable
+Puzzle Collection (henceforth referred to simply as \q{Puzzles}),
+for use by anyone attempting to implement a new puzzle or port to a
+new platform.
+
+This guide is believed correct as of r6190. Hopefully it will be
+updated along with the code in future, but if not, I've at least
+left this version number in here so you can figure out what's
+changed by tracking commit comments from there onwards.
+
+\C{intro} Introduction
+
+The Puzzles code base is divided into four parts: a set of
+interchangeable front ends, a set of interchangeable back ends, a
+universal \q{middle end} which acts as a buffer between the two, and
+a bunch of miscellaneous utility functions. In the following
+sections I give some general discussion of each of these parts.
+
+\H{intro-frontend} Front end
+
+The front end is the non-portable part of the code: it's the bit
+that you replace completely when you port to a different platform.
+So it's responsible for all system calls, all GUI interaction, and
+anything else platform-specific.
+
+The current front ends in the main code base are for Windows, GTK
+and MacOS X; I also know of a third-party front end for PalmOS.
+
+The front end contains \cw{main()} or the local platform's
+equivalent. Top-level control over the application's execution flow
+belongs to the front end (it isn't, for example, a set of functions
+called by a universal \cw{main()} somewhere else).
+
+The front end has complete freedom to design the GUI for any given
+port of Puzzles. There is no centralised mechanism for maintaining
+the menu layout, for example. This has a cost in consistency (when I
+\e{do} want the same menu layout on more than one platform, I have
+to edit two pieces of code in parallel every time I make a change),
+but the advantage is that local GUI conventions can be conformed to
+and local constraints adapted to. For example, MacOS X has strict
+human interface guidelines which specify a different menu layout
+from the one I've used on Windows and GTK; there's nothing stopping
+the OS X front end from providing a menu layout consistent with
+those guidelines.
+
+Although the front end is mostly caller rather than the callee in
+its interactions with other parts of the code, it is required to
+implement a small API for other modules to call, mostly of drawing
+functions for games to use when drawing their graphics. The drawing
+API is documented in \k{drawing}; the other miscellaneous front end
+API functions are documented in \k{frontend-api}.
+
+\H{intro-backend} Back end
+
+A \q{back end}, in this collection, is synonymous with a \q{puzzle}.
+Each back end implements a different game.
+
+At the top level, a back end is simply a data structure, containing
+a few constants (flag words, preferred pixel size) and a large
+number of function pointers. Back ends are almost invariably callee
+rather than caller, which means there's a limitation on what a back
+end can do on its own initiative.
+
+The persistent state in a back end is divided into a number of data
+structures, which are used for different purposes and therefore
+likely to be switched around, changed without notice, and otherwise
+updated by the rest of the code. It is important when designing a
+back end to put the right pieces of data into the right structures,
+or standard midend-provided features (such as Undo) may fail to
+work.
+
+The functions and variables provided in the back end data structure
+are documented in \k{backend}.
+
+\H{intro-midend} Middle end
+
+Puzzles has a single and universal \q{middle end}. This code is
+common to all platforms and all games; it sits in between the front
+end and the back end and provides standard functionality everywhere.
+
+People adding new back ends or new front ends should generally not
+need to edit the middle end. On rare occasions there might be a
+change that can be made to the middle end to permit a new game to do
+something not currently anticipated by the middle end's present
+design; however, this is terribly easy to get wrong and should
+probably not be undertaken without consulting the primary maintainer
+(me). Patch submissions containing unannounced mid-end changes will
+be treated on their merits like any other patch; this is just a
+friendly warning that mid-end changes will need quite a lot of
+merits to make them acceptable.
+
+Functionality provided by the mid-end includes:
+
+\b Maintaining a list of game state structures and moving back and
+forth along that list to provide Undo and Redo.
+
+\b Handling timers (for move animations, flashes on completion, and
+in some cases actually timing the game).
+
+\b Handling the container format of game IDs: receiving them,
+picking them apart into parameters, description and/or random seed,
+and so on. The game back end need only handle the individual parts
+of a game ID (encoded parameters and encoded game description);
+everything else is handled centrally by the mid-end.
+
+\b Handling standard keystrokes and menu commands, such as \q{New
+Game}, \q{Restart Game} and \q{Quit}.
+
+\b Pre-processing mouse events so that the game back ends can rely
+on them arriving in a sensible order (no missing button-release
+events, no sudden changes of which button is currently pressed,
+etc).
+
+\b Handling the dialog boxes which ask the user for a game ID.
+
+\b Handling serialisation of entire games (for loading and saving a
+half-finished game to a disk file, or for handling application
+shutdown and restart on platforms such as PalmOS where state is
+expected to be saved).
+
+Thus, there's a lot of work done once by the mid-end so that
+individual back ends don't have to worry about it. All the back end
+has to do is cooperate in ensuring the mid-end can do its work
+properly.
+
+The API of functions provided by the mid-end to be called by the
+front end is documented in \k{midend}.
+
+\H{intro-utils} Miscellaneous utilities
+
+In addition to these three major structural components, the Puzzles
+code also contains a variety of utility modules usable by all of the
+above components. There is a set of functions to provide
+platform-independent random number generation; functions to make
+memory allocation easier; functions which implement a balanced tree
+structure to be used as necessary in complex algorithms; and a few
+other miscellaneous functions. All of these are documented in
+\k{utils}.
+
+\H{intro-structure} Structure of this guide
+
+There are a number of function call interfaces within Puzzles, and
+this guide will discuss each one in a chapter of its own. After
+that, \k{writing} discusses how to design new games, with some
+general design thoughts and tips.
+
+\C{backend} Interface to the back end
+
+This chapter gives a detailed discussion of the interface that each
+back end must implement.
+
+At the top level, each back end source file exports a single global
+symbol, which is a \c{const struct game} containing a large number
+of function pointers and a small amount of constant data. This
+structure is called by different names depending on what kind of
+platform the puzzle set is being compiled on:
+
+\b On platforms such as Windows and GTK, which build a separate
+binary for each puzzle, the game structure in every back end has the
+same name, \cq{thegame}; the front end refers directly to this name,
+so that compiling the same front end module against a different back
+end module builds a different puzzle.
+
+\b On platforms such as MacOS X and PalmOS, which build all the
+puzzles into a single monolithic binary, the game structure in each
+back end must have a different name, and there's a helper module
+\c{list.c} (constructed automatically by the same Perl script that
+builds the \cw{Makefile}s) which contains a complete list of those
+game structures.
+
+On the latter type of platform, source files may assume that the
+preprocessor symbol \c{COMBINED} has been defined. Thus, the usual
+code to declare the game structure looks something like this:
+
+\c #ifdef COMBINED
+\c #define thegame net    /* or whatever this game is called */
+\e                 iii    iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
+\c #endif
+\c 
+\c const struct game thegame = {
+\c     /* lots of structure initialisation in here */
+\e     iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
+\c };
+
+Game back ends must also internally define a number of data
+structures, for storing their various persistent state. This chapter
+will first discuss the nature and use of those structures, and then
+go on to give details of every element of the game structure.
+
+\H{backend-structs} Data structures
+
+Each game is required to define four separate data structures. This
+section discusses each one and suggests what sorts of things need to
+be put in it.
+
+\S{backend-game-params} \c{game_params}
+
+The \c{game_params} structure contains anything which affects the
+automatic generation of new puzzles. So if puzzle generation is
+parametrised in any way, those parameters need to be stored in
+\c{game_params}.
+
+Most puzzles currently in this collection are played on a grid of
+squares, meaning that the most obvious parameter is the grid size.
+Many puzzles have additional parameters; for example, Mines allows
+you to control the number of mines in the grid independently of its
+size, Net can be wrapping or non-wrapping, Solo has difficulty
+levels and symmetry settings, and so on.
+
+A simple rule for deciding whether a data item needs to go in
+\c{game_params} is: would the user expect to be able to control this
+data item from either the preset-game-types menu or the \q{Custom}
+game type configuration? If so, it's part of \c{game_params}.
+
+\c{game_params} structures are permitted to contain pointers to
+subsidiary data if they need to. The back end is required to provide
+functions to create and destroy \c{game_params}, and those functions
+can allocate and free additional memory if necessary. (It has not
+yet been necessary to do this in any puzzle so far, but the
+capability is there just in case.)
+
+\c{game_params} is also the only structure which the game's
+\cw{compute_size()} function may refer to; this means that any
+aspect of the game which affects the size of the window it needs to
+be drawn in must be stored in \c{game_params}. In particular, this
+imposes the fundamental limitation that random game generation may
+not have a random effect on the window size: game generation
+algorithms are constrained to work by starting from the grid size
+rather than generating it as an emergent phenomenon. (Although this
+is a restriction in theory, it has not yet seemed to be a problem.)
+
+\S{backend-game-state} \c{game_state}
+
+While the user is actually playing a puzzle, the \c{game_state}
+structure stores all the data corresponding to the current state of
+play.
+
+The mid-end keeps \c{game_state}s in a list, and adds to the list
+every time the player makes a move; the Undo and Redo functions step
+back and forth through that list.
+
+Therefore, a good means of deciding whether a data item needs to go
+in \c{game_state} is: would a player expect that data item to be
+restored on undo? If so, put it in \c{game_state}, and this will
+automatically happen without you having to lift a finger. If not
+\dash for example, the deaths counter in Mines is precisely
+something that does \e{not} want to be reset to its previous state
+on an undo \dash then you might have found a data item that needs to
+go in \c{game_ui} instead.
+
+During play, \c{game_state}s are often passed around without an
+accompanying \c{game_params} structure. Therefore, any information
+in \c{game_params} which is important during play (such as the grid
+size) must be duplicated within the \c{game_state}. One simple
+method of doing this is to have the \c{game_state} structure
+\e{contain} a \c{game_params} structure as one of its members,
+although this isn't obligatory if you prefer to do it another way.
+
+\S{backend-game-drawstate} \c{game_drawstate}
+
+\c{game_drawstate} carries persistent state relating to the current
+graphical contents of the puzzle window. The same \c{game_drawstate}
+is passed to every call to the game redraw function, so that it can
+remember what it has already drawn and what needs redrawing.
+
+A typical use for a \c{game_drawstate} is to have an array mirroring
+the array of grid squares in the \c{game_state}; then every time the
+redraw function was passed a \c{game_state}, it would loop over all
+the squares, and physically redraw any whose description in the
+\c{game_state} (i.e. what the square needs to look like when the
+redraw is completed) did not match its description in the
+\c{game_drawstate} (i.e. what the square currently looks like).
+
+\c{game_drawstate} is occasionally completely torn down and
+reconstructed by the mid-end, if the user somehow forces a full
+redraw. Therefore, no data should be stored in \c{game_drawstate}
+which is \e{not} related to the state of the puzzle window, because
+it might be unexpectedly destroyed.
+
+The back end provides functions to create and destroy
+\c{game_drawstate}, which means it can contain pointers to
+subsidiary allocated data if it needs to. A common thing to want to
+allocate in a \c{game_drawstate} is a \c{blitter}; see
+\k{drawing-blitter} for more on this subject.
+
+\S{backend-game-ui} \c{game_ui}
+
+\c{game_ui} contains whatever doesn't fit into the above three
+structures!
+
+A new \c{game_ui} is created when the user begins playing a new
+instance of a puzzle (i.e. during \q{New Game} or after entering a
+game ID etc). It persists until the user finishes playing that game
+and begins another one (or closes the window); in particular,
+\q{Restart Game} does \e{not} destroy the \c{game_ui}.
+
+\c{game_ui} is useful for implementing user-interface state which is
+not part of \c{game_state}. Common examples are keyboard control
+(you wouldn't want to have to separately Undo through every cursor
+motion) and mouse dragging. See \k{writing-keyboard-cursor} and
+\k{writing-howto-dragging}, respectively, for more details.
+
+Another use for \c{game_ui} is to store highly persistent data such
+as the Mines death counter. This is conceptually rather different:
+where the Net cursor position was \e{not important enough} to
+preserve for the player to restore by Undo, the Mines death counter
+is \e{too important} to permit the player to revert by Undo!
+
+A final use for \c{game_ui} is to pass information to the redraw
+function about recent changes to the game state. This is used in
+Mines, for example, to indicate whether a requested \q{flash} should
+be a white flash for victory or a red flash for defeat; see
+\k{writing-flash-types}.
+
+\H{backend-simple} Simple data in the back end
+
+In this section I begin to discuss each individual element in the
+back end structure. To begin with, here are some simple
+self-contained data elements.
+
+\S{backend-name} \c{name}
+
+\c const char *name;
+
+This is a simple ASCII string giving the name of the puzzle. This
+name will be used in window titles, in game selection menus on
+monolithic platforms, and anywhere else that the front end needs to
+know the name of a game.
+
+\S{backend-winhelp} \c{winhelp_topic}
+
+\c const char *winhelp_topic;
+
+This member is used on Windows only, to provide online help.
+Although the Windows front end provides a separate binary for each
+puzzle, it has a single monolithic help file; so when a user selects
+\q{Help} from the menu, the program needs to open the help file and
+jump to the chapter describing that particular puzzle.
+
+Therefore, each chapter in \c{puzzles.but} is labelled with a
+\e{help topic} name, similar to this:
+
+\c \cfg{winhelp-topic}{games.net}
+
+And then the corresponding game back end encodes the topic string
+(here \cq{games.net}) in the \c{winhelp_topic} element of the game
+structure.
+
+\H{backend-params} Handling game parameter sets
+
+In this section I present the various functions which handle the
+\c{game_params} structure.
+
+\S{backend-default-params} \cw{default_params()}
+
+\c game_params *(*default_params)(void);
+
+This function allocates a new \c{game_params} structure, fills it
+with the default values, and returns a pointer to it.
+
+\S{backend-fetch-preset} \cw{fetch_preset()}
+
+\c int (*fetch_preset)(int i, char **name, game_params **params);
+
+This function is used to populate the \q{Type} menu, which provides
+a list of conveniently accessible preset parameters for most games.
+
+The function is called with \c{i} equal to the index of the preset
+required (numbering from zero). It returns \cw{FALSE} if that preset
+does not exist (if \c{i} is less than zero or greater than the
+largest preset index). Otherwise, it sets \c{*params} to point at a
+newly allocated \c{game_params} structure containing the preset
+information, sets \c{*name} to point at a newly allocated C string
+containing the preset title (to go on the \q{Type} menu), and
+returns \cw{TRUE}.
+
+If the game does not wish to support any presets at all, this
+function is permitted to return \cw{FALSE} always.
+
+\S{backend-encode-params} \cw{encode_params()}
+
+\c char *(*encode_params)(const game_params *params, int full);
+
+The job of this function is to take a \c{game_params}, and encode it
+in a string form for use in game IDs. The return value must be a
+newly allocated C string, and \e{must} not contain a colon or a hash
+(since those characters are used to mark the end of the parameter
+section in a game ID).
+
+Ideally, it should also not contain any other potentially
+controversial punctuation; bear in mind when designing a string
+parameter format that it will probably be used on both Windows and
+Unix command lines under a variety of exciting shell quoting and
+metacharacter rules. Sticking entirely to alphanumerics is the
+safest thing; if you really need punctuation, you can probably get
+away with commas, periods or underscores without causing anybody any
+major inconvenience. If you venture far beyond that, you're likely
+to irritate \e{somebody}.
+
+(At the time of writing this, all existing games have purely
+alphanumeric string parameter formats. Usually these involve a
+letter denoting a parameter, followed optionally by a number giving
+the value of that parameter, with a few mandatory parts at the
+beginning such as numeric width and height separated by \cq{x}.)
+
+If the \c{full} parameter is \cw{TRUE}, this function should encode
+absolutely everything in the \c{game_params}, such that a subsequent
+call to \cw{decode_params()} (\k{backend-decode-params}) will yield
+an identical structure. If \c{full} is \cw{FALSE}, however, you
+should leave out anything which is not necessary to describe a
+\e{specific puzzle instance}, i.e. anything which only takes effect
+when a new puzzle is \e{generated}. For example, the Solo
+\c{game_params} includes a difficulty rating used when constructing
+new puzzles; but a Solo game ID need not explicitly include the
+difficulty, since to describe a puzzle once generated it's
+sufficient to give the grid dimensions and the location and contents
+of the clue squares. (Indeed, one might very easily type in a puzzle
+out of a newspaper without \e{knowing} what its difficulty level is
+in Solo's terminology.) Therefore, Solo's \cw{encode_params()} only
+encodes the difficulty level if \c{full} is set.
+
+\S{backend-decode-params} \cw{decode_params()}
+
+\c void (*decode_params)(game_params *params, char const *string);
+
+This function is the inverse of \cw{encode_params()}
+(\k{backend-encode-params}). It parses the supplied string and fills
+in the supplied \c{game_params} structure. Note that the structure
+will \e{already} have been allocated: this function is not expected
+to create a \e{new} \c{game_params}, but to modify an existing one.
+
+This function can receive a string which only encodes a subset of
+the parameters. The most obvious way in which this can happen is if
+the string was constructed by \cw{encode_params()} with its \c{full}
+parameter set to \cw{FALSE}; however, it could also happen if the
+user typed in a parameter set manually and missed something out. Be
+prepared to deal with a wide range of possibilities.
+
+When dealing with a parameter which is not specified in the input
+string, what to do requires a judgment call on the part of the
+programmer. Sometimes it makes sense to adjust other parameters to
+bring them into line with the new ones. In Mines, for example, you
+would probably not want to keep the same mine count if the user
+dropped the grid size and didn't specify one, since you might easily
+end up with more mines than would actually fit in the grid! On the
+other hand, sometimes it makes sense to leave the parameter alone: a
+Solo player might reasonably expect to be able to configure size and
+difficulty independently of one another.
+
+This function currently has no direct means of returning an error if
+the string cannot be parsed at all. However, the returned
+\c{game_params} is almost always subsequently passed to
+\cw{validate_params()} (\k{backend-validate-params}), so if you
+really want to signal parse errors, you could always have a \c{char
+*} in your parameters structure which stored an error message, and
+have \cw{validate_params()} return it if it is non-\cw{NULL}.
+
+\S{backend-free-params} \cw{free_params()}
+
+\c void (*free_params)(game_params *params);
+
+This function frees a \c{game_params} structure, and any subsidiary
+allocations contained within it.
+
+\S{backend-dup-params} \cw{dup_params()}
+
+\c game_params *(*dup_params)(const game_params *params);
+
+This function allocates a new \c{game_params} structure and
+initialises it with an exact copy of the information in the one
+provided as input. It returns a pointer to the new duplicate.
+
+\S{backend-can-configure} \c{can_configure}
+
+\c int can_configure;
+
+This boolean data element is set to \cw{TRUE} if the back end
+supports custom parameter configuration via a dialog box. If it is
+\cw{TRUE}, then the functions \cw{configure()} and
+\cw{custom_params()} are expected to work. See \k{backend-configure}
+and \k{backend-custom-params} for more details.
+
+\S{backend-configure} \cw{configure()}
+
+\c config_item *(*configure)(const game_params *params);
+
+This function is called when the user requests a dialog box for
+custom parameter configuration. It returns a newly allocated array
+of \cw{config_item} structures, describing the GUI elements required
+in the dialog box. The array should have one more element than the
+number of controls, since it is terminated with a \cw{C_END} marker
+(see below). Each array element describes the control together with
+its initial value; the front end will modify the value fields and
+return the updated array to \cw{custom_params()} (see
+\k{backend-custom-params}).
+
+The \cw{config_item} structure contains the following elements:
+
+\c char *name;
+\c int type;
+\c char *sval;
+\c int ival;
+
+\c{name} is an ASCII string giving the textual label for a GUI
+control. It is \e{not} expected to be dynamically allocated.
+
+\c{type} contains one of a small number of \c{enum} values defining
+what type of control is being described. The meaning of the \c{sval}
+and \c{ival} fields depends on the value in \c{type}. The valid
+values are:
+
+\dt \c{C_STRING}
+
+\dd Describes a text input box. (This is also used for numeric
+input. The back end does not bother informing the front end that the
+box is numeric rather than textual; some front ends do have the
+capacity to take this into account, but I decided it wasn't worth
+the extra complexity in the interface.) For this type, \c{ival} is
+unused, and \c{sval} contains a dynamically allocated string
+representing the contents of the input box.
+
+\dt \c{C_BOOLEAN}
+
+\dd Describes a simple checkbox. For this type, \c{sval} is unused,
+and \c{ival} is \cw{TRUE} or \cw{FALSE}.
+
+\dt \c{C_CHOICES}
+
+\dd Describes a drop-down list presenting one of a small number of
+fixed choices. For this type, \c{sval} contains a list of strings
+describing the choices; the very first character of \c{sval} is used
+as a delimiter when processing the rest (so that the strings
+\cq{:zero:one:two}, \cq{!zero!one!two} and \cq{xzeroxonextwo} all
+define a three-element list containing \cq{zero}, \cq{one} and
+\cq{two}). \c{ival} contains the index of the currently selected
+element, numbering from zero (so that in the above example, 0 would
+mean \cq{zero} and 2 would mean \cq{two}).
+
+\lcont{
+
+Note that for this control type, \c{sval} is \e{not} dynamically
+allocated, whereas it was for \c{C_STRING}.
+
+}
+
+\dt \c{C_END}
+
+\dd Marks the end of the array of \c{config_item}s. All other fields
+are unused.
+
+The array returned from this function is expected to have filled in
+the initial values of all the controls according to the input
+\c{game_params} structure.
+
+If the game's \c{can_configure} flag is set to \cw{FALSE}, this
+function is never called and need not do anything at all.
+
+\S{backend-custom-params} \cw{custom_params()}
+
+\c game_params *(*custom_params)(const config_item *cfg);
+
+This function is the counterpart to \cw{configure()}
+(\k{backend-configure}). It receives as input an array of
+\c{config_item}s which was originally created by \cw{configure()},
+but in which the control values have since been changed in
+accordance with user input. Its function is to read the new values
+out of the controls and return a newly allocated \c{game_params}
+structure representing the user's chosen parameter set.
+
+(The front end will have modified the controls' \e{values}, but
+there will still always be the same set of controls, in the same
+order, as provided by \cw{configure()}. It is not necessary to check
+the \c{name} and \c{type} fields, although you could use
+\cw{assert()} if you were feeling energetic.)
+
+This function is not expected to (and indeed \e{must not}) free the
+input \c{config_item} array. (If the parameters fail to validate,
+the dialog box will stay open.)
+
+If the game's \c{can_configure} flag is set to \cw{FALSE}, this
+function is never called and need not do anything at all.
+
+\S{backend-validate-params} \cw{validate_params()}
+
+\c char *(*validate_params)(const game_params *params, int full);
+
+This function takes a \c{game_params} structure as input, and checks
+that the parameters described in it fall within sensible limits. (At
+the very least, grid dimensions should almost certainly be strictly
+positive, for example.)
+
+Return value is \cw{NULL} if no problems were found, or
+alternatively a (non-dynamically-allocated) ASCII string describing
+the error in human-readable form.
+
+If the \c{full} parameter is set, full validation should be
+performed: any set of parameters which would not permit generation
+of a sensible puzzle should be faulted. If \c{full} is \e{not} set,
+the implication is that these parameters are not going to be used
+for \e{generating} a puzzle; so parameters which can't even sensibly
+\e{describe} a valid puzzle should still be faulted, but parameters
+which only affect puzzle generation should not be.
+
+(The \c{full} option makes a difference when parameter combinations
+are non-orthogonal. For example, Net has a boolean option
+controlling whether it enforces a unique solution; it turns out that
+it's impossible to generate a uniquely soluble puzzle with wrapping
+walls and width 2, so \cw{validate_params()} will complain if you
+ask for one. However, if the user had just been playing a unique
+wrapping puzzle of a more sensible width, and then pastes in a game
+ID acquired from somebody else which happens to describe a
+\e{non}-unique wrapping width-2 puzzle, then \cw{validate_params()}
+will be passed a \c{game_params} containing the width and wrapping
+settings from the new game ID and the uniqueness setting from the
+old one. This would be faulted, if it weren't for the fact that
+\c{full} is not set during this call, so Net ignores the
+inconsistency. The resulting \c{game_params} is never subsequently
+used to generate a puzzle; this is a promise made by the mid-end
+when it asks for a non-full validation.)
+
+\H{backend-descs} Handling game descriptions
+
+In this section I present the functions that deal with a textual
+description of a puzzle, i.e. the part that comes after the colon in
+a descriptive-format game ID.
+
+\S{backend-new-desc} \cw{new_desc()}
+
+\c char *(*new_desc)(const game_params *params, random_state *rs,
+\c                   char **aux, int interactive);
+
+This function is where all the really hard work gets done. This is
+the function whose job is to randomly generate a new puzzle,
+ensuring solubility and uniqueness as appropriate.
+
+As input it is given a \c{game_params} structure and a random state
+(see \k{utils-random} for the random number API). It must invent a
+puzzle instance, encode it in string form, and return a dynamically
+allocated C string containing that encoding.
+
+Additionally, it may return a second dynamically allocated string in
+\c{*aux}. (If it doesn't want to, then it can leave that parameter
+completely alone; it isn't required to set it to \cw{NULL}, although
+doing so is harmless.) That string, if present, will be passed to
+\cw{solve()} (\k{backend-solve}) later on; so if the puzzle is
+generated in such a way that a solution is known, then information
+about that solution can be saved in \c{*aux} for \cw{solve()} to
+use.
+
+The \c{interactive} parameter should be ignored by almost all
+puzzles. Its purpose is to distinguish between generating a puzzle
+within a GUI context for immediate play, and generating a puzzle in
+a command-line context for saving to be played later. The only
+puzzle that currently uses this distinction (and, I fervently hope,
+the only one which will \e{ever} need to use it) is Mines, which
+chooses a random first-click location when generating puzzles
+non-interactively, but which waits for the user to place the first
+click when interactive. If you think you have come up with another
+puzzle which needs to make use of this parameter, please think for
+at least ten minutes about whether there is \e{any} alternative!
+
+Note that game description strings are not required to contain an
+encoding of parameters such as grid size; a game description is
+never separated from the \c{game_params} it was generated with, so
+any information contained in that structure need not be encoded
+again in the game description.
+
+\S{backend-validate-desc} \cw{validate_desc()}
+
+\c char *(*validate_desc)(const game_params *params, const char *desc);
+
+This function is given a game description, and its job is to
+validate that it describes a puzzle which makes sense.
+
+To some extent it's up to the user exactly how far they take the
+phrase \q{makes sense}; there are no particularly strict rules about
+how hard the user is permitted to shoot themself in the foot when
+typing in a bogus game description by hand. (For example, Rectangles
+will not verify that the sum of all the numbers in the grid equals
+the grid's area. So a user could enter a puzzle which was provably
+not soluble, and the program wouldn't complain; there just wouldn't
+happen to be any sequence of moves which solved it.)
+
+The one non-negotiable criterion is that any game description which
+makes it through \cw{validate_desc()} \e{must not} subsequently
+cause a crash or an assertion failure when fed to \cw{new_game()}
+and thence to the rest of the back end.
+
+The return value is \cw{NULL} on success, or a
+non-dynamically-allocated C string containing an error message.
+
+\S{backend-new-game} \cw{new_game()}
+
+\c game_state *(*new_game)(midend *me, const game_params *params,
+\c                         const char *desc);
+
+This function takes a game description as input, together with its
+accompanying \c{game_params}, and constructs a \c{game_state}
+describing the initial state of the puzzle. It returns a newly
+allocated \c{game_state} structure.
+
+Almost all puzzles should ignore the \c{me} parameter. It is
+required by Mines, which needs it for later passing to
+\cw{midend_supersede_game_desc()} (see \k{backend-supersede}) once
+the user has placed the first click. I fervently hope that no other
+puzzle will be awkward enough to require it, so everybody else
+should ignore it. As with the \c{interactive} parameter in
+\cw{new_desc()} (\k{backend-new-desc}), if you think you have a
+reason to need this parameter, please try very hard to think of an
+alternative approach!
+
+\H{backend-states} Handling game states
+
+This section describes the functions which create and destroy
+\c{game_state} structures.
+
+(Well, except \cw{new_game()}, which is in \k{backend-new-game}
+instead of under here; but it deals with game descriptions \e{and}
+game states and it had to go in one section or the other.)
+
+\S{backend-dup-game} \cw{dup_game()}
+
+\c game_state *(*dup_game)(const game_state *state);
+
+This function allocates a new \c{game_state} structure and
+initialises it with an exact copy of the information in the one
+provided as input. It returns a pointer to the new duplicate.
+
+\S{backend-free-game} \cw{free_game()}
+
+\c void (*free_game)(game_state *state);
+
+This function frees a \c{game_state} structure, and any subsidiary
+allocations contained within it.
+
+\H{backend-ui} Handling \c{game_ui}
+
+\S{backend-new-ui} \cw{new_ui()}
+
+\c game_ui *(*new_ui)(const game_state *state);
+
+This function allocates and returns a new \c{game_ui} structure for
+playing a particular puzzle. It is passed a pointer to the initial
+\c{game_state}, in case it needs to refer to that when setting up
+the initial values for the new game.
+
+\S{backend-free-ui} \cw{free_ui()}
+
+\c void (*free_ui)(game_ui *ui);
+
+This function frees a \c{game_ui} structure, and any subsidiary
+allocations contained within it.
+
+\S{backend-encode-ui} \cw{encode_ui()}
+
+\c char *(*encode_ui)(const game_ui *ui);
+
+This function encodes any \e{important} data in a \c{game_ui}
+structure in string form. It is only called when saving a
+half-finished game to a file.
+
+It should be used sparingly. Almost all data in a \c{game_ui} is not
+important enough to save. The location of the keyboard-controlled
+cursor, for example, can be reset to a default position on reloading
+the game without impacting the user experience. If the user should
+somehow manage to save a game while a mouse drag was in progress,
+then discarding that mouse drag would be an outright \e{feature}.
+
+A typical thing that \e{would} be worth encoding in this function is
+the Mines death counter: it's in the \c{game_ui} rather than the
+\c{game_state} because it's too important to allow the user to
+revert it by using Undo, and therefore it's also too important to
+allow the user to revert it by saving and reloading. (Of course, the
+user could edit the save file by hand... But if the user is \e{that}
+determined to cheat, they could just as easily modify the game's
+source.)
+
+\S{backend-decode-ui} \cw{decode_ui()}
+
+\c void (*decode_ui)(game_ui *ui, const char *encoding);
+
+This function parses a string previously output by \cw{encode_ui()},
+and writes the decoded data back into the provided \c{game_ui}
+structure.
+
+\S{backend-changed-state} \cw{changed_state()}
+
+\c void (*changed_state)(game_ui *ui, const game_state *oldstate,
+\c                       const game_state *newstate);
+
+This function is called by the mid-end whenever the current game
+state changes, for any reason. Those reasons include:
+
+\b a fresh move being made by \cw{interpret_move()} and
+\cw{execute_move()}
+
+\b a solve operation being performed by \cw{solve()} and
+\cw{execute_move()}
+
+\b the user moving back and forth along the undo list by means of
+the Undo and Redo operations
+
+\b the user selecting Restart to go back to the initial game state.
+
+The job of \cw{changed_state()} is to update the \c{game_ui} for
+consistency with the new game state, if any update is necessary. For
+example, Same Game stores data about the currently selected tile
+group in its \c{game_ui}, and this data is intrinsically related to
+the game state it was derived from. So it's very likely to become
+invalid when the game state changes; thus, Same Game's
+\cw{changed_state()} function clears the current selection whenever
+it is called.
+
+When \cw{anim_length()} or \cw{flash_length()} are called, you can
+be sure that there has been a previous call to \cw{changed_state()}.
+So \cw{changed_state()} can set up data in the \c{game_ui} which will
+be read by \cw{anim_length()} and \cw{flash_length()}, and those
+functions will not have to worry about being called without the data
+having been initialised.
+
+\H{backend-moves} Making moves
+
+This section describes the functions which actually make moves in
+the game: that is, the functions which process user input and end up
+producing new \c{game_state}s.
+
+\S{backend-interpret-move} \cw{interpret_move()}
+
+\c char *(*interpret_move)(const game_state *state, game_ui *ui,
+\c                         const game_drawstate *ds,
+\c                         int x, int y, int button);
+
+This function receives user input and processes it. Its input
+parameters are the current \c{game_state}, the current \c{game_ui}
+and the current \c{game_drawstate}, plus details of the input event.
+\c{button} is either an ASCII value or a special code (listed below)
+indicating an arrow or function key or a mouse event; when
+\c{button} is a mouse event, \c{x} and \c{y} contain the pixel
+coordinates of the mouse pointer relative to the top left of the
+puzzle's drawing area.
+
+(The pointer to the \c{game_drawstate} is marked \c{const}, because
+\c{interpret_move} should not write to it. The normal use of that
+pointer will be to read the game's tile size parameter in order to
+divide mouse coordinates by it.)
+
+\cw{interpret_move()} may return in three different ways:
+
+\b Returning \cw{NULL} indicates that no action whatsoever occurred
+in response to the input event; the puzzle was not interested in it
+at all.
+
+\b Returning the empty string (\cw{""}) indicates that the input
+event has resulted in a change being made to the \c{game_ui} which
+will require a redraw of the game window, but that no actual
+\e{move} was made (i.e. no new \c{game_state} needs to be created).
+
+\b Returning anything else indicates that a move was made and that a
+new \c{game_state} must be created. However, instead of actually
+constructing a new \c{game_state} itself, this function is required
+to return a string description of the details of the move. This
+string will be passed to \cw{execute_move()}
+(\k{backend-execute-move}) to actually create the new
+\c{game_state}. (Encoding moves as strings in this way means that
+the mid-end can keep the strings as well as the game states, and the
+strings can be written to disk when saving the game and fed to
+\cw{execute_move()} again on reloading.)
+
+The return value from \cw{interpret_move()} is expected to be
+dynamically allocated if and only if it is not either \cw{NULL}
+\e{or} the empty string.
+
+After this function is called, the back end is permitted to rely on
+some subsequent operations happening in sequence:
+
+\b \cw{execute_move()} will be called to convert this move
+description into a new \c{game_state}
+
+\b \cw{changed_state()} will be called with the new \c{game_state}.
+
+This means that if \cw{interpret_move()} needs to do updates to the
+\c{game_ui} which are easier to perform by referring to the new
+\c{game_state}, it can safely leave them to be done in
+\cw{changed_state()} and not worry about them failing to happen.
+
+(Note, however, that \cw{execute_move()} may \e{also} be called in
+other circumstances. It is only \cw{interpret_move()} which can rely
+on a subsequent call to \cw{changed_state()}.)
+
+The special key codes supported by this function are:
+
+\dt \cw{LEFT_BUTTON}, \cw{MIDDLE_BUTTON}, \cw{RIGHT_BUTTON}
+
+\dd Indicate that one of the mouse buttons was pressed down.
+
+\dt \cw{LEFT_DRAG}, \cw{MIDDLE_DRAG}, \cw{RIGHT_DRAG}
+
+\dd Indicate that the mouse was moved while one of the mouse buttons
+was still down. The mid-end guarantees that when one of these events
+is received, it will always have been preceded by a button-down
+event (and possibly other drag events) for the same mouse button,
+and no event involving another mouse button will have appeared in
+between.
+
+\dt \cw{LEFT_RELEASE}, \cw{MIDDLE_RELEASE}, \cw{RIGHT_RELEASE}
+
+\dd Indicate that a mouse button was released.  The mid-end
+guarantees that when one of these events is received, it will always
+have been preceded by a button-down event (and possibly some drag
+events) for the same mouse button, and no event involving another
+mouse button will have appeared in between.
+
+\dt \cw{CURSOR_UP}, \cw{CURSOR_DOWN}, \cw{CURSOR_LEFT},
+\cw{CURSOR_RIGHT}
+
+\dd Indicate that an arrow key was pressed.
+
+\dt \cw{CURSOR_SELECT}
+
+\dd On platforms which have a prominent \q{select} button alongside
+their cursor keys, indicates that that button was pressed.
+
+In addition, there are some modifiers which can be bitwise-ORed into
+the \c{button} parameter:
+
+\dt \cw{MOD_CTRL}, \cw{MOD_SHFT}
+
+\dd These indicate that the Control or Shift key was pressed
+alongside the key. They only apply to the cursor keys, not to mouse
+buttons or anything else.
+
+\dt \cw{MOD_NUM_KEYPAD}
+
+\dd This applies to some ASCII values, and indicates that the key
+code was input via the numeric keypad rather than the main keyboard.
+Some puzzles may wish to treat this differently (for example, a
+puzzle might want to use the numeric keypad as an eight-way
+directional pad), whereas others might not (a game involving numeric
+input probably just wants to treat the numeric keypad as numbers).
+
+\dt \cw{MOD_MASK}
+
+\dd This mask is the bitwise OR of all the available modifiers; you
+can bitwise-AND with \cw{~MOD_MASK} to strip all the modifiers off
+any input value.
+
+\S{backend-execute-move} \cw{execute_move()}
+
+\c game_state *(*execute_move)(const game_state *state, char *move);
+
+This function takes an input \c{game_state} and a move string as
+output from \cw{interpret_move()}. It returns a newly allocated
+\c{game_state} which contains the result of applying the specified
+move to the input game state.
+
+This function may return \cw{NULL} if it cannot parse the move
+string (and this is definitely preferable to crashing or failing an
+assertion, since one way this can happen is if loading a corrupt
+save file). However, it must not return \cw{NULL} for any move
+string that really was output from \cw{interpret_move()}: this is
+punishable by assertion failure in the mid-end.
+
+\S{backend-can-solve} \c{can_solve}
+
+\c int can_solve;
+
+This boolean field is set to \cw{TRUE} if the game's \cw{solve()}
+function does something. If it's set to \cw{FALSE}, the game will
+not even offer the \q{Solve} menu option.
+
+\S{backend-solve} \cw{solve()}
+
+\c char *(*solve)(const game_state *orig, const game_state *curr,
+\c                const char *aux, char **error);
+
+This function is called when the user selects the \q{Solve} option
+from the menu.
+
+It is passed two input game states: \c{orig} is the game state from
+the very start of the puzzle, and \c{curr} is the current one.
+(Different games find one or other or both of these convenient.) It
+is also passed the \c{aux} string saved by \cw{new_desc()}
+(\k{backend-new-desc}), in case that encodes important information
+needed to provide the solution.
+
+If this function is unable to produce a solution (perhaps, for
+example, the game has no in-built solver so it can only solve
+puzzles it invented internally and has an \c{aux} string for) then
+it may return \cw{NULL}. If it does this, it must also set
+\c{*error} to an error message to be presented to the user (such as
+\q{Solution not known for this puzzle}); that error message is not
+expected to be dynamically allocated.
+
+If this function \e{does} produce a solution, it returns a move string
+suitable for feeding to \cw{execute_move()}
+(\k{backend-execute-move}). Like a (non-empty) string returned from
+\cw{interpret_move()}, the returned string should be dynamically
+allocated.
+
+\H{backend-drawing} Drawing the game graphics
+
+This section discusses the back end functions that deal with
+drawing.
+
+\S{backend-new-drawstate} \cw{new_drawstate()}
+
+\c game_drawstate *(*new_drawstate)(drawing *dr,
+\c                                  const game_state *state);
+
+This function allocates and returns a new \c{game_drawstate}
+structure for drawing a particular puzzle. It is passed a pointer to
+a \c{game_state}, in case it needs to refer to that when setting up
+any initial data.
+
+This function may not rely on the puzzle having been newly started;
+a new draw state can be constructed at any time if the front end
+requests a forced redraw. For games like Pattern, in which initial
+game states are much simpler than general ones, this might be
+important to keep in mind.
+
+The parameter \c{dr} is a drawing object (see \k{drawing}) which the
+function might need to use to allocate blitters. (However, this
+isn't recommended; it's usually more sensible to wait to allocate a
+blitter until \cw{set_size()} is called, because that way you can
+tailor it to the scale at which the puzzle is being drawn.)
+
+\S{backend-free-drawstate} \cw{free_drawstate()}
+
+\c void (*free_drawstate)(drawing *dr, game_drawstate *ds);
+
+This function frees a \c{game_drawstate} structure, and any
+subsidiary allocations contained within it.
+
+The parameter \c{dr} is a drawing object (see \k{drawing}), which
+might be required if you are freeing a blitter.
+
+\S{backend-preferred-tilesize} \c{preferred_tilesize}
+
+\c int preferred_tilesize;
+
+Each game is required to define a single integer parameter which
+expresses, in some sense, the scale at which it is drawn. This is
+described in the APIs as \cq{tilesize}, since most puzzles are on a
+square (or possibly triangular or hexagonal) grid and hence a
+sensible interpretation of this parameter is to define it as the
+size of one grid tile in pixels; however, there's no actual
+requirement that the \q{tile size} be proportional to the game
+window size. Window size is required to increase monotonically with
+\q{tile size}, however.
+
+The data element \c{preferred_tilesize} indicates the tile size
+which should be used in the absence of a good reason to do otherwise
+(such as the screen being too small, or the user explicitly
+requesting a resize if that ever gets implemented).
+
+\S{backend-compute-size} \cw{compute_size()}
+
+\c void (*compute_size)(const game_params *params, int tilesize,
+\c                      int *x, int *y);
+
+This function is passed a \c{game_params} structure and a tile size.
+It returns, in \c{*x} and \c{*y}, the size in pixels of the drawing
+area that would be required to render a puzzle with those parameters
+at that tile size.
+
+\S{backend-set-size} \cw{set_size()}
+
+\c void (*set_size)(drawing *dr, game_drawstate *ds,
+\c                  const game_params *params, int tilesize);
+
+This function is responsible for setting up a \c{game_drawstate} to
+draw at a given tile size. Typically this will simply involve
+copying the supplied \c{tilesize} parameter into a \c{tilesize}
+field inside the draw state; for some more complex games it might
+also involve setting up other dimension fields, or possibly
+allocating a blitter (see \k{drawing-blitter}).
+
+The parameter \c{dr} is a drawing object (see \k{drawing}), which is
+required if a blitter needs to be allocated.
+
+Back ends may assume (and may enforce by assertion) that this
+function will be called at most once for any \c{game_drawstate}. If
+a puzzle needs to be redrawn at a different size, the mid-end will
+create a fresh drawstate.
+
+\S{backend-colours} \cw{colours()}
+
+\c float *(*colours)(frontend *fe, int *ncolours);
+
+This function is responsible for telling the front end what colours
+the puzzle will need to draw itself.
+
+It returns the number of colours required in \c{*ncolours}, and the
+return value from the function itself is a dynamically allocated
+array of three times that many \c{float}s, containing the red, green
+and blue components of each colour respectively as numbers in the
+range [0,1].
+
+The second parameter passed to this function is a front end handle.
+The only things it is permitted to do with this handle are to call
+the front-end function called \cw{frontend_default_colour()} (see
+\k{frontend-default-colour}) or the utility function called
+\cw{game_mkhighlight()} (see \k{utils-game-mkhighlight}). (The
+latter is a wrapper on the former, so front end implementors only
+need to provide \cw{frontend_default_colour()}.) This allows
+\cw{colours()} to take local configuration into account when
+deciding on its own colour allocations. Most games use the front
+end's default colour as their background, apart from a few which
+depend on drawing relief highlights so they adjust the background
+colour if it's too light for highlights to show up against it.
+
+Note that the colours returned from this function are for
+\e{drawing}, not for printing. Printing has an entirely different
+colour allocation policy.
+
+\S{backend-anim-length} \cw{anim_length()}
+
+\c float (*anim_length)(const game_state *oldstate,
+\c                      const game_state *newstate,
+\c                      int dir, game_ui *ui);
+
+This function is called when a move is made, undone or redone. It is
+given the old and the new \c{game_state}, and its job is to decide
+whether the transition between the two needs to be animated or can
+be instant.
+
+\c{oldstate} is the state that was current until this call;
+\c{newstate} is the state that will be current after it. \c{dir}
+specifies the chronological order of those states: if it is
+positive, then the transition is the result of a move or a redo (and
+so \c{newstate} is the later of the two moves), whereas if it is
+negative then the transition is the result of an undo (so that
+\c{newstate} is the \e{earlier} move).
+
+If this function decides the transition should be animated, it
+returns the desired length of the animation in seconds. If not, it
+returns zero.
+
+State changes as a result of a Restart operation are never animated;
+the mid-end will handle them internally and never consult this
+function at all. State changes as a result of Solve operations are
+also not animated by default, although you can change this for a
+particular game by setting a flag in \c{flags} (\k{backend-flags}).
+
+The function is also passed a pointer to the local \c{game_ui}. It
+may refer to information in here to help with its decision (see
+\k{writing-conditional-anim} for an example of this), and/or it may
+\e{write} information about the nature of the animation which will
+be read later by \cw{redraw()}.
+
+When this function is called, it may rely on \cw{changed_state()}
+having been called previously, so if \cw{anim_length()} needs to
+refer to information in the \c{game_ui}, then \cw{changed_state()}
+is a reliable place to have set that information up.
+
+Move animations do not inhibit further input events. If the user
+continues playing before a move animation is complete, the animation
+will be abandoned and the display will jump straight to the final
+state.
+
+\S{backend-flash-length} \cw{flash_length()}
+
+\c float (*flash_length)(const game_state *oldstate,
+\c                       const game_state *newstate,
+\c                       int dir, game_ui *ui);
+
+This function is called when a move is completed. (\q{Completed}
+means that not only has the move been made, but any animation which
+accompanied it has finished.) It decides whether the transition from
+\c{oldstate} to \c{newstate} merits a \q{flash}.
+
+A flash is much like a move animation, but it is \e{not} interrupted
+by further user interface activity; it runs to completion in
+parallel with whatever else might be going on on the display. The
+only thing which will rush a flash to completion is another flash.
+
+The purpose of flashes is to indicate that the game has been
+completed. They were introduced as a separate concept from move
+animations because of Net: the habit of most Net players (and
+certainly me) is to rotate a tile into place and immediately lock
+it, then move on to another tile. When you make your last move, at
+the instant the final tile is rotated into place the screen starts
+to flash to indicate victory \dash but if you then press the lock
+button out of habit, then the move animation is cancelled, and the
+victory flash does not complete. (And if you \e{don't} press the
+lock button, the completed grid will look untidy because there will
+be one unlocked square.) Therefore, I introduced a specific concept
+of a \q{flash} which is separate from a move animation and can
+proceed in parallel with move animations and any other display
+activity, so that the victory flash in Net is not cancelled by that
+final locking move.
+
+The input parameters to \cw{flash_length()} are exactly the same as
+the ones to \cw{anim_length()}.
+
+Just like \cw{anim_length()}, when this function is called, it may
+rely on \cw{changed_state()} having been called previously, so if it
+needs to refer to information in the \c{game_ui} then
+\cw{changed_state()} is a reliable place to have set that
+information up.
+
+(Some games use flashes to indicate defeat as well as victory;
+Mines, for example, flashes in a different colour when you tread on
+a mine from the colour it uses when you complete the game. In order
+to achieve this, its \cw{flash_length()} function has to store a
+flag in the \c{game_ui} to indicate which flash type is required.)
+
+\S{backend-status} \cw{status()}
+
+\c int (*status)(const game_state *state);
+
+This function returns a status value indicating whether the current
+game is still in play, or has been won, or has been conclusively lost.
+The mid-end uses this to implement \cw{midend_status()}
+(\k{midend-status}).
+
+The return value should be +1 if the game has been successfully
+solved. If the game has been lost in a situation where further play is
+unlikely, the return value should be -1. If neither is true (so play
+is still ongoing), return zero.
+
+Front ends may wish to use a non-zero status as a cue to proactively
+offer the option of starting a new game. Therefore, back ends should
+not return -1 if the game has been \e{technically} lost but undoing
+and continuing is still a realistic possibility.
+
+(For instance, games with hidden information such as Guess or Mines
+might well return a non-zero status whenever they reveal the solution,
+whether or not the player guessed it correctly, on the grounds that a
+player would be unlikely to hide the solution and continue playing
+after the answer was spoiled. On the other hand, games where you can
+merely get into a dead end such as Same Game or Inertia might choose
+to return 0 in that situation, on the grounds that the player would
+quite likely press Undo and carry on playing.)
+
+\S{backend-redraw} \cw{redraw()}
+
+\c void (*redraw)(drawing *dr, game_drawstate *ds,
+\c                const game_state *oldstate,
+\c                const game_state *newstate,
+\c                int dir, const game_ui *ui,
+\c                float anim_time, float flash_time);
+
+This function is responsible for actually drawing the contents of
+the game window, and for redrawing every time the game state or the
+\c{game_ui} changes.
+
+The parameter \c{dr} is a drawing object which may be passed to the
+drawing API functions (see \k{drawing} for documentation of the
+drawing API). This function may not save \c{dr} and use it
+elsewhere; it must only use it for calling back to the drawing API
+functions within its own lifetime.
+
+\c{ds} is the local \c{game_drawstate}, of course, and \c{ui} is the
+local \c{game_ui}.
+
+\c{newstate} is the semantically-current game state, and is always
+non-\cw{NULL}. If \c{oldstate} is also non-\cw{NULL}, it means that
+a move has recently been made and the game is still in the process
+of displaying an animation linking the old and new states; in this
+situation, \c{anim_time} will give the length of time (in seconds)
+that the animation has already been running. If \c{oldstate} is
+\cw{NULL}, then \c{anim_time} is unused (and will hopefully be set
+to zero to avoid confusion).
+
+\c{flash_time}, if it is is non-zero, denotes that the game is in
+the middle of a flash, and gives the time since the start of the
+flash. See \k{backend-flash-length} for general discussion of
+flashes.
+
+The very first time this function is called for a new
+\c{game_drawstate}, it is expected to redraw the \e{entire} drawing
+area. Since this often involves drawing visual furniture which is
+never subsequently altered, it is often simplest to arrange this by
+having a special \q{first time} flag in the draw state, and
+resetting it after the first redraw.
+
+When this function (or any subfunction) calls the drawing API, it is
+expected to pass colour indices which were previously defined by the
+\cw{colours()} function.
+
+\H{backend-printing} Printing functions
+
+This section discusses the back end functions that deal with
+printing puzzles out on paper.
+
+\S{backend-can-print} \c{can_print}
+
+\c int can_print;
+
+This flag is set to \cw{TRUE} if the puzzle is capable of printing
+itself on paper. (This makes sense for some puzzles, such as Solo,
+which can be filled in with a pencil. Other puzzles, such as
+Twiddle, inherently involve moving things around and so would not
+make sense to print.)
+
+If this flag is \cw{FALSE}, then the functions \cw{print_size()}
+and \cw{print()} will never be called.
+
+\S{backend-can-print-in-colour} \c{can_print_in_colour}
+
+\c int can_print_in_colour;
+
+This flag is set to \cw{TRUE} if the puzzle is capable of printing
+itself differently when colour is available. For example, Map can
+actually print coloured regions in different \e{colours} rather than
+resorting to cross-hatching.
+
+If the \c{can_print} flag is \cw{FALSE}, then this flag will be
+ignored.
+
+\S{backend-print-size} \cw{print_size()}
+
+\c void (*print_size)(const game_params *params, float *x, float *y);
+
+This function is passed a \c{game_params} structure and a tile size.
+It returns, in \c{*x} and \c{*y}, the preferred size in
+\e{millimetres} of that puzzle if it were to be printed out on paper.
+
+If the \c{can_print} flag is \cw{FALSE}, this function will never be
+called.
+
+\S{backend-print} \cw{print()}
+
+\c void (*print)(drawing *dr, const game_state *state, int tilesize);
+
+This function is called when a puzzle is to be printed out on paper.
+It should use the drawing API functions (see \k{drawing}) to print
+itself.
+
+This function is separate from \cw{redraw()} because it is often
+very different:
+
+\b The printing function may not depend on pixel accuracy, since
+printer resolution is variable. Draw as if your canvas had infinite
+resolution.
+
+\b The printing function sometimes needs to display things in a
+completely different style. Net, for example, is very different as
+an on-screen puzzle and as a printed one.
+
+\b The printing function is often much simpler since it has no need
+to deal with repeated partial redraws.
+
+However, there's no reason the printing and redraw functions can't
+share some code if they want to.
+
+When this function (or any subfunction) calls the drawing API, the
+colour indices it passes should be colours which have been allocated
+by the \cw{print_*_colour()} functions within this execution of
+\cw{print()}. This is very different from the fixed small number of
+colours used in \cw{redraw()}, because printers do not have a
+limitation on the total number of colours that may be used. Some
+puzzles' printing functions might wish to allocate only one \q{ink}
+colour and use it for all drawing; others might wish to allocate
+\e{more} colours than are used on screen.
+
+One possible colour policy worth mentioning specifically is that a
+puzzle's printing function might want to allocate the \e{same}
+colour indices as are used by the redraw function, so that code
+shared between drawing and printing does not have to keep switching
+its colour indices. In order to do this, the simplest thing is to
+make use of the fact that colour indices returned from
+\cw{print_*_colour()} are guaranteed to be in increasing order from
+zero. So if you have declared an \c{enum} defining three colours
+\cw{COL_BACKGROUND}, \cw{COL_THIS} and \cw{COL_THAT}, you might then
+write
+
+\c int c;
+\c c = print_mono_colour(dr, 1); assert(c == COL_BACKGROUND);
+\c c = print_mono_colour(dr, 0); assert(c == COL_THIS);
+\c c = print_mono_colour(dr, 0); assert(c == COL_THAT);
+
+If the \c{can_print} flag is \cw{FALSE}, this function will never be
+called.
+
+\H{backend-misc} Miscellaneous
+
+\S{backend-can-format-as-text-ever} \c{can_format_as_text_ever}
+
+\c int can_format_as_text_ever;
+
+This boolean field is \cw{TRUE} if the game supports formatting a
+game state as ASCII text (typically ASCII art) for copying to the
+clipboard and pasting into other applications. If it is \cw{FALSE},
+front ends will not offer the \q{Copy} command at all.
+
+If this field is \cw{TRUE}, the game does not necessarily have to
+support text formatting for \e{all} games: e.g. a game which can be
+played on a square grid or a triangular one might only support copy
+and paste for the former, because triangular grids in ASCII art are
+just too difficult.
+
+If this field is \cw{FALSE}, the functions
+\cw{can_format_as_text_now()} (\k{backend-can-format-as-text-now})
+and \cw{text_format()} (\k{backend-text-format}) are never called.
+
+\S{backend-can-format-as-text-now} \c{can_format_as_text_now()}
+
+\c int (*can_format_as_text_now)(const game_params *params);
+
+This function is passed a \c{game_params} and returns a boolean,
+which is \cw{TRUE} if the game can support ASCII text output for
+this particular game type. If it returns \cw{FALSE}, front ends will
+grey out or otherwise disable the \q{Copy} command.
+
+Games may enable and disable the copy-and-paste function for
+different game \e{parameters}, but are currently constrained to
+return the same answer from this function for all game \e{states}
+sharing the same parameters. In other words, the \q{Copy} function
+may enable or disable itself when the player changes game preset,
+but will never change during play of a single game or when another
+game of exactly the same type is generated.
+
+This function should not take into account aspects of the game
+parameters which are not encoded by \cw{encode_params()}
+(\k{backend-encode-params}) when the \c{full} parameter is set to
+\cw{FALSE}. Such parameters will not necessarily match up between a
+call to this function and a subsequent call to \cw{text_format()}
+itself. (For instance, game \e{difficulty} should not affect whether
+the game can be copied to the clipboard. Only the actual visible
+\e{shape} of the game can affect that.)
+
+\S{backend-text-format} \cw{text_format()}
+
+\c char *(*text_format)(const game_state *state);
+
+This function is passed a \c{game_state}, and returns a newly
+allocated C string containing an ASCII representation of that game
+state. It is used to implement the \q{Copy} operation in many front
+ends.
+
+This function will only ever be called if the back end field
+\c{can_format_as_text_ever} (\k{backend-can-format-as-text-ever}) is
+\cw{TRUE} \e{and} the function \cw{can_format_as_text_now()}
+(\k{backend-can-format-as-text-now}) has returned \cw{TRUE} for the
+currently selected game parameters.
+
+The returned string may contain line endings (and will probably want
+to), using the normal C internal \cq{\\n} convention. For
+consistency between puzzles, all multi-line textual puzzle
+representations should \e{end} with a newline as well as containing
+them internally. (There are currently no puzzles which have a
+one-line ASCII representation, so there's no precedent yet for
+whether that should come with a newline or not.)
+
+\S{backend-wants-statusbar} \cw{wants_statusbar}
+
+\c int wants_statusbar;
+
+This boolean field is set to \cw{TRUE} if the puzzle has a use for a
+textual status line (to display score, completion status, currently
+active tiles, etc).
+
+\S{backend-is-timed} \c{is_timed}
+
+\c int is_timed;
+
+This boolean field is \cw{TRUE} if the puzzle is time-critical. If
+so, the mid-end will maintain a game timer while the user plays.
+
+If this field is \cw{FALSE}, then \cw{timing_state()} will never be
+called and need not do anything.
+
+\S{backend-timing-state} \cw{timing_state()}
+
+\c int (*timing_state)(const game_state *state, game_ui *ui);
+
+This function is passed the current \c{game_state} and the local
+\c{game_ui}; it returns \cw{TRUE} if the game timer should currently
+be running.
+
+A typical use for the \c{game_ui} in this function is to note when
+the game was first completed (by setting a flag in
+\cw{changed_state()} \dash see \k{backend-changed-state}), and
+freeze the timer thereafter so that the user can undo back through
+their solution process without altering their time.
+
+\S{backend-flags} \c{flags}
+
+\c int flags;
+
+This field contains miscellaneous per-backend flags. It consists of
+the bitwise OR of some combination of the following:
+
+\dt \cw{BUTTON_BEATS(x,y)}
+
+\dd Given any \cw{x} and \cw{y} from the set \{\cw{LEFT_BUTTON},
+\cw{MIDDLE_BUTTON}, \cw{RIGHT_BUTTON}\}, this macro evaluates to a
+bit flag which indicates that when buttons \cw{x} and \cw{y} are
+both pressed simultaneously, the mid-end should consider \cw{x} to
+have priority. (In the absence of any such flags, the mid-end will
+always consider the most recently pressed button to have priority.)
+
+\dt \cw{SOLVE_ANIMATES}
+
+\dd This flag indicates that moves generated by \cw{solve()}
+(\k{backend-solve}) are candidates for animation just like any other
+move. For most games, solve moves should not be animated, so the
+mid-end doesn't even bother calling \cw{anim_length()}
+(\k{backend-anim-length}), thus saving some special-case code in
+each game. On the rare occasion that animated solve moves are
+actually required, you can set this flag.
+
+\dt \cw{REQUIRE_RBUTTON}
+
+\dd This flag indicates that the puzzle cannot be usefully played
+without the use of mouse buttons other than the left one. On some
+PDA platforms, this flag is used by the front end to enable
+right-button emulation through an appropriate gesture. Note that a
+puzzle is not required to set this just because it \e{uses} the
+right button, but only if its use of the right button is critical to
+playing the game. (Slant, for example, uses the right button to
+cycle through the three square states in the opposite order from the
+left button, and hence can manage fine without it.)
+
+\dt \cw{REQUIRE_NUMPAD}
+
+\dd This flag indicates that the puzzle cannot be usefully played
+without the use of number-key input. On some PDA platforms it causes
+an emulated number pad to appear on the screen. Similarly to
+\cw{REQUIRE_RBUTTON}, a puzzle need not specify this simply if its
+use of the number keys is not critical.
+
+\H{backend-initiative} Things a back end may do on its own initiative
+
+This section describes a couple of things that a back end may choose
+to do by calling functions elsewhere in the program, which would not
+otherwise be obvious.
+
+\S{backend-newrs} Create a random state
+
+If a back end needs random numbers at some point during normal play,
+it can create a fresh \c{random_state} by first calling
+\c{get_random_seed} (\k{frontend-get-random-seed}) and then passing
+the returned seed data to \cw{random_new()}.
+
+This is likely not to be what you want. If a puzzle needs randomness
+in the middle of play, it's likely to be more sensible to store some
+sort of random state within the \c{game_state}, so that the random
+numbers are tied to the particular game state and hence the player
+can't simply keep undoing their move until they get numbers they
+like better.
+
+This facility is currently used only in Net, to implement the
+\q{jumble} command, which sets every unlocked tile to a new random
+orientation. This randomness \e{is} a reasonable use of the feature,
+because it's non-adversarial \dash there's no advantage to the user
+in getting different random numbers.
+
+\S{backend-supersede} Supersede its own game description
+
+In response to a move, a back end is (reluctantly) permitted to call
+\cw{midend_supersede_game_desc()}:
+
+\c void midend_supersede_game_desc(midend *me,
+\c                                 char *desc, char *privdesc);
+
+When the user selects \q{New Game}, the mid-end calls
+\cw{new_desc()} (\k{backend-new-desc}) to get a new game
+description, and (as well as using that to generate an initial game
+state) stores it for the save file and for telling to the user. The
+function above overwrites that game description, and also splits it
+in two. \c{desc} becomes the new game description which is provided
+to the user on request, and is also the one used to construct a new
+initial game state if the user selects \q{Restart}. \c{privdesc} is
+a \q{private} game description, used to reconstruct the game's
+initial state when reloading.
+
+The distinction between the two, as well as the need for this
+function at all, comes from Mines. Mines begins with a blank grid
+and no idea of where the mines actually are; \cw{new_desc()} does
+almost no work in interactive mode, and simply returns a string
+encoding the \c{random_state}. When the user first clicks to open a
+tile, \e{then} Mines generates the mine positions, in such a way
+that the game is soluble from that starting point. Then it uses this
+function to supersede the random-state game description with a
+proper one. But it needs two: one containing the initial click
+location (because that's what you want to happen if you restart the
+game, and also what you want to send to a friend so that they play
+\e{the same game} as you), and one without the initial click
+location (because when you save and reload the game, you expect to
+see the same blank initial state as you had before saving).
+
+I should stress again that this function is a horrid hack. Nobody
+should use it if they're not Mines; if you think you need to use it,
+think again repeatedly in the hope of finding a better way to do
+whatever it was you needed to do.
+
+\C{drawing} The drawing API
+
+The back end function \cw{redraw()} (\k{backend-redraw}) is required
+to draw the puzzle's graphics on the window's drawing area, or on
+paper if the puzzle is printable. To do this portably, it is
+provided with a drawing API allowing it to talk directly to the
+front end. In this chapter I document that API, both for the benefit
+of back end authors trying to use it and for front end authors
+trying to implement it.
+
+The drawing API as seen by the back end is a collection of global
+functions, each of which takes a pointer to a \c{drawing} structure
+(a \q{drawing object}). These objects are supplied as parameters to
+the back end's \cw{redraw()} and \cw{print()} functions.
+
+In fact these global functions are not implemented directly by the
+front end; instead, they are implemented centrally in \c{drawing.c}
+and form a small piece of middleware. The drawing API as supplied by
+the front end is a structure containing a set of function pointers,
+plus a \cq{void *} handle which is passed to each of those
+functions. This enables a single front end to switch between
+multiple implementations of the drawing API if necessary. For
+example, the Windows API supplies a printing mechanism integrated
+into the same GDI which deals with drawing in windows, and therefore
+the same API implementation can handle both drawing and printing;
+but on Unix, the most common way for applications to print is by
+producing PostScript output directly, and although it would be
+\e{possible} to write a single (say) \cw{draw_rect()} function which
+checked a global flag to decide whether to do GTK drawing operations
+or output PostScript to a file, it's much nicer to have two separate
+functions and switch between them as appropriate.
+
+When drawing, the puzzle window is indexed by pixel coordinates,
+with the top left pixel defined as \cw{(0,0)} and the bottom right
+pixel \cw{(w-1,h-1)}, where \c{w} and \c{h} are the width and height
+values returned by the back end function \cw{compute_size()}
+(\k{backend-compute-size}).
+
+When printing, the puzzle's print area is indexed in exactly the
+same way (with an arbitrary tile size provided by the printing
+module \c{printing.c}), to facilitate sharing of code between the
+drawing and printing routines. However, when printing, puzzles may
+no longer assume that the coordinate unit has any relationship to a
+pixel; the printer's actual resolution might very well not even be
+known at print time, so the coordinate unit might be smaller or
+larger than a pixel. Puzzles' print functions should restrict
+themselves to drawing geometric shapes rather than fiddly pixel
+manipulation.
+
+\e{Puzzles' redraw functions may assume that the surface they draw
+on is persistent}. It is the responsibility of every front end to
+preserve the puzzle's window contents in the face of GUI window
+expose issues and similar. It is not permissible to request that the
+back end redraw any part of a window that it has already drawn,
+unless something has actually changed as a result of making moves in
+the puzzle.
+
+Most front ends accomplish this by having the drawing routines draw
+on a stored bitmap rather than directly on the window, and copying
+the bitmap to the window every time a part of the window needs to be
+redrawn. Therefore, it is vitally important that whenever the back
+end does any drawing it informs the front end of which parts of the
+window it has accessed, and hence which parts need repainting. This
+is done by calling \cw{draw_update()} (\k{drawing-draw-update}).
+
+Persistence of old drawing is convenient. However, a puzzle should
+be very careful about how it updates its drawing area. The problem
+is that some front ends do anti-aliased drawing: rather than simply
+choosing between leaving each pixel untouched or painting it a
+specified colour, an antialiased drawing function will \e{blend} the
+original and new colours in pixels at a figure's boundary according
+to the proportion of the pixel occupied by the figure (probably
+modified by some heuristic fudge factors). All of this produces a
+smoother appearance for curves and diagonal lines.
+
+An unfortunate effect of drawing an anti-aliased figure repeatedly
+is that the pixels around the figure's boundary come steadily more
+saturated with \q{ink} and the boundary appears to \q{spread out}.
+Worse, redrawing a figure in a different colour won't fully paint
+over the old boundary pixels, so the end result is a rather ugly
+smudge.
+
+A good strategy to avoid unpleasant anti-aliasing artifacts is to
+identify a number of rectangular areas which need to be redrawn,
+clear them to the background colour, and then redraw their contents
+from scratch, being careful all the while not to stray beyond the
+boundaries of the original rectangles. The \cw{clip()} function
+(\k{drawing-clip}) comes in very handy here. Games based on a square
+grid can often do this fairly easily. Other games may need to be
+somewhat more careful. For example, Loopy's redraw function first
+identifies portions of the display which need to be updated. Then,
+if the changes are fairly well localised, it clears and redraws a
+rectangle containing each changed area. Otherwise, it gives up and
+redraws the entire grid from scratch.
+
+It is possible to avoid clearing to background and redrawing from
+scratch if one is very careful about which drawing functions one
+uses: if a function is documented as not anti-aliasing under some
+circumstances, you can rely on each pixel in a drawing either being
+left entirely alone or being set to the requested colour, with no
+blending being performed.
+
+In the following sections I first discuss the drawing API as seen by
+the back end, and then the \e{almost} identical function-pointer
+form seen by the front end.
+
+\H{drawing-backend} Drawing API as seen by the back end
+
+This section documents the back-end drawing API, in the form of
+functions which take a \c{drawing} object as an argument.
+
+\S{drawing-draw-rect} \cw{draw_rect()}
+
+\c void draw_rect(drawing *dr, int x, int y, int w, int h,
+\c                int colour);
+
+Draws a filled rectangle in the puzzle window.
+
+\c{x} and \c{y} give the coordinates of the top left pixel of the
+rectangle. \c{w} and \c{h} give its width and height. Thus, the
+horizontal extent of the rectangle runs from \c{x} to \c{x+w-1}
+inclusive, and the vertical extent from \c{y} to \c{y+h-1}
+inclusive.
+
+\c{colour} is an integer index into the colours array returned by
+the back end function \cw{colours()} (\k{backend-colours}).
+
+There is no separate pixel-plotting function. If you want to plot a
+single pixel, the approved method is to use \cw{draw_rect()} with
+width and height set to 1.
+
+Unlike many of the other drawing functions, this function is
+guaranteed to be pixel-perfect: the rectangle will be sharply
+defined and not anti-aliased or anything like that.
+
+This function may be used for both drawing and printing.
+
+\S{drawing-draw-rect-outline} \cw{draw_rect_outline()}
+
+\c void draw_rect_outline(drawing *dr, int x, int y, int w, int h,
+\c                        int colour);
+
+Draws an outline rectangle in the puzzle window.
+
+\c{x} and \c{y} give the coordinates of the top left pixel of the
+rectangle. \c{w} and \c{h} give its width and height. Thus, the
+horizontal extent of the rectangle runs from \c{x} to \c{x+w-1}
+inclusive, and the vertical extent from \c{y} to \c{y+h-1}
+inclusive.
+
+\c{colour} is an integer index into the colours array returned by
+the back end function \cw{colours()} (\k{backend-colours}).
+
+From a back end perspective, this function may be considered to be
+part of the drawing API. However, front ends are not required to
+implement it, since it is actually implemented centrally (in
+\cw{misc.c}) as a wrapper on \cw{draw_polygon()}.
+
+This function may be used for both drawing and printing.
+
+\S{drawing-draw-line} \cw{draw_line()}
+
+\c void draw_line(drawing *dr, int x1, int y1, int x2, int y2,
+\c                int colour);
+
+Draws a straight line in the puzzle window.
+
+\c{x1} and \c{y1} give the coordinates of one end of the line.
+\c{x2} and \c{y2} give the coordinates of the other end. The line
+drawn includes both those points.
+
+\c{colour} is an integer index into the colours array returned by
+the back end function \cw{colours()} (\k{backend-colours}).
+
+Some platforms may perform anti-aliasing on this function.
+Therefore, do not assume that you can erase a line by drawing the
+same line over it in the background colour; anti-aliasing might lead
+to perceptible ghost artefacts around the vanished line. Horizontal
+and vertical lines, however, are pixel-perfect and not anti-aliased.
+
+This function may be used for both drawing and printing.
+
+\S{drawing-draw-polygon} \cw{draw_polygon()}
+
+\c void draw_polygon(drawing *dr, int *coords, int npoints,
+\c                   int fillcolour, int outlinecolour);
+
+Draws an outlined or filled polygon in the puzzle window.
+
+\c{coords} is an array of \cw{(2*npoints)} integers, containing the
+\c{x} and \c{y} coordinates of \c{npoints} vertices.
+
+\c{fillcolour} and \c{outlinecolour} are integer indices into the
+colours array returned by the back end function \cw{colours()}
+(\k{backend-colours}). \c{fillcolour} may also be \cw{-1} to
+indicate that the polygon should be outlined only.
+
+The polygon defined by the specified list of vertices is first
+filled in \c{fillcolour}, if specified, and then outlined in
+\c{outlinecolour}.
+
+\c{outlinecolour} may \e{not} be \cw{-1}; it must be a valid colour
+(and front ends are permitted to enforce this by assertion). This is
+because different platforms disagree on whether a filled polygon
+should include its boundary line or not, so drawing \e{only} a
+filled polygon would have non-portable effects. If you want your
+filled polygon not to have a visible outline, you must set
+\c{outlinecolour} to the same as \c{fillcolour}.
+
+Some platforms may perform anti-aliasing on this function.
+Therefore, do not assume that you can erase a polygon by drawing the
+same polygon over it in the background colour. Also, be prepared for
+the polygon to extend a pixel beyond its obvious bounding box as a
+result of this; if you really need it not to do this to avoid
+interfering with other delicate graphics, you should probably use
+\cw{clip()} (\k{drawing-clip}). You can rely on horizontal and
+vertical lines not being anti-aliased.
+
+This function may be used for both drawing and printing.
+
+\S{drawing-draw-circle} \cw{draw_circle()}
+
+\c void draw_circle(drawing *dr, int cx, int cy, int radius,
+\c                  int fillcolour, int outlinecolour);
+
+Draws an outlined or filled circle in the puzzle window.
+
+\c{cx} and \c{cy} give the coordinates of the centre of the circle.
+\c{radius} gives its radius. The total horizontal pixel extent of
+the circle is from \c{cx-radius+1} to \c{cx+radius-1} inclusive, and
+the vertical extent similarly around \c{cy}.
+
+\c{fillcolour} and \c{outlinecolour} are integer indices into the
+colours array returned by the back end function \cw{colours()}
+(\k{backend-colours}). \c{fillcolour} may also be \cw{-1} to
+indicate that the circle should be outlined only.
+
+The circle is first filled in \c{fillcolour}, if specified, and then
+outlined in \c{outlinecolour}.
+
+\c{outlinecolour} may \e{not} be \cw{-1}; it must be a valid colour
+(and front ends are permitted to enforce this by assertion). This is
+because different platforms disagree on whether a filled circle
+should include its boundary line or not, so drawing \e{only} a
+filled circle would have non-portable effects. If you want your
+filled circle not to have a visible outline, you must set
+\c{outlinecolour} to the same as \c{fillcolour}.
+
+Some platforms may perform anti-aliasing on this function.
+Therefore, do not assume that you can erase a circle by drawing the
+same circle over it in the background colour. Also, be prepared for
+the circle to extend a pixel beyond its obvious bounding box as a
+result of this; if you really need it not to do this to avoid
+interfering with other delicate graphics, you should probably use
+\cw{clip()} (\k{drawing-clip}).
+
+This function may be used for both drawing and printing.
+
+\S{drawing-draw-thick-line} \cw{draw_thick_line()}
+
+\c void draw_thick_line(drawing *dr, float thickness,
+\c                      float x1, float y1, float x2, float y2,
+\c                      int colour)
+
+Draws a line in the puzzle window, giving control over the line's
+thickness.
+
+\c{x1} and \c{y1} give the coordinates of one end of the line.
+\c{x2} and \c{y2} give the coordinates of the other end.
+\c{thickness} gives the thickness of the line, in pixels.
+
+Note that the coordinates and thickness are floating-point: the
+continuous coordinate system is in effect here. It's important to
+be able to address points with better-than-pixel precision in this
+case, because one can't otherwise properly express the endpoints of
+lines with both odd and even thicknesses.
+
+Some platforms may perform anti-aliasing on this function. The
+precise pixels affected by a thick-line drawing operation may vary
+between platforms, and no particular guarantees are provided.
+Indeed, even horizontal or vertical lines may be anti-aliased.
+
+This function may be used for both drawing and printing.
+
+\S{drawing-draw-text} \cw{draw_text()}
+
+\c void draw_text(drawing *dr, int x, int y, int fonttype,
+\c                int fontsize, int align, int colour, char *text);
+
+Draws text in the puzzle window.
+
+\c{x} and \c{y} give the coordinates of a point. The relation of
+this point to the location of the text is specified by \c{align},
+which is a bitwise OR of horizontal and vertical alignment flags:
+
+\dt \cw{ALIGN_VNORMAL}
+
+\dd Indicates that \c{y} is aligned with the baseline of the text.
+
+\dt \cw{ALIGN_VCENTRE}
+
+\dd Indicates that \c{y} is aligned with the vertical centre of the
+text. (In fact, it's aligned with the vertical centre of normal
+\e{capitalised} text: displaying two pieces of text with
+\cw{ALIGN_VCENTRE} at the same \cw{y}-coordinate will cause their
+baselines to be aligned with one another, even if one is an ascender
+and the other a descender.)
+
+\dt \cw{ALIGN_HLEFT}
+
+\dd Indicates that \c{x} is aligned with the left-hand end of the
+text.
+
+\dt \cw{ALIGN_HCENTRE}
+
+\dd Indicates that \c{x} is aligned with the horizontal centre of
+the text.
+
+\dt \cw{ALIGN_HRIGHT}
+
+\dd Indicates that \c{x} is aligned with the right-hand end of the
+text.
+
+\c{fonttype} is either \cw{FONT_FIXED} or \cw{FONT_VARIABLE}, for a
+monospaced or proportional font respectively. (No more detail than
+that may be specified; it would only lead to portability issues
+between different platforms.)
+
+\c{fontsize} is the desired size, in pixels, of the text. This size
+corresponds to the overall point size of the text, not to any
+internal dimension such as the cap-height.
+
+\c{colour} is an integer index into the colours array returned by
+the back end function \cw{colours()} (\k{backend-colours}).
+
+This function may be used for both drawing and printing.
+
+The character set used to encode the text passed to this function is
+specified \e{by the drawing object}, although it must be a superset
+of ASCII. If a puzzle wants to display text that is not contained in
+ASCII, it should use the \cw{text_fallback()} function
+(\k{drawing-text-fallback}) to query the drawing object for an
+appropriate representation of the characters it wants.
+
+\S{drawing-text-fallback} \cw{text_fallback()}
+
+\c char *text_fallback(drawing *dr, const char *const *strings,
+\c                     int nstrings);
+
+This function is used to request a translation of UTF-8 text into
+whatever character encoding is expected by the drawing object's
+implementation of \cw{draw_text()}.
+
+The input is a list of strings encoded in UTF-8: \cw{nstrings} gives
+the number of strings in the list, and \cw{strings[0]},
+\cw{strings[1]}, ..., \cw{strings[nstrings-1]} are the strings
+themselves.
+
+The returned string (which is dynamically allocated and must be
+freed when finished with) is derived from the first string in the
+list that the drawing object expects to be able to display reliably;
+it will consist of that string translated into the character set
+expected by \cw{draw_text()}.
+
+Drawing implementations are not required to handle anything outside
+ASCII, but are permitted to assume that \e{some} string will be
+successfully translated. So every call to this function must include
+a string somewhere in the list (presumably the last element) which
+consists of nothing but ASCII, to be used by any front end which
+cannot handle anything else.
+
+For example, if a puzzle wished to display a string including a
+multiplication sign (U+00D7 in Unicode, represented by the bytes C3
+97 in UTF-8), it might do something like this:
+
+\c static const char *const times_signs[] = { "\xC3\x97", "x" };
+\c char *times_sign = text_fallback(dr, times_signs, 2);
+\c sprintf(buffer, "%d%s%d", width, times_sign, height);
+\c draw_text(dr, x, y, font, size, align, colour, buffer);
+\c sfree(buffer);
+
+which would draw a string with a times sign in the middle on
+platforms that support it, and fall back to a simple ASCII \cq{x}
+where there was no alternative.
+
+\S{drawing-clip} \cw{clip()}
+
+\c void clip(drawing *dr, int x, int y, int w, int h);
+
+Establishes a clipping rectangle in the puzzle window.
+
+\c{x} and \c{y} give the coordinates of the top left pixel of the
+clipping rectangle. \c{w} and \c{h} give its width and height. Thus,
+the horizontal extent of the rectangle runs from \c{x} to \c{x+w-1}
+inclusive, and the vertical extent from \c{y} to \c{y+h-1}
+inclusive. (These are exactly the same semantics as
+\cw{draw_rect()}.)
+
+After this call, no drawing operation will affect anything outside
+the specified rectangle. The effect can be reversed by calling
+\cw{unclip()} (\k{drawing-unclip}). The clipping rectangle is
+pixel-perfect: pixels within the rectangle are affected as usual by
+drawing functions; pixels outside are completely untouched.
+
+Back ends should not assume that a clipping rectangle will be
+automatically cleared up by the front end if it's left lying around;
+that might work on current front ends, but shouldn't be relied upon.
+Always explicitly call \cw{unclip()}.
+
+This function may be used for both drawing and printing.
+
+\S{drawing-unclip} \cw{unclip()}
+
+\c void unclip(drawing *dr);
+
+Reverts the effect of a previous call to \cw{clip()}. After this
+call, all drawing operations will be able to affect the entire
+puzzle window again.
+
+This function may be used for both drawing and printing.
+
+\S{drawing-draw-update} \cw{draw_update()}
+
+\c void draw_update(drawing *dr, int x, int y, int w, int h);
+
+Informs the front end that a rectangular portion of the puzzle
+window has been drawn on and needs to be updated.
+
+\c{x} and \c{y} give the coordinates of the top left pixel of the
+update rectangle. \c{w} and \c{h} give its width and height. Thus,
+the horizontal extent of the rectangle runs from \c{x} to \c{x+w-1}
+inclusive, and the vertical extent from \c{y} to \c{y+h-1}
+inclusive. (These are exactly the same semantics as
+\cw{draw_rect()}.)
+
+The back end redraw function \e{must} call this function to report
+any changes it has made to the window. Otherwise, those changes may
+not become immediately visible, and may then appear at an
+unpredictable subsequent time such as the next time the window is
+covered and re-exposed.
+
+This function is only important when drawing. It may be called when
+printing as well, but doing so is not compulsory, and has no effect.
+(So if you have a shared piece of code between the drawing and
+printing routines, that code may safely call \cw{draw_update()}.)
+
+\S{drawing-status-bar} \cw{status_bar()}
+
+\c void status_bar(drawing *dr, char *text);
+
+Sets the text in the game's status bar to \c{text}. The text is copied
+from the supplied buffer, so the caller is free to deallocate or
+modify the buffer after use.
+
+(This function is not exactly a \e{drawing} function, but it shares
+with the drawing API the property that it may only be called from
+within the back end redraw function, so this is as good a place as
+any to document it.)
+
+The supplied text is filtered through the mid-end for optional
+rewriting before being passed on to the front end; the mid-end will
+prepend the current game time if the game is timed (and may in
+future perform other rewriting if it seems like a good idea).
+
+This function is for drawing only; it must never be called during
+printing.
+
+\S{drawing-blitter} Blitter functions
+
+This section describes a group of related functions which save and
+restore a section of the puzzle window. This is most commonly used
+to implement user interfaces involving dragging a puzzle element
+around the window: at the end of each call to \cw{redraw()}, if an
+object is currently being dragged, the back end saves the window
+contents under that location and then draws the dragged object, and
+at the start of the next \cw{redraw()} the first thing it does is to
+restore the background.
+
+The front end defines an opaque type called a \c{blitter}, which is
+capable of storing a rectangular area of a specified size.
+
+Blitter functions are for drawing only; they must never be called
+during printing.
+
+\S2{drawing-blitter-new} \cw{blitter_new()}
+
+\c blitter *blitter_new(drawing *dr, int w, int h);
+
+Creates a new blitter object which stores a rectangle of size \c{w}
+by \c{h} pixels. Returns a pointer to the blitter object.
+
+Blitter objects are best stored in the \c{game_drawstate}. A good
+time to create them is in the \cw{set_size()} function
+(\k{backend-set-size}), since it is at this point that you first
+know how big a rectangle they will need to save.
+
+\S2{drawing-blitter-free} \cw{blitter_free()}
+
+\c void blitter_free(drawing *dr, blitter *bl);
+
+Disposes of a blitter object. Best called in \cw{free_drawstate()}.
+(However, check that the blitter object is not \cw{NULL} before
+attempting to free it; it is possible that a draw state might be
+created and freed without ever having \cw{set_size()} called on it
+in between.)
+
+\S2{drawing-blitter-save} \cw{blitter_save()}
+
+\c void blitter_save(drawing *dr, blitter *bl, int x, int y);
+
+This is a true drawing API function, in that it may only be called
+from within the game redraw routine. It saves a rectangular portion
+of the puzzle window into the specified blitter object.
+
+\c{x} and \c{y} give the coordinates of the top left corner of the
+saved rectangle. The rectangle's width and height are the ones
+specified when the blitter object was created.
+
+This function is required to cope and do the right thing if \c{x}
+and \c{y} are out of range. (The right thing probably means saving
+whatever part of the blitter rectangle overlaps with the visible
+area of the puzzle window.)
+
+\S2{drawing-blitter-load} \cw{blitter_load()}
+
+\c void blitter_load(drawing *dr, blitter *bl, int x, int y);
+
+This is a true drawing API function, in that it may only be called
+from within the game redraw routine. It restores a rectangular
+portion of the puzzle window from the specified blitter object.
+
+\c{x} and \c{y} give the coordinates of the top left corner of the
+rectangle to be restored. The rectangle's width and height are the
+ones specified when the blitter object was created.
+
+Alternatively, you can specify both \c{x} and \c{y} as the special
+value \cw{BLITTER_FROMSAVED}, in which case the rectangle will be
+restored to exactly where it was saved from. (This is probably what
+you want to do almost all the time, if you're using blitters to
+implement draggable puzzle elements.)
+
+This function is required to cope and do the right thing if \c{x}
+and \c{y} (or the equivalent ones saved in the blitter) are out of
+range. (The right thing probably means restoring whatever part of
+the blitter rectangle overlaps with the visible area of the puzzle
+window.)
+
+If this function is called on a blitter which had previously been
+saved from a partially out-of-range rectangle, then the parts of the
+saved bitmap which were not visible at save time are undefined. If
+the blitter is restored to a different position so as to make those
+parts visible, the effect on the drawing area is undefined.
+
+\S{print-mono-colour} \cw{print_mono_colour()}
+
+\c int print_mono_colour(drawing *dr, int grey);
+
+This function allocates a colour index for a simple monochrome
+colour during printing.
+
+\c{grey} must be 0 or 1. If \c{grey} is 0, the colour returned is
+black; if \c{grey} is 1, the colour is white.
+
+\S{print-grey-colour} \cw{print_grey_colour()}
+
+\c int print_grey_colour(drawing *dr, float grey);
+
+This function allocates a colour index for a grey-scale colour
+during printing.
+
+\c{grey} may be any number between 0 (black) and 1 (white); for
+example, 0.5 indicates a medium grey.
+
+The chosen colour will be rendered to the limits of the printer's
+halftoning capability.
+
+\S{print-hatched-colour} \cw{print_hatched_colour()}
+
+\c int print_hatched_colour(drawing *dr, int hatch);
+
+This function allocates a colour index which does not represent a
+literal \e{colour}. Instead, regions shaded in this colour will be
+hatched with parallel lines. The \c{hatch} parameter defines what
+type of hatching should be used in place of this colour:
+
+\dt \cw{HATCH_SLASH}
+
+\dd This colour will be hatched by lines slanting to the right at 45
+degrees. 
+
+\dt \cw{HATCH_BACKSLASH}
+
+\dd This colour will be hatched by lines slanting to the left at 45
+degrees.
+
+\dt \cw{HATCH_HORIZ}
+
+\dd This colour will be hatched by horizontal lines.
+
+\dt \cw{HATCH_VERT}
+
+\dd This colour will be hatched by vertical lines.
+
+\dt \cw{HATCH_PLUS}
+
+\dd This colour will be hatched by criss-crossing horizontal and
+vertical lines.
+
+\dt \cw{HATCH_X}
+
+\dd This colour will be hatched by criss-crossing diagonal lines.
+
+Colours defined to use hatching may not be used for drawing lines or
+text; they may only be used for filling areas. That is, they may be
+used as the \c{fillcolour} parameter to \cw{draw_circle()} and
+\cw{draw_polygon()}, and as the colour parameter to
+\cw{draw_rect()}, but may not be used as the \c{outlinecolour}
+parameter to \cw{draw_circle()} or \cw{draw_polygon()}, or with
+\cw{draw_line()} or \cw{draw_text()}.
+
+\S{print-rgb-mono-colour} \cw{print_rgb_mono_colour()}
+
+\c int print_rgb_mono_colour(drawing *dr, float r, float g,
+\c                           float b, float grey);
+
+This function allocates a colour index for a fully specified RGB
+colour during printing.
+
+\c{r}, \c{g} and \c{b} may each be anywhere in the range from 0 to 1.
+
+If printing in black and white only, these values will be ignored,
+and either pure black or pure white will be used instead, according
+to the \q{grey} parameter. (The fallback colour is the same as the
+one which would be allocated by \cw{print_mono_colour(grey)}.)
+
+\S{print-rgb-grey-colour} \cw{print_rgb_grey_colour()}
+
+\c int print_rgb_grey_colour(drawing *dr, float r, float g,
+\c                           float b, float grey);
+
+This function allocates a colour index for a fully specified RGB
+colour during printing.
+
+\c{r}, \c{g} and \c{b} may each be anywhere in the range from 0 to 1.
+
+If printing in black and white only, these values will be ignored,
+and a shade of grey given by the \c{grey} parameter will be used
+instead. (The fallback colour is the same as the one which would be
+allocated by \cw{print_grey_colour(grey)}.)
+
+\S{print-rgb-hatched-colour} \cw{print_rgb_hatched_colour()}
+
+\c int print_rgb_hatched_colour(drawing *dr, float r, float g,
+\c                              float b, float hatched);
+
+This function allocates a colour index for a fully specified RGB
+colour during printing.
+
+\c{r}, \c{g} and \c{b} may each be anywhere in the range from 0 to 1.
+
+If printing in black and white only, these values will be ignored,
+and a form of cross-hatching given by the \c{hatch} parameter will
+be used instead; see \k{print-hatched-colour} for the possible
+values of this parameter. (The fallback colour is the same as the
+one which would be allocated by \cw{print_hatched_colour(hatch)}.)
+
+\S{print-line-width} \cw{print_line_width()}
+
+\c void print_line_width(drawing *dr, int width);
+
+This function is called to set the thickness of lines drawn during
+printing. It is meaningless in drawing: all lines drawn by
+\cw{draw_line()}, \cw{draw_circle} and \cw{draw_polygon()} are one
+pixel in thickness. However, in printing there is no clear
+definition of a pixel and so line widths must be explicitly
+specified.
+
+The line width is specified in the usual coordinate system. Note,
+however, that it is a hint only: the central printing system may
+choose to vary line thicknesses at user request or due to printer
+capabilities.
+
+\S{print-line-dotted} \cw{print_line_dotted()}
+
+\c void print_line_dotted(drawing *dr, int dotted);
+
+This function is called to toggle the drawing of dotted lines during
+printing. It is not supported during drawing.
+
+The parameter \cq{dotted} is a boolean; \cw{TRUE} means that future
+lines drawn by \cw{draw_line()}, \cw{draw_circle} and
+\cw{draw_polygon()} will be dotted, and \cw{FALSE} means that they
+will be solid.
+
+Some front ends may impose restrictions on the width of dotted
+lines. Asking for a dotted line via this front end will override any
+line width request if the front end requires it.
+
+\H{drawing-frontend} The drawing API as implemented by the front end
+
+This section describes the drawing API in the function-pointer form
+in which it is implemented by a front end.
+
+(It isn't only platform-specific front ends which implement this
+API; the platform-independent module \c{ps.c} also provides an
+implementation of it which outputs PostScript. Thus, any platform
+which wants to do PS printing can do so with minimum fuss.)
+
+The following entries all describe function pointer fields in a
+structure called \c{drawing_api}. Each of the functions takes a
+\cq{void *} context pointer, which it should internally cast back to
+a more useful type. Thus, a drawing \e{object} (\c{drawing *)}
+suitable for passing to the back end redraw or printing functions
+is constructed by passing a \c{drawing_api} and a \cq{void *} to the
+function \cw{drawing_new()} (see \k{drawing-new}).
+
+\S{drawingapi-draw-text} \cw{draw_text()}
+
+\c void (*draw_text)(void *handle, int x, int y, int fonttype,
+\c                   int fontsize, int align, int colour, char *text);
+
+This function behaves exactly like the back end \cw{draw_text()}
+function; see \k{drawing-draw-text}.
+
+\S{drawingapi-draw-rect} \cw{draw_rect()}
+
+\c void (*draw_rect)(void *handle, int x, int y, int w, int h,
+\c                   int colour);
+
+This function behaves exactly like the back end \cw{draw_rect()}
+function; see \k{drawing-draw-rect}.
+
+\S{drawingapi-draw-line} \cw{draw_line()}
+
+\c void (*draw_line)(void *handle, int x1, int y1, int x2, int y2,
+\c                   int colour);
+
+This function behaves exactly like the back end \cw{draw_line()}
+function; see \k{drawing-draw-line}.
+
+\S{drawingapi-draw-polygon} \cw{draw_polygon()}
+
+\c void (*draw_polygon)(void *handle, int *coords, int npoints,
+\c                      int fillcolour, int outlinecolour);
+
+This function behaves exactly like the back end \cw{draw_polygon()}
+function; see \k{drawing-draw-polygon}.
+
+\S{drawingapi-draw-circle} \cw{draw_circle()}
+
+\c void (*draw_circle)(void *handle, int cx, int cy, int radius,
+\c                     int fillcolour, int outlinecolour);
+
+This function behaves exactly like the back end \cw{draw_circle()}
+function; see \k{drawing-draw-circle}.
+
+\S{drawingapi-draw-thick-line} \cw{draw_thick_line()}
+
+\c void draw_thick_line(drawing *dr, float thickness,
+\c                      float x1, float y1, float x2, float y2,
+\c                      int colour)
+
+This function behaves exactly like the back end
+\cw{draw_thick_line()} function; see \k{drawing-draw-thick-line}.
+
+An implementation of this API which doesn't provide high-quality
+rendering of thick lines is permitted to define this function
+pointer to be \cw{NULL}. The middleware in \cw{drawing.c} will notice
+and provide a low-quality alternative using \cw{draw_polygon()}.
+
+\S{drawingapi-draw-update} \cw{draw_update()}
+
+\c void (*draw_update)(void *handle, int x, int y, int w, int h);
+
+This function behaves exactly like the back end \cw{draw_update()}
+function; see \k{drawing-draw-update}.
+
+An implementation of this API which only supports printing is
+permitted to define this function pointer to be \cw{NULL} rather
+than bothering to define an empty function. The middleware in
+\cw{drawing.c} will notice and avoid calling it.
+
+\S{drawingapi-clip} \cw{clip()}
+
+\c void (*clip)(void *handle, int x, int y, int w, int h);
+
+This function behaves exactly like the back end \cw{clip()}
+function; see \k{drawing-clip}.
+
+\S{drawingapi-unclip} \cw{unclip()}
+
+\c void (*unclip)(void *handle);
+
+This function behaves exactly like the back end \cw{unclip()}
+function; see \k{drawing-unclip}.
+
+\S{drawingapi-start-draw} \cw{start_draw()}
+
+\c void (*start_draw)(void *handle);
+
+This function is called at the start of drawing. It allows the front
+end to initialise any temporary data required to draw with, such as
+device contexts.
+
+Implementations of this API which do not provide drawing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless drawing is attempted.
+
+\S{drawingapi-end-draw} \cw{end_draw()}
+
+\c void (*end_draw)(void *handle);
+
+This function is called at the end of drawing. It allows the front
+end to do cleanup tasks such as deallocating device contexts and
+scheduling appropriate GUI redraw events.
+
+Implementations of this API which do not provide drawing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless drawing is attempted.
+
+\S{drawingapi-status-bar} \cw{status_bar()}
+
+\c void (*status_bar)(void *handle, char *text);
+
+This function behaves exactly like the back end \cw{status_bar()}
+function; see \k{drawing-status-bar}.
+
+Front ends implementing this function need not worry about it being
+called repeatedly with the same text; the middleware code in
+\cw{status_bar()} will take care of this.
+
+Implementations of this API which do not provide drawing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless drawing is attempted.
+
+\S{drawingapi-blitter-new} \cw{blitter_new()}
+
+\c blitter *(*blitter_new)(void *handle, int w, int h);
+
+This function behaves exactly like the back end \cw{blitter_new()}
+function; see \k{drawing-blitter-new}.
+
+Implementations of this API which do not provide drawing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless drawing is attempted.
+
+\S{drawingapi-blitter-free} \cw{blitter_free()}
+
+\c void (*blitter_free)(void *handle, blitter *bl);
+
+This function behaves exactly like the back end \cw{blitter_free()}
+function; see \k{drawing-blitter-free}.
+
+Implementations of this API which do not provide drawing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless drawing is attempted.
+
+\S{drawingapi-blitter-save} \cw{blitter_save()}
+
+\c void (*blitter_save)(void *handle, blitter *bl, int x, int y);
+
+This function behaves exactly like the back end \cw{blitter_save()}
+function; see \k{drawing-blitter-save}.
+
+Implementations of this API which do not provide drawing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless drawing is attempted.
+
+\S{drawingapi-blitter-load} \cw{blitter_load()}
+
+\c void (*blitter_load)(void *handle, blitter *bl, int x, int y);
+
+This function behaves exactly like the back end \cw{blitter_load()}
+function; see \k{drawing-blitter-load}.
+
+Implementations of this API which do not provide drawing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless drawing is attempted.
+
+\S{drawingapi-begin-doc} \cw{begin_doc()}
+
+\c void (*begin_doc)(void *handle, int pages);
+
+This function is called at the beginning of a printing run. It gives
+the front end an opportunity to initialise any required printing
+subsystem. It also provides the number of pages in advance.
+
+Implementations of this API which do not provide printing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless printing is attempted.
+
+\S{drawingapi-begin-page} \cw{begin_page()}
+
+\c void (*begin_page)(void *handle, int number);
+
+This function is called during printing, at the beginning of each
+page. It gives the page number (numbered from 1 rather than 0, so
+suitable for use in user-visible contexts).
+
+Implementations of this API which do not provide printing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless printing is attempted.
+
+\S{drawingapi-begin-puzzle} \cw{begin_puzzle()}
+
+\c void (*begin_puzzle)(void *handle, float xm, float xc,
+\c                      float ym, float yc, int pw, int ph, float wmm);
+
+This function is called during printing, just before printing a
+single puzzle on a page. It specifies the size and location of the
+puzzle on the page.
+
+\c{xm} and \c{xc} specify the horizontal position of the puzzle on
+the page, as a linear function of the page width. The front end is
+expected to multiply the page width by \c{xm}, add \c{xc} (measured
+in millimetres), and use the resulting x-coordinate as the left edge
+of the puzzle.
+
+Similarly, \c{ym} and \c{yc} specify the vertical position of the
+puzzle as a function of the page height: the page height times
+\c{ym}, plus \c{yc} millimetres, equals the desired distance from
+the top of the page to the top of the puzzle.
+
+(This unwieldy mechanism is required because not all printing
+systems can communicate the page size back to the software. The
+PostScript back end, for example, writes out PS which determines the
+page size at print time by means of calling \cq{clippath}, and
+centres the puzzles within that. Thus, exactly the same PS file
+works on A4 or on US Letter paper without needing local
+configuration, which simplifies matters.)
+
+\cw{pw} and \cw{ph} give the size of the puzzle in drawing API
+coordinates. The printing system will subsequently call the puzzle's
+own print function, which will in turn call drawing API functions in
+the expectation that an area \cw{pw} by \cw{ph} units is available
+to draw the puzzle on.
+
+Finally, \cw{wmm} gives the desired width of the puzzle in
+millimetres. (The aspect ratio is expected to be preserved, so if
+the desired puzzle height is also needed then it can be computed as
+\cw{wmm*ph/pw}.)
+
+Implementations of this API which do not provide printing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless printing is attempted.
+
+\S{drawingapi-end-puzzle} \cw{end_puzzle()}
+
+\c void (*end_puzzle)(void *handle);
+
+This function is called after the printing of a specific puzzle is
+complete.
+
+Implementations of this API which do not provide printing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless printing is attempted.
+
+\S{drawingapi-end-page} \cw{end_page()}
+
+\c void (*end_page)(void *handle, int number);
+
+This function is called after the printing of a page is finished.
+
+Implementations of this API which do not provide printing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless printing is attempted.
+
+\S{drawingapi-end-doc} \cw{end_doc()}
+
+\c void (*end_doc)(void *handle);
+
+This function is called after the printing of the entire document is
+finished. This is the moment to close files, send things to the
+print spooler, or whatever the local convention is.
+
+Implementations of this API which do not provide printing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless printing is attempted.
+
+\S{drawingapi-line-width} \cw{line_width()}
+
+\c void (*line_width)(void *handle, float width);
+
+This function is called to set the line thickness, during printing
+only. Note that the width is a \cw{float} here, where it was an
+\cw{int} as seen by the back end. This is because \cw{drawing.c} may
+have scaled it on the way past.
+
+However, the width is still specified in the same coordinate system
+as the rest of the drawing.
+
+Implementations of this API which do not provide printing services
+may define this function pointer to be \cw{NULL}; it will never be
+called unless printing is attempted.
+
+\S{drawingapi-text-fallback} \cw{text_fallback()}
+
+\c char *(*text_fallback)(void *handle, const char *const *strings,
+\c                        int nstrings);
+
+This function behaves exactly like the back end \cw{text_fallback()}
+function; see \k{drawing-text-fallback}.
+
+Implementations of this API which do not support any characters
+outside ASCII may define this function pointer to be \cw{NULL}, in
+which case the central code in \cw{drawing.c} will provide a default
+implementation.
+
+\H{drawingapi-frontend} The drawing API as called by the front end
+
+There are a small number of functions provided in \cw{drawing.c}
+which the front end needs to \e{call}, rather than helping to
+implement. They are described in this section.
+
+\S{drawing-new} \cw{drawing_new()}
+
+\c drawing *drawing_new(const drawing_api *api, midend *me,
+\c                      void *handle);
+
+This function creates a drawing object. It is passed a
+\c{drawing_api}, which is a structure containing nothing but
+function pointers; and also a \cq{void *} handle. The handle is
+passed back to each function pointer when it is called.
+
+The \c{midend} parameter is used for rewriting the status bar
+contents: \cw{status_bar()} (see \k{drawing-status-bar}) has to call
+a function in the mid-end which might rewrite the status bar text.
+If the drawing object is to be used only for printing, or if the
+game is known not to call \cw{status_bar()}, this parameter may be
+\cw{NULL}.
+
+\S{drawing-free} \cw{drawing_free()}
+
+\c void drawing_free(drawing *dr);
+
+This function frees a drawing object. Note that the \cq{void *}
+handle is not freed; if that needs cleaning up it must be done by
+the front end.
+
+\S{drawing-print-get-colour} \cw{print_get_colour()}
+
+\c void print_get_colour(drawing *dr, int colour, int printincolour,
+\c                       int *hatch, float *r, float *g, float *b)
+
+This function is called by the implementations of the drawing API
+functions when they are called in a printing context. It takes a
+colour index as input, and returns the description of the colour as
+requested by the back end.
+
+\c{printincolour} is \cw{TRUE} iff the implementation is printing in
+colour. This will alter the results returned if the colour in
+question was specified with a black-and-white fallback value.
+
+If the colour should be rendered by hatching, \c{*hatch} is filled
+with the type of hatching desired. See \k{print-grey-colour} for
+details of the values this integer can take.
+
+If the colour should be rendered as solid colour, \c{*hatch} is
+given a negative value, and \c{*r}, \c{*g} and \c{*b} are filled
+with the RGB values of the desired colour (if printing in colour),
+or all filled with the grey-scale value (if printing in black and
+white).
+
+\C{midend} The API provided by the mid-end
+
+This chapter documents the API provided by the mid-end to be called
+by the front end. You probably only need to read this if you are a
+front end implementor, i.e. you are porting Puzzles to a new
+platform. If you're only interested in writing new puzzles, you can
+safely skip this chapter.
+
+All the persistent state in the mid-end is encapsulated within a
+\c{midend} structure, to facilitate having multiple mid-ends in any
+port which supports multiple puzzle windows open simultaneously.
+Each \c{midend} is intended to handle the contents of a single
+puzzle window.
+
+\H{midend-new} \cw{midend_new()}
+
+\c midend *midend_new(frontend *fe, const game *ourgame,
+\c                    const drawing_api *drapi, void *drhandle)
+
+Allocates and returns a new mid-end structure.
+
+The \c{fe} argument is stored in the mid-end. It will be used when
+calling back to functions such as \cw{activate_timer()}
+(\k{frontend-activate-timer}), and will be passed on to the back end
+function \cw{colours()} (\k{backend-colours}).
+
+The parameters \c{drapi} and \c{drhandle} are passed to
+\cw{drawing_new()} (\k{drawing-new}) to construct a drawing object
+which will be passed to the back end function \cw{redraw()}
+(\k{backend-redraw}). Hence, all drawing-related function pointers
+defined in \c{drapi} can expect to be called with \c{drhandle} as
+their first argument.
+
+The \c{ourgame} argument points to a container structure describing
+a game back end. The mid-end thus created will only be capable of
+handling that one game. (So even in a monolithic front end
+containing all the games, this imposes the constraint that any
+individual puzzle window is tied to a single game. Unless, of
+course, you feel brave enough to change the mid-end for the window
+without closing the window...)
+
+\H{midend-free} \cw{midend_free()}
+
+\c void midend_free(midend *me);
+
+Frees a mid-end structure and all its associated data.
+
+\H{midend-tilesize} \cw{midend_tilesize()}
+
+\c int midend_tilesize(midend *me);
+
+Returns the \cq{tilesize} parameter being used to display the
+current puzzle (\k{backend-preferred-tilesize}).
+
+\H{midend-set-params} \cw{midend_set_params()}
+
+\c void midend_set_params(midend *me, game_params *params);
+
+Sets the current game parameters for a mid-end. Subsequent games
+generated by \cw{midend_new_game()} (\k{midend-new-game}) will use
+these parameters until further notice.
+
+The usual way in which the front end will have an actual
+\c{game_params} structure to pass to this function is if it had
+previously got it from \cw{midend_fetch_preset()}
+(\k{midend-fetch-preset}). Thus, this function is usually called in
+response to the user making a selection from the presets menu.
+
+\H{midend-get-params} \cw{midend_get_params()}
+
+\c game_params *midend_get_params(midend *me);
+
+Returns the current game parameters stored in this mid-end.
+
+The returned value is dynamically allocated, and should be freed
+when finished with by passing it to the game's own
+\cw{free_params()} function (see \k{backend-free-params}).
+
+\H{midend-size} \cw{midend_size()}
+
+\c void midend_size(midend *me, int *x, int *y, int user_size);
+
+Tells the mid-end to figure out its window size.
+
+On input, \c{*x} and \c{*y} should contain the maximum or requested
+size for the window. (Typically this will be the size of the screen
+that the window has to fit on, or similar.) The mid-end will
+repeatedly call the back end function \cw{compute_size()}
+(\k{backend-compute-size}), searching for a tile size that best
+satisfies the requirements. On exit, \c{*x} and \c{*y} will contain
+the size needed for the puzzle window's drawing area. (It is of
+course up to the front end to adjust this for any additional window
+furniture such as menu bars and window borders, if necessary. The
+status bar is also not included in this size.)
+
+Use \c{user_size} to indicate whether \c{*x} and \c{*y} are a
+requested size, or just a maximum size.
+
+If \c{user_size} is set to \cw{TRUE}, the mid-end will treat the
+input size as a request, and will pick a tile size which
+approximates it \e{as closely as possible}, going over the game's
+preferred tile size if necessary to achieve this. The mid-end will
+also use the resulting tile size as its preferred one until further
+notice, on the assumption that this size was explicitly requested
+by the user. Use this option if you want your front end to support
+dynamic resizing of the puzzle window with automatic scaling of the
+puzzle to fit.
+
+If \c{user_size} is set to \cw{FALSE}, then the game's tile size
+will never go over its preferred one, although it may go under in
+order to fit within the maximum bounds specified by \c{*x} and
+\c{*y}. This is the recommended approach when opening a new window
+at default size: the game will use its preferred size unless it has
+to use a smaller one to fit on the screen. If the tile size is
+shrunk for this reason, the change will not persist; if a smaller
+grid is subsequently chosen, the tile size will recover.
+
+The mid-end will try as hard as it can to return a size which is
+less than or equal to the input size, in both dimensions. In extreme
+circumstances it may fail (if even the lowest possible tile size
+gives window dimensions greater than the input), in which case it
+will return a size greater than the input size. Front ends should be
+prepared for this to happen (i.e. don't crash or fail an assertion),
+but may handle it in any way they see fit: by rejecting the game
+parameters which caused the problem, by opening a window larger than
+the screen regardless of inconvenience, by introducing scroll bars
+on the window, by drawing on a large bitmap and scaling it into a
+smaller window, or by any other means you can think of. It is likely
+that when the tile size is that small the game will be unplayable
+anyway, so don't put \e{too} much effort into handling it
+creatively.
+
+If your platform has no limit on window size (or if you're planning
+to use scroll bars for large puzzles), you can pass dimensions of
+\cw{INT_MAX} as input to this function. You should probably not do
+that \e{and} set the \c{user_size} flag, though!
+
+The midend relies on the frontend calling \cw{midend_new_game()}
+(\k{midend-new-game}) before calling \cw{midend_size()}.
+
+\H{midend-reset-tilesize} \cw{midend_reset_tilesize()}
+
+\c void midend_reset_tilesize(midend *me);
+
+This function resets the midend's preferred tile size to that of the
+standard puzzle.
+
+As discussed in \k{midend-size}, puzzle resizes are typically
+'sticky', in that once the user has dragged the puzzle to a different
+window size, the resulting tile size will be remembered and used when
+the puzzle configuration changes. If you \e{don't} want that, e.g. if
+you want to provide a command to explicitly reset the puzzle size back
+to its default, then you can call this just before calling
+\cw{midend_size()} (which, in turn, you would probably call with
+\c{user_size} set to \cw{FALSE}).
+
+\H{midend-new-game} \cw{midend_new_game()}
+
+\c void midend_new_game(midend *me);
+
+Causes the mid-end to begin a new game. Normally the game will be a
+new randomly generated puzzle. However, if you have previously
+called \cw{midend_game_id()} or \cw{midend_set_config()}, the game
+generated might be dictated by the results of those functions. (In
+particular, you \e{must} call \cw{midend_new_game()} after calling
+either of those functions, or else no immediate effect will be
+visible.)
+
+You will probably need to call \cw{midend_size()} after calling this
+function, because if the game parameters have been changed since the
+last new game then the window size might need to change. (If you
+know the parameters \e{haven't} changed, you don't need to do this.)
+
+This function will create a new \c{game_drawstate}, but does not
+actually perform a redraw (since you often need to call
+\cw{midend_size()} before the redraw can be done). So after calling
+this function and after calling \cw{midend_size()}, you should then
+call \cw{midend_redraw()}. (It is not necessary to call
+\cw{midend_force_redraw()}; that will discard the draw state and
+create a fresh one, which is unnecessary in this case since there's
+a fresh one already. It would work, but it's usually excessive.)
+
+\H{midend-restart-game} \cw{midend_restart_game()}
+
+\c void midend_restart_game(midend *me);
+
+This function causes the current game to be restarted. This is done
+by placing a new copy of the original game state on the end of the
+undo list (so that an accidental restart can be undone).
+
+This function automatically causes a redraw, i.e. the front end can
+expect its drawing API to be called from \e{within} a call to this
+function. Some back ends require that \cw{midend_size()}
+(\k{midend-size}) is called before \cw{midend_restart_game()}.
+
+\H{midend-force-redraw} \cw{midend_force_redraw()}
+
+\c void midend_force_redraw(midend *me);
+
+Forces a complete redraw of the puzzle window, by means of
+discarding the current \c{game_drawstate} and creating a new one
+from scratch before calling the game's \cw{redraw()} function.
+
+The front end can expect its drawing API to be called from within a
+call to this function. Some back ends require that \cw{midend_size()}
+(\k{midend-size}) is called before \cw{midend_force_redraw()}.
+
+\H{midend-redraw} \cw{midend_redraw()}
+
+\c void midend_redraw(midend *me);
+
+Causes a partial redraw of the puzzle window, by means of simply
+calling the game's \cw{redraw()} function. (That is, the only things
+redrawn will be things that have changed since the last redraw.)
+
+The front end can expect its drawing API to be called from within a
+call to this function. Some back ends require that \cw{midend_size()}
+(\k{midend-size}) is called before \cw{midend_redraw()}.
+
+\H{midend-process-key} \cw{midend_process_key()}
+
+\c int midend_process_key(midend *me, int x, int y, int button);
+
+The front end calls this function to report a mouse or keyboard
+event. The parameters \c{x}, \c{y} and \c{button} are almost
+identical to the ones passed to the back end function
+\cw{interpret_move()} (\k{backend-interpret-move}), except that the
+front end is \e{not} required to provide the guarantees about mouse
+event ordering. The mid-end will sort out multiple simultaneous
+button presses and changes of button; the front end's responsibility
+is simply to pass on the mouse events it receives as accurately as
+possible.
+
+(Some platforms may need to emulate absent mouse buttons by means of
+using a modifier key such as Shift with another mouse button. This
+tends to mean that if Shift is pressed or released in the middle of
+a mouse drag, the mid-end will suddenly stop receiving, say,
+\cw{LEFT_DRAG} events and start receiving \cw{RIGHT_DRAG}s, with no
+intervening button release or press events. This too is something
+which the mid-end will sort out for you; the front end has no
+obligation to maintain sanity in this area.)
+
+The front end \e{should}, however, always eventually send some kind
+of button release. On some platforms this requires special effort:
+Windows, for example, requires a call to the system API function
+\cw{SetCapture()} in order to ensure that your window receives a
+mouse-up event even if the pointer has left the window by the time
+the mouse button is released. On any platform that requires this
+sort of thing, the front end \e{is} responsible for doing it.
+
+Calling this function is very likely to result in calls back to the
+front end's drawing API and/or \cw{activate_timer()}
+(\k{frontend-activate-timer}).
+
+The return value from \cw{midend_process_key()} is non-zero, unless
+the effect of the keypress was to request termination of the
+program. A front end should shut down the puzzle in response to a
+zero return.
+
+\H{midend-colours} \cw{midend_colours()}
+
+\c float *midend_colours(midend *me, int *ncolours);
+
+Returns an array of the colours required by the game, in exactly the
+same format as that returned by the back end function \cw{colours()}
+(\k{backend-colours}). Front ends should call this function rather
+than calling the back end's version directly, since the mid-end adds
+standard customisation facilities. (At the time of writing, those
+customisation facilities are implemented hackily by means of
+environment variables, but it's not impossible that they may become
+more full and formal in future.)
+
+\H{midend-timer} \cw{midend_timer()}
+
+\c void midend_timer(midend *me, float tplus);
+
+If the mid-end has called \cw{activate_timer()}
+(\k{frontend-activate-timer}) to request regular callbacks for
+purposes of animation or timing, this is the function the front end
+should call on a regular basis. The argument \c{tplus} gives the
+time, in seconds, since the last time either this function was
+called or \cw{activate_timer()} was invoked.
+
+One of the major purposes of timing in the mid-end is to perform
+move animation. Therefore, calling this function is very likely to
+result in calls back to the front end's drawing API.
+
+\H{midend-num-presets} \cw{midend_num_presets()}
+
+\c int midend_num_presets(midend *me);
+
+Returns the number of game parameter presets supplied by this game.
+Front ends should use this function and \cw{midend_fetch_preset()}
+to configure their presets menu rather than calling the back end
+directly, since the mid-end adds standard customisation facilities.
+(At the time of writing, those customisation facilities are
+implemented hackily by means of environment variables, but it's not
+impossible that they may become more full and formal in future.)
+
+\H{midend-fetch-preset} \cw{midend_fetch_preset()}
+
+\c void midend_fetch_preset(midend *me, int n,
+\c                          char **name, game_params **params);
+
+Returns one of the preset game parameter structures for the game. On
+input \c{n} must be a non-negative integer and less than the value
+returned from \cw{midend_num_presets()}. On output, \c{*name} is set
+to an ASCII string suitable for entering in the game's presets menu,
+and \c{*params} is set to the corresponding \c{game_params}
+structure.
+
+Both of the two output values are dynamically allocated, but they
+are owned by the mid-end structure: the front end should not ever
+free them directly, because they will be freed automatically during
+\cw{midend_free()}.
+
+\H{midend-which-preset} \cw{midend_which_preset()}
+
+\c int midend_which_preset(midend *me);
+
+Returns the numeric index of the preset game parameter structure
+which matches the current game parameters, or a negative number if
+no preset matches. Front ends could use this to maintain a tick
+beside one of the items in the menu (or tick the \q{Custom} option
+if the return value is less than zero).
+
+\H{midend-wants-statusbar} \cw{midend_wants_statusbar()}
+
+\c int midend_wants_statusbar(midend *me);
+
+This function returns \cw{TRUE} if the puzzle has a use for a
+textual status line (to display score, completion status, currently
+active tiles, time, or anything else).
+
+Front ends should call this function rather than talking directly to
+the back end.
+
+\H{midend-get-config} \cw{midend_get_config()}
+
+\c config_item *midend_get_config(midend *me, int which,
+\c                                char **wintitle);
+
+Returns a dialog box description for user configuration.
+
+On input, \cw{which} should be set to one of three values, which
+select which of the various dialog box descriptions is returned:
+
+\dt \cw{CFG_SETTINGS}
+
+\dd Requests the GUI parameter configuration box generated by the
+puzzle itself. This should be used when the user selects \q{Custom}
+from the game types menu (or equivalent). The mid-end passes this
+request on to the back end function \cw{configure()}
+(\k{backend-configure}).
+
+\dt \cw{CFG_DESC}
+
+\dd Requests a box suitable for entering a descriptive game ID (and
+viewing the existing one). The mid-end generates this dialog box
+description itself. This should be used when the user selects
+\q{Specific} from the game menu (or equivalent).
+
+\dt \cw{CFG_SEED}
+
+\dd Requests a box suitable for entering a random-seed game ID (and
+viewing the existing one). The mid-end generates this dialog box
+description itself. This should be used when the user selects
+\q{Random Seed} from the game menu (or equivalent).
+
+The returned value is an array of \cw{config_item}s, exactly as
+described in \k{backend-configure}. Another returned value is an
+ASCII string giving a suitable title for the configuration window,
+in \c{*wintitle}.
+
+Both returned values are dynamically allocated and will need to be
+freed. The window title can be freed in the obvious way; the
+\cw{config_item} array is a slightly complex structure, so a utility
+function \cw{free_cfg()} is provided to free it for you. See
+\k{utils-free-cfg}.
+
+(Of course, you will probably not want to free the \cw{config_item}
+array until the dialog box is dismissed, because before then you
+will probably need to pass it to \cw{midend_set_config}.)
+
+\H{midend-set-config} \cw{midend_set_config()}
+
+\c char *midend_set_config(midend *me, int which,
+\c                         config_item *cfg);
+
+Passes the mid-end the results of a configuration dialog box.
+\c{which} should have the same value which it had when
+\cw{midend_get_config()} was called; \c{cfg} should be the array of
+\c{config_item}s returned from \cw{midend_get_config()}, modified to
+contain the results of the user's editing operations.
+
+This function returns \cw{NULL} on success, or otherwise (if the
+configuration data was in some way invalid) an ASCII string
+containing an error message suitable for showing to the user.
+
+If the function succeeds, it is likely that the game parameters will
+have been changed and it is certain that a new game will be
+requested. The front end should therefore call
+\cw{midend_new_game()}, and probably also re-think the window size
+using \cw{midend_size()} and eventually perform a refresh using
+\cw{midend_redraw()}.
+
+\H{midend-game-id} \cw{midend_game_id()}
+
+\c char *midend_game_id(midend *me, char *id);
+
+Passes the mid-end a string game ID (of any of the valid forms
+\cq{params}, \cq{params:description} or \cq{params#seed}) which the
+mid-end will process and use for the next generated game.
+
+This function returns \cw{NULL} on success, or otherwise (if the
+configuration data was in some way invalid) an ASCII string
+containing an error message (not dynamically allocated) suitable for
+showing to the user. In the event of an error, the mid-end's
+internal state will be left exactly as it was before the call.
+
+If the function succeeds, it is likely that the game parameters will
+have been changed and it is certain that a new game will be
+requested. The front end should therefore call
+\cw{midend_new_game()}, and probably also re-think the window size
+using \cw{midend_size()} and eventually case a refresh using
+\cw{midend_redraw()}.
+
+\H{midend-get-game-id} \cw{midend_get_game_id()}
+
+\c char *midend_get_game_id(midend *me)
+
+Returns a descriptive game ID (i.e. one in the form
+\cq{params:description}) describing the game currently active in the
+mid-end. The returned string is dynamically allocated.
+
+\H{midend-get-random-seed} \cw{midend_get_random_seed()}
+
+\c char *midend_get_random_seed(midend *me)
+
+Returns a random game ID (i.e. one in the form \cq{params#seedstring})
+describing the game currently active in the mid-end, if there is one.
+If the game was created by entering a description, no random seed will
+currently exist and this function will return \cw{NULL}.
+
+The returned string, if it is non-\cw{NULL}, is dynamically allocated.
+
+\H{midend-can-format-as-text-now} \cw{midend_can_format_as_text_now()}
+
+\c int midend_can_format_as_text_now(midend *me);
+
+Returns \cw{TRUE} if the game code is capable of formatting puzzles
+of the currently selected game type as ASCII.
+
+If this returns \cw{FALSE}, then \cw{midend_text_format()}
+(\k{midend-text-format}) will return \cw{NULL}.
+
+\H{midend-text-format} \cw{midend_text_format()}
+
+\c char *midend_text_format(midend *me);
+
+Formats the current game's current state as ASCII text suitable for
+copying to the clipboard. The returned string is dynamically
+allocated.
+
+If the game's \c{can_format_as_text_ever} flag is \cw{FALSE}, or if
+its \cw{can_format_as_text_now()} function returns \cw{FALSE}, then
+this function will return \cw{NULL}.
+
+If the returned string contains multiple lines (which is likely), it
+will use the normal C line ending convention (\cw{\\n} only). On
+platforms which use a different line ending convention for data in
+the clipboard, it is the front end's responsibility to perform the
+conversion.
+
+\H{midend-solve} \cw{midend_solve()}
+
+\c char *midend_solve(midend *me);
+
+Requests the mid-end to perform a Solve operation.
+
+On success, \cw{NULL} is returned. On failure, an error message (not
+dynamically allocated) is returned, suitable for showing to the
+user.
+
+The front end can expect its drawing API and/or
+\cw{activate_timer()} to be called from within a call to this
+function.  Some back ends require that \cw{midend_size()}
+(\k{midend-size}) is called before \cw{midend_solve()}.
+
+\H{midend-status} \cw{midend_status()}
+
+\c int midend_status(midend *me);
+
+This function returns +1 if the midend is currently displaying a game
+in a solved state, -1 if the game is in a permanently lost state, or 0
+otherwise. This function just calls the back end's \cw{status()}
+function. Front ends may wish to use this as a cue to proactively
+offer the option of starting a new game.
+
+(See \k{backend-status} for more detail about the back end's
+\cw{status()} function and discussion of what should count as which
+status code.)
+
+\H{midend-can-undo} \cw{midend_can_undo()}
+
+\c int midend_can_undo(midend *me);
+
+Returns \cw{TRUE} if the midend is currently in a state where the undo
+operation is meaningful (i.e. at least one position exists on the undo
+chain before the present one). Front ends may wish to use this to
+visually activate and deactivate an undo button.
+
+\H{midend-can-redo} \cw{midend_can_redo()}
+
+\c int midend_can_redo(midend *me);
+
+Returns \cw{TRUE} if the midend is currently in a state where the redo
+operation is meaningful (i.e. at least one position exists on the redo
+chain after the present one). Front ends may wish to use this to
+visually activate and deactivate a redo button.
+
+\H{midend-serialise} \cw{midend_serialise()}
+
+\c void midend_serialise(midend *me,
+\c                       void (*write)(void *ctx, void *buf, int len),
+\c                       void *wctx);
+
+Calling this function causes the mid-end to convert its entire
+internal state into a long ASCII text string, and to pass that
+string (piece by piece) to the supplied \c{write} function.
+
+Desktop implementations can use this function to save a game in any
+state (including half-finished) to a disk file, by supplying a
+\c{write} function which is a wrapper on \cw{fwrite()} (or local
+equivalent). Other implementations may find other uses for it, such
+as compressing the large and sprawling mid-end state into a
+manageable amount of memory when a palmtop application is suspended
+so that another one can run; in this case \cw{write} might want to
+write to a memory buffer rather than a file. There may be other uses
+for it as well.
+
+This function will call back to the supplied \c{write} function a
+number of times, with the first parameter (\c{ctx}) equal to
+\c{wctx}, and the other two parameters pointing at a piece of the
+output string.
+
+\H{midend-deserialise} \cw{midend_deserialise()}
+
+\c char *midend_deserialise(midend *me,
+\c                          int (*read)(void *ctx, void *buf, int len),
+\c                          void *rctx);
+
+This function is the counterpart to \cw{midend_serialise()}. It
+calls the supplied \cw{read} function repeatedly to read a quantity
+of data, and attempts to interpret that data as a serialised mid-end
+as output by \cw{midend_serialise()}.
+
+The \cw{read} function is called with the first parameter (\c{ctx})
+equal to \c{rctx}, and should attempt to read \c{len} bytes of data
+into the buffer pointed to by \c{buf}. It should return \cw{FALSE}
+on failure or \cw{TRUE} on success. It should not report success
+unless it has filled the entire buffer; on platforms which might be
+reading from a pipe or other blocking data source, \c{read} is
+responsible for looping until the whole buffer has been filled.
+
+If the de-serialisation operation is successful, the mid-end's
+internal data structures will be replaced by the results of the
+load, and \cw{NULL} will be returned. Otherwise, the mid-end's state
+will be completely unchanged and an error message (typically some
+variation on \q{save file is corrupt}) will be returned. As usual,
+the error message string is not dynamically allocated.
+
+If this function succeeds, it is likely that the game parameters
+will have been changed. The front end should therefore probably
+re-think the window size using \cw{midend_size()}, and probably
+cause a refresh using \cw{midend_redraw()}.
+
+Because each mid-end is tied to a specific game back end, this
+function will fail if you attempt to read in a save file generated by
+a different game from the one configured in this mid-end, even if your
+application is a monolithic one containing all the puzzles. See
+\k{identify-game} for a helper function which will allow you to
+identify a save file before you instantiate your mid-end in the first
+place.
+
+\H{identify-game} \cw{identify_game()}
+
+\c char *identify_game(char **name,
+\c                     int (*read)(void *ctx, void *buf, int len),
+\c                     void *rctx);
+
+This function examines a serialised midend stream, of the same kind
+used by \cw{midend_serialise()} and \cw{midend_deserialise()}, and
+returns the \cw{name} field of the game back end from which it was
+saved.
+
+You might want this if your front end was a monolithic one containing
+all the puzzles, and you wanted to be able to load an arbitrary save
+file and automatically switch to the right game. Probably your next
+step would be to iterate through \cw{gamelist} (\k{frontend-backend})
+looking for a game structure whose \cw{name} field matched the
+returned string, and give an error if you didn't find one.
+
+On success, the return value of this function is \cw{NULL}, and the
+game name string is written into \cw{*name}. The caller should free
+that string after using it.
+
+On failure, \cw{*name} is \cw{NULL}, and the return value is an error
+message (which does not need freeing at all).
+
+(This isn't strictly speaking a midend function, since it doesn't
+accept or return a pointer to a midend. You'd probably call it just
+\e{before} deciding what kind of midend you wanted to instantiate.)
+
+\H{midend-request-id-changes} \cw{midend_request_id_changes()}
+
+\c void midend_request_id_changes(midend *me,
+\c                                void (*notify)(void *), void *ctx);
+
+This function is called by the front end to request notification by
+the mid-end when the current game IDs (either descriptive or
+random-seed) change. This can occur as a result of keypresses ('n' for
+New Game, for example) or when a puzzle supersedes its game
+description (see \k{backend-supersede}). After this function is
+called, any change of the game ids will cause the mid-end to call
+\cw{notify(ctx)} after the change.
+
+This is for use by puzzles which want to present the game description
+to the user constantly (e.g. as an HTML hyperlink) instead of only
+showing it when the user explicitly requests it.
+
+This is a function I anticipate few front ends needing to implement,
+so I make it a callback rather than a static function in order to
+relieve most front ends of the need to provide an empty
+implementation.
+
+\H{frontend-backend} Direct reference to the back end structure by
+the front end
+
+Although \e{most} things the front end needs done should be done by
+calling the mid-end, there are a few situations in which the front
+end needs to refer directly to the game back end structure.
+
+The most obvious of these is
+
+\b passing the game back end as a parameter to \cw{midend_new()}.
+
+There are a few other back end features which are not wrapped by the
+mid-end because there didn't seem much point in doing so:
+
+\b fetching the \c{name} field to use in window titles and similar
+
+\b reading the \c{can_configure}, \c{can_solve} and
+\c{can_format_as_text_ever} fields to decide whether to add those
+items to the menu bar or equivalent
+
+\b reading the \c{winhelp_topic} field (Windows only)
+
+\b the GTK front end provides a \cq{--generate} command-line option
+which directly calls the back end to do most of its work. This is
+not really part of the main front end code, though, and I'm not sure
+it counts.
+
+In order to find the game back end structure, the front end does one
+of two things:
+
+\b If the particular front end is compiling a separate binary per
+game, then the back end structure is a global variable with the
+standard name \cq{thegame}:
+
+\lcont{
+
+\c extern const game thegame;
+
+}
+
+\b If the front end is compiled as a monolithic application
+containing all the puzzles together (in which case the preprocessor
+symbol \cw{COMBINED} must be defined when compiling most of the code
+base), then there will be two global variables defined:
+
+\lcont{
+
+\c extern const game *gamelist[];
+\c extern const int gamecount;
+
+\c{gamelist} will be an array of \c{gamecount} game structures,
+declared in the automatically constructed source module \c{list.c}.
+The application should search that array for the game it wants,
+probably by reaching into each game structure and looking at its
+\c{name} field.
+
+}
+
+\H{frontend-api} Mid-end to front-end calls
+
+This section describes the small number of functions which a front
+end must provide to be called by the mid-end or other standard
+utility modules.
+
+\H{frontend-get-random-seed} \cw{get_random_seed()}
+
+\c void get_random_seed(void **randseed, int *randseedsize);
+
+This function is called by a new mid-end, and also occasionally by
+game back ends. Its job is to return a piece of data suitable for
+using as a seed for initialisation of a new \c{random_state}.
+
+On exit, \c{*randseed} should be set to point at a newly allocated
+piece of memory containing some seed data, and \c{*randseedsize}
+should be set to the length of that data.
+
+A simple and entirely adequate implementation is to return a piece
+of data containing the current system time at the highest
+conveniently available resolution.
+
+\H{frontend-activate-timer} \cw{activate_timer()}
+
+\c void activate_timer(frontend *fe);
+
+This is called by the mid-end to request that the front end begin
+calling it back at regular intervals.
+
+The timeout interval is left up to the front end; the finer it is,
+the smoother move animations will be, but the more CPU time will be
+used. Current front ends use values around 20ms (i.e. 50Hz).
+
+After this function is called, the mid-end will expect to receive
+calls to \cw{midend_timer()} on a regular basis.
+
+\H{frontend-deactivate-timer} \cw{deactivate_timer()}
+
+\c void deactivate_timer(frontend *fe);
+
+This is called by the mid-end to request that the front end stop
+calling \cw{midend_timer()}.
+
+\H{frontend-fatal} \cw{fatal()}
+
+\c void fatal(char *fmt, ...);
+
+This is called by some utility functions if they encounter a
+genuinely fatal error such as running out of memory. It is a
+variadic function in the style of \cw{printf()}, and is expected to
+show the formatted error message to the user any way it can and then
+terminate the application. It must not return.
+
+\H{frontend-default-colour} \cw{frontend_default_colour()}
+
+\c void frontend_default_colour(frontend *fe, float *output);
+
+This function expects to be passed a pointer to an array of three
+\cw{float}s. It returns the platform's local preferred background
+colour in those three floats, as red, green and blue values (in that
+order) ranging from \cw{0.0} to \cw{1.0}.
+
+This function should only ever be called by the back end function
+\cw{colours()} (\k{backend-colours}). (Thus, it isn't a
+\e{midend}-to-frontend function as such, but there didn't seem to be
+anywhere else particularly good to put it. Sorry.)
+
+\C{utils} Utility APIs
+
+This chapter documents a variety of utility APIs provided for the
+general use of the rest of the Puzzles code.
+
+\H{utils-random} Random number generation
+
+Platforms' local random number generators vary widely in quality and
+seed size. Puzzles therefore supplies its own high-quality random
+number generator, with the additional advantage of giving the same
+results if fed the same seed data on different platforms. This
+allows game random seeds to be exchanged between different ports of
+Puzzles and still generate the same games.
+
+Unlike the ANSI C \cw{rand()} function, the Puzzles random number
+generator has an \e{explicit} state object called a
+\c{random_state}. One of these is managed by each mid-end, for
+example, and passed to the back end to generate a game with.
+
+\S{utils-random-init} \cw{random_new()}
+
+\c random_state *random_new(char *seed, int len);
+
+Allocates, initialises and returns a new \c{random_state}. The input
+data is used as the seed for the random number stream (i.e. using
+the same seed at a later time will generate the same stream).
+
+The seed data can be any data at all; there is no requirement to use
+printable ASCII, or NUL-terminated strings, or anything like that.
+
+\S{utils-random-copy} \cw{random_copy()}
+
+\c random_state *random_copy(random_state *tocopy);
+
+Allocates a new \c{random_state}, copies the contents of another
+\c{random_state} into it, and returns the new state.  If exactly the
+same sequence of functions is subseqently called on both the copy and
+the original, the results will be identical.  This may be useful for
+speculatively performing some operation using a given random state,
+and later replaying that operation precisely.
+
+\S{utils-random-free} \cw{random_free()}
+
+\c void random_free(random_state *state);
+
+Frees a \c{random_state}.
+
+\S{utils-random-bits} \cw{random_bits()}
+
+\c unsigned long random_bits(random_state *state, int bits);
+
+Returns a random number from 0 to \cw{2^bits-1} inclusive. \c{bits}
+should be between 1 and 32 inclusive.
+
+\S{utils-random-upto} \cw{random_upto()}
+
+\c unsigned long random_upto(random_state *state, unsigned long limit);
+
+Returns a random number from 0 to \cw{limit-1} inclusive.
+
+\S{utils-random-state-encode} \cw{random_state_encode()}
+
+\c char *random_state_encode(random_state *state);
+
+Encodes the entire contents of a \c{random_state} in printable
+ASCII. Returns a dynamically allocated string containing that
+encoding. This can subsequently be passed to
+\cw{random_state_decode()} to reconstruct the same \c{random_state}.
+
+\S{utils-random-state-decode} \cw{random_state_decode()}
+
+\c random_state *random_state_decode(char *input);
+
+Decodes a string generated by \cw{random_state_encode()} and
+reconstructs an equivalent \c{random_state} to the one encoded, i.e.
+it should produce the same stream of random numbers.
+
+This function has no error reporting; if you pass it an invalid
+string it will simply generate an arbitrary random state, which may
+turn out to be noticeably non-random.
+
+\S{utils-shuffle} \cw{shuffle()}
+
+\c void shuffle(void *array, int nelts, int eltsize, random_state *rs);
+
+Shuffles an array into a random order. The interface is much like
+ANSI C \cw{qsort()}, except that there's no need for a compare
+function.
+
+\c{array} is a pointer to the first element of the array. \c{nelts}
+is the number of elements in the array; \c{eltsize} is the size of a
+single element (typically measured using \c{sizeof}). \c{rs} is a
+\c{random_state} used to generate all the random numbers for the
+shuffling process.
+
+\H{utils-alloc} Memory allocation
+
+Puzzles has some central wrappers on the standard memory allocation
+functions, which provide compile-time type checking, and run-time
+error checking by means of quitting the application if it runs out
+of memory. This doesn't provide the best possible recovery from
+memory shortage, but on the other hand it greatly simplifies the
+rest of the code, because nothing else anywhere needs to worry about
+\cw{NULL} returns from allocation.
+
+\S{utils-snew} \cw{snew()}
+
+\c var = snew(type);
+\e iii        iiii
+
+This macro takes a single argument which is a \e{type name}. It
+allocates space for one object of that type. If allocation fails it
+will call \cw{fatal()} and not return; so if it does return, you can
+be confident that its return value is non-\cw{NULL}.
+
+The return value is cast to the specified type, so that the compiler
+will type-check it against the variable you assign it into. Thus,
+this ensures you don't accidentally allocate memory the size of the
+wrong type and assign it into a variable of the right one (or vice
+versa!).
+
+\S{utils-snewn} \cw{snewn()}
+
+\c var = snewn(n, type);
+\e iii         i  iiii
+
+This macro is the array form of \cw{snew()}. It takes two arguments;
+the first is a number, and the second is a type name. It allocates
+space for that many objects of that type, and returns a type-checked
+non-\cw{NULL} pointer just as \cw{snew()} does.
+
+\S{utils-sresize} \cw{sresize()}
+
+\c var = sresize(var, n, type);
+\e iii           iii  i  iiii
+
+This macro is a type-checked form of \cw{realloc()}. It takes three
+arguments: an input memory block, a new size in elements, and a
+type. It re-sizes the input memory block to a size sufficient to
+contain that many elements of that type. It returns a type-checked
+non-\cw{NULL} pointer, like \cw{snew()} and \cw{snewn()}.
+
+The input memory block can be \cw{NULL}, in which case this function
+will behave exactly like \cw{snewn()}. (In principle any
+ANSI-compliant \cw{realloc()} implementation ought to cope with
+this, but I've never quite trusted it to work everywhere.)
+
+\S{utils-sfree} \cw{sfree()}
+
+\c void sfree(void *p);
+
+This function is pretty much equivalent to \cw{free()}. It is
+provided with a dynamically allocated block, and frees it.
+
+The input memory block can be \cw{NULL}, in which case this function
+will do nothing. (In principle any ANSI-compliant \cw{free()}
+implementation ought to cope with this, but I've never quite trusted
+it to work everywhere.)
+
+\S{utils-dupstr} \cw{dupstr()}
+
+\c char *dupstr(const char *s);
+
+This function dynamically allocates a duplicate of a C string. Like
+the \cw{snew()} functions, it guarantees to return non-\cw{NULL} or
+not return at all.
+
+(Many platforms provide the function \cw{strdup()}. As well as
+guaranteeing never to return \cw{NULL}, my version has the advantage
+of being defined \e{everywhere}, rather than inconveniently not
+quite everywhere.)
+
+\S{utils-free-cfg} \cw{free_cfg()}
+
+\c void free_cfg(config_item *cfg);
+
+This function correctly frees an array of \c{config_item}s,
+including walking the array until it gets to the end and freeing
+precisely those \c{sval} fields which are expected to be dynamically
+allocated.
+
+(See \k{backend-configure} for details of the \c{config_item}
+structure.)
+
+\H{utils-tree234} Sorted and counted tree functions
+
+Many games require complex algorithms for generating random puzzles,
+and some require moderately complex algorithms even during play. A
+common requirement during these algorithms is for a means of
+maintaining sorted or unsorted lists of items, such that items can
+be removed and added conveniently.
+
+For general use, Puzzles provides the following set of functions
+which maintain 2-3-4 trees in memory. (A 2-3-4 tree is a balanced
+tree structure, with the property that all lookups, insertions,
+deletions, splits and joins can be done in \cw{O(log N)} time.)
+
+All these functions expect you to be storing a tree of \c{void *}
+pointers. You can put anything you like in those pointers.
+
+By the use of per-node element counts, these tree structures have
+the slightly unusual ability to look elements up by their numeric
+index within the list represented by the tree. This means that they
+can be used to store an unsorted list (in which case, every time you
+insert a new element, you must explicitly specify the position where
+you wish to insert it). They can also do numeric lookups in a sorted
+tree, which might be useful for (for example) tracking the median of
+a changing data set.
+
+As well as storing sorted lists, these functions can be used for
+storing \q{maps} (associative arrays), by defining each element of a
+tree to be a (key, value) pair.
+
+\S{utils-newtree234} \cw{newtree234()}
+
+\c tree234 *newtree234(cmpfn234 cmp);
+
+Creates a new empty tree, and returns a pointer to it.
+
+The parameter \c{cmp} determines the sorting criterion on the tree.
+Its prototype is
+
+\c typedef int (*cmpfn234)(void *, void *);
+
+If you want a sorted tree, you should provide a function matching
+this prototype, which returns like \cw{strcmp()} does (negative if
+the first argument is smaller than the second, positive if it is
+bigger, zero if they compare equal). In this case, the function
+\cw{addpos234()} will not be usable on your tree (because all
+insertions must respect the sorting order).
+
+If you want an unsorted tree, pass \cw{NULL}. In this case you will
+not be able to use either \cw{add234()} or \cw{del234()}, or any
+other function such as \cw{find234()} which depends on a sorting
+order. Your tree will become something more like an array, except
+that it will efficiently support insertion and deletion as well as
+lookups by numeric index.
+
+\S{utils-freetree234} \cw{freetree234()}
+
+\c void freetree234(tree234 *t);
+
+Frees a tree. This function will not free the \e{elements} of the
+tree (because they might not be dynamically allocated, or you might
+be storing the same set of elements in more than one tree); it will
+just free the tree structure itself. If you want to free all the
+elements of a tree, you should empty it before passing it to
+\cw{freetree234()}, by means of code along the lines of
+
+\c while ((element = delpos234(tree, 0)) != NULL)
+\c     sfree(element); /* or some more complicated free function */
+\e                     iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
+
+\S{utils-add234} \cw{add234()}
+
+\c void *add234(tree234 *t, void *e);
+
+Inserts a new element \c{e} into the tree \c{t}. This function
+expects the tree to be sorted; the new element is inserted according
+to the sort order.
+
+If an element comparing equal to \c{e} is already in the tree, then
+the insertion will fail, and the return value will be the existing
+element. Otherwise, the insertion succeeds, and \c{e} is returned.
+
+\S{utils-addpos234} \cw{addpos234()}
+
+\c void *addpos234(tree234 *t, void *e, int index);
+
+Inserts a new element into an unsorted tree. Since there is no
+sorting order to dictate where the new element goes, you must
+specify where you want it to go. Setting \c{index} to zero puts the
+new element right at the start of the list; setting \c{index} to the
+current number of elements in the tree puts the new element at the
+end.
+
+Return value is \c{e}, in line with \cw{add234()} (although this
+function cannot fail except by running out of memory, in which case
+it will bomb out and die rather than returning an error indication).
+
+\S{utils-index234} \cw{index234()}
+
+\c void *index234(tree234 *t, int index);
+
+Returns a pointer to the \c{index}th element of the tree, or
+\cw{NULL} if \c{index} is out of range. Elements of the tree are
+numbered from zero.
+
+\S{utils-find234} \cw{find234()}
+
+\c void *find234(tree234 *t, void *e, cmpfn234 cmp);
+
+Searches for an element comparing equal to \c{e} in a sorted tree.
+
+If \c{cmp} is \cw{NULL}, the tree's ordinary comparison function
+will be used to perform the search. However, sometimes you don't
+want that; suppose, for example, each of your elements is a big
+structure containing a \c{char *} name field, and you want to find
+the element with a given name. You \e{could} achieve this by
+constructing a fake element structure, setting its name field
+appropriately, and passing it to \cw{find234()}, but you might find
+it more convenient to pass \e{just} a name string to \cw{find234()},
+supplying an alternative comparison function which expects one of
+its arguments to be a bare name and the other to be a large
+structure containing a name field.
+
+Therefore, if \c{cmp} is not \cw{NULL}, then it will be used to
+compare \c{e} to elements of the tree. The first argument passed to
+\c{cmp} will always be \c{e}; the second will be an element of the
+tree.
+
+(See \k{utils-newtree234} for the definition of the \c{cmpfn234}
+function pointer type.)
+
+The returned value is the element found, or \cw{NULL} if the search
+is unsuccessful.
+
+\S{utils-findrel234} \cw{findrel234()}
+
+\c void *findrel234(tree234 *t, void *e, cmpfn234 cmp, int relation);
+
+This function is like \cw{find234()}, but has the additional ability
+to do a \e{relative} search. The additional parameter \c{relation}
+can be one of the following values:
+
+\dt \cw{REL234_EQ}
+
+\dd Find only an element that compares equal to \c{e}. This is
+exactly the behaviour of \cw{find234()}.
+
+\dt \cw{REL234_LT}
+
+\dd Find the greatest element that compares strictly less than
+\c{e}. \c{e} may be \cw{NULL}, in which case it finds the greatest
+element in the whole tree (which could also be done by
+\cw{index234(t, count234(t)-1)}).
+
+\dt \cw{REL234_LE}
+
+\dd Find the greatest element that compares less than or equal to
+\c{e}. (That is, find an element that compares equal to \c{e} if
+possible, but failing that settle for something just less than it.)
+
+\dt \cw{REL234_GT}
+
+\dd Find the smallest element that compares strictly greater than
+\c{e}. \c{e} may be \cw{NULL}, in which case it finds the smallest
+element in the whole tree (which could also be done by
+\cw{index234(t, 0)}).
+
+\dt \cw{REL234_GE}
+
+\dd Find the smallest element that compares greater than or equal to
+\c{e}. (That is, find an element that compares equal to \c{e} if
+possible, but failing that settle for something just bigger than
+it.)
+
+Return value, as before, is the element found or \cw{NULL} if no
+element satisfied the search criterion.
+
+\S{utils-findpos234} \cw{findpos234()}
+
+\c void *findpos234(tree234 *t, void *e, cmpfn234 cmp, int *index);
+
+This function is like \cw{find234()}, but has the additional feature
+of returning the index of the element found in the tree; that index
+is written to \c{*index} in the event of a successful search (a
+non-\cw{NULL} return value).
+
+\c{index} may be \cw{NULL}, in which case this function behaves
+exactly like \cw{find234()}.
+
+\S{utils-findrelpos234} \cw{findrelpos234()}
+
+\c void *findrelpos234(tree234 *t, void *e, cmpfn234 cmp, int relation,
+\c                     int *index);
+
+This function combines all the features of \cw{findrel234()} and
+\cw{findpos234()}.
+
+\S{utils-del234} \cw{del234()}
+
+\c void *del234(tree234 *t, void *e);
+
+Finds an element comparing equal to \c{e} in the tree, deletes it,
+and returns it.
+
+The input tree must be sorted.
+
+The element found might be \c{e} itself, or might merely compare
+equal to it.
+
+Return value is \cw{NULL} if no such element is found.
+
+\S{utils-delpos234} \cw{delpos234()}
+
+\c void *delpos234(tree234 *t, int index);
+
+Deletes the element at position \c{index} in the tree, and returns
+it.
+
+Return value is \cw{NULL} if the index is out of range.
+
+\S{utils-count234} \cw{count234()}
+
+\c int count234(tree234 *t);
+
+Returns the number of elements currently in the tree.
+
+\S{utils-splitpos234} \cw{splitpos234()}
+
+\c tree234 *splitpos234(tree234 *t, int index, int before);
+
+Splits the input tree into two pieces at a given position, and
+creates a new tree containing all the elements on one side of that
+position.
+
+If \c{before} is \cw{TRUE}, then all the items at or after position
+\c{index} are left in the input tree, and the items before that
+point are returned in the new tree. Otherwise, the reverse happens:
+all the items at or after \c{index} are moved into the new tree, and
+those before that point are left in the old one.
+
+If \c{index} is equal to 0 or to the number of elements in the input
+tree, then one of the two trees will end up empty (and this is not
+an error condition). If \c{index} is further out of range in either
+direction, the operation will fail completely and return \cw{NULL}.
+
+This operation completes in \cw{O(log N)} time, no matter how large
+the tree or how balanced or unbalanced the split.
+
+\S{utils-split234} \cw{split234()}
+
+\c tree234 *split234(tree234 *t, void *e, cmpfn234 cmp, int rel);
+
+Splits a sorted tree according to its sort order.
+
+\c{rel} can be any of the relation constants described in
+\k{utils-findrel234}, \e{except} for \cw{REL234_EQ}. All the
+elements having that relation to \c{e} will be transferred into the
+new tree; the rest will be left in the old one.
+
+The parameter \c{cmp} has the same semantics as it does in
+\cw{find234()}: if it is not \cw{NULL}, it will be used in place of
+the tree's own comparison function when comparing elements to \c{e},
+in such a way that \c{e} itself is always the first of its two
+operands.
+
+Again, this operation completes in \cw{O(log N)} time, no matter how
+large the tree or how balanced or unbalanced the split.
+
+\S{utils-join234} \cw{join234()}
+
+\c tree234 *join234(tree234 *t1, tree234 *t2);
+
+Joins two trees together by concatenating the lists they represent.
+All the elements of \c{t2} are moved into \c{t1}, in such a way that
+they appear \e{after} the elements of \c{t1}. The tree \c{t2} is
+freed; the return value is \c{t1}.
+
+If you apply this function to a sorted tree and it violates the sort
+order (i.e. the smallest element in \c{t2} is smaller than or equal
+to the largest element in \c{t1}), the operation will fail and
+return \cw{NULL}.
+
+This operation completes in \cw{O(log N)} time, no matter how large
+the trees being joined together.
+
+\S{utils-join234r} \cw{join234r()}
+
+\c tree234 *join234r(tree234 *t1, tree234 *t2);
+
+Joins two trees together in exactly the same way as \cw{join234()},
+but this time the combined tree is returned in \c{t2}, and \c{t1} is
+destroyed. The elements in \c{t1} still appear before those in
+\c{t2}.
+
+Again, this operation completes in \cw{O(log N)} time, no matter how
+large the trees being joined together.
+
+\S{utils-copytree234} \cw{copytree234()}
+
+\c tree234 *copytree234(tree234 *t, copyfn234 copyfn,
+\c                      void *copyfnstate);
+
+Makes a copy of an entire tree.
+
+If \c{copyfn} is \cw{NULL}, the tree will be copied but the elements
+will not be; i.e. the new tree will contain pointers to exactly the
+same physical elements as the old one.
+
+If you want to copy each actual element during the operation, you
+can instead pass a function in \c{copyfn} which makes a copy of each
+element. That function has the prototype
+
+\c typedef void *(*copyfn234)(void *state, void *element);
+
+and every time it is called, the \c{state} parameter will be set to
+the value you passed in as \c{copyfnstate}.
+
+\H{utils-misc} Miscellaneous utility functions and macros
+
+This section contains all the utility functions which didn't
+sensibly fit anywhere else.
+
+\S{utils-truefalse} \cw{TRUE} and \cw{FALSE}
+
+The main Puzzles header file defines the macros \cw{TRUE} and
+\cw{FALSE}, which are used throughout the code in place of 1 and 0
+(respectively) to indicate that the values are in a boolean context.
+For code base consistency, I'd prefer it if submissions of new code
+followed this convention as well.
+
+\S{utils-maxmin} \cw{max()} and \cw{min()}
+
+The main Puzzles header file defines the pretty standard macros
+\cw{max()} and \cw{min()}, each of which is given two arguments and
+returns the one which compares greater or less respectively.
+
+These macros may evaluate their arguments multiple times. Avoid side
+effects.
+
+\S{utils-pi} \cw{PI}
+
+The main Puzzles header file defines a macro \cw{PI} which expands
+to a floating-point constant representing pi.
+
+(I've never understood why ANSI's \cw{<math.h>} doesn't define this.
+It'd be so useful!)
+
+\S{utils-obfuscate-bitmap} \cw{obfuscate_bitmap()}
+
+\c void obfuscate_bitmap(unsigned char *bmp, int bits, int decode);
+
+This function obscures the contents of a piece of data, by
+cryptographic methods. It is useful for games of hidden information
+(such as Mines, Guess or Black Box), in which the game ID
+theoretically reveals all the information the player is supposed to
+be trying to guess. So in order that players should be able to send
+game IDs to one another without accidentally spoiling the resulting
+game by looking at them, these games obfuscate their game IDs using
+this function.
+
+Although the obfuscation function is cryptographic, it cannot
+properly be called encryption because it has no key. Therefore,
+anybody motivated enough can re-implement it, or hack it out of the
+Puzzles source, and strip the obfuscation off one of these game IDs
+to see what lies beneath. (Indeed, they could usually do it much
+more easily than that, by entering the game ID into their own copy
+of the puzzle and hitting Solve.) The aim is not to protect against
+a determined attacker; the aim is simply to protect people who
+wanted to play the game honestly from \e{accidentally} spoiling
+their own fun.
+
+The input argument \c{bmp} points at a piece of memory to be
+obfuscated. \c{bits} gives the length of the data. Note that that
+length is in \e{bits} rather than bytes: if you ask for obfuscation
+of a partial number of bytes, then you will get it. Bytes are
+considered to be used from the top down: thus, for example, setting
+\c{bits} to 10 will cover the whole of \cw{bmp[0]} and the \e{top
+two} bits of \cw{bmp[1]}. The remainder of a partially used byte is
+undefined (i.e. it may be corrupted by the function).
+
+The parameter \c{decode} is \cw{FALSE} for an encoding operation,
+and \cw{TRUE} for a decoding operation. Each is the inverse of the
+other. (There's no particular reason you shouldn't obfuscate by
+decoding and restore cleartext by encoding, if you really wanted to;
+it should still work.)
+
+The input bitmap is processed in place.
+
+\S{utils-bin2hex} \cw{bin2hex()}
+
+\c char *bin2hex(const unsigned char *in, int inlen);
+
+This function takes an input byte array and converts it into an
+ASCII string encoding those bytes in (lower-case) hex. It returns a
+dynamically allocated string containing that encoding.
+
+This function is useful for encoding the result of
+\cw{obfuscate_bitmap()} in printable ASCII for use in game IDs.
+
+\S{utils-hex2bin} \cw{hex2bin()}
+
+\c unsigned char *hex2bin(const char *in, int outlen);
+
+This function takes an ASCII string containing hex digits, and
+converts it back into a byte array of length \c{outlen}. If there
+aren't enough hex digits in the string, the contents of the
+resulting array will be undefined.
+
+This function is the inverse of \cw{bin2hex()}.
+
+\S{utils-game-mkhighlight} \cw{game_mkhighlight()}
+
+\c void game_mkhighlight(frontend *fe, float *ret,
+\c                       int background, int highlight, int lowlight);
+
+It's reasonably common for a puzzle game's graphics to use
+highlights and lowlights to indicate \q{raised} or \q{lowered}
+sections. Fifteen, Sixteen and Twiddle are good examples of this.
+
+Puzzles using this graphical style are running a risk if they just
+use whatever background colour is supplied to them by the front end,
+because that background colour might be too light to see any
+highlights on at all. (In particular, it's not unheard of for the
+front end to specify a default background colour of white.)
+
+Therefore, such puzzles can call this utility function from their
+\cw{colours()} routine (\k{backend-colours}). You pass it your front
+end handle, a pointer to the start of your return array, and three
+colour indices. It will:
+
+\b call \cw{frontend_default_colour()} (\k{frontend-default-colour})
+to fetch the front end's default background colour
+
+\b alter the brightness of that colour if it's unsuitable
+
+\b define brighter and darker variants of the colour to be used as
+highlights and lowlights
+
+\b write those results into the relevant positions in the \c{ret}
+array.
+
+Thus, \cw{ret[background*3]} to \cw{ret[background*3+2]} will be set
+to RGB values defining a sensible background colour, and similary
+\c{highlight} and \c{lowlight} will be set to sensible colours.
+
+\C{writing} How to write a new puzzle
+
+This chapter gives a guide to how to actually write a new puzzle:
+where to start, what to do first, how to solve common problems.
+
+The previous chapters have been largely composed of facts. This one
+is mostly advice.
+
+\H{writing-editorial} Choosing a puzzle
+
+Before you start writing a puzzle, you have to choose one. Your
+taste in puzzle games is up to you, of course; and, in fact, you're
+probably reading this guide because you've \e{already} thought of a
+game you want to write. But if you want to get it accepted into the
+official Puzzles distribution, then there's a criterion it has to
+meet.
+
+The current Puzzles editorial policy is that all games should be
+\e{fair}. A fair game is one which a player can only fail to
+complete through demonstrable lack of skill \dash that is, such that
+a better player in the same situation would have \e{known} to do
+something different.
+
+For a start, that means every game presented to the user must have
+\e{at least one solution}. Giving the unsuspecting user a puzzle
+which is actually impossible is not acceptable. (There is an
+exception: if the user has selected some non-default option which is
+clearly labelled as potentially unfair, \e{then} you're allowed to
+generate possibly insoluble puzzles, because the user isn't
+unsuspecting any more. Same Game and Mines both have options of this
+type.)
+
+Also, this actually \e{rules out} games such as Klondike, or the
+normal form of Mahjong Solitaire. Those games have the property that
+even if there is a solution (i.e. some sequence of moves which will
+get from the start state to the solved state), the player doesn't
+necessarily have enough information to \e{find} that solution. In
+both games, it is possible to reach a dead end because you had an
+arbitrary choice to make and made it the wrong way. This violates
+the fairness criterion, because a better player couldn't have known
+they needed to make the other choice.
+
+(GNOME has a variant on Mahjong Solitaire which makes it fair: there
+is a Shuffle operation which randomly permutes all the remaining
+tiles without changing their positions, which allows you to get out
+of a sticky situation. Using this operation adds a 60-second penalty
+to your solution time, so it's to the player's advantage to try to
+minimise the chance of having to use it. It's still possible to
+render the game uncompletable if you end up with only two tiles
+vertically stacked, but that's easy to foresee and avoid using a
+shuffle operation. This form of the game \e{is} fair. Implementing
+it in Puzzles would require an infrastructure change so that the
+back end could communicate time penalties to the mid-end, but that
+would be easy enough.)
+
+Providing a \e{unique} solution is a little more negotiable; it
+depends on the puzzle. Solo would have been of unacceptably low
+quality if it didn't always have a unique solution, whereas Twiddle
+inherently has multiple solutions by its very nature and it would
+have been meaningless to even \e{suggest} making it uniquely
+soluble. Somewhere in between, Flip could reasonably be made to have
+unique solutions (by enforcing a zero-dimension kernel in every
+generated matrix) but it doesn't seem like a serious quality problem
+that it doesn't.
+
+Of course, you don't \e{have} to care about all this. There's
+nothing stopping you implementing any puzzle you want to if you're
+happy to maintain your puzzle yourself, distribute it from your own
+web site, fork the Puzzles code completely, or anything like that.
+It's free software; you can do what you like with it. But any game
+that you want to be accepted into \e{my} Puzzles code base has to
+satisfy the fairness criterion, which means all randomly generated
+puzzles must have a solution (unless the user has deliberately
+chosen otherwise) and it must be possible \e{in theory} to find that
+solution without having to guess.
+
+\H{writing-gs} Getting started
+
+The simplest way to start writing a new puzzle is to copy
+\c{nullgame.c}. This is a template puzzle source file which does
+almost nothing, but which contains all the back end function
+prototypes and declares the back end data structure correctly. It is
+built every time the rest of Puzzles is built, to ensure that it
+doesn't get out of sync with the code and remains buildable.
+
+So start by copying \c{nullgame.c} into your new source file. Then
+you'll gradually add functionality until the very boring Null Game
+turns into your real game.
+
+Next you'll need to add your puzzle to the Makefiles, in order to
+compile it conveniently. \e{Do not edit the Makefiles}: they are
+created automatically by the script \c{mkfiles.pl}, from the file
+called \c{Recipe}. Edit \c{Recipe}, and then re-run \c{mkfiles.pl}.
+
+Also, don't forget to add your puzzle to \c{list.c}: if you don't,
+then it will still run fine on platforms which build each puzzle
+separately, but Mac OS X and other monolithic platforms will not
+include your new puzzle in their single binary.
+
+Once your source file is building, you can move on to the fun bit.
+
+\S{writing-generation} Puzzle generation
+
+Randomly generating instances of your puzzle is almost certain to be
+the most difficult part of the code, and also the task with the
+highest chance of turning out to be completely infeasible. Therefore
+I strongly recommend doing it \e{first}, so that if it all goes
+horribly wrong you haven't wasted any more time than you absolutely
+had to. What I usually do is to take an unmodified \c{nullgame.c},
+and start adding code to \cw{new_game_desc()} which tries to
+generate a puzzle instance and print it out using \cw{printf()}.
+Once that's working, \e{then} I start connecting it up to the return
+value of \cw{new_game_desc()}, populating other structures like
+\c{game_params}, and generally writing the rest of the source file.
+
+There are many ways to generate a puzzle which is known to be
+soluble. In this section I list all the methods I currently know of,
+in case any of them can be applied to your puzzle. (Not all of these
+methods will work, or in some cases even make sense, for all
+puzzles.)
+
+Some puzzles are mathematically tractable, meaning you can work out
+in advance which instances are soluble. Sixteen, for example, has a
+parity constraint in some settings which renders exactly half the
+game space unreachable, but it can be mathematically proved that any
+position not in that half \e{is} reachable. Therefore, Sixteen's
+grid generation simply consists of selecting at random from a well
+defined subset of the game space. Cube in its default state is even
+easier: \e{every} possible arrangement of the blue squares and the
+cube's starting position is soluble!
+
+Another option is to redefine what you mean by \q{soluble}. Black
+Box takes this approach. There are layouts of balls in the box which
+are completely indistinguishable from one another no matter how many
+beams you fire into the box from which angles, which would normally
+be grounds for declaring those layouts unfair; but fortunately,
+detecting that indistinguishability is computationally easy. So
+Black Box doesn't demand that your ball placements match its own; it
+merely demands that your ball placements be \e{indistinguishable}
+from the ones it was thinking of. If you have an ambiguous puzzle,
+then any of the possible answers is considered to be a solution.
+Having redefined the rules in that way, any puzzle is soluble again.
+
+Those are the simple techniques. If they don't work, you have to get
+cleverer.
+
+One way to generate a soluble puzzle is to start from the solved
+state and make inverse moves until you reach a starting state. Then
+you know there's a solution, because you can just list the inverse
+moves you made and make them in the opposite order to return to the
+solved state.
+
+This method can be simple and effective for puzzles where you get to
+decide what's a starting state and what's not. In Pegs, for example,
+the generator begins with one peg in the centre of the board and
+makes inverse moves until it gets bored; in this puzzle, valid
+inverse moves are easy to detect, and \e{any} state that's reachable
+from the solved state by inverse moves is a reasonable starting
+position. So Pegs just continues making inverse moves until the
+board satisfies some criteria about extent and density, and then
+stops and declares itself done.
+
+For other puzzles, it can be a lot more difficult. Same Game uses
+this strategy too, and it's lucky to get away with it at all: valid
+inverse moves aren't easy to find (because although it's easy to
+insert additional squares in a Same Game position, it's difficult to
+arrange that \e{after} the insertion they aren't adjacent to any
+other squares of the same colour), so you're constantly at risk of
+running out of options and having to backtrack or start again. Also,
+Same Game grids never start off half-empty, which means you can't
+just stop when you run out of moves \dash you have to find a way to
+fill the grid up \e{completely}.
+
+The other way to generate a puzzle that's soluble is to start from
+the other end, and actually write a \e{solver}. This tends to ensure
+that a puzzle has a \e{unique} solution over and above having a
+solution at all, so it's a good technique to apply to puzzles for
+which that's important.
+
+One theoretical drawback of generating soluble puzzles by using a
+solver is that your puzzles are restricted in difficulty to those
+which the solver can handle. (Most solvers are not fully general:
+many sets of puzzle rules are NP-complete or otherwise nasty, so
+most solvers can only handle a subset of the theoretically soluble
+puzzles.) It's been my experience in practice, however, that this
+usually isn't a problem; computers are good at very different things
+from humans, and what the computer thinks is nice and easy might
+still be pleasantly challenging for a human. For example, when
+solving Dominosa puzzles I frequently find myself using a variety of
+reasoning techniques that my solver doesn't know about; in
+principle, therefore, I should be able to solve the puzzle using
+only those techniques it \e{does} know about, but this would involve
+repeatedly searching the entire grid for the one simple deduction I
+can make. Computers are good at this sort of exhaustive search, but
+it's been my experience that human solvers prefer to do more complex
+deductions than to spend ages searching for simple ones. So in many
+cases I don't find my own playing experience to be limited by the
+restrictions on the solver.
+
+(This isn't \e{always} the case. Solo is a counter-example;
+generating Solo puzzles using a simple solver does lead to
+qualitatively easier puzzles. Therefore I had to make the Solo
+solver rather more advanced than most of them.)
+
+There are several different ways to apply a solver to the problem of
+generating a soluble puzzle. I list a few of them below.
+
+The simplest approach is brute force: randomly generate a puzzle,
+use the solver to see if it's soluble, and if not, throw it away and
+try again until you get lucky. This is often a viable technique if
+all else fails, but it tends not to scale well: for many puzzle
+types, the probability of finding a uniquely soluble instance
+decreases sharply as puzzle size goes up, so this technique might
+work reasonably fast for small puzzles but take (almost) forever at
+larger sizes. Still, if there's no other alternative it can be
+usable: Pattern and Dominosa both use this technique. (However,
+Dominosa has a means of tweaking the randomly generated grids to
+increase the \e{probability} of them being soluble, by ruling out
+one of the most common ambiguous cases. This improved generation
+speed by over a factor of 10 on the highest preset!)
+
+An approach which can be more scalable involves generating a grid
+and then tweaking it to make it soluble. This is the technique used
+by Mines and also by Net: first a random puzzle is generated, and
+then the solver is run to see how far it gets. Sometimes the solver
+will get stuck; when that happens, examine the area it's having
+trouble with, and make a small random change in that area to allow
+it to make more progress. Continue solving (possibly even without
+restarting the solver), tweaking as necessary, until the solver
+finishes. Then restart the solver from the beginning to ensure that
+the tweaks haven't caused new problems in the process of solving old
+ones (which can sometimes happen).
+
+This strategy works well in situations where the usual solver
+failure mode is to get stuck in an easily localised spot. Thus it
+works well for Net and Mines, whose most common failure mode tends
+to be that most of the grid is fine but there are a few widely
+separated ambiguous sections; but it would work less well for
+Dominosa, in which the way you get stuck is to have scoured the
+whole grid and not found anything you can deduce \e{anywhere}. Also,
+it relies on there being a low probability that tweaking the grid
+introduces a new problem at the same time as solving the old one;
+Mines and Net also have the property that most of their deductions
+are local, so that it's very unlikely for a tweak to affect
+something half way across the grid from the location where it was
+applied. In Dominosa, by contrast, a lot of deductions use
+information about half the grid (\q{out of all the sixes, only one
+is next to a three}, which can depend on the values of up to 32 of
+the 56 squares in the default setting!), so this tweaking strategy
+would be rather less likely to work well.
+
+A more specialised strategy is that used in Solo and Slant. These
+puzzles have the property that they derive their difficulty from not
+presenting all the available clues. (In Solo's case, if all the
+possible clues were provided then the puzzle would already be
+solved; in Slant it would still require user action to fill in the
+lines, but it would present no challenge at all). Therefore, a
+simple generation technique is to leave the decision of which clues
+to provide until the last minute. In other words, first generate a
+random \e{filled} grid with all possible clues present, and then
+gradually remove clues for as long as the solver reports that it's
+still soluble. Unlike the methods described above, this technique
+\e{cannot} fail \dash once you've got a filled grid, nothing can
+stop you from being able to convert it into a viable puzzle.
+However, it wouldn't even be meaningful to apply this technique to
+(say) Pattern, in which clues can never be left out, so the only way
+to affect the set of clues is by altering the solution.
+
+(Unfortunately, Solo is complicated by the need to provide puzzles
+at varying difficulty levels. It's easy enough to generate a puzzle
+of \e{at most} a given level of difficulty; you just have a solver
+with configurable intelligence, and you set it to a given level and
+apply the above technique, thus guaranteeing that the resulting grid
+is solvable by someone with at most that much intelligence. However,
+generating a puzzle of \e{at least} a given level of difficulty is
+rather harder; if you go for \e{at most} Intermediate level, you're
+likely to find that you've accidentally generated a Trivial grid a
+lot of the time, because removing just one number is sufficient to
+take the puzzle from Trivial straight to Ambiguous. In that
+situation Solo has no remaining options but to throw the puzzle away
+and start again.)
+
+A final strategy is to use the solver \e{during} puzzle
+construction: lay out a bit of the grid, run the solver to see what
+it allows you to deduce, and then lay out a bit more to allow the
+solver to make more progress. There are articles on the web that
+recommend constructing Sudoku puzzles by this method (which is
+completely the opposite way round to how Solo does it); for Sudoku
+it has the advantage that you get to specify your clue squares in
+advance (so you can have them make pretty patterns).
+
+Rectangles uses a strategy along these lines. First it generates a
+grid by placing the actual rectangles; then it has to decide where
+in each rectangle to place a number. It uses a solver to help it
+place the numbers in such a way as to ensure a unique solution. It
+does this by means of running a test solver, but it runs the solver
+\e{before} it's placed any of the numbers \dash which means the
+solver must be capable of coping with uncertainty about exactly
+where the numbers are! It runs the solver as far as it can until it
+gets stuck; then it narrows down the possible positions of a number
+in order to allow the solver to make more progress, and so on. Most
+of the time this process terminates with the grid fully solved, at
+which point any remaining number-placement decisions can be made at
+random from the options not so far ruled out. Note that unlike the
+Net/Mines tweaking strategy described above, this algorithm does not
+require a checking run after it completes: if it finishes
+successfully at all, then it has definitely produced a uniquely
+soluble puzzle.
+
+Most of the strategies described above are not 100% reliable. Each
+one has a failure rate: every so often it has to throw out the whole
+grid and generate a fresh one from scratch. (Solo's strategy would
+be the exception, if it weren't for the need to provide configurable
+difficulty levels.) Occasional failures are not a fundamental
+problem in this sort of work, however: it's just a question of
+dividing the grid generation time by the success rate (if it takes
+10ms to generate a candidate grid and 1/5 of them work, then it will
+take 50ms on average to generate a viable one), and seeing whether
+the expected time taken to \e{successfully} generate a puzzle is
+unacceptably slow. Dominosa's generator has a very low success rate
+(about 1 out of 20 candidate grids turn out to be usable, and if you
+think \e{that's} bad then go and look at the source code and find
+the comment showing what the figures were before the generation-time
+tweaks!), but the generator itself is very fast so this doesn't
+matter. Rectangles has a slower generator, but fails well under 50%
+of the time.
+
+So don't be discouraged if you have an algorithm that doesn't always
+work: if it \e{nearly} always works, that's probably good enough.
+The one place where reliability is important is that your algorithm
+must never produce false positives: it must not claim a puzzle is
+soluble when it isn't. It can produce false negatives (failing to
+notice that a puzzle is soluble), and it can fail to generate a
+puzzle at all, provided it doesn't do either so often as to become
+slow.
+
+One last piece of advice: for grid-based puzzles, when writing and
+testing your generation algorithm, it's almost always a good idea
+\e{not} to test it initially on a grid that's square (i.e.
+\cw{w==h}), because if the grid is square then you won't notice if
+you mistakenly write \c{h} instead of \c{w} (or vice versa)
+somewhere in the code. Use a rectangular grid for testing, and any
+size of grid will be likely to work after that.
+
+\S{writing-textformats} Designing textual description formats
+
+Another aspect of writing a puzzle which is worth putting some
+thought into is the design of the various text description formats:
+the format of the game parameter encoding, the game description
+encoding, and the move encoding.
+
+The first two of these should be reasonably intuitive for a user to
+type in; so provide some flexibility where possible. Suppose, for
+example, your parameter format consists of two numbers separated by
+an \c{x} to specify the grid dimensions (\c{10x10} or \c{20x15}),
+and then has some suffixes to specify other aspects of the game
+type. It's almost always a good idea in this situation to arrange
+that \cw{decode_params()} can handle the suffixes appearing in any
+order, even if \cw{encode_params()} only ever generates them in one
+order.
+
+These formats will also be expected to be reasonably stable: users
+will expect to be able to exchange game IDs with other users who
+aren't running exactly the same version of your game. So make them
+robust and stable: don't build too many assumptions into the game ID
+format which will have to be changed every time something subtle
+changes in the puzzle code.
+
+\H{writing-howto} Common how-to questions
+
+This section lists some common things people want to do when writing
+a puzzle, and describes how to achieve them within the Puzzles
+framework.
+
+\S{writing-howto-cursor} Drawing objects at only one position
+
+A common phenomenon is to have an object described in the
+\c{game_state} or the \c{game_ui} which can only be at one position.
+A cursor \dash probably specified in the \c{game_ui} \dash is a good
+example.
+
+In the \c{game_ui}, it would \e{obviously} be silly to have an array
+covering the whole game grid with a boolean flag stating whether the
+cursor was at each position. Doing that would waste space, would
+make it difficult to find the cursor in order to do anything with
+it, and would introduce the potential for synchronisation bugs in
+which you ended up with two cursors or none. The obviously sensible
+way to store a cursor in the \c{game_ui} is to have fields directly
+encoding the cursor's coordinates.
+
+However, it is a mistake to assume that the same logic applies to
+the \c{game_drawstate}. If you replicate the cursor position fields
+in the draw state, the redraw code will get very complicated. In the
+draw state, in fact, it \e{is} probably the right thing to have a
+cursor flag for every position in the grid. You probably have an
+array for the whole grid in the drawstate already (stating what is
+currently displayed in the window at each position); the sensible
+approach is to add a \q{cursor} flag to each element of that array.
+Then the main redraw loop will look something like this
+(pseudo-code):
+
+\c for (y = 0; y < h; y++) {
+\c     for (x = 0; x < w; x++) {
+\c         int value = state->symbol_at_position[y][x];
+\c         if (x == ui->cursor_x && y == ui->cursor_y)
+\c             value |= CURSOR;
+\c         if (ds->symbol_at_position[y][x] != value) {
+\c             symbol_drawing_subroutine(dr, ds, x, y, value);
+\c             ds->symbol_at_position[y][x] = value;
+\c         }
+\c     }
+\c }
+
+This loop is very simple, pretty hard to get wrong, and
+\e{automatically} deals both with erasing the previous cursor and
+drawing the new one, with no special case code required.
+
+This type of loop is generally a sensible way to write a redraw
+function, in fact. The best thing is to ensure that the information
+stored in the draw state for each position tells you \e{everything}
+about what was drawn there. A good way to ensure that is to pass
+precisely the same information, and \e{only} that information, to a
+subroutine that does the actual drawing; then you know there's no
+additional information which affects the drawing but which you don't
+notice changes in.
+
+\S{writing-keyboard-cursor} Implementing a keyboard-controlled cursor
+
+It is often useful to provide a keyboard control method in a
+basically mouse-controlled game. A keyboard-controlled cursor is
+best implemented by storing its location in the \c{game_ui} (since
+if it were in the \c{game_state} then the user would have to
+separately undo every cursor move operation). So the procedure would
+be:
+
+\b Put cursor position fields in the \c{game_ui}.
+
+\b \cw{interpret_move()} responds to arrow keys by modifying the
+cursor position fields and returning \cw{""}.
+
+\b \cw{interpret_move()} responds to some sort of fire button by
+actually performing a move based on the current cursor location.
+
+\b You might want an additional \c{game_ui} field stating whether
+the cursor is currently visible, and having it disappear when a
+mouse action occurs (so that it doesn't clutter the display when not
+actually in use).
+
+\b You might also want to automatically hide the cursor in
+\cw{changed_state()} when the current game state changes to one in
+which there is no move to make (which is the case in some types of
+completed game).
+
+\b \cw{redraw()} draws the cursor using the technique described in
+\k{writing-howto-cursor}.
+
+\S{writing-howto-dragging} Implementing draggable sprites
+
+Some games have a user interface which involves dragging some sort
+of game element around using the mouse. If you need to show a
+graphic moving smoothly over the top of other graphics, use a
+blitter (see \k{drawing-blitter} for the blitter API) to save the
+background underneath it. The typical scenario goes:
+
+\b Have a blitter field in the \c{game_drawstate}.
+
+\b Set the blitter field to \cw{NULL} in the game's
+\cw{new_drawstate()} function, since you don't yet know how big the
+piece of saved background needs to be.
+
+\b In the game's \cw{set_size()} function, once you know the size of
+the object you'll be dragging around the display and hence the
+required size of the blitter, actually allocate the blitter.
+
+\b In \cw{free_drawstate()}, free the blitter if it's not \cw{NULL}.
+
+\b In \cw{interpret_move()}, respond to mouse-down and mouse-drag
+events by updating some fields in the \cw{game_ui} which indicate
+that a drag is in progress.
+
+\b At the \e{very end} of \cw{redraw()}, after all other drawing has
+been done, draw the moving object if there is one. First save the
+background under the object in the blitter; then set a clip
+rectangle covering precisely the area you just saved (just in case
+anti-aliasing or some other error causes your drawing to go beyond
+the area you saved). Then draw the object, and call \cw{unclip()}.
+Finally, set a flag in the \cw{game_drawstate} that indicates that
+the blitter needs restoring.
+
+\b At the very start of \cw{redraw()}, before doing anything else at
+all, check the flag in the \cw{game_drawstate}, and if it says the
+blitter needs restoring then restore it. (Then clear the flag, so
+that this won't happen again in the next redraw if no moving object
+is drawn this time.)
+
+This way, you will be able to write the rest of the redraw function
+completely ignoring the dragged object, as if it were floating above
+your bitmap and being completely separate.
+
+\S{writing-ref-counting} Sharing large invariant data between all
+game states
+
+In some puzzles, there is a large amount of data which never changes
+between game states. The array of numbers in Dominosa is a good
+example.
+
+You \e{could} dynamically allocate a copy of that array in every
+\c{game_state}, and have \cw{dup_game()} make a fresh copy of it for
+every new \c{game_state}; but it would waste memory and time. A
+more efficient way is to use a reference-counted structure.
+
+\b Define a structure type containing the data in question, and also
+containing an integer reference count.
+
+\b Have a field in \c{game_state} which is a pointer to this
+structure.
+
+\b In \cw{new_game()}, when creating a fresh game state at the start
+of a new game, create an instance of this structure, initialise it
+with the invariant data, and set its reference count to 1.
+
+\b In \cw{dup_game()}, rather than making a copy of the structure
+for the new game state, simply set the new game state to point at
+the same copy of the structure, and increment its reference count.
+
+\b In \cw{free_game()}, decrement the reference count in the
+structure pointed to by the game state; if the count reaches zero,
+free the structure.
+
+This way, the invariant data will persist for only as long as it's
+genuinely needed; \e{as soon} as the last game state for a
+particular puzzle instance is freed, the invariant data for that
+puzzle will vanish as well. Reference counting is a very efficient
+form of garbage collection, when it works at all. (Which it does in
+this instance, of course, because there's no possibility of circular
+references.)
+
+\S{writing-flash-types} Implementing multiple types of flash
+
+In some games you need to flash in more than one different way.
+Mines, for example, flashes white when you win, and flashes red when
+you tread on a mine and die.
+
+The simple way to do this is:
+
+\b Have a field in the \c{game_ui} which describes the type of flash.
+
+\b In \cw{flash_length()}, examine the old and new game states to
+decide whether a flash is required and what type. Write the type of
+flash to the \c{game_ui} field whenever you return non-zero.
+
+\b In \cw{redraw()}, when you detect that \c{flash_time} is
+non-zero, examine the field in \c{game_ui} to decide which type of
+flash to draw.
+
+\cw{redraw()} will never be called with \c{flash_time} non-zero
+unless \cw{flash_length()} was first called to tell the mid-end that
+a flash was required; so whenever \cw{redraw()} notices that
+\c{flash_time} is non-zero, you can be sure that the field in
+\c{game_ui} is correctly set.
+
+\S{writing-move-anim} Animating game moves
+
+A number of puzzle types benefit from a quick animation of each move
+you make.
+
+For some games, such as Fifteen, this is particularly easy. Whenever
+\cw{redraw()} is called with \c{oldstate} non-\cw{NULL}, Fifteen
+simply compares the position of each tile in the two game states,
+and if the tile is not in the same place then it draws it some
+fraction of the way from its old position to its new position. This
+method copes automatically with undo.
+
+Other games are less obvious. In Sixteen, for example, you can't
+just draw each tile a fraction of the way from its old to its new
+position: if you did that, the end tile would zip very rapidly past
+all the others to get to the other end and that would look silly.
+(Worse, it would look inconsistent if the end tile was drawn on top
+going one way and on the bottom going the other way.)
+
+A useful trick here is to define a field or two in the game state
+that indicates what the last move was.
+
+\b Add a \q{last move} field to the \c{game_state} (or two or more
+fields if the move is complex enough to need them).
+
+\b \cw{new_game()} initialises this field to a null value for a new
+game state.
+
+\b \cw{execute_move()} sets up the field to reflect the move it just
+performed.
+
+\b \cw{redraw()} now needs to examine its \c{dir} parameter. If
+\c{dir} is positive, it determines the move being animated by
+looking at the last-move field in \c{newstate}; but if \c{dir} is
+negative, it has to look at the last-move field in \c{oldstate}, and
+invert whatever move it finds there.
+
+Note also that Sixteen needs to store the \e{direction} of the move,
+because you can't quite determine it by examining the row or column
+in question. You can in almost all cases, but when the row is
+precisely two squares long it doesn't work since a move in either
+direction looks the same. (You could argue that since moving a
+2-element row left and right has the same effect, it doesn't matter
+which one you animate; but in fact it's very disorienting to click
+the arrow left and find the row moving right, and almost as bad to
+undo a move to the right and find the game animating \e{another}
+move to the right.)
+
+\S{writing-conditional-anim} Animating drag operations
+
+In Untangle, moves are made by dragging a node from an old position
+to a new position. Therefore, at the time when the move is initially
+made, it should not be animated, because the node has already been
+dragged to the right place and doesn't need moving there. However,
+it's nice to animate the same move if it's later undone or redone.
+This requires a bit of fiddling.
+
+The obvious approach is to have a flag in the \c{game_ui} which
+inhibits move animation, and to set that flag in
+\cw{interpret_move()}. The question is, when would the flag be reset
+again? The obvious place to do so is \cw{changed_state()}, which
+will be called once per move. But it will be called \e{before}
+\cw{anim_length()}, so if it resets the flag then \cw{anim_length()}
+will never see the flag set at all.
+
+The solution is to have \e{two} flags in a queue.
+
+\b Define two flags in \c{game_ui}; let's call them \q{current} and
+\q{next}.
+
+\b Set both to \cw{FALSE} in \c{new_ui()}.
+
+\b When a drag operation completes in \cw{interpret_move()}, set the
+\q{next} flag to \cw{TRUE}.
+
+\b Every time \cw{changed_state()} is called, set the value of
+\q{current} to the value in \q{next}, and then set the value of
+\q{next} to \cw{FALSE}.
+
+\b That way, \q{current} will be \cw{TRUE} \e{after} a call to
+\cw{changed_state()} if and only if that call to
+\cw{changed_state()} was the result of a drag operation processed by
+\cw{interpret_move()}. Any other call to \cw{changed_state()}, due
+to an Undo or a Redo or a Restart or a Solve, will leave \q{current}
+\cw{FALSE}.
+
+\b So now \cw{anim_length()} can request a move animation if and
+only if the \q{current} flag is \e{not} set.
+
+\S{writing-cheating} Inhibiting the victory flash when Solve is used
+
+Many games flash when you complete them, as a visual congratulation
+for having got to the end of the puzzle. It often seems like a good
+idea to disable that flash when the puzzle is brought to a solved
+state by means of the Solve operation.
+
+This is easily done:
+
+\b Add a \q{cheated} flag to the \c{game_state}.
+
+\b Set this flag to \cw{FALSE} in \cw{new_game()}.
+
+\b Have \cw{solve()} return a move description string which clearly
+identifies the move as a solve operation.
+
+\b Have \cw{execute_move()} respond to that clear identification by
+setting the \q{cheated} flag in the returned \c{game_state}. The
+flag will then be propagated to all subsequent game states, even if
+the user continues fiddling with the game after it is solved.
+
+\b \cw{flash_length()} now returns non-zero if \c{oldstate} is not
+completed and \c{newstate} is, \e{and} neither state has the
+\q{cheated} flag set.
+
+\H{writing-testing} Things to test once your puzzle is written
+
+Puzzle implementations written in this framework are self-testing as
+far as I could make them.
+
+Textual game and move descriptions, for example, are generated and
+parsed as part of the normal process of play. Therefore, if you can
+make moves in the game \e{at all} you can be reasonably confident
+that the mid-end serialisation interface will function correctly and
+you will be able to save your game. (By contrast, if I'd stuck with
+a single \cw{make_move()} function performing the jobs of both
+\cw{interpret_move()} and \cw{execute_move()}, and had separate
+functions to encode and decode a game state in string form, then
+those functions would not be used during normal play; so they could
+have been completely broken, and you'd never know it until you tried
+to save the game \dash which would have meant you'd have to test
+game saving \e{extensively} and make sure to test every possible
+type of game state. As an added bonus, doing it the way I did leads
+to smaller save files.)
+
+There is one exception to this, which is the string encoding of the
+\c{game_ui}. Most games do not store anything permanent in the
+\c{game_ui}, and hence do not need to put anything in its encode and
+decode functions; but if there is anything in there, you do need to
+test game loading and saving to ensure those functions work
+properly.
+
+It's also worth testing undo and redo of all operations, to ensure
+that the redraw and the animations (if any) work properly. Failing
+to animate undo properly seems to be a common error.
+
+Other than that, just use your common sense.
diff --git a/apps/plugins/puzzles/divvy.c b/apps/plugins/puzzles/divvy.c
new file mode 100644
index 0000000000..dfd409c9e0
--- /dev/null
+++ b/apps/plugins/puzzles/divvy.c
@@ -0,0 +1,781 @@
+/*
+ * Library code to divide up a rectangle into a number of equally
+ * sized ominoes, in a random fashion.
+ * 
+ * Could use this for generating solved grids of
+ * http://www.nikoli.co.jp/ja/puzzles/block_puzzle/
+ * or for generating the playfield for Jigsaw Sudoku.
+ */
+
+/*
+ * This code is restricted to simply connected solutions: that is,
+ * no single polyomino may completely surround another (not even
+ * with a corner visible to the outside world, in the sense that a
+ * 7-omino can `surround' a single square).
+ * 
+ * It's tempting to think that this is a natural consequence of
+ * all the ominoes being the same size - after all, a division of
+ * anything into 7-ominoes must necessarily have all of them
+ * simply connected, because if one was not then the 1-square
+ * space in the middle could not be part of any 7-omino - but in
+ * fact, for sufficiently large k, it is perfectly possible for a
+ * k-omino to completely surround another k-omino. A simple
+ * example is this one with two 25-ominoes:
+ * 
+ *   +--+--+--+--+--+--+--+
+ *   |                    |
+ *   +  +--+--+--+--+--+  +
+ *   |  |              |  |
+ *   +  +              +  +
+ *   |  |              |  |
+ *   +  +              +  +--+
+ *   |  |              |     |
+ *   +  +              +  +--+
+ *   |  |              |  |
+ *   +  +              +  +
+ *   |  |              |  |
+ *   +  +--+--+--+--+--+  +
+ *   |                    |
+ *   +--+--+--+--+--+--+--+
+ * 
+ * I claim the smallest k which can manage this is 23. More
+ * formally:
+ * 
+ *   If a k-omino P is completely surrounded by another k-omino Q,
+ *   such that every edge of P borders on Q, then k >= 23.
+ * 
+ * Proof:
+ * 
+ * It's relatively simple to find the largest _rectangle_ a
+ * k-omino can enclose. So I'll construct my proof in two parts:
+ * firstly, show that no 22-omino or smaller can enclose a
+ * rectangle as large as itself, and secondly, show that no
+ * polyomino can enclose a larger non-rectangle than a rectangle.
+ * 
+ * The first of those claims:
+ * 
+ * To surround an m x n rectangle, a polyomino must have 2m
+ * squares along the two m-sides of the rectangle, 2n squares
+ * along the two n-sides, and must fill in at least three of the
+ * corners in order to be connected. Thus, 2(m+n)+3 <= k. We wish
+ * to find the largest value of mn subject to that constraint, and
+ * it's clear that this is achieved when m and n are as close to
+ * equal as possible. (If they aren't, WLOG suppose m < n; then
+ * (m+1)(n-1) = mn + n - m - 1 >= mn, with equality only when
+ * m=n-1.)
+ * 
+ * So the area of the largest rectangle which can be enclosed by a
+ * k-omino is given by floor(k'/2) * ceil(k'/2), where k' =
+ * (k-3)/2. This is a monotonic function in k, so there will be a
+ * unique point at which it goes from being smaller than k to
+ * being larger than k. That point is between 22 (maximum area 20)
+ * and 23 (maximum area 25).
+ * 
+ * The second claim:
+ * 
+ * Suppose we have an inner polyomino P surrounded by an outer
+ * polyomino Q. I seek to show that if P is non-rectangular, then
+ * P is also non-maximal, in the sense that we can transform P and
+ * Q into a new pair of polyominoes in which P is larger and Q is
+ * at most the same size.
+ * 
+ * Consider walking along the boundary of P in a clockwise
+ * direction. (We may assume, of course, that there is only _one_
+ * boundary of P, i.e. P has no hole in the middle. If it does
+ * have a hole in the middle, it's _trivially_ non-maximal because
+ * we can just fill the hole in!) Our walk will take us along many
+ * edges between squares; sometimes we might turn left, and
+ * certainly sometimes we will turn right. Always there will be a
+ * square of P on our right, and a square of Q on our left.
+ * 
+ * The net angle through which we turn during the entire walk must
+ * add up to 360 degrees rightwards. So if there are no left
+ * turns, then we must turn right exactly four times, meaning we
+ * have described a rectangle. Hence, if P is _not_ rectangular,
+ * then there must have been a left turn at some point. A left
+ * turn must mean we walk along two edges of the same square of Q.
+ * 
+ * Thus, there is some square X in Q which is adjacent to two
+ * diagonally separated squares in P. Let us call those two
+ * squares N and E; let us refer to the other two neighbours of X
+ * as S and W; let us refer to the other mutual neighbour of S and
+ * W as D; and let us refer to the other mutual neighbour of S and
+ * E as Y. In other words, we have named seven squares, arranged
+ * thus:
+ * 
+ *     N
+ *   W X E
+ *   D S Y
+ * 
+ * where N and E are in P, and X is in Q.
+ * 
+ * Clearly at least one of W and S must be in Q (because otherwise
+ * X would not be connected to any other square in Q, and would
+ * hence have to be the whole of Q; and evidently if Q were a
+ * 1-omino it could not enclose _anything_). So we divide into
+ * cases:
+ * 
+ * If both W and S are in Q, then we take X out of Q and put it in
+ * P, which does not expose any edge of P. If this disconnects Q,
+ * then we can reconnect it by adding D to Q.
+ * 
+ * If only one of W and S is in Q, then wlog let it be W. If S is
+ * in _P_, then we have a particularly easy case: we can simply
+ * take X out of Q and add it to P, and this cannot disconnect X
+ * since X was a leaf square of Q.
+ * 
+ * Our remaining case is that W is in Q and S is in neither P nor
+ * Q. Again we take X out of Q and put it in P; we also add S to
+ * Q. This ensures we do not expose an edge of P, but we must now
+ * prove that S is adjacent to some other existing square of Q so
+ * that we haven't disconnected Q by adding it.
+ * 
+ * To do this, we recall that we walked along the edge XE, and
+ * then turned left to walk along XN. So just before doing all
+ * that, we must have reached the corner XSE, and we must have
+ * done it by walking along one of the three edges meeting at that
+ * corner which are _not_ XE. It can't have been SY, since S would
+ * then have been on our left and it isn't in Q; and it can't have
+ * been XS, since S would then have been on our right and it isn't
+ * in P. So it must have been YE, in which case Y was on our left,
+ * and hence is in Q.
+ * 
+ * So in all cases we have shown that we can take X out of Q and
+ * add it to P, and add at most one square to Q to restore the
+ * containment and connectedness properties. Hence, we can keep
+ * doing this until we run out of left turns and P becomes
+ * rectangular. []
+ * 
+ * ------------
+ * 
+ * Anyway, that entire proof was a bit of a sidetrack. The point
+ * is, although constructions of this type are possible for
+ * sufficiently large k, divvy_rectangle() will never generate
+ * them. This could be considered a weakness for some purposes, in
+ * the sense that we can't generate all possible divisions.
+ * However, there are many divisions which we are highly unlikely
+ * to generate anyway, so in practice it probably isn't _too_ bad.
+ * 
+ * If I wanted to fix this issue, I would have to make the rules
+ * more complicated for determining when a square can safely be
+ * _removed_ from a polyomino. Adding one becomes easier (a square
+ * may be added to a polyomino iff it is 4-adjacent to any square
+ * currently part of the polyomino, and the current test for loop
+ * formation may be dispensed with), but to determine which
+ * squares may be removed we must now resort to analysis of the
+ * overall structure of the polyomino rather than the simple local
+ * properties we can currently get away with measuring.
+ */
+
+/*
+ * Possible improvements which might cut the fail rate:
+ * 
+ *  - instead of picking one omino to extend in an iteration, try
+ *    them all in succession (in a randomised order)
+ * 
+ *  - (for real rigour) instead of bfsing over ominoes, bfs over
+ *    the space of possible _removed squares_. That way we aren't
+ *    limited to randomly choosing a single square to remove from
+ *    an omino and failing if that particular square doesn't
+ *    happen to work.
+ * 
+ * However, I don't currently think it's necessary to do either of
+ * these, because the failure rate is already low enough to be
+ * easily tolerable, under all circumstances I've been able to
+ * think of.
+ */
+
+#include "rbassert.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+
+#include "puzzles.h"
+
+/*
+ * Subroutine which implements a function used in computing both
+ * whether a square can safely be added to an omino, and whether
+ * it can safely be removed.
+ * 
+ * We enumerate the eight squares 8-adjacent to this one, in
+ * cyclic order. We go round that loop and count the number of
+ * times we find a square owned by the target omino next to one
+ * not owned by it. We then return success iff that count is 2.
+ * 
+ * When adding a square to an omino, this is precisely the
+ * criterion which tells us that adding the square won't leave a
+ * hole in the middle of the omino. (If it did, then things get
+ * more complicated; see above.)
+ * 
+ * When removing a square from an omino, the _same_ criterion
+ * tells us that removing the square won't disconnect the omino.
+ * (This only works _because_ we've ensured the omino is simply
+ * connected.)
+ */
+static int addremcommon(int w, int h, int x, int y, int *own, int val)
+{
+    int neighbours[8];
+    int dir, count;
+
+    for (dir = 0; dir < 8; dir++) {
+        int dx = ((dir & 3) == 2 ? 0 : dir > 2 && dir < 6 ? +1 : -1);
+        int dy = ((dir & 3) == 0 ? 0 : dir < 4 ? -1 : +1);
+        int sx = x+dx, sy = y+dy;
+
+        if (sx < 0 || sx >= w || sy < 0 || sy >= h)
+            neighbours[dir] = -1;      /* outside the grid */
+        else
+            neighbours[dir] = own[sy*w+sx];
+    }
+
+    /*
+     * To begin with, check 4-adjacency.
+     */
+    if (neighbours[0] != val && neighbours[2] != val &&
+        neighbours[4] != val && neighbours[6] != val)
+        return FALSE;
+
+    count = 0;
+
+    for (dir = 0; dir < 8; dir++) {
+        int next = (dir + 1) & 7;
+        int gotthis = (neighbours[dir] == val);
+        int gotnext = (neighbours[next] == val);
+
+        if (gotthis != gotnext)
+            count++;
+    }
+
+    return (count == 2);
+}
+
+/*
+ * w and h are the dimensions of the rectangle.
+ * 
+ * k is the size of the required ominoes. (So k must divide w*h,
+ * of course.)
+ * 
+ * The returned result is a w*h-sized dsf.
+ * 
+ * In both of the above suggested use cases, the user would
+ * probably want w==h==k, but that isn't a requirement.
+ */
+static int *divvy_internal(int w, int h, int k, random_state *rs)
+{
+    int *order, *queue, *tmp, *own, *sizes, *addable, *removable, *retdsf;
+    int wh = w*h;
+    int i, j, n, x, y, qhead, qtail;
+
+    n = wh / k;
+    assert(wh == k*n);
+
+    order = snewn(wh, int);
+    tmp = snewn(wh, int);
+    own = snewn(wh, int);
+    sizes = snewn(n, int);
+    queue = snewn(n, int);
+    addable = snewn(wh*4, int);
+    removable = snewn(wh, int);
+
+    /*
+     * Permute the grid squares into a random order, which will be
+     * used for iterating over the grid whenever we need to search
+     * for something. This prevents directional bias and arranges
+     * for the answer to be non-deterministic.
+     */
+    for (i = 0; i < wh; i++)
+        order[i] = i;
+    shuffle(order, wh, sizeof(*order), rs);
+
+    /*
+     * Begin by choosing a starting square at random for each
+     * omino.
+     */
+    for (i = 0; i < wh; i++) {
+        own[i] = -1;
+    }
+    for (i = 0; i < n; i++) {
+        own[order[i]] = i;
+        sizes[i] = 1;
+    }
+
+    /*
+     * Now repeatedly pick a random omino which isn't already at
+     * the target size, and find a way to expand it by one. This
+     * may involve stealing a square from another omino, in which
+     * case we then re-expand that omino, forming a chain of
+     * square-stealing which terminates in an as yet unclaimed
+     * square. Hence every successful iteration around this loop
+     * causes the number of unclaimed squares to drop by one, and
+     * so the process is bounded in duration.
+     */
+    while (1) {
+
+#ifdef DIVVY_DIAGNOSTICS
+        {
+            int x, y;
+            printf("Top of loop. Current grid:\n");
+            for (y = 0; y < h; y++) {
+                for (x = 0; x < w; x++)
+                    printf("%3d", own[y*w+x]);
+                printf("\n");
+            }
+        }
+#endif
+
+        /*
+         * Go over the grid and figure out which squares can
+         * safely be added to, or removed from, each omino. We
+         * don't take account of other ominoes in this process, so
+         * we will often end up knowing that a square can be
+         * poached from one omino by another.
+         * 
+         * For each square, there may be up to four ominoes to
+         * which it can be added (those to which it is
+         * 4-adjacent).
+         */
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                int yx = y*w+x;
+                int curr = own[yx];
+                int dir;
+
+                if (curr < 0) {
+                    removable[yx] = FALSE; /* can't remove if not owned! */
+                } else if (sizes[curr] == 1) {
+                    removable[yx] = TRUE; /* can always remove a singleton */
+                } else {
+                    /*
+                     * See if this square can be removed from its
+                     * omino without disconnecting it.
+                     */
+                    removable[yx] = addremcommon(w, h, x, y, own, curr);
+                }
+
+                for (dir = 0; dir < 4; dir++) {
+                    int dx = (dir == 0 ? -1 : dir == 1 ? +1 : 0);
+                    int dy = (dir == 2 ? -1 : dir == 3 ? +1 : 0);
+                    int sx = x + dx, sy = y + dy;
+                    int syx = sy*w+sx;
+
+                    addable[yx*4+dir] = -1;
+
+                    if (sx < 0 || sx >= w || sy < 0 || sy >= h)
+                        continue;      /* no omino here! */
+                    if (own[syx] < 0)
+                        continue;      /* also no omino here */
+                    if (own[syx] == own[yx])
+                        continue;      /* we already got one */
+                    if (!addremcommon(w, h, x, y, own, own[syx]))
+                        continue;      /* would non-simply connect the omino */
+                    
+                    addable[yx*4+dir] = own[syx];
+                }
+            }
+        }
+
+        for (i = j = 0; i < n; i++)
+            if (sizes[i] < k)
+                tmp[j++] = i;
+        if (j == 0)
+            break;                     /* all ominoes are complete! */
+        j = tmp[random_upto(rs, j)];
+#ifdef DIVVY_DIAGNOSTICS
+        printf("Trying to extend %d\n", j);
+#endif
+
+        /*
+         * So we're trying to expand omino j. We breadth-first
+         * search out from j across the space of ominoes.
+         * 
+         * For bfs purposes, we use two elements of tmp per omino:
+         * tmp[2*i+0] tells us which omino we got to i from, and
+         * tmp[2*i+1] numbers the grid square that omino stole
+         * from us.
+         * 
+         * This requires that wh (the size of tmp) is at least 2n,
+         * i.e. k is at least 2. There would have been nothing to
+         * stop a user calling this function with k=1, but if they
+         * did then we wouldn't have got to _here_ in the code -
+         * we would have noticed above that all ominoes were
+         * already at their target sizes, and terminated :-)
+         */
+        assert(wh >= 2*n);
+        for (i = 0; i < n; i++)
+            tmp[2*i] = tmp[2*i+1] = -1;
+        qhead = qtail = 0;
+        queue[qtail++] = j;
+        tmp[2*j] = tmp[2*j+1] = -2;    /* special value: `starting point' */
+
+        while (qhead < qtail) {
+            int tmpsq;
+
+            j = queue[qhead];
+
+            /*
+             * We wish to expand omino j. However, we might have
+             * got here by omino j having a square stolen from it,
+             * so first of all we must temporarily mark that
+             * square as not belonging to j, so that our adjacency
+             * calculations don't assume j _does_ belong to us.
+             */
+            tmpsq = tmp[2*j+1];
+            if (tmpsq >= 0) {
+                assert(own[tmpsq] == j);
+                own[tmpsq] = -3;
+            }
+
+            /*
+             * OK. Now begin by seeing if we can find any
+             * unclaimed square into which we can expand omino j.
+             * If we find one, the entire bfs terminates.
+             */
+            for (i = 0; i < wh; i++) {
+                int dir;
+
+                if (own[order[i]] != -1)
+                    continue;          /* this square is claimed */
+
+                /*
+                 * Special case: if our current omino was size 1
+                 * and then had a square stolen from it, it's now
+                 * size zero, which means it's valid to `expand'
+                 * it into _any_ unclaimed square.
+                 */
+                if (sizes[j] == 1 && tmpsq >= 0)
+                    break;             /* got one */
+
+                /*
+                 * Failing that, we must do the full test for
+                 * addability.
+                 */
+                for (dir = 0; dir < 4; dir++)
+                    if (addable[order[i]*4+dir] == j) {
+                        /*
+                         * We know this square is addable to this
+                         * omino with the grid in the state it had
+                         * at the top of the loop. However, we
+                         * must now check that it's _still_
+                         * addable to this omino when the omino is
+                         * missing a square. To do this it's only
+                         * necessary to re-check addremcommon.
+                         */
+                        if (!addremcommon(w, h, order[i]%w, order[i]/w,
+                                          own, j))
+                            continue;
+                        break;
+                    }
+                if (dir == 4)
+                    continue;          /* we can't add this square to j */
+
+                break;                 /* got one! */
+            }
+            if (i < wh) {
+                i = order[i];
+
+                /*
+                 * Restore the temporarily removed square _before_
+                 * we start shifting ownerships about.
+                 */
+                if (tmpsq >= 0)
+                    own[tmpsq] = j;
+
+                /*
+                 * We are done. We can add square i to omino j,
+                 * and then backtrack along the trail in tmp
+                 * moving squares between ominoes, ending up
+                 * expanding our starting omino by one.
+                 */
+#ifdef DIVVY_DIAGNOSTICS
+                printf("(%d,%d)", i%w, i/w);
+#endif
+                while (1) {
+                    own[i] = j;
+#ifdef DIVVY_DIAGNOSTICS
+                    printf(" -> %d", j);
+#endif
+                    if (tmp[2*j] == -2)
+                        break;
+                    i = tmp[2*j+1];
+                    j = tmp[2*j];
+#ifdef DIVVY_DIAGNOSTICS
+                    printf("; (%d,%d)", i%w, i/w);
+#endif
+                }
+#ifdef DIVVY_DIAGNOSTICS
+                printf("\n");
+#endif
+
+                /*
+                 * Increment the size of the starting omino.
+                 */
+                sizes[j]++;
+
+                /*
+                 * Terminate the bfs loop.
+                 */
+                break;
+            }
+
+            /*
+             * If we get here, we haven't been able to expand
+             * omino j into an unclaimed square. So now we begin
+             * to investigate expanding it into squares which are
+             * claimed by ominoes the bfs has not yet visited.
+             */
+            for (i = 0; i < wh; i++) {
+                int dir, nj;
+
+                nj = own[order[i]];
+                if (nj < 0 || tmp[2*nj] != -1)
+                    continue;          /* unclaimed, or owned by wrong omino */
+                if (!removable[order[i]])
+                    continue;          /* its omino won't let it go */
+
+                for (dir = 0; dir < 4; dir++)
+                    if (addable[order[i]*4+dir] == j) {
+                        /*
+                         * As above, re-check addremcommon.
+                         */
+                        if (!addremcommon(w, h, order[i]%w, order[i]/w,
+                                          own, j))
+                            continue;
+
+                        /*
+                         * We have found a square we can use to
+                         * expand omino j, at the expense of the
+                         * as-yet unvisited omino nj. So add this
+                         * to the bfs queue.
+                         */
+                        assert(qtail < n);
+                        queue[qtail++] = nj;
+                        tmp[2*nj] = j;
+                        tmp[2*nj+1] = order[i];
+
+                        /*
+                         * Now terminate the loop over dir, to
+                         * ensure we don't accidentally add the
+                         * same omino twice to the queue.
+                         */
+                        break;
+                    }
+            }
+
+            /*
+             * Restore the temporarily removed square.
+             */
+            if (tmpsq >= 0)
+                own[tmpsq] = j;
+
+            /*
+             * Advance the queue head.
+             */
+            qhead++;
+        }
+
+        if (qhead == qtail) {
+            /*
+             * We have finished the bfs and not found any way to
+             * expand omino j. Panic, and return failure.
+             * 
+             * FIXME: or should we loop over all ominoes before we
+             * give up?
+             */
+#ifdef DIVVY_DIAGNOSTICS
+            printf("FAIL!\n");
+#endif
+            retdsf = NULL;
+            goto cleanup;
+        }
+    }
+
+#ifdef DIVVY_DIAGNOSTICS
+    {
+        int x, y;
+        printf("SUCCESS! Final grid:\n");
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++)
+                printf("%3d", own[y*w+x]);
+            printf("\n");
+        }
+    }
+#endif
+
+    /*
+     * Construct the output dsf.
+     */
+    for (i = 0; i < wh; i++) {
+        assert(own[i] >= 0 && own[i] < n);
+        tmp[own[i]] = i;
+    }
+    retdsf = snew_dsf(wh);
+    for (i = 0; i < wh; i++) {
+        dsf_merge(retdsf, i, tmp[own[i]]);
+    }
+
+    /*
+     * Construct the output dsf a different way, to verify that
+     * the ominoes really are k-ominoes and we haven't
+     * accidentally split one into two disconnected pieces.
+     */
+    dsf_init(tmp, wh);
+    for (y = 0; y < h; y++)
+        for (x = 0; x+1 < w; x++)
+            if (own[y*w+x] == own[y*w+(x+1)])
+                dsf_merge(tmp, y*w+x, y*w+(x+1));
+    for (x = 0; x < w; x++)
+        for (y = 0; y+1 < h; y++)
+            if (own[y*w+x] == own[(y+1)*w+x])
+                dsf_merge(tmp, y*w+x, (y+1)*w+x);
+    for (i = 0; i < wh; i++) {
+        j = dsf_canonify(retdsf, i);
+        assert(dsf_canonify(tmp, j) == dsf_canonify(tmp, i));
+    }
+
+    cleanup:
+
+    /*
+     * Free our temporary working space.
+     */
+    sfree(order);
+    sfree(tmp);
+    sfree(own);
+    sfree(sizes);
+    sfree(queue);
+    sfree(addable);
+    sfree(removable);
+
+    /*
+     * And we're done.
+     */
+    return retdsf;
+}
+
+#ifdef TESTMODE
+static int fail_counter = 0;
+#endif
+
+int *divvy_rectangle(int w, int h, int k, random_state *rs)
+{
+    int *ret;
+
+    do {
+        ret = divvy_internal(w, h, k, rs);
+
+#ifdef TESTMODE
+        if (!ret)
+            fail_counter++;
+#endif
+
+    } while (!ret);
+
+    return ret;
+}
+
+#ifdef TESTMODE
+
+/*
+ * gcc -g -O0 -DTESTMODE -I.. -o divvy divvy.c ../random.c ../malloc.c ../dsf.c ../misc.c ../nullfe.c
+ * 
+ * or to debug
+ * 
+ * gcc -g -O0 -DDIVVY_DIAGNOSTICS -DTESTMODE -I.. -o divvy divvy.c ../random.c ../malloc.c ../dsf.c ../misc.c ../nullfe.c
+ */
+
+int main(int argc, char **argv)
+{
+    int *dsf;
+    int i;
+    int w = 9, h = 4, k = 6, tries = 100;
+    random_state *rs;
+
+    rs = random_new("123456", 6);
+
+    if (argc > 1)
+        w = atoi(argv[1]);
+    if (argc > 2)
+        h = atoi(argv[2]);
+    if (argc > 3)
+        k = atoi(argv[3]);
+    if (argc > 4)
+        tries = atoi(argv[4]);
+
+    for (i = 0; i < tries; i++) {
+        int x, y;
+
+        dsf = divvy_rectangle(w, h, k, rs);
+        assert(dsf);
+
+        for (y = 0; y <= 2*h; y++) {
+            for (x = 0; x <= 2*w; x++) {
+                int miny = y/2 - 1, maxy = y/2;
+                int minx = x/2 - 1, maxx = x/2;
+                int classes[4], tx, ty;
+                for (ty = 0; ty < 2; ty++)
+                    for (tx = 0; tx < 2; tx++) {
+                        int cx = minx+tx, cy = miny+ty;
+                        if (cx < 0 || cx >= w || cy < 0 || cy >= h)
+                            classes[ty*2+tx] = -1;
+                        else
+                            classes[ty*2+tx] = dsf_canonify(dsf, cy*w+cx);
+                    }
+                switch (y%2 * 2 + x%2) {
+                  case 0:              /* corner */
+                    /*
+                     * Cases for the corner:
+                     *
+                     *  - if all four surrounding squares belong
+                     *    to the same omino, we print a space.
+                     *
+                     *  - if the top two are the same and the
+                     *    bottom two are the same, we print a
+                     *    horizontal line.
+                     *
+                     *  - if the left two are the same and the
+                     *    right two are the same, we print a
+                     *    vertical line.
+                     *
+                     *  - otherwise, we print a cross.
+                     */
+                    if (classes[0] == classes[1] &&
+                        classes[1] == classes[2] &&
+                        classes[2] == classes[3])
+                        printf(" ");
+                    else if (classes[0] == classes[1] &&
+                             classes[2] == classes[3])
+                        printf("-");
+                    else if (classes[0] == classes[2] &&
+                             classes[1] == classes[3])
+                        printf("|");
+                    else
+                        printf("+");
+                    break;
+                  case 1:              /* horiz edge */
+                    if (classes[1] == classes[3])
+                        printf("  ");
+                    else
+                        printf("--");
+                    break;
+                  case 2:              /* vert edge */
+                    if (classes[2] == classes[3])
+                        printf(" ");
+                    else
+                        printf("|");
+                    break;
+                  case 3:              /* square centre */
+                    printf("  ");
+                    break;
+                }
+            }
+            printf("\n");
+        }
+        printf("\n");
+        sfree(dsf);
+    }
+
+    printf("%d retries needed for %d successes\n", fail_counter, tries);
+
+    return 0;
+}
+
+#endif
diff --git a/apps/plugins/puzzles/dominosa.R b/apps/plugins/puzzles/dominosa.R
new file mode 100644
index 0000000000..99218366e6
--- /dev/null
+++ b/apps/plugins/puzzles/dominosa.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+DOMINOSA_EXTRA = laydomino
+
+dominosa : [X] GTK COMMON dominosa DOMINOSA_EXTRA dominosa-icon|no-icon
+
+dominosa : [G] WINDOWS COMMON dominosa DOMINOSA_EXTRA dominosa.res|noicon.res
+
+ALL += dominosa[COMBINED] DOMINOSA_EXTRA
+
+!begin am gtk
+GAMES += dominosa
+!end
+
+!begin >list.c
+    A(dominosa) \
+!end
+
+!begin >gamedesc.txt
+dominosa:dominosa.exe:Dominosa:Domino tiling puzzle:Tile the rectangle with a full set of dominoes.
+!end
diff --git a/apps/plugins/puzzles/dominosa.c b/apps/plugins/puzzles/dominosa.c
new file mode 100644
index 0000000000..a2dd69ba86
--- /dev/null
+++ b/apps/plugins/puzzles/dominosa.c
@@ -0,0 +1,1748 @@
+/*
+ * dominosa.c: Domino jigsaw puzzle. Aim to place one of every
+ * possible domino within a rectangle in such a way that the number
+ * on each square matches the provided clue.
+ */
+
+/*
+ * TODO:
+ * 
+ *  - improve solver so as to use more interesting forms of
+ *    deduction
+ *
+ *     * rule out a domino placement if it would divide an unfilled
+ *       region such that at least one resulting region had an odd
+ *       area
+ *        + use b.f.s. to determine the area of an unfilled region
+ *        + a square is unfilled iff it has at least two possible
+ *          placements, and two adjacent unfilled squares are part
+ *          of the same region iff the domino placement joining
+ *          them is possible
+ *
+ *     * perhaps set analysis
+ *        + look at all unclaimed squares containing a given number
+ *        + for each one, find the set of possible numbers that it
+ *          can connect to (i.e. each neighbouring tile such that
+ *          the placement between it and that neighbour has not yet
+ *          been ruled out)
+ *        + now proceed similarly to Solo set analysis: try to find
+ *          a subset of the squares such that the union of their
+ *          possible numbers is the same size as the subset. If so,
+ *          rule out those possible numbers for all other squares.
+ *           * important wrinkle: the double dominoes complicate
+ *             matters. Connecting a number to itself uses up _two_
+ *             of the unclaimed squares containing a number. Thus,
+ *             when finding the initial subset we must never
+ *             include two adjacent squares; and also, when ruling
+ *             things out after finding the subset, we must be
+ *             careful that we don't rule out precisely the domino
+ *             placement that was _included_ in our set!
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+/* nth triangular number */
+#define TRI(n) ( (n) * ((n) + 1) / 2 )
+/* number of dominoes for value n */
+#define DCOUNT(n) TRI((n)+1)
+/* map a pair of numbers to a unique domino index from 0 upwards. */
+#define DINDEX(n1,n2) ( TRI(max(n1,n2)) + min(n1,n2) )
+
+#define FLASH_TIME 0.13F
+
+enum {
+    COL_BACKGROUND,
+    COL_TEXT,
+    COL_DOMINO,
+    COL_DOMINOCLASH,
+    COL_DOMINOTEXT,
+    COL_EDGE,
+    COL_HIGHLIGHT_1,
+    COL_HIGHLIGHT_2,
+    NCOLOURS
+};
+
+struct game_params {
+    int n;
+    int unique;
+};
+
+struct game_numbers {
+    int refcount;
+    int *numbers;                      /* h x w */
+};
+
+#define EDGE_L 0x100
+#define EDGE_R 0x200
+#define EDGE_T 0x400
+#define EDGE_B 0x800
+
+struct game_state {
+    game_params params;
+    int w, h;
+    struct game_numbers *numbers;
+    int *grid;
+    unsigned short *edges;             /* h x w */
+    int completed, cheated;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->n = 6;
+    ret->unique = TRUE;
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    int n;
+    char buf[80];
+
+    switch (i) {
+      case 0: n = 3; break;
+      case 1: n = 4; break;
+      case 2: n = 5; break;
+      case 3: n = 6; break;
+      case 4: n = 7; break;
+      case 5: n = 8; break;
+      case 6: n = 9; break;
+      default: return FALSE;
+    }
+
+    sprintf(buf, "Up to double-%d", n);
+    *name = dupstr(buf);
+
+    *params = ret = snew(game_params);
+    ret->n = n;
+    ret->unique = TRUE;
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->n = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'a')
+        params->unique = FALSE;
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[80];
+    sprintf(buf, "%d", params->n);
+    if (full && !params->unique)
+        strcat(buf, "a");
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(3, config_item);
+
+    ret[0].name = "Maximum number on dominoes";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->n);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Ensure unique solution";
+    ret[1].type = C_BOOLEAN;
+    ret[1].sval = NULL;
+    ret[1].ival = params->unique;
+
+    ret[2].name = NULL;
+    ret[2].type = C_END;
+    ret[2].sval = NULL;
+    ret[2].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->n = atoi(cfg[0].sval);
+    ret->unique = cfg[1].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->n < 1)
+        return "Maximum face number must be at least one";
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver.
+ */
+
+static int find_overlaps(int w, int h, int placement, int *set)
+{
+    int x, y, n;
+
+    n = 0;                             /* number of returned placements */
+
+    x = placement / 2;
+    y = x / w;
+    x %= w;
+
+    if (placement & 1) {
+        /*
+         * Horizontal domino, indexed by its left end.
+         */
+        if (x > 0)
+            set[n++] = placement-2;    /* horizontal domino to the left */
+        if (y > 0)
+            set[n++] = placement-2*w-1;/* vertical domino above left side */
+        if (y+1 < h)
+            set[n++] = placement-1;    /* vertical domino below left side */
+        if (x+2 < w)
+            set[n++] = placement+2;    /* horizontal domino to the right */
+        if (y > 0)
+            set[n++] = placement-2*w+2-1;/* vertical domino above right side */
+        if (y+1 < h)
+            set[n++] = placement+2-1;  /* vertical domino below right side */
+    } else {
+        /*
+         * Vertical domino, indexed by its top end.
+         */
+        if (y > 0)
+            set[n++] = placement-2*w;  /* vertical domino above */
+        if (x > 0)
+            set[n++] = placement-2+1;  /* horizontal domino left of top */
+        if (x+1 < w)
+            set[n++] = placement+1;    /* horizontal domino right of top */
+        if (y+2 < h)
+            set[n++] = placement+2*w;  /* vertical domino below */
+        if (x > 0)
+            set[n++] = placement-2+2*w+1;/* horizontal domino left of bottom */
+        if (x+1 < w)
+            set[n++] = placement+2*w+1;/* horizontal domino right of bottom */
+    }
+
+    return n;
+}
+
+/*
+ * Returns 0, 1 or 2 for number of solutions. 2 means `any number
+ * more than one', or more accurately `we were unable to prove
+ * there was only one'.
+ * 
+ * Outputs in a `placements' array, indexed the same way as the one
+ * within this function (see below); entries in there are <0 for a
+ * placement ruled out, 0 for an uncertain placement, and 1 for a
+ * definite one.
+ */
+static int solver(int w, int h, int n, int *grid, int *output)
+{
+    int wh = w*h, dc = DCOUNT(n);
+    int *placements, *heads;
+    int i, j, x, y, ret;
+
+    /*
+     * This array has one entry for every possible domino
+     * placement. Vertical placements are indexed by their top
+     * half, at (y*w+x)*2; horizontal placements are indexed by
+     * their left half at (y*w+x)*2+1.
+     * 
+     * This array is used to link domino placements together into
+     * linked lists, so that we can track all the possible
+     * placements of each different domino. It's also used as a
+     * quick means of looking up an individual placement to see
+     * whether we still think it's possible. Actual values stored
+     * in this array are -2 (placement not possible at all), -1
+     * (end of list), or the array index of the next item.
+     * 
+     * Oh, and -3 for `not even valid', used for array indices
+     * which don't even represent a plausible placement.
+     */
+    placements = snewn(2*wh, int);
+    for (i = 0; i < 2*wh; i++)
+        placements[i] = -3;            /* not even valid */
+
+    /*
+     * This array has one entry for every domino, and it is an
+     * index into `placements' denoting the head of the placement
+     * list for that domino.
+     */
+    heads = snewn(dc, int);
+    for (i = 0; i < dc; i++)
+        heads[i] = -1;
+
+    /*
+     * Set up the initial possibility lists by scanning the grid.
+     */
+    for (y = 0; y < h-1; y++)
+        for (x = 0; x < w; x++) {
+            int di = DINDEX(grid[y*w+x], grid[(y+1)*w+x]);
+            placements[(y*w+x)*2] = heads[di];
+            heads[di] = (y*w+x)*2;
+        }
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w-1; x++) {
+            int di = DINDEX(grid[y*w+x], grid[y*w+(x+1)]);
+            placements[(y*w+x)*2+1] = heads[di];
+            heads[di] = (y*w+x)*2+1;
+        }
+
+#ifdef SOLVER_DIAGNOSTICS
+    printf("before solver:\n");
+    for (i = 0; i <= n; i++)
+        for (j = 0; j <= i; j++) {
+            int k, m;
+            m = 0;
+            printf("%2d [%d %d]:", DINDEX(i, j), i, j);
+            for (k = heads[DINDEX(i,j)]; k >= 0; k = placements[k])
+                printf(" %3d [%d,%d,%c]", k, k/2%w, k/2/w, k%2?'h':'v');
+            printf("\n");
+        }
+#endif
+
+    while (1) {
+        int done_something = FALSE;
+
+        /*
+         * For each domino, look at its possible placements, and
+         * for each placement consider the placements (of any
+         * domino) it overlaps. Any placement overlapped by all
+         * placements of this domino can be ruled out.
+         * 
+         * Each domino placement overlaps only six others, so we
+         * need not do serious set theory to work this out.
+         */
+        for (i = 0; i < dc; i++) {
+            int permset[6], permlen = 0, p;
+            
+
+            if (heads[i] == -1) {      /* no placement for this domino */
+                ret = 0;               /* therefore puzzle is impossible */
+                goto done;
+            }
+            for (j = heads[i]; j >= 0; j = placements[j]) {
+                assert(placements[j] != -2);
+
+                if (j == heads[i]) {
+                    permlen = find_overlaps(w, h, j, permset);
+                } else {
+                    int tempset[6], templen, m, n, k;
+
+                    templen = find_overlaps(w, h, j, tempset);
+
+                    /*
+                     * Pathetically primitive set intersection
+                     * algorithm, which I'm only getting away with
+                     * because I know my sets are bounded by a very
+                     * small size.
+                     */
+                    for (m = n = 0; m < permlen; m++) {
+                        for (k = 0; k < templen; k++)
+                            if (tempset[k] == permset[m])
+                                break;
+                        if (k < templen)
+                            permset[n++] = permset[m];
+                    }
+                    permlen = n;
+                }
+            }
+            for (p = 0; p < permlen; p++) {
+                j = permset[p];
+                if (placements[j] != -2) {
+                    int p1, p2, di;
+
+                    done_something = TRUE;
+
+                    /*
+                     * Rule out this placement. First find what
+                     * domino it is...
+                     */
+                    p1 = j / 2;
+                    p2 = (j & 1) ? p1 + 1 : p1 + w;
+                    di = DINDEX(grid[p1], grid[p2]);
+#ifdef SOLVER_DIAGNOSTICS
+                    printf("considering domino %d: ruling out placement %d"
+                           " for %d\n", i, j, di);
+#endif
+
+                    /*
+                     * ... then walk that domino's placement list,
+                     * removing this placement when we find it.
+                     */
+                    if (heads[di] == j)
+                        heads[di] = placements[j];
+                    else {
+                        int k = heads[di];
+                        while (placements[k] != -1 && placements[k] != j)
+                            k = placements[k];
+                        assert(placements[k] == j);
+                        placements[k] = placements[j];
+                    }
+                    placements[j] = -2;
+                }
+            }
+        }
+
+        /*
+         * For each square, look at the available placements
+         * involving that square. If all of them are for the same
+         * domino, then rule out any placements for that domino
+         * _not_ involving this square.
+         */
+        for (i = 0; i < wh; i++) {
+            int list[4], k, n, adi;
+
+            x = i % w;
+            y = i / w;
+
+            j = 0;
+            if (x > 0)
+                list[j++] = 2*(i-1)+1;
+            if (x+1 < w)
+                list[j++] = 2*i+1;
+            if (y > 0)
+                list[j++] = 2*(i-w);
+            if (y+1 < h)
+                list[j++] = 2*i;
+
+            for (n = k = 0; k < j; k++)
+                if (placements[list[k]] >= -1)
+                    list[n++] = list[k];
+
+            adi = -1;
+
+            for (j = 0; j < n; j++) {
+                int p1, p2, di;
+                k = list[j];
+
+                p1 = k / 2;
+                p2 = (k & 1) ? p1 + 1 : p1 + w;
+                di = DINDEX(grid[p1], grid[p2]);
+
+                if (adi == -1)
+                    adi = di;
+                if (adi != di)
+                    break;
+            }
+
+            if (j == n) {
+                int nn;
+
+                assert(adi >= 0);
+                /*
+                 * We've found something. All viable placements
+                 * involving this square are for domino `adi'. If
+                 * the current placement list for that domino is
+                 * longer than n, reduce it to precisely this
+                 * placement list and we've done something.
+                 */
+                nn = 0;
+                for (k = heads[adi]; k >= 0; k = placements[k])
+                    nn++;
+                if (nn > n) {
+                    done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                    printf("considering square %d,%d: reducing placements "
+                           "of domino %d\n", x, y, adi);
+#endif
+                    /*
+                     * Set all other placements on the list to
+                     * impossible.
+                     */
+                    k = heads[adi];
+                    while (k >= 0) {
+                        int tmp = placements[k];
+                        placements[k] = -2;
+                        k = tmp;
+                    }
+                    /*
+                     * Set up the new list.
+                     */
+                    heads[adi] = list[0];
+                    for (k = 0; k < n; k++)
+                        placements[list[k]] = (k+1 == n ? -1 : list[k+1]);
+                }
+            }
+        }
+
+        if (!done_something)
+            break;
+    }
+
+#ifdef SOLVER_DIAGNOSTICS
+    printf("after solver:\n");
+    for (i = 0; i <= n; i++)
+        for (j = 0; j <= i; j++) {
+            int k, m;
+            m = 0;
+            printf("%2d [%d %d]:", DINDEX(i, j), i, j);
+            for (k = heads[DINDEX(i,j)]; k >= 0; k = placements[k])
+                printf(" %3d [%d,%d,%c]", k, k/2%w, k/2/w, k%2?'h':'v');
+            printf("\n");
+        }
+#endif
+
+    ret = 1;
+    for (i = 0; i < wh*2; i++) {
+        if (placements[i] == -2) {
+            if (output)
+                output[i] = -1;        /* ruled out */
+        } else if (placements[i] != -3) {
+            int p1, p2, di;
+
+            p1 = i / 2;
+            p2 = (i & 1) ? p1 + 1 : p1 + w;
+            di = DINDEX(grid[p1], grid[p2]);
+
+            if (i == heads[di] && placements[i] == -1) {
+                if (output)
+                    output[i] = 1;     /* certain */
+            } else {
+                if (output)
+                    output[i] = 0;     /* uncertain */
+                ret = 2;
+            }
+        }
+    }
+
+    done:
+    /*
+     * Free working data.
+     */
+    sfree(placements);
+    sfree(heads);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * End of solver code.
+ */
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int n = params->n, w = n+2, h = n+1, wh = w*h;
+    int *grid, *grid2, *list;
+    int i, j, k, len;
+    char *ret;
+
+    /*
+     * Allocate space in which to lay the grid out.
+     */
+    grid = snewn(wh, int);
+    grid2 = snewn(wh, int);
+    list = snewn(2*wh, int);
+
+    /*
+     * I haven't been able to think of any particularly clever
+     * techniques for generating instances of Dominosa with a
+     * unique solution. Many of the deductions used in this puzzle
+     * are based on information involving half the grid at a time
+     * (`of all the 6s, exactly one is next to a 3'), so a strategy
+     * of partially solving the grid and then perturbing the place
+     * where the solver got stuck seems particularly likely to
+     * accidentally destroy the information which the solver had
+     * used in getting that far. (Contrast with, say, Mines, in
+     * which most deductions are local so this is an excellent
+     * strategy.)
+     *
+     * Therefore I resort to the basest of brute force methods:
+     * generate a random grid, see if it's solvable, throw it away
+     * and try again if not. My only concession to sophistication
+     * and cleverness is to at least _try_ not to generate obvious
+     * 2x2 ambiguous sections (see comment below in the domino-
+     * flipping section).
+     *
+     * During tests performed on 2005-07-15, I found that the brute
+     * force approach without that tweak had to throw away about 87
+     * grids on average (at the default n=6) before finding a
+     * unique one, or a staggering 379 at n=9; good job the
+     * generator and solver are fast! When I added the
+     * ambiguous-section avoidance, those numbers came down to 19
+     * and 26 respectively, which is a lot more sensible.
+     */
+
+    do {
+        domino_layout_prealloc(w, h, rs, grid, grid2, list);
+
+        /*
+         * Now we have a complete layout covering the whole
+         * rectangle with dominoes. So shuffle the actual domino
+         * values and fill the rectangle with numbers.
+         */
+        k = 0;
+        for (i = 0; i <= params->n; i++)
+            for (j = 0; j <= i; j++) {
+                list[k++] = i;
+                list[k++] = j;
+            }
+        shuffle(list, k/2, 2*sizeof(*list), rs);
+        j = 0;
+        for (i = 0; i < wh; i++)
+            if (grid[i] > i) {
+                /* Optionally flip the domino round. */
+                int flip = -1;
+
+                if (params->unique) {
+                    int t1, t2;
+                    /*
+                     * If we're after a unique solution, we can do
+                     * something here to improve the chances. If
+                     * we're placing a domino so that it forms a
+                     * 2x2 rectangle with one we've already placed,
+                     * and if that domino and this one share a
+                     * number, we can try not to put them so that
+                     * the identical numbers are diagonally
+                     * separated, because that automatically causes
+                     * non-uniqueness:
+                     * 
+                     * +---+      +-+-+
+                     * |2 3|      |2|3|
+                     * +---+  ->  | | |
+                     * |4 2|      |4|2|
+                     * +---+      +-+-+
+                     */
+                    t1 = i;
+                    t2 = grid[i];
+                    if (t2 == t1 + w) {  /* this domino is vertical */
+                        if (t1 % w > 0 &&/* and not on the left hand edge */
+                            grid[t1-1] == t2-1 &&/* alongside one to left */
+                            (grid2[t1-1] == list[j] ||   /* and has a number */
+                             grid2[t1-1] == list[j+1] ||   /* in common */
+                             grid2[t2-1] == list[j] ||
+                             grid2[t2-1] == list[j+1])) {
+                            if (grid2[t1-1] == list[j] ||
+                                grid2[t2-1] == list[j+1])
+                                flip = 0;
+                            else
+                                flip = 1;
+                        }
+                    } else {           /* this domino is horizontal */
+                        if (t1 / w > 0 &&/* and not on the top edge */
+                            grid[t1-w] == t2-w &&/* alongside one above */
+                            (grid2[t1-w] == list[j] ||   /* and has a number */
+                             grid2[t1-w] == list[j+1] ||   /* in common */
+                             grid2[t2-w] == list[j] ||
+                             grid2[t2-w] == list[j+1])) {
+                            if (grid2[t1-w] == list[j] ||
+                                grid2[t2-w] == list[j+1])
+                                flip = 0;
+                            else
+                                flip = 1;
+                        }
+                    }
+                }
+
+                if (flip < 0)
+                    flip = random_upto(rs, 2);
+
+                grid2[i] = list[j + flip];
+                grid2[grid[i]] = list[j + 1 - flip];
+                j += 2;
+            }
+        assert(j == k);
+    } while (params->unique && solver(w, h, n, grid2, NULL) > 1);
+
+#ifdef GENERATION_DIAGNOSTICS
+    for (j = 0; j < h; j++) {
+        for (i = 0; i < w; i++) {
+            putchar('0' + grid2[j*w+i]);
+        }
+        putchar('\n');
+    }
+    putchar('\n');
+#endif
+
+    /*
+     * Encode the resulting game state.
+     * 
+     * Our encoding is a string of digits. Any number greater than
+     * 9 is represented by a decimal integer within square
+     * brackets. We know there are n+2 of every number (it's paired
+     * with each number from 0 to n inclusive, and one of those is
+     * itself so that adds another occurrence), so we can work out
+     * the string length in advance.
+     */
+
+    /*
+     * To work out the total length of the decimal encodings of all
+     * the numbers from 0 to n inclusive:
+     *  - every number has a units digit; total is n+1.
+     *  - all numbers above 9 have a tens digit; total is max(n+1-10,0).
+     *  - all numbers above 99 have a hundreds digit; total is max(n+1-100,0).
+     *  - and so on.
+     */
+    len = n+1;
+    for (i = 10; i <= n; i *= 10)
+        len += max(n + 1 - i, 0);
+    /* Now add two square brackets for each number above 9. */
+    len += 2 * max(n + 1 - 10, 0);
+    /* And multiply by n+2 for the repeated occurrences of each number. */
+    len *= n+2;
+
+    /*
+     * Now actually encode the string.
+     */
+    ret = snewn(len+1, char);
+    j = 0;
+    for (i = 0; i < wh; i++) {
+        k = grid2[i];
+        if (k < 10)
+            ret[j++] = '0' + k;
+        else
+            j += sprintf(ret+j, "[%d]", k);
+        assert(j <= len);
+    }
+    assert(j == len);
+    ret[j] = '\0';
+
+    /*
+     * Encode the solved state as an aux_info.
+     */
+    {
+        char *auxinfo = snewn(wh+1, char);
+
+        for (i = 0; i < wh; i++) {
+            int v = grid[i];
+            auxinfo[i] = (v == i+1 ? 'L' : v == i-1 ? 'R' :
+                          v == i+w ? 'T' : v == i-w ? 'B' : '.');
+        }
+        auxinfo[wh] = '\0';
+
+        *aux = auxinfo;
+    }
+
+    sfree(list);
+    sfree(grid2);
+    sfree(grid);
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int n = params->n, w = n+2, h = n+1, wh = w*h;
+    int *occurrences;
+    int i, j;
+    char *ret;
+
+    ret = NULL;
+    occurrences = snewn(n+1, int);
+    for (i = 0; i <= n; i++)
+        occurrences[i] = 0;
+
+    for (i = 0; i < wh; i++) {
+        if (!*desc) {
+            ret = ret ? ret : "Game description is too short";
+        } else {
+            if (*desc >= '0' && *desc <= '9')
+                j = *desc++ - '0';
+            else if (*desc == '[') {
+                desc++;
+                j = atoi(desc);
+                while (*desc && isdigit((unsigned char)*desc)) desc++;
+                if (*desc != ']')
+                    ret = ret ? ret : "Missing ']' in game description";
+                else
+                    desc++;
+            } else {
+                j = -1;
+                ret = ret ? ret : "Invalid syntax in game description";
+            }
+            if (j < 0 || j > n)
+                ret = ret ? ret : "Number out of range in game description";
+            else
+                occurrences[j]++;
+        }
+    }
+
+    if (*desc)
+        ret = ret ? ret : "Game description is too long";
+
+    if (!ret) {
+        for (i = 0; i <= n; i++)
+            if (occurrences[i] != n+2)
+                ret = "Incorrect number balance in game description";
+    }
+
+    sfree(occurrences);
+
+    return ret;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int n = params->n, w = n+2, h = n+1, wh = w*h;
+    game_state *state = snew(game_state);
+    int i, j;
+
+    state->params = *params;
+    state->w = w;
+    state->h = h;
+
+    state->grid = snewn(wh, int);
+    for (i = 0; i < wh; i++)
+        state->grid[i] = i;
+
+    state->edges = snewn(wh, unsigned short);
+    for (i = 0; i < wh; i++)
+        state->edges[i] = 0;
+
+    state->numbers = snew(struct game_numbers);
+    state->numbers->refcount = 1;
+    state->numbers->numbers = snewn(wh, int);
+
+    for (i = 0; i < wh; i++) {
+        assert(*desc);
+        if (*desc >= '0' && *desc <= '9')
+            j = *desc++ - '0';
+        else {
+            assert(*desc == '[');
+            desc++;
+            j = atoi(desc);
+            while (*desc && isdigit((unsigned char)*desc)) desc++;
+            assert(*desc == ']');
+            desc++;
+        }
+        assert(j >= 0 && j <= n);
+        state->numbers->numbers[i] = j;
+    }
+
+    state->completed = state->cheated = FALSE;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int n = state->params.n, w = n+2, h = n+1, wh = w*h;
+    game_state *ret = snew(game_state);
+
+    ret->params = state->params;
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->grid = snewn(wh, int);
+    memcpy(ret->grid, state->grid, wh * sizeof(int));
+    ret->edges = snewn(wh, unsigned short);
+    memcpy(ret->edges, state->edges, wh * sizeof(unsigned short));
+    ret->numbers = state->numbers;
+    ret->numbers->refcount++;
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    sfree(state->edges);
+    if (--state->numbers->refcount <= 0) {
+        sfree(state->numbers->numbers);
+        sfree(state->numbers);
+    }
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int n = state->params.n, w = n+2, h = n+1, wh = w*h;
+    int *placements;
+    char *ret;
+    int retlen, retsize;
+    int i, v;
+    char buf[80];
+    int extra;
+
+    if (aux) {
+        retsize = 256;
+        ret = snewn(retsize, char);
+        retlen = sprintf(ret, "S");
+
+        for (i = 0; i < wh; i++) {
+            if (aux[i] == 'L')
+                extra = sprintf(buf, ";D%d,%d", i, i+1);
+            else if (aux[i] == 'T')
+                extra = sprintf(buf, ";D%d,%d", i, i+w);
+            else
+                continue;
+
+            if (retlen + extra + 1 >= retsize) {
+                retsize = retlen + extra + 256;
+                ret = sresize(ret, retsize, char);
+            }
+            strcpy(ret + retlen, buf);
+            retlen += extra;
+        }
+
+    } else {
+
+        placements = snewn(wh*2, int);
+        for (i = 0; i < wh*2; i++)
+            placements[i] = -3;
+        solver(w, h, n, state->numbers->numbers, placements);
+
+        /*
+         * First make a pass putting in edges for -1, then make a pass
+         * putting in dominoes for +1.
+         */
+        retsize = 256;
+        ret = snewn(retsize, char);
+        retlen = sprintf(ret, "S");
+
+        for (v = -1; v <= +1; v += 2)
+            for (i = 0; i < wh*2; i++)
+                if (placements[i] == v) {
+                    int p1 = i / 2;
+                    int p2 = (i & 1) ? p1+1 : p1+w;
+
+                    extra = sprintf(buf, ";%c%d,%d",
+                                    (int)(v==-1 ? 'E' : 'D'), p1, p2);
+
+                    if (retlen + extra + 1 >= retsize) {
+                        retsize = retlen + extra + 256;
+                        ret = sresize(ret, retsize, char);
+                    }
+                    strcpy(ret + retlen, buf);
+                    retlen += extra;
+                }
+
+        sfree(placements);
+    }
+
+    return ret;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return params->n < 1000;
+}
+
+static void draw_domino(char *board, int start, char corner,
+                        int dshort, int nshort, char cshort,
+                        int dlong, int nlong, char clong)
+{
+    int go_short = nshort*dshort, go_long = nlong*dlong, i;
+
+    board[start] = corner;
+    board[start + go_short] = corner;
+    board[start + go_long] = corner;
+    board[start + go_short + go_long] = corner;
+
+    for (i = 1; i < nshort; ++i) {
+        int j = start + i*dshort, k = start + i*dshort + go_long;
+        if (board[j] != corner) board[j] = cshort;
+        if (board[k] != corner) board[k] = cshort;
+    }
+
+    for (i = 1; i < nlong; ++i) {
+        int j = start + i*dlong, k = start + i*dlong + go_short;
+        if (board[j] != corner) board[j] = clong;
+        if (board[k] != corner) board[k] = clong;
+    }
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->w, h = state->h, r, c;
+    int cw = 4, ch = 2, gw = cw*w + 2, gh = ch * h + 1, len = gw * gh;
+    char *board = snewn(len + 1, char);
+
+    memset(board, ' ', len);
+
+    for (r = 0; r < h; ++r) {
+        for (c = 0; c < w; ++c) {
+            int cell = r*ch*gw + cw*c, center = cell + gw*ch/2 + cw/2;
+            int i = r*w + c, num = state->numbers->numbers[i];
+
+            if (num < 100) {
+                board[center] = '0' + num % 10;
+                if (num >= 10) board[center - 1] = '0' + num / 10;
+            } else {
+                board[center+1] = '0' + num % 10;
+                board[center] = '0' + num / 10 % 10;
+                board[center-1] = '0' + num / 100;
+            }
+
+            if (state->edges[i] & EDGE_L) board[center - cw/2] = '|';
+            if (state->edges[i] & EDGE_R) board[center + cw/2] = '|';
+            if (state->edges[i] & EDGE_T) board[center - gw] = '-';
+            if (state->edges[i] & EDGE_B) board[center + gw] = '-';
+
+            if (state->grid[i] == i) continue; /* no domino pairing */
+            if (state->grid[i] < i) continue; /* already done */
+            assert (state->grid[i] == i + 1 || state->grid[i] == i + w);
+            if (state->grid[i] == i + 1)
+                draw_domino(board, cell, '+', gw, ch, '|', +1, 2*cw, '-');
+            else if (state->grid[i] == i + w)
+                draw_domino(board, cell, '+', +1, cw, '-', gw, 2*ch, '|');
+        }
+        board[r*ch*gw + gw - 1] = '\n';
+        board[r*ch*gw + gw + gw - 1] = '\n';
+    }
+    board[len - 1] = '\n';
+    board[len] = '\0';
+    return board;
+}
+
+struct game_ui {
+    int cur_x, cur_y, cur_visible, highlight_1, highlight_2;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->cur_x = ui->cur_y = 0;
+    ui->cur_visible = 0;
+    ui->highlight_1 = ui->highlight_2 = -1;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    if (!oldstate->completed && newstate->completed)
+        ui->cur_visible = 0;
+}
+
+#define PREFERRED_TILESIZE 32
+#define TILESIZE (ds->tilesize)
+#define BORDER (TILESIZE * 3 / 4)
+#define DOMINO_GUTTER (TILESIZE / 16)
+#define DOMINO_RADIUS (TILESIZE / 8)
+#define DOMINO_COFFSET (DOMINO_GUTTER + DOMINO_RADIUS)
+#define CURSOR_RADIUS (TILESIZE / 4)
+
+#define COORD(x) ( (x) * TILESIZE + BORDER )
+#define FROMCOORD(x) ( ((x) - BORDER + TILESIZE) / TILESIZE - 1 )
+
+struct game_drawstate {
+    int started;
+    int w, h, tilesize;
+    unsigned long *visible;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->w, h = state->h;
+    char buf[80];
+
+    /*
+     * A left-click between two numbers toggles a domino covering
+     * them. A right-click toggles an edge.
+     */
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        int tx = FROMCOORD(x), ty = FROMCOORD(y), t = ty*w+tx;
+        int dx, dy;
+        int d1, d2;
+
+        if (tx < 0 || tx >= w || ty < 0 || ty >= h)
+            return NULL;
+
+        /*
+         * Now we know which square the click was in, decide which
+         * edge of the square it was closest to.
+         */
+        dx = 2 * (x - COORD(tx)) - TILESIZE;
+        dy = 2 * (y - COORD(ty)) - TILESIZE;
+
+        if (abs(dx) > abs(dy) && dx < 0 && tx > 0)
+            d1 = t - 1, d2 = t;        /* clicked in right side of domino */
+        else if (abs(dx) > abs(dy) && dx > 0 && tx+1 < w)
+            d1 = t, d2 = t + 1;        /* clicked in left side of domino */
+        else if (abs(dy) > abs(dx) && dy < 0 && ty > 0)
+            d1 = t - w, d2 = t;        /* clicked in bottom half of domino */
+        else if (abs(dy) > abs(dx) && dy > 0 && ty+1 < h)
+            d1 = t, d2 = t + w;        /* clicked in top half of domino */
+        else
+            return NULL;
+
+        /*
+         * We can't mark an edge next to any domino.
+         */
+        if (button == RIGHT_BUTTON &&
+            (state->grid[d1] != d1 || state->grid[d2] != d2))
+            return NULL;
+
+        ui->cur_visible = 0;
+        sprintf(buf, "%c%d,%d", (int)(button == RIGHT_BUTTON ? 'E' : 'D'), d1, d2);
+        return dupstr(buf);
+    } else if (IS_CURSOR_MOVE(button)) {
+        ui->cur_visible = 1;
+
+        move_cursor(button, &ui->cur_x, &ui->cur_y, 2*w-1, 2*h-1, 0);
+
+        return "";
+    } else if (IS_CURSOR_SELECT(button)) {
+        int d1, d2;
+
+        if (!((ui->cur_x ^ ui->cur_y) & 1))
+            return NULL;               /* must have exactly one dimension odd */
+        d1 = (ui->cur_y / 2) * w + (ui->cur_x / 2);
+        d2 = ((ui->cur_y+1) / 2) * w + ((ui->cur_x+1) / 2);
+
+        /*
+         * We can't mark an edge next to any domino.
+         */
+        if (button == CURSOR_SELECT2 &&
+            (state->grid[d1] != d1 || state->grid[d2] != d2))
+            return NULL;
+
+        sprintf(buf, "%c%d,%d", (int)(button == CURSOR_SELECT2 ? 'E' : 'D'), d1, d2);
+        return dupstr(buf);
+    } else if (isdigit(button)) {
+        int n = state->params.n, num = button - '0';
+        if (num > n) {
+            return NULL;
+        } else if (ui->highlight_1 == num) {
+            ui->highlight_1 = -1;
+        } else if (ui->highlight_2 == num) {
+            ui->highlight_2 = -1;
+        } else if (ui->highlight_1 == -1) {
+            ui->highlight_1 = num;
+        } else if (ui->highlight_2 == -1) {
+            ui->highlight_2 = num;
+        } else {
+            return NULL;
+        }
+        return "";
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int n = state->params.n, w = n+2, h = n+1, wh = w*h;
+    int d1, d2, d3, p;
+    game_state *ret = dup_game(state);
+
+    while (*move) {
+        if (move[0] == 'S') {
+            int i;
+
+            ret->cheated = TRUE;
+
+            /*
+             * Clear the existing edges and domino placements. We
+             * expect the S to be followed by other commands.
+             */
+            for (i = 0; i < wh; i++) {
+                ret->grid[i] = i;
+                ret->edges[i] = 0;
+            }
+            move++;
+        } else if (move[0] == 'D' &&
+                   sscanf(move+1, "%d,%d%n", &d1, &d2, &p) == 2 &&
+                   d1 >= 0 && d1 < wh && d2 >= 0 && d2 < wh && d1 < d2) {
+
+            /*
+             * Toggle domino presence between d1 and d2.
+             */
+            if (ret->grid[d1] == d2) {
+                assert(ret->grid[d2] == d1);
+                ret->grid[d1] = d1;
+                ret->grid[d2] = d2;
+            } else {
+                /*
+                 * Erase any dominoes that might overlap the new one.
+                 */
+                d3 = ret->grid[d1];
+                if (d3 != d1)
+                    ret->grid[d3] = d3;
+                d3 = ret->grid[d2];
+                if (d3 != d2)
+                    ret->grid[d3] = d3;
+                /*
+                 * Place the new one.
+                 */
+                ret->grid[d1] = d2;
+                ret->grid[d2] = d1;
+
+                /*
+                 * Destroy any edges lurking around it.
+                 */
+                if (ret->edges[d1] & EDGE_L) {
+                    assert(d1 - 1 >= 0);
+                    ret->edges[d1 - 1] &= ~EDGE_R;
+                }
+                if (ret->edges[d1] & EDGE_R) {
+                    assert(d1 + 1 < wh);
+                    ret->edges[d1 + 1] &= ~EDGE_L;
+                }
+                if (ret->edges[d1] & EDGE_T) {
+                    assert(d1 - w >= 0);
+                    ret->edges[d1 - w] &= ~EDGE_B;
+                }
+                if (ret->edges[d1] & EDGE_B) {
+                    assert(d1 + 1 < wh);
+                    ret->edges[d1 + w] &= ~EDGE_T;
+                }
+                ret->edges[d1] = 0;
+                if (ret->edges[d2] & EDGE_L) {
+                    assert(d2 - 1 >= 0);
+                    ret->edges[d2 - 1] &= ~EDGE_R;
+                }
+                if (ret->edges[d2] & EDGE_R) {
+                    assert(d2 + 1 < wh);
+                    ret->edges[d2 + 1] &= ~EDGE_L;
+                }
+                if (ret->edges[d2] & EDGE_T) {
+                    assert(d2 - w >= 0);
+                    ret->edges[d2 - w] &= ~EDGE_B;
+                }
+                if (ret->edges[d2] & EDGE_B) {
+                    assert(d2 + 1 < wh);
+                    ret->edges[d2 + w] &= ~EDGE_T;
+                }
+                ret->edges[d2] = 0;
+            }
+
+            move += p+1;
+        } else if (move[0] == 'E' &&
+                   sscanf(move+1, "%d,%d%n", &d1, &d2, &p) == 2 &&
+                   d1 >= 0 && d1 < wh && d2 >= 0 && d2 < wh && d1 < d2 &&
+                   ret->grid[d1] == d1 && ret->grid[d2] == d2) {
+
+            /*
+             * Toggle edge presence between d1 and d2.
+             */
+            if (d2 == d1 + 1) {
+                ret->edges[d1] ^= EDGE_R;
+                ret->edges[d2] ^= EDGE_L;
+            } else {
+                ret->edges[d1] ^= EDGE_B;
+                ret->edges[d2] ^= EDGE_T;
+            }
+
+            move += p+1;
+        } else {
+            free_game(ret);
+            return NULL;
+        }
+
+        if (*move) {
+            if (*move != ';') {
+                free_game(ret);
+                return NULL;
+            }
+            move++;
+        }
+    }
+
+    /*
+     * After modifying the grid, check completion.
+     */
+    if (!ret->completed) {
+        int i, ok = 0;
+        unsigned char *used = snewn(TRI(n+1), unsigned char);
+
+        memset(used, 0, TRI(n+1));
+        for (i = 0; i < wh; i++)
+            if (ret->grid[i] > i) {
+                int n1, n2, di;
+
+                n1 = ret->numbers->numbers[i];
+                n2 = ret->numbers->numbers[ret->grid[i]];
+
+                di = DINDEX(n1, n2);
+                assert(di >= 0 && di < TRI(n+1));
+
+                if (!used[di]) {
+                    used[di] = 1;
+                    ok++;
+                }
+            }
+
+        sfree(used);
+        if (ok == DCOUNT(n))
+            ret->completed = TRUE;
+    }
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    int n = params->n, w = n+2, h = n+1;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = w * TILESIZE + 2*BORDER;
+    *y = h * TILESIZE + 2*BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_TEXT * 3 + 0] = 0.0F;
+    ret[COL_TEXT * 3 + 1] = 0.0F;
+    ret[COL_TEXT * 3 + 2] = 0.0F;
+
+    ret[COL_DOMINO * 3 + 0] = 0.0F;
+    ret[COL_DOMINO * 3 + 1] = 0.0F;
+    ret[COL_DOMINO * 3 + 2] = 0.0F;
+
+    ret[COL_DOMINOCLASH * 3 + 0] = 0.5F;
+    ret[COL_DOMINOCLASH * 3 + 1] = 0.0F;
+    ret[COL_DOMINOCLASH * 3 + 2] = 0.0F;
+
+    ret[COL_DOMINOTEXT * 3 + 0] = 1.0F;
+    ret[COL_DOMINOTEXT * 3 + 1] = 1.0F;
+    ret[COL_DOMINOTEXT * 3 + 2] = 1.0F;
+
+    ret[COL_EDGE * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 2 / 3;
+    ret[COL_EDGE * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 2 / 3;
+    ret[COL_EDGE * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 2 / 3;
+
+    ret[COL_HIGHLIGHT_1 * 3 + 0] = 0.85;
+    ret[COL_HIGHLIGHT_1 * 3 + 1] = 0.20;
+    ret[COL_HIGHLIGHT_1 * 3 + 2] = 0.20;
+
+    ret[COL_HIGHLIGHT_2 * 3 + 0] = 0.30;
+    ret[COL_HIGHLIGHT_2 * 3 + 1] = 0.85;
+    ret[COL_HIGHLIGHT_2 * 3 + 2] = 0.20;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->started = FALSE;
+    ds->w = state->w;
+    ds->h = state->h;
+    ds->visible = snewn(ds->w * ds->h, unsigned long);
+    ds->tilesize = 0;                  /* not decided yet */
+    for (i = 0; i < ds->w * ds->h; i++)
+        ds->visible[i] = 0xFFFF;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->visible);
+    sfree(ds);
+}
+
+enum {
+    TYPE_L,
+    TYPE_R,
+    TYPE_T,
+    TYPE_B,
+    TYPE_BLANK,
+    TYPE_MASK = 0x0F
+};
+
+/* These flags must be disjoint with:
+   * the above enum (TYPE_*)    [0x000 -- 0x00F]
+   * EDGE_*                     [0x100 -- 0xF00]
+ * and must fit into an unsigned long (32 bits).
+ */
+#define DF_HIGHLIGHT_1  0x10
+#define DF_HIGHLIGHT_2  0x20
+#define DF_FLASH        0x40
+#define DF_CLASH        0x80
+
+#define DF_CURSOR        0x01000
+#define DF_CURSOR_USEFUL 0x02000
+#define DF_CURSOR_XBASE  0x10000
+#define DF_CURSOR_XMASK  0x30000
+#define DF_CURSOR_YBASE  0x40000
+#define DF_CURSOR_YMASK  0xC0000
+
+#define CEDGE_OFF       (TILESIZE / 8)
+#define IS_EMPTY(s,x,y) ((s)->grid[(y)*(s)->w+(x)] == ((y)*(s)->w+(x)))
+
+static void draw_tile(drawing *dr, game_drawstate *ds, const game_state *state,
+                      int x, int y, int type, int highlight_1, int highlight_2)
+{
+    int w = state->w /*, h = state->h */;
+    int cx = COORD(x), cy = COORD(y);
+    int nc;
+    char str[80];
+    int flags;
+
+    clip(dr, cx, cy, TILESIZE, TILESIZE);
+    draw_rect(dr, cx, cy, TILESIZE, TILESIZE, COL_BACKGROUND);
+
+    flags = type &~ TYPE_MASK;
+    type &= TYPE_MASK;
+
+    if (type != TYPE_BLANK) {
+        int i, bg;
+
+        /*
+         * Draw one end of a domino. This is composed of:
+         * 
+         *  - two filled circles (rounded corners)
+         *  - two rectangles
+         *  - a slight shift in the number
+         */
+
+        if (flags & DF_CLASH)
+            bg = COL_DOMINOCLASH;
+        else
+            bg = COL_DOMINO;
+        nc = COL_DOMINOTEXT;
+
+        if (flags & DF_FLASH) {
+            int tmp = nc;
+            nc = bg;
+            bg = tmp;
+        }
+
+        if (type == TYPE_L || type == TYPE_T)
+            draw_circle(dr, cx+DOMINO_COFFSET, cy+DOMINO_COFFSET,
+                        DOMINO_RADIUS, bg, bg);
+        if (type == TYPE_R || type == TYPE_T)
+            draw_circle(dr, cx+TILESIZE-1-DOMINO_COFFSET, cy+DOMINO_COFFSET,
+                        DOMINO_RADIUS, bg, bg);
+        if (type == TYPE_L || type == TYPE_B)
+            draw_circle(dr, cx+DOMINO_COFFSET, cy+TILESIZE-1-DOMINO_COFFSET,
+                        DOMINO_RADIUS, bg, bg);
+        if (type == TYPE_R || type == TYPE_B)
+            draw_circle(dr, cx+TILESIZE-1-DOMINO_COFFSET,
+                        cy+TILESIZE-1-DOMINO_COFFSET,
+                        DOMINO_RADIUS, bg, bg);
+
+        for (i = 0; i < 2; i++) {
+            int x1, y1, x2, y2;
+
+            x1 = cx + (i ? DOMINO_GUTTER : DOMINO_COFFSET);
+            y1 = cy + (i ? DOMINO_COFFSET : DOMINO_GUTTER);
+            x2 = cx + TILESIZE-1 - (i ? DOMINO_GUTTER : DOMINO_COFFSET);
+            y2 = cy + TILESIZE-1 - (i ? DOMINO_COFFSET : DOMINO_GUTTER);
+            if (type == TYPE_L)
+                x2 = cx + TILESIZE + TILESIZE/16;
+            else if (type == TYPE_R)
+                x1 = cx - TILESIZE/16;
+            else if (type == TYPE_T)
+                y2 = cy + TILESIZE + TILESIZE/16;
+            else if (type == TYPE_B)
+                y1 = cy - TILESIZE/16;
+
+            draw_rect(dr, x1, y1, x2-x1+1, y2-y1+1, bg);
+        }
+    } else {
+        if (flags & EDGE_T)
+            draw_rect(dr, cx+DOMINO_GUTTER, cy,
+                      TILESIZE-2*DOMINO_GUTTER, 1, COL_EDGE);
+        if (flags & EDGE_B)
+            draw_rect(dr, cx+DOMINO_GUTTER, cy+TILESIZE-1,
+                      TILESIZE-2*DOMINO_GUTTER, 1, COL_EDGE);
+        if (flags & EDGE_L)
+            draw_rect(dr, cx, cy+DOMINO_GUTTER,
+                      1, TILESIZE-2*DOMINO_GUTTER, COL_EDGE);
+        if (flags & EDGE_R)
+            draw_rect(dr, cx+TILESIZE-1, cy+DOMINO_GUTTER,
+                      1, TILESIZE-2*DOMINO_GUTTER, COL_EDGE);
+        nc = COL_TEXT;
+    }
+
+    if (flags & DF_CURSOR) {
+        int curx = ((flags & DF_CURSOR_XMASK) / DF_CURSOR_XBASE) & 3;
+        int cury = ((flags & DF_CURSOR_YMASK) / DF_CURSOR_YBASE) & 3;
+        int ox = cx + curx*TILESIZE/2;
+        int oy = cy + cury*TILESIZE/2;
+
+        draw_rect_corners(dr, ox, oy, CURSOR_RADIUS, nc);
+        if (flags & DF_CURSOR_USEFUL)
+            draw_rect_corners(dr, ox, oy, CURSOR_RADIUS+1, nc);
+    }
+
+    if (flags & DF_HIGHLIGHT_1) {
+        nc = COL_HIGHLIGHT_1;
+    } else if (flags & DF_HIGHLIGHT_2) {
+        nc = COL_HIGHLIGHT_2;
+    }
+
+    sprintf(str, "%d", state->numbers->numbers[y*w+x]);
+    draw_text(dr, cx+TILESIZE/2, cy+TILESIZE/2, FONT_VARIABLE, TILESIZE/2,
+              ALIGN_HCENTRE | ALIGN_VCENTRE, nc, str);
+
+    draw_update(dr, cx, cy, TILESIZE, TILESIZE);
+    unclip(dr);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int n = state->params.n, w = state->w, h = state->h, wh = w*h;
+    int x, y, i;
+    unsigned char *used;
+
+    if (!ds->started) {
+        int pw, ph;
+        game_compute_size(&state->params, TILESIZE, &pw, &ph);
+        draw_rect(dr, 0, 0, pw, ph, COL_BACKGROUND);
+        draw_update(dr, 0, 0, pw, ph);
+        ds->started = TRUE;
+    }
+
+    /*
+     * See how many dominoes of each type there are, so we can
+     * highlight clashes in red.
+     */
+    used = snewn(TRI(n+1), unsigned char);
+    memset(used, 0, TRI(n+1));
+    for (i = 0; i < wh; i++)
+        if (state->grid[i] > i) {
+            int n1, n2, di;
+
+            n1 = state->numbers->numbers[i];
+            n2 = state->numbers->numbers[state->grid[i]];
+
+            di = DINDEX(n1, n2);
+            assert(di >= 0 && di < TRI(n+1));
+
+            if (used[di] < 2)
+                used[di]++;
+        }
+
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int n = y*w+x;
+            int n1, n2, di;
+            unsigned long c;
+
+            if (state->grid[n] == n-1)
+                c = TYPE_R;
+            else if (state->grid[n] == n+1)
+                c = TYPE_L;
+            else if (state->grid[n] == n-w)
+                c = TYPE_B;
+            else if (state->grid[n] == n+w)
+                c = TYPE_T;
+            else
+                c = TYPE_BLANK;
+
+            n1 = state->numbers->numbers[n];
+            if (c != TYPE_BLANK) {
+                n2 = state->numbers->numbers[state->grid[n]];
+                di = DINDEX(n1, n2);
+                if (used[di] > 1)
+                    c |= DF_CLASH;         /* highlight a clash */
+            } else {
+                c |= state->edges[n];
+            }
+
+            if (n1 == ui->highlight_1)
+                c |= DF_HIGHLIGHT_1;
+            if (n1 == ui->highlight_2)
+                c |= DF_HIGHLIGHT_2;
+
+            if (flashtime != 0)
+                c |= DF_FLASH;             /* we're flashing */
+
+            if (ui->cur_visible) {
+                unsigned curx = (unsigned)(ui->cur_x - (2*x-1));
+                unsigned cury = (unsigned)(ui->cur_y - (2*y-1));
+                if (curx < 3 && cury < 3) {
+                    c |= (DF_CURSOR |
+                          (curx * DF_CURSOR_XBASE) |
+                          (cury * DF_CURSOR_YBASE));
+                    if ((ui->cur_x ^ ui->cur_y) & 1)
+                        c |= DF_CURSOR_USEFUL;
+                }
+            }
+
+            if (ds->visible[n] != c) {
+                draw_tile(dr, ds, state, x, y, c,
+                          ui->highlight_1, ui->highlight_2);
+                ds->visible[n] = c;
+            }
+        }
+
+    sfree(used);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+    {
+        ui->highlight_1 = ui->highlight_2 = -1;
+        return FLASH_TIME;
+    }
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 6mm squares by default.
+     */
+    game_compute_size(params, 600, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->w, h = state->h;
+    int c, x, y;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    c = print_mono_colour(dr, 1); assert(c == COL_BACKGROUND);
+    c = print_mono_colour(dr, 0); assert(c == COL_TEXT);
+    c = print_mono_colour(dr, 0); assert(c == COL_DOMINO);
+    c = print_mono_colour(dr, 0); assert(c == COL_DOMINOCLASH);
+    c = print_mono_colour(dr, 1); assert(c == COL_DOMINOTEXT);
+    c = print_mono_colour(dr, 0); assert(c == COL_EDGE);
+
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int n = y*w+x;
+            unsigned long c;
+
+            if (state->grid[n] == n-1)
+                c = TYPE_R;
+            else if (state->grid[n] == n+1)
+                c = TYPE_L;
+            else if (state->grid[n] == n-w)
+                c = TYPE_B;
+            else if (state->grid[n] == n+w)
+                c = TYPE_T;
+            else
+                c = TYPE_BLANK;
+
+            draw_tile(dr, ds, state, x, y, c, -1, -1);
+        }
+}
+
+#ifdef COMBINED
+#define thegame dominosa
+#endif
+
+const struct game thegame = {
+    "Dominosa", "games.dominosa", "dominosa",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+/* vim: set shiftwidth=4 :set textwidth=80: */
+
diff --git a/apps/plugins/puzzles/drawing.c b/apps/plugins/puzzles/drawing.c
new file mode 100644
index 0000000000..8bf58d5530
--- /dev/null
+++ b/apps/plugins/puzzles/drawing.c
@@ -0,0 +1,351 @@
+/*
+ * drawing.c: Intermediary between the drawing interface as
+ * presented to the back end, and that implemented by the front
+ * end.
+ * 
+ * Mostly just looks up calls in a vtable and passes them through
+ * unchanged. However, on the printing side it tracks print colours
+ * so the front end API doesn't have to.
+ * 
+ * FIXME:
+ * 
+ *  - I'd _like_ to do automatic draw_updates, but it's a pain for
+ *    draw_text in particular. I'd have to invent a front end API
+ *    which retrieved the text bounds.
+ *     + that might allow me to do the alignment centrally as well?
+ *        * perhaps not, because PS can't return this information,
+ *          so there would have to be a special case for it.
+ *     + however, that at least doesn't stand in the way of using
+ *       the text bounds for draw_update, because PS doesn't need
+ *       draw_update since it's printing-only. Any _interactive_
+ *       drawing API couldn't get away with refusing to tell you
+ *       what parts of the screen a text draw had covered, because
+ *       you would inevitably need to erase it later on.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <math.h>
+
+#include "puzzles.h"
+
+struct print_colour {
+    int hatch;
+    int hatch_when;                    /* 0=never 1=only-in-b&w 2=always */
+    float r, g, b;
+    float grey;
+};
+
+struct drawing {
+    const drawing_api *api;
+    void *handle;
+    struct print_colour *colours;
+    int ncolours, coloursize;
+    float scale;
+    /* `me' is only used in status_bar(), so print-oriented instances of
+     * this may set it to NULL. */
+    midend *me;
+    char *laststatus;
+};
+
+drawing *drawing_new(const drawing_api *api, midend *me, void *handle)
+{
+    drawing *dr = snew(drawing);
+    dr->api = api;
+    dr->handle = handle;
+    dr->colours = NULL;
+    dr->ncolours = dr->coloursize = 0;
+    dr->scale = 1.0F;
+    dr->me = me;
+    dr->laststatus = NULL;
+    return dr;
+}
+
+void drawing_free(drawing *dr)
+{
+    sfree(dr->laststatus);
+    sfree(dr->colours);
+    sfree(dr);
+}
+
+void draw_text(drawing *dr, int x, int y, int fonttype, int fontsize,
+               int align, int colour, char *text)
+{
+    dr->api->draw_text(dr->handle, x, y, fonttype, fontsize, align,
+                       colour, text);
+}
+
+void draw_rect(drawing *dr, int x, int y, int w, int h, int colour)
+{
+    dr->api->draw_rect(dr->handle, x, y, w, h, colour);
+}
+
+void draw_line(drawing *dr, int x1, int y1, int x2, int y2, int colour)
+{
+    dr->api->draw_line(dr->handle, x1, y1, x2, y2, colour);
+}
+
+void draw_thick_line(drawing *dr, float thickness,
+                     float x1, float y1, float x2, float y2, int colour)
+{
+    if (dr->api->draw_thick_line) {
+        dr->api->draw_thick_line(dr->handle, thickness,
+                                 x1, y1, x2, y2, colour);
+    } else {
+        /* We'll fake it up with a filled polygon.  The tweak to the
+         * thickness empirically compensates for rounding errors, because
+         * polygon rendering uses integer coordinates.
+         */
+        float len = sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
+        float tvhatx = (x2 - x1)/len * (thickness/2 - 0.2);
+        float tvhaty = (y2 - y1)/len * (thickness/2 - 0.2);
+        int p[8];
+
+        p[0] = x1 - tvhaty;
+        p[1] = y1 + tvhatx;
+        p[2] = x2 - tvhaty;
+        p[3] = y2 + tvhatx;
+        p[4] = x2 + tvhaty;
+        p[5] = y2 - tvhatx;
+        p[6] = x1 + tvhaty;
+        p[7] = y1 - tvhatx;
+        dr->api->draw_polygon(dr->handle, p, 4, colour, colour);
+    }
+}
+
+void draw_polygon(drawing *dr, int *coords, int npoints,
+                  int fillcolour, int outlinecolour)
+{
+    dr->api->draw_polygon(dr->handle, coords, npoints, fillcolour,
+                          outlinecolour);
+}
+
+void draw_circle(drawing *dr, int cx, int cy, int radius,
+                 int fillcolour, int outlinecolour)
+{
+    dr->api->draw_circle(dr->handle, cx, cy, radius, fillcolour,
+                         outlinecolour);
+}
+
+void draw_update(drawing *dr, int x, int y, int w, int h)
+{
+    if (dr->api->draw_update)
+        dr->api->draw_update(dr->handle, x, y, w, h);
+}
+
+void clip(drawing *dr, int x, int y, int w, int h)
+{
+    dr->api->clip(dr->handle, x, y, w, h);
+}
+
+void unclip(drawing *dr)
+{
+    dr->api->unclip(dr->handle);
+}
+
+void start_draw(drawing *dr)
+{
+    dr->api->start_draw(dr->handle);
+}
+
+void end_draw(drawing *dr)
+{
+    dr->api->end_draw(dr->handle);
+}
+
+char *text_fallback(drawing *dr, const char *const *strings, int nstrings)
+{
+    int i;
+
+    /*
+     * If the drawing implementation provides one of these, use it.
+     */
+    if (dr && dr->api->text_fallback)
+        return dr->api->text_fallback(dr->handle, strings, nstrings);
+
+    /*
+     * Otherwise, do the simple thing and just pick the first string
+     * that fits in plain ASCII. It will then need no translation
+     * out of UTF-8.
+     */
+    for (i = 0; i < nstrings; i++) {
+        const char *p;
+
+        for (p = strings[i]; *p; p++)
+            if (*p & 0x80)
+                break;
+        if (!*p)
+            return dupstr(strings[i]);
+    }
+
+    /*
+     * The caller was responsible for making sure _some_ string in
+     * the list was in plain ASCII.
+     */
+    assert(!"Should never get here");
+    return NULL;                       /* placate optimiser */
+}
+
+void status_bar(drawing *dr, char *text)
+{
+    char *rewritten;
+
+    if (!dr->api->status_bar)
+        return;
+
+    assert(dr->me);
+
+    rewritten = midend_rewrite_statusbar(dr->me, text);
+    if (!dr->laststatus || strcmp(rewritten, dr->laststatus)) {
+        dr->api->status_bar(dr->handle, rewritten);
+        sfree(dr->laststatus);
+        dr->laststatus = rewritten;
+    } else {
+        sfree(rewritten);
+    }
+}
+
+blitter *blitter_new(drawing *dr, int w, int h)
+{
+    return dr->api->blitter_new(dr->handle, w, h);
+}
+
+void blitter_free(drawing *dr, blitter *bl)
+{
+    dr->api->blitter_free(dr->handle, bl);
+}
+
+void blitter_save(drawing *dr, blitter *bl, int x, int y)
+{
+    dr->api->blitter_save(dr->handle, bl, x, y);
+}
+
+void blitter_load(drawing *dr, blitter *bl, int x, int y)
+{
+    dr->api->blitter_load(dr->handle, bl, x, y);
+}
+
+void print_begin_doc(drawing *dr, int pages)
+{
+    dr->api->begin_doc(dr->handle, pages);
+}
+
+void print_begin_page(drawing *dr, int number)
+{
+    dr->api->begin_page(dr->handle, number);
+}
+
+void print_begin_puzzle(drawing *dr, float xm, float xc,
+                        float ym, float yc, int pw, int ph, float wmm,
+                        float scale)
+{
+    dr->scale = scale;
+    dr->ncolours = 0;
+    dr->api->begin_puzzle(dr->handle, xm, xc, ym, yc, pw, ph, wmm);
+}
+
+void print_end_puzzle(drawing *dr)
+{
+    dr->api->end_puzzle(dr->handle);
+    dr->scale = 1.0F;
+}
+
+void print_end_page(drawing *dr, int number)
+{
+    dr->api->end_page(dr->handle, number);
+}
+
+void print_end_doc(drawing *dr)
+{
+    dr->api->end_doc(dr->handle);
+}
+
+void print_get_colour(drawing *dr, int colour, int printing_in_colour,
+                      int *hatch, float *r, float *g, float *b)
+{
+    assert(colour >= 0 && colour < dr->ncolours);
+    if (dr->colours[colour].hatch_when == 2 ||
+        (dr->colours[colour].hatch_when == 1 && !printing_in_colour)) {
+        *hatch = dr->colours[colour].hatch;
+    } else {
+        *hatch = -1;
+        if (printing_in_colour) {
+            *r = dr->colours[colour].r;
+            *g = dr->colours[colour].g;
+            *b = dr->colours[colour].b;
+        } else {
+            *r = *g = *b = dr->colours[colour].grey;
+        }
+    }
+}
+
+static int print_generic_colour(drawing *dr, float r, float g, float b,
+                                float grey, int hatch, int hatch_when)
+{
+    if (dr->ncolours >= dr->coloursize) {
+        dr->coloursize = dr->ncolours + 16;
+        dr->colours = sresize(dr->colours, dr->coloursize,
+                              struct print_colour);
+    }
+    dr->colours[dr->ncolours].hatch = hatch;
+    dr->colours[dr->ncolours].hatch_when = hatch_when;
+    dr->colours[dr->ncolours].r = r;
+    dr->colours[dr->ncolours].g = g;
+    dr->colours[dr->ncolours].b = b;
+    dr->colours[dr->ncolours].grey = grey;
+    return dr->ncolours++;
+}
+
+int print_mono_colour(drawing *dr, int grey)
+{
+    return print_generic_colour(dr, grey, grey, grey, grey, -1, 0);
+}
+
+int print_grey_colour(drawing *dr, float grey)
+{
+    return print_generic_colour(dr, grey, grey, grey, grey, -1, 0);
+}
+
+int print_hatched_colour(drawing *dr, int hatch)
+{
+    return print_generic_colour(dr, 0, 0, 0, 0, hatch, 2);
+}
+
+int print_rgb_mono_colour(drawing *dr, float r, float g, float b, int grey)
+{
+    return print_generic_colour(dr, r, g, b, grey, -1, 0);
+}
+
+int print_rgb_grey_colour(drawing *dr, float r, float g, float b, float grey)
+{
+    return print_generic_colour(dr, r, g, b, grey, -1, 0);
+}
+
+int print_rgb_hatched_colour(drawing *dr, float r, float g, float b, int hatch)
+{
+    return print_generic_colour(dr, r, g, b, 0, hatch, 1);
+}
+
+void print_line_width(drawing *dr, int width)
+{
+    /*
+     * I don't think it's entirely sensible to have line widths be
+     * entirely relative to the puzzle size; there is a point
+     * beyond which lines are just _stupidly_ thick. On the other
+     * hand, absolute line widths aren't particularly nice either
+     * because they start to feel a bit feeble at really large
+     * scales.
+     * 
+     * My experimental answer is to scale line widths as the
+     * _square root_ of the main puzzle scale. Double the puzzle
+     * size, and the line width multiplies by 1.4.
+     */
+    dr->api->line_width(dr->handle, (float)sqrt(dr->scale) * width);
+}
+
+void print_line_dotted(drawing *dr, int dotted)
+{
+    dr->api->line_dotted(dr->handle, dotted);
+}
diff --git a/apps/plugins/puzzles/dsf.c b/apps/plugins/puzzles/dsf.c
new file mode 100644
index 0000000000..1a2fa8c4be
--- /dev/null
+++ b/apps/plugins/puzzles/dsf.c
@@ -0,0 +1,192 @@
+/*
+ * dsf.c: some functions to handle a disjoint set forest,
+ * which is a data structure useful in any solver which has to
+ * worry about avoiding closed loops.
+ */
+
+#include "rbassert.h"
+#include <string.h>
+
+#include "puzzles.h"
+
+/*void print_dsf(int *dsf, int size)
+{
+    int *printed_elements = snewn(size, int);
+    int *equal_elements = snewn(size, int);
+    int *inverse_elements = snewn(size, int);
+    int printed_count = 0, equal_count, inverse_count;
+    int i, n, inverse;
+
+    memset(printed_elements, -1, sizeof(int) * size);
+
+    while (1) {
+        equal_count = 0;
+        inverse_count = 0;
+        for (i = 0; i < size; ++i) {
+            if (!memchr(printed_elements, i, sizeof(int) * size)) 
+                break;
+        }
+        if (i == size)
+            goto done;
+
+        i = dsf_canonify(dsf, i);
+
+        for (n = 0; n < size; ++n) {
+            if (edsf_canonify(dsf, n, &inverse) == i) {
+               if (inverse)
+                   inverse_elements[inverse_count++] = n;
+               else
+                   equal_elements[equal_count++] = n;
+            }
+        }
+        
+        for (n = 0; n < equal_count; ++n) {
+            fprintf(stderr, "%d ", equal_elements[n]);
+            printed_elements[printed_count++] = equal_elements[n];
+        }
+        if (inverse_count) {
+            fprintf(stderr, "!= ");
+            for (n = 0; n < inverse_count; ++n) {
+                fprintf(stderr, "%d ", inverse_elements[n]);
+                printed_elements[printed_count++] = inverse_elements[n];
+            }
+        }
+        fprintf(stderr, "\n");
+    }
+done:
+
+    sfree(printed_elements);
+    sfree(equal_elements);
+    sfree(inverse_elements);
+}*/
+
+void dsf_init(int *dsf, int size)
+{
+    int i;
+
+    for (i = 0; i < size; i++) dsf[i] = 6;
+    /* Bottom bit of each element of this array stores whether that
+     * element is opposite to its parent, which starts off as
+     * false. Second bit of each element stores whether that element
+     * is the root of its tree or not.  If it's not the root, the
+     * remaining 30 bits are the parent, otherwise the remaining 30
+     * bits are the number of elements in the tree.  */
+}
+
+int *snew_dsf(int size)
+{
+    int *ret;
+    
+    ret = snewn(size, int);
+    dsf_init(ret, size);
+
+    /*print_dsf(ret, size); */
+
+    return ret;
+}
+
+int dsf_canonify(int *dsf, int index)
+{
+    return edsf_canonify(dsf, index, NULL);
+}
+
+void dsf_merge(int *dsf, int v1, int v2)
+{
+    edsf_merge(dsf, v1, v2, FALSE);
+}
+
+int dsf_size(int *dsf, int index) {
+    return dsf[dsf_canonify(dsf, index)] >> 2;
+}
+
+int edsf_canonify(int *dsf, int index, int *inverse_return)
+{
+    int start_index = index, canonical_index;
+    int inverse = 0;
+
+/*    fprintf(stderr, "dsf = %p\n", dsf); */
+/*    fprintf(stderr, "Canonify %2d\n", index); */
+
+    assert(index >= 0);
+
+    /* Find the index of the canonical element of the 'equivalence class' of
+     * which start_index is a member, and figure out whether start_index is the
+     * same as or inverse to that. */
+    while ((dsf[index] & 2) == 0) {
+        inverse ^= (dsf[index] & 1);
+        index = dsf[index] >> 2;
+/*        fprintf(stderr, "index = %2d, ", index); */
+/*        fprintf(stderr, "inverse = %d\n", inverse); */
+    }
+    canonical_index = index;
+    
+    if (inverse_return)
+        *inverse_return = inverse;
+    
+    /* Update every member of this 'equivalence class' to point directly at the
+     * canonical member. */
+    index = start_index;
+    while (index != canonical_index) {
+        int nextindex = dsf[index] >> 2;
+        int nextinverse = inverse ^ (dsf[index] & 1);
+        dsf[index] = (canonical_index << 2) | inverse;
+        inverse = nextinverse;
+        index = nextindex;
+    }
+
+    assert(inverse == 0);
+
+/*    fprintf(stderr, "Return %2d\n", index); */
+    
+    return index;
+}
+
+void edsf_merge(int *dsf, int v1, int v2, int inverse)
+{
+    int i1, i2;
+
+/*    fprintf(stderr, "dsf = %p\n", dsf); */
+/*    fprintf(stderr, "Merge [%2d,%2d], %d\n", v1, v2, inverse); */
+    
+    v1 = edsf_canonify(dsf, v1, &i1);
+    assert(dsf[v1] & 2);
+    inverse ^= i1;
+    v2 = edsf_canonify(dsf, v2, &i2);
+    assert(dsf[v2] & 2);
+    inverse ^= i2;
+
+/*    fprintf(stderr, "Doing [%2d,%2d], %d\n", v1, v2, inverse); */
+
+    if (v1 == v2)
+        assert(!inverse);
+    else {
+        assert(inverse == 0 || inverse == 1);
+        /*
+         * We always make the smaller of v1 and v2 the new canonical
+         * element. This ensures that the canonical element of any
+         * class in this structure is always the first element in
+         * it. 'Keen' depends critically on this property.
+         *
+         * (Jonas Koelker previously had this code choosing which
+         * way round to connect the trees by examining the sizes of
+         * the classes being merged, so that the root of the
+         * larger-sized class became the new root. This gives better
+         * asymptotic performance, but I've changed it to do it this
+         * way because I like having a deterministic canonical
+         * element.)
+         */
+        if (v1 > v2) {
+            int v3 = v1;
+            v1 = v2;
+            v2 = v3;
+        }
+        dsf[v1] += (dsf[v2] >> 2) << 2;
+        dsf[v2] = (v1 << 2) | !!inverse;
+    }
+    
+    v2 = edsf_canonify(dsf, v2, &i2);
+    assert(v2 == v1);
+    assert(i2 == inverse);
+
+/*    fprintf(stderr, "dsf[%2d] = %2d\n", v2, dsf[v2]); */
+}
diff --git a/apps/plugins/puzzles/emcc.c b/apps/plugins/puzzles/emcc.c
new file mode 100644
index 0000000000..5ffcb0b793
--- /dev/null
+++ b/apps/plugins/puzzles/emcc.c
@@ -0,0 +1,867 @@
+/*
+ * emcc.c: the C component of an Emscripten-based web/Javascript front
+ * end for Puzzles.
+ *
+ * The Javascript parts of this system live in emcclib.js and
+ * emccpre.js. It also depends on being run in the context of a web
+ * page containing an appropriate collection of bits and pieces (a
+ * canvas, some buttons and links etc), which is generated for each
+ * puzzle by the script html/jspage.pl.
+ */
+
+/*
+ * Further thoughts on possible enhancements:
+ *
+ *  - I think it might be feasible to have these JS puzzles permit
+ *    loading and saving games in disk files. Saving would be done by
+ *    constructing a data: URI encapsulating the save file, and then
+ *    telling the browser to visit that URI with the effect that it
+ *    would naturally pop up a 'where would you like to save this'
+ *    dialog box. Loading, more or less similarly, might be feasible
+ *    by using the DOM File API to ask the user to select a file and
+ *    permit us to see its contents.
+ *
+ *  - I should think about whether these webified puzzles can support
+ *    touchscreen-based tablet browsers (assuming there are any that
+ *    can cope with the reasonably modern JS and run it fast enough to
+ *    be worthwhile).
+ *
+ *  - think about making use of localStorage. It might be useful to
+ *    let the user save games into there as an alternative to disk
+ *    files - disk files are all very well for getting the save right
+ *    out of your browser to (e.g.) email to me as a bug report, but
+ *    for just resuming a game you were in the middle of, you'd
+ *    probably rather have a nice simple 'quick save' and 'quick load'
+ *    button pair. Also, that might be a useful place to store
+ *    preferences, if I ever get round to writing a preferences UI.
+ *
+ *  - some CSS to make the button bar and configuration dialogs a
+ *    little less ugly would probably not go amiss.
+ *
+ *  - this is a downright silly idea, but it does occur to me that if
+ *    I were to write a PDF output driver for the Puzzles printing
+ *    API, then I might be able to implement a sort of 'printing'
+ *    feature in this front end, using data: URIs again. (Ask the user
+ *    exactly what they want printed, then construct an appropriate
+ *    PDF and embed it in a gigantic data: URI. Then they can print
+ *    that using whatever they normally use to print PDFs!)
+ */
+
+#include "rbassert.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "puzzles.h"
+
+/*
+ * Extern references to Javascript functions provided in emcclib.js.
+ */
+extern void js_debug(const char *);
+extern void js_error_box(const char *message);
+extern void js_remove_type_dropdown(void);
+extern void js_remove_solve_button(void);
+extern void js_add_preset(const char *name);
+extern int js_get_selected_preset(void);
+extern void js_select_preset(int n);
+extern void js_get_date_64(unsigned *p);
+extern void js_update_permalinks(const char *desc, const char *seed);
+extern void js_enable_undo_redo(int undo, int redo);
+extern void js_activate_timer();
+extern void js_deactivate_timer();
+extern void js_canvas_start_draw(void);
+extern void js_canvas_draw_update(int x, int y, int w, int h);
+extern void js_canvas_end_draw(void);
+extern void js_canvas_draw_rect(int x, int y, int w, int h,
+                                const char *colour);
+extern void js_canvas_clip_rect(int x, int y, int w, int h);
+extern void js_canvas_unclip(void);
+extern void js_canvas_draw_line(float x1, float y1, float x2, float y2,
+                                int width, const char *colour);
+extern void js_canvas_draw_poly(int *points, int npoints,
+                                const char *fillcolour,
+                                const char *outlinecolour);
+extern void js_canvas_draw_circle(int x, int y, int r,
+                                  const char *fillcolour,
+                                  const char *outlinecolour);
+extern int js_canvas_find_font_midpoint(int height, const char *fontptr);
+extern void js_canvas_draw_text(int x, int y, int halign,
+                                const char *colptr, const char *fontptr,
+                                const char *text);
+extern int js_canvas_new_blitter(int w, int h);
+extern void js_canvas_free_blitter(int id);
+extern void js_canvas_copy_to_blitter(int id, int x, int y, int w, int h);
+extern void js_canvas_copy_from_blitter(int id, int x, int y, int w, int h);
+extern void js_canvas_make_statusbar(void);
+extern void js_canvas_set_statusbar(const char *text);
+extern void js_canvas_set_size(int w, int h);
+
+extern void js_dialog_init(const char *title);
+extern void js_dialog_string(int i, const char *title, const char *initvalue);
+extern void js_dialog_choices(int i, const char *title, const char *choicelist,
+                              int initvalue);
+extern void js_dialog_boolean(int i, const char *title, int initvalue);
+extern void js_dialog_launch(void);
+extern void js_dialog_cleanup(void);
+extern void js_focus_canvas(void);
+
+/*
+ * Call JS to get the date, and use that to initialise our random
+ * number generator to invent the first game seed.
+ */
+void get_random_seed(void **randseed, int *randseedsize)
+{
+    unsigned *ret = snewn(2, unsigned);
+    js_get_date_64(ret);
+    *randseed = ret;
+    *randseedsize = 2*sizeof(unsigned);
+}
+
+/*
+ * Fatal error, called in cases of complete despair such as when
+ * malloc() has returned NULL.
+ */
+void fatal(char *fmt, ...)
+{
+    char buf[512];
+    va_list ap;
+
+    strcpy(buf, "puzzle fatal error: ");
+
+    va_start(ap, fmt);
+    vsnprintf(buf+strlen(buf), sizeof(buf)-strlen(buf), fmt, ap);
+    va_end(ap);
+
+    js_error_box(buf);
+}
+
+void debug_printf(char *fmt, ...)
+{
+    char buf[512];
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+    js_debug(buf);
+}
+
+/*
+ * Helper function that makes it easy to test strings that might be
+ * NULL.
+ */
+int strnullcmp(const char *a, const char *b)
+{
+    if (a == NULL || b == NULL)
+        return a != NULL ? +1 : b != NULL ? -1 : 0;
+    return strcmp(a, b);
+}
+
+/*
+ * HTMLish names for the colours allocated by the puzzle.
+ */
+char **colour_strings;
+int ncolours;
+
+/*
+ * The global midend object.
+ */
+midend *me;
+
+/* ----------------------------------------------------------------------
+ * Timing functions.
+ */
+int timer_active = FALSE;
+void deactivate_timer(frontend *fe)
+{
+    js_deactivate_timer();
+    timer_active = FALSE;
+}
+void activate_timer(frontend *fe)
+{
+    if (!timer_active) {
+        js_activate_timer();
+        timer_active = TRUE;
+    }
+}
+void timer_callback(double tplus)
+{
+    if (timer_active)
+        midend_timer(me, tplus);
+}
+
+/* ----------------------------------------------------------------------
+ * Helper functions to resize the canvas, and variables to remember
+ * its size for other functions (e.g. trimming blitter rectangles).
+ */
+static int canvas_w, canvas_h;
+
+/* Called when we resize as a result of changing puzzle settings */
+static void resize(void)
+{
+    int w, h;
+    w = h = INT_MAX;
+    midend_size(me, &w, &h, FALSE);
+    js_canvas_set_size(w, h);
+    canvas_w = w;
+    canvas_h = h;
+}
+
+/* Called from JS when the user uses the resize handle */
+void resize_puzzle(int w, int h)
+{
+    midend_size(me, &w, &h, TRUE);
+    if (canvas_w != w || canvas_h != h) { 
+        js_canvas_set_size(w, h);
+        canvas_w = w;
+        canvas_h = h;
+        midend_force_redraw(me);
+    }
+}
+
+/* Called from JS when the user uses the restore button */
+void restore_puzzle_size(int w, int h)
+{
+    midend_reset_tilesize(me);
+    resize();
+    midend_force_redraw(me);
+}
+
+/*
+ * HTML doesn't give us a default frontend colour of its own, so we
+ * just make up a lightish grey ourselves.
+ */
+void frontend_default_colour(frontend *fe, float *output)
+{
+    output[0] = output[1] = output[2] = 0.9F;
+}
+
+/*
+ * Helper function called from all over the place to ensure the undo
+ * and redo buttons get properly enabled and disabled after every move
+ * or undo or new-game event.
+ */
+static void update_undo_redo(void)
+{
+    js_enable_undo_redo(midend_can_undo(me), midend_can_redo(me));
+}
+
+/*
+ * Mouse event handlers called from JS.
+ */
+void mousedown(int x, int y, int button)
+{
+    button = (button == 0 ? LEFT_BUTTON :
+              button == 1 ? MIDDLE_BUTTON : RIGHT_BUTTON);
+    midend_process_key(me, x, y, button);
+    update_undo_redo();
+}
+
+void mouseup(int x, int y, int button)
+{
+    button = (button == 0 ? LEFT_RELEASE :
+              button == 1 ? MIDDLE_RELEASE : RIGHT_RELEASE);
+    midend_process_key(me, x, y, button);
+    update_undo_redo();
+}
+
+void mousemove(int x, int y, int buttons)
+{
+    int button = (buttons & 2 ? MIDDLE_DRAG :
+                  buttons & 4 ? RIGHT_DRAG : LEFT_DRAG);
+    midend_process_key(me, x, y, button);
+    update_undo_redo();
+}
+
+/*
+ * Keyboard handler called from JS.
+ */
+void key(int keycode, int charcode, const char *key, const char *chr,
+         int shift, int ctrl)
+{
+    int keyevent = -1;
+
+    if (!strnullcmp(key, "Backspace") || !strnullcmp(key, "Del") ||
+        keycode == 8 || keycode == 46) {
+        keyevent = 127;                /* Backspace / Delete */
+    } else if (!strnullcmp(key, "Enter") || keycode == 13) {
+        keyevent = 13;             /* return */
+    } else if (!strnullcmp(key, "Left") || keycode == 37) {
+        keyevent = CURSOR_LEFT;
+    } else if (!strnullcmp(key, "Up") || keycode == 38) {
+        keyevent = CURSOR_UP;
+    } else if (!strnullcmp(key, "Right") || keycode == 39) {
+        keyevent = CURSOR_RIGHT;
+    } else if (!strnullcmp(key, "Down") || keycode == 40) {
+        keyevent = CURSOR_DOWN;
+    } else if (!strnullcmp(key, "End") || keycode == 35) {
+        /*
+         * We interpret Home, End, PgUp and PgDn as numeric keypad
+         * controls regardless of whether they're the ones on the
+         * numeric keypad (since we can't tell). The effect of
+         * this should only be that the non-numeric-pad versions
+         * of those keys generate directions in 8-way movement
+         * puzzles like Cube and Inertia.
+         */
+        keyevent = MOD_NUM_KEYPAD | '1';
+    } else if (!strnullcmp(key, "PageDown") || keycode==34) {
+        keyevent = MOD_NUM_KEYPAD | '3';
+    } else if (!strnullcmp(key, "Home") || keycode==36) {
+        keyevent = MOD_NUM_KEYPAD | '7';
+    } else if (!strnullcmp(key, "PageUp") || keycode==33) {
+        keyevent = MOD_NUM_KEYPAD | '9';
+    } else if (chr && chr[0] && !chr[1]) {
+        keyevent = chr[0] & 0xFF;
+    } else if (keycode >= 96 && keycode < 106) {
+        keyevent = MOD_NUM_KEYPAD | ('0' + keycode - 96);
+    } else if (keycode >= 65 && keycode <= 90) {
+        keyevent = keycode + (shift ? 0 : 32);
+    } else if (keycode >= 48 && keycode <= 57) {
+        keyevent = keycode;
+    } else if (keycode == 32) {        /* space / CURSOR_SELECT2 */
+        keyevent = keycode;
+    }
+
+    if (keyevent >= 0) {
+        if (shift && keyevent >= 0x100)
+            keyevent |= MOD_SHFT;
+
+        if (ctrl) {
+            if (keyevent >= 0x100)
+                keyevent |= MOD_CTRL;
+            else
+                keyevent &= 0x1F;
+        }
+
+        midend_process_key(me, 0, 0, keyevent);
+        update_undo_redo();
+    }
+}
+
+/*
+ * Helper function called from several places to update the permalinks
+ * whenever a new game is created.
+ */
+static void update_permalinks(void)
+{
+    char *desc, *seed;
+    desc = midend_get_game_id(me);
+    seed = midend_get_random_seed(me);
+    js_update_permalinks(desc, seed);
+    sfree(desc);
+    sfree(seed);
+}
+
+/*
+ * Callback from the midend when the game ids change, so we can update
+ * the permalinks.
+ */
+static void ids_changed(void *ignored)
+{
+    update_permalinks();
+}
+
+/* ----------------------------------------------------------------------
+ * Implementation of the drawing API by calling Javascript canvas
+ * drawing functions. (Well, half of it; the other half is on the JS
+ * side.)
+ */
+static void js_start_draw(void *handle)
+{
+    js_canvas_start_draw();
+}
+
+static void js_clip(void *handle, int x, int y, int w, int h)
+{
+    js_canvas_clip_rect(x, y, w, h);
+}
+
+static void js_unclip(void *handle)
+{
+    js_canvas_unclip();
+}
+
+static void js_draw_text(void *handle, int x, int y, int fonttype,
+                         int fontsize, int align, int colour, char *text)
+{
+    char fontstyle[80];
+    int halign;
+
+    sprintf(fontstyle, "%dpx %s", fontsize,
+            fonttype == FONT_FIXED ? "monospace" : "sans-serif");
+
+    if (align & ALIGN_VCENTRE)
+        y += js_canvas_find_font_midpoint(fontsize, fontstyle);
+
+    if (align & ALIGN_HCENTRE)
+        halign = 1;
+    else if (align & ALIGN_HRIGHT)
+        halign = 2;
+    else
+        halign = 0;
+
+    js_canvas_draw_text(x, y, halign, colour_strings[colour], fontstyle, text);
+}
+
+static void js_draw_rect(void *handle, int x, int y, int w, int h, int colour)
+{
+    js_canvas_draw_rect(x, y, w, h, colour_strings[colour]);
+}
+
+static void js_draw_line(void *handle, int x1, int y1, int x2, int y2,
+                         int colour)
+{
+    js_canvas_draw_line(x1, y1, x2, y2, 1, colour_strings[colour]);
+}
+
+static void js_draw_thick_line(void *handle, float thickness,
+                               float x1, float y1, float x2, float y2,
+                               int colour)
+{
+    js_canvas_draw_line(x1, y1, x2, y2, thickness, colour_strings[colour]);
+}
+
+static void js_draw_poly(void *handle, int *coords, int npoints,
+                         int fillcolour, int outlinecolour)
+{
+    js_canvas_draw_poly(coords, npoints,
+                        fillcolour >= 0 ? colour_strings[fillcolour] : NULL,
+                        colour_strings[outlinecolour]);
+}
+
+static void js_draw_circle(void *handle, int cx, int cy, int radius,
+                           int fillcolour, int outlinecolour)
+{
+    js_canvas_draw_circle(cx, cy, radius,
+                          fillcolour >= 0 ? colour_strings[fillcolour] : NULL,
+                          colour_strings[outlinecolour]);
+}
+
+struct blitter {
+    int id;                            /* allocated on the js side */
+    int w, h;                          /* easier to retain here */
+};
+
+static blitter *js_blitter_new(void *handle, int w, int h)
+{
+    blitter *bl = snew(blitter);
+    bl->w = w;
+    bl->h = h;
+    bl->id = js_canvas_new_blitter(w, h);
+    return bl;
+}
+
+static void js_blitter_free(void *handle, blitter *bl)
+{
+    js_canvas_free_blitter(bl->id);
+    sfree(bl);
+}
+
+static void trim_rect(int *x, int *y, int *w, int *h)
+{
+    int x0, x1, y0, y1;
+
+    /*
+     * Reduce the size of the copied rectangle to stop it going
+     * outside the bounds of the canvas.
+     */
+
+    /* Transform from x,y,w,h form into coordinates of all edges */
+    x0 = *x;
+    y0 = *y;
+    x1 = *x + *w;
+    y1 = *y + *h;
+
+    /* Clip each coordinate at both extremes of the canvas */
+    x0 = (x0 < 0 ? 0 : x0 > canvas_w ? canvas_w : x0);
+    x1 = (x1 < 0 ? 0 : x1 > canvas_w ? canvas_w : x1);
+    y0 = (y0 < 0 ? 0 : y0 > canvas_h ? canvas_h : y0);
+    y1 = (y1 < 0 ? 0 : y1 > canvas_h ? canvas_h : y1); 
+
+    /* Transform back into x,y,w,h to return */
+    *x = x0;
+    *y = y0;
+    *w = x1 - x0;
+    *h = y1 - y0;
+}
+
+static void js_blitter_save(void *handle, blitter *bl, int x, int y)
+{
+    int w = bl->w, h = bl->h;
+    trim_rect(&x, &y, &w, &h);
+    if (w > 0 && h > 0)
+        js_canvas_copy_to_blitter(bl->id, x, y, w, h);
+}
+
+static void js_blitter_load(void *handle, blitter *bl, int x, int y)
+{
+    int w = bl->w, h = bl->h;
+    trim_rect(&x, &y, &w, &h);
+    if (w > 0 && h > 0)
+        js_canvas_copy_from_blitter(bl->id, x, y, w, h);
+}
+
+static void js_draw_update(void *handle, int x, int y, int w, int h)
+{
+    trim_rect(&x, &y, &w, &h);
+    if (w > 0 && h > 0)
+        js_canvas_draw_update(x, y, w, h);
+}
+
+static void js_end_draw(void *handle)
+{
+    js_canvas_end_draw();
+}
+
+static void js_status_bar(void *handle, char *text)
+{
+    js_canvas_set_statusbar(text);
+}
+
+static char *js_text_fallback(void *handle, const char *const *strings,
+                              int nstrings)
+{
+    return dupstr(strings[0]); /* Emscripten has no trouble with UTF-8 */
+}
+
+const struct drawing_api js_drawing = {
+    js_draw_text,
+    js_draw_rect,
+    js_draw_line,
+    js_draw_poly,
+    js_draw_circle,
+    js_draw_update,
+    js_clip,
+    js_unclip,
+    js_start_draw,
+    js_end_draw,
+    js_status_bar,
+    js_blitter_new,
+    js_blitter_free,
+    js_blitter_save,
+    js_blitter_load,
+    NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */
+    NULL, NULL,                        /* line_width, line_dotted */
+    js_text_fallback,
+    js_draw_thick_line,
+};
+
+/* ----------------------------------------------------------------------
+ * Presets and game-configuration dialog support.
+ */
+static game_params **presets;
+static int npresets;
+int have_presets_dropdown;
+
+void select_appropriate_preset(void)
+{
+    if (have_presets_dropdown) {
+        int preset = midend_which_preset(me);
+        js_select_preset(preset < 0 ? -1 : preset);
+    }
+}
+
+static config_item *cfg = NULL;
+static int cfg_which;
+
+/*
+ * Set up a dialog box. This is pretty easy on the C side; most of the
+ * work is done in JS.
+ */
+static void cfg_start(int which)
+{
+    char *title;
+    int i;
+
+    cfg = midend_get_config(me, which, &title);
+    cfg_which = which;
+
+    js_dialog_init(title);
+    sfree(title);
+
+    for (i = 0; cfg[i].type != C_END; i++) {
+        switch (cfg[i].type) {
+          case C_STRING:
+            js_dialog_string(i, cfg[i].name, cfg[i].sval);
+            break;
+          case C_BOOLEAN:
+            js_dialog_boolean(i, cfg[i].name, cfg[i].ival);
+            break;
+          case C_CHOICES:
+            js_dialog_choices(i, cfg[i].name, cfg[i].sval, cfg[i].ival);
+            break;
+        }
+    }
+
+    js_dialog_launch();
+}
+
+/*
+ * Callbacks from JS when the OK button is clicked, to return the
+ * final state of each control.
+ */
+void dlg_return_sval(int index, const char *val)
+{
+    sfree(cfg[index].sval);
+    cfg[index].sval = dupstr(val);
+}
+void dlg_return_ival(int index, int val)
+{
+    cfg[index].ival = val;
+}
+
+/*
+ * Called when the user clicks OK or Cancel. use_results will be TRUE
+ * or FALSE respectively, in those cases. We terminate the dialog box,
+ * unless the user selected an invalid combination of parameters.
+ */
+static void cfg_end(int use_results)
+{
+    if (use_results) {
+        /*
+         * User hit OK.
+         */
+        char *err = midend_set_config(me, cfg_which, cfg);
+
+        if (err) {
+            /*
+             * The settings were unacceptable, so leave the config box
+             * open for the user to adjust them and try again.
+             */
+            js_error_box(err);
+        } else {
+            /*
+             * New settings are fine; start a new game and close the
+             * dialog.
+             */
+            select_appropriate_preset();
+            midend_new_game(me);
+            resize();
+            midend_redraw(me);
+            free_cfg(cfg);
+            js_dialog_cleanup();
+        }
+    } else {
+        /*
+         * User hit Cancel. Close the dialog, but also we must still
+         * reselect the right element of the dropdown list.
+         *
+         * (Because: imagine you have a preset selected, and then you
+         * select Custom from the list, but change your mind and hit
+         * Esc. The Custom option will now still be selected in the
+         * list, whereas obviously it should show the preset you still
+         * _actually_ have selected. Worse still, it'll be the visible
+         * rather than invisible Custom option - see the comment in
+         * js_add_preset in emcclib.js - so you won't even be able to
+         * select Custom without a faffy workaround.)
+         */
+        select_appropriate_preset();
+
+        free_cfg(cfg);
+        js_dialog_cleanup();
+    }
+}
+
+/* ----------------------------------------------------------------------
+ * Called from JS when a command is given to the puzzle by clicking a
+ * button or control of some sort.
+ */
+void command(int n)
+{
+    switch (n) {
+      case 0:                          /* specific game ID */
+        cfg_start(CFG_DESC);
+        break;
+      case 1:                          /* random game seed */
+        cfg_start(CFG_SEED);
+        break;
+      case 2:                          /* game parameter dropdown changed */
+        {
+            int i = js_get_selected_preset();
+            if (i < 0) {
+                /*
+                 * The user selected 'Custom', so launch the config
+                 * box.
+                 */
+                if (thegame.can_configure) /* (double-check just in case) */
+                    cfg_start(CFG_SETTINGS);
+            } else {
+                /*
+                 * The user selected a preset, so just switch straight
+                 * to that.
+                 */
+                assert(i < npresets);
+                midend_set_params(me, presets[i]);
+                midend_new_game(me);
+                resize();
+                midend_redraw(me);
+                update_undo_redo();
+                js_focus_canvas();
+                select_appropriate_preset(); /* sort out Custom/Customise */
+            }
+        }
+        break;
+      case 3:                          /* OK clicked in a config box */
+        cfg_end(TRUE);
+        update_undo_redo();
+        break;
+      case 4:                          /* Cancel clicked in a config box */
+        cfg_end(FALSE);
+        update_undo_redo();
+        break;
+      case 5:                          /* New Game */
+        midend_process_key(me, 0, 0, 'n');
+        update_undo_redo();
+        js_focus_canvas();
+        break;
+      case 6:                          /* Restart */
+        midend_restart_game(me);
+        update_undo_redo();
+        js_focus_canvas();
+        break;
+      case 7:                          /* Undo */
+        midend_process_key(me, 0, 0, 'u');
+        update_undo_redo();
+        js_focus_canvas();
+        break;
+      case 8:                          /* Redo */
+        midend_process_key(me, 0, 0, 'r');
+        update_undo_redo();
+        js_focus_canvas();
+        break;
+      case 9:                          /* Solve */
+        if (thegame.can_solve) {
+            char *msg = midend_solve(me);
+            if (msg)
+                js_error_box(msg);
+        }
+        update_undo_redo();
+        js_focus_canvas();
+        break;
+    }
+}
+
+/* ----------------------------------------------------------------------
+ * Setup function called at page load time. It's called main() because
+ * that's the most convenient thing in Emscripten, but it's not main()
+ * in the usual sense of bounding the program's entire execution.
+ * Instead, this function returns once the initial puzzle is set up
+ * and working, and everything thereafter happens by means of JS event
+ * handlers sending us callbacks.
+ */
+int main(int argc, char **argv)
+{
+    char *param_err;
+    float *colours;
+    int i;
+
+    /*
+     * Instantiate a midend.
+     */
+    me = midend_new(NULL, &thegame, &js_drawing, NULL);
+
+    /*
+     * Chuck in the HTML fragment ID if we have one (trimming the
+     * leading # off the front first). If that's invalid, we retain
+     * the error message and will display it at the end, after setting
+     * up a random puzzle as usual.
+     */
+    if (argc > 1 && argv[1][0] == '#' && argv[1][1] != '\0')
+        param_err = midend_game_id(me, argv[1] + 1);
+    else
+        param_err = NULL;
+
+    /*
+     * Create either a random game or the specified one, and set the
+     * canvas size appropriately.
+     */
+    midend_new_game(me);
+    resize();
+
+    /*
+     * Create a status bar, if needed.
+     */
+    if (midend_wants_statusbar(me))
+        js_canvas_make_statusbar();
+
+    /*
+     * Set up the game-type dropdown with presets and/or the Custom
+     * option.
+     */
+    npresets = midend_num_presets(me);
+    if (npresets == 0) {
+        /*
+         * This puzzle doesn't have selectable game types at all.
+         * Completely remove the drop-down list from the page.
+         */
+        js_remove_type_dropdown();
+        have_presets_dropdown = FALSE;
+    } else {
+        presets = snewn(npresets, game_params *);
+        for (i = 0; i < npresets; i++) {
+            char *name;
+            midend_fetch_preset(me, i, &name, &presets[i]);
+            js_add_preset(name);
+        }
+        if (thegame.can_configure)
+            js_add_preset(NULL);   /* the 'Custom' entry in the dropdown */
+
+        have_presets_dropdown = TRUE;
+
+        /*
+         * Now ensure the appropriate element of the presets menu
+         * starts off selected, in case it isn't the first one in the
+         * list (e.g. Slant).
+         */
+        select_appropriate_preset();
+    }
+
+    /*
+     * Remove the Solve button if the game doesn't support it.
+     */
+    if (!thegame.can_solve)
+        js_remove_solve_button();
+
+    /*
+     * Retrieve the game's colours, and convert them into #abcdef type
+     * hex ID strings.
+     */
+    colours = midend_colours(me, &ncolours);
+    colour_strings = snewn(ncolours, char *);
+    for (i = 0; i < ncolours; i++) {
+        char col[40];
+        sprintf(col, "#%02x%02x%02x",
+                (unsigned)(0.5 + 255 * colours[i*3+0]),
+                (unsigned)(0.5 + 255 * colours[i*3+1]),
+                (unsigned)(0.5 + 255 * colours[i*3+2]));
+        colour_strings[i] = dupstr(col);
+    }
+
+    /*
+     * Request notification when the game ids change (e.g. if the user
+     * presses 'n', and also when Mines supersedes its game
+     * description), so that we can proactively update the permalink.
+     */
+    midend_request_id_changes(me, ids_changed, NULL);
+
+    /*
+     * Draw the puzzle's initial state, and set up the permalinks and
+     * undo/redo greying out.
+     */
+    midend_redraw(me);
+    update_permalinks();
+    update_undo_redo();
+
+    /*
+     * If we were given an erroneous game ID in argv[1], now's the
+     * time to put up the error box about it, after we've fully set up
+     * a random puzzle. Then when the user clicks 'ok', we have a
+     * puzzle for them.
+     */
+    if (param_err)
+        js_error_box(param_err);
+
+    /*
+     * Done. Return to JS, and await callbacks!
+     */
+    return 0;
+}
diff --git a/apps/plugins/puzzles/emcclib.js b/apps/plugins/puzzles/emcclib.js
new file mode 100644
index 0000000000..385281ad0b
--- /dev/null
+++ b/apps/plugins/puzzles/emcclib.js
@@ -0,0 +1,757 @@
+/*
+ * emcclib.js: one of the Javascript components of an Emscripten-based
+ * web/Javascript front end for Puzzles.
+ *
+ * The other parts of this system live in emcc.c and emccpre.js. It
+ * also depends on being run in the context of a web page containing
+ * an appropriate collection of bits and pieces (a canvas, some
+ * buttons and links etc), which is generated for each puzzle by the
+ * script html/jspage.pl.
+ *
+ * This file contains a set of Javascript functions which we insert
+ * into Emscripten's library object via the --js-library option; this
+ * allows us to provide JS code which can be called from the
+ * Emscripten-compiled C, mostly dealing with UI interaction of
+ * various kinds.
+ */
+
+mergeInto(LibraryManager.library, {
+    /*
+     * void js_debug(const char *message);
+     *
+     * A function to write a diagnostic to the Javascript console.
+     * Unused in production, but handy in development.
+     */
+    js_debug: function(ptr) {
+        console.log(Pointer_stringify(ptr));
+    },
+
+    /*
+     * void js_error_box(const char *message);
+     *
+     * A wrapper around Javascript's alert(), so the C code can print
+     * simple error message boxes (e.g. when invalid data is entered
+     * in a configuration dialog).
+     */
+    js_error_box: function(ptr) {
+        alert(Pointer_stringify(ptr));
+    },
+
+    /*
+     * void js_remove_type_dropdown(void);
+     *
+     * Get rid of the drop-down list on the web page for selecting
+     * game presets. Called at setup time if the game back end
+     * provides neither presets nor configurability.
+     */
+    js_remove_type_dropdown: function() {
+        document.getElementById("gametype").style.display = "none";
+    },
+
+    /*
+     * void js_remove_solve_button(void);
+     *
+     * Get rid of the Solve button on the web page. Called at setup
+     * time if the game doesn't support an in-game solve function.
+     */
+    js_remove_solve_button: function() {
+        document.getElementById("solve").style.display = "none";
+    },
+
+    /*
+     * void js_add_preset(const char *name);
+     *
+     * Add a preset to the drop-down types menu. The provided text is
+     * the name of the preset. (The corresponding game_params stays on
+     * the C side and never comes out this far; we just pass a numeric
+     * index back to the C code when a selection is made.)
+     *
+     * The special 'Custom' preset is requested by passing NULL to
+     * this function, rather than the string "Custom", since in that
+     * case we need to do something special - see below.
+     */
+    js_add_preset: function(ptr) {
+        var name = (ptr == 0 ? "Customise..." : Pointer_stringify(ptr));
+        var value = gametypeoptions.length;
+
+        var option = document.createElement("option");
+        option.value = value;
+        option.appendChild(document.createTextNode(name));
+        gametypeselector.appendChild(option);
+        gametypeoptions.push(option);
+
+        if (ptr == 0) {
+            // The option we've just created is the one for inventing
+            // a new custom setup.
+            gametypenewcustom = option;
+            option.value = -1;
+
+            // Now create another element called 'Custom', which will
+            // be auto-selected by us to indicate the custom settings
+            // you've previously selected. However, we don't add it to
+            // the game type selector; it will only appear when the
+            // user actually has custom settings selected.
+            option = document.createElement("option");
+            option.value = -2;
+            option.appendChild(document.createTextNode("Custom"));
+            gametypethiscustom = option;
+        }
+    },
+
+    /*
+     * int js_get_selected_preset(void);
+     *
+     * Return the index of the currently selected value in the type
+     * dropdown.
+     */
+    js_get_selected_preset: function() {
+        for (var i in gametypeoptions) {
+            if (gametypeoptions[i].selected) {
+                return gametypeoptions[i].value;
+            }
+        }
+        return 0;
+    },
+
+    /*
+     * void js_select_preset(int n);
+     *
+     * Cause a different value to be selected in the type dropdown
+     * (for when the user selects values from the Custom configurer
+     * which turn out to exactly match a preset).
+     */
+    js_select_preset: function(n) {
+        if (gametypethiscustom !== null) {
+            // Fiddle with the Custom/Customise options. If we're
+            // about to select the Custom option, then it should be in
+            // the menu, and the other one should read "Re-customise";
+            // if we're about to select another one, then the static
+            // Custom option should disappear and the other one should
+            // read "Customise".
+
+            if (gametypethiscustom.parentNode == gametypeselector)
+                gametypeselector.removeChild(gametypethiscustom);
+            if (gametypenewcustom.parentNode == gametypeselector)
+                gametypeselector.removeChild(gametypenewcustom);
+
+            if (n < 0) {
+                gametypeselector.appendChild(gametypethiscustom);
+                gametypenewcustom.lastChild.data = "Re-customise...";
+            } else {
+                gametypenewcustom.lastChild.data = "Customise...";
+            }
+            gametypeselector.appendChild(gametypenewcustom);
+            gametypenewcustom.selected = false;
+        }
+
+        if (n < 0) {
+            gametypethiscustom.selected = true;
+        } else {
+            gametypeoptions[n].selected = true;
+        }
+    },
+
+    /*
+     * void js_get_date_64(unsigned *p);
+     *
+     * Return the current date, in milliseconds since the epoch
+     * (Javascript's native format), as a 64-bit integer. Used to
+     * invent an initial random seed for puzzle generation.
+     */
+    js_get_date_64: function(ptr) {
+        var d = (new Date()).valueOf();
+        setValue(ptr, d, 'i64');
+    },
+
+    /*
+     * void js_update_permalinks(const char *desc, const char *seed);
+     *
+     * Update the permalinks on the web page for a new game
+     * description and optional random seed. desc can never be NULL,
+     * but seed might be (if the game was generated by entering a
+     * descriptive id by hand), in which case we suppress display of
+     * the random seed permalink.
+     */
+    js_update_permalinks: function(desc, seed) {
+        desc = Pointer_stringify(desc);
+        permalink_desc.href = "#" + desc;
+
+        if (seed == 0) {
+            permalink_seed.style.display = "none";
+        } else {
+            seed = Pointer_stringify(seed);
+            permalink_seed.href = "#" + seed;
+            permalink_seed.style.display = "inline";
+        }
+    },
+
+    /*
+     * void js_enable_undo_redo(int undo, int redo);
+     *
+     * Set the enabled/disabled states of the undo and redo buttons,
+     * after a move.
+     */
+    js_enable_undo_redo: function(undo, redo) {
+        undo_button.disabled = (undo == 0);
+        redo_button.disabled = (redo == 0);
+    },
+
+    /*
+     * void js_activate_timer();
+     *
+     * Start calling the C timer_callback() function every 20ms.
+     */
+    js_activate_timer: function() {
+        if (timer === null) {
+            timer_reference_date = (new Date()).valueOf();
+            timer = setInterval(function() {
+                var now = (new Date()).valueOf();
+                timer_callback((now - timer_reference_date) / 1000.0);
+                timer_reference_date = now;
+                return true;
+            }, 20);
+        }
+    },
+
+    /*
+     * void js_deactivate_timer();
+     *
+     * Stop calling the C timer_callback() function every 20ms.
+     */
+    js_deactivate_timer: function() {
+        if (timer !== null) {
+            clearInterval(timer);
+            timer = null;
+        }
+    },
+
+    /*
+     * void js_canvas_start_draw(void);
+     *
+     * Prepare to do some drawing on the canvas.
+     */
+    js_canvas_start_draw: function() {
+        ctx = offscreen_canvas.getContext('2d');
+        update_xmin = update_xmax = update_ymin = update_ymax = undefined;
+    },
+
+    /*
+     * void js_canvas_draw_update(int x, int y, int w, int h);
+     *
+     * Mark a rectangle of the off-screen canvas as needing to be
+     * copied to the on-screen one.
+     */
+    js_canvas_draw_update: function(x, y, w, h) {
+        /*
+         * Currently we do this in a really simple way, just by taking
+         * the smallest rectangle containing all updates so far. We
+         * could instead keep the data in a richer form (e.g. retain
+         * multiple smaller rectangles needing update, and only redraw
+         * the whole thing beyond a certain threshold) but this will
+         * do for now.
+         */
+        if (update_xmin === undefined || update_xmin > x) update_xmin = x;
+        if (update_ymin === undefined || update_ymin > y) update_ymin = y;
+        if (update_xmax === undefined || update_xmax < x+w) update_xmax = x+w;
+        if (update_ymax === undefined || update_ymax < y+h) update_ymax = y+h;
+    },
+
+    /*
+     * void js_canvas_end_draw(void);
+     *
+     * Finish the drawing, by actually copying the newly drawn stuff
+     * to the on-screen canvas.
+     */
+    js_canvas_end_draw: function() {
+        if (update_xmin !== undefined) {
+            var onscreen_ctx = onscreen_canvas.getContext('2d');
+            onscreen_ctx.drawImage(offscreen_canvas,
+                                   update_xmin, update_ymin,
+                                   update_xmax - update_xmin,
+                                   update_ymax - update_ymin,
+                                   update_xmin, update_ymin,
+                                   update_xmax - update_xmin,
+                                   update_ymax - update_ymin);
+        }
+        ctx = null;
+    },
+
+    /*
+     * void js_canvas_draw_rect(int x, int y, int w, int h,
+     *                          const char *colour);
+     * 
+     * Draw a rectangle.
+     */
+    js_canvas_draw_rect: function(x, y, w, h, colptr) {
+        ctx.fillStyle = Pointer_stringify(colptr);
+        ctx.fillRect(x, y, w, h);
+    },
+
+    /*
+     * void js_canvas_clip_rect(int x, int y, int w, int h);
+     * 
+     * Set a clipping rectangle.
+     */
+    js_canvas_clip_rect: function(x, y, w, h) {
+        ctx.save();
+        ctx.beginPath();
+        ctx.rect(x, y, w, h);
+        ctx.clip();
+    },
+
+    /*
+     * void js_canvas_unclip(void);
+     * 
+     * Reset to no clipping.
+     */
+    js_canvas_unclip: function() {
+        ctx.restore();
+    },
+
+    /*
+     * void js_canvas_draw_line(float x1, float y1, float x2, float y2,
+     *                          int width, const char *colour);
+     * 
+     * Draw a line. We must adjust the coordinates by 0.5 because
+     * Javascript's canvas coordinates appear to be pixel corners,
+     * whereas we want pixel centres. Also, we manually draw the pixel
+     * at each end of the line, which our clients will expect but
+     * Javascript won't reliably do by default (in common with other
+     * Postscriptish drawing frameworks).
+     */
+    js_canvas_draw_line: function(x1, y1, x2, y2, width, colour) {
+        colour = Pointer_stringify(colour);
+
+        ctx.beginPath();
+        ctx.moveTo(x1 + 0.5, y1 + 0.5);
+        ctx.lineTo(x2 + 0.5, y2 + 0.5);
+        ctx.lineWidth = width;
+        ctx.lineCap = 'round';
+        ctx.lineJoin = 'round';
+        ctx.strokeStyle = colour;
+        ctx.stroke();
+        ctx.fillStyle = colour;
+        ctx.fillRect(x1, y1, 1, 1);
+        ctx.fillRect(x2, y2, 1, 1);
+    },
+
+    /*
+     * void js_canvas_draw_poly(int *points, int npoints,
+     *                          const char *fillcolour,
+     *                          const char *outlinecolour);
+     * 
+     * Draw a polygon.
+     */
+    js_canvas_draw_poly: function(pointptr, npoints, fill, outline) {
+        ctx.beginPath();
+        ctx.moveTo(getValue(pointptr  , 'i32') + 0.5,
+                   getValue(pointptr+4, 'i32') + 0.5);
+        for (var i = 1; i < npoints; i++)
+            ctx.lineTo(getValue(pointptr+8*i  , 'i32') + 0.5,
+                       getValue(pointptr+8*i+4, 'i32') + 0.5);
+        ctx.closePath();
+        if (fill != 0) {
+            ctx.fillStyle = Pointer_stringify(fill);
+            ctx.fill();
+        }
+        ctx.lineWidth = '1';
+        ctx.lineCap = 'round';
+        ctx.lineJoin = 'round';
+        ctx.strokeStyle = Pointer_stringify(outline);
+        ctx.stroke();
+    },
+
+    /*
+     * void js_canvas_draw_circle(int x, int y, int r,
+     *                            const char *fillcolour,
+     *                            const char *outlinecolour);
+     * 
+     * Draw a circle.
+     */
+    js_canvas_draw_circle: function(x, y, r, fill, outline) {
+        ctx.beginPath();
+        ctx.arc(x + 0.5, y + 0.5, r, 0, 2*Math.PI);
+        if (fill != 0) {
+            ctx.fillStyle = Pointer_stringify(fill);
+            ctx.fill();
+        }
+        ctx.lineWidth = '1';
+        ctx.lineCap = 'round';
+        ctx.lineJoin = 'round';
+        ctx.strokeStyle = Pointer_stringify(outline);
+        ctx.stroke();
+    },
+
+    /*
+     * int js_canvas_find_font_midpoint(int height, const char *fontptr);
+     * 
+     * Return the adjustment required for text displayed using
+     * ALIGN_VCENTRE. We want to place the midpoint between the
+     * baseline and the cap-height at the specified position; so this
+     * function returns the adjustment which, when added to the
+     * desired centre point, returns the y-coordinate at which you
+     * should put the baseline.
+     *
+     * There is no sensible method of querying this kind of font
+     * metric in Javascript, so instead we render a piece of test text
+     * to a throwaway offscreen canvas and then read the pixel data
+     * back out to find the highest and lowest pixels. That's good
+     * _enough_ (in that we only needed the answer to the nearest
+     * pixel anyway), but rather disgusting!
+     *
+     * Since this is a very expensive operation, we cache the results
+     * per (font,height) pair.
+     */
+    js_canvas_find_font_midpoint: function(height, font) {
+        font = Pointer_stringify(font);
+
+        // Reuse cached value if possible
+        if (midpoint_cache[font] !== undefined)
+            return midpoint_cache[font];
+
+        // Find the width of the string
+        var ctx1 = onscreen_canvas.getContext('2d');
+        ctx1.font = font;
+        var width = (ctx1.measureText(midpoint_test_str).width + 1) | 0;
+
+        // Construct a test canvas of appropriate size, initialise it to
+        // black, and draw the string on it in white
+        var measure_canvas = document.createElement('canvas');
+        var ctx2 = measure_canvas.getContext('2d');
+        ctx2.canvas.width = width;
+        ctx2.canvas.height = 2*height;
+        ctx2.fillStyle = "#000000";
+        ctx2.fillRect(0, 0, width, 2*height);
+        var baseline = (1.5*height) | 0;
+        ctx2.fillStyle = "#ffffff";
+        ctx2.font = font;
+        ctx2.fillText(midpoint_test_str, 0, baseline);
+
+        // Scan the contents of the test canvas to find the top and bottom
+        // set pixels.
+        var pixels = ctx2.getImageData(0, 0, width, 2*height).data;
+        var ymin = 2*height, ymax = -1;
+        for (var y = 0; y < 2*height; y++) {
+            for (var x = 0; x < width; x++) {
+                if (pixels[4*(y*width+x)] != 0) {
+                    if (ymin > y) ymin = y;
+                    if (ymax < y) ymax = y;
+                    break;
+                }
+            }
+        }
+
+        var ret = (baseline - (ymin + ymax) / 2) | 0;
+        midpoint_cache[font] = ret;
+        return ret;
+    },
+
+    /*
+     * void js_canvas_draw_text(int x, int y, int halign,
+     *                          const char *colptr, const char *fontptr,
+     *                          const char *text);
+     * 
+     * Draw text. Vertical alignment has been taken care of on the C
+     * side, by optionally calling the above function. Horizontal
+     * alignment is handled here, since we can get the canvas draw
+     * function to do it for us with almost no extra effort.
+     */
+    js_canvas_draw_text: function(x, y, halign, colptr, fontptr, text) {
+        ctx.font = Pointer_stringify(fontptr);
+        ctx.fillStyle = Pointer_stringify(colptr);
+        ctx.textAlign = (halign == 0 ? 'left' :
+                         halign == 1 ? 'center' : 'right');
+        ctx.textBaseline = 'alphabetic';
+        ctx.fillText(Pointer_stringify(text), x, y);
+    },
+
+    /*
+     * int js_canvas_new_blitter(int w, int h);
+     * 
+     * Create a new blitter object, which is just an offscreen canvas
+     * of the specified size.
+     */
+    js_canvas_new_blitter: function(w, h) {
+        var id = blittercount++;
+        blitters[id] = document.createElement("canvas");
+        blitters[id].width = w;
+        blitters[id].height = h;
+        return id;
+    },
+
+    /*
+     * void js_canvas_free_blitter(int id);
+     * 
+     * Free a blitter (or rather, destroy our reference to it so JS
+     * can garbage-collect it, and also enforce that we don't
+     * accidentally use it again afterwards).
+     */
+    js_canvas_free_blitter: function(id) {
+        blitters[id] = null;
+    },
+
+    /*
+     * void js_canvas_copy_to_blitter(int id, int x, int y, int w, int h);
+     * 
+     * Copy from the puzzle image to a blitter. The size is passed to
+     * us, partly so we don't have to remember the size of each
+     * blitter, but mostly so that the C side can adjust the copy
+     * rectangle in the case where it partially overlaps the edge of
+     * the screen.
+     */
+    js_canvas_copy_to_blitter: function(id, x, y, w, h) {
+        var blitter_ctx = blitters[id].getContext('2d');
+        blitter_ctx.drawImage(offscreen_canvas,
+                              x, y, w, h,
+                              0, 0, w, h);
+    },
+
+    /*
+     * void js_canvas_copy_from_blitter(int id, int x, int y, int w, int h);
+     * 
+     * Copy from a blitter back to the puzzle image. As above, the
+     * size of the copied rectangle is passed to us from the C side
+     * and may already have been modified.
+     */
+    js_canvas_copy_from_blitter: function(id, x, y, w, h) {
+        ctx.drawImage(blitters[id],
+                      0, 0, w, h,
+                      x, y, w, h);
+    },
+
+    /*
+     * void js_canvas_make_statusbar(void);
+     * 
+     * Cause a status bar to exist. Called at setup time if the puzzle
+     * back end turns out to want one.
+     */
+    js_canvas_make_statusbar: function() {
+        var statusholder = document.getElementById("statusbarholder");
+        statusbar = document.createElement("div");
+        statusbar.style.overflow = "hidden";
+        statusbar.style.width = (onscreen_canvas.width - 4) + "px";
+        statusholder.style.width = onscreen_canvas.width + "px";
+        statusbar.style.height = "1.2em";
+        statusbar.style.textAlign = "left";
+        statusbar.style.background = "#d8d8d8";
+        statusbar.style.borderLeft = '2px solid #c8c8c8';
+        statusbar.style.borderTop = '2px solid #c8c8c8';
+        statusbar.style.borderRight = '2px solid #e8e8e8';
+        statusbar.style.borderBottom = '2px solid #e8e8e8';
+        statusbar.appendChild(document.createTextNode(" "));
+        statusholder.appendChild(statusbar);
+    },
+
+    /*
+     * void js_canvas_set_statusbar(const char *text);
+     * 
+     * Set the text in the status bar.
+     */
+    js_canvas_set_statusbar: function(ptr) {
+        var text = Pointer_stringify(ptr);
+        statusbar.replaceChild(document.createTextNode(text),
+                               statusbar.lastChild);
+    },
+
+    /*
+     * void js_canvas_set_size(int w, int h);
+     * 
+     * Set the size of the puzzle canvas. Called at setup, and every
+     * time the user picks new puzzle settings requiring a different
+     * size.
+     */
+    js_canvas_set_size: function(w, h) {
+        onscreen_canvas.width = w;
+        offscreen_canvas.width = w;
+        if (statusbar !== null) {
+            statusbar.style.width = (w - 4) + "px";
+            document.getElementById("statusbarholder").style.width = w + "px";
+        }
+        resizable_div.style.width = w + "px";
+
+        onscreen_canvas.height = h;
+        offscreen_canvas.height = h;
+    },
+
+    /*
+     * void js_dialog_init(const char *title);
+     * 
+     * Begin constructing a 'dialog box' which will be popped up in an
+     * overlay on top of the rest of the puzzle web page.
+     */
+    js_dialog_init: function(titletext) {
+        // Create an overlay on the page which darkens everything
+        // beneath it.
+        dlg_dimmer = document.createElement("div");
+        dlg_dimmer.style.width = "100%";
+        dlg_dimmer.style.height = "100%";
+        dlg_dimmer.style.background = '#000000';
+        dlg_dimmer.style.position = 'fixed';
+        dlg_dimmer.style.opacity = 0.3;
+        dlg_dimmer.style.top = dlg_dimmer.style.left = 0;
+        dlg_dimmer.style["z-index"] = 99;
+
+        // Now create a form which sits on top of that in turn.
+        dlg_form = document.createElement("form");
+        dlg_form.style.width = (window.innerWidth * 2 / 3) + "px";
+        dlg_form.style.opacity = 1;
+        dlg_form.style.background = '#ffffff';
+        dlg_form.style.color = '#000000';
+        dlg_form.style.position = 'absolute';
+        dlg_form.style.border = "2px solid black";
+        dlg_form.style.padding = "20px";
+        dlg_form.style.top = (window.innerHeight / 10) + "px";
+        dlg_form.style.left = (window.innerWidth / 6) + "px";
+        dlg_form.style["z-index"] = 100;
+
+        var title = document.createElement("p");
+        title.style.marginTop = "0px";
+        title.appendChild(document.createTextNode
+                          (Pointer_stringify(titletext)));
+        dlg_form.appendChild(title);
+
+        dlg_return_funcs = [];
+        dlg_next_id = 0;
+    },
+
+    /*
+     * void js_dialog_string(int i, const char *title, const char *initvalue);
+     * 
+     * Add a string control (that is, an edit box) to the dialog under
+     * construction.
+     */
+    js_dialog_string: function(index, title, initialtext) {
+        dlg_form.appendChild(document.createTextNode(Pointer_stringify(title)));
+        var editbox = document.createElement("input");
+        editbox.type = "text";
+        editbox.value = Pointer_stringify(initialtext);
+        dlg_form.appendChild(editbox);
+        dlg_form.appendChild(document.createElement("br"));
+
+        dlg_return_funcs.push(function() {
+            dlg_return_sval(index, editbox.value);
+        });
+    },
+
+    /*
+     * void js_dialog_choices(int i, const char *title, const char *choicelist,
+     *                        int initvalue);
+     * 
+     * Add a choices control (i.e. a drop-down list) to the dialog
+     * under construction. The 'choicelist' parameter is unchanged
+     * from the way the puzzle back end will have supplied it: i.e.
+     * it's still encoded as a single string whose first character
+     * gives the separator.
+     */
+    js_dialog_choices: function(index, title, choicelist, initvalue) {
+        dlg_form.appendChild(document.createTextNode(Pointer_stringify(title)));
+        var dropdown = document.createElement("select");
+        var choicestr = Pointer_stringify(choicelist);
+        var items = choicestr.slice(1).split(choicestr[0]);
+        var options = [];
+        for (var i in items) {
+            var option = document.createElement("option");
+            option.value = i;
+            option.appendChild(document.createTextNode(items[i]));
+            if (i == initvalue) option.selected = true;
+            dropdown.appendChild(option);
+            options.push(option);
+        }
+        dlg_form.appendChild(dropdown);
+        dlg_form.appendChild(document.createElement("br"));
+
+        dlg_return_funcs.push(function() {
+            var val = 0;
+            for (var i in options) {
+                if (options[i].selected) {
+                    val = options[i].value;
+                    break;
+                }
+            }
+            dlg_return_ival(index, val);
+        });
+    },
+
+    /*
+     * void js_dialog_boolean(int i, const char *title, int initvalue);
+     * 
+     * Add a boolean control (a checkbox) to the dialog under
+     * construction. Checkboxes are generally expected to be sensitive
+     * on their label text as well as the box itself, so for this
+     * control we create an actual label rather than merely a text
+     * node (and hence we must allocate an id to the checkbox so that
+     * the label can refer to it).
+     */
+    js_dialog_boolean: function(index, title, initvalue) {
+        var checkbox = document.createElement("input");
+        checkbox.type = "checkbox";
+        checkbox.id = "cb" + String(dlg_next_id++);
+        checkbox.checked = (initvalue != 0);
+        dlg_form.appendChild(checkbox);
+        var checkboxlabel = document.createElement("label");
+        checkboxlabel.setAttribute("for", checkbox.id);
+        checkboxlabel.textContent = Pointer_stringify(title);
+        dlg_form.appendChild(checkboxlabel);
+        dlg_form.appendChild(document.createElement("br"));
+
+        dlg_return_funcs.push(function() {
+            dlg_return_ival(index, checkbox.checked ? 1 : 0);
+        });
+    },
+
+    /*
+     * void js_dialog_launch(void);
+     * 
+     * Finish constructing a dialog, and actually display it, dimming
+     * everything else on the page.
+     */
+    js_dialog_launch: function() {
+        // Put in the OK and Cancel buttons at the bottom.
+        var button;
+
+        button = document.createElement("input");
+        button.type = "button";
+        button.value = "OK";
+        button.onclick = function(event) {
+            for (var i in dlg_return_funcs)
+                dlg_return_funcs[i]();
+            command(3);
+        }
+        dlg_form.appendChild(button);
+
+        button = document.createElement("input");
+        button.type = "button";
+        button.value = "Cancel";
+        button.onclick = function(event) {
+            command(4);
+        }
+        dlg_form.appendChild(button);
+
+        document.body.appendChild(dlg_dimmer);
+        document.body.appendChild(dlg_form);
+    },
+
+    /*
+     * void js_dialog_cleanup(void);
+     * 
+     * Stop displaying a dialog, and clean up the internal state
+     * associated with it.
+     */
+    js_dialog_cleanup: function() {
+        document.body.removeChild(dlg_dimmer);
+        document.body.removeChild(dlg_form);
+        dlg_dimmer = dlg_form = null;
+        onscreen_canvas.focus();
+    },
+
+    /*
+     * void js_focus_canvas(void);
+     * 
+     * Return keyboard focus to the puzzle canvas. Called after a
+     * puzzle-control button is pressed, which tends to have the side
+     * effect of taking focus away from the canvas.
+     */
+    js_focus_canvas: function() {
+        onscreen_canvas.focus();
+    }
+});
diff --git a/apps/plugins/puzzles/emccpre.js b/apps/plugins/puzzles/emccpre.js
new file mode 100644
index 0000000000..ebf67d1fc6
--- /dev/null
+++ b/apps/plugins/puzzles/emccpre.js
@@ -0,0 +1,364 @@
+/*
+ * emccpre.js: one of the Javascript components of an Emscripten-based
+ * web/Javascript front end for Puzzles.
+ *
+ * The other parts of this system live in emcc.c and emcclib.js. It
+ * also depends on being run in the context of a web page containing
+ * an appropriate collection of bits and pieces (a canvas, some
+ * buttons and links etc), which is generated for each puzzle by the
+ * script html/jspage.pl.
+ *
+ * This file contains the Javascript code which is prefixed unmodified
+ * to Emscripten's output via the --pre-js option. It declares all our
+ * global variables, and provides the puzzle init function and a
+ * couple of other helper functions.
+ */
+
+// To avoid flicker while doing complicated drawing, we use two
+// canvases, the same size. One is actually on the web page, and the
+// other is off-screen. We do all our drawing on the off-screen one
+// first, and then copy rectangles of it to the on-screen canvas in
+// response to draw_update() calls by the game backend.
+var onscreen_canvas, offscreen_canvas;
+
+// A persistent drawing context for the offscreen canvas, to save
+// constructing one per individual graphics operation.
+var ctx;
+
+// Bounding rectangle for the copy to the onscreen canvas that will be
+// done at drawing end time. Updated by js_canvas_draw_update and used
+// by js_canvas_end_draw.
+var update_xmin, update_xmax, update_ymin, update_ymax;
+
+// Module object for Emscripten. We fill in these parameters to ensure
+// that Module.run() won't be called until we're ready (we want to do
+// our own init stuff first), and that when main() returns nothing
+// will get cleaned up so we remain able to call the puzzle's various
+// callbacks.
+var Module = {
+    'noInitialRun': true,
+    'noExitRuntime': true
+};
+
+// Variables used by js_canvas_find_font_midpoint().
+var midpoint_test_str = "ABCDEFGHIKLMNOPRSTUVWXYZ0123456789";
+var midpoint_cache = [];
+
+// Variables used by js_activate_timer() and js_deactivate_timer().
+var timer = null;
+var timer_reference_date;
+
+// void timer_callback(double tplus);
+//
+// Called every 20ms while timing is active.
+var timer_callback;
+
+// The status bar object, if we create one.
+var statusbar = null;
+
+// Currently live blitters. We keep an integer id for each one on the
+// JS side; the C side, which expects a blitter to look like a struct,
+// simply defines the struct to contain that integer id.
+var blittercount = 0;
+var blitters = [];
+
+// State for the dialog-box mechanism. dlg_dimmer and dlg_form are the
+// page-darkening overlay and the actual dialog box respectively;
+// dlg_next_id is used to allocate each checkbox a unique id to use
+// for linking its label to it (see js_dialog_boolean);
+// dlg_return_funcs is a list of JS functions to be called when the OK
+// button is pressed, to pass the results back to C.
+var dlg_dimmer = null, dlg_form = null;
+var dlg_next_id = 0;
+var dlg_return_funcs = null;
+
+// void dlg_return_sval(int index, const char *val);
+// void dlg_return_ival(int index, int val);
+//
+// C-side entry points called by functions in dlg_return_funcs, to
+// pass back the final value in each dialog control.
+var dlg_return_sval, dlg_return_ival;
+
+// The <select> object implementing the game-type drop-down, and a
+// list of the <option> objects inside it. Used by js_add_preset(),
+// js_get_selected_preset() and js_select_preset().
+//
+// gametypethiscustom is an option which indicates some custom game
+// params you've already set up, and which will be auto-selected on
+// return from the customisation dialog; gametypenewcustom is an
+// option which you select to indicate that you want to bring up the
+// customisation dialog and select a new configuration. Ideally I'd do
+// this with just one option serving both purposes, but instead we
+// have to do this a bit oddly because browsers don't send 'onchange'
+// events for a select element if you reselect the same one - so if
+// you've picked a custom setup and now want to change it, you need a
+// way to specify that.
+var gametypeselector = null, gametypeoptions = [];
+var gametypethiscustom = null, gametypehiddencustom = null;
+
+// The two anchors used to give permalinks to the current puzzle. Used
+// by js_update_permalinks().
+var permalink_seed, permalink_desc;
+
+// The undo and redo buttons. Used by js_enable_undo_redo().
+var undo_button, redo_button;
+
+// A div element enclosing both the puzzle and its status bar, used
+// for positioning the resize handle.
+var resizable_div;
+
+// Helper function to find the absolute position of a given DOM
+// element on a page, by iterating upwards through the DOM finding
+// each element's offset from its parent, and thus calculating the
+// page-relative position of the target element.
+function element_coords(element) {
+    var ex = 0, ey = 0;
+    while (element.offsetParent) {
+        ex += element.offsetLeft;
+        ey += element.offsetTop;
+        element = element.offsetParent;
+    }
+    return {x: ex, y:ey};
+}
+
+// Helper function which is passed a mouse event object and a DOM
+// element, and returns the coordinates of the mouse event relative to
+// the top left corner of the element by subtracting element_coords
+// from event.page{X,Y}.
+function relative_mouse_coords(event, element) {
+    var ecoords = element_coords(element);
+    return {x: event.pageX - ecoords.x,
+            y: event.pageY - ecoords.y};
+}
+
+// Init function called from body.onload.
+function initPuzzle() {
+    // Construct the off-screen canvas used for double buffering.
+    onscreen_canvas = document.getElementById("puzzlecanvas");
+    offscreen_canvas = document.createElement("canvas");
+    offscreen_canvas.width = onscreen_canvas.width;
+    offscreen_canvas.height = onscreen_canvas.height;
+
+    // Stop right-clicks on the puzzle from popping up a context menu.
+    // We need those right-clicks!
+    onscreen_canvas.oncontextmenu = function(event) { return false; }
+
+    // Set up mouse handlers. We do a bit of tracking of the currently
+    // pressed mouse buttons, to avoid sending mousemoves with no
+    // button down (our puzzles don't want those events).
+    mousedown = Module.cwrap('mousedown', 'void',
+                             ['number', 'number', 'number']);
+    buttons_down = 0;
+    onscreen_canvas.onmousedown = function(event) {
+        var xy = relative_mouse_coords(event, onscreen_canvas);
+        mousedown(xy.x, xy.y, event.button);
+        buttons_down |= 1 << event.button;
+        onscreen_canvas.setCapture(true);
+    };
+    mousemove = Module.cwrap('mousemove', 'void',
+                             ['number', 'number', 'number']);
+    onscreen_canvas.onmousemove = function(event) {
+        if (buttons_down) {
+            var xy = relative_mouse_coords(event, onscreen_canvas);
+            mousemove(xy.x, xy.y, buttons_down);
+        }
+    };
+    mouseup = Module.cwrap('mouseup', 'void',
+                           ['number', 'number', 'number']);
+    onscreen_canvas.onmouseup = function(event) {
+        if (buttons_down & (1 << event.button)) {
+            buttons_down ^= 1 << event.button;
+            var xy = relative_mouse_coords(event, onscreen_canvas);
+            mouseup(xy.x, xy.y, event.button);
+        }
+    };
+
+    // Set up keyboard handlers. We do all the actual keyboard
+    // handling in onkeydown; but we also call event.preventDefault()
+    // in both the keydown and keypress handlers. This means that
+    // while the canvas itself has focus, _all_ keypresses go only to
+    // the puzzle - so users of this puzzle collection in other media
+    // can indulge their instinct to press ^R for redo, for example,
+    // without accidentally reloading the page.
+    key = Module.cwrap('key', 'void', ['number', 'number', 'string',
+                                       'string', 'number', 'number']);
+    onscreen_canvas.onkeydown = function(event) {
+        key(event.keyCode, event.charCode, event.key, event.char,
+            event.shiftKey ? 1 : 0, event.ctrlKey ? 1 : 0);
+        event.preventDefault();
+    };
+    onscreen_canvas.onkeypress = function(event) {
+        event.preventDefault();
+    };
+
+    // command() is a C function called to pass back events which
+    // don't fall into other categories like mouse and key events.
+    // Mostly those are button presses, but there's also one for the
+    // game-type dropdown having been changed.
+    command = Module.cwrap('command', 'void', ['number']);
+
+    // Event handlers for buttons and things, which call command().
+    document.getElementById("specific").onclick = function(event) {
+        // Ensure we don't accidentally process these events when a
+        // dialog is actually active, e.g. because the button still
+        // has keyboard focus
+        if (dlg_dimmer === null)
+            command(0);
+    };
+    document.getElementById("random").onclick = function(event) {
+        if (dlg_dimmer === null)
+            command(1);
+    };
+    document.getElementById("new").onclick = function(event) {
+        if (dlg_dimmer === null)
+            command(5);
+    };
+    document.getElementById("restart").onclick = function(event) {
+        if (dlg_dimmer === null)
+            command(6);
+    };
+    undo_button = document.getElementById("undo");
+    undo_button.onclick = function(event) {
+        if (dlg_dimmer === null)
+            command(7);
+    };
+    redo_button = document.getElementById("redo");
+    redo_button.onclick = function(event) {
+        if (dlg_dimmer === null)
+            command(8);
+    };
+    document.getElementById("solve").onclick = function(event) {
+        if (dlg_dimmer === null)
+            command(9);
+    };
+
+    gametypeselector = document.getElementById("gametype");
+    gametypeselector.onchange = function(event) {
+        if (dlg_dimmer === null)
+            command(2);
+    };
+
+    // In IE, the canvas doesn't automatically gain focus on a mouse
+    // click, so make sure it does
+    onscreen_canvas.addEventListener("mousedown", function(event) {
+        onscreen_canvas.focus();
+    });
+
+    // In our dialog boxes, Return and Escape should be like pressing
+    // OK and Cancel respectively
+    document.addEventListener("keydown", function(event) {
+
+        if (dlg_dimmer !== null && event.keyCode == 13) {
+            for (var i in dlg_return_funcs)
+                dlg_return_funcs[i]();
+            command(3);
+        }
+
+        if (dlg_dimmer !== null && event.keyCode == 27)
+            command(4);
+    });
+
+    // Set up the function pointers we haven't already grabbed. 
+    dlg_return_sval = Module.cwrap('dlg_return_sval', 'void',
+                                   ['number','string']);
+    dlg_return_ival = Module.cwrap('dlg_return_ival', 'void',
+                                   ['number','number']);
+    timer_callback = Module.cwrap('timer_callback', 'void', ['number']);
+
+    // Save references to the two permalinks.
+    permalink_desc = document.getElementById("permalink-desc");
+    permalink_seed = document.getElementById("permalink-seed");
+
+    // Default to giving keyboard focus to the puzzle.
+    onscreen_canvas.focus();
+
+    // Create the resize handle.
+    var resize_handle = document.createElement("canvas");
+    resize_handle.width = 10;
+    resize_handle.height = 10;
+    {
+        var ctx = resize_handle.getContext("2d");
+        ctx.beginPath();
+        for (var i = 1; i <= 7; i += 3) {
+            ctx.moveTo(8.5, i + 0.5);
+            ctx.lineTo(i + 0.5, 8.5);
+        }
+        ctx.lineWidth = '1px';
+        ctx.lineCap = 'round';
+        ctx.lineJoin = 'round';
+        ctx.strokeStyle = '#000000';
+        ctx.stroke();
+    }
+    resizable_div = document.getElementById("resizable");
+    resizable_div.appendChild(resize_handle);
+    resize_handle.style.position = 'absolute';
+    resize_handle.style.zIndex = 98;
+    resize_handle.style.bottom = "0";
+    resize_handle.style.right = "0";
+    resize_handle.style.cursor = "se-resize";
+    resize_handle.title = "Drag to resize the puzzle. Right-click to restore the default size.";
+    var resize_xbase = null, resize_ybase = null, restore_pending = false;
+    var resize_xoffset = null, resize_yoffset = null;
+    var resize_puzzle = Module.cwrap('resize_puzzle',
+                                     'void', ['number', 'number']);
+    var restore_puzzle_size = Module.cwrap('restore_puzzle_size', 'void', []);
+    resize_handle.oncontextmenu = function(event) { return false; }
+    resize_handle.onmousedown = function(event) {
+        if (event.button == 0) {
+            var xy = element_coords(onscreen_canvas);
+            resize_xbase = xy.x + onscreen_canvas.width / 2;
+            resize_ybase = xy.y;
+            resize_xoffset = xy.x + onscreen_canvas.width - event.pageX;
+            resize_yoffset = xy.y + onscreen_canvas.height - event.pageY;
+        } else {
+            restore_pending = true;
+        }
+        resize_handle.setCapture(true);
+        event.preventDefault();
+    };
+    window.addEventListener("mousemove", function(event) {
+        if (resize_xbase !== null && resize_ybase !== null) {
+            resize_puzzle((event.pageX + resize_xoffset - resize_xbase) * 2,
+                          (event.pageY + resize_yoffset - resize_ybase));
+            event.preventDefault();
+            // Chrome insists on selecting text during a resize drag
+            // no matter what I do
+            if (window.getSelection)
+                window.getSelection().removeAllRanges();
+            else
+                document.selection.empty();        }
+    });
+    window.addEventListener("mouseup", function(event) {
+        if (resize_xbase !== null && resize_ybase !== null) {
+            resize_xbase = null;
+            resize_ybase = null;
+            onscreen_canvas.focus(); // return focus to the puzzle
+            event.preventDefault();
+        } else if (restore_pending) {
+            // If you have the puzzle at larger than normal size and
+            // then right-click to restore, I haven't found any way to
+            // stop Chrome and IE popping up a context menu on the
+            // revealed piece of document when you release the button
+            // except by putting the actual restore into a setTimeout.
+            // Gah.
+            setTimeout(function() {
+                restore_pending = false;
+                restore_puzzle_size();
+                onscreen_canvas.focus();
+            }, 20);
+            event.preventDefault();
+        }
+    });
+
+    // Run the C setup function, passing argv[1] as the fragment
+    // identifier (so that permalinks of the form puzzle.html#game-id
+    // can launch the specified id).
+    Module.callMain([location.hash]);
+
+    // And if we get here with everything having gone smoothly, i.e.
+    // we haven't crashed for one reason or another during setup, then
+    // it's probably safe to hide the 'sorry, no puzzle here' div and
+    // show the div containing the actual puzzle.
+    document.getElementById("apology").style.display = "none";
+    document.getElementById("puzzle").style.display = "inline";
+}
diff --git a/apps/plugins/puzzles/emccx.json b/apps/plugins/puzzles/emccx.json
new file mode 100644
index 0000000000..e03f7e25c7
--- /dev/null
+++ b/apps/plugins/puzzles/emccx.json
@@ -0,0 +1,29 @@
+// -*- js -*-
+//
+// List of entry points exported by the C side of the Emscripten
+// puzzle builds. Passed in to emcc via the option '-s
+// EXPORTED_FUNCTIONS=[list]'.
+//
+// This file isn't actually a valid list in its current state, since
+// emcc doesn't like comments or newlines. However, it's a nicer
+// source form to keep the comments and newlines in, so we sed them
+// away at compile time.
+[
+    // Event handlers for mouse and keyboard input
+    '_mouseup',
+    '_mousedown',
+    '_mousemove',
+    '_key',
+    // Callback when the program activates timing
+    '_timer_callback',
+    // Callback from button presses in the UI outside the canvas
+    '_command',
+    // Callbacks to return values from dialog boxes
+    '_dlg_return_sval',
+    '_dlg_return_ival',
+    // Callbacks when the resizing controls are used
+    '_resize_puzzle',
+    '_restore_puzzle_size',
+    // Main program, run at initialisation time
+    '_main'
+]
diff --git a/apps/plugins/puzzles/fifteen.R b/apps/plugins/puzzles/fifteen.R
new file mode 100644
index 0000000000..b2292acc69
--- /dev/null
+++ b/apps/plugins/puzzles/fifteen.R
@@ -0,0 +1,22 @@
+# -*- makefile -*-
+
+fifteen  : [X] GTK COMMON fifteen fifteen-icon|no-icon
+
+fifteen  : [G] WINDOWS COMMON fifteen fifteen.res|noicon.res
+
+fifteensolver :    [U] fifteen[STANDALONE_SOLVER] STANDALONE
+fifteensolver :    [C] fifteen[STANDALONE_SOLVER] STANDALONE
+
+ALL += fifteen[COMBINED]
+
+!begin am gtk
+GAMES += fifteen
+!end
+
+!begin >list.c
+    A(fifteen) \
+!end
+
+!begin >gamedesc.txt
+fifteen:fifteen.exe:Fifteen:Sliding block puzzle:Slide the tiles around to arrange them into order.
+!end
diff --git a/apps/plugins/puzzles/fifteen.c b/apps/plugins/puzzles/fifteen.c
new file mode 100644
index 0000000000..0d5e7f5b0c
--- /dev/null
+++ b/apps/plugins/puzzles/fifteen.c
@@ -0,0 +1,1215 @@
+/*
+ * fifteen.c: standard 15-puzzle.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#define PREFERRED_TILE_SIZE 48
+#define TILE_SIZE (ds->tilesize)
+#define BORDER    (TILE_SIZE / 2)
+#define HIGHLIGHT_WIDTH (TILE_SIZE / 20)
+#define COORD(x)  ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
+
+#define ANIM_TIME 0.13F
+#define FLASH_FRAME 0.13F
+
+#define X(state, i) ( (i) % (state)->w )
+#define Y(state, i) ( (i) / (state)->w )
+#define C(state, x, y) ( (y) * (state)->w + (x) )
+
+#define PARITY_P(params, gap) (((X((params), (gap)) - ((params)->w - 1)) ^ \
+                                (Y((params), (gap)) - ((params)->h - 1)) ^ \
+                                (((params)->w * (params)->h) + 1)) & 1)
+#define PARITY_S(state) PARITY_P((state), ((state)->gap_pos))
+
+enum {
+    COL_BACKGROUND,
+    COL_TEXT,
+    COL_HIGHLIGHT,
+    COL_LOWLIGHT,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h;
+};
+
+struct game_state {
+    int w, h, n;
+    int *tiles;
+    int gap_pos;
+    int completed;
+    int used_solve;                    /* used to suppress completion flash */
+    int movecount;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 4;
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    if (i == 0) {
+        *params = default_params();
+        *name = dupstr("4x4");
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        ret->h = atoi(string);
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    sprintf(data, "%dx%d", params->w, params->h);
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(3, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = NULL;
+    ret[2].type = C_END;
+    ret[2].sval = NULL;
+    ret[2].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 2 || params->h < 2)
+        return "Width and height must both be at least two";
+
+    return NULL;
+}
+
+static int perm_parity(int *perm, int n)
+{
+    int i, j, ret;
+
+    ret = 0;
+
+    for (i = 0; i < n-1; i++)
+        for (j = i+1; j < n; j++)
+            if (perm[i] > perm[j])
+                ret = !ret;
+
+    return ret;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int gap, n, i, x;
+    int x1, x2, p1, p2, parity;
+    int *tiles, *used;
+    char *ret;
+    int retlen;
+
+    n = params->w * params->h;
+
+    tiles = snewn(n, int);
+    used = snewn(n, int);
+
+    for (i = 0; i < n; i++) {
+        tiles[i] = -1;
+        used[i] = FALSE;
+    }
+
+    gap = random_upto(rs, n);
+    tiles[gap] = 0;
+    used[0] = TRUE;
+
+    /*
+     * Place everything else except the last two tiles.
+     */
+    for (x = 0, i = n-1; i > 2; i--) {
+        int k = random_upto(rs, i);
+        int j;
+
+        for (j = 0; j < n; j++)
+            if (!used[j] && (k-- == 0))
+                break;
+
+        assert(j < n && !used[j]);
+        used[j] = TRUE;
+
+        while (tiles[x] >= 0)
+            x++;
+        assert(x < n);
+        tiles[x] = j;
+    }
+
+    /*
+     * Find the last two locations, and the last two pieces.
+     */
+    while (tiles[x] >= 0)
+        x++;
+    assert(x < n);
+    x1 = x;
+    x++;
+    while (tiles[x] >= 0)
+        x++;
+    assert(x < n);
+    x2 = x;
+
+    for (i = 0; i < n; i++)
+        if (!used[i])
+            break;
+    p1 = i;
+    for (i = p1+1; i < n; i++)
+        if (!used[i])
+            break;
+    p2 = i;
+
+    /*
+     * Determine the required parity of the overall permutation.
+     * This is the XOR of:
+     * 
+     *  - The chessboard parity ((x^y)&1) of the gap square. The
+     *    bottom right counts as even.
+     * 
+     *  - The parity of n. (The target permutation is 1,...,n-1,0
+     *    rather than 0,...,n-1; this is a cyclic permutation of
+     *    the starting point and hence is odd iff n is even.)
+     */
+    parity = PARITY_P(params, gap);
+
+    /*
+     * Try the last two tiles one way round. If that fails, swap
+     * them.
+     */
+    tiles[x1] = p1;
+    tiles[x2] = p2;
+    if (perm_parity(tiles, n) != parity) {
+        tiles[x1] = p2;
+        tiles[x2] = p1;
+        assert(perm_parity(tiles, n) == parity);
+    }
+
+    /*
+     * Now construct the game description, by describing the tile
+     * array as a simple sequence of comma-separated integers.
+     */
+    ret = NULL;
+    retlen = 0;
+    for (i = 0; i < n; i++) {
+        char buf[80];
+        int k;
+
+        k = sprintf(buf, "%d,", tiles[i]);
+
+        ret = sresize(ret, retlen + k + 1, char);
+        strcpy(ret + retlen, buf);
+        retlen += k;
+    }
+    ret[retlen-1] = '\0';              /* delete last comma */
+
+    sfree(tiles);
+    sfree(used);
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    const char *p;
+    char *err;
+    int i, area;
+    int *used;
+
+    area = params->w * params->h;
+    p = desc;
+    err = NULL;
+
+    used = snewn(area, int);
+    for (i = 0; i < area; i++)
+        used[i] = FALSE;
+
+    for (i = 0; i < area; i++) {
+        const char *q = p;
+        int n;
+
+        if (*p < '0' || *p > '9') {
+            err = "Not enough numbers in string";
+            goto leave;
+        }
+        while (*p >= '0' && *p <= '9')
+            p++;
+        if (i < area-1 && *p != ',') {
+            err = "Expected comma after number";
+            goto leave;
+        }
+        else if (i == area-1 && *p) {
+            err = "Excess junk at end of string";
+            goto leave;
+        }
+        n = atoi(q);
+        if (n < 0 || n >= area) {
+            err = "Number out of range";
+            goto leave;
+        }
+        if (used[n]) {
+            err = "Number used twice";
+            goto leave;
+        }
+        used[n] = TRUE;
+
+        if (*p) p++;                   /* eat comma */
+    }
+
+    leave:
+    sfree(used);
+    return err;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    int i;
+    const char *p;
+
+    state->w = params->w;
+    state->h = params->h;
+    state->n = params->w * params->h;
+    state->tiles = snewn(state->n, int);
+
+    state->gap_pos = 0;
+    p = desc;
+    i = 0;
+    for (i = 0; i < state->n; i++) {
+        assert(*p);
+        state->tiles[i] = atoi(p);
+        if (state->tiles[i] == 0)
+            state->gap_pos = i;
+        while (*p && *p != ',')
+            p++;
+        if (*p) p++;                   /* eat comma */
+    }
+    assert(!*p);
+    assert(state->tiles[state->gap_pos] == 0);
+
+    state->completed = state->movecount = 0;
+    state->used_solve = FALSE;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->n = state->n;
+    ret->tiles = snewn(state->w * state->h, int);
+    memcpy(ret->tiles, state->tiles, state->w * state->h * sizeof(int));
+    ret->gap_pos = state->gap_pos;
+    ret->completed = state->completed;
+    ret->movecount = state->movecount;
+    ret->used_solve = state->used_solve;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->tiles);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return dupstr("S");
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    char *ret, *p, buf[80];
+    int x, y, col, maxlen;
+
+    /*
+     * First work out how many characters we need to display each
+     * number.
+     */
+    col = sprintf(buf, "%d", state->n-1);
+
+    /*
+     * Now we know the exact total size of the grid we're going to
+     * produce: it's got h rows, each containing w lots of col, w-1
+     * spaces and a trailing newline.
+     */
+    maxlen = state->h * state->w * (col+1);
+
+    ret = snewn(maxlen+1, char);
+    p = ret;
+
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            int v = state->tiles[state->w*y+x];
+            if (v == 0)
+                sprintf(buf, "%*s", col, "");
+            else
+                sprintf(buf, "%*d", col, v);
+            memcpy(p, buf, col);
+            p += col;
+            if (x+1 == state->w)
+                *p++ = '\n';
+            else
+                *p++ = ' ';
+        }
+    }
+
+    assert(p - ret == maxlen);
+    *p = '\0';
+    return ret;
+}
+
+static game_ui *new_ui(const game_state *state)
+{
+    return NULL;
+}
+
+static void free_ui(game_ui *ui)
+{
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int started;
+    int w, h, bgcolour;
+    int *tiles;
+    int tilesize;
+};
+
+static int flip_cursor(int button)
+{
+    switch (button) {
+    case CURSOR_UP: return CURSOR_DOWN;
+    case CURSOR_DOWN: return CURSOR_UP;
+    case CURSOR_LEFT: return CURSOR_RIGHT;
+    case CURSOR_RIGHT: return CURSOR_LEFT;
+    }
+    return 0;
+}
+
+static void next_move_3x2(int ax, int ay, int bx, int by,
+                          int gx, int gy, int *dx, int *dy)
+{
+    /* When w = 3 and h = 2 and the tile going in the top left corner
+     * is at (ax, ay) and the tile going in the bottom left corner is
+     * at (bx, by) and the blank tile is at (gx, gy), how do you move? */
+
+    /* Hard-coded shortest solutions.  Sorry. */
+    static const unsigned char move[120] = {
+        1,2,0,1,2,2,
+        2,0,0,2,0,0,
+        0,0,2,0,2,0,
+        0,0,0,2,0,2,
+        2,0,0,0,2,0,
+
+        0,3,0,1,1,1,
+        3,0,3,2,1,2,
+        2,1,1,0,1,0,
+        2,1,2,1,0,1,
+        1,2,0,2,1,2,
+
+        0,1,3,1,3,0,
+        1,3,1,3,0,3,
+        0,0,3,3,0,0,
+        0,0,0,1,2,1,
+        3,0,0,1,1,1,
+
+        3,1,1,1,3,0,
+        1,1,1,1,1,1,
+        1,3,1,1,3,0,
+        1,1,3,3,1,3,
+        1,3,0,0,0,0
+    };
+    static const struct { int dx, dy; } d[4] = {{+1,0},{-1,0},{0,+1},{0,-1}};
+
+    int ea = 3*ay + ax, eb = 3*by + bx, eg = 3*gy + gx, v;
+    if (eb > ea) --eb;
+    if (eg > ea) --eg;
+    if (eg > eb) --eg;
+    v = move[ea + eb*6 + eg*5*6];
+    *dx = d[v].dx;
+    *dy = d[v].dy;
+}
+
+static void next_move(int nx, int ny, int ox, int oy, int gx, int gy,
+                      int tx, int ty, int w, int *dx, int *dy)
+{
+    const int to_tile_x = (gx < nx ? +1 : -1);
+    const int to_goal_x = (gx < tx ? +1 : -1);
+    const int gap_x_on_goal_side = ((nx-tx) * (nx-gx) > 0);
+
+    assert (nx != tx || ny != ty); /* not already in place */
+    assert (nx != gx || ny != gy); /* not placing the gap */
+    assert (ty <= ny); /* because we're greedy (and flipping) */
+    assert (ty <= gy); /* because we're greedy (and flipping) */
+
+    /* TODO: define a termination function.  Idea: 0 if solved, or
+     * the number of moves to solve the next piece plus the number of
+     * further unsolved pieces times an upper bound on the number of
+     * moves required to solve any piece.  If such a function can be
+     * found, we have (termination && (termination => correctness)).
+     * The catch is our temporary disturbance of 2x3 corners. */
+
+    /* handles end-of-row, when 3 and 4 are in the top right 2x3 box */
+    if (tx == w - 2 &&
+        ny <= ty + 2 && (nx == tx || nx == tx + 1) &&
+        oy <= ty + 2 && (ox == tx || ox == tx + 1) &&
+        gy <= ty + 2 && (gx == tx || gx == tx + 1))
+    {
+        next_move_3x2(oy - ty, tx + 1 - ox,
+                      ny - ty, tx + 1 - nx,
+                      gy - ty, tx + 1 - gx, dy, dx);
+        *dx *= -1;
+        return;
+    }
+
+    if (tx == w - 1) {
+        if (ny <= ty + 2 && (nx == tx || nx == tx - 1) &&
+            gy <= ty + 2 && (gx == tx || gx == tx - 1)) {
+            next_move_3x2(ny - ty, tx - nx, 0, 1, gy - ty, tx - gx, dy, dx);
+            *dx *= -1;
+        } else if (gy == ty)
+            *dy = +1;
+        else if (nx != tx || ny != ty + 1) {
+            next_move((w - 1) - nx, ny, -1, -1, (w - 1) - gx, gy,
+                      0, ty + 1, -1, dx, dy);
+            *dx *= -1;
+        } else if (gx == nx)
+            *dy = -1;
+        else
+            *dx = +1;
+        return;
+    }
+
+    /* note that *dy = -1 is unsafe when gy = ty + 1 and gx < tx */
+    if (gy < ny)
+        if (nx == gx || (gy == ty && gx == tx))
+            *dy = +1;
+        else if (!gap_x_on_goal_side)
+            *dx = to_tile_x;
+        else if (ny - ty > abs(nx - tx))
+            *dx = to_tile_x;
+        else *dy = +1;
+
+    else if (gy == ny)
+        if (nx == tx) /* then we know ny > ty */
+            if (gx > nx || ny > ty + 1)
+                *dy = -1; /* ... so this is safe */
+            else
+                *dy = +1;
+        else if (gap_x_on_goal_side)
+            *dx = to_tile_x;
+        else if (gy == ty || (gy == ty + 1 && gx < tx))
+            *dy = +1;
+        else
+            *dy = -1;
+
+    else if (nx == tx) /* gy > ny */
+        if (gx > nx)
+            *dy = -1;
+        else
+            *dx = +1;
+    else if (gx == nx)
+        *dx = to_goal_x;
+    else if (gap_x_on_goal_side)
+        if (gy == ty + 1 && gx < tx)
+            *dx = to_tile_x;
+        else
+            *dy = -1;
+
+    else if (ny - ty > abs(nx - tx))
+        *dy = -1;
+    else
+        *dx = to_tile_x;
+}
+
+static int compute_hint(const game_state *state, int *out_x, int *out_y)
+{
+    /* The overall solving process is this:
+     * 1. Find the next piece to be put in its place
+     * 2. Move it diagonally towards its place
+     * 3. Move it horizontally or vertically towards its place
+     * (Modulo the last two tiles at the end of each row/column)
+     */
+
+    int gx = X(state, state->gap_pos);
+    int gy = Y(state, state->gap_pos);
+
+    int tx, ty, nx, ny, ox, oy, /* {target,next,next2}_{x,y} */ i;
+    int dx = 0, dy = 0;
+
+    /* 1. Find the next piece
+     * if (there are no more unfinished columns than rows) {
+     *     fill the top-most row, left to right
+     * } else { fill the left-most column, top to bottom }
+     */
+    const int w = state->w, h = state->h, n = w*h;
+    int next_piece = 0, next_piece_2 = 0, solr = 0, solc = 0;
+    int unsolved_rows = h, unsolved_cols = w;
+
+    assert(out_x);
+    assert(out_y);
+
+    while (solr < h && solc < w) {
+        int start, step, stop;
+        if (unsolved_cols <= unsolved_rows)
+            start = solr*w + solc, step = 1, stop = unsolved_cols;
+        else
+            start = solr*w + solc, step = w, stop = unsolved_rows;
+        for (i = 0; i < stop; ++i) {
+            const int j = start + i*step;
+            if (state->tiles[j] != j + 1) {
+                next_piece = j + 1;
+                next_piece_2 = next_piece + step;
+                break;
+            }
+        }
+        if (i < stop) break;
+
+        (unsolved_cols <= unsolved_rows)
+            ? (++solr, --unsolved_rows)
+            : (++solc, --unsolved_cols);
+    }
+
+    if (next_piece == n)
+        return FALSE;
+
+    /* 2, 3. Move the next piece towards its place */
+
+    /* gx, gy already set */
+    tx = X(state, next_piece - 1); /* where we're going */
+    ty = Y(state, next_piece - 1);
+    for (i = 0; i < n && state->tiles[i] != next_piece; ++i);
+    nx = X(state, i); /* where we're at */
+    ny = Y(state, i);
+    for (i = 0; i < n && state->tiles[i] != next_piece_2; ++i);
+    ox = X(state, i);
+    oy = Y(state, i);
+
+    if (unsolved_cols <= unsolved_rows)
+        next_move(nx, ny, ox, oy, gx, gy, tx, ty, w, &dx, &dy);
+    else
+        next_move(ny, nx, oy, ox, gy, gx, ty, tx, h, &dy, &dx);
+
+    assert (dx || dy);
+
+    *out_x = gx + dx;
+    *out_y = gy + dy;
+    return TRUE;
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int cx = X(state, state->gap_pos), nx = cx;
+    int cy = Y(state, state->gap_pos), ny = cy;
+    char buf[80];
+
+    button &= ~MOD_MASK;
+
+    if (button == LEFT_BUTTON) {
+        nx = FROMCOORD(x);
+        ny = FROMCOORD(y);
+        if (nx < 0 || nx >= state->w || ny < 0 || ny >= state->h)
+            return NULL;               /* out of bounds */
+    } else if (IS_CURSOR_MOVE(button)) {
+        static int invert_cursor = -1;
+        if (invert_cursor == -1) {
+            char *env = getenv("FIFTEEN_INVERT_CURSOR");
+            invert_cursor = (env && (env[0] == 'y' || env[0] == 'Y'));
+        }
+        button = flip_cursor(button); /* the default */
+        if (invert_cursor)
+            button = flip_cursor(button); /* undoes the first flip */
+        move_cursor(button, &nx, &ny, state->w, state->h, FALSE);
+    } else if ((button == 'h' || button == 'H') && !state->completed) {
+        if (!compute_hint(state, &nx, &ny))
+            return NULL; /* shouldn't happen, since ^^we^^checked^^ */
+    } else
+        return NULL;                   /* no move */
+
+    /*
+     * Any click location should be equal to the gap location
+     * in _precisely_ one coordinate.
+     */
+    if ((cx == nx) ^ (cy == ny)) {
+        sprintf(buf, "M%d,%d", nx, ny);
+        return dupstr(buf);
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    int gx, gy, dx, dy, ux, uy, up, p;
+    game_state *ret;
+
+    if (!strcmp(move, "S")) {
+        int i;
+
+        ret = dup_game(from);
+
+        /*
+         * Simply replace the grid with a solved one. For this game,
+         * this isn't a useful operation for actually telling the user
+         * what they should have done, but it is useful for
+         * conveniently being able to get hold of a clean state from
+         * which to practise manoeuvres.
+         */
+        for (i = 0; i < ret->n; i++)
+            ret->tiles[i] = (i+1) % ret->n;
+        ret->gap_pos = ret->n-1;
+        ret->used_solve = TRUE;
+        ret->completed = ret->movecount = 1;
+
+        return ret;
+    }
+
+    gx = X(from, from->gap_pos);
+    gy = Y(from, from->gap_pos);
+
+    if (move[0] != 'M' ||
+        sscanf(move+1, "%d,%d", &dx, &dy) != 2 ||
+        (dx == gx && dy == gy) || (dx != gx && dy != gy) ||
+        dx < 0 || dx >= from->w || dy < 0 || dy >= from->h)
+        return NULL;
+
+    /*
+     * Find the unit displacement from the original gap
+     * position towards this one.
+     */
+    ux = (dx < gx ? -1 : dx > gx ? +1 : 0);
+    uy = (dy < gy ? -1 : dy > gy ? +1 : 0);
+    up = C(from, ux, uy);
+
+    ret = dup_game(from);
+
+    ret->gap_pos = C(from, dx, dy);
+    assert(ret->gap_pos >= 0 && ret->gap_pos < ret->n);
+
+    ret->tiles[ret->gap_pos] = 0;
+
+    for (p = from->gap_pos; p != ret->gap_pos; p += up) {
+        assert(p >= 0 && p < from->n);
+        ret->tiles[p] = from->tiles[p + up];
+        ret->movecount++;
+    }
+
+    /*
+     * See if the game has been completed.
+     */
+    if (!ret->completed) {
+        ret->completed = ret->movecount;
+        for (p = 0; p < ret->n; p++)
+            if (ret->tiles[p] != (p < ret->n-1 ? p+1 : 0))
+                ret->completed = 0;
+    }
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = TILE_SIZE * params->w + 2 * BORDER;
+    *y = TILE_SIZE * params->h + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    for (i = 0; i < 3; i++)
+        ret[COL_TEXT * 3 + i] = 0.0;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->started = FALSE;
+    ds->w = state->w;
+    ds->h = state->h;
+    ds->bgcolour = COL_BACKGROUND;
+    ds->tiles = snewn(ds->w*ds->h, int);
+    ds->tilesize = 0;                  /* haven't decided yet */
+    for (i = 0; i < ds->w*ds->h; i++)
+        ds->tiles[i] = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->tiles);
+    sfree(ds);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds, const game_state *state,
+                      int x, int y, int tile, int flash_colour)
+{
+    if (tile == 0) {
+        draw_rect(dr, x, y, TILE_SIZE, TILE_SIZE,
+                  flash_colour);
+    } else {
+        int coords[6];
+        char str[40];
+
+        coords[0] = x + TILE_SIZE - 1;
+        coords[1] = y + TILE_SIZE - 1;
+        coords[2] = x + TILE_SIZE - 1;
+        coords[3] = y;
+        coords[4] = x;
+        coords[5] = y + TILE_SIZE - 1;
+        draw_polygon(dr, coords, 3, COL_LOWLIGHT, COL_LOWLIGHT);
+
+        coords[0] = x;
+        coords[1] = y;
+        draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+
+        draw_rect(dr, x + HIGHLIGHT_WIDTH, y + HIGHLIGHT_WIDTH,
+                  TILE_SIZE - 2*HIGHLIGHT_WIDTH, TILE_SIZE - 2*HIGHLIGHT_WIDTH,
+                  flash_colour);
+
+        sprintf(str, "%d", tile);
+        draw_text(dr, x + TILE_SIZE/2, y + TILE_SIZE/2,
+                  FONT_VARIABLE, TILE_SIZE/3, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                  COL_TEXT, str);
+    }
+    draw_update(dr, x, y, TILE_SIZE, TILE_SIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int i, pass, bgcolour;
+
+    if (flashtime > 0) {
+        int frame = (int)(flashtime / FLASH_FRAME);
+        bgcolour = (frame % 2 ? COL_LOWLIGHT : COL_HIGHLIGHT);
+    } else
+        bgcolour = COL_BACKGROUND;
+
+    if (!ds->started) {
+        int coords[10];
+
+        draw_rect(dr, 0, 0,
+                  TILE_SIZE * state->w + 2 * BORDER,
+                  TILE_SIZE * state->h + 2 * BORDER, COL_BACKGROUND);
+        draw_update(dr, 0, 0,
+                    TILE_SIZE * state->w + 2 * BORDER,
+                    TILE_SIZE * state->h + 2 * BORDER);
+
+        /*
+         * Recessed area containing the whole puzzle.
+         */
+        coords[0] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
+        coords[1] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
+        coords[2] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
+        coords[3] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[4] = coords[2] - TILE_SIZE;
+        coords[5] = coords[3] + TILE_SIZE;
+        coords[8] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[9] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
+        coords[6] = coords[8] + TILE_SIZE;
+        coords[7] = coords[9] - TILE_SIZE;
+        draw_polygon(dr, coords, 5, COL_HIGHLIGHT, COL_HIGHLIGHT);
+
+        coords[1] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
+        draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
+
+        ds->started = TRUE;
+    }
+
+    /*
+     * Now draw each tile. We do this in two passes to make
+     * animation easy.
+     */
+    for (pass = 0; pass < 2; pass++) {
+        for (i = 0; i < state->n; i++) {
+            int t, t0;
+            /*
+             * Figure out what should be displayed at this
+             * location. It's either a simple tile, or it's a
+             * transition between two tiles (in which case we say
+             * -1 because it must always be drawn).
+             */
+
+            if (oldstate && oldstate->tiles[i] != state->tiles[i])
+                t = -1;
+            else
+                t = state->tiles[i];
+
+            t0 = t;
+
+            if (ds->bgcolour != bgcolour ||   /* always redraw when flashing */
+                ds->tiles[i] != t || ds->tiles[i] == -1 || t == -1) {
+                int x, y;
+
+                /*
+                 * Figure out what to _actually_ draw, and where to
+                 * draw it.
+                 */
+                if (t == -1) {
+                    int x0, y0, x1, y1;
+                    int j;
+
+                    /*
+                     * On the first pass, just blank the tile.
+                     */
+                    if (pass == 0) {
+                        x = COORD(X(state, i));
+                        y = COORD(Y(state, i));
+                        t = 0;
+                    } else {
+                        float c;
+
+                        t = state->tiles[i];
+
+                        /*
+                         * Don't bother moving the gap; just don't
+                         * draw it.
+                         */
+                        if (t == 0)
+                            continue;
+
+                        /*
+                         * Find the coordinates of this tile in the old and
+                         * new states.
+                         */
+                        x1 = COORD(X(state, i));
+                        y1 = COORD(Y(state, i));
+                        for (j = 0; j < oldstate->n; j++)
+                            if (oldstate->tiles[j] == state->tiles[i])
+                                break;
+                        assert(j < oldstate->n);
+                        x0 = COORD(X(state, j));
+                        y0 = COORD(Y(state, j));
+
+                        c = (animtime / ANIM_TIME);
+                        if (c < 0.0F) c = 0.0F;
+                        if (c > 1.0F) c = 1.0F;
+
+                        x = x0 + (int)(c * (x1 - x0));
+                        y = y0 + (int)(c * (y1 - y0));
+                    }
+
+                } else {
+                    if (pass == 0)
+                        continue;
+                    x = COORD(X(state, i));
+                    y = COORD(Y(state, i));
+                }
+
+                draw_tile(dr, ds, state, x, y, t, bgcolour);
+            }
+            ds->tiles[i] = t0;
+        }
+    }
+    ds->bgcolour = bgcolour;
+
+    /*
+     * Update the status bar.
+     */
+    {
+        char statusbuf[256];
+
+        /*
+         * Don't show the new status until we're also showing the
+         * new _state_ - after the game animation is complete.
+         */
+        if (oldstate)
+            state = oldstate;
+
+        if (state->used_solve)
+            sprintf(statusbuf, "Moves since auto-solve: %d",
+                    state->movecount - state->completed);
+        else
+            sprintf(statusbuf, "%sMoves: %d",
+                    (state->completed ? "COMPLETED! " : ""),
+                    (state->completed ? state->completed : state->movecount));
+
+        status_bar(dr, statusbuf);
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return ANIM_TIME;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->used_solve && !newstate->used_solve)
+        return 2 * FLASH_FRAME;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame fifteen
+#endif
+
+const struct game thegame = {
+    "Fifteen", "games.fifteen", "fifteen",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+int main(int argc, char **argv)
+{
+    game_params *params;
+    game_state *state;
+    char *id = NULL, *desc, *err;
+    int grade = FALSE;
+    char *progname = argv[0];
+
+    char buf[80];
+    int limit, x, y, solvable;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            /* solver_show_working = TRUE; */
+        } else if (!strcmp(p, "-g")) {
+            grade = TRUE;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", progname, p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-g | -v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    params = default_params();
+    decode_params(params, id);
+    err = validate_desc(params, desc);
+    if (err) {
+        free_params(params);
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+
+    state = new_game(NULL, params, desc);
+    free_params(params);
+
+    solvable = (PARITY_S(state) == perm_parity(state->tiles, state->n));
+    if (grade || !solvable) {
+        free_game(state);
+        fputs(solvable ? "Game is solvable" : "Game is unsolvable",
+              grade ? stdout : stderr);
+        return !grade;
+    }
+
+    for (limit = 5 * state->n * state->n * state->n; limit; --limit) {
+        game_state *next_state;
+        if (!compute_hint(state, &x, &y)) {
+            fprintf(stderr, "couldn't compute next move while solving %s:%s",
+                    id, desc);
+            return 1;
+        }
+        printf("Move the space to (%d, %d), moving %d into the space\n",
+               x + 1, y + 1, state->tiles[C(state, x, y)]);
+        sprintf(buf, "M%d,%d", x, y);
+        next_state = execute_move(state, buf);
+
+        free_game(state);
+        if (!next_state) {
+            fprintf(stderr, "invalid move when solving %s:%s\n", id, desc);
+            return 1;
+        }
+        state = next_state;
+        if (next_state->completed) {
+            free_game(state);
+            return 0;
+        }
+    }
+
+    free_game(state);
+    fprintf(stderr, "ran out of moves for %s:%s\n", id, desc);
+    return 1;
+}
+
+#endif
diff --git a/apps/plugins/puzzles/filling.R b/apps/plugins/puzzles/filling.R
new file mode 100644
index 0000000000..cffbafaa0a
--- /dev/null
+++ b/apps/plugins/puzzles/filling.R
@@ -0,0 +1,24 @@
+# -*- makefile -*-
+
+FILLING_EXTRA = dsf
+
+fillingsolver : [U] filling[STANDALONE_SOLVER] FILLING_EXTRA STANDALONE
+fillingsolver : [C] filling[STANDALONE_SOLVER] FILLING_EXTRA STANDALONE
+
+filling : [X] GTK COMMON filling FILLING_EXTRA filling-icon|no-icon
+
+filling : [G] WINDOWS COMMON filling FILLING_EXTRA filling.res|noicon.res
+
+ALL += filling[COMBINED] FILLING_EXTRA
+
+!begin am gtk
+GAMES += filling
+!end
+
+!begin >list.c
+    A(filling) \
+!end
+
+!begin >gamedesc.txt
+filling:filling.exe:Filling:Polyomino puzzle:Mark every square with the area of its containing region.
+!end
diff --git a/apps/plugins/puzzles/filling.c b/apps/plugins/puzzles/filling.c
new file mode 100644
index 0000000000..c2dfafc7ca
--- /dev/null
+++ b/apps/plugins/puzzles/filling.c
@@ -0,0 +1,2179 @@
+/* -*- tab-width: 8; indent-tabs-mode: t -*-
+ * filling.c: An implementation of the Nikoli game fillomino.
+ * Copyright (C) 2007 Jonas Kölker.  See LICENSE for the license.
+ */
+
+/* TODO:
+ *
+ *  - use a typedef instead of int for numbers on the board
+ *     + replace int with something else (signed short?)
+ *        - the type should be signed (for -board[i] and -SENTINEL)
+ *        - the type should be somewhat big: board[i] = i
+ *        - Using shorts gives us 181x181 puzzles as upper bound.
+ *
+ *  - in board generation, after having merged regions such that no
+ *    more merges are necessary, try splitting (big) regions.
+ *     + it seems that smaller regions make for better puzzles; see
+ *       for instance the 7x7 puzzle in this file (grep for 7x7:).
+ *
+ *  - symmetric hints (solo-style)
+ *     + right now that means including _many_ hints, and the puzzles
+ *       won't look any nicer.  Not worth it (at the moment).
+ *
+ *  - make the solver do recursion/backtracking.
+ *     + This is for user-submitted puzzles, not for puzzle
+ *       generation (on the other hand, never say never).
+ *
+ *  - prove that only w=h=2 needs a special case
+ *
+ *  - solo-like pencil marks?
+ *
+ *  - a user says that the difficulty is unevenly distributed.
+ *     + partition into levels?  Will they be non-crap?
+ *
+ *  - Allow square contents > 9?
+ *     + I could use letters for digits (solo does this), but
+ *       letters don't have numeric significance (normal people hate
+ *       base36), which is relevant here (much more than in solo).
+ *     + [click, 1, 0, enter] => [10 in clicked square]?
+ *     + How much information is needed to solve?  Does one need to
+ *       know the algorithm by which the largest number is set?
+ *
+ *  - eliminate puzzle instances with done chunks (1's in particular)?
+ *     + that's what the qsort call is all about.
+ *     + the 1's don't bother me that much.
+ *     + but this takes a LONG time (not always possible)?
+ *        - this may be affected by solver (lack of) quality.
+ *        - weed them out by construction instead of post-cons check
+ *           + but that interleaves make_board and new_game_desc: you
+ *             have to alternate between changing the board and
+ *             changing the hint set (instead of just creating the
+ *             board once, then changing the hint set once -> done).
+ *
+ *  - use binary search when discovering the minimal sovable point
+ *     + profile to show a need (but when the solver gets slower...)
+ *     + 7x9 @ .011s, 9x13 @ .075s, 17x13 @ .661s (all avg with n=100)
+ *     + but the hints are independent, not linear, so... what?
+ */
+
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "puzzles.h"
+
+static unsigned char verbose;
+
+static void printv(char *fmt, ...) {
+#ifndef PALM
+    if (verbose) {
+        va_list va;
+        va_start(va, fmt);
+        vprintf(fmt, va);
+        va_end(va);
+    }
+#endif
+}
+
+/*****************************************************************************
+ * GAME CONFIGURATION AND PARAMETERS                                         *
+ *****************************************************************************/
+
+struct game_params {
+    int w, h;
+};
+
+struct shared_state {
+    struct game_params params;
+    int *clues;
+    int refcnt;
+};
+
+struct game_state {
+    int *board;
+    struct shared_state *shared;
+    int completed, cheated;
+};
+
+static const struct game_params filling_defaults[3] = {
+    {9, 7}, {13, 9}, {17, 13}
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    *ret = filling_defaults[1]; /* struct copy */
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    char buf[64];
+
+    if (i < 0 || i >= lenof(filling_defaults)) return FALSE;
+    *params = snew(game_params);
+    **params = filling_defaults[i]; /* struct copy */
+    sprintf(buf, "%dx%d", filling_defaults[i].w, filling_defaults[i].h);
+    *name = dupstr(buf);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params; /* struct copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    while (*string && isdigit((unsigned char) *string)) ++string;
+    if (*string == 'x') ret->h = atoi(++string);
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[64];
+    sprintf(buf, "%dx%d", params->w, params->h);
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[64];
+
+    ret = snewn(3, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = NULL;
+    ret[2].type = C_END;
+    ret[2].sval = NULL;
+    ret[2].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 1) return "Width must be at least one";
+    if (params->h < 1) return "Height must be at least one";
+
+    return NULL;
+}
+
+/*****************************************************************************
+ * STRINGIFICATION OF GAME STATE                                             *
+ *****************************************************************************/
+
+#define EMPTY 0
+
+/* Example of plaintext rendering:
+ *  +---+---+---+---+---+---+---+
+ *  | 6 |   |   | 2 |   |   | 2 |
+ *  +---+---+---+---+---+---+---+
+ *  |   | 3 |   | 6 |   | 3 |   |
+ *  +---+---+---+---+---+---+---+
+ *  | 3 |   |   |   |   |   | 1 |
+ *  +---+---+---+---+---+---+---+
+ *  |   | 2 | 3 |   | 4 | 2 |   |
+ *  +---+---+---+---+---+---+---+
+ *  | 2 |   |   |   |   |   | 3 |
+ *  +---+---+---+---+---+---+---+
+ *  |   | 5 |   | 1 |   | 4 |   |
+ *  +---+---+---+---+---+---+---+
+ *  | 4 |   |   | 3 |   |   | 3 |
+ *  +---+---+---+---+---+---+---+
+ *
+ * This puzzle instance is taken from the nikoli website
+ * Encoded (unsolved and solved), the strings are these:
+ * 7x7:6002002030603030000010230420200000305010404003003
+ * 7x7:6662232336663232331311235422255544325413434443313
+ */
+static char *board_to_string(int *board, int w, int h) {
+    const int sz = w * h;
+    const int chw = (4*w + 2); /* +2 for trailing '+' and '\n' */
+    const int chh = (2*h + 1); /* +1: n fence segments, n+1 posts */
+    const int chlen = chw * chh;
+    char *repr = snewn(chlen + 1, char);
+    int i;
+
+    assert(board);
+
+    /* build the first line ("^(\+---){n}\+$") */
+    for (i = 0; i < w; ++i) {
+        repr[4*i + 0] = '+';
+        repr[4*i + 1] = '-';
+        repr[4*i + 2] = '-';
+        repr[4*i + 3] = '-';
+    }
+    repr[4*i + 0] = '+';
+    repr[4*i + 1] = '\n';
+
+    /* ... and copy it onto the odd-numbered lines */
+    for (i = 0; i < h; ++i) memcpy(repr + (2*i + 2) * chw, repr, chw);
+
+    /* build the second line ("^(\|\t){n}\|$") */
+    for (i = 0; i < w; ++i) {
+        repr[chw + 4*i + 0] = '|';
+        repr[chw + 4*i + 1] = ' ';
+        repr[chw + 4*i + 2] = ' ';
+        repr[chw + 4*i + 3] = ' ';
+    }
+    repr[chw + 4*i + 0] = '|';
+    repr[chw + 4*i + 1] = '\n';
+
+    /* ... and copy it onto the even-numbered lines */
+    for (i = 1; i < h; ++i) memcpy(repr + (2*i + 1) * chw, repr + chw, chw);
+
+    /* fill in the numbers */
+    for (i = 0; i < sz; ++i) {
+        const int x = i % w;
+        const int y = i / w;
+        if (board[i] == EMPTY) continue;
+        repr[chw*(2*y + 1) + (4*x + 2)] = board[i] + '0';
+    }
+
+    repr[chlen] = '\0';
+    return repr;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    const int w = state->shared->params.w;
+    const int h = state->shared->params.h;
+    return board_to_string(state->board, w, h);
+}
+
+/*****************************************************************************
+ * GAME GENERATION AND SOLVER                                                *
+ *****************************************************************************/
+
+static const int dx[4] = {-1, 1, 0, 0};
+static const int dy[4] = {0, 0, -1, 1};
+
+struct solver_state
+{
+    int *dsf;
+    int *board;
+    int *connected;
+    int nempty;
+
+    /* Used internally by learn_bitmap_deductions; kept here to avoid
+     * mallocing/freeing them every time that function is called. */
+    int *bm, *bmdsf, *bmminsize;
+};
+
+static void print_board(int *board, int w, int h) {
+    if (verbose) {
+        char *repr = board_to_string(board, w, h);
+        printv("%s\n", repr);
+        free(repr);
+    }
+}
+
+static game_state *new_game(midend *, const game_params *, const char *);
+static void free_game(game_state *);
+
+#define SENTINEL sz
+
+static int mark_region(int *board, int w, int h, int i, int n, int m) {
+    int j;
+
+    board[i] = -1;
+
+    for (j = 0; j < 4; ++j) {
+        const int x = (i % w) + dx[j], y = (i / w) + dy[j], ii = w*y + x;
+        if (x < 0 || x >= w || y < 0 || y >= h) continue;
+        if (board[ii] == m) return FALSE;
+        if (board[ii] != n) continue;
+        if (!mark_region(board, w, h, ii, n, m)) return FALSE;
+    }
+    return TRUE;
+}
+
+static int region_size(int *board, int w, int h, int i) {
+    const int sz = w * h;
+    int j, size, copy;
+    if (board[i] == 0) return 0;
+    copy = board[i];
+    mark_region(board, w, h, i, board[i], SENTINEL);
+    for (size = j = 0; j < sz; ++j) {
+        if (board[j] != -1) continue;
+        ++size;
+        board[j] = copy;
+    }
+    return size;
+}
+
+static void merge_ones(int *board, int w, int h)
+{
+    const int sz = w * h;
+    const int maxsize = min(max(max(w, h), 3), 9);
+    int i, j, k, change;
+    do {
+        change = FALSE;
+        for (i = 0; i < sz; ++i) {
+            if (board[i] != 1) continue;
+
+            for (j = 0; j < 4; ++j, board[i] = 1) {
+                const int x = (i % w) + dx[j], y = (i / w) + dy[j];
+                int oldsize, newsize, ok, ii = w*y + x;
+                if (x < 0 || x >= w || y < 0 || y >= h) continue;
+                if (board[ii] == maxsize) continue;
+
+                oldsize = board[ii];
+                board[i] = oldsize;
+                newsize = region_size(board, w, h, i);
+
+                if (newsize > maxsize) continue;
+
+                ok = mark_region(board, w, h, i, oldsize, newsize);
+
+                for (k = 0; k < sz; ++k)
+                    if (board[k] == -1)
+                        board[k] = ok ? newsize : oldsize;
+
+                if (ok) break;
+            }
+            if (j < 4) change = TRUE;
+        }
+    } while (change);
+}
+
+/* generate a random valid board; uses validate_board. */
+static void make_board(int *board, int w, int h, random_state *rs) {
+    const int sz = w * h;
+
+    /* w=h=2 is a special case which requires a number > max(w, h) */
+    /* TODO prove that this is the case ONLY for w=h=2. */
+    const int maxsize = min(max(max(w, h), 3), 9);
+
+    /* Note that if 1 in {w, h} then it's impossible to have a region
+     * of size > w*h, so the special case only affects w=h=2. */
+
+    int i, change, *dsf;
+
+    assert(w >= 1);
+    assert(h >= 1);
+    assert(board);
+
+    /* I abuse the board variable: when generating the puzzle, it
+     * contains a shuffled list of numbers {0, ..., sz-1}. */
+    for (i = 0; i < sz; ++i) board[i] = i;
+
+    dsf = snewn(sz, int);
+retry:
+    dsf_init(dsf, sz);
+    shuffle(board, sz, sizeof (int), rs);
+
+    do {
+        change = FALSE; /* as long as the board potentially has errors */
+        for (i = 0; i < sz; ++i) {
+            const int square = dsf_canonify(dsf, board[i]);
+            const int size = dsf_size(dsf, square);
+            int merge = SENTINEL, min = maxsize - size + 1, error = FALSE;
+            int neighbour, neighbour_size, j;
+
+            for (j = 0; j < 4; ++j) {
+                const int x = (board[i] % w) + dx[j];
+                const int y = (board[i] / w) + dy[j];
+                if (x < 0 || x >= w || y < 0 || y >= h) continue;
+
+                neighbour = dsf_canonify(dsf, w*y + x);
+                if (square == neighbour) continue;
+
+                neighbour_size = dsf_size(dsf, neighbour);
+                if (size == neighbour_size) error = TRUE;
+
+                /* find the smallest neighbour to merge with, which
+                 * wouldn't make the region too large.  (This is
+                 * guaranteed by the initial value of `min'.) */
+                if (neighbour_size < min) {
+                    min = neighbour_size;
+                    merge = neighbour;
+                }
+            }
+
+            /* if this square is not in error, leave it be */
+            if (!error) continue;
+
+            /* if it is, but we can't fix it, retry the whole board.
+             * Maybe we could fix it by merging the conflicting
+             * neighbouring region(s) into some of their neighbours,
+             * but just restarting works out fine. */
+            if (merge == SENTINEL) goto retry;
+
+            /* merge with the smallest neighbouring workable region. */
+            dsf_merge(dsf, square, merge);
+            change = TRUE;
+        }
+    } while (change);
+
+    for (i = 0; i < sz; ++i) board[i] = dsf_size(dsf, i);
+    merge_ones(board, w, h);
+
+    sfree(dsf);
+}
+
+static void merge(int *dsf, int *connected, int a, int b) {
+    int c;
+    assert(dsf);
+    assert(connected);
+    a = dsf_canonify(dsf, a);
+    b = dsf_canonify(dsf, b);
+    if (a == b) return;
+    dsf_merge(dsf, a, b);
+    c = connected[a];
+    connected[a] = connected[b];
+    connected[b] = c;
+}
+
+static void *memdup(const void *ptr, size_t len, size_t esz) {
+    void *dup = smalloc(len * esz);
+    assert(ptr);
+    memcpy(dup, ptr, len * esz);
+    return dup;
+}
+
+static void expand(struct solver_state *s, int w, int h, int t, int f) {
+    int j;
+    assert(s);
+    assert(s->board[t] == EMPTY); /* expand to empty square */
+    assert(s->board[f] != EMPTY); /* expand from non-empty square */
+    printv(
+        "learn: expanding %d from (%d, %d) into (%d, %d)\n",
+        s->board[f], f % w, f / w, t % w, t / w);
+    s->board[t] = s->board[f];
+    for (j = 0; j < 4; ++j) {
+        const int x = (t % w) + dx[j];
+        const int y = (t / w) + dy[j];
+        const int idx = w*y + x;
+        if (x < 0 || x >= w || y < 0 || y >= h) continue;
+        if (s->board[idx] != s->board[t]) continue;
+        merge(s->dsf, s->connected, t, idx);
+    }
+    --s->nempty;
+}
+
+static void clear_count(int *board, int sz) {
+    int i;
+    for (i = 0; i < sz; ++i) {
+        if (board[i] >= 0) continue;
+        else if (board[i] == -SENTINEL) board[i] = EMPTY;
+        else board[i] = -board[i];
+    }
+}
+
+static void flood_count(int *board, int w, int h, int i, int n, int *c) {
+    const int sz = w * h;
+    int k;
+
+    if (board[i] == EMPTY) board[i] = -SENTINEL;
+    else if (board[i] == n) board[i] = -board[i];
+    else return;
+
+    if (--*c == 0) return;
+
+    for (k = 0; k < 4; ++k) {
+        const int x = (i % w) + dx[k];
+        const int y = (i / w) + dy[k];
+        const int idx = w*y + x;
+        if (x < 0 || x >= w || y < 0 || y >= h) continue;
+        flood_count(board, w, h, idx, n, c);
+        if (*c == 0) return;
+    }
+}
+
+static int check_capacity(int *board, int w, int h, int i) {
+    int n = board[i];
+    flood_count(board, w, h, i, board[i], &n);
+    clear_count(board, w * h);
+    return n == 0;
+}
+
+static int expandsize(const int *board, int *dsf, int w, int h, int i, int n) {
+    int j;
+    int nhits = 0;
+    int hits[4];
+    int size = 1;
+    for (j = 0; j < 4; ++j) {
+        const int x = (i % w) + dx[j];
+        const int y = (i / w) + dy[j];
+        const int idx = w*y + x;
+        int root;
+        int m;
+        if (x < 0 || x >= w || y < 0 || y >= h) continue;
+        if (board[idx] != n) continue;
+        root = dsf_canonify(dsf, idx);
+        for (m = 0; m < nhits && root != hits[m]; ++m);
+        if (m < nhits) continue;
+        printv("\t  (%d, %d) contrib %d to size\n", x, y, dsf[root] >> 2);
+        size += dsf_size(dsf, root);
+        assert(dsf_size(dsf, root) >= 1);
+        hits[nhits++] = root;
+    }
+    return size;
+}
+
+/*
+ *  +---+---+---+---+---+---+---+
+ *  | 6 |   |   | 2 |   |   | 2 |
+ *  +---+---+---+---+---+---+---+
+ *  |   | 3 |   | 6 |   | 3 |   |
+ *  +---+---+---+---+---+---+---+
+ *  | 3 |   |   |   |   |   | 1 |
+ *  +---+---+---+---+---+---+---+
+ *  |   | 2 | 3 |   | 4 | 2 |   |
+ *  +---+---+---+---+---+---+---+
+ *  | 2 |   |   |   |   |   | 3 |
+ *  +---+---+---+---+---+---+---+
+ *  |   | 5 |   | 1 |   | 4 |   |
+ *  +---+---+---+---+---+---+---+
+ *  | 4 |   |   | 3 |   |   | 3 |
+ *  +---+---+---+---+---+---+---+
+ */
+
+/* Solving techniques:
+ *
+ * CONNECTED COMPONENT FORCED EXPANSION (too big):
+ * When a CC can only be expanded in one direction, because all the
+ * other ones would make the CC too big.
+ *  +---+---+---+---+---+
+ *  | 2 | 2 |   | 2 | _ |
+ *  +---+---+---+---+---+
+ *
+ * CONNECTED COMPONENT FORCED EXPANSION (too small):
+ * When a CC must include a particular square, because otherwise there
+ * would not be enough room to complete it.  This includes squares not
+ * adjacent to the CC through learn_critical_square.
+ *  +---+---+
+ *  | 2 | _ |
+ *  +---+---+
+ *
+ * DROPPING IN A ONE:
+ * When an empty square has no neighbouring empty squares and only a 1
+ * will go into the square (or other CCs would be too big).
+ *  +---+---+---+
+ *  | 2 | 2 | _ |
+ *  +---+---+---+
+ *
+ * TODO: generalise DROPPING IN A ONE: find the size of the CC of
+ * empty squares and a list of all adjacent numbers.  See if only one
+ * number in {1, ..., size} u {all adjacent numbers} is possible.
+ * Probably this is only effective for a CC size < n for some n (4?)
+ *
+ * TODO: backtracking.
+ */
+
+static void filled_square(struct solver_state *s, int w, int h, int i) {
+    int j;
+    for (j = 0; j < 4; ++j) {
+        const int x = (i % w) + dx[j];
+        const int y = (i / w) + dy[j];
+        const int idx = w*y + x;
+        if (x < 0 || x >= w || y < 0 || y >= h) continue;
+        if (s->board[i] == s->board[idx])
+            merge(s->dsf, s->connected, i, idx);
+    }
+}
+
+static void init_solver_state(struct solver_state *s, int w, int h) {
+    const int sz = w * h;
+    int i;
+    assert(s);
+
+    s->nempty = 0;
+    for (i = 0; i < sz; ++i) s->connected[i] = i;
+    for (i = 0; i < sz; ++i)
+        if (s->board[i] == EMPTY) ++s->nempty;
+        else filled_square(s, w, h, i);
+}
+
+static int learn_expand_or_one(struct solver_state *s, int w, int h) {
+    const int sz = w * h;
+    int i;
+    int learn = FALSE;
+
+    assert(s);
+
+    for (i = 0; i < sz; ++i) {
+        int j;
+        int one = TRUE;
+
+        if (s->board[i] != EMPTY) continue;
+
+        for (j = 0; j < 4; ++j) {
+            const int x = (i % w) + dx[j];
+            const int y = (i / w) + dy[j];
+            const int idx = w*y + x;
+            if (x < 0 || x >= w || y < 0 || y >= h) continue;
+            if (s->board[idx] == EMPTY) {
+                one = FALSE;
+                continue;
+            }
+            if (one &&
+                (s->board[idx] == 1 ||
+                 (s->board[idx] >= expandsize(s->board, s->dsf, w, h,
+                                              i, s->board[idx]))))
+                one = FALSE;
+            if (dsf_size(s->dsf, idx) == s->board[idx]) continue;
+            assert(s->board[i] == EMPTY);
+            s->board[i] = -SENTINEL;
+            if (check_capacity(s->board, w, h, idx)) continue;
+            assert(s->board[i] == EMPTY);
+            printv("learn: expanding in one\n");
+            expand(s, w, h, i, idx);
+            learn = TRUE;
+            break;
+        }
+
+        if (j == 4 && one) {
+            printv("learn: one at (%d, %d)\n", i % w, i / w);
+            assert(s->board[i] == EMPTY);
+            s->board[i] = 1;
+            assert(s->nempty);
+            --s->nempty;
+            learn = TRUE;
+        }
+    }
+    return learn;
+}
+
+static int learn_blocked_expansion(struct solver_state *s, int w, int h) {
+    const int sz = w * h;
+    int i;
+    int learn = FALSE;
+
+    assert(s);
+    /* for every connected component */
+    for (i = 0; i < sz; ++i) {
+        int exp = SENTINEL;
+        int j;
+
+        if (s->board[i] == EMPTY) continue;
+        j = dsf_canonify(s->dsf, i);
+
+        /* (but only for each connected component) */
+        if (i != j) continue;
+
+        /* (and not if it's already complete) */
+        if (dsf_size(s->dsf, j) == s->board[j]) continue;
+
+        /* for each square j _in_ the connected component */
+        do {
+            int k;
+            printv("  looking at (%d, %d)\n", j % w, j / w);
+
+            /* for each neighbouring square (idx) */
+            for (k = 0; k < 4; ++k) {
+                const int x = (j % w) + dx[k];
+                const int y = (j / w) + dy[k];
+                const int idx = w*y + x;
+                int size;
+                /* int l;
+                   int nhits = 0;
+                   int hits[4]; */
+                if (x < 0 || x >= w || y < 0 || y >= h) continue;
+                if (s->board[idx] != EMPTY) continue;
+                if (exp == idx) continue;
+                printv("\ttrying to expand onto (%d, %d)\n", x, y);
+
+                /* find out the would-be size of the new connected
+                 * component if we actually expanded into idx */
+                /*
+                size = 1;
+                for (l = 0; l < 4; ++l) {
+                    const int lx = x + dx[l];
+                    const int ly = y + dy[l];
+                    const int idxl = w*ly + lx;
+                    int root;
+                    int m;
+                    if (lx < 0 || lx >= w || ly < 0 || ly >= h) continue;
+                    if (board[idxl] != board[j]) continue;
+                    root = dsf_canonify(dsf, idxl);
+                    for (m = 0; m < nhits && root != hits[m]; ++m);
+                    if (m != nhits) continue;
+                    // printv("\t  (%d, %d) contributed %d to size\n", lx, ly, dsf[root] >> 2);
+                    size += dsf_size(dsf, root);
+                    assert(dsf_size(dsf, root) >= 1);
+                    hits[nhits++] = root;
+                }
+                */
+
+                size = expandsize(s->board, s->dsf, w, h, idx, s->board[j]);
+
+                /* ... and see if that size is too big, or if we
+                 * have other expansion candidates.  Otherwise
+                 * remember the (so far) only candidate. */
+
+                printv("\tthat would give a size of %d\n", size);
+                if (size > s->board[j]) continue;
+                /* printv("\tnow knowing %d expansions\n", nexpand + 1); */
+                if (exp != SENTINEL) goto next_i;
+                assert(exp != idx);
+                exp = idx;
+            }
+
+            j = s->connected[j]; /* next square in the same CC */
+            assert(s->board[i] == s->board[j]);
+        } while (j != i);
+        /* end: for each square j _in_ the connected component */
+
+        if (exp == SENTINEL) continue;
+        printv("learning to expand\n");
+        expand(s, w, h, exp, i);
+        learn = TRUE;
+
+        next_i:
+        ;
+    }
+    /* end: for each connected component */
+    return learn;
+}
+
+static int learn_critical_square(struct solver_state *s, int w, int h) {
+    const int sz = w * h;
+    int i;
+    int learn = FALSE;
+    assert(s);
+
+    /* for each connected component */
+    for (i = 0; i < sz; ++i) {
+        int j, slack;
+        if (s->board[i] == EMPTY) continue;
+        if (i != dsf_canonify(s->dsf, i)) continue;
+        slack = s->board[i] - dsf_size(s->dsf, i);
+        if (slack == 0) continue;
+        assert(s->board[i] != 1);
+        /* for each empty square */
+        for (j = 0; j < sz; ++j) {
+            if (s->board[j] == EMPTY) {
+                /* if it's too far away from the CC, don't bother */
+                int k = i, jx = j % w, jy = j / w;
+                do {
+                    int kx = k % w, ky = k / w;
+                    if (abs(kx - jx) + abs(ky - jy) <= slack) break;
+                    k = s->connected[k];
+                } while (i != k);
+                if (i == k) continue; /* not within range */
+            } else continue;
+            s->board[j] = -SENTINEL;
+            if (check_capacity(s->board, w, h, i)) continue;
+            /* if not expanding s->board[i] to s->board[j] implies
+             * that s->board[i] can't reach its full size, ... */
+            assert(s->nempty);
+            printv(
+                "learn: ds %d at (%d, %d) blocking (%d, %d)\n",
+                s->board[i], j % w, j / w, i % w, i / w);
+            --s->nempty;
+            s->board[j] = s->board[i];
+            filled_square(s, w, h, j);
+            learn = TRUE;
+        }
+    }
+    return learn;
+}
+
+#if 0
+static void print_bitmap(int *bitmap, int w, int h) {
+    if (verbose) {
+        int x, y;
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                printv(" %03x", bm[y*w+x]);
+            }
+            printv("\n");
+        }
+    }
+}
+#endif
+
+static int learn_bitmap_deductions(struct solver_state *s, int w, int h)
+{
+    const int sz = w * h;
+    int *bm = s->bm;
+    int *dsf = s->bmdsf;
+    int *minsize = s->bmminsize;
+    int x, y, i, j, n;
+    int learn = FALSE;
+
+    /*
+     * This function does deductions based on building up a bitmap
+     * which indicates the possible numbers that can appear in each
+     * grid square. If we can rule out all but one possibility for a
+     * particular square, then we've found out the value of that
+     * square. In particular, this is one of the few forms of
+     * deduction capable of inferring the existence of a 'ghost
+     * region', i.e. a region which has none of its squares filled in
+     * at all.
+     *
+     * The reasoning goes like this. A currently unfilled square S can
+     * turn out to contain digit n in exactly two ways: either S is
+     * part of an n-region which also includes some currently known
+     * connected component of squares with n in, or S is part of an
+     * n-region separate from _all_ currently known connected
+     * components. If we can rule out both possibilities, then square
+     * S can't contain digit n at all.
+     *
+     * The former possibility: if there's a region of size n
+     * containing both S and some existing component C, then that
+     * means the distance from S to C must be small enough that C
+     * could be extended to include S without becoming too big. So we
+     * can do a breadth-first search out from all existing components
+     * with n in them, to identify all the squares which could be
+     * joined to any of them.
+     *
+     * The latter possibility: if there's a region of size n that
+     * doesn't contain _any_ existing component, then it also can't
+     * contain any square adjacent to an existing component either. So
+     * we can identify all the EMPTY squares not adjacent to any
+     * existing square with n in, and group them into connected
+     * components; then any component of size less than n is ruled
+     * out, because there wouldn't be room to create a completely new
+     * n-region in it.
+     *
+     * In fact we process these possibilities in the other order.
+     * First we find all the squares not adjacent to an existing
+     * square with n in; then we winnow those by removing too-small
+     * connected components, to get the set of squares which could
+     * possibly be part of a brand new n-region; and finally we do the
+     * breadth-first search to add in the set of squares which could
+     * possibly be added to some existing n-region.
+     */
+
+    /*
+     * Start by initialising our bitmap to 'all numbers possible in
+     * all squares'.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            bm[y*w+x] = (1 << 10) - (1 << 1); /* bits 1,2,...,9 now set */
+#if 0
+    printv("initial bitmap:\n");
+    print_bitmap(bm, w, h);
+#endif
+
+    /*
+     * Now completely zero out the bitmap for squares that are already
+     * filled in (we aren't interested in those anyway). Also, for any
+     * filled square, eliminate its number from all its neighbours
+     * (because, as discussed above, the neighbours couldn't be part
+     * of a _new_ region with that number in it, and that's the case
+     * we consider first).
+     */
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            i = y*w+x;
+            n = s->board[i];
+
+            if (n != EMPTY) {
+                bm[i] = 0;
+
+                if (x > 0)
+                    bm[i-1] &= ~(1 << n);
+                if (x+1 < w)
+                    bm[i+1] &= ~(1 << n);
+                if (y > 0)
+                    bm[i-w] &= ~(1 << n);
+                if (y+1 < h)
+                    bm[i+w] &= ~(1 << n);
+            }
+        }
+    }
+#if 0
+    printv("bitmap after filled squares:\n");
+    print_bitmap(bm, w, h);
+#endif
+
+    /*
+     * Now, for each n, we separately find the connected components of
+     * squares for which n is still a possibility. Then discard any
+     * component of size < n, because that component is too small to
+     * have a completely new n-region in it.
+     */
+    for (n = 1; n <= 9; n++) {
+        dsf_init(dsf, sz);
+
+        /* Build the dsf */
+        for (y = 0; y < h; y++)
+            for (x = 0; x+1 < w; x++)
+                if (bm[y*w+x] & bm[y*w+(x+1)] & (1 << n))
+                    dsf_merge(dsf, y*w+x, y*w+(x+1));
+        for (y = 0; y+1 < h; y++)
+            for (x = 0; x < w; x++)
+                if (bm[y*w+x] & bm[(y+1)*w+x] & (1 << n))
+                    dsf_merge(dsf, y*w+x, (y+1)*w+x);
+
+        /* Query the dsf */
+        for (i = 0; i < sz; i++)
+            if ((bm[i] & (1 << n)) && dsf_size(dsf, i) < n)
+                bm[i] &= ~(1 << n);
+    }
+#if 0
+    printv("bitmap after winnowing small components:\n");
+    print_bitmap(bm, w, h);
+#endif
+
+    /*
+     * Now our bitmap includes every square which could be part of a
+     * completely new region, of any size. Extend it to include
+     * squares which could be part of an existing region.
+     */
+    for (n = 1; n <= 9; n++) {
+        /*
+         * We're going to do a breadth-first search starting from
+         * existing connected components with cell value n, to find
+         * all cells they might possibly extend into.
+         *
+         * The quantity we compute, for each square, is 'minimum size
+         * that any existing CC would have to have if extended to
+         * include this square'. So squares already _in_ an existing
+         * CC are initialised to the size of that CC; then we search
+         * outwards using the rule that if a square's score is j, then
+         * its neighbours can't score more than j+1.
+         *
+         * Scores are capped at n+1, because if a square scores more
+         * than n then that's enough to know it can't possibly be
+         * reached by extending an existing region - we don't need to
+         * know exactly _how far_ out of reach it is.
+         */
+        for (i = 0; i < sz; i++) {
+            if (s->board[i] == n) {
+                /* Square is part of an existing CC. */
+                minsize[i] = dsf_size(s->dsf, i);
+            } else {
+                /* Otherwise, initialise to the maximum score n+1;
+                 * we'll reduce this later if we find a neighbouring
+                 * square with a lower score. */
+                minsize[i] = n+1;
+            }
+        }
+
+        for (j = 1; j < n; j++) {
+            /*
+             * Find neighbours of cells scoring j, and set their score
+             * to at most j+1.
+             *
+             * Doing the BFS this way means we need n passes over the
+             * grid, which isn't entirely optimal but it seems to be
+             * fast enough for the moment. This could probably be
+             * improved by keeping a linked-list queue of cells in
+             * some way, but I think you'd have to be a bit careful to
+             * insert things into the right place in the queue; this
+             * way is easier not to get wrong.
+             */
+            for (y = 0; y < h; y++) {
+                for (x = 0; x < w; x++) {
+                    i = y*w+x;
+                    if (minsize[i] == j) {
+                        if (x > 0 && minsize[i-1] > j+1)
+                            minsize[i-1] = j+1;
+                        if (x+1 < w && minsize[i+1] > j+1)
+                            minsize[i+1] = j+1;
+                        if (y > 0 && minsize[i-w] > j+1)
+                            minsize[i-w] = j+1;
+                        if (y+1 < h && minsize[i+w] > j+1)
+                            minsize[i+w] = j+1;
+                    }
+                }
+            }
+        }
+
+        /*
+         * Now, every cell scoring at most n should have its 1<<n bit
+         * in the bitmap reinstated, because we've found that it's
+         * potentially reachable by extending an existing CC.
+         */
+        for (i = 0; i < sz; i++)
+            if (minsize[i] <= n)
+                bm[i] |= 1<<n;
+    }
+#if 0
+    printv("bitmap after bfs:\n");
+    print_bitmap(bm, w, h);
+#endif
+
+    /*
+     * Now our bitmap is complete. Look for entries with only one bit
+     * set; those are squares with only one possible number, in which
+     * case we can fill that number in.
+     */
+    for (i = 0; i < sz; i++) {
+        if (bm[i] && !(bm[i] & (bm[i]-1))) { /* is bm[i] a power of two? */
+            int val = bm[i];
+
+            /* Integer log2, by simple binary search. */
+            n = 0;
+            if (val >> 8) { val >>= 8; n += 8; }
+            if (val >> 4) { val >>= 4; n += 4; }
+            if (val >> 2) { val >>= 2; n += 2; }
+            if (val >> 1) { val >>= 1; n += 1; }
+
+            /* Double-check that we ended up with a sensible
+             * answer. */
+            assert(1 <= n);
+            assert(n <= 9);
+            assert(bm[i] == (1 << n));
+
+            if (s->board[i] == EMPTY) {
+                printv("learn: %d is only possibility at (%d, %d)\n",
+                       n, i % w, i / w);
+                s->board[i] = n;
+                filled_square(s, w, h, i);
+                assert(s->nempty);
+                --s->nempty;
+                learn = TRUE;
+            }
+        }
+    }
+
+    return learn;
+}
+
+static int solver(const int *orig, int w, int h, char **solution) {
+    const int sz = w * h;
+
+    struct solver_state ss;
+    ss.board = memdup(orig, sz, sizeof (int));
+    ss.dsf = snew_dsf(sz); /* eqv classes: connected components */
+    ss.connected = snewn(sz, int); /* connected[n] := n.next; */
+    /* cyclic disjoint singly linked lists, same partitioning as dsf.
+     * The lists lets you iterate over a partition given any member */
+    ss.bm = snewn(sz, int);
+    ss.bmdsf = snew_dsf(sz);
+    ss.bmminsize = snewn(sz, int);
+
+    printv("trying to solve this:\n");
+    print_board(ss.board, w, h);
+
+    init_solver_state(&ss, w, h);
+    do {
+        if (learn_blocked_expansion(&ss, w, h)) continue;
+        if (learn_expand_or_one(&ss, w, h)) continue;
+        if (learn_critical_square(&ss, w, h)) continue;
+        if (learn_bitmap_deductions(&ss, w, h)) continue;
+        break;
+    } while (ss.nempty);
+
+    printv("best guess:\n");
+    print_board(ss.board, w, h);
+
+    if (solution) {
+        int i;
+        *solution = snewn(sz + 2, char);
+        **solution = 's';
+        for (i = 0; i < sz; ++i) (*solution)[i + 1] = ss.board[i] + '0';
+        (*solution)[sz + 1] = '\0';
+        /* We don't need the \0 for execute_move (the only user)
+         * I'm just being printf-friendly in case I wanna print */
+    }
+
+    sfree(ss.dsf);
+    sfree(ss.board);
+    sfree(ss.connected);
+    sfree(ss.bm);
+    sfree(ss.bmdsf);
+    sfree(ss.bmminsize);
+
+    return !ss.nempty;
+}
+
+static int *make_dsf(int *dsf, int *board, const int w, const int h) {
+    const int sz = w * h;
+    int i;
+
+    if (!dsf)
+        dsf = snew_dsf(w * h);
+    else
+        dsf_init(dsf, w * h);
+
+    for (i = 0; i < sz; ++i) {
+        int j;
+        for (j = 0; j < 4; ++j) {
+            const int x = (i % w) + dx[j];
+            const int y = (i / w) + dy[j];
+            const int k = w*y + x;
+            if (x < 0 || x >= w || y < 0 || y >= h) continue;
+            if (board[i] == board[k]) dsf_merge(dsf, i, k);
+        }
+    }
+    return dsf;
+}
+
+static void minimize_clue_set(int *board, int w, int h, random_state *rs)
+{
+    const int sz = w * h;
+    int *shuf = snewn(sz, int), i;
+    int *dsf, *next;
+
+    for (i = 0; i < sz; ++i) shuf[i] = i;
+    shuffle(shuf, sz, sizeof (int), rs);
+
+    /*
+     * First, try to eliminate an entire region at a time if possible,
+     * because inferring the existence of a completely unclued region
+     * is a particularly good aspect of this puzzle type and we want
+     * to encourage it to happen.
+     *
+     * Begin by identifying the regions as linked lists of cells using
+     * the 'next' array.
+     */
+    dsf = make_dsf(NULL, board, w, h);
+    next = snewn(sz, int);
+    for (i = 0; i < sz; ++i) {
+        int j = dsf_canonify(dsf, i);
+        if (i == j) {
+            /* First cell of a region; set next[i] = -1 to indicate
+             * end-of-list. */
+            next[i] = -1;
+        } else {
+            /* Add this cell to a region which already has a
+             * linked-list head, by pointing the canonical element j
+             * at this one, and pointing this one in turn at wherever
+             * j previously pointed. (This should end up with the
+             * elements linked in the order 1,n,n-1,n-2,...,2, which
+             * is a bit weird-looking, but any order is fine.)
+             */
+            assert(j < i);
+            next[i] = next[j];
+            next[j] = i;
+        }
+    }
+
+    /*
+     * Now loop over the grid cells in our shuffled order, and each
+     * time we encounter a region for the first time, try to remove it
+     * all. Then we set next[canonical index] to -2 rather than -1, to
+     * mark it as already tried.
+     *
+     * Doing this in a loop over _cells_, rather than extracting and
+     * shuffling a list of _regions_, is intended to skew the
+     * probabilities towards trying to remove larger regions first
+     * (but without anything as crudely predictable as enforcing that
+     * we _always_ process regions in descending size order). Region
+     * removals might well be mutually exclusive, and larger ghost
+     * regions are more interesting, so we want to bias towards them
+     * if we can.
+     */
+    for (i = 0; i < sz; ++i) {
+        int j = dsf_canonify(dsf, shuf[i]);
+        if (next[j] != -2) {
+            int tmp = board[j];
+            int k;
+
+            /* Blank out the whole thing. */
+            for (k = j; k >= 0; k = next[k])
+                board[k] = EMPTY;
+
+            if (!solver(board, w, h, NULL)) {
+                /* Wasn't still solvable; reinstate it all */
+                for (k = j; k >= 0; k = next[k])
+                    board[k] = tmp;
+            }
+
+            /* Either way, don't try this region again. */
+            next[j] = -2;
+        }
+    }
+    sfree(next);
+    sfree(dsf);
+
+    /*
+     * Now go through individual cells, in the same shuffled order,
+     * and try to remove each one by itself.
+     */
+    for (i = 0; i < sz; ++i) {
+        int tmp = board[shuf[i]];
+        board[shuf[i]] = EMPTY;
+        if (!solver(board, w, h, NULL)) board[shuf[i]] = tmp;
+    }
+
+    sfree(shuf);
+}
+
+static int encode_run(char *buffer, int run)
+{
+    int i = 0;
+    for (; run > 26; run -= 26)
+        buffer[i++] = 'z';
+    if (run)
+        buffer[i++] = 'a' - 1 + run;
+    return i;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    const int w = params->w, h = params->h, sz = w * h;
+    int *board = snewn(sz, int), i, j, run;
+    char *description = snewn(sz + 1, char);
+
+    make_board(board, w, h, rs);
+    minimize_clue_set(board, w, h, rs);
+
+    for (run = j = i = 0; i < sz; ++i) {
+        assert(board[i] >= 0);
+        assert(board[i] < 10);
+        if (board[i] == 0) {
+            ++run;
+        } else {
+            j += encode_run(description + j, run);
+            run = 0;
+            description[j++] = board[i] + '0';
+        }
+    }
+    j += encode_run(description + j, run);
+    description[j++] = '\0';
+
+    sfree(board);
+
+    return sresize(description, j, char);
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    const int sz = params->w * params->h;
+    const char m = '0' + max(max(params->w, params->h), 3);
+    int area;
+
+    for (area = 0; *desc; ++desc) {
+        if (*desc >= 'a' && *desc <= 'z') area += *desc - 'a' + 1;
+        else if (*desc >= '0' && *desc <= m) ++area;
+        else {
+            static char s[] =  "Invalid character '%""' in game description";
+            int n = sprintf(s, "Invalid character '%1c' in game description",
+                            *desc);
+            assert(n + 1 <= lenof(s)); /* +1 for the terminating NUL */
+            return s;
+        }
+        if (area > sz) return "Too much data to fit in grid";
+    }
+    return (area < sz) ? "Not enough data to fill grid" : NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    int sz = params->w * params->h;
+    int i;
+
+    state->cheated = state->completed = FALSE;
+    state->shared = snew(struct shared_state);
+    state->shared->refcnt = 1;
+    state->shared->params = *params; /* struct copy */
+    state->shared->clues = snewn(sz, int);
+
+    for (i = 0; *desc; ++desc) {
+        if (*desc >= 'a' && *desc <= 'z') {
+            int j = *desc - 'a' + 1;
+            assert(i + j <= sz);
+            for (; j; --j) state->shared->clues[i++] = 0;
+        } else state->shared->clues[i++] = *desc - '0';
+    }
+    state->board = memdup(state->shared->clues, sz, sizeof (int));
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    const int sz = state->shared->params.w * state->shared->params.h;
+    game_state *ret = snew(game_state);
+
+    ret->board = memdup(state->board, sz, sizeof (int));
+    ret->shared = state->shared;
+    ret->cheated = state->cheated;
+    ret->completed = state->completed;
+    ++ret->shared->refcnt;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    assert(state);
+    sfree(state->board);
+    if (--state->shared->refcnt == 0) {
+        sfree(state->shared->clues);
+        sfree(state->shared);
+    }
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    if (aux == NULL) {
+        const int w = state->shared->params.w;
+        const int h = state->shared->params.h;
+        char *new_aux;
+        if (!solver(state->board, w, h, &new_aux))
+            *error = "Sorry, I couldn't find a solution";
+        return new_aux;
+    }
+    return dupstr(aux);
+}
+
+/*****************************************************************************
+ * USER INTERFACE STATE AND ACTION                                           *
+ *****************************************************************************/
+
+struct game_ui {
+    int *sel; /* w*h highlighted squares, or NULL */
+    int cur_x, cur_y, cur_visible, keydragging;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->sel = NULL;
+    ui->cur_x = ui->cur_y = ui->cur_visible = ui->keydragging = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    if (ui->sel)
+        sfree(ui->sel);
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    /* Clear any selection */
+    if (ui->sel) {
+        sfree(ui->sel);
+        ui->sel = NULL;
+    }
+    ui->keydragging = FALSE;
+}
+
+#define PREFERRED_TILE_SIZE 32
+#define TILE_SIZE (ds->tilesize)
+#define BORDER (TILE_SIZE / 2)
+#define BORDER_WIDTH (max(TILE_SIZE / 32, 1))
+
+struct game_drawstate {
+    struct game_params params;
+    int tilesize;
+    int started;
+    int *v, *flags;
+    int *dsf_scratch, *border_scratch;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    const int w = state->shared->params.w;
+    const int h = state->shared->params.h;
+
+    const int tx = (x + TILE_SIZE - BORDER) / TILE_SIZE - 1;
+    const int ty = (y + TILE_SIZE - BORDER) / TILE_SIZE - 1;
+
+    char *move = NULL;
+    int i;
+
+    assert(ui);
+    assert(ds);
+
+    button &= ~MOD_MASK;
+
+    if (button == LEFT_BUTTON || button == LEFT_DRAG) {
+        /* A left-click anywhere will clear the current selection. */
+        if (button == LEFT_BUTTON) {
+            if (ui->sel) {
+                sfree(ui->sel);
+                ui->sel = NULL;
+            }
+        }
+        if (tx >= 0 && tx < w && ty >= 0 && ty < h) {
+            if (!ui->sel) {
+                ui->sel = snewn(w*h, int);
+                memset(ui->sel, 0, w*h*sizeof(int));
+            }
+            if (!state->shared->clues[w*ty+tx])
+                ui->sel[w*ty+tx] = 1;
+        }
+        ui->cur_visible = 0;
+        return ""; /* redraw */
+    }
+
+    if (IS_CURSOR_MOVE(button)) {
+        ui->cur_visible = 1;
+        move_cursor(button, &ui->cur_x, &ui->cur_y, w, h, 0);
+        if (ui->keydragging) goto select_square;
+        return "";
+    }
+    if (button == CURSOR_SELECT) {
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+        ui->keydragging = !ui->keydragging;
+        if (!ui->keydragging) return "";
+
+      select_square:
+        if (!ui->sel) {
+            ui->sel = snewn(w*h, int);
+            memset(ui->sel, 0, w*h*sizeof(int));
+        }
+        if (!state->shared->clues[w*ui->cur_y + ui->cur_x])
+            ui->sel[w*ui->cur_y + ui->cur_x] = 1;
+        return "";
+    }
+    if (button == CURSOR_SELECT2) {
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+        if (!ui->sel) {
+            ui->sel = snewn(w*h, int);
+            memset(ui->sel, 0, w*h*sizeof(int));
+        }
+        ui->keydragging = FALSE;
+        if (!state->shared->clues[w*ui->cur_y + ui->cur_x])
+            ui->sel[w*ui->cur_y + ui->cur_x] ^= 1;
+        for (i = 0; i < w*h && !ui->sel[i]; i++);
+        if (i == w*h) {
+            sfree(ui->sel);
+            ui->sel = NULL;
+        }
+        return "";
+    }
+
+    if (button == '\b' || button == 27) {
+        sfree(ui->sel);
+        ui->sel = NULL;
+        ui->keydragging = FALSE;
+        return "";
+    }
+
+    if (button < '0' || button > '9') return NULL;
+    button -= '0';
+    if (button > (w == 2 && h == 2 ? 3 : max(w, h))) return NULL;
+    ui->keydragging = FALSE;
+
+    for (i = 0; i < w*h; i++) {
+        char buf[32];
+        if ((ui->sel && ui->sel[i]) ||
+            (!ui->sel && ui->cur_visible && (w*ui->cur_y+ui->cur_x) == i)) {
+            if (state->shared->clues[i] != 0) continue; /* in case cursor is on clue */
+            if (state->board[i] != button) {
+                sprintf(buf, "%s%d", move ? "," : "", i);
+                if (move) {
+                    move = srealloc(move, strlen(move)+strlen(buf)+1);
+                    strcat(move, buf);
+                } else {
+                    move = smalloc(strlen(buf)+1);
+                    strcpy(move, buf);
+                }
+            }
+        }
+    }
+    if (move) {
+        char buf[32];
+        sprintf(buf, "_%d", button);
+        move = srealloc(move, strlen(move)+strlen(buf)+1);
+        strcat(move, buf);
+    }
+    if (!ui->sel) return move ? move : NULL;
+    sfree(ui->sel);
+    ui->sel = NULL;
+    /* Need to update UI at least, as we cleared the selection */
+    return move ? move : "";
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    game_state *new_state = NULL;
+    const int sz = state->shared->params.w * state->shared->params.h;
+
+    if (*move == 's') {
+        int i = 0;
+        new_state = dup_game(state);
+        for (++move; i < sz; ++i) new_state->board[i] = move[i] - '0';
+        new_state->cheated = TRUE;
+    } else {
+        int value;
+        char *endptr, *delim = strchr(move, '_');
+        if (!delim) goto err;
+        value = strtol(delim+1, &endptr, 10);
+        if (*endptr || endptr == delim+1) goto err;
+        if (value < 0 || value > 9) goto err;
+        new_state = dup_game(state);
+        while (*move) {
+            const int i = strtol(move, &endptr, 10);
+            if (endptr == move) goto err;
+            if (i < 0 || i >= sz) goto err;
+            new_state->board[i] = value;
+            if (*endptr == '_') break;
+            if (*endptr != ',') goto err;
+            move = endptr + 1;
+        }
+    }
+
+    /*
+     * Check for completion.
+     */
+    if (!new_state->completed) {
+        const int w = new_state->shared->params.w;
+        const int h = new_state->shared->params.h;
+        const int sz = w * h;
+        int *dsf = make_dsf(NULL, new_state->board, w, h);
+        int i;
+        for (i = 0; i < sz && new_state->board[i] == dsf_size(dsf, i); ++i);
+        sfree(dsf);
+        if (i == sz)
+            new_state->completed = TRUE;
+    }
+
+    return new_state;
+
+err:
+    if (new_state) free_game(new_state);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define FLASH_TIME 0.4F
+
+#define COL_CLUE COL_GRID
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_HIGHLIGHT,
+    COL_CORRECT,
+    COL_ERROR,
+    COL_USER,
+    COL_CURSOR,
+    NCOLOURS
+};
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    *x = (params->w + 1) * tilesize;
+    *y = (params->h + 1) * tilesize;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_GRID * 3 + 0] = 0.0F;
+    ret[COL_GRID * 3 + 1] = 0.0F;
+    ret[COL_GRID * 3 + 2] = 0.0F;
+
+    ret[COL_HIGHLIGHT * 3 + 0] = 0.85F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_HIGHLIGHT * 3 + 1] = 0.85F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_HIGHLIGHT * 3 + 2] = 0.85F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_CORRECT * 3 + 0] = 0.9F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_CORRECT * 3 + 1] = 0.9F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_CORRECT * 3 + 2] = 0.9F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_CURSOR * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_CURSOR * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_CURSOR * 3 + 2] = 0.5F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.85F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_ERROR * 3 + 2] = 0.85F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_USER * 3 + 0] = 0.0F;
+    ret[COL_USER * 3 + 1] = 0.6F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_USER * 3 + 2] = 0.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = PREFERRED_TILE_SIZE;
+    ds->started = 0;
+    ds->params = state->shared->params;
+    ds->v = snewn(ds->params.w * ds->params.h, int);
+    ds->flags = snewn(ds->params.w * ds->params.h, int);
+    for (i = 0; i < ds->params.w * ds->params.h; i++)
+        ds->v[i] = ds->flags[i] = -1;
+    ds->border_scratch = snewn(ds->params.w * ds->params.h, int);
+    ds->dsf_scratch = NULL;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->v);
+    sfree(ds->flags);
+    sfree(ds->border_scratch);
+    sfree(ds->dsf_scratch);
+    sfree(ds);
+}
+
+#define BORDER_U   0x001
+#define BORDER_D   0x002
+#define BORDER_L   0x004
+#define BORDER_R   0x008
+#define BORDER_UR  0x010
+#define BORDER_DR  0x020
+#define BORDER_UL  0x040
+#define BORDER_DL  0x080
+#define HIGH_BG    0x100
+#define CORRECT_BG 0x200
+#define ERROR_BG   0x400
+#define USER_COL   0x800
+#define CURSOR_SQ 0x1000
+
+static void draw_square(drawing *dr, game_drawstate *ds, int x, int y,
+                        int n, int flags)
+{
+    assert(dr);
+    assert(ds);
+
+    /*
+     * Clip to the grid square.
+     */
+    clip(dr, BORDER + x*TILE_SIZE, BORDER + y*TILE_SIZE,
+         TILE_SIZE, TILE_SIZE);
+
+    /*
+     * Clear the square.
+     */
+    draw_rect(dr,
+              BORDER + x*TILE_SIZE,
+              BORDER + y*TILE_SIZE,
+              TILE_SIZE,
+              TILE_SIZE,
+              (flags & HIGH_BG ? COL_HIGHLIGHT :
+               flags & ERROR_BG ? COL_ERROR :
+               flags & CORRECT_BG ? COL_CORRECT : COL_BACKGROUND));
+
+    /*
+     * Draw the grid lines.
+     */
+    draw_line(dr, BORDER + x*TILE_SIZE, BORDER + y*TILE_SIZE,
+              BORDER + (x+1)*TILE_SIZE, BORDER + y*TILE_SIZE, COL_GRID);
+    draw_line(dr, BORDER + x*TILE_SIZE, BORDER + y*TILE_SIZE,
+              BORDER + x*TILE_SIZE, BORDER + (y+1)*TILE_SIZE, COL_GRID);
+
+    /*
+     * Draw the number.
+     */
+    if (n) {
+        char buf[2];
+        buf[0] = n + '0';
+        buf[1] = '\0';
+        draw_text(dr,
+                  (x + 1) * TILE_SIZE,
+                  (y + 1) * TILE_SIZE,
+                  FONT_VARIABLE,
+                  TILE_SIZE / 2,
+                  ALIGN_VCENTRE | ALIGN_HCENTRE,
+                  flags & USER_COL ? COL_USER : COL_CLUE,
+                  buf);
+    }
+
+    /*
+     * Draw bold lines around the borders.
+     */
+    if (flags & BORDER_L)
+        draw_rect(dr,
+                  BORDER + x*TILE_SIZE + 1,
+                  BORDER + y*TILE_SIZE + 1,
+                  BORDER_WIDTH,
+                  TILE_SIZE - 1,
+                  COL_GRID);
+    if (flags & BORDER_U)
+        draw_rect(dr,
+                  BORDER + x*TILE_SIZE + 1,
+                  BORDER + y*TILE_SIZE + 1,
+                  TILE_SIZE - 1,
+                  BORDER_WIDTH,
+                  COL_GRID);
+    if (flags & BORDER_R)
+        draw_rect(dr,
+                  BORDER + (x+1)*TILE_SIZE - BORDER_WIDTH,
+                  BORDER + y*TILE_SIZE + 1,
+                  BORDER_WIDTH,
+                  TILE_SIZE - 1,
+                  COL_GRID);
+    if (flags & BORDER_D)
+        draw_rect(dr,
+                  BORDER + x*TILE_SIZE + 1,
+                  BORDER + (y+1)*TILE_SIZE - BORDER_WIDTH,
+                  TILE_SIZE - 1,
+                  BORDER_WIDTH,
+                  COL_GRID);
+    if (flags & BORDER_UL)
+        draw_rect(dr,
+                  BORDER + x*TILE_SIZE + 1,
+                  BORDER + y*TILE_SIZE + 1,
+                  BORDER_WIDTH,
+                  BORDER_WIDTH,
+                  COL_GRID);
+    if (flags & BORDER_UR)
+        draw_rect(dr,
+                  BORDER + (x+1)*TILE_SIZE - BORDER_WIDTH,
+                  BORDER + y*TILE_SIZE + 1,
+                  BORDER_WIDTH,
+                  BORDER_WIDTH,
+                  COL_GRID);
+    if (flags & BORDER_DL)
+        draw_rect(dr,
+                  BORDER + x*TILE_SIZE + 1,
+                  BORDER + (y+1)*TILE_SIZE - BORDER_WIDTH,
+                  BORDER_WIDTH,
+                  BORDER_WIDTH,
+                  COL_GRID);
+    if (flags & BORDER_DR)
+        draw_rect(dr,
+                  BORDER + (x+1)*TILE_SIZE - BORDER_WIDTH,
+                  BORDER + (y+1)*TILE_SIZE - BORDER_WIDTH,
+                  BORDER_WIDTH,
+                  BORDER_WIDTH,
+                  COL_GRID);
+
+    if (flags & CURSOR_SQ) {
+        int coff = TILE_SIZE/8;
+        draw_rect_outline(dr,
+                          BORDER + x*TILE_SIZE + coff,
+                          BORDER + y*TILE_SIZE + coff,
+                          TILE_SIZE - coff*2,
+                          TILE_SIZE - coff*2,
+                          COL_CURSOR);
+    }
+
+    unclip(dr);
+
+    draw_update(dr,
+                BORDER + x*TILE_SIZE,
+                BORDER + y*TILE_SIZE,
+                TILE_SIZE,
+                TILE_SIZE);
+}
+
+static void draw_grid(drawing *dr, game_drawstate *ds, const game_state *state,
+                      const game_ui *ui, int flashy, int borders, int shading)
+{
+    const int w = state->shared->params.w;
+    const int h = state->shared->params.h;
+    int x;
+    int y;
+
+    /*
+     * Build a dsf for the board in its current state, to use for
+     * highlights and hints.
+     */
+    ds->dsf_scratch = make_dsf(ds->dsf_scratch, state->board, w, h);
+
+    /*
+     * Work out where we're putting borders between the cells.
+     */
+    for (y = 0; y < w*h; y++)
+        ds->border_scratch[y] = 0;
+
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int dx, dy;
+            int v1, s1, v2, s2;
+
+            for (dx = 0; dx <= 1; dx++) {
+                int border = FALSE;
+
+                dy = 1 - dx;
+
+                if (x+dx >= w || y+dy >= h)
+                    continue;
+
+                v1 = state->board[y*w+x];
+                v2 = state->board[(y+dy)*w+(x+dx)];
+                s1 = dsf_size(ds->dsf_scratch, y*w+x);
+                s2 = dsf_size(ds->dsf_scratch, (y+dy)*w+(x+dx));
+
+                /*
+                 * We only ever draw a border between two cells if
+                 * they don't have the same contents.
+                 */
+                if (v1 != v2) {
+                    /*
+                     * But in that situation, we don't always draw
+                     * a border. We do if the two cells both
+                     * contain actual numbers...
+                     */
+                    if (v1 && v2)
+                        border = TRUE;
+
+                    /*
+                     * ... or if at least one of them is a
+                     * completed or overfull omino.
+                     */
+                    if (v1 && s1 >= v1)
+                        border = TRUE;
+                    if (v2 && s2 >= v2)
+                        border = TRUE;
+                }
+
+                if (border)
+                    ds->border_scratch[y*w+x] |= (dx ? 1 : 2);
+            }
+        }
+
+    /*
+     * Actually do the drawing.
+     */
+    for (y = 0; y < h; ++y)
+        for (x = 0; x < w; ++x) {
+            /*
+             * Determine what we need to draw in this square.
+             */
+            int i = y*w+x, v = state->board[i];
+            int flags = 0;
+
+            if (flashy || !shading) {
+                /* clear all background flags */
+            } else if (ui && ui->sel && ui->sel[i]) {
+                flags |= HIGH_BG;
+            } else if (v) {
+                int size = dsf_size(ds->dsf_scratch, i);
+                if (size == v)
+                    flags |= CORRECT_BG;
+                else if (size > v)
+                    flags |= ERROR_BG;
+                else {
+                    int rt = dsf_canonify(ds->dsf_scratch, i), j;
+                    for (j = 0; j < w*h; ++j) {
+                        int k;
+                        if (dsf_canonify(ds->dsf_scratch, j) != rt) continue;
+                        for (k = 0; k < 4; ++k) {
+                            const int xx = j % w + dx[k], yy = j / w + dy[k];
+                            if (xx >= 0 && xx < w && yy >= 0 && yy < h &&
+                                state->board[yy*w + xx] == EMPTY)
+                                goto noflag;
+                        }
+                    }
+                    flags |= ERROR_BG;
+                  noflag:
+                    ;
+                }
+            }
+            if (ui && ui->cur_visible && x == ui->cur_x && y == ui->cur_y)
+              flags |= CURSOR_SQ;
+
+            /*
+             * Borders at the very edges of the grid are
+             * independent of the `borders' flag.
+             */
+            if (x == 0)
+                flags |= BORDER_L;
+            if (y == 0)
+                flags |= BORDER_U;
+            if (x == w-1)
+                flags |= BORDER_R;
+            if (y == h-1)
+                flags |= BORDER_D;
+
+            if (borders) {
+                if (x == 0 || (ds->border_scratch[y*w+(x-1)] & 1))
+                    flags |= BORDER_L;
+                if (y == 0 || (ds->border_scratch[(y-1)*w+x] & 2))
+                    flags |= BORDER_U;
+                if (x == w-1 || (ds->border_scratch[y*w+x] & 1))
+                    flags |= BORDER_R;
+                if (y == h-1 || (ds->border_scratch[y*w+x] & 2))
+                    flags |= BORDER_D;
+
+                if (y > 0 && x > 0 && (ds->border_scratch[(y-1)*w+(x-1)]))
+                    flags |= BORDER_UL;
+                if (y > 0 && x < w-1 &&
+                    ((ds->border_scratch[(y-1)*w+x] & 1) ||
+                     (ds->border_scratch[(y-1)*w+(x+1)] & 2)))
+                    flags |= BORDER_UR;
+                if (y < h-1 && x > 0 &&
+                    ((ds->border_scratch[y*w+(x-1)] & 2) ||
+                     (ds->border_scratch[(y+1)*w+(x-1)] & 1)))
+                    flags |= BORDER_DL;
+                if (y < h-1 && x < w-1 &&
+                    ((ds->border_scratch[y*w+(x+1)] & 2) ||
+                     (ds->border_scratch[(y+1)*w+x] & 1)))
+                    flags |= BORDER_DR;
+            }
+
+            if (!state->shared->clues[y*w+x])
+                flags |= USER_COL;
+
+            if (ds->v[y*w+x] != v || ds->flags[y*w+x] != flags) {
+                draw_square(dr, ds, x, y, v, flags);
+                ds->v[y*w+x] = v;
+                ds->flags[y*w+x] = flags;
+            }
+        }
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    const int w = state->shared->params.w;
+    const int h = state->shared->params.h;
+
+    const int flashy =
+        flashtime > 0 &&
+        (flashtime <= FLASH_TIME/3 || flashtime >= FLASH_TIME*2/3);
+
+    if (!ds->started) {
+        /*
+         * The initial contents of the window are not guaranteed and
+         * can vary with front ends. To be on the safe side, all games
+         * should start by drawing a big background-colour rectangle
+         * covering the whole window.
+         */
+        draw_rect(dr, 0, 0, w*TILE_SIZE + 2*BORDER, h*TILE_SIZE + 2*BORDER,
+                  COL_BACKGROUND);
+
+        /*
+         * Smaller black rectangle which is the main grid.
+         */
+        draw_rect(dr, BORDER - BORDER_WIDTH, BORDER - BORDER_WIDTH,
+                  w*TILE_SIZE + 2*BORDER_WIDTH + 1,
+                  h*TILE_SIZE + 2*BORDER_WIDTH + 1,
+                  COL_GRID);
+
+        draw_update(dr, 0, 0, w*TILE_SIZE + 2*BORDER, h*TILE_SIZE + 2*BORDER);
+
+        ds->started = TRUE;
+    }
+
+    draw_grid(dr, ds, state, ui, flashy, TRUE, TRUE);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    assert(oldstate);
+    assert(newstate);
+    assert(newstate->shared);
+    assert(oldstate->shared == newstate->shared);
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 6mm squares by default.
+     */
+    game_compute_size(params, 600, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    const int w = state->shared->params.w;
+    const int h = state->shared->params.h;
+    int c, i, borders;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate *ds = game_new_drawstate(dr, state);
+    game_set_size(dr, ds, NULL, tilesize);
+
+    c = print_mono_colour(dr, 1); assert(c == COL_BACKGROUND);
+    c = print_mono_colour(dr, 0); assert(c == COL_GRID);
+    c = print_mono_colour(dr, 1); assert(c == COL_HIGHLIGHT);
+    c = print_mono_colour(dr, 1); assert(c == COL_CORRECT);
+    c = print_mono_colour(dr, 1); assert(c == COL_ERROR);
+    c = print_mono_colour(dr, 0); assert(c == COL_USER);
+
+    /*
+     * Border.
+     */
+    draw_rect(dr, BORDER - BORDER_WIDTH, BORDER - BORDER_WIDTH,
+              w*TILE_SIZE + 2*BORDER_WIDTH + 1,
+              h*TILE_SIZE + 2*BORDER_WIDTH + 1,
+              COL_GRID);
+
+    /*
+     * We'll draw borders between the ominoes iff the grid is not
+     * pristine. So scan it to see if it is.
+     */
+    borders = FALSE;
+    for (i = 0; i < w*h; i++)
+        if (state->board[i] && !state->shared->clues[i])
+            borders = TRUE;
+
+    /*
+     * Draw grid.
+     */
+    print_line_width(dr, TILE_SIZE / 64);
+    draw_grid(dr, ds, state, NULL, FALSE, borders, FALSE);
+
+    /*
+     * Clean up.
+     */
+    game_free_drawstate(dr, ds);
+}
+
+#ifdef COMBINED
+#define thegame filling
+#endif
+
+const struct game thegame = {
+    "Filling", "games.filling", "filling",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                                 /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_NUMPAD,                    /* flags */
+};
+
+#ifdef STANDALONE_SOLVER /* solver? hah! */
+
+int main(int argc, char **argv) {
+    while (*++argv) {
+        game_params *params;
+        game_state *state;
+        char *par;
+        char *desc;
+
+        for (par = desc = *argv; *desc != '\0' && *desc != ':'; ++desc);
+        if (*desc == '\0') {
+            fprintf(stderr, "bad puzzle id: %s", par);
+            continue;
+        }
+
+        *desc++ = '\0';
+
+        params = snew(game_params);
+        decode_params(params, par);
+        state = new_game(NULL, params, desc);
+        if (solver(state->board, params->w, params->h, NULL))
+            printf("%s:%s: solvable\n", par, desc);
+        else
+            printf("%s:%s: not solvable\n", par, desc);
+    }
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/findloop.c b/apps/plugins/puzzles/findloop.c
new file mode 100644
index 0000000000..e6b2654cad
--- /dev/null
+++ b/apps/plugins/puzzles/findloop.c
@@ -0,0 +1,500 @@
+/*
+ * Routine for finding loops in graphs, reusable across multiple
+ * puzzles.
+ *
+ * The strategy is Tarjan's bridge-finding algorithm, which is
+ * designed to list all edges whose removal would disconnect a
+ * previously connected component of the graph. We're interested in
+ * exactly the reverse - edges that are part of a loop in the graph
+ * are precisely those which _wouldn't_ disconnect anything if removed
+ * (individually) - but of course flipping the sense of the output is
+ * easy.
+ */
+
+#include "puzzles.h"
+
+struct findloopstate {
+    int parent, child, sibling, visited;
+    int index, minindex, maxindex;
+    int minreachable, maxreachable;
+    int bridge;
+};
+
+struct findloopstate *findloop_new_state(int nvertices)
+{
+    /*
+     * Allocate a findloopstate structure for each vertex, and one
+     * extra one at the end which will be the overall root of a
+     * 'super-tree', which links the whole graph together to make it
+     * as easy as possible to iterate over all the connected
+     * components.
+     */
+    return snewn(nvertices + 1, struct findloopstate);
+}
+
+void findloop_free_state(struct findloopstate *state)
+{
+    sfree(state);
+}
+
+int findloop_is_loop_edge(struct findloopstate *pv, int u, int v)
+{
+    /*
+     * Since the algorithm is intended for finding bridges, and a
+     * bridge must be part of any spanning tree, it follows that there
+     * is at most one bridge per vertex.
+     *
+     * Furthermore, by finding a _rooted_ spanning tree (so that each
+     * bridge is a parent->child link), you can find an injection from
+     * bridges to vertices (namely, map each bridge to the vertex at
+     * its child end).
+     *
+     * So if the u-v edge is a bridge, then either v was u's parent
+     * when the algorithm ran and we set pv[u].bridge = v, or vice
+     * versa.
+     */
+    return !(pv[u].bridge == v || pv[v].bridge == u);
+}
+
+int findloop_run(struct findloopstate *pv, int nvertices,
+                 neighbour_fn_t neighbour, void *ctx)
+{
+    int u, v, w, root, index;
+    int nbridges, nedges;
+
+    root = nvertices;
+
+    /*
+     * First pass: organise the graph into a rooted spanning forest.
+     * That is, a tree structure with a clear up/down orientation -
+     * every node has exactly one parent (which may be 'root') and
+     * zero or more children, and every parent-child link corresponds
+     * to a graph edge.
+     *
+     * (A side effect of this is to find all the connected components,
+     * which of course we could do less confusingly with a dsf - but
+     * then we'd have to do that *and* build the tree, so it's less
+     * effort to do it all at once.)
+     */
+    for (v = 0; v <= nvertices; v++) {
+        pv[v].parent = root;
+        pv[v].child = -2;
+        pv[v].sibling = -1;
+        pv[v].visited = FALSE;
+    }
+    pv[root].child = -1;
+    nedges = 0;
+    debug(("------------- new find_loops, nvertices=%d\n", nvertices));
+    for (v = 0; v < nvertices; v++) {
+        if (pv[v].parent == root) {
+            /*
+             * Found a new connected component. Enumerate and treeify
+             * it.
+             */
+            pv[v].sibling = pv[root].child;
+            pv[root].child = v;
+            debug(("%d is new child of root\n", v));
+
+            u = v;
+            while (1) {
+                if (!pv[u].visited) {
+                    pv[u].visited = TRUE;
+
+                    /*
+                     * Enumerate the neighbours of u, and any that are
+                     * as yet not in the tree structure (indicated by
+                     * child==-2, and distinct from the 'visited'
+                     * flag) become children of u.
+                     */
+                    debug(("  component pass: processing %d\n", u));
+                    for (w = neighbour(u, ctx); w >= 0;
+                         w = neighbour(-1, ctx)) {
+                        debug(("    edge %d-%d\n", u, w));
+                        if (pv[w].child == -2) {
+                            debug(("      -> new child\n"));
+                            pv[w].child = -1;
+                            pv[w].sibling = pv[u].child;
+                            pv[w].parent = u;
+                            pv[u].child = w;
+                        }
+
+                        /* While we're here, count the edges in the whole
+                         * graph, so that we can easily check at the end
+                         * whether all of them are bridges, i.e. whether
+                         * no loop exists at all. */
+                        if (w > u) /* count each edge only in one direction */
+                            nedges++;
+                    }
+
+                    /*
+                     * Now descend in depth-first search.
+                     */
+                    if (pv[u].child >= 0) {
+                        u = pv[u].child;
+                        debug(("    descending to %d\n", u));
+                        continue;
+                    }
+                }
+
+                if (u == v) {
+                    debug(("      back at %d, done this component\n", u));
+                    break;
+                } else if (pv[u].sibling >= 0) {
+                    u = pv[u].sibling;
+                    debug(("    sideways to %d\n", u));
+                } else {
+                    u = pv[u].parent;
+                    debug(("    ascending to %d\n", u));
+                }
+            }
+        }
+    }
+
+    /*
+     * Second pass: index all the vertices in such a way that every
+     * subtree has a contiguous range of indices. (Easily enough done,
+     * by iterating through the tree structure we just built and
+     * numbering its elements as if they were those of a sorted list.)
+     *
+     * For each vertex, we compute the min and max index of the
+     * subtree starting there.
+     *
+     * (We index the vertices in preorder, per Tarjan's original
+     * description, so that each vertex's min subtree index is its own
+     * index; but that doesn't actually matter; either way round would
+     * do. The important thing is that we have a simple arithmetic
+     * criterion that tells us whether a vertex is in a given subtree
+     * or not.)
+     */
+    debug(("--- begin indexing pass\n"));
+    index = 0;
+    for (v = 0; v < nvertices; v++)
+        pv[v].visited = FALSE;
+    pv[root].visited = TRUE;
+    u = pv[root].child;
+    while (1) {
+        if (!pv[u].visited) {
+            pv[u].visited = TRUE;
+
+            /*
+             * Index this node.
+             */
+            pv[u].minindex = pv[u].index = index;
+            debug(("  vertex %d <- index %d\n", u, index));
+            index++;
+
+            /*
+             * Now descend in depth-first search.
+             */
+            if (pv[u].child >= 0) {
+                u = pv[u].child;
+                debug(("    descending to %d\n", u));
+                continue;
+            }
+        }
+
+        if (u == root) {
+            debug(("      back at %d, done indexing\n", u));
+            break;
+        }
+
+        /*
+         * As we re-ascend to here from its children (or find that we
+         * had no children to descend to in the first place), fill in
+         * its maxindex field.
+         */
+        pv[u].maxindex = index-1;
+        debug(("  vertex %d <- maxindex %d\n", u, pv[u].maxindex));
+
+        if (pv[u].sibling >= 0) {
+            u = pv[u].sibling;
+            debug(("    sideways to %d\n", u));
+        } else {
+            u = pv[u].parent;
+            debug(("    ascending to %d\n", u));
+        }
+    }
+
+    /*
+     * We're ready to generate output now, so initialise the output
+     * fields.
+     */
+    for (v = 0; v < nvertices; v++)
+        pv[v].bridge = -1;
+
+    /*
+     * Final pass: determine the min and max index of the vertices
+     * reachable from every subtree, not counting the link back to
+     * each vertex's parent. Then our criterion is: given a vertex u,
+     * defining a subtree consisting of u and all its descendants, we
+     * compare the range of vertex indices _in_ that subtree (which is
+     * just the minindex and maxindex of u) with the range of vertex
+     * indices in the _neighbourhood_ of the subtree (computed in this
+     * final pass, and not counting u's own edge to its parent), and
+     * if the latter includes anything outside the former, then there
+     * must be some path from u to outside its subtree which does not
+     * go through the parent edge - i.e. the edge from u to its parent
+     * is part of a loop.
+     */
+    debug(("--- begin min-max pass\n"));
+    nbridges = 0;
+    for (v = 0; v < nvertices; v++)
+        pv[v].visited = FALSE;
+    u = pv[root].child;
+    pv[root].visited = TRUE;
+    while (1) {
+        if (!pv[u].visited) {
+            pv[u].visited = TRUE;
+
+            /*
+             * Look for vertices reachable directly from u, including
+             * u itself.
+             */
+            debug(("  processing vertex %d\n", u));
+            pv[u].minreachable = pv[u].maxreachable = pv[u].minindex;
+            for (w = neighbour(u, ctx); w >= 0; w = neighbour(-1, ctx)) {
+                debug(("    edge %d-%d\n", u, w));
+                if (w != pv[u].parent) {
+                    int i = pv[w].index;
+                    if (pv[u].minreachable > i)
+                        pv[u].minreachable = i;
+                    if (pv[u].maxreachable < i)
+                        pv[u].maxreachable = i;
+                }
+            }
+            debug(("    initial min=%d max=%d\n",
+                   pv[u].minreachable, pv[u].maxreachable));
+
+            /*
+             * Now descend in depth-first search.
+             */
+            if (pv[u].child >= 0) {
+                u = pv[u].child;
+                debug(("    descending to %d\n", u));
+                continue;
+            }
+        }
+
+        if (u == root) {
+            debug(("      back at %d, done min-maxing\n", u));
+            break;
+        }
+
+        /*
+         * As we re-ascend to this vertex, go back through its
+         * immediate children and do a post-update of its min/max.
+         */
+        for (v = pv[u].child; v >= 0; v = pv[v].sibling) {
+            if (pv[u].minreachable > pv[v].minreachable)
+                pv[u].minreachable = pv[v].minreachable;
+            if (pv[u].maxreachable < pv[v].maxreachable)
+                pv[u].maxreachable = pv[v].maxreachable;
+        }
+
+        debug(("  postorder update of %d: min=%d max=%d (indices %d-%d)\n", u,
+               pv[u].minreachable, pv[u].maxreachable,
+               pv[u].minindex, pv[u].maxindex));
+
+        /*
+         * And now we know whether each to our own parent is a bridge.
+         */
+        if ((v = pv[u].parent) != root) {
+            if (pv[u].minreachable >= pv[u].minindex &&
+                pv[u].maxreachable <= pv[u].maxindex) {
+                /* Yes, it's a bridge. */
+                pv[u].bridge = v;
+                nbridges++;
+                debug(("  %d-%d is a bridge\n", v, u));
+            } else {
+                debug(("  %d-%d is not a bridge\n", v, u));
+            }
+        }
+
+        if (pv[u].sibling >= 0) {
+            u = pv[u].sibling;
+            debug(("    sideways to %d\n", u));
+        } else {
+            u = pv[u].parent;
+            debug(("    ascending to %d\n", u));
+        }
+    }
+
+    debug(("finished, nedges=%d nbridges=%d\n", nedges, nbridges));
+
+    /*
+     * Done.
+     */
+    return nbridges < nedges;
+}
+
+/*
+ * Appendix: the long and painful history of loop detection in these puzzles
+ * =========================================================================
+ *
+ * For interest, I thought I'd write up the five loop-finding methods
+ * I've gone through before getting to this algorithm. It's a case
+ * study in all the ways you can solve this particular problem
+ * wrongly, and also how much effort you can waste by not managing to
+ * find the existing solution in the literature :-(
+ *
+ * Vertex dsf
+ * ----------
+ *
+ * Initially, in puzzles where you need to not have any loops in the
+ * solution graph, I detected them by using a dsf to track connected
+ * components of vertices. Iterate over each edge unifying the two
+ * vertices it connects; but before that, check if the two vertices
+ * are _already_ known to be connected. If so, then the new edge is
+ * providing a second path between them, i.e. a loop exists.
+ *
+ * That's adequate for automated solvers, where you just need to know
+ * _whether_ a loop exists, so as to rule out that move and do
+ * something else. But during play, you want to do better than that:
+ * you want to _point out_ the loops with error highlighting.
+ *
+ * Graph pruning
+ * -------------
+ *
+ * So my second attempt worked by iteratively pruning the graph. Find
+ * a vertex with degree 1; remove that edge; repeat until you can't
+ * find such a vertex any more. This procedure will remove *every*
+ * edge of the graph if and only if there were no loops; so if there
+ * are any edges remaining, highlight them.
+ *
+ * This successfully highlights loops, but not _only_ loops. If the
+ * graph contains a 'dumb-bell' shaped subgraph consisting of two
+ * loops connected by a path, then we'll end up highlighting the
+ * connecting path as well as the loops. That's not what we wanted.
+ *
+ * Vertex dsf with ad-hoc loop tracing
+ * -----------------------------------
+ *
+ * So my third attempt was to go back to the dsf strategy, only this
+ * time, when you detect that a particular edge connects two
+ * already-connected vertices (and hence is part of a loop), you try
+ * to trace round that loop to highlight it - before adding the new
+ * edge, search for a path between its endpoints among the edges the
+ * algorithm has already visited, and when you find one (which you
+ * must), highlight the loop consisting of that path plus the new
+ * edge.
+ *
+ * This solves the dumb-bell problem - we definitely now cannot
+ * accidentally highlight any edge that is *not* part of a loop. But
+ * it's far from clear that we'll highlight *every* edge that *is*
+ * part of a loop - what if there were multiple paths between the two
+ * vertices? It would be difficult to guarantee that we'd always catch
+ * every single one.
+ *
+ * On the other hand, it is at least guaranteed that we'll highlight
+ * _something_ if any loop exists, and in other error highlighting
+ * situations (see in particular the Tents connected component
+ * analysis) I've been known to consider that sufficient. So this
+ * version hung around for quite a while, until I had a better idea.
+ *
+ * Face dsf
+ * --------
+ *
+ * Round about the time Loopy was being revamped to include non-square
+ * grids, I had a much cuter idea, making use of the fact that the
+ * graph is planar, and hence has a concept of faces.
+ *
+ * In Loopy, there are really two graphs: the 'grid', consisting of
+ * all the edges that the player *might* fill in, and the solution
+ * graph of the edges the player actually *has* filled in. The
+ * algorithm is: set up a dsf on the *faces* of the grid. Iterate over
+ * each edge of the grid which is _not_ marked by the player as an
+ * edge of the solution graph, unifying the faces on either side of
+ * that edge. This groups the faces into connected components. Now,
+ * there is more than one connected component iff a loop exists, and
+ * moreover, an edge of the solution graph is part of a loop iff the
+ * faces on either side of it are in different connected components!
+ *
+ * This is the first algorithm I came up with that I was confident
+ * would successfully highlight exactly the correct set of edges in
+ * all cases. It's also conceptually elegant, and very easy to
+ * implement and to be confident you've got it right (since it just
+ * consists of two very simple loops over the edge set, one building
+ * the dsf and one reading it off). I was very pleased with it.
+ *
+ * Doing the same thing in Slant is slightly more difficult because
+ * the set of edges the user can fill in do not form a planar graph
+ * (the two potential edges in each square cross in the middle). But
+ * you can still apply the same principle by considering the 'faces'
+ * to be diamond-shaped regions of space around each horizontal or
+ * vertical grid line. Equivalently, pretend each edge added by the
+ * player is really divided into two edges, each from a square-centre
+ * to one of the square's corners, and now the grid graph is planar
+ * again.
+ *
+ * However, it fell down when - much later - I tried to implement the
+ * same algorithm in Net.
+ *
+ * Net doesn't *absolutely need* loop detection, because of its system
+ * of highlighting squares connected to the source square: an argument
+ * involving counting vertex degrees shows that if any loop exists,
+ * then it must be counterbalanced by some disconnected square, so
+ * there will be _some_ error highlight in any invalid grid even
+ * without loop detection. However, in large complicated cases, it's
+ * still nice to highlight the loop itself, so that once the player is
+ * clued in to its existence by a disconnected square elsewhere, they
+ * don't have to spend forever trying to find it.
+ *
+ * The new wrinkle in Net, compared to other loop-disallowing puzzles,
+ * is that it can be played with wrapping walls, or - topologically
+ * speaking - on a torus. And a torus has a property that algebraic
+ * topologists would know of as a 'non-trivial H_1 homology group',
+ * which essentially means that there can exist a loop on a torus
+ * which *doesn't* separate the surface into two regions disconnected
+ * from each other.
+ *
+ * In other words, using this algorithm in Net will do fine at finding
+ * _small_ localised loops, but a large-scale loop that goes (say) off
+ * the top of the grid, back on at the bottom, and meets up in the
+ * middle again will not be detected.
+ *
+ * Footpath dsf
+ * ------------
+ *
+ * To solve this homology problem in Net, I hastily thought up another
+ * dsf-based algorithm.
+ *
+ * This time, let's consider each edge of the graph to be a road, with
+ * a separate pedestrian footpath down each side. We'll form a dsf on
+ * those imaginary segments of footpath.
+ *
+ * At each vertex of the graph, we go round the edges leaving that
+ * vertex, in order around the vertex. For each pair of edges adjacent
+ * in this order, we unify their facing pair of footpaths (e.g. if
+ * edge E appears anticlockwise of F, then we unify the anticlockwise
+ * footpath of F with the clockwise one of E) . In particular, if a
+ * vertex has degree 1, then the two footpaths on either side of its
+ * single edge are unified.
+ *
+ * Then, an edge is part of a loop iff its two footpaths are not
+ * reachable from one another.
+ *
+ * This algorithm is almost as simple to implement as the face dsf,
+ * and it works on a wider class of graphs embedded in plane-like
+ * surfaces; in particular, it fixes the torus bug in the face-dsf
+ * approach. However, it still depends on the graph having _some_ sort
+ * of embedding in a 2-manifold, because it relies on there being a
+ * meaningful notion of 'order of edges around a vertex' in the first
+ * place, so you couldn't use it on a wildly nonplanar graph like the
+ * diamond lattice. Also, more subtly, it depends on the graph being
+ * embedded in an _orientable_ surface - and that's a thing that might
+ * much more plausibly change in future puzzles, because it's not at
+ * all unlikely that at some point I might feel moved to implement a
+ * puzzle that can be played on the surface of a Mobius strip or a
+ * Klein bottle. And then even this algorithm won't work.
+ *
+ * Tarjan's bridge-finding algorithm
+ * ---------------------------------
+ *
+ * And so, finally, we come to the algorithm above. This one is pure
+ * graph theory: it doesn't depend on any concept of 'faces', or 'edge
+ * ordering around a vertex', or any other trapping of a planar or
+ * quasi-planar graph embedding. It should work on any graph
+ * whatsoever, and reliably identify precisely the set of edges that
+ * form part of some loop. So *hopefully* this long string of failures
+ * has finally come to an end...
+ */
diff --git a/apps/plugins/puzzles/flip.R b/apps/plugins/puzzles/flip.R
new file mode 100644
index 0000000000..03241f015b
--- /dev/null
+++ b/apps/plugins/puzzles/flip.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+FLIP_EXTRA = tree234
+
+flip     : [X] GTK COMMON flip FLIP_EXTRA flip-icon|no-icon
+
+flip     : [G] WINDOWS COMMON flip FLIP_EXTRA flip.res|noicon.res
+
+ALL += flip[COMBINED] FLIP_EXTRA
+
+!begin am gtk
+GAMES += flip
+!end
+
+!begin >list.c
+    A(flip) \
+!end
+
+!begin >gamedesc.txt
+flip:flip.exe:Flip:Tile inversion puzzle:Flip groups of squares to light them all up at once.
+!end
diff --git a/apps/plugins/puzzles/flip.c b/apps/plugins/puzzles/flip.c
new file mode 100644
index 0000000000..ffa6c07c94
--- /dev/null
+++ b/apps/plugins/puzzles/flip.c
@@ -0,0 +1,1349 @@
+/*
+ * flip.c: Puzzle involving lighting up all the squares on a grid,
+ * where each click toggles an overlapping set of lights.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+
+enum {
+    COL_BACKGROUND,
+    COL_WRONG,
+    COL_RIGHT,
+    COL_GRID,
+    COL_DIAG,
+    COL_HINT,
+    COL_CURSOR,
+    NCOLOURS
+};
+
+#define PREFERRED_TILE_SIZE 48
+#define TILE_SIZE (ds->tilesize)
+#define BORDER    (TILE_SIZE / 2)
+#define COORD(x)  ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
+
+#define ANIM_TIME 0.25F
+#define FLASH_FRAME 0.07F
+
+/*
+ * Possible ways to decide which lights are toggled by each click.
+ * Essentially, each of these describes a means of inventing a
+ * matrix over GF(2).
+ */
+enum {
+    CROSSES, RANDOM
+};
+
+struct game_params {
+    int w, h;
+    int matrix_type;
+};
+
+/*
+ * This structure is shared between all the game_states describing
+ * a particular game, so it's reference-counted.
+ */
+struct matrix {
+    int refcount;
+    unsigned char *matrix;             /* array of (w*h) by (w*h) */
+};
+
+struct game_state {
+    int w, h;
+    int moves, completed, cheated, hints_active;
+    unsigned char *grid;               /* array of w*h */
+    struct matrix *matrix;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 5;
+    ret->matrix_type = CROSSES;
+
+    return ret;
+}
+
+static const struct game_params flip_presets[] = {
+    {3, 3, CROSSES},
+    {4, 4, CROSSES},
+    {5, 5, CROSSES},
+    {3, 3, RANDOM},
+    {4, 4, RANDOM},
+    {5, 5, RANDOM},
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(flip_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = flip_presets[i];
+
+    sprintf(str, "%dx%d %s", ret->w, ret->h,
+            ret->matrix_type == CROSSES ? "Crosses" : "Random");
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        ret->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 'r') {
+        string++;
+        ret->matrix_type = RANDOM;
+    } else if (*string == 'c') {
+        string++;
+        ret->matrix_type = CROSSES;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    sprintf(data, "%dx%d%s", params->w, params->h,
+            !full ? "" : params->matrix_type == CROSSES ? "c" : "r");
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret = snewn(4, config_item);
+    char buf[80];
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Shape type";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = ":Crosses:Random";
+    ret[2].ival = params->matrix_type;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->matrix_type = cfg[2].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w <= 0 || params->h <= 0)
+        return "Width and height must both be greater than zero";
+    return NULL;
+}
+
+static char *encode_bitmap(unsigned char *bmp, int len)
+{
+    int slen = (len + 3) / 4;
+    char *ret;
+    int i;
+
+    ret = snewn(slen + 1, char);
+    for (i = 0; i < slen; i++) {
+        int j, v;
+        v = 0;
+        for (j = 0; j < 4; j++)
+            if (i*4+j < len && bmp[i*4+j])
+                v |= 8 >> j;
+        ret[i] = "0123456789abcdef"[v];
+    }
+    ret[slen] = '\0';
+    return ret;
+}
+
+static void decode_bitmap(unsigned char *bmp, int len, const char *hex)
+{
+    int slen = (len + 3) / 4;
+    int i;
+
+    for (i = 0; i < slen; i++) {
+        int j, v, c = hex[i];
+        if (c >= '0' && c <= '9')
+            v = c - '0';
+        else if (c >= 'A' && c <= 'F')
+            v = c - 'A' + 10;
+        else if (c >= 'a' && c <= 'f')
+            v = c - 'a' + 10;
+        else
+            v = 0;                     /* shouldn't happen */
+        for (j = 0; j < 4; j++) {
+            if (i*4+j < len) {
+                if (v & (8 >> j))
+                    bmp[i*4+j] = 1;
+                else
+                    bmp[i*4+j] = 0;
+            }
+        }
+    }
+}
+
+/*
+ * Structure used during random matrix generation, and a compare
+ * function to permit storage in a tree234.
+ */
+struct sq {
+    int cx, cy;                        /* coords of click square */
+    int x, y;                          /* coords of output square */
+    /*
+     * Number of click squares which currently affect this output
+     * square.
+     */
+    int coverage;
+    /*
+     * Number of output squares currently affected by this click
+     * square.
+     */
+    int ominosize;
+};
+#define SORT(field) do { \
+    if (a->field < b->field) \
+        return -1; \
+    else if (a->field > b->field) \
+        return +1; \
+} while (0)
+/*
+ * Compare function for choosing the next square to add. We must
+ * sort by coverage, then by omino size, then everything else.
+ */
+static int sqcmp_pick(void *av, void *bv)
+{
+    struct sq *a = (struct sq *)av;
+    struct sq *b = (struct sq *)bv;
+    SORT(coverage);
+    SORT(ominosize);
+    SORT(cy);
+    SORT(cx);
+    SORT(y);
+    SORT(x);
+    return 0;
+}
+/*
+ * Compare function for adjusting the coverage figures after a
+ * change. We sort first by coverage and output square, then by
+ * everything else.
+ */
+static int sqcmp_cov(void *av, void *bv)
+{
+    struct sq *a = (struct sq *)av;
+    struct sq *b = (struct sq *)bv;
+    SORT(coverage);
+    SORT(y);
+    SORT(x);
+    SORT(ominosize);
+    SORT(cy);
+    SORT(cx);
+    return 0;
+}
+/*
+ * Compare function for adjusting the omino sizes after a change.
+ * We sort first by omino size and input square, then by everything
+ * else.
+ */
+static int sqcmp_osize(void *av, void *bv)
+{
+    struct sq *a = (struct sq *)av;
+    struct sq *b = (struct sq *)bv;
+    SORT(ominosize);
+    SORT(cy);
+    SORT(cx);
+    SORT(coverage);
+    SORT(y);
+    SORT(x);
+    return 0;
+}
+static void addsq(tree234 *t, int w, int h, int cx, int cy,
+                  int x, int y, unsigned char *matrix)
+{
+    int wh = w * h;
+    struct sq *sq;
+    int i;
+
+    if (x < 0 || x >= w || y < 0 || y >= h)
+        return;
+    if (abs(x-cx) > 1 || abs(y-cy) > 1)
+        return;
+    if (matrix[(cy*w+cx) * wh + y*w+x])
+        return;
+
+    sq = snew(struct sq);
+    sq->cx = cx;
+    sq->cy = cy;
+    sq->x = x;
+    sq->y = y;
+    sq->coverage = sq->ominosize = 0;
+    for (i = 0; i < wh; i++) {
+        if (matrix[i * wh + y*w+x])
+            sq->coverage++;
+        if (matrix[(cy*w+cx) * wh + i])
+            sq->ominosize++;
+    }
+
+    if (add234(t, sq) != sq)
+        sfree(sq);                     /* already there */
+}
+static void addneighbours(tree234 *t, int w, int h, int cx, int cy,
+                          int x, int y, unsigned char *matrix)
+{
+    addsq(t, w, h, cx, cy, x-1, y, matrix);
+    addsq(t, w, h, cx, cy, x+1, y, matrix);
+    addsq(t, w, h, cx, cy, x, y-1, matrix);
+    addsq(t, w, h, cx, cy, x, y+1, matrix);
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, h = params->h, wh = w * h;
+    int i, j;
+    unsigned char *matrix, *grid;
+    char *mbmp, *gbmp, *ret;
+
+    matrix = snewn(wh * wh, unsigned char);
+    grid = snewn(wh, unsigned char);
+
+    /*
+     * First set up the matrix.
+     */
+    switch (params->matrix_type) {
+      case CROSSES:
+        for (i = 0; i < wh; i++) {
+            int ix = i % w, iy = i / w;
+            for (j = 0; j < wh; j++) {
+                int jx = j % w, jy = j / w;
+                if (abs(jx - ix) + abs(jy - iy) <= 1)
+                    matrix[i*wh+j] = 1;
+                else
+                    matrix[i*wh+j] = 0;
+            }
+        }
+        break;
+      case RANDOM:
+        while (1) {
+            tree234 *pick, *cov, *osize;
+            int limit;
+
+            pick = newtree234(sqcmp_pick);
+            cov = newtree234(sqcmp_cov);
+            osize = newtree234(sqcmp_osize);
+
+            memset(matrix, 0, wh * wh);
+            for (i = 0; i < wh; i++) {
+                matrix[i*wh+i] = 1;
+            }
+
+            for (i = 0; i < wh; i++) {
+                int ix = i % w, iy = i / w;
+                addneighbours(pick, w, h, ix, iy, ix, iy, matrix);
+                addneighbours(cov, w, h, ix, iy, ix, iy, matrix);
+                addneighbours(osize, w, h, ix, iy, ix, iy, matrix);
+            }
+
+            /*
+             * Repeatedly choose a square to add to the matrix,
+             * until we have enough. I'll arbitrarily choose our
+             * limit to be the same as the total number of set bits
+             * in the crosses matrix.
+             */
+            limit = 4*wh - 2*(w+h);    /* centre squares already present */
+
+            while (limit-- > 0) {
+                struct sq *sq, *sq2, sqlocal;
+                int k;
+
+                /*
+                 * Find the lowest element in the pick tree.
+                 */
+                sq = index234(pick, 0);
+
+                /*
+                 * Find the highest element with the same coverage
+                 * and omino size, by setting all other elements to
+                 * lots.
+                 */
+                sqlocal = *sq;
+                sqlocal.cx = sqlocal.cy = sqlocal.x = sqlocal.y = wh;
+                sq = findrelpos234(pick, &sqlocal, NULL, REL234_LT, &k);
+                assert(sq != 0);
+
+                /*
+                 * Pick at random from all elements up to k of the
+                 * pick tree.
+                 */
+                k = random_upto(rs, k+1);
+                sq = delpos234(pick, k);
+                del234(cov, sq);
+                del234(osize, sq);
+
+                /*
+                 * Add this square to the matrix.
+                 */
+                matrix[(sq->cy * w + sq->cx) * wh + (sq->y * w + sq->x)] = 1;
+
+                /*
+                 * Correct the matrix coverage field of any sq
+                 * which points at this output square.
+                 */
+                sqlocal = *sq;
+                sqlocal.cx = sqlocal.cy = sqlocal.ominosize = -1;
+                while ((sq2 = findrel234(cov, &sqlocal, NULL,
+                                         REL234_GT)) != NULL &&
+                       sq2->coverage == sq->coverage &&
+                       sq2->x == sq->x && sq2->y == sq->y) {
+                    del234(pick, sq2);
+                    del234(cov, sq2);
+                    del234(osize, sq2);
+                    sq2->coverage++;
+                    add234(pick, sq2);
+                    add234(cov, sq2);
+                    add234(osize, sq2);
+                }
+
+                /*
+                 * Correct the omino size field of any sq which
+                 * points at this input square.
+                 */
+                sqlocal = *sq;
+                sqlocal.x = sqlocal.y = sqlocal.coverage = -1;
+                while ((sq2 = findrel234(osize, &sqlocal, NULL,
+                                         REL234_GT)) != NULL &&
+                       sq2->ominosize == sq->ominosize &&
+                       sq2->cx == sq->cx && sq2->cy == sq->cy) {
+                    del234(pick, sq2);
+                    del234(cov, sq2);
+                    del234(osize, sq2);
+                    sq2->ominosize++;
+                    add234(pick, sq2);
+                    add234(cov, sq2);
+                    add234(osize, sq2);
+                }
+
+                /*
+                 * The sq we actually picked out of the tree is
+                 * finished with; but its neighbours now need to
+                 * appear.
+                 */
+                addneighbours(pick, w,h, sq->cx,sq->cy, sq->x,sq->y, matrix);
+                addneighbours(cov, w,h, sq->cx,sq->cy, sq->x,sq->y, matrix);
+                addneighbours(osize, w,h, sq->cx,sq->cy, sq->x,sq->y, matrix);
+                sfree(sq);
+            }
+
+            /*
+             * Free all remaining sq structures.
+             */
+            {
+                struct sq *sq;
+                while ((sq = delpos234(pick, 0)) != NULL)
+                    sfree(sq);
+            }
+            freetree234(pick);
+            freetree234(cov);
+            freetree234(osize);
+
+            /*
+             * Finally, check to see if any two matrix rows are
+             * exactly identical. If so, this is not an acceptable
+             * matrix, and we give up and go round again.
+             * 
+             * I haven't been immediately able to think of a
+             * plausible means of algorithmically avoiding this
+             * situation (by, say, making a small perturbation to
+             * an offending matrix), so for the moment I'm just
+             * going to deal with it by throwing the whole thing
+             * away. I suspect this will lead to scalability
+             * problems (since most of the things happening in
+             * these matrices are local, the chance of _some_
+             * neighbourhood having two identical regions will
+             * increase with the grid area), but so far this puzzle
+             * seems to be really hard at large sizes so I'm not
+             * massively worried yet. Anyone needs this done
+             * better, they're welcome to submit a patch.
+             */
+            for (i = 0; i < wh; i++) {
+                for (j = 0; j < wh; j++)
+                    if (i != j &&
+                        !memcmp(matrix + i * wh, matrix + j * wh, wh))
+                        break;
+                if (j < wh)
+                    break;
+            }
+            if (i == wh)
+                break;                 /* no matches found */
+        }
+        break;
+    }
+
+    /*
+     * Now invent a random initial set of lights.
+     * 
+     * At first glance it looks as if it might be quite difficult
+     * to choose equiprobably from all soluble light sets. After
+     * all, soluble light sets are those in the image space of the
+     * transformation matrix; so first we'd have to identify that
+     * space and its dimension, then pick a random coordinate for
+     * each basis vector and recombine. Lot of fiddly matrix
+     * algebra there.
+     * 
+     * However, vector spaces are nicely orthogonal and relieve us
+     * of all that difficulty. For every point in the image space,
+     * there are precisely as many points in the input space that
+     * map to it as there are elements in the kernel of the
+     * transformation matrix (because adding any kernel element to
+     * the input does not change the output, and because any two
+     * inputs mapping to the same output must differ by an element
+     * of the kernel because that's what the kernel _is_); and
+     * these cosets are all disjoint (obviously, since no input
+     * point can map to more than one output point) and cover the
+     * whole space (equally obviously, because no input point can
+     * map to fewer than one output point!).
+     *
+     * So the input space contains the same number of points for
+     * each point in the output space; thus, we can simply choose
+     * equiprobably from elements of the _input_ space, and filter
+     * the result through the transformation matrix in the obvious
+     * way, and we thereby guarantee to choose equiprobably from
+     * all the output points. Phew!
+     */
+    while (1) {
+        memset(grid, 0, wh);
+        for (i = 0; i < wh; i++) {
+            int v = random_upto(rs, 2);
+            if (v) {
+                for (j = 0; j < wh; j++)
+                    grid[j] ^= matrix[i*wh+j];
+            }
+        }
+        /*
+         * Ensure we don't have the starting state already!
+         */
+        for (i = 0; i < wh; i++)
+            if (grid[i])
+                break;
+        if (i < wh)
+            break;
+    }
+
+    /*
+     * Now encode the matrix and the starting grid as a game
+     * description. We'll do this by concatenating two great big
+     * hex bitmaps.
+     */
+    mbmp = encode_bitmap(matrix, wh*wh);
+    gbmp = encode_bitmap(grid, wh);
+    ret = snewn(strlen(mbmp) + strlen(gbmp) + 2, char);
+    sprintf(ret, "%s,%s", mbmp, gbmp);
+    sfree(mbmp);
+    sfree(gbmp);
+    sfree(matrix);
+    sfree(grid);
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, h = params->h, wh = w * h;
+    int mlen = (wh*wh+3)/4, glen = (wh+3)/4;
+
+    if (strspn(desc, "0123456789abcdefABCDEF") != mlen)
+        return "Matrix description is wrong length";
+    if (desc[mlen] != ',')
+        return "Expected comma after matrix description";
+    if (strspn(desc+mlen+1, "0123456789abcdefABCDEF") != glen)
+        return "Grid description is wrong length";
+    if (desc[mlen+1+glen])
+        return "Unexpected data after grid description";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, h = params->h, wh = w * h;
+    int mlen = (wh*wh+3)/4;
+
+    game_state *state = snew(game_state);
+
+    state->w = w;
+    state->h = h;
+    state->completed = FALSE;
+    state->cheated = FALSE;
+    state->hints_active = FALSE;
+    state->moves = 0;
+    state->matrix = snew(struct matrix);
+    state->matrix->refcount = 1;
+    state->matrix->matrix = snewn(wh*wh, unsigned char);
+    decode_bitmap(state->matrix->matrix, wh*wh, desc);
+    state->grid = snewn(wh, unsigned char);
+    decode_bitmap(state->grid, wh, desc + mlen + 1);
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+    ret->hints_active = state->hints_active;
+    ret->moves = state->moves;
+    ret->matrix = state->matrix;
+    state->matrix->refcount++;
+    ret->grid = snewn(ret->w * ret->h, unsigned char);
+    memcpy(ret->grid, state->grid, ret->w * ret->h);
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    if (--state->matrix->refcount <= 0) {
+        sfree(state->matrix->matrix);
+        sfree(state->matrix);
+    }
+    sfree(state);
+}
+
+static void rowxor(unsigned char *row1, unsigned char *row2, int len)
+{
+    int i;
+    for (i = 0; i < len; i++)
+        row1[i] ^= row2[i];
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int w = state->w, h = state->h, wh = w * h;
+    unsigned char *equations, *solution, *shortest;
+    int *und, nund;
+    int rowsdone, colsdone;
+    int i, j, k, len, bestlen;
+    char *ret;
+
+    /*
+     * Set up a list of simultaneous equations. Each one is of
+     * length (wh+1) and has wh coefficients followed by a value.
+     */
+    equations = snewn((wh + 1) * wh, unsigned char);
+    for (i = 0; i < wh; i++) {
+        for (j = 0; j < wh; j++)
+            equations[i * (wh+1) + j] = currstate->matrix->matrix[j*wh+i];
+        equations[i * (wh+1) + wh] = currstate->grid[i] & 1;
+    }
+
+    /*
+     * Perform Gaussian elimination over GF(2).
+     */
+    rowsdone = colsdone = 0;
+    nund = 0;
+    und = snewn(wh, int);
+    do {
+        /*
+         * Find the leftmost column which has a 1 in it somewhere
+         * outside the first `rowsdone' rows.
+         */
+        j = -1;
+        for (i = colsdone; i < wh; i++) {
+            for (j = rowsdone; j < wh; j++)
+                if (equations[j * (wh+1) + i])
+                    break;
+            if (j < wh)
+                break;                 /* found one */
+            /*
+             * This is a column which will not have an equation
+             * controlling it. Mark it as undetermined.
+             */
+            und[nund++] = i;
+        }
+
+        /*
+         * If there wasn't one, then we've finished: all remaining
+         * equations are of the form 0 = constant. Check to see if
+         * any of them wants 0 to be equal to 1; this is the
+         * condition which indicates an insoluble problem
+         * (therefore _hopefully_ one typed in by a user!).
+         */
+        if (i == wh) {
+            for (j = rowsdone; j < wh; j++)
+                if (equations[j * (wh+1) + wh]) {
+                    *error = "No solution exists for this position";
+                    sfree(equations);
+                    sfree(und);
+                    return NULL;
+                }
+            break;
+        }
+
+        /*
+         * We've found a 1. It's in column i, and the topmost 1 in
+         * that column is in row j. Do a row-XOR to move it up to
+         * the topmost row if it isn't already there.
+         */
+        assert(j != -1);
+        if (j > rowsdone)
+            rowxor(equations + rowsdone*(wh+1), equations + j*(wh+1), wh+1);
+
+        /*
+         * Do row-XORs to eliminate that 1 from all rows below the
+         * topmost row.
+         */
+        for (j = rowsdone + 1; j < wh; j++)
+            if (equations[j*(wh+1) + i])
+                rowxor(equations + j*(wh+1),
+                       equations + rowsdone*(wh+1), wh+1);
+
+        /*
+         * Mark this row and column as done.
+         */
+        rowsdone++;
+        colsdone = i+1;
+
+        /*
+         * If we've done all the rows, terminate.
+         */
+    } while (rowsdone < wh);
+
+    /*
+     * If we reach here, we have the ability to produce a solution.
+     * So we go through _all_ possible solutions (each
+     * corresponding to a set of arbitrary choices of those
+     * components not directly determined by an equation), and pick
+     * one requiring the smallest number of flips.
+     */
+    solution = snewn(wh, unsigned char);
+    shortest = snewn(wh, unsigned char);
+    memset(solution, 0, wh);
+    bestlen = wh + 1;
+    while (1) {
+        /*
+         * Find a solution based on the current values of the
+         * undetermined variables.
+         */
+        for (j = rowsdone; j-- ;) {
+            int v;
+
+            /*
+             * Find the leftmost set bit in this equation.
+             */
+            for (i = 0; i < wh; i++)
+                if (equations[j * (wh+1) + i])
+                    break;
+            assert(i < wh);                    /* there must have been one! */
+
+            /*
+             * Compute this variable using the rest.
+             */
+            v = equations[j * (wh+1) + wh];
+            for (k = i+1; k < wh; k++)
+                if (equations[j * (wh+1) + k])
+                    v ^= solution[k];
+
+            solution[i] = v;
+        }
+
+        /*
+         * Compare this solution to the current best one, and
+         * replace the best one if this one is shorter.
+         */
+        len = 0;
+        for (i = 0; i < wh; i++)
+            if (solution[i])
+                len++;
+        if (len < bestlen) {
+            bestlen = len;
+            memcpy(shortest, solution, wh);
+        }
+
+        /*
+         * Now increment the binary number given by the
+         * undetermined variables: turn all 1s into 0s until we see
+         * a 0, at which point we turn it into a 1.
+         */
+        for (i = 0; i < nund; i++) {
+            solution[und[i]] = !solution[und[i]];
+            if (solution[und[i]])
+                break;
+        }
+
+        /*
+         * If we didn't find a 0 at any point, we have wrapped
+         * round and are back at the start, i.e. we have enumerated
+         * all solutions.
+         */
+        if (i == nund)
+            break;
+    }
+
+    /*
+     * We have a solution. Produce a move string encoding the
+     * solution.
+     */
+    ret = snewn(wh + 2, char);
+    ret[0] = 'S';
+    for (i = 0; i < wh; i++)
+        ret[i+1] = shortest[i] ? '1' : '0';
+    ret[wh+1] = '\0';
+
+    sfree(shortest);
+    sfree(solution);
+    sfree(equations);
+    sfree(und);
+
+    return ret;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+#define RIGHT 1
+#define DOWN gw
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->w, h = state->h, wh = w*h, r, c, dx, dy;
+    int cw = 4, ch = 4, gw = w * cw + 2, gh = h * ch + 1, len = gw * gh;
+    char *board = snewn(len + 1, char);
+
+    memset(board, ' ', len - 1);
+
+    for (r = 0; r < h; ++r) {
+        for (c = 0; c < w; ++c) {
+            int cell = r*ch*gw + c*cw, center = cell+(ch/2)*DOWN + cw/2*RIGHT;
+            char flip = (state->grid[r*w + c] & 1) ? '#' : '.';
+            for (dy = -1 + (r == 0); dy <= 1 - (r == h - 1); ++dy)
+                for (dx = -1 + (c == 0); dx <= 1 - (c == w - 1); ++dx)
+                    if (state->matrix->matrix[(r*w+c)*wh + ((r+dy)*w + c+dx)])
+                        board[center + dy*DOWN + dx*RIGHT] = flip;
+            board[cell] = '+';
+            for (dx = 1; dx < cw; ++dx) board[cell+dx*RIGHT] = '-';
+            for (dy = 1; dy < ch; ++dy) board[cell+dy*DOWN] = '|';
+        }
+        board[r*ch*gw + gw - 2] = '+';
+        board[r*ch*gw + gw - 1] = '\n';
+        for (dy = 1; dy < ch; ++dy) {
+            board[r*ch*gw + gw - 2 + dy*DOWN] = '|';
+            board[r*ch*gw + gw - 1 + dy*DOWN] = '\n';
+        }
+    }
+    memset(board + len - gw, '-', gw - 2);
+    for (c = 0; c <= w; ++c) board[len - gw + cw*c] = '+';
+    board[len - 1] = '\n';
+    board[len] = '\0';
+    return board;
+}
+
+#undef RIGHT
+#undef DOWN
+
+struct game_ui {
+    int cx, cy, cdraw;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->cx = ui->cy = ui->cdraw = 0;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int w, h, started;
+    unsigned char *tiles;
+    int tilesize;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->w, h = state->h, wh = w * h;
+    char buf[80], *nullret = NULL;
+
+    if (button == LEFT_BUTTON || IS_CURSOR_SELECT(button)) {
+        int tx, ty;
+        if (button == LEFT_BUTTON) {
+            tx = FROMCOORD(x), ty = FROMCOORD(y);
+            ui->cdraw = 0;
+        } else {
+            tx = ui->cx; ty = ui->cy;
+            ui->cdraw = 1;
+        }
+        nullret = "";
+
+        if (tx >= 0 && tx < w && ty >= 0 && ty < h) {
+            /*
+             * It's just possible that a manually entered game ID
+             * will have at least one square do nothing whatsoever.
+             * If so, we avoid encoding a move at all.
+             */
+            int i = ty*w+tx, j, makemove = FALSE;
+            for (j = 0; j < wh; j++) {
+                if (state->matrix->matrix[i*wh+j])
+                    makemove = TRUE;
+            }
+            if (makemove) {
+                sprintf(buf, "M%d,%d", tx, ty);
+                return dupstr(buf);
+            } else {
+                return NULL;
+            }
+        }
+    }
+    else if (IS_CURSOR_MOVE(button)) {
+        int dx = 0, dy = 0;
+        switch (button) {
+        case CURSOR_UP:         dy = -1; break;
+        case CURSOR_DOWN:       dy = 1; break;
+        case CURSOR_RIGHT:      dx = 1; break;
+        case CURSOR_LEFT:       dx = -1; break;
+        default: assert(!"shouldn't get here");
+        }
+        ui->cx += dx; ui->cy += dy;
+        ui->cx = min(max(ui->cx, 0), state->w - 1);
+        ui->cy = min(max(ui->cy, 0), state->h - 1);
+        ui->cdraw = 1;
+        nullret = "";
+    }
+
+    return nullret;
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    int w = from->w, h = from->h, wh = w * h;
+    game_state *ret;
+    int x, y;
+
+    if (move[0] == 'S' && strlen(move) == wh+1) {
+        int i;
+
+        ret = dup_game(from);
+        ret->hints_active = TRUE;
+        ret->cheated = TRUE;
+        for (i = 0; i < wh; i++) {
+            ret->grid[i] &= ~2;
+            if (move[i+1] != '0')
+                ret->grid[i] |= 2;
+        }
+        return ret;
+    } else if (move[0] == 'M' &&
+               sscanf(move+1, "%d,%d", &x, &y) == 2 &&
+        x >= 0 && x < w && y >= 0 && y < h) {
+        int i, j, done;
+
+        ret = dup_game(from);
+
+        if (!ret->completed)
+            ret->moves++;
+
+        i = y * w + x;
+
+        done = TRUE;
+        for (j = 0; j < wh; j++) {
+            ret->grid[j] ^= ret->matrix->matrix[i*wh+j];
+            if (ret->grid[j] & 1)
+                done = FALSE;
+        }
+        ret->grid[i] ^= 2;             /* toggle hint */
+        if (done) {
+            ret->completed = TRUE;
+            ret->hints_active = FALSE;
+        }
+
+        return ret;
+    } else
+        return NULL;                   /* can't parse move string */
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = TILE_SIZE * params->w + 2 * BORDER;
+    *y = TILE_SIZE * params->h + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_WRONG * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] / 3;
+    ret[COL_WRONG * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] / 3;
+    ret[COL_WRONG * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] / 3;
+
+    ret[COL_RIGHT * 3 + 0] = 1.0F;
+    ret[COL_RIGHT * 3 + 1] = 1.0F;
+    ret[COL_RIGHT * 3 + 2] = 1.0F;
+
+    ret[COL_GRID * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] / 1.5F;
+    ret[COL_GRID * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] / 1.5F;
+    ret[COL_GRID * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] / 1.5F;
+
+    ret[COL_DIAG * 3 + 0] = ret[COL_GRID * 3 + 0];
+    ret[COL_DIAG * 3 + 1] = ret[COL_GRID * 3 + 1];
+    ret[COL_DIAG * 3 + 2] = ret[COL_GRID * 3 + 2];
+
+    ret[COL_HINT * 3 + 0] = 1.0F;
+    ret[COL_HINT * 3 + 1] = 0.0F;
+    ret[COL_HINT * 3 + 2] = 0.0F;
+
+    ret[COL_CURSOR * 3 + 0] = 0.8F;
+    ret[COL_CURSOR * 3 + 1] = 0.0F;
+    ret[COL_CURSOR * 3 + 2] = 0.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->started = FALSE;
+    ds->w = state->w;
+    ds->h = state->h;
+    ds->tiles = snewn(ds->w*ds->h, unsigned char);
+    ds->tilesize = 0;                  /* haven't decided yet */
+    for (i = 0; i < ds->w*ds->h; i++)
+        ds->tiles[i] = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->tiles);
+    sfree(ds);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds, const game_state *state,
+                      int x, int y, int tile, int anim, float animtime)
+{
+    int w = ds->w, h = ds->h, wh = w * h;
+    int bx = x * TILE_SIZE + BORDER, by = y * TILE_SIZE + BORDER;
+    int i, j, dcol = (tile & 4) ? COL_CURSOR : COL_DIAG;
+
+    clip(dr, bx+1, by+1, TILE_SIZE-1, TILE_SIZE-1);
+
+    draw_rect(dr, bx+1, by+1, TILE_SIZE-1, TILE_SIZE-1,
+              anim ? COL_BACKGROUND : tile & 1 ? COL_WRONG : COL_RIGHT);
+    if (anim) {
+        /*
+         * Draw a polygon indicating that the square is diagonally
+         * flipping over.
+         */
+        int coords[8], colour;
+
+        coords[0] = bx + TILE_SIZE;
+        coords[1] = by;
+        coords[2] = bx + (int)((float)TILE_SIZE * animtime);
+        coords[3] = by + (int)((float)TILE_SIZE * animtime);
+        coords[4] = bx;
+        coords[5] = by + TILE_SIZE;
+        coords[6] = bx + TILE_SIZE - (int)((float)TILE_SIZE * animtime);
+        coords[7] = by + TILE_SIZE - (int)((float)TILE_SIZE * animtime);
+
+        colour = (tile & 1 ? COL_WRONG : COL_RIGHT);
+        if (animtime < 0.5)
+            colour = COL_WRONG + COL_RIGHT - colour;
+
+        draw_polygon(dr, coords, 4, colour, COL_GRID);
+    }
+
+    /*
+     * Draw a little diagram in the tile which indicates which
+     * surrounding tiles flip when this one is clicked.
+     */
+    for (i = 0; i < h; i++)
+        for (j = 0; j < w; j++)
+            if (state->matrix->matrix[(y*w+x)*wh + i*w+j]) {
+                int ox = j - x, oy = i - y;
+                int td = TILE_SIZE / 16;
+                int cx = (bx + TILE_SIZE/2) + (2 * ox - 1) * td;
+                int cy = (by + TILE_SIZE/2) + (2 * oy - 1) * td;
+                if (ox == 0 && oy == 0)
+                    draw_rect(dr, cx, cy, 2*td+1, 2*td+1, dcol);
+                else {
+                    draw_line(dr, cx, cy, cx+2*td, cy, dcol);
+                    draw_line(dr, cx, cy+2*td, cx+2*td, cy+2*td, dcol);
+                    draw_line(dr, cx, cy, cx, cy+2*td, dcol);
+                    draw_line(dr, cx+2*td, cy, cx+2*td, cy+2*td, dcol);
+                }
+            }
+
+    /*
+     * Draw a hint rectangle if required.
+     */
+    if (tile & 2) {
+        int x1 = bx + TILE_SIZE / 20, x2 = bx + TILE_SIZE - TILE_SIZE / 20;
+        int y1 = by + TILE_SIZE / 20, y2 = by + TILE_SIZE - TILE_SIZE / 20;
+        int i = 3;
+        while (i--) {
+            draw_line(dr, x1, y1, x2, y1, COL_HINT);
+            draw_line(dr, x1, y2, x2, y2, COL_HINT);
+            draw_line(dr, x1, y1, x1, y2, COL_HINT);
+            draw_line(dr, x2, y1, x2, y2, COL_HINT);
+            x1++, y1++, x2--, y2--;
+        }
+    }
+
+    unclip(dr);
+
+    draw_update(dr, bx+1, by+1, TILE_SIZE-1, TILE_SIZE-1);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = ds->w, h = ds->h, wh = w * h;
+    int i, flashframe;
+
+    if (!ds->started) {
+        draw_rect(dr, 0, 0, TILE_SIZE * w + 2 * BORDER,
+                  TILE_SIZE * h + 2 * BORDER, COL_BACKGROUND);
+
+        /*
+         * Draw the grid lines.
+         */
+        for (i = 0; i <= w; i++)
+            draw_line(dr, i * TILE_SIZE + BORDER, BORDER,
+                      i * TILE_SIZE + BORDER, h * TILE_SIZE + BORDER,
+                      COL_GRID);
+        for (i = 0; i <= h; i++)
+            draw_line(dr, BORDER, i * TILE_SIZE + BORDER,
+                      w * TILE_SIZE + BORDER, i * TILE_SIZE + BORDER,
+                      COL_GRID);
+
+        draw_update(dr, 0, 0, TILE_SIZE * w + 2 * BORDER,
+                    TILE_SIZE * h + 2 * BORDER);
+
+        ds->started = TRUE;
+    }
+
+    if (flashtime)
+        flashframe = (int)(flashtime / FLASH_FRAME);
+    else
+        flashframe = -1;
+
+    animtime /= ANIM_TIME;             /* scale it so it goes from 0 to 1 */
+
+    for (i = 0; i < wh; i++) {
+        int x = i % w, y = i / w;
+        int fx, fy, fd;
+        int v = state->grid[i];
+        int vv;
+
+        if (flashframe >= 0) {
+            fx = (w+1)/2 - min(x+1, w-x);
+            fy = (h+1)/2 - min(y+1, h-y);
+            fd = max(fx, fy);
+            if (fd == flashframe)
+                v |= 1;
+            else if (fd == flashframe - 1)
+                v &= ~1;
+        }
+
+        if (!state->hints_active)
+            v &= ~2;
+        if (ui->cdraw && ui->cx == x && ui->cy == y)
+            v |= 4;
+
+        if (oldstate && ((state->grid[i] ^ oldstate->grid[i]) &~ 2))
+            vv = 255;                  /* means `animated' */
+        else
+            vv = v;
+
+        if (ds->tiles[i] == 255 || vv == 255 || ds->tiles[i] != vv) {
+            draw_tile(dr, ds, state, x, y, v, vv == 255, animtime);
+            ds->tiles[i] = vv;
+        }
+    }
+
+    {
+        char buf[256];
+
+        sprintf(buf, "%sMoves: %d",
+                (state->completed ? 
+                 (state->cheated ? "Auto-solved. " : "COMPLETED! ") :
+                 (state->cheated ? "Auto-solver used. " : "")),
+                state->moves);
+
+        status_bar(dr, buf);
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return ANIM_TIME;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed)
+        return FLASH_FRAME * (max((newstate->w+1)/2, (newstate->h+1)/2)+1);
+
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame flip
+#endif
+
+const struct game thegame = {
+    "Flip", "games.flip", "flip",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
diff --git a/apps/plugins/puzzles/flood.R b/apps/plugins/puzzles/flood.R
new file mode 100644
index 0000000000..359bbb5dce
--- /dev/null
+++ b/apps/plugins/puzzles/flood.R
@@ -0,0 +1,19 @@
+# -*- makefile -*-
+
+flood     : [X] GTK COMMON flood flood-icon|no-icon
+
+flood     : [G] WINDOWS COMMON flood flood.res|noicon.res
+
+ALL += flood[COMBINED]
+
+!begin am gtk
+GAMES += flood
+!end
+
+!begin >list.c
+    A(flood) \
+!end
+
+!begin >gamedesc.txt
+flood:flood.exe:Flood:Flood-filling puzzle:Turn the grid the same colour in as few flood fills as possible.
+!end
diff --git a/apps/plugins/puzzles/flood.c b/apps/plugins/puzzles/flood.c
new file mode 100644
index 0000000000..69ae3067a9
--- /dev/null
+++ b/apps/plugins/puzzles/flood.c
@@ -0,0 +1,1372 @@
+/*
+ * flood.c: puzzle in which you make a grid all the same colour by
+ * repeatedly flood-filling the top left corner, and try to do so in
+ * as few moves as possible.
+ */
+
+/*
+ * Possible further work:
+ *
+ *  - UI: perhaps we should only permit clicking on regions that can
+ *    actually be reached by the next flood-fill - i.e. a click is
+ *    only interpreted as a move if it would cause the clicked-on
+ *    square to become part of the controlled area. This provides a
+ *    hint in cases where you mistakenly thought that would happen,
+ *    and protects you against typos in cases where you just
+ *    mis-aimed.
+ *
+ *  - UI: perhaps mark the fill square in some way? Or even mark the
+ *    whole connected component _containing_ the fill square. Pro:
+ *    that would make it easier to tell apart cases where almost all
+ *    the yellow squares in the grid are part of the target component
+ *    (hence, yellow is _done_ and you never have to fill in that
+ *    colour again) from cases where there's still one yellow square
+ *    that's only diagonally adjacent and hence will need coming back
+ *    to. Con: but it would almost certainly be ugly.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+enum {
+    COL_BACKGROUND, COL_SEPARATOR,
+    COL_1, COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8, COL_9, COL_10,
+    COL_HIGHLIGHT, COL_LOWLIGHT,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h;
+    int colours;
+    int leniency;
+};
+
+/* Just in case I want to make this changeable later, I'll put the
+ * coordinates of the flood-fill point here so that it'll be easy to
+ * find everywhere later that has to change. */
+#define FILLX 0
+#define FILLY 0
+
+typedef struct soln {
+    int refcount;
+    int nmoves;
+    char *moves;
+} soln;
+
+struct game_state {
+    int w, h, colours;
+    int moves, movelimit;
+    int complete;
+    char *grid;
+    int cheated;
+    int solnpos;
+    soln *soln;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 12;
+    ret->colours = 6;
+    ret->leniency = 5;
+
+    return ret;
+}
+
+static const struct {
+    struct game_params preset;
+    const char *name;
+} flood_presets[] = {
+    /* Default 12x12 size, three difficulty levels. */
+    {{12, 12, 6, 5}, "12x12 Easy"},
+    {{12, 12, 6, 2}, "12x12 Medium"},
+    {{12, 12, 6, 0}, "12x12 Hard"},
+    /* Larger puzzles, leaving off Easy in the expectation that people
+     * wanting a bigger grid will have played it enough to find Easy
+     * easy. */
+    {{16, 16, 6, 2}, "16x16 Medium"},
+    {{16, 16, 6, 0}, "16x16 Hard"},
+    /* A couple of different colour counts. It seems generally not too
+     * hard with fewer colours (probably because fewer choices), so no
+     * extra moves for these modes. */
+    {{12, 12, 3, 0}, "12x12, 3 colours"},
+    {{12, 12, 4, 0}, "12x12, 4 colours"},
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+
+    if (i < 0 || i >= lenof(flood_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = flood_presets[i].preset;
+    *name = dupstr(flood_presets[i].name);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        ret->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    while (*string) {
+        if (*string == 'c') {
+            string++;
+            ret->colours = atoi(string);
+            while (string[1] && isdigit((unsigned char)string[1])) string++;
+        } else if (*string == 'm') {
+            string++;
+            ret->leniency = atoi(string);
+            while (string[1] && isdigit((unsigned char)string[1])) string++;
+        }
+        string++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[256];
+    sprintf(buf, "%dx%d", params->w, params->h);
+    if (full)
+        sprintf(buf + strlen(buf), "c%dm%d",
+                params->colours, params->leniency);
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(5, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Colours";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->colours);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = "Extra moves permitted";
+    ret[3].type = C_STRING;
+    sprintf(buf, "%d", params->leniency);
+    ret[3].sval = dupstr(buf);
+    ret[3].ival = 0;
+
+    ret[4].name = NULL;
+    ret[4].type = C_END;
+    ret[4].sval = NULL;
+    ret[4].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->colours = atoi(cfg[2].sval);
+    ret->leniency = atoi(cfg[3].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 2 && params->h < 2)
+        return "Grid must contain at least two squares";
+    if (params->colours < 3 || params->colours > 10)
+        return "Must have between 3 and 10 colours";
+    if (params->leniency < 0)
+        return "Leniency must be non-negative";
+    return NULL;
+}
+
+#if 0
+/*
+ * Bodge to permit varying the recursion depth for testing purposes.
+
+To test two Floods against each other:
+
+paste <(./flood.1 --generate 100 12x12c6m0#12345 | cut -f2 -d,) <(./flood.2 --generate 100 12x12c6m0#12345 | cut -f2 -d,) | awk '{print $2-$1}' | sort -n | uniq -c | awk '{print $2,$1}' | tee z
+
+and then run gnuplot and plot "z".
+
+ */
+static int rdepth = 0;
+#define RECURSION_DEPTH (rdepth)
+void check_recursion_depth(void)
+{
+    if (!rdepth) {
+        const char *depthstr = getenv("FLOOD_DEPTH");
+        rdepth = depthstr ? atoi(depthstr) : 1;
+        rdepth = rdepth > 0 ? rdepth : 1;
+    }
+}
+#else
+/*
+ * Last time I empirically checked this, depth 3 was a noticeable
+ * improvement on 2, but 4 only negligibly better than 3.
+ */
+#define RECURSION_DEPTH 3
+#define check_recursion_depth() (void)0
+#endif
+
+struct solver_scratch {
+    int *queue[2];
+    int *dist;
+    char *grid, *grid2;
+    char *rgrids;
+};
+
+static struct solver_scratch *new_scratch(int w, int h)
+{
+    int wh = w*h;
+    struct solver_scratch *scratch = snew(struct solver_scratch);
+    check_recursion_depth();
+    scratch->queue[0] = snewn(wh, int);
+    scratch->queue[1] = snewn(wh, int);
+    scratch->dist = snewn(wh, int);
+    scratch->grid = snewn(wh, char);
+    scratch->grid2 = snewn(wh, char);
+    scratch->rgrids = snewn(wh * RECURSION_DEPTH, char);
+    return scratch;
+}
+
+static void free_scratch(struct solver_scratch *scratch)
+{
+    sfree(scratch->queue[0]);
+    sfree(scratch->queue[1]);
+    sfree(scratch->dist);
+    sfree(scratch->grid);
+    sfree(scratch->grid2);
+    sfree(scratch->rgrids);
+    sfree(scratch);
+}
+
+#if 0
+/* Diagnostic routines you can uncomment if you need them */
+void dump_grid(int w, int h, const char *grid, const char *titlefmt, ...)
+{
+    int x, y;
+    if (titlefmt) {
+        va_list ap;
+        va_start(ap, titlefmt);
+        vprintf(titlefmt, ap);
+        va_end(ap);
+        printf(":\n");
+    } else {
+        printf("Grid:\n");
+    }
+    for (y = 0; y < h; y++) {
+        printf("  ");
+        for (x = 0; x < w; x++) {
+            printf("%1x", grid[y*w+x]);
+        }
+        printf("\n");
+    }
+}
+
+void dump_dist(int w, int h, const int *dists, const char *titlefmt, ...)
+{
+    int x, y;
+    if (titlefmt) {
+        va_list ap;
+        va_start(ap, titlefmt);
+        vprintf(titlefmt, ap);
+        va_end(ap);
+        printf(":\n");
+    } else {
+        printf("Distances:\n");
+    }
+    for (y = 0; y < h; y++) {
+        printf("  ");
+        for (x = 0; x < w; x++) {
+            printf("%3d", dists[y*w+x]);
+        }
+        printf("\n");
+    }
+}
+#endif
+
+/*
+ * Search a grid to find the most distant square(s). Return their
+ * distance and the number of them, and also the number of squares in
+ * the current controlled set (i.e. at distance zero).
+ */
+static void search(int w, int h, char *grid, int x0, int y0,
+                   struct solver_scratch *scratch,
+                   int *rdist, int *rnumber, int *rcontrol)
+{
+    int wh = w*h;
+    int i, qcurr, qhead, qtail, qnext, currdist, remaining;
+
+    for (i = 0; i < wh; i++)
+        scratch->dist[i] = -1;
+    scratch->queue[0][0] = y0*w+x0;
+    scratch->queue[1][0] = y0*w+x0;
+    scratch->dist[y0*w+x0] = 0;
+    currdist = 0;
+    qcurr = 0;
+    qtail = 0;
+    qhead = 1;
+    qnext = 1;
+    remaining = wh - 1;
+
+    while (1) {
+        if (qtail == qhead) {
+            /* Switch queues. */
+            if (currdist == 0)
+                *rcontrol = qhead;
+            currdist++;
+            qcurr ^= 1;                    /* switch queues */
+            qhead = qnext;
+            qtail = 0;
+            qnext = 0;
+#if 0
+            printf("switch queue, new dist %d, queue %d\n", currdist, qhead);
+#endif
+        } else if (remaining == 0 && qnext == 0) {
+            break;
+        } else {
+            int pos = scratch->queue[qcurr][qtail++];
+            int y = pos / w;
+            int x = pos % w;
+#if 0
+            printf("checking neighbours of %d,%d\n", x, y);
+#endif
+            int dir;
+            for (dir = 0; dir < 4; dir++) {
+                int y1 = y + (dir == 1 ? 1 : dir == 3 ? -1 : 0);
+                int x1 = x + (dir == 0 ? 1 : dir == 2 ? -1 : 0);
+                if (0 <= x1 && x1 < w && 0 <= y1 && y1 < h) {
+                    int pos1 = y1*w+x1;
+#if 0
+                    printf("trying %d,%d: colours %d-%d dist %d\n", x1, y1,
+                           grid[pos], grid[pos1], scratch->dist[pos]);
+#endif
+                    if (scratch->dist[pos1] == -1 &&
+                        ((grid[pos1] == grid[pos] &&
+                          scratch->dist[pos] == currdist) ||
+                         (grid[pos1] != grid[pos] &&
+                          scratch->dist[pos] == currdist - 1))) {
+#if 0
+                        printf("marking %d,%d dist %d\n", x1, y1, currdist);
+#endif
+                        scratch->queue[qcurr][qhead++] = pos1;
+                        scratch->queue[qcurr^1][qnext++] = pos1;
+                        scratch->dist[pos1] = currdist;
+                        remaining--;
+                    }
+                }
+            }
+        }
+    }
+
+    *rdist = currdist;
+    *rnumber = qhead;
+    if (currdist == 0)
+        *rcontrol = qhead;
+}
+
+/*
+ * Enact a flood-fill move on a grid.
+ */
+static void fill(int w, int h, char *grid, int x0, int y0, char newcolour,
+                 int *queue)
+{
+    char oldcolour;
+    int qhead, qtail;
+
+    oldcolour = grid[y0*w+x0];
+    assert(oldcolour != newcolour);
+    grid[y0*w+x0] = newcolour;
+    queue[0] = y0*w+x0;
+    qtail = 0;
+    qhead = 1;
+
+    while (qtail < qhead) {
+        int pos = queue[qtail++];
+        int y = pos / w;
+        int x = pos % w;
+        int dir;
+        for (dir = 0; dir < 4; dir++) {
+            int y1 = y + (dir == 1 ? 1 : dir == 3 ? -1 : 0);
+            int x1 = x + (dir == 0 ? 1 : dir == 2 ? -1 : 0);
+            if (0 <= x1 && x1 < w && 0 <= y1 && y1 < h) {
+                int pos1 = y1*w+x1;
+                if (grid[pos1] == oldcolour) {
+                    grid[pos1] = newcolour;
+                    queue[qhead++] = pos1;
+                }
+            }
+        }
+    }
+}
+
+/*
+ * Detect a completed grid.
+ */
+static int completed(int w, int h, char *grid)
+{
+    int wh = w*h;
+    int i;
+
+    for (i = 1; i < wh; i++)
+        if (grid[i] != grid[0])
+            return FALSE;
+
+    return TRUE;
+}
+
+/*
+ * Try out every possible move on a grid, and choose whichever one
+ * reduced the result of search() by the most.
+ */
+static char choosemove_recurse(int w, int h, char *grid, int x0, int y0,
+                               int maxmove, struct solver_scratch *scratch,
+                               int depth, int *rbestdist, int *rbestnumber, int *rbestcontrol)
+{
+    int wh = w*h;
+    char move, bestmove;
+    int dist, number, control, bestdist, bestnumber, bestcontrol;
+    char *tmpgrid;
+
+    assert(0 <= depth && depth < RECURSION_DEPTH);
+    tmpgrid = scratch->rgrids + depth*wh;
+
+    bestdist = wh + 1;
+    bestnumber = 0;
+    bestcontrol = 0;
+    bestmove = -1;
+
+#if 0
+    dump_grid(w, h, grid, "before choosemove_recurse %d", depth);
+#endif
+    for (move = 0; move < maxmove; move++) {
+        if (grid[y0*w+x0] == move)
+            continue;
+        memcpy(tmpgrid, grid, wh * sizeof(*grid));
+        fill(w, h, tmpgrid, x0, y0, move, scratch->queue[0]);
+        if (completed(w, h, tmpgrid)) {
+            /*
+             * A move that wins is immediately the best, so stop
+             * searching. Record what depth of recursion that happened
+             * at, so that higher levels will choose a move that gets
+             * to a winning position sooner.
+             */
+            *rbestdist = -1;
+            *rbestnumber = depth;
+            *rbestcontrol = wh;
+            return move;
+        }
+        if (depth < RECURSION_DEPTH-1) {
+            choosemove_recurse(w, h, tmpgrid, x0, y0, maxmove, scratch,
+                               depth+1, &dist, &number, &control);
+        } else {
+#if 0
+            dump_grid(w, h, tmpgrid, "after move %d at depth %d",
+                      move, depth);
+#endif
+            search(w, h, tmpgrid, x0, y0, scratch, &dist, &number, &control);
+#if 0
+            dump_dist(w, h, scratch->dist, "after move %d at depth %d",
+                      move, depth);
+            printf("move %d at depth %d: %d at %d\n",
+                   depth, move, number, dist);
+#endif
+        }
+        if (dist < bestdist ||
+            (dist == bestdist &&
+             (number < bestnumber ||
+              (number == bestnumber &&
+               (control > bestcontrol))))) {
+            bestdist = dist;
+            bestnumber = number;
+            bestcontrol = control;
+            bestmove = move;
+        }
+    }
+#if 0
+    printf("best at depth %d was %d (%d at %d, %d controlled)\n",
+           depth, bestmove, bestnumber, bestdist, bestcontrol);
+#endif
+
+    *rbestdist = bestdist;
+    *rbestnumber = bestnumber;
+    *rbestcontrol = bestcontrol;
+    return bestmove;
+}
+static char choosemove(int w, int h, char *grid, int x0, int y0,
+                       int maxmove, struct solver_scratch *scratch)
+{
+    int tmp0, tmp1, tmp2;
+    return choosemove_recurse(w, h, grid, x0, y0, maxmove, scratch,
+                              0, &tmp0, &tmp1, &tmp2);
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    int i, moves;
+    char *desc;
+    struct solver_scratch *scratch;
+
+    scratch = new_scratch(w, h);
+
+    /*
+     * Invent a random grid.
+     */
+    for (i = 0; i < wh; i++)
+        scratch->grid[i] = random_upto(rs, params->colours);
+
+    /*
+     * Run the solver, and count how many moves it uses.
+     */
+    memcpy(scratch->grid2, scratch->grid, wh * sizeof(*scratch->grid2));
+    moves = 0;
+    check_recursion_depth();
+    while (!completed(w, h, scratch->grid2)) {
+        char move = choosemove(w, h, scratch->grid2, FILLX, FILLY,
+                               params->colours, scratch);
+        fill(w, h, scratch->grid2, FILLX, FILLY, move, scratch->queue[0]);
+        moves++;
+    }
+
+    /*
+     * Adjust for difficulty.
+     */
+    moves += params->leniency;
+
+    /*
+     * Encode the game id.
+     */
+    desc = snewn(wh + 40, char);
+    for (i = 0; i < wh; i++) {
+        char colour = scratch->grid[i];
+        char textcolour = (colour > 9 ? 'A' : '0') + colour;
+        desc[i] = textcolour;
+    }
+    sprintf(desc+i, ",%d", moves);
+
+    free_scratch(scratch);
+
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    int i;
+    for (i = 0; i < wh; i++) {
+        char c = *desc++;
+        if (c == 0)
+            return "Not enough data in grid description";
+        if (c >= '0' && c <= '9')
+            c -= '0';
+        else if (c >= 'A' && c <= 'Z')
+            c = 10 + (c - 'A');
+        else
+            return "Bad character in grid description";
+        if ((unsigned)c >= params->colours)
+            return "Colour out of range in grid description";
+    }
+    if (*desc != ',')
+        return "Expected ',' after grid description";
+    desc++;
+    if (desc[strspn(desc, "0123456789")])
+        return "Badly formatted move limit after grid description";
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    game_state *state = snew(game_state);
+    int i;
+
+    state->w = w;
+    state->h = h;
+    state->colours = params->colours;
+    state->moves = 0;
+    state->grid = snewn(wh, char);
+
+    for (i = 0; i < wh; i++) {
+        char c = *desc++;
+        assert(c);
+        if (c >= '0' && c <= '9')
+            c -= '0';
+        else if (c >= 'A' && c <= 'Z')
+            c = 10 + (c - 'A');
+        else
+            assert(!"bad colour");
+        state->grid[i] = c;
+    }
+    assert(*desc == ',');
+    desc++;
+
+    state->movelimit = atoi(desc);
+    state->complete = FALSE;
+    state->cheated = FALSE;
+    state->solnpos = 0;
+    state->soln = NULL;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->colours = state->colours;
+    ret->moves = state->moves;
+    ret->movelimit = state->movelimit;
+    ret->complete = state->complete;
+    ret->grid = snewn(state->w * state->h, char);
+    memcpy(ret->grid, state->grid, state->w * state->h * sizeof(*ret->grid));
+
+    ret->cheated = state->cheated;
+    ret->soln = state->soln;
+    if (ret->soln)
+        ret->soln->refcount++;
+    ret->solnpos = state->solnpos;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (state->soln && --state->soln->refcount == 0) {
+        sfree(state->soln->moves);
+        sfree(state->soln);
+    }
+    sfree(state->grid);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int w = state->w, h = state->h, wh = w*h;
+    char *moves, *ret, *p;
+    int i, len, nmoves;
+    char buf[256];
+    struct solver_scratch *scratch;
+
+    if (currstate->complete) {
+        *error = "Puzzle is already solved";
+        return NULL;
+    }
+
+    /*
+     * Find the best solution our solver can give.
+     */
+    moves = snewn(wh, char);           /* sure to be enough */
+    nmoves = 0;
+    scratch = new_scratch(w, h);
+    memcpy(scratch->grid2, currstate->grid, wh * sizeof(*scratch->grid2));
+    check_recursion_depth();
+    while (!completed(w, h, scratch->grid2)) {
+        char move = choosemove(w, h, scratch->grid2, FILLX, FILLY,
+                               currstate->colours, scratch);
+        fill(w, h, scratch->grid2, FILLX, FILLY, move, scratch->queue[0]);
+        assert(nmoves < wh);
+        moves[nmoves++] = move;
+    }
+    free_scratch(scratch);
+
+    /*
+     * Encode it as a move string.
+     */
+    len = 1;                           /* trailing NUL */
+    for (i = 0; i < nmoves; i++)
+        len += sprintf(buf, ",%d", moves[i]);
+    ret = snewn(len, char);
+    p = ret;
+    for (i = 0; i < nmoves; i++)
+        p += sprintf(p, "%c%d", (i==0 ? 'S' : ','), moves[i]);
+    assert(p - ret == len - 1);
+
+    sfree(moves);
+    return ret;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->w, h = state->h;
+    char *ret, *p;
+    int x, y, len;
+
+    len = h * (w+1);                   /* +1 for newline after each row */
+    ret = snewn(len+1, char);          /* and +1 for terminating \0 */
+    p = ret;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            char colour = state->grid[y*w+x];
+            char textcolour = (colour > 9 ? 'A' : '0') + colour;
+            *p++ = textcolour;
+        }
+        *p++ = '\n';
+    }
+
+    assert(p - ret == len);
+    *p = '\0';
+
+    return ret;
+}
+
+struct game_ui {
+    int cursor_visible;
+    int cx, cy;
+    enum { VICTORY, DEFEAT } flash_type;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    struct game_ui *ui = snew(struct game_ui);
+    ui->cursor_visible = FALSE;
+    ui->cx = FILLX;
+    ui->cy = FILLY;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int started;
+    int tilesize;
+    int *grid;
+};
+
+#define TILESIZE (ds->tilesize)
+#define PREFERRED_TILESIZE 32
+#define BORDER (TILESIZE / 2)
+#define SEP_WIDTH (TILESIZE / 32)
+#define CURSOR_INSET (TILESIZE / 8)
+#define HIGHLIGHT_WIDTH (TILESIZE / 10)
+#define COORD(x)  ( (x) * TILESIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILESIZE) / TILESIZE - 1 )
+#define VICTORY_FLASH_FRAME 0.03F
+#define DEFEAT_FLASH_FRAME 0.10F
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->w, h = state->h;
+    int tx = -1, ty = -1, move = -1;
+
+    if (button == LEFT_BUTTON) {
+        tx = FROMCOORD(x);
+        ty = FROMCOORD(y);
+        ui->cursor_visible = FALSE;
+    } else if (button == CURSOR_LEFT && ui->cx > 0) {
+        ui->cx--;
+        ui->cursor_visible = TRUE;
+        return "";
+    } else if (button == CURSOR_RIGHT && ui->cx+1 < w) {
+        ui->cx++;
+        ui->cursor_visible = TRUE;
+        return "";
+    } else if (button == CURSOR_UP && ui->cy > 0) {
+        ui->cy--;
+        ui->cursor_visible = TRUE;
+        return "";
+    } else if (button == CURSOR_DOWN && ui->cy+1 < h) {
+        ui->cy++;
+        ui->cursor_visible = TRUE;
+        return "";
+    } else if (button == CURSOR_SELECT) {
+        tx = ui->cx;
+        ty = ui->cy;
+    } else if (button == CURSOR_SELECT2 &&
+               state->soln && state->solnpos < state->soln->nmoves) {
+        move = state->soln->moves[state->solnpos];
+    } else {
+        return NULL;
+    }
+
+    if (tx >= 0 && tx < w && ty >= 0 && ty < h &&
+        state->grid[0] != state->grid[ty*w+tx])
+        move = state->grid[ty*w+tx];
+
+    if (move >= 0 && !state->complete) {
+        char buf[256];
+        sprintf(buf, "M%d", move);
+        return dupstr(buf);
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    game_state *ret;
+    int c;
+
+    if (move[0] == 'M' &&
+        sscanf(move+1, "%d", &c) == 1 &&
+        c >= 0 &&
+        !state->complete) {
+        int *queue = snewn(state->w * state->h, int);
+        ret = dup_game(state);
+        fill(ret->w, ret->h, ret->grid, FILLX, FILLY, c, queue);
+        ret->moves++;
+        ret->complete = completed(ret->w, ret->h, ret->grid);
+
+        if (ret->soln) {
+            /*
+             * If this move is the correct next one in the stored
+             * solution path, advance solnpos.
+             */
+            if (c == ret->soln->moves[ret->solnpos] &&
+                ret->solnpos+1 < ret->soln->nmoves) {
+                ret->solnpos++;
+            } else {
+                /*
+                 * Otherwise, the user has strayed from the path or
+                 * else the path has come to an end; either way, the
+                 * path is no longer valid.
+                 */
+                ret->soln->refcount--;
+                assert(ret->soln->refcount > 0);/* `state' at least still exists */
+                ret->soln = NULL;
+                ret->solnpos = 0;
+            }
+        }
+
+        sfree(queue);
+        return ret;
+    } else if (*move == 'S') {
+        soln *sol;
+        const char *p;
+        int i;
+
+        /*
+         * This is a solve move, so we don't actually _change_ the
+         * grid but merely set up a stored solution path.
+         */
+        move++;
+        sol = snew(soln);
+
+        sol->nmoves = 1;
+        for (p = move; *p; p++) {
+            if (*p == ',')
+                sol->nmoves++;
+        }
+
+        sol->moves = snewn(sol->nmoves, char);
+        for (i = 0, p = move; i < sol->nmoves; i++) {
+            assert(*p);
+            sol->moves[i] = atoi(p);
+            p += strspn(p, "0123456789");
+            if (*p) {
+                assert(*p == ',');
+                p++;
+            }
+        }
+
+        ret = dup_game(state);
+        ret->cheated = TRUE;
+        if (ret->soln && --ret->soln->refcount == 0) {
+            sfree(ret->soln->moves);
+            sfree(ret->soln);
+        }
+        ret->soln = sol;
+        ret->solnpos = 0;
+        sol->refcount = 1;
+        return ret;
+    }
+
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = BORDER * 2 + TILESIZE * params->w;
+    *y = BORDER * 2 + TILESIZE * params->h;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    ret[COL_SEPARATOR * 3 + 0] = 0.0F;
+    ret[COL_SEPARATOR * 3 + 1] = 0.0F;
+    ret[COL_SEPARATOR * 3 + 2] = 0.0F;
+
+    /* red */
+    ret[COL_1 * 3 + 0] = 1.0F;
+    ret[COL_1 * 3 + 1] = 0.0F;
+    ret[COL_1 * 3 + 2] = 0.0F;
+
+    /* yellow */
+    ret[COL_2 * 3 + 0] = 1.0F;
+    ret[COL_2 * 3 + 1] = 1.0F;
+    ret[COL_2 * 3 + 2] = 0.0F;
+
+    /* green */
+    ret[COL_3 * 3 + 0] = 0.0F;
+    ret[COL_3 * 3 + 1] = 1.0F;
+    ret[COL_3 * 3 + 2] = 0.0F;
+
+    /* blue */
+    ret[COL_4 * 3 + 0] = 0.2F;
+    ret[COL_4 * 3 + 1] = 0.3F;
+    ret[COL_4 * 3 + 2] = 1.0F;
+
+    /* orange */
+    ret[COL_5 * 3 + 0] = 1.0F;
+    ret[COL_5 * 3 + 1] = 0.5F;
+    ret[COL_5 * 3 + 2] = 0.0F;
+
+    /* purple */
+    ret[COL_6 * 3 + 0] = 0.5F;
+    ret[COL_6 * 3 + 1] = 0.0F;
+    ret[COL_6 * 3 + 2] = 0.7F;
+
+    /* brown */
+    ret[COL_7 * 3 + 0] = 0.5F;
+    ret[COL_7 * 3 + 1] = 0.3F;
+    ret[COL_7 * 3 + 2] = 0.3F;
+
+    /* light blue */
+    ret[COL_8 * 3 + 0] = 0.4F;
+    ret[COL_8 * 3 + 1] = 0.8F;
+    ret[COL_8 * 3 + 2] = 1.0F;
+
+    /* light green */
+    ret[COL_9 * 3 + 0] = 0.7F;
+    ret[COL_9 * 3 + 1] = 1.0F;
+    ret[COL_9 * 3 + 2] = 0.7F;
+
+    /* pink */
+    ret[COL_10 * 3 + 0] = 1.0F;
+    ret[COL_10 * 3 + 1] = 0.6F;
+    ret[COL_10 * 3 + 2] = 1.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int w = state->w, h = state->h, wh = w*h;
+    int i;
+
+    ds->started = FALSE;
+    ds->tilesize = 0;
+    ds->grid = snewn(wh, int);
+    for (i = 0; i < wh; i++)
+        ds->grid[i] = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+#define BORDER_L  0x001
+#define BORDER_R  0x002
+#define BORDER_U  0x004
+#define BORDER_D  0x008
+#define CORNER_UL 0x010
+#define CORNER_UR 0x020
+#define CORNER_DL 0x040
+#define CORNER_DR 0x080
+#define CURSOR    0x100
+#define BADFLASH  0x200
+#define SOLNNEXT  0x400
+#define COLOUR_SHIFT 11
+
+static void draw_tile(drawing *dr, game_drawstate *ds,
+                      int x, int y, int tile)
+{
+    int colour;
+    int tx = COORD(x), ty = COORD(y);
+
+    colour = tile >> COLOUR_SHIFT;
+    if (tile & BADFLASH)
+        colour = COL_SEPARATOR;
+    else
+        colour += COL_1;
+    draw_rect(dr, tx, ty, TILESIZE, TILESIZE, colour);
+
+    if (tile & BORDER_L)
+        draw_rect(dr, tx, ty,
+                  SEP_WIDTH, TILESIZE, COL_SEPARATOR);
+    if (tile & BORDER_R)
+        draw_rect(dr, tx + TILESIZE - SEP_WIDTH, ty,
+                  SEP_WIDTH, TILESIZE, COL_SEPARATOR);
+    if (tile & BORDER_U)
+        draw_rect(dr, tx, ty,
+                  TILESIZE, SEP_WIDTH, COL_SEPARATOR);
+    if (tile & BORDER_D)
+        draw_rect(dr, tx, ty + TILESIZE - SEP_WIDTH,
+                  TILESIZE, SEP_WIDTH, COL_SEPARATOR);
+
+    if (tile & CORNER_UL)
+        draw_rect(dr, tx, ty,
+                  SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
+    if (tile & CORNER_UR)
+        draw_rect(dr, tx + TILESIZE - SEP_WIDTH, ty,
+                  SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
+    if (tile & CORNER_DL)
+        draw_rect(dr, tx, ty + TILESIZE - SEP_WIDTH,
+                  SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
+    if (tile & CORNER_DR)
+        draw_rect(dr, tx + TILESIZE - SEP_WIDTH, ty + TILESIZE - SEP_WIDTH,
+                  SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
+
+    if (tile & CURSOR)
+        draw_rect_outline(dr, tx + CURSOR_INSET, ty + CURSOR_INSET,
+                          TILESIZE - 1 - CURSOR_INSET * 2,
+                          TILESIZE - 1 - CURSOR_INSET * 2,
+                          COL_SEPARATOR);
+
+    if (tile & SOLNNEXT) {
+        draw_circle(dr, tx + TILESIZE/2, ty + TILESIZE/2, TILESIZE/6,
+                    COL_SEPARATOR, COL_SEPARATOR);
+    }
+
+    draw_update(dr, tx, ty, TILESIZE, TILESIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->w, h = state->h, wh = w*h;
+    int x, y, flashframe, solnmove;
+    char *grid;
+
+    /* This was entirely cloned from fifteen.c; it should probably be
+     * moved into some generic 'draw-recessed-rectangle' utility fn. */
+    if (!ds->started) {
+        int coords[10];
+
+        draw_rect(dr, 0, 0,
+                  TILESIZE * w + 2 * BORDER,
+                  TILESIZE * h + 2 * BORDER, COL_BACKGROUND);
+        draw_update(dr, 0, 0,
+                    TILESIZE * w + 2 * BORDER,
+                    TILESIZE * h + 2 * BORDER);
+
+        /*
+         * Recessed area containing the whole puzzle.
+         */
+        coords[0] = COORD(w) + HIGHLIGHT_WIDTH - 1;
+        coords[1] = COORD(h) + HIGHLIGHT_WIDTH - 1;
+        coords[2] = COORD(w) + HIGHLIGHT_WIDTH - 1;
+        coords[3] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[4] = coords[2] - TILESIZE;
+        coords[5] = coords[3] + TILESIZE;
+        coords[8] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[9] = COORD(h) + HIGHLIGHT_WIDTH - 1;
+        coords[6] = coords[8] + TILESIZE;
+        coords[7] = coords[9] - TILESIZE;
+        draw_polygon(dr, coords, 5, COL_HIGHLIGHT, COL_HIGHLIGHT);
+
+        coords[1] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
+        draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
+
+        draw_rect(dr, COORD(0) - SEP_WIDTH, COORD(0) - SEP_WIDTH,
+                  TILESIZE * w + 2 * SEP_WIDTH, TILESIZE * h + 2 * SEP_WIDTH,
+                  COL_SEPARATOR);
+
+        ds->started = 1;
+    }
+
+    if (flashtime > 0) {
+        float frame = (ui->flash_type == VICTORY ?
+                       VICTORY_FLASH_FRAME : DEFEAT_FLASH_FRAME);
+        flashframe = (int)(flashtime / frame);
+    } else {
+        flashframe = -1;
+    }
+
+    grid = snewn(wh, char);
+    memcpy(grid, state->grid, wh * sizeof(*grid));
+
+    if (state->soln && state->solnpos < state->soln->nmoves) {
+        int i, *queue;
+
+        /*
+         * Highlight as 'next auto-solver move' every square of the
+         * target colour which is adjacent to the currently controlled
+         * region. We do this by first enacting the actual move, then
+         * flood-filling again in a nonexistent colour, and finally
+         * reverting to the original grid anything in the new colour
+         * that was part of the original controlled region. Then
+         * regions coloured in the dummy colour should be displayed as
+         * soln_move with the SOLNNEXT flag.
+         */
+        solnmove = state->soln->moves[state->solnpos];
+
+        queue = snewn(wh, int);
+        fill(w, h, grid, FILLX, FILLY, solnmove, queue);
+        fill(w, h, grid, FILLX, FILLY, state->colours, queue);
+        sfree(queue);
+
+        for (i = 0; i < wh; i++)
+            if (grid[i] == state->colours && state->grid[i] != solnmove)
+                grid[i] = state->grid[i];
+    } else {
+        solnmove = 0;                  /* placate optimiser */
+    }
+
+    if (flashframe >= 0 && ui->flash_type == VICTORY) {
+        /*
+         * Modify the display grid by superimposing our rainbow flash
+         * on it.
+         */
+        for (x = 0; x < w; x++) {
+            for (y = 0; y < h; y++) {
+                int flashpos = flashframe - (abs(x - FILLX) + abs(y - FILLY));
+                if (flashpos >= 0 && flashpos < state->colours)
+                    grid[y*w+x] = flashpos;
+            }
+        }
+    }
+
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            int pos = y*w+x;
+            int tile;
+
+            if (grid[pos] == state->colours) {
+                tile = (solnmove << COLOUR_SHIFT) | SOLNNEXT;
+            } else {
+                tile = (int)grid[pos] << COLOUR_SHIFT;
+            }
+
+            if (x == 0 || grid[pos-1] != grid[pos])
+                tile |= BORDER_L;
+            if (x==w-1 || grid[pos+1] != grid[pos])
+                tile |= BORDER_R;
+            if (y == 0 || grid[pos-w] != grid[pos])
+                tile |= BORDER_U;
+            if (y==h-1 || grid[pos+w] != grid[pos])
+                tile |= BORDER_D;
+            if (x == 0 || y == 0 || grid[pos-w-1] != grid[pos])
+                tile |= CORNER_UL;
+            if (x==w-1 || y == 0 || grid[pos-w+1] != grid[pos])
+                tile |= CORNER_UR;
+            if (x == 0 || y==h-1 || grid[pos+w-1] != grid[pos])
+                tile |= CORNER_DL;
+            if (x==w-1 || y==h-1 || grid[pos+w+1] != grid[pos])
+                tile |= CORNER_DR;
+            if (ui->cursor_visible && ui->cx == x && ui->cy == y)
+                tile |= CURSOR;
+
+            if (flashframe >= 0 && ui->flash_type == DEFEAT && flashframe != 1)
+                tile |= BADFLASH;
+
+            if (ds->grid[pos] != tile) {
+                draw_tile(dr, ds, x, y, tile);
+                ds->grid[pos] = tile;
+            }
+        }
+    }
+
+    sfree(grid);
+
+    {
+        char status[255];
+
+        sprintf(status, "%s%d / %d moves",
+                (state->complete && state->moves <= state->movelimit ?
+                 (state->cheated ? "Auto-solved. " : "COMPLETED! ") :
+                 state->moves >= state->movelimit ? "FAILED! " :
+                 state->cheated ? "Auto-solver used. " :
+                 ""),
+                state->moves,
+                state->movelimit);
+
+        status_bar(dr, status);
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    if (state->complete && state->moves <= state->movelimit) {
+        return +1;                     /* victory! */
+    } else if (state->moves >= state->movelimit) {
+        return -1;                     /* defeat */
+    } else {
+        return 0;                      /* still playing */
+    }
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (dir == +1) {
+        int old_status = game_status(oldstate);
+        int new_status = game_status(newstate);
+        if (old_status != new_status) {
+            assert(old_status == 0);
+
+            if (new_status == +1) {
+                int frames = newstate->w + newstate->h + newstate->colours - 2;
+                ui->flash_type = VICTORY;
+                return VICTORY_FLASH_FRAME * frames;
+            } else {
+                ui->flash_type = DEFEAT;
+                return DEFEAT_FLASH_FRAME * 3;
+            }
+        }
+    }
+    return 0.0F;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame flood
+#endif
+
+const struct game thegame = {
+    "Flood", "games.flood", "flood",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
diff --git a/apps/plugins/puzzles/galaxies.R b/apps/plugins/puzzles/galaxies.R
new file mode 100644
index 0000000000..957e5dad90
--- /dev/null
+++ b/apps/plugins/puzzles/galaxies.R
@@ -0,0 +1,28 @@
+# -*- makefile -*-
+
+GALAXIES_EXTRA = dsf
+
+galaxies : [X] GTK COMMON galaxies GALAXIES_EXTRA galaxies-icon|no-icon
+
+galaxies : [G] WINDOWS COMMON galaxies GALAXIES_EXTRA galaxies.res|noicon.res
+
+galaxiessolver : [U] galaxies[STANDALONE_SOLVER] GALAXIES_EXTRA STANDALONE m.lib
+galaxiessolver : [C] galaxies[STANDALONE_SOLVER] GALAXIES_EXTRA STANDALONE
+
+galaxiespicture : [U] galaxies[STANDALONE_PICTURE_GENERATOR] GALAXIES_EXTRA STANDALONE
+                + m.lib
+galaxiespicture : [C] galaxies[STANDALONE_PICTURE_GENERATOR] GALAXIES_EXTRA STANDALONE
+
+ALL += galaxies[COMBINED] GALAXIES_EXTRA
+
+!begin am gtk
+GAMES += galaxies
+!end
+
+!begin >list.c
+    A(galaxies) \
+!end
+
+!begin >gamedesc.txt
+galaxies:galaxies.exe:Galaxies:Symmetric polyomino puzzle:Divide the grid into rotationally symmetric regions each centred on a dot.
+!end
diff --git a/apps/plugins/puzzles/galaxies.c b/apps/plugins/puzzles/galaxies.c
new file mode 100644
index 0000000000..a18901d6e5
--- /dev/null
+++ b/apps/plugins/puzzles/galaxies.c
@@ -0,0 +1,3995 @@
+/*
+ * galaxies.c: implementation of 'Tentai Show' from Nikoli,
+ *             also sometimes called 'Spiral Galaxies'.
+ *
+ * Notes:
+ *
+ * Grid is stored as size (2n-1), holding edges as well as spaces
+ * (and thus vertices too, at edge intersections).
+ *
+ * Any dot will thus be positioned at one of our grid points,
+ * which saves any faffing with half-of-a-square stuff.
+ *
+ * Edges have on/off state; obviously the actual edges of the
+ * board are fixed to on, and everything else starts as off.
+ *
+ * TTD:
+   * Cleverer solver
+   * Think about how to display remote groups of tiles?
+ *
+ * Bugs:
+ *
+ * Notable puzzle IDs:
+ *
+ * Nikoli's example [web site has wrong highlighting]
+ * (at http://www.nikoli.co.jp/en/puzzles/astronomical_show/):
+ *  5x5:eBbbMlaBbOEnf
+ *
+ * The 'spiral galaxies puzzles are NP-complete' paper
+ * (at http://www.stetson.edu/~efriedma/papers/spiral.pdf):
+ *  7x7:chpgdqqqoezdddki
+ *
+ * Puzzle competition pdf examples
+ * (at http://www.puzzleratings.org/Yurekli2006puz.pdf):
+ *  6x6:EDbaMucCohbrecEi
+ *  10x10:beFbufEEzowDlxldibMHezBQzCdcFzjlci
+ *  13x13:dCemIHFFkJajjgDfdbdBzdzEgjccoPOcztHjBczLDjczqktJjmpreivvNcggFi
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#ifdef DEBUGGING
+#define solvep debug
+#else
+int solver_show_working;
+#define solvep(x) do { if (solver_show_working) { printf x; } } while(0)
+#endif
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+/*
+ * Dirty hack to enable the generator to construct a game ID which
+ * solves to a specified black-and-white bitmap. We define a global
+ * variable here which gives the desired colour of each square, and
+ * we arrange that the grid generator never merges squares of
+ * different colours.
+ *
+ * The bitmap as stored here is a simple int array (at these sizes
+ * it isn't worth doing fiddly bit-packing). picture[y*w+x] is 1
+ * iff the pixel at (x,y) is intended to be black.
+ *
+ * (It might be nice to be able to specify some pixels as
+ * don't-care, to give the generator more leeway. But that might be
+ * fiddly.)
+ */
+static int *picture;
+#endif
+
+enum {
+    COL_BACKGROUND,
+    COL_WHITEBG,
+    COL_BLACKBG,
+    COL_WHITEDOT,
+    COL_BLACKDOT,
+    COL_GRID,
+    COL_EDGE,
+    COL_ARROW,
+    COL_CURSOR,
+    NCOLOURS
+};
+
+#define DIFFLIST(A)             \
+    A(NORMAL,Normal,n)          \
+    A(UNREASONABLE,Unreasonable,u)
+
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+enum { DIFFLIST(ENUM)
+    DIFF_IMPOSSIBLE, DIFF_AMBIGUOUS, DIFF_UNFINISHED, DIFF_MAX };
+static char const *const galaxies_diffnames[] = {
+    DIFFLIST(TITLE) "Impossible", "Ambiguous", "Unfinished" };
+static char const galaxies_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+struct game_params {
+    /* X and Y is the area of the board as seen by
+     * the user, not the (2n+1) area the game uses. */
+    int w, h, diff;
+};
+
+enum { s_tile, s_edge, s_vertex };
+
+#define F_DOT           1       /* there's a dot here */
+#define F_EDGE_SET      2       /* the edge is set */
+#define F_TILE_ASSOC    4       /* this tile is associated with a dot. */
+#define F_DOT_BLACK     8       /* (ui only) dot is black. */
+#define F_MARK          16      /* scratch flag */
+#define F_REACHABLE     32
+#define F_SCRATCH       64
+#define F_MULTIPLE      128
+#define F_DOT_HOLD      256
+#define F_GOOD          512
+
+typedef struct space {
+    int x, y;           /* its position */
+    int type;
+    unsigned int flags;
+    int dotx, doty;     /* if flags & F_TILE_ASSOC */
+    int nassoc;         /* if flags & F_DOT */
+} space;
+
+#define INGRID(s,x,y) ((x) >= 0 && (y) >= 0 &&                  \
+                       (x) < (state)->sx && (y) < (state)->sy)
+#define INUI(s,x,y)   ((x) > 0 && (y) > 0 &&                  \
+                       (x) < ((state)->sx-1) && (y) < ((state)->sy-1))
+
+#define GRID(s,g,x,y) ((s)->g[((y)*(s)->sx)+(x)])
+#define SPACE(s,x,y) GRID(s,grid,x,y)
+
+struct game_state {
+    int w, h;           /* size from params */
+    int sx, sy;         /* allocated size, (2x-1)*(2y-1) */
+    space *grid;
+    int completed, used_solve;
+    int ndots;
+    space **dots;
+
+    midend *me;         /* to call supersede_game_desc */
+    int cdiff;          /* difficulty of current puzzle (for status bar),
+                           or -1 if stale. */
+};
+
+static int check_complete(const game_state *state, int *dsf, int *colours);
+static int solver_state(game_state *state, int maxdiff);
+static int solver_obvious(game_state *state);
+static int solver_obvious_dot(game_state *state, space *dot);
+static space *space_opposite_dot(const game_state *state, const space *sp,
+                                 const space *dot);
+static space *tile_opposite(const game_state *state, const space *sp);
+
+/* ----------------------------------------------------------
+ * Game parameters and presets
+ */
+
+/* make up some sensible default sizes */
+
+#define DEFAULT_PRESET 0
+
+static const game_params galaxies_presets[] = {
+    {  7,  7, DIFF_NORMAL },
+    {  7,  7, DIFF_UNREASONABLE },
+    { 10, 10, DIFF_NORMAL },
+    { 15, 15, DIFF_NORMAL },
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(galaxies_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = galaxies_presets[i]; /* structure copy */
+
+    sprintf(buf, "%dx%d %s", ret->w, ret->h,
+            galaxies_diffnames[ret->diff]);
+
+    if (name) *name = dupstr(buf);
+    *params = ret;
+    return TRUE;
+}
+
+static game_params *default_params(void)
+{
+    game_params *ret;
+    game_fetch_preset(DEFAULT_PRESET, NULL, &ret);
+    return ret;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->h = params->w = atoi(string);
+    params->diff = DIFF_NORMAL;
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        params->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 'd') {
+        int i;
+        string++;
+        for (i = 0; i <= DIFF_UNREASONABLE; i++)
+            if (*string == galaxies_diffchars[i])
+                params->diff = i;
+        if (*string) string++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char str[80];
+    sprintf(str, "%dx%d", params->w, params->h);
+    if (full)
+        sprintf(str + strlen(str), "d%c", galaxies_diffchars[params->diff]);
+    return dupstr(str);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Difficulty";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = DIFFCONFIG;
+    ret[2].ival = params->diff;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->diff = cfg[2].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 3 || params->h < 3)
+        return "Width and height must both be at least 3";
+    /*
+     * This shouldn't be able to happen at all, since decode_params
+     * and custom_params will never generate anything that isn't
+     * within range.
+     */
+    assert(params->diff <= DIFF_UNREASONABLE);
+
+    return NULL;
+}
+
+/* ----------------------------------------------------------
+ * Game utility functions.
+ */
+
+static void add_dot(space *space) {
+    assert(!(space->flags & F_DOT));
+    space->flags |= F_DOT;
+    space->nassoc = 0;
+}
+
+static void remove_dot(space *space) {
+    assert(space->flags & F_DOT);
+    space->flags &= ~F_DOT;
+}
+
+static void remove_assoc(const game_state *state, space *tile) {
+    if (tile->flags & F_TILE_ASSOC) {
+        SPACE(state, tile->dotx, tile->doty).nassoc--;
+        tile->flags &= ~F_TILE_ASSOC;
+        tile->dotx = -1;
+        tile->doty = -1;
+    }
+}
+
+static void remove_assoc_with_opposite(game_state *state, space *tile) {
+    space *opposite;
+
+    if (!(tile->flags & F_TILE_ASSOC)) {
+        return;
+    }
+
+    opposite = tile_opposite(state, tile);
+    remove_assoc(state, tile);
+
+    if (opposite != NULL && opposite != tile) {
+        remove_assoc(state, opposite);
+    }
+}
+
+static void add_assoc(const game_state *state, space *tile, space *dot) {
+    remove_assoc(state, tile);
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+    if (picture)
+        assert(!picture[(tile->y/2) * state->w + (tile->x/2)] ==
+               !(dot->flags & F_DOT_BLACK));
+#endif
+    tile->flags |= F_TILE_ASSOC;
+    tile->dotx = dot->x;
+    tile->doty = dot->y;
+    dot->nassoc++;
+    /*debug(("add_assoc sp %d %d --> dot %d,%d, new nassoc %d.\n",
+           tile->x, tile->y, dot->x, dot->y, dot->nassoc));*/
+}
+
+static void add_assoc_with_opposite(game_state *state, space *tile, space *dot) {
+    int *colors;
+    space *opposite = space_opposite_dot(state, tile, dot);
+
+    if (opposite == NULL) {
+        return;
+    }
+    if (opposite->flags & F_DOT) {
+        return;
+    }
+
+    colors = snewn(state->w * state->h, int);
+    check_complete(state, NULL, colors);
+    if (colors[(tile->y - 1)/2 * state->w + (tile->x - 1)/2]) {
+        sfree(colors);
+        return;
+    }
+    if (colors[(opposite->y - 1)/2 * state->w + (opposite->x - 1)/2]) {
+        sfree(colors);
+        return;
+    }
+
+    sfree(colors);
+    remove_assoc_with_opposite(state, tile);
+    add_assoc(state, tile, dot);
+    remove_assoc_with_opposite(state, opposite);
+    add_assoc(state, opposite, dot);
+}
+
+static space *sp2dot(const game_state *state, int x, int y)
+{
+    space *sp = &SPACE(state, x, y);
+    if (!(sp->flags & F_TILE_ASSOC)) return NULL;
+    return &SPACE(state, sp->dotx, sp->doty);
+}
+
+#define IS_VERTICAL_EDGE(x) ((x % 2) == 0)
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int maxlen = (state->sx+1)*state->sy, x, y;
+    char *ret, *p;
+    space *sp;
+
+    ret = snewn(maxlen+1, char);
+    p = ret;
+
+    for (y = 0; y < state->sy; y++) {
+        for (x = 0; x < state->sx; x++) {
+            sp = &SPACE(state, x, y);
+            if (sp->flags & F_DOT)
+                *p++ = 'o';
+#if 0
+            else if (sp->flags & (F_REACHABLE|F_MULTIPLE|F_MARK))
+                *p++ = (sp->flags & F_MULTIPLE) ? 'M' :
+                    (sp->flags & F_REACHABLE) ? 'R' : 'X';
+#endif
+            else {
+                switch (sp->type) {
+                case s_tile:
+                    if (sp->flags & F_TILE_ASSOC) {
+                        space *dot = sp2dot(state, sp->x, sp->y);
+                        if (dot && dot->flags & F_DOT)
+                            *p++ = (dot->flags & F_DOT_BLACK) ? 'B' : 'W';
+                        else
+                            *p++ = '?'; /* association with not-a-dot. */
+                    } else
+                        *p++ = ' ';
+                    break;
+
+                case s_vertex:
+                    *p++ = '+';
+                    break;
+
+                case s_edge:
+                    if (sp->flags & F_EDGE_SET)
+                        *p++ = (IS_VERTICAL_EDGE(x)) ? '|' : '-';
+                    else
+                        *p++ = ' ';
+                    break;
+
+                default:
+                    assert(!"shouldn't get here!");
+                }
+            }
+        }
+        *p++ = '\n';
+    }
+
+    assert(p - ret == maxlen);
+    *p = '\0';
+
+    return ret;
+}
+
+static void dbg_state(const game_state *state)
+{
+#ifdef DEBUGGING
+    char *temp = game_text_format(state);
+    debug(("%s\n", temp));
+    sfree(temp);
+#endif
+}
+
+/* Space-enumeration callbacks should all return 1 for 'progress made',
+ * -1 for 'impossible', and 0 otherwise. */
+typedef int (*space_cb)(game_state *state, space *sp, void *ctx);
+
+#define IMPOSSIBLE_QUITS        1
+
+static int foreach_sub(game_state *state, space_cb cb, unsigned int f,
+                       void *ctx, int startx, int starty)
+{
+    int x, y, progress = 0, impossible = 0, ret;
+    space *sp;
+
+    for (y = starty; y < state->sy; y += 2) {
+        sp = &SPACE(state, startx, y);
+        for (x = startx; x < state->sx; x += 2) {
+            ret = cb(state, sp, ctx);
+            if (ret == -1) {
+                if (f & IMPOSSIBLE_QUITS) return -1;
+                impossible = -1;
+            } else if (ret == 1) {
+                progress = 1;
+            }
+            sp += 2;
+        }
+    }
+    return impossible ? -1 : progress;
+}
+
+static int foreach_tile(game_state *state, space_cb cb, unsigned int f,
+                        void *ctx)
+{
+    return foreach_sub(state, cb, f, ctx, 1, 1);
+}
+
+static int foreach_edge(game_state *state, space_cb cb, unsigned int f,
+                        void *ctx)
+{
+    int ret1, ret2;
+
+    ret1 = foreach_sub(state, cb, f, ctx, 0, 1);
+    ret2 = foreach_sub(state, cb, f, ctx, 1, 0);
+
+    if (ret1 == -1 || ret2 == -1) return -1;
+    return (ret1 || ret2) ? 1 : 0;
+}
+
+#if 0
+static int foreach_vertex(game_state *state, space_cb cb, unsigned int f,
+                          void *ctx)
+{
+    return foreach_sub(state, cb, f, ctx, 0, 0);
+}
+#endif
+
+#if 0
+static int is_same_assoc(game_state *state,
+                         int x1, int y1, int x2, int y2)
+{
+    space *s1, *s2;
+
+    if (!INGRID(state, x1, y1) || !INGRID(state, x2, y2))
+        return 0;
+
+    s1 = &SPACE(state, x1, y1);
+    s2 = &SPACE(state, x2, y2);
+    assert(s1->type == s_tile && s2->type == s_tile);
+    if ((s1->flags & F_TILE_ASSOC) && (s2->flags & F_TILE_ASSOC) &&
+        s1->dotx == s2->dotx && s1->doty == s2->doty)
+        return 1;
+    return 0; /* 0 if not same or not both associated. */
+}
+#endif
+
+#if 0
+static int edges_into_vertex(game_state *state,
+                             int x, int y)
+{
+    int dx, dy, nx, ny, count = 0;
+
+    assert(SPACE(state, x, y).type == s_vertex);
+    for (dx = -1; dx <= 1; dx++) {
+        for (dy = -1; dy <= 1; dy++) {
+            if (dx != 0 && dy != 0) continue;
+            if (dx == 0 && dy == 0) continue;
+
+            nx = x+dx; ny = y+dy;
+            if (!INGRID(state, nx, ny)) continue;
+            assert(SPACE(state, nx, ny).type == s_edge);
+            if (SPACE(state, nx, ny).flags & F_EDGE_SET)
+                count++;
+        }
+    }
+    return count;
+}
+#endif
+
+static space *space_opposite_dot(const game_state *state, const space *sp,
+                                 const space *dot)
+{
+    int dx, dy, tx, ty;
+    space *sp2;
+
+    dx = sp->x - dot->x;
+    dy = sp->y - dot->y;
+    tx = dot->x - dx;
+    ty = dot->y - dy;
+    if (!INGRID(state, tx, ty)) return NULL;
+
+    sp2 = &SPACE(state, tx, ty);
+    assert(sp2->type == sp->type);
+    return sp2;
+}
+
+static space *tile_opposite(const game_state *state, const space *sp)
+{
+    space *dot;
+
+    assert(sp->flags & F_TILE_ASSOC);
+    dot = &SPACE(state, sp->dotx, sp->doty);
+    return space_opposite_dot(state, sp, dot);
+}
+
+static int dotfortile(game_state *state, space *tile, space *dot)
+{
+    space *tile_opp = space_opposite_dot(state, tile, dot);
+
+    if (!tile_opp) return 0; /* opposite would be off grid */
+    if (tile_opp->flags & F_TILE_ASSOC &&
+            (tile_opp->dotx != dot->x || tile_opp->doty != dot->y))
+            return 0; /* opposite already associated with diff. dot */
+    return 1;
+}
+
+static void adjacencies(game_state *state, space *sp, space **a1s, space **a2s)
+{
+    int dxs[4] = {-1, 1, 0, 0}, dys[4] = {0, 0, -1, 1};
+    int n, x, y;
+
+    /* this function needs optimising. */
+
+    for (n = 0; n < 4; n++) {
+        x = sp->x+dxs[n];
+        y = sp->y+dys[n];
+
+        if (INGRID(state, x, y)) {
+            a1s[n] = &SPACE(state, x, y);
+
+            x += dxs[n]; y += dys[n];
+
+            if (INGRID(state, x, y))
+                a2s[n] = &SPACE(state, x, y);
+            else
+                a2s[n] = NULL;
+        } else {
+            a1s[n] = a2s[n] = NULL;
+        }
+    }
+}
+
+static int outline_tile_fordot(game_state *state, space *tile, int mark)
+{
+    space *tadj[4], *eadj[4];
+    int i, didsth = 0, edge, same;
+
+    assert(tile->type == s_tile);
+    adjacencies(state, tile, eadj, tadj);
+    for (i = 0; i < 4; i++) {
+        if (!eadj[i]) continue;
+
+        edge = (eadj[i]->flags & F_EDGE_SET) ? 1 : 0;
+        if (tadj[i]) {
+            if (!(tile->flags & F_TILE_ASSOC))
+                same = (tadj[i]->flags & F_TILE_ASSOC) ? 0 : 1;
+            else
+                same = ((tadj[i]->flags & F_TILE_ASSOC) &&
+                    tile->dotx == tadj[i]->dotx &&
+                    tile->doty == tadj[i]->doty) ? 1 : 0;
+        } else
+            same = 0;
+
+        if (!edge && !same) {
+            if (mark) eadj[i]->flags |= F_EDGE_SET;
+            didsth = 1;
+        } else if (edge && same) {
+            if (mark) eadj[i]->flags &= ~F_EDGE_SET;
+            didsth = 1;
+        }
+    }
+    return didsth;
+}
+
+static void tiles_from_edge(game_state *state, space *sp, space **ts)
+{
+    int xs[2], ys[2];
+
+    if (IS_VERTICAL_EDGE(sp->x)) {
+        xs[0] = sp->x-1; ys[0] = sp->y;
+        xs[1] = sp->x+1; ys[1] = sp->y;
+    } else {
+        xs[0] = sp->x; ys[0] = sp->y-1;
+        xs[1] = sp->x; ys[1] = sp->y+1;
+    }
+    ts[0] = INGRID(state, xs[0], ys[0]) ? &SPACE(state, xs[0], ys[0]) : NULL;
+    ts[1] = INGRID(state, xs[1], ys[1]) ? &SPACE(state, xs[1], ys[1]) : NULL;
+}
+
+/* Returns a move string for use by 'solve', including the initial
+ * 'S' if issolve is true. */
+static char *diff_game(const game_state *src, const game_state *dest,
+                       int issolve)
+{
+    int movelen = 0, movesize = 256, x, y, len;
+    char *move = snewn(movesize, char), buf[80], *sep = "";
+    char achar = issolve ? 'a' : 'A';
+    space *sps, *spd;
+
+    assert(src->sx == dest->sx && src->sy == dest->sy);
+
+    if (issolve) {
+        move[movelen++] = 'S';
+        sep = ";";
+    }
+    move[movelen] = '\0';
+    for (x = 0; x < src->sx; x++) {
+        for (y = 0; y < src->sy; y++) {
+            sps = &SPACE(src, x, y);
+            spd = &SPACE(dest, x, y);
+
+            assert(sps->type == spd->type);
+
+            len = 0;
+            if (sps->type == s_tile) {
+                if ((sps->flags & F_TILE_ASSOC) &&
+                    (spd->flags & F_TILE_ASSOC)) {
+                    if (sps->dotx != spd->dotx ||
+                        sps->doty != spd->doty)
+                    /* Both associated; change association, if different */
+                        len = sprintf(buf, "%s%c%d,%d,%d,%d", sep,
+                                      (int)achar, x, y, spd->dotx, spd->doty);
+                } else if (sps->flags & F_TILE_ASSOC)
+                    /* Only src associated; remove. */
+                    len = sprintf(buf, "%sU%d,%d", sep, x, y);
+                else if (spd->flags & F_TILE_ASSOC)
+                    /* Only dest associated; add. */
+                    len = sprintf(buf, "%s%c%d,%d,%d,%d", sep,
+                                  (int)achar, x, y, spd->dotx, spd->doty);
+            } else if (sps->type == s_edge) {
+                if ((sps->flags & F_EDGE_SET) != (spd->flags & F_EDGE_SET))
+                    /* edge flags are different; flip them. */
+                    len = sprintf(buf, "%sE%d,%d", sep, x, y);
+            }
+            if (len) {
+                if (movelen + len >= movesize) {
+                    movesize = movelen + len + 256;
+                    move = sresize(move, movesize, char);
+                }
+                strcpy(move + movelen, buf);
+                movelen += len;
+                sep = ";";
+            }
+        }
+    }
+    debug(("diff_game src then dest:\n"));
+    dbg_state(src);
+    dbg_state(dest);
+    debug(("diff string %s\n", move));
+    return move;
+}
+
+/* Returns 1 if a dot here would not be too close to any other dots
+ * (and would avoid other game furniture). */
+static int dot_is_possible(game_state *state, space *sp, int allow_assoc)
+{
+    int bx = 0, by = 0, dx, dy;
+    space *adj;
+#ifdef STANDALONE_PICTURE_GENERATOR
+    int col = -1;
+#endif
+
+    switch (sp->type) {
+    case s_tile:
+        bx = by = 1; break;
+    case s_edge:
+        if (IS_VERTICAL_EDGE(sp->x)) {
+            bx = 2; by = 1;
+        } else {
+            bx = 1; by = 2;
+        }
+        break;
+    case s_vertex:
+        bx = by = 2; break;
+    }
+
+    for (dx = -bx; dx <= bx; dx++) {
+        for (dy = -by; dy <= by; dy++) {
+            if (!INGRID(state, sp->x+dx, sp->y+dy)) continue;
+
+            adj = &SPACE(state, sp->x+dx, sp->y+dy);
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+            /*
+             * Check that all the squares we're looking at have the
+             * same colour.
+             */
+            if (picture) {
+                if (adj->type == s_tile) {
+                    int c = picture[(adj->y / 2) * state->w + (adj->x / 2)];
+                    if (col < 0)
+                        col = c;
+                    if (c != col)
+                        return 0;          /* colour mismatch */
+                }
+            }
+#endif
+
+            if (!allow_assoc && (adj->flags & F_TILE_ASSOC))
+                return 0;
+
+            if (dx != 0 || dy != 0) {
+                /* Other than our own square, no dots nearby. */
+                if (adj->flags & (F_DOT))
+                    return 0;
+            }
+
+            /* We don't want edges within our rectangle
+             * (but don't care about edges on the edge) */
+            if (abs(dx) < bx && abs(dy) < by &&
+                adj->flags & F_EDGE_SET)
+                return 0;
+        }
+    }
+    return 1;
+}
+
+/* ----------------------------------------------------------
+ * Game generation, structure creation, and descriptions.
+ */
+
+static game_state *blank_game(int w, int h)
+{
+    game_state *state = snew(game_state);
+    int x, y;
+
+    state->w = w;
+    state->h = h;
+
+    state->sx = (w*2)+1;
+    state->sy = (h*2)+1;
+    state->grid = snewn(state->sx * state->sy, space);
+    state->completed = state->used_solve = 0;
+
+    for (x = 0; x < state->sx; x++) {
+        for (y = 0; y < state->sy; y++) {
+            space *sp = &SPACE(state, x, y);
+            memset(sp, 0, sizeof(space));
+            sp->x = x;
+            sp->y = y;
+            if ((x % 2) == 0 && (y % 2) == 0)
+                sp->type = s_vertex;
+            else if ((x % 2) == 0 || (y % 2) == 0) {
+                sp->type = s_edge;
+                if (x == 0 || y == 0 || x == state->sx-1 || y == state->sy-1)
+                    sp->flags |= F_EDGE_SET;
+            } else
+                sp->type = s_tile;
+        }
+    }
+
+    state->ndots = 0;
+    state->dots = NULL;
+
+    state->me = NULL; /* filled in by new_game. */
+    state->cdiff = -1;
+
+    return state;
+}
+
+static void game_update_dots(game_state *state)
+{
+    int i, n, sz = state->sx * state->sy;
+
+    if (state->dots) sfree(state->dots);
+    state->ndots = 0;
+
+    for (i = 0; i < sz; i++) {
+        if (state->grid[i].flags & F_DOT) state->ndots++;
+    }
+    state->dots = snewn(state->ndots, space *);
+    n = 0;
+    for (i = 0; i < sz; i++) {
+        if (state->grid[i].flags & F_DOT)
+            state->dots[n++] = &state->grid[i];
+    }
+}
+
+static void clear_game(game_state *state, int cleardots)
+{
+    int x, y;
+
+    /* don't erase edge flags around outline! */
+    for (x = 1; x < state->sx-1; x++) {
+        for (y = 1; y < state->sy-1; y++) {
+            if (cleardots)
+                SPACE(state, x, y).flags = 0;
+            else
+                SPACE(state, x, y).flags &= (F_DOT|F_DOT_BLACK);
+        }
+    }
+    if (cleardots) game_update_dots(state);
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = blank_game(state->w, state->h);
+
+    ret->completed = state->completed;
+    ret->used_solve = state->used_solve;
+
+    memcpy(ret->grid, state->grid,
+           ret->sx*ret->sy*sizeof(space));
+
+    game_update_dots(ret);
+
+    ret->me = state->me;
+    ret->cdiff = state->cdiff;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (state->dots) sfree(state->dots);
+    sfree(state->grid);
+    sfree(state);
+}
+
+/* Game description is a sequence of letters representing the number
+ * of spaces (a = 0, y = 24) before the next dot; a-y for a white dot,
+ * and A-Y for a black dot. 'z' is 25 spaces (and no dot).
+ *
+ * I know it's a bitch to generate by hand, so we provide
+ * an edit mode.
+ */
+
+static char *encode_game(game_state *state)
+{
+    char *desc, *p;
+    int run, x, y, area;
+    unsigned int f;
+
+    area = (state->sx-2) * (state->sy-2);
+
+    desc = snewn(area, char);
+    p = desc;
+    run = 0;
+    for (y = 1; y < state->sy-1; y++) {
+        for (x = 1; x < state->sx-1; x++) {
+            f = SPACE(state, x, y).flags;
+
+            /* a/A is 0 spaces between, b/B is 1 space, ...
+             * y/Y is 24 spaces, za/zA is 25 spaces, ...
+             * It's easier to count from 0 because we then
+             * don't have to special-case the top left-hand corner
+             * (which could be a dot with 0 spaces before it). */
+            if (!(f & F_DOT))
+                run++;
+            else {
+                while (run > 24) {
+                    *p++ = 'z';
+                    run -= 25;
+                }
+                *p++ = ((f & F_DOT_BLACK) ? 'A' : 'a') + run;
+                run = 0;
+            }
+        }
+    }
+    assert(p - desc < area);
+    *p++ = '\0';
+    desc = sresize(desc, p - desc, char);
+
+    return desc;
+}
+
+struct movedot {
+    int op;
+    space *olddot, *newdot;
+};
+
+enum { MD_CHECK, MD_MOVE };
+
+static int movedot_cb(game_state *state, space *tile, void *vctx)
+{
+   struct movedot *md = (struct movedot *)vctx;
+   space *newopp = NULL;
+
+   assert(tile->type == s_tile);
+   assert(md->olddot && md->newdot);
+
+   if (!(tile->flags & F_TILE_ASSOC)) return 0;
+   if (tile->dotx != md->olddot->x || tile->doty != md->olddot->y)
+       return 0;
+
+   newopp = space_opposite_dot(state, tile, md->newdot);
+
+   switch (md->op) {
+   case MD_CHECK:
+       /* If the tile is associated with the old dot, check its
+        * opposite wrt the _new_ dot is empty or same assoc. */
+       if (!newopp) return -1; /* no new opposite */
+       if (newopp->flags & F_TILE_ASSOC) {
+           if (newopp->dotx != md->olddot->x ||
+               newopp->doty != md->olddot->y)
+               return -1; /* associated, but wrong dot. */
+       }
+#ifdef STANDALONE_PICTURE_GENERATOR
+       if (picture) {
+           /*
+            * Reject if either tile and the dot don't match in colour.
+            */
+           if (!(picture[(tile->y/2) * state->w + (tile->x/2)]) ^
+               !(md->newdot->flags & F_DOT_BLACK))
+               return -1;
+           if (!(picture[(newopp->y/2) * state->w + (newopp->x/2)]) ^
+               !(md->newdot->flags & F_DOT_BLACK))
+               return -1;
+       }
+#endif
+       break;
+
+   case MD_MOVE:
+       /* Move dot associations: anything that was associated
+        * with the old dot, and its opposite wrt the new dot,
+        * become associated with the new dot. */
+       assert(newopp);
+       debug(("Associating %d,%d and %d,%d with new dot %d,%d.\n",
+              tile->x, tile->y, newopp->x, newopp->y,
+              md->newdot->x, md->newdot->y));
+       add_assoc(state, tile, md->newdot);
+       add_assoc(state, newopp, md->newdot);
+       return 1; /* we did something! */
+   }
+   return 0;
+}
+
+/* For the given dot, first see if we could expand it into all the given
+ * extra spaces (by checking for empty spaces on the far side), and then
+ * see if we can move the dot to shift the CoG to include the new spaces.
+ */
+static int dot_expand_or_move(game_state *state, space *dot,
+                              space **toadd, int nadd)
+{
+    space *tileopp;
+    int i, ret, nnew, cx, cy;
+    struct movedot md;
+
+    debug(("dot_expand_or_move: %d tiles for dot %d,%d\n",
+           nadd, dot->x, dot->y));
+    for (i = 0; i < nadd; i++)
+        debug(("dot_expand_or_move:   dot %d,%d\n",
+               toadd[i]->x, toadd[i]->y));
+    assert(dot->flags & F_DOT);
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+    if (picture) {
+        /*
+         * Reject the expansion totally if any of the new tiles are
+         * the wrong colour.
+         */
+        for (i = 0; i < nadd; i++) {
+            if (!(picture[(toadd[i]->y/2) * state->w + (toadd[i]->x/2)]) ^
+                !(dot->flags & F_DOT_BLACK))
+                return 0;
+        }
+    }
+#endif
+
+    /* First off, could we just expand the current dot's tile to cover
+     * the space(s) passed in and their opposites? */
+    for (i = 0; i < nadd; i++) {
+        tileopp = space_opposite_dot(state, toadd[i], dot);
+        if (!tileopp) goto noexpand;
+        if (tileopp->flags & F_TILE_ASSOC) goto noexpand;
+#ifdef STANDALONE_PICTURE_GENERATOR
+        if (picture) {
+            /*
+             * The opposite tiles have to be the right colour as well.
+             */
+            if (!(picture[(tileopp->y/2) * state->w + (tileopp->x/2)]) ^
+                !(dot->flags & F_DOT_BLACK))
+                goto noexpand;
+        }
+#endif
+    }
+    /* OK, all spaces have valid empty opposites: associate spaces and
+     * opposites with our dot. */
+    for (i = 0; i < nadd; i++) {
+        tileopp = space_opposite_dot(state, toadd[i], dot);
+        add_assoc(state, toadd[i], dot);
+        add_assoc(state, tileopp, dot);
+        debug(("Added associations %d,%d and %d,%d --> %d,%d\n",
+               toadd[i]->x, toadd[i]->y,
+               tileopp->x, tileopp->y,
+               dot->x, dot->y));
+        dbg_state(state);
+    }
+    return 1;
+
+noexpand:
+    /* Otherwise, try to move dot so as to encompass given spaces: */
+    /* first, calculate the 'centre of gravity' of the new dot. */
+    nnew = dot->nassoc + nadd; /* number of tiles assoc. with new dot. */
+    cx = dot->x * dot->nassoc;
+    cy = dot->y * dot->nassoc;
+    for (i = 0; i < nadd; i++) {
+        cx += toadd[i]->x;
+        cy += toadd[i]->y;
+    }
+    /* If the CoG isn't a whole number, it's not possible. */
+    if ((cx % nnew) != 0 || (cy % nnew) != 0) {
+        debug(("Unable to move dot %d,%d, CoG not whole number.\n",
+               dot->x, dot->y));
+        return 0;
+    }
+    cx /= nnew; cy /= nnew;
+
+    /* Check whether all spaces in the old tile would have a good
+     * opposite wrt the new dot. */
+    md.olddot = dot;
+    md.newdot = &SPACE(state, cx, cy);
+    md.op = MD_CHECK;
+    ret = foreach_tile(state, movedot_cb, IMPOSSIBLE_QUITS, &md);
+    if (ret == -1) {
+        debug(("Unable to move dot %d,%d, new dot not symmetrical.\n",
+               dot->x, dot->y));
+        return 0;
+    }
+    /* Also check whether all spaces we're adding would have a good
+     * opposite wrt the new dot. */
+    for (i = 0; i < nadd; i++) {
+        tileopp = space_opposite_dot(state, toadd[i], md.newdot);
+        if (tileopp && (tileopp->flags & F_TILE_ASSOC) &&
+            (tileopp->dotx != dot->x || tileopp->doty != dot->y)) {
+            tileopp = NULL;
+        }
+        if (!tileopp) {
+            debug(("Unable to move dot %d,%d, new dot not symmetrical.\n",
+               dot->x, dot->y));
+            return 0;
+        }
+#ifdef STANDALONE_PICTURE_GENERATOR
+        if (picture) {
+            if (!(picture[(tileopp->y/2) * state->w + (tileopp->x/2)]) ^
+                !(dot->flags & F_DOT_BLACK))
+                return 0;
+        }
+#endif
+    }
+
+    /* If we've got here, we're ok. First, associate all of 'toadd'
+     * with the _old_ dot (so they'll get fixed up, with their opposites,
+     * in the next step). */
+    for (i = 0; i < nadd; i++) {
+        debug(("Associating to-add %d,%d with old dot %d,%d.\n",
+               toadd[i]->x, toadd[i]->y, dot->x, dot->y));
+        add_assoc(state, toadd[i], dot);
+    }
+
+    /* Finally, move the dot and fix up all the old associations. */
+    debug(("Moving dot at %d,%d to %d,%d\n",
+           dot->x, dot->y, md.newdot->x, md.newdot->y));
+    {
+#ifdef STANDALONE_PICTURE_GENERATOR
+        int f = dot->flags & F_DOT_BLACK;
+#endif
+        remove_dot(dot);
+        add_dot(md.newdot);
+#ifdef STANDALONE_PICTURE_GENERATOR
+        md.newdot->flags |= f;
+#endif
+    }
+
+    md.op = MD_MOVE;
+    ret = foreach_tile(state, movedot_cb, 0, &md);
+    assert(ret == 1);
+    dbg_state(state);
+
+    return 1;
+}
+
+/* Hard-code to a max. of 2x2 squares, for speed (less malloc) */
+#define MAX_TOADD 4
+#define MAX_OUTSIDE 8
+
+#define MAX_TILE_PERC 20
+
+static int generate_try_block(game_state *state, random_state *rs,
+                              int x1, int y1, int x2, int y2)
+{
+    int x, y, nadd = 0, nout = 0, i, maxsz;
+    space *sp, *toadd[MAX_TOADD], *outside[MAX_OUTSIDE], *dot;
+
+    if (!INGRID(state, x1, y1) || !INGRID(state, x2, y2)) return 0;
+
+    /* We limit the maximum size of tiles to be ~2*sqrt(area); so,
+     * a 5x5 grid shouldn't have anything >10 tiles, a 20x20 grid
+     * nothing >40 tiles. */
+    maxsz = (int)sqrt((double)(state->w * state->h)) * 2;
+    debug(("generate_try_block, maxsz %d\n", maxsz));
+
+    /* Make a static list of the spaces; if any space is already
+     * associated then quit immediately. */
+    for (x = x1; x <= x2; x += 2) {
+        for (y = y1; y <= y2; y += 2) {
+            assert(nadd < MAX_TOADD);
+            sp = &SPACE(state, x, y);
+            assert(sp->type == s_tile);
+            if (sp->flags & F_TILE_ASSOC) return 0;
+            toadd[nadd++] = sp;
+        }
+    }
+
+    /* Make a list of the spaces outside of our block, and shuffle it. */
+#define OUTSIDE(x, y) do {                              \
+    if (INGRID(state, (x), (y))) {                      \
+        assert(nout < MAX_OUTSIDE);                     \
+        outside[nout++] = &SPACE(state, (x), (y));      \
+    }                                                   \
+} while(0)
+    for (x = x1; x <= x2; x += 2) {
+        OUTSIDE(x, y1-2);
+        OUTSIDE(x, y2+2);
+    }
+    for (y = y1; y <= y2; y += 2) {
+        OUTSIDE(x1-2, y);
+        OUTSIDE(x2+2, y);
+    }
+    shuffle(outside, nout, sizeof(space *), rs);
+
+    for (i = 0; i < nout; i++) {
+        if (!(outside[i]->flags & F_TILE_ASSOC)) continue;
+        dot = &SPACE(state, outside[i]->dotx, outside[i]->doty);
+        if (dot->nassoc >= maxsz) {
+            debug(("Not adding to dot %d,%d, large enough (%d) already.\n",
+                   dot->x, dot->y, dot->nassoc));
+            continue;
+        }
+        if (dot_expand_or_move(state, dot, toadd, nadd)) return 1;
+    }
+    return 0;
+}
+
+#ifdef STANDALONE_SOLVER
+int maxtries;
+#define MAXTRIES maxtries
+#else
+#define MAXTRIES 50
+#endif
+
+#define GP_DOTS   1
+
+static void generate_pass(game_state *state, random_state *rs, int *scratch,
+                         int perc, unsigned int flags)
+{
+    int sz = state->sx*state->sy, nspc, i, ret;
+
+    shuffle(scratch, sz, sizeof(int), rs);
+
+    /* This bug took me a, er, little while to track down. On PalmOS,
+     * which has 16-bit signed ints, puzzles over about 9x9 started
+     * failing to generate because the nspc calculation would start
+     * to overflow, causing the dots not to be filled in properly. */
+    nspc = (int)(((long)perc * (long)sz) / 100L);
+    debug(("generate_pass: %d%% (%d of %dx%d) squares, flags 0x%x\n",
+           perc, nspc, state->sx, state->sy, flags));
+
+    for (i = 0; i < nspc; i++) {
+        space *sp = &state->grid[scratch[i]];
+        int x1 = sp->x, y1 = sp->y, x2 = sp->x, y2 = sp->y;
+
+        if (sp->type == s_edge) {
+            if (IS_VERTICAL_EDGE(sp->x)) {
+                x1--; x2++;
+            } else {
+                y1--; y2++;
+            }
+        }
+        if (sp->type != s_vertex) {
+            /* heuristic; expanding from vertices tends to generate lots of
+             * too-big regions of tiles. */
+            if (generate_try_block(state, rs, x1, y1, x2, y2))
+                continue; /* we expanded successfully. */
+        }
+
+        if (!(flags & GP_DOTS)) continue;
+
+        if ((sp->type == s_edge) && (i % 2)) {
+            debug(("Omitting edge %d,%d as half-of.\n", sp->x, sp->y));
+            continue;
+        }
+
+        /* If we've got here we might want to put a dot down. Check
+         * if we can, and add one if so. */
+        if (dot_is_possible(state, sp, 0)) {
+            add_dot(sp);
+#ifdef STANDALONE_PICTURE_GENERATOR
+            if (picture) {
+                if (picture[(sp->y/2) * state->w + (sp->x/2)])
+                    sp->flags |= F_DOT_BLACK;
+            }
+#endif
+            ret = solver_obvious_dot(state, sp);
+            assert(ret != -1);
+            debug(("Added dot (and obvious associations) at %d,%d\n",
+                   sp->x, sp->y));
+            dbg_state(state);
+        }
+    }
+    dbg_state(state);
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    game_state *state = blank_game(params->w, params->h), *copy;
+    char *desc;
+    int *scratch, sz = state->sx*state->sy, i;
+    int diff, ntries = 0, cc;
+
+    /* Random list of squares to try and process, one-by-one. */
+    scratch = snewn(sz, int);
+    for (i = 0; i < sz; i++) scratch[i] = i;
+
+generate:
+    clear_game(state, 1);
+    ntries++;
+
+    /* generate_pass(state, rs, scratch, 10, GP_DOTS); */
+    /* generate_pass(state, rs, scratch, 100, 0); */
+    generate_pass(state, rs, scratch, 100, GP_DOTS);
+
+    game_update_dots(state);
+
+    if (state->ndots == 1) goto generate;
+
+#ifdef DEBUGGING
+    {
+        char *tmp = encode_game(state);
+        debug(("new_game_desc state %dx%d:%s\n", params->w, params->h, tmp));
+        sfree(tmp);
+    }
+#endif
+
+    for (i = 0; i < state->sx*state->sy; i++)
+        if (state->grid[i].type == s_tile)
+            outline_tile_fordot(state, &state->grid[i], TRUE);
+    cc = check_complete(state, NULL, NULL);
+    assert(cc);
+
+    copy = dup_game(state);
+    clear_game(copy, 0);
+    dbg_state(copy);
+    diff = solver_state(copy, params->diff);
+    free_game(copy);
+
+    assert(diff != DIFF_IMPOSSIBLE);
+    if (diff != params->diff) {
+        /*
+         * We'll grudgingly accept a too-easy puzzle, but we must
+         * _not_ permit a too-hard one (one which the solver
+         * couldn't handle at all).
+         */
+        if (diff > params->diff ||
+            ntries < MAXTRIES) goto generate;
+    }
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+    /*
+     * Postprocessing pass to prevent excessive numbers of adjacent
+     * singletons. Iterate over all edges in random shuffled order;
+     * for each edge that separates two regions, investigate
+     * whether removing that edge and merging the regions would
+     * still yield a valid and soluble puzzle. (The two regions
+     * must also be the same colour, of course.) If so, do it.
+     * 
+     * This postprocessing pass is slow (due to repeated solver
+     * invocations), and seems to be unnecessary during normal
+     * unconstrained game generation. However, when generating a
+     * game under colour constraints, excessive singletons seem to
+     * turn up more often, so it's worth doing this.
+     */
+    {
+        int *posns, nposns;
+        int i, j, newdiff;
+        game_state *copy2;
+
+        nposns = params->w * (params->h+1) + params->h * (params->w+1);
+        posns = snewn(nposns, int);
+        for (i = j = 0; i < state->sx*state->sy; i++)
+            if (state->grid[i].type == s_edge)
+                posns[j++] = i;
+        assert(j == nposns);
+
+        shuffle(posns, nposns, sizeof(*posns), rs);
+
+        for (i = 0; i < nposns; i++) {
+            int x, y, x0, y0, x1, y1, cx, cy, cn, cx0, cy0, cx1, cy1, tx, ty;
+            space *s0, *s1, *ts, *d0, *d1, *dn;
+            int ok;
+
+            /* Coordinates of edge space */
+            x = posns[i] % state->sx;
+            y = posns[i] / state->sx;
+
+            /* Coordinates of square spaces on either side of edge */
+            x0 = ((x+1) & ~1) - 1;     /* round down to next odd number */
+            y0 = ((y+1) & ~1) - 1;
+            x1 = 2*x-x0;               /* and reflect about x to get x1 */
+            y1 = 2*y-y0;
+
+            if (!INGRID(state, x0, y0) || !INGRID(state, x1, y1))
+                continue;              /* outermost edge of grid */
+            s0 = &SPACE(state, x0, y0);
+            s1 = &SPACE(state, x1, y1);
+            assert(s0->type == s_tile && s1->type == s_tile);
+
+            if (s0->dotx == s1->dotx && s0->doty == s1->doty)
+                continue;              /* tiles _already_ owned by same dot */
+
+            d0 = &SPACE(state, s0->dotx, s0->doty);
+            d1 = &SPACE(state, s1->dotx, s1->doty);
+
+            if ((d0->flags ^ d1->flags) & F_DOT_BLACK)
+                continue;              /* different colours: cannot merge */
+
+            /*
+             * Work out where the centre of gravity of the new
+             * region would be.
+             */
+            cx = d0->nassoc * d0->x + d1->nassoc * d1->x;
+            cy = d0->nassoc * d0->y + d1->nassoc * d1->y;
+            cn = d0->nassoc + d1->nassoc;
+            if (cx % cn || cy % cn)
+                continue;              /* CoG not at integer coordinates */
+            cx /= cn;
+            cy /= cn;
+            assert(INUI(state, cx, cy));
+
+            /*
+             * Ensure that the CoG would actually be _in_ the new
+             * region, by verifying that all its surrounding tiles
+             * belong to one or other of our two dots.
+             */
+            cx0 = ((cx+1) & ~1) - 1;   /* round down to next odd number */
+            cy0 = ((cy+1) & ~1) - 1;
+            cx1 = 2*cx-cx0;            /* and reflect about cx to get cx1 */
+            cy1 = 2*cy-cy0;
+            ok = TRUE;
+            for (ty = cy0; ty <= cy1; ty += 2)
+                for (tx = cx0; tx <= cx1; tx += 2) {
+                    ts = &SPACE(state, tx, ty);
+                    assert(ts->type == s_tile);
+                    if ((ts->dotx != d0->x || ts->doty != d0->y) &&
+                        (ts->dotx != d1->x || ts->doty != d1->y))
+                        ok = FALSE;
+                }
+            if (!ok)
+                continue;
+
+            /*
+             * Verify that for every tile in either source region,
+             * that tile's image in the new CoG is also in one of
+             * the two source regions.
+             */
+            for (ty = 1; ty < state->sy; ty += 2) {
+                for (tx = 1; tx < state->sx; tx += 2) {
+                    int tx1, ty1;
+
+                    ts = &SPACE(state, tx, ty);
+                    assert(ts->type == s_tile);
+                    if ((ts->dotx != d0->x || ts->doty != d0->y) &&
+                        (ts->dotx != d1->x || ts->doty != d1->y))
+                        continue;      /* not part of these tiles anyway */
+                    tx1 = 2*cx-tx;
+                    ty1 = 2*cy-ty;
+                    if (!INGRID(state, tx1, ty1)) {
+                        ok = FALSE;
+                        break;
+                    }
+                    ts = &SPACE(state, cx+cx-tx, cy+cy-ty);
+                    if ((ts->dotx != d0->x || ts->doty != d0->y) &&
+                        (ts->dotx != d1->x || ts->doty != d1->y)) {
+                        ok = FALSE;
+                        break;
+                    }
+                }
+                if (!ok)
+                    break;
+            }
+            if (!ok)
+                continue;
+
+            /*
+             * Now we're clear to attempt the merge. We take a copy
+             * of the game state first, so we can revert it easily
+             * if the resulting puzzle turns out to have become
+             * insoluble.
+             */
+            copy2 = dup_game(state);
+
+            remove_dot(d0);
+            remove_dot(d1);
+            dn = &SPACE(state, cx, cy);
+            add_dot(dn);
+            dn->flags |= (d0->flags & F_DOT_BLACK);
+            for (ty = 1; ty < state->sy; ty += 2) {
+                for (tx = 1; tx < state->sx; tx += 2) {
+                    ts = &SPACE(state, tx, ty);
+                    assert(ts->type == s_tile);
+                    if ((ts->dotx != d0->x || ts->doty != d0->y) &&
+                        (ts->dotx != d1->x || ts->doty != d1->y))
+                        continue;      /* not part of these tiles anyway */
+                    add_assoc(state, ts, dn);
+                }
+            }
+
+            copy = dup_game(state);
+            clear_game(copy, 0);
+            dbg_state(copy);
+            newdiff = solver_state(copy, params->diff);
+            free_game(copy);
+            if (diff == newdiff) {
+                /* Still just as soluble. Let the merge stand. */
+                free_game(copy2);
+            } else {
+                /* Became insoluble. Revert. */
+                free_game(state);
+                state = copy2;
+            }
+        }
+        sfree(posns);
+    }
+#endif
+
+    desc = encode_game(state);
+#ifndef STANDALONE_SOLVER
+    debug(("new_game_desc generated: \n"));
+    dbg_state(state);
+#endif
+
+    free_game(state);
+    sfree(scratch);
+
+    return desc;
+}
+
+static int dots_too_close(game_state *state)
+{
+    /* Quick-and-dirty check, using half the solver:
+     * solver_obvious will only fail if the dots are
+     * too close together, so dot-proximity associations
+     * overlap. */
+    game_state *tmp = dup_game(state);
+    int ret = solver_obvious(tmp);
+    free_game(tmp);
+    return (ret == -1) ? 1 : 0;
+}
+
+static game_state *load_game(const game_params *params, const char *desc,
+                             char **why_r)
+{
+    game_state *state = blank_game(params->w, params->h);
+    char *why = NULL;
+    int i, x, y, n;
+    unsigned int df;
+
+    i = 0;
+    while (*desc) {
+        n = *desc++;
+        if (n == 'z') {
+            i += 25;
+            continue;
+        }
+        if (n >= 'a' && n <= 'y') {
+            i += n - 'a';
+            df = 0;
+        } else if (n >= 'A' && n <= 'Y') {
+            i += n - 'A';
+            df = F_DOT_BLACK;
+        } else {
+            why = "Invalid characters in game description"; goto fail;
+        }
+        /* if we got here we incremented i and have a dot to add. */
+        y = (i / (state->sx-2)) + 1;
+        x = (i % (state->sx-2)) + 1;
+        if (!INUI(state, x, y)) {
+            why = "Too much data to fit in grid"; goto fail;
+        }
+        add_dot(&SPACE(state, x, y));
+        SPACE(state, x, y).flags |= df;
+        i++;
+    }
+    game_update_dots(state);
+
+    if (dots_too_close(state)) {
+        why = "Dots too close together"; goto fail;
+    }
+
+    return state;
+
+fail:
+    free_game(state);
+    if (why_r) *why_r = why;
+    return NULL;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    char *why = NULL;
+    game_state *dummy = load_game(params, desc, &why);
+    if (dummy) {
+        free_game(dummy);
+        assert(!why);
+    } else
+        assert(why);
+    return why;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = load_game(params, desc, NULL);
+    if (!state) {
+        assert("Unable to load ?validated game.");
+        return NULL;
+    }
+#ifdef EDITOR
+    state->me = me;
+#endif
+    return state;
+}
+
+/* ----------------------------------------------------------
+ * Solver and all its little wizards.
+ */
+
+int solver_recurse_depth;
+
+typedef struct solver_ctx {
+    game_state *state;
+    int sz;             /* state->sx * state->sy */
+    space **scratch;    /* size sz */
+
+} solver_ctx;
+
+static solver_ctx *new_solver(game_state *state)
+{
+    solver_ctx *sctx = snew(solver_ctx);
+    sctx->state = state;
+    sctx->sz = state->sx*state->sy;
+    sctx->scratch = snewn(sctx->sz, space *);
+    return sctx;
+}
+
+static void free_solver(solver_ctx *sctx)
+{
+    sfree(sctx->scratch);
+    sfree(sctx);
+}
+
+    /* Solver ideas so far:
+     *
+     * For any empty space, work out how many dots it could associate
+     * with:
+       * it needs line-of-sight
+       * it needs an empty space on the far side
+       * any adjacent lines need corresponding line possibilities.
+     */
+
+/* The solver_ctx should keep a list of dot positions, for quicker looping.
+ *
+ * Solver techniques, in order of difficulty:
+   * obvious adjacency to dots
+   * transferring tiles to opposite side
+   * transferring lines to opposite side
+   * one possible dot for a given tile based on opposite availability
+   * tile with 3 definite edges next to an associated tile must associate
+      with same dot.
+   *
+   * one possible dot for a given tile based on line-of-sight
+ */
+
+static int solver_add_assoc(game_state *state, space *tile, int dx, int dy,
+                            const char *why)
+{
+    space *dot, *tile_opp;
+
+    dot = &SPACE(state, dx, dy);
+    tile_opp = space_opposite_dot(state, tile, dot);
+
+    assert(tile->type == s_tile);
+    if (tile->flags & F_TILE_ASSOC) {
+        if ((tile->dotx != dx) || (tile->doty != dy)) {
+            solvep(("%*sSet %d,%d --> %d,%d (%s) impossible; "
+                    "already --> %d,%d.\n",
+                    solver_recurse_depth*4, "",
+                    tile->x, tile->y, dx, dy, why,
+                    tile->dotx, tile->doty));
+            return -1;
+        }
+        return 0; /* no-op */
+    }
+    if (!tile_opp) {
+        solvep(("%*s%d,%d --> %d,%d impossible, no opposite tile.\n",
+                solver_recurse_depth*4, "", tile->x, tile->y, dx, dy));
+        return -1;
+    }
+    if (tile_opp->flags & F_TILE_ASSOC &&
+        (tile_opp->dotx != dx || tile_opp->doty != dy)) {
+        solvep(("%*sSet %d,%d --> %d,%d (%s) impossible; "
+                "opposite already --> %d,%d.\n",
+                solver_recurse_depth*4, "",
+                tile->x, tile->y, dx, dy, why,
+                tile_opp->dotx, tile_opp->doty));
+        return -1;
+    }
+
+    add_assoc(state, tile, dot);
+    add_assoc(state, tile_opp, dot);
+    solvep(("%*sSetting %d,%d --> %d,%d (%s).\n",
+            solver_recurse_depth*4, "",
+            tile->x, tile->y,dx, dy, why));
+    solvep(("%*sSetting %d,%d --> %d,%d (%s, opposite).\n",
+            solver_recurse_depth*4, "",
+            tile_opp->x, tile_opp->y, dx, dy, why));
+    return 1;
+}
+
+static int solver_obvious_dot(game_state *state, space *dot)
+{
+    int dx, dy, ret, didsth = 0;
+    space *tile;
+
+    debug(("%*ssolver_obvious_dot for %d,%d.\n",
+           solver_recurse_depth*4, "", dot->x, dot->y));
+
+    assert(dot->flags & F_DOT);
+    for (dx = -1; dx <= 1; dx++) {
+        for (dy = -1; dy <= 1; dy++) {
+            if (!INGRID(state, dot->x+dx, dot->y+dy)) continue;
+
+            tile = &SPACE(state, dot->x+dx, dot->y+dy);
+            if (tile->type == s_tile) {
+                ret = solver_add_assoc(state, tile, dot->x, dot->y,
+                                       "next to dot");
+                if (ret < 0) return -1;
+                if (ret > 0) didsth = 1;
+            }
+        }
+    }
+    return didsth;
+}
+
+static int solver_obvious(game_state *state)
+{
+    int i, didsth = 0, ret;
+
+    debug(("%*ssolver_obvious.\n", solver_recurse_depth*4, ""));
+
+    for (i = 0; i < state->ndots; i++) {
+        ret = solver_obvious_dot(state, state->dots[i]);
+        if (ret < 0) return -1;
+        if (ret > 0) didsth = 1;
+    }
+    return didsth;
+}
+
+static int solver_lines_opposite_cb(game_state *state, space *edge, void *ctx)
+{
+    int didsth = 0, n, dx, dy;
+    space *tiles[2], *tile_opp, *edge_opp;
+
+    assert(edge->type == s_edge);
+
+    tiles_from_edge(state, edge, tiles);
+
+    /* if tiles[0] && tiles[1] && they're both associated
+     * and they're both associated with different dots,
+     * ensure the line is set. */
+    if (!(edge->flags & F_EDGE_SET) &&
+        tiles[0] && tiles[1] &&
+        (tiles[0]->flags & F_TILE_ASSOC) &&
+        (tiles[1]->flags & F_TILE_ASSOC) &&
+        (tiles[0]->dotx != tiles[1]->dotx ||
+         tiles[0]->doty != tiles[1]->doty)) {
+        /* No edge, but the two adjacent tiles are both
+         * associated with different dots; add the edge. */
+        solvep(("%*sSetting edge %d,%d - tiles different dots.\n",
+               solver_recurse_depth*4, "", edge->x, edge->y));
+        edge->flags |= F_EDGE_SET;
+        didsth = 1;
+    }
+
+    if (!(edge->flags & F_EDGE_SET)) return didsth;
+    for (n = 0; n < 2; n++) {
+        if (!tiles[n]) continue;
+        assert(tiles[n]->type == s_tile);
+        if (!(tiles[n]->flags & F_TILE_ASSOC)) continue;
+
+        tile_opp = tile_opposite(state, tiles[n]);
+        if (!tile_opp) {
+            solvep(("%*simpossible: edge %d,%d has assoc. tile %d,%d"
+                   " with no opposite.\n",
+                   solver_recurse_depth*4, "",
+                   edge->x, edge->y, tiles[n]->x, tiles[n]->y));
+            /* edge of tile has no opposite edge (off grid?);
+             * this is impossible. */
+            return -1;
+        }
+
+        dx = tiles[n]->x - edge->x;
+        dy = tiles[n]->y - edge->y;
+        assert(INGRID(state, tile_opp->x+dx, tile_opp->y+dy));
+        edge_opp = &SPACE(state, tile_opp->x+dx, tile_opp->y+dy);
+        if (!(edge_opp->flags & F_EDGE_SET)) {
+            solvep(("%*sSetting edge %d,%d as opposite %d,%d\n",
+                   solver_recurse_depth*4, "",
+                   tile_opp->x-dx, tile_opp->y-dy, edge->x, edge->y));
+            edge_opp->flags |= F_EDGE_SET;
+            didsth = 1;
+        }
+    }
+    return didsth;
+}
+
+static int solver_spaces_oneposs_cb(game_state *state, space *tile, void *ctx)
+{
+    int n, eset, ret;
+    space *edgeadj[4], *tileadj[4];
+    int dotx, doty;
+
+    assert(tile->type == s_tile);
+    if (tile->flags & F_TILE_ASSOC) return 0;
+
+    adjacencies(state, tile, edgeadj, tileadj);
+
+    /* Empty tile. If each edge is either set, or associated with
+     * the same dot, we must also associate with dot. */
+    eset = 0; dotx = -1; doty = -1;
+    for (n = 0; n < 4; n++) {
+        assert(edgeadj[n]);
+        assert(edgeadj[n]->type == s_edge);
+        if (edgeadj[n]->flags & F_EDGE_SET) {
+            eset++;
+        } else {
+            assert(tileadj[n]);
+            assert(tileadj[n]->type == s_tile);
+
+            /* If an adjacent tile is empty we can't make any deductions.*/
+            if (!(tileadj[n]->flags & F_TILE_ASSOC))
+                return 0;
+
+            /* If an adjacent tile is assoc. with a different dot
+             * we can't make any deductions. */
+            if (dotx != -1 && doty != -1 &&
+                (tileadj[n]->dotx != dotx ||
+                 tileadj[n]->doty != doty))
+                return 0;
+
+            dotx = tileadj[n]->dotx;
+            doty = tileadj[n]->doty;
+        }
+    }
+    if (eset == 4) {
+        solvep(("%*simpossible: empty tile %d,%d has 4 edges\n",
+               solver_recurse_depth*4, "",
+               tile->x, tile->y));
+        return -1;
+    }
+    assert(dotx != -1 && doty != -1);
+
+    ret = solver_add_assoc(state, tile, dotx, doty, "rest are edges");
+    if (ret == -1) return -1;
+    assert(ret != 0); /* really should have done something. */
+
+    return 1;
+}
+
+/* Improved algorithm for tracking line-of-sight from dots, and not spaces.
+ *
+ * The solver_ctx already stores a list of dots: the algorithm proceeds by
+ * expanding outwards from each dot in turn, expanding first to the boundary
+ * of its currently-connected tile and then to all empty tiles that could see
+ * it. Empty tiles will be flagged with a 'can see dot <x,y>' sticker.
+ *
+ * Expansion will happen by (symmetrically opposite) pairs of squares; if
+ * a square hasn't an opposite number there's no point trying to expand through
+ * it. Empty tiles will therefore also be tagged in pairs.
+ *
+ * If an empty tile already has a 'can see dot <x,y>' tag from a previous dot,
+ * it (and its partner) gets untagged (or, rather, a 'can see two dots' tag)
+ * because we're looking for single-dot possibilities.
+ *
+ * Once we've gone through all the dots, any which still have a 'can see dot'
+ * tag get associated with that dot (because it must have been the only one);
+ * any without any tag (i.e. that could see _no_ dots) cause an impossibility
+ * marked.
+ *
+ * The expansion will happen each time with a stored list of (space *) pairs,
+ * rather than a mark-and-sweep idea; that's horrifically inefficient.
+ *
+ * expansion algorithm:
+ *
+ * * allocate list of (space *) the size of s->sx*s->sy.
+ * * allocate second grid for (flags, dotx, doty) size of sx*sy.
+ *
+ * clear second grid (flags = 0, all dotx and doty = 0)
+ * flags: F_REACHABLE, F_MULTIPLE
+ *
+ *
+ * * for each dot, start with one pair of tiles that are associated with it --
+ *   * vertex --> (dx+1, dy+1), (dx-1, dy-1)
+ *   * edge --> (adj1, adj2)
+ *   * tile --> (tile, tile) ???
+ * * mark that pair of tiles with F_MARK, clear all other F_MARKs.
+ * * add two tiles to start of list.
+ *
+ * set start = 0, end = next = 2
+ *
+ * from (start to end-1, step 2) {
+ * * we have two tiles (t1, t2), opposites wrt our dot.
+ * * for each (at1) sensible adjacent tile to t1 (i.e. not past an edge):
+ *   * work out at2 as the opposite to at1
+ *   * assert at1 and at2 have the same F_MARK values.
+ *   * if at1 & F_MARK ignore it (we've been there on a previous sweep)
+ *   * if either are associated with a different dot
+ *     * mark both with F_MARK (so we ignore them later)
+ *   * otherwise (assoc. with our dot, or empty):
+ *     * mark both with F_MARK
+ *     * add their space * values to the end of the list, set next += 2.
+ * }
+ *
+ * if (end == next)
+ * * we didn't add any new squares; exit the loop.
+ * else
+ * * set start = next+1, end = next. go round again
+ *
+ * We've finished expanding from the dot. Now, for each square we have
+ * in our list (--> each square with F_MARK):
+ * * if the tile is empty:
+ *   * if F_REACHABLE was already set
+ *     * set F_MULTIPLE
+ *   * otherwise
+ *     * set F_REACHABLE, set dotx and doty to our dot.
+ *
+ * Then, continue the whole thing for each dot in turn.
+ *
+ * Once we've done for each dot, go through the entire grid looking for
+ * empty tiles: for each empty tile:
+   * if F_REACHABLE and not F_MULTIPLE, set that dot (and its double)
+   * if !F_REACHABLE, return as impossible.
+ *
+ */
+
+/* Returns 1 if this tile is either already associated with this dot,
+ * or blank. */
+static int solver_expand_checkdot(space *tile, space *dot)
+{
+    if (!(tile->flags & F_TILE_ASSOC)) return 1;
+    if (tile->dotx == dot->x && tile->doty == dot->y) return 1;
+    return 0;
+}
+
+static void solver_expand_fromdot(game_state *state, space *dot, solver_ctx *sctx)
+{
+    int i, j, x, y, start, end, next;
+    space *sp;
+
+    /* Clear the grid of the (space) flags we'll use. */
+
+    /* This is well optimised; analysis showed that:
+        for (i = 0; i < sctx->sz; i++) state->grid[i].flags &= ~F_MARK;
+       took up ~85% of the total function time! */
+    for (y = 1; y < state->sy; y += 2) {
+        sp = &SPACE(state, 1, y);
+        for (x = 1; x < state->sx; x += 2, sp += 2)
+            sp->flags &= ~F_MARK;
+    }
+
+    /* Seed the list of marked squares with two that must be associated
+     * with our dot (possibly the same space) */
+    if (dot->type == s_tile) {
+        sctx->scratch[0] = sctx->scratch[1] = dot;
+    } else if (dot->type == s_edge) {
+        tiles_from_edge(state, dot, sctx->scratch);
+    } else if (dot->type == s_vertex) {
+        /* pick two of the opposite ones arbitrarily. */
+        sctx->scratch[0] = &SPACE(state, dot->x-1, dot->y-1);
+        sctx->scratch[1] = &SPACE(state, dot->x+1, dot->y+1);
+    }
+    assert(sctx->scratch[0]->flags & F_TILE_ASSOC);
+    assert(sctx->scratch[1]->flags & F_TILE_ASSOC);
+
+    sctx->scratch[0]->flags |= F_MARK;
+    sctx->scratch[1]->flags |= F_MARK;
+
+    debug(("%*sexpand from dot %d,%d seeded with %d,%d and %d,%d.\n",
+           solver_recurse_depth*4, "", dot->x, dot->y,
+           sctx->scratch[0]->x, sctx->scratch[0]->y,
+           sctx->scratch[1]->x, sctx->scratch[1]->y));
+
+    start = 0; end = 2; next = 2;
+
+expand:
+    debug(("%*sexpand: start %d, end %d, next %d\n",
+           solver_recurse_depth*4, "", start, end, next));
+    for (i = start; i < end; i += 2) {
+        space *t1 = sctx->scratch[i]/*, *t2 = sctx->scratch[i+1]*/;
+        space *edges[4], *tileadj[4], *tileadj2;
+
+        adjacencies(state, t1, edges, tileadj);
+
+        for (j = 0; j < 4; j++) {
+            assert(edges[j]);
+            if (edges[j]->flags & F_EDGE_SET) continue;
+            assert(tileadj[j]);
+
+            if (tileadj[j]->flags & F_MARK) continue; /* seen before. */
+
+            /* We have a tile adjacent to t1; find its opposite. */
+            tileadj2 = space_opposite_dot(state, tileadj[j], dot);
+            if (!tileadj2) {
+                debug(("%*sMarking %d,%d, no opposite.\n",
+                       solver_recurse_depth*4, "",
+                       tileadj[j]->x, tileadj[j]->y));
+                tileadj[j]->flags |= F_MARK;
+                continue; /* no opposite, so mark for next time. */
+            }
+            /* If the tile had an opposite we should have either seen both of
+             * these, or neither of these, before. */
+            assert(!(tileadj2->flags & F_MARK));
+
+            if (solver_expand_checkdot(tileadj[j], dot) &&
+                solver_expand_checkdot(tileadj2, dot)) {
+                /* Both tiles could associate with this dot; add them to
+                 * our list. */
+                debug(("%*sAdding %d,%d and %d,%d to possibles list.\n",
+                       solver_recurse_depth*4, "",
+                       tileadj[j]->x, tileadj[j]->y, tileadj2->x, tileadj2->y));
+                sctx->scratch[next++] = tileadj[j];
+                sctx->scratch[next++] = tileadj2;
+            }
+            /* Either way, we've seen these tiles already so mark them. */
+            debug(("%*sMarking %d,%d and %d,%d.\n",
+                   solver_recurse_depth*4, "",
+                       tileadj[j]->x, tileadj[j]->y, tileadj2->x, tileadj2->y));
+            tileadj[j]->flags |= F_MARK;
+            tileadj2->flags |= F_MARK;
+        }
+    }
+    if (next > end) {
+        /* We added more squares; go back and try again. */
+        start = end; end = next; goto expand;
+    }
+
+    /* We've expanded as far as we can go. Now we update the main flags
+     * on all tiles we've expanded into -- if they were empty, we have
+     * found possible associations for this dot. */
+    for (i = 0; i < end; i++) {
+        if (sctx->scratch[i]->flags & F_TILE_ASSOC) continue;
+        if (sctx->scratch[i]->flags & F_REACHABLE) {
+            /* This is (at least) the second dot this tile could
+             * associate with. */
+            debug(("%*sempty tile %d,%d could assoc. other dot %d,%d\n",
+                   solver_recurse_depth*4, "",
+                   sctx->scratch[i]->x, sctx->scratch[i]->y, dot->x, dot->y));
+            sctx->scratch[i]->flags |= F_MULTIPLE;
+        } else {
+            /* This is the first (possibly only) dot. */
+            debug(("%*sempty tile %d,%d could assoc. 1st dot %d,%d\n",
+                   solver_recurse_depth*4, "",
+                   sctx->scratch[i]->x, sctx->scratch[i]->y, dot->x, dot->y));
+            sctx->scratch[i]->flags |= F_REACHABLE;
+            sctx->scratch[i]->dotx = dot->x;
+            sctx->scratch[i]->doty = dot->y;
+        }
+    }
+    dbg_state(state);
+}
+
+static int solver_expand_postcb(game_state *state, space *tile, void *ctx)
+{
+    assert(tile->type == s_tile);
+
+    if (tile->flags & F_TILE_ASSOC) return 0;
+
+    if (!(tile->flags & F_REACHABLE)) {
+        solvep(("%*simpossible: space (%d,%d) can reach no dots.\n",
+                solver_recurse_depth*4, "", tile->x, tile->y));
+        return -1;
+    }
+    if (tile->flags & F_MULTIPLE) return 0;
+
+    return solver_add_assoc(state, tile, tile->dotx, tile->doty,
+                            "single possible dot after expansion");
+}
+
+static int solver_expand_dots(game_state *state, solver_ctx *sctx)
+{
+    int i;
+
+    for (i = 0; i < sctx->sz; i++)
+        state->grid[i].flags &= ~(F_REACHABLE|F_MULTIPLE);
+
+    for (i = 0; i < state->ndots; i++)
+        solver_expand_fromdot(state, state->dots[i], sctx);
+
+    return foreach_tile(state, solver_expand_postcb, IMPOSSIBLE_QUITS, sctx);
+}
+
+struct recurse_ctx {
+    space *best;
+    int bestn;
+};
+
+static int solver_recurse_cb(game_state *state, space *tile, void *ctx)
+{
+    struct recurse_ctx *rctx = (struct recurse_ctx *)ctx;
+    int i, n = 0;
+
+    assert(tile->type == s_tile);
+    if (tile->flags & F_TILE_ASSOC) return 0;
+
+    /* We're unassociated: count up all the dots we could associate with. */
+    for (i = 0; i < state->ndots; i++) {
+        if (dotfortile(state, tile, state->dots[i]))
+            n++;
+    }
+    if (n > rctx->bestn) {
+        rctx->bestn = n;
+        rctx->best = tile;
+    }
+    return 0;
+}
+
+#define MAXRECURSE 5
+
+static int solver_recurse(game_state *state, int maxdiff)
+{
+    int diff = DIFF_IMPOSSIBLE, ret, n, gsz = state->sx * state->sy;
+    space *ingrid, *outgrid = NULL, *bestopp;
+    struct recurse_ctx rctx;
+
+    if (solver_recurse_depth >= MAXRECURSE) {
+        solvep(("Limiting recursion to %d, returning.", MAXRECURSE));
+        return DIFF_UNFINISHED;
+    }
+
+    /* Work out the cell to recurse on; go through all unassociated tiles
+     * and find which one has the most possible dots it could associate
+     * with. */
+    rctx.best = NULL;
+    rctx.bestn = 0;
+
+    foreach_tile(state, solver_recurse_cb, 0, &rctx);
+    if (rctx.bestn == 0) return DIFF_IMPOSSIBLE; /* or assert? */
+    assert(rctx.best);
+
+    solvep(("%*sRecursing around %d,%d, with %d possible dots.\n",
+           solver_recurse_depth*4, "",
+           rctx.best->x, rctx.best->y, rctx.bestn));
+
+#ifdef STANDALONE_SOLVER
+    solver_recurse_depth++;
+#endif
+
+    ingrid = snewn(gsz, space);
+    memcpy(ingrid, state->grid, gsz * sizeof(space));
+
+    for (n = 0; n < state->ndots; n++) {
+        memcpy(state->grid, ingrid, gsz * sizeof(space));
+
+        if (!dotfortile(state, rctx.best, state->dots[n])) continue;
+
+        /* set cell (temporarily) pointing to that dot. */
+        solver_add_assoc(state, rctx.best,
+                         state->dots[n]->x, state->dots[n]->y,
+                         "Attempting for recursion");
+
+        ret = solver_state(state, maxdiff);
+
+        if (diff == DIFF_IMPOSSIBLE && ret != DIFF_IMPOSSIBLE) {
+            /* we found our first solved grid; copy it away. */
+            assert(!outgrid);
+            outgrid = snewn(gsz, space);
+            memcpy(outgrid, state->grid, gsz * sizeof(space));
+        }
+        /* reset cell back to unassociated. */
+        bestopp = tile_opposite(state, rctx.best);
+        assert(bestopp && bestopp->flags & F_TILE_ASSOC);
+
+        remove_assoc(state, rctx.best);
+        remove_assoc(state, bestopp);
+
+        if (ret == DIFF_AMBIGUOUS || ret == DIFF_UNFINISHED)
+            diff = ret;
+        else if (ret == DIFF_IMPOSSIBLE)
+            /* no change */;
+        else {
+            /* precisely one solution */
+            if (diff == DIFF_IMPOSSIBLE)
+                diff = DIFF_UNREASONABLE;
+            else
+                diff = DIFF_AMBIGUOUS;
+        }
+        /* if we've found >1 solution, or ran out of recursion,
+         * give up immediately. */
+        if (diff == DIFF_AMBIGUOUS || diff == DIFF_UNFINISHED)
+            break;
+    }
+
+#ifdef STANDALONE_SOLVER
+    solver_recurse_depth--;
+#endif
+
+    if (outgrid) {
+        /* we found (at least one) soln; copy it back to state */
+        memcpy(state->grid, outgrid, gsz * sizeof(space));
+        sfree(outgrid);
+    }
+    sfree(ingrid);
+    return diff;
+}
+
+static int solver_state(game_state *state, int maxdiff)
+{
+    solver_ctx *sctx = new_solver(state);
+    int ret, diff = DIFF_NORMAL;
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+    /* hack, hack: set picture to NULL during solving so that add_assoc
+     * won't complain when we attempt recursive guessing and guess wrong */
+    int *savepic = picture;
+    picture = NULL;
+#endif
+
+    ret = solver_obvious(state);
+    if (ret < 0) {
+        diff = DIFF_IMPOSSIBLE;
+        goto got_result;
+    }
+
+#define CHECKRET(d) do {                                        \
+    if (ret < 0) { diff = DIFF_IMPOSSIBLE; goto got_result; }   \
+    if (ret > 0) { diff = max(diff, (d)); goto cont; }          \
+} while(0)
+
+    while (1) {
+cont:
+        ret = foreach_edge(state, solver_lines_opposite_cb,
+                           IMPOSSIBLE_QUITS, sctx);
+        CHECKRET(DIFF_NORMAL);
+
+        ret = foreach_tile(state, solver_spaces_oneposs_cb,
+                           IMPOSSIBLE_QUITS, sctx);
+        CHECKRET(DIFF_NORMAL);
+
+        ret = solver_expand_dots(state, sctx);
+        CHECKRET(DIFF_NORMAL);
+
+        if (maxdiff <= DIFF_NORMAL)
+            break;
+
+        /* harder still? */
+
+        /* if we reach here, we've made no deductions, so we terminate. */
+        break;
+    }
+
+    if (check_complete(state, NULL, NULL)) goto got_result;
+
+    diff = (maxdiff >= DIFF_UNREASONABLE) ?
+        solver_recurse(state, maxdiff) : DIFF_UNFINISHED;
+
+got_result:
+    free_solver(sctx);
+#ifndef STANDALONE_SOLVER
+    debug(("solver_state ends, diff %s:\n", galaxies_diffnames[diff]));
+    dbg_state(state);
+#endif
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+    picture = savepic;
+#endif
+
+    return diff;
+}
+
+#ifndef EDITOR
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    game_state *tosolve;
+    char *ret;
+    int i;
+    int diff;
+
+    tosolve = dup_game(currstate);
+    diff = solver_state(tosolve, DIFF_UNREASONABLE);
+    if (diff != DIFF_UNFINISHED && diff != DIFF_IMPOSSIBLE) {
+        debug(("solve_game solved with current state.\n"));
+        goto solved;
+    }
+    free_game(tosolve);
+
+    tosolve = dup_game(state);
+    diff = solver_state(tosolve, DIFF_UNREASONABLE);
+    if (diff != DIFF_UNFINISHED && diff != DIFF_IMPOSSIBLE) {
+        debug(("solve_game solved with original state.\n"));
+        goto solved;
+    }
+    free_game(tosolve);
+
+    return NULL;
+
+solved:
+    /*
+     * Clear tile associations: the solution will only include the
+     * edges.
+     */
+    for (i = 0; i < tosolve->sx*tosolve->sy; i++)
+        tosolve->grid[i].flags &= ~F_TILE_ASSOC;
+    ret = diff_game(currstate, tosolve, 1);
+    free_game(tosolve);
+    return ret;
+}
+#endif
+
+/* ----------------------------------------------------------
+ * User interface.
+ */
+
+struct game_ui {
+    int dragging;
+    int dx, dy;         /* pixel coords of drag pos. */
+    int dotx, doty;     /* grid coords of dot we're dragging from. */
+    int srcx, srcy;     /* grid coords of drag start */
+    int cur_x, cur_y, cur_visible;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->dragging = FALSE;
+    ui->cur_x = ui->cur_y = 1;
+    ui->cur_visible = 0;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+#define FLASH_TIME 0.15F
+
+#define PREFERRED_TILE_SIZE 32
+#define TILE_SIZE (ds->tilesize)
+#define DOT_SIZE        (TILE_SIZE / 4)
+#define EDGE_THICKNESS (max(TILE_SIZE / 16, 2))
+#define BORDER TILE_SIZE
+
+#define COORD(x) ( (x) * TILE_SIZE + BORDER )
+#define SCOORD(x) ( ((x) * TILE_SIZE)/2 + BORDER )
+#define FROMCOORD(x) ( ((x) - BORDER) / TILE_SIZE )
+
+#define DRAW_WIDTH      (BORDER * 2 + ds->w * TILE_SIZE)
+#define DRAW_HEIGHT     (BORDER * 2 + ds->h * TILE_SIZE)
+
+#define CURSOR_SIZE DOT_SIZE
+
+struct game_drawstate {
+    int started;
+    int w, h;
+    int tilesize;
+    unsigned long *grid;
+    int *dx, *dy;
+    blitter *bl;
+    blitter *blmirror;
+
+    int dragging, dragx, dragy;
+
+    int *colour_scratch;
+
+    int cx, cy, cur_visible;
+    blitter *cur_bl;
+};
+
+#define CORNER_TOLERANCE 0.15F
+#define CENTRE_TOLERANCE 0.15F
+
+/*
+ * Round FP coordinates to the centre of the nearest edge.
+ */
+#ifndef EDITOR
+static void coord_round_to_edge(float x, float y, int *xr, int *yr)
+{
+    float xs, ys, xv, yv, dx, dy;
+
+    /*
+     * Find the nearest square-centre.
+     */
+    xs = (float)floor(x) + 0.5F;
+    ys = (float)floor(y) + 0.5F;
+
+    /*
+     * Find the nearest grid vertex.
+     */
+    xv = (float)floor(x + 0.5F);
+    yv = (float)floor(y + 0.5F);
+
+    /*
+     * Determine whether the horizontal or vertical edge from that
+     * vertex alongside that square is closer to us, by comparing
+     * distances from the square cente.
+     */
+    dx = (float)fabs(x - xs);
+    dy = (float)fabs(y - ys);
+    if (dx > dy) {
+        /* Vertical edge: x-coord of corner,
+         * y-coord of square centre. */
+        *xr = 2 * (int)xv;
+        *yr = 1 + 2 * (int)floor(ys);
+    } else {
+        /* Horizontal edge: x-coord of square centre,
+         * y-coord of corner. */
+        *xr = 1 + 2 * (int)floor(xs);
+        *yr = 2 * (int)yv;
+    }
+}
+#endif
+
+#ifdef EDITOR
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    char buf[80];
+    int px, py;
+    space *sp;
+
+    px = 2*FROMCOORD((float)x) + 0.5;
+    py = 2*FROMCOORD((float)y) + 0.5;
+
+    state->cdiff = -1;
+
+    if (button == 'C' || button == 'c') return dupstr("C");
+
+    if (button == 'S' || button == 's') {
+        char *ret;
+        game_state *tmp = dup_game(state);
+        state->cdiff = solver_state(tmp, DIFF_UNREASONABLE-1);
+        ret = diff_game(state, tmp, 0);
+        free_game(tmp);
+        return ret;
+    }
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        if (!INUI(state, px, py)) return NULL;
+        sp = &SPACE(state, px, py);
+        if (!dot_is_possible(state, sp, 1)) return NULL;
+        sprintf(buf, "%c%d,%d",
+                (char)((button == LEFT_BUTTON) ? 'D' : 'd'), px, py);
+        return dupstr(buf);
+    }
+
+    return NULL;
+}
+#else
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    /* UI operations (play mode):
+     *
+     * Toggle edge (set/unset) (left-click on edge)
+     * Associate space with dot (left-drag from dot)
+     * Unassociate space (left-drag from space off grid)
+     * Autofill lines around shape? (right-click?)
+     *
+     * (edit mode; will clear all lines/associations)
+     *
+     * Add or remove dot (left-click)
+     */
+    char buf[80];
+    const char *sep = "";
+    int px, py;
+    space *sp, *dot;
+
+    buf[0] = '\0';
+
+    if (button == 'H' || button == 'h') {
+        char *ret;
+        game_state *tmp = dup_game(state);
+        solver_obvious(tmp);
+        ret = diff_game(state, tmp, 0);
+        free_game(tmp);
+        return ret;
+    }
+
+    if (button == LEFT_BUTTON) {
+        ui->cur_visible = 0;
+        coord_round_to_edge(FROMCOORD((float)x), FROMCOORD((float)y),
+                            &px, &py);
+
+        if (!INUI(state, px, py)) return NULL;
+
+        sp = &SPACE(state, px, py);
+        assert(sp->type == s_edge);
+        {
+            sprintf(buf, "E%d,%d", px, py);
+            return dupstr(buf);
+        }
+    } else if (button == RIGHT_BUTTON) {
+        int px1, py1;
+
+        ui->cur_visible = 0;
+
+        px = (int)(2*FROMCOORD((float)x) + 0.5);
+        py = (int)(2*FROMCOORD((float)y) + 0.5);
+
+        dot = NULL;
+
+        /*
+         * If there's a dot anywhere nearby, we pick up an arrow
+         * pointing at that dot.
+         */
+        for (py1 = py-1; py1 <= py+1; py1++)
+            for (px1 = px-1; px1 <= px+1; px1++) {
+                if (px1 >= 0 && px1 < state->sx &&
+                    py1 >= 0 && py1 < state->sy &&
+                    x >= SCOORD(px1-1) && x < SCOORD(px1+1) &&
+                    y >= SCOORD(py1-1) && y < SCOORD(py1+1) &&
+                    SPACE(state, px1, py1).flags & F_DOT) {
+                    /*
+                     * Found a dot. Begin a drag from it.
+                     */
+                    dot = &SPACE(state, px1, py1);
+                    ui->srcx = px1;
+                    ui->srcy = py1;
+                    goto done;         /* multi-level break */
+                }
+            }
+
+        /*
+         * Otherwise, find the nearest _square_, and pick up the
+         * same arrow as it's got on it, if any.
+         */
+        if (!dot) {
+            px = 2*FROMCOORD(x+TILE_SIZE) - 1;
+            py = 2*FROMCOORD(y+TILE_SIZE) - 1;
+            if (px >= 0 && px < state->sx && py >= 0 && py < state->sy) {
+                sp = &SPACE(state, px, py);
+                if (sp->flags & F_TILE_ASSOC) {
+                    dot = &SPACE(state, sp->dotx, sp->doty);
+                    ui->srcx = px;
+                    ui->srcy = py;
+                }
+            }
+        }
+
+        done:
+        /*
+         * Now, if we've managed to find a dot, begin a drag.
+         */
+        if (dot) {
+            ui->dragging = TRUE;
+            ui->dx = x;
+            ui->dy = y;
+            ui->dotx = dot->x;
+            ui->doty = dot->y;
+            return "";
+        }
+    } else if (button == RIGHT_DRAG && ui->dragging) {
+        /* just move the drag coords. */
+        ui->dx = x;
+        ui->dy = y;
+        return "";
+    } else if (button == RIGHT_RELEASE && ui->dragging) {
+        ui->dragging = FALSE;
+
+        /*
+         * Drags are always targeted at a single square.
+         */
+        px = 2*FROMCOORD(x+TILE_SIZE) - 1;
+        py = 2*FROMCOORD(y+TILE_SIZE) - 1;
+
+        /*
+         * Dragging an arrow on to the same square it started from
+         * is a null move; just update the ui and finish.
+         */
+        if (px == ui->srcx && py == ui->srcy)
+            return "";
+
+        /*
+         * Otherwise, we remove the arrow from its starting
+         * square if we didn't start from a dot...
+         */
+        if ((ui->srcx != ui->dotx || ui->srcy != ui->doty) &&
+            SPACE(state, ui->srcx, ui->srcy).flags & F_TILE_ASSOC) {
+            sprintf(buf + strlen(buf), "%sU%d,%d", sep, ui->srcx, ui->srcy);
+            sep = ";";
+        }
+
+        /*
+         * ... and if the square we're moving it _to_ is valid, we
+         * add one there instead.
+         */
+        if (INUI(state, px, py)) {
+            sp = &SPACE(state, px, py);
+
+            if (!(sp->flags & F_DOT))
+                sprintf(buf + strlen(buf), "%sA%d,%d,%d,%d",
+                        sep, px, py, ui->dotx, ui->doty);
+        }
+
+        if (buf[0])
+            return dupstr(buf);
+        else
+            return "";
+    } else if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->sx-1, state->sy-1, 0);
+        if (ui->cur_x < 1) ui->cur_x = 1;
+        if (ui->cur_y < 1) ui->cur_y = 1;
+        ui->cur_visible = 1;
+        if (ui->dragging) {
+            ui->dx = SCOORD(ui->cur_x);
+            ui->dy = SCOORD(ui->cur_y);
+        }
+        return "";
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+        sp = &SPACE(state, ui->cur_x, ui->cur_y);
+        if (ui->dragging) {
+            ui->dragging = FALSE;
+
+            if ((ui->srcx != ui->dotx || ui->srcy != ui->doty) &&
+                SPACE(state, ui->srcx, ui->srcy).flags & F_TILE_ASSOC) {
+                sprintf(buf, "%sU%d,%d", sep, ui->srcx, ui->srcy);
+                sep = ";";
+            }
+            if (sp->type == s_tile && !(sp->flags & F_DOT) && !(sp->flags & F_TILE_ASSOC)) {
+                sprintf(buf + strlen(buf), "%sA%d,%d,%d,%d",
+                        sep, ui->cur_x, ui->cur_y, ui->dotx, ui->doty);
+            }
+            return dupstr(buf);
+        } else if (sp->flags & F_DOT) {
+            ui->dragging = TRUE;
+            ui->dx = SCOORD(ui->cur_x);
+            ui->dy = SCOORD(ui->cur_y);
+            ui->dotx = ui->srcx = ui->cur_x;
+            ui->doty = ui->srcy = ui->cur_y;
+            return "";
+        } else if (sp->flags & F_TILE_ASSOC) {
+            assert(sp->type == s_tile);
+            ui->dragging = TRUE;
+            ui->dx = SCOORD(ui->cur_x);
+            ui->dy = SCOORD(ui->cur_y);
+            ui->dotx = sp->dotx;
+            ui->doty = sp->doty;
+            ui->srcx = ui->cur_x;
+            ui->srcy = ui->cur_y;
+            return "";
+        } else if (sp->type == s_edge) {
+            sprintf(buf, "E%d,%d", ui->cur_x, ui->cur_y);
+            return dupstr(buf);
+        }
+    }
+
+    return NULL;
+}
+#endif
+
+static int check_complete(const game_state *state, int *dsf, int *colours)
+{
+    int w = state->w, h = state->h;
+    int x, y, i, ret;
+
+    int free_dsf;
+    struct sqdata {
+        int minx, miny, maxx, maxy;
+        int cx, cy;
+        int valid, colour;
+    } *sqdata;
+
+    if (!dsf) {
+        dsf = snew_dsf(w*h);
+        free_dsf = TRUE;
+    } else {
+        dsf_init(dsf, w*h);
+        free_dsf = FALSE;
+    }
+
+    /*
+     * During actual game play, completion checking is done on the
+     * basis of the edges rather than the square associations. So
+     * first we must go through the grid figuring out the connected
+     * components into which the edges divide it.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            if (y+1 < h && !(SPACE(state, 2*x+1, 2*y+2).flags & F_EDGE_SET))
+                dsf_merge(dsf, y*w+x, (y+1)*w+x);
+            if (x+1 < w && !(SPACE(state, 2*x+2, 2*y+1).flags & F_EDGE_SET))
+                dsf_merge(dsf, y*w+x, y*w+(x+1));
+        }
+
+    /*
+     * That gives us our connected components. Now, for each
+     * component, decide whether it's _valid_. A valid component is
+     * one which:
+     *
+     *  - is 180-degree rotationally symmetric
+     *  - has a dot at its centre of symmetry
+     *  - has no other dots anywhere within it (including on its
+     *    boundary)
+     *  - contains no internal edges (i.e. edges separating two
+     *    squares which are both part of the component).
+     */
+
+    /*
+     * First, go through the grid finding the bounding box of each
+     * component.
+     */
+    sqdata = snewn(w*h, struct sqdata);
+    for (i = 0; i < w*h; i++) {
+        sqdata[i].minx = w+1;
+        sqdata[i].miny = h+1;
+        sqdata[i].maxx = sqdata[i].maxy = -1;
+        sqdata[i].valid = FALSE;
+    }
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            i = dsf_canonify(dsf, y*w+x);
+            if (sqdata[i].minx > x)
+                sqdata[i].minx = x;
+            if (sqdata[i].maxx < x)
+                sqdata[i].maxx = x;
+            if (sqdata[i].miny > y)
+                sqdata[i].miny = y;
+            if (sqdata[i].maxy < y)
+                sqdata[i].maxy = y;
+            sqdata[i].valid = TRUE;
+        }
+
+    /*
+     * Now we're in a position to loop over each actual component
+     * and figure out where its centre of symmetry has to be if
+     * it's anywhere.
+     */
+    for (i = 0; i < w*h; i++)
+        if (sqdata[i].valid) {
+            int cx, cy;
+            cx = sqdata[i].cx = sqdata[i].minx + sqdata[i].maxx + 1;
+            cy = sqdata[i].cy = sqdata[i].miny + sqdata[i].maxy + 1;
+            if (!(SPACE(state, sqdata[i].cx, sqdata[i].cy).flags & F_DOT))
+                sqdata[i].valid = FALSE;   /* no dot at centre of symmetry */
+            if (dsf_canonify(dsf, (cy-1)/2*w+(cx-1)/2) != i ||
+                dsf_canonify(dsf, (cy)/2*w+(cx-1)/2) != i ||
+                dsf_canonify(dsf, (cy-1)/2*w+(cx)/2) != i ||
+                dsf_canonify(dsf, (cy)/2*w+(cx)/2) != i)
+                sqdata[i].valid = FALSE;   /* dot at cx,cy isn't ours */
+            if (SPACE(state, sqdata[i].cx, sqdata[i].cy).flags & F_DOT_BLACK)
+                sqdata[i].colour = 2;
+            else
+                sqdata[i].colour = 1;
+        }
+
+    /*
+     * Now we loop over the whole grid again, this time finding
+     * extraneous dots (any dot which wholly or partially overlaps
+     * a square and is not at the centre of symmetry of that
+     * square's component disqualifies the component from validity)
+     * and extraneous edges (any edge separating two squares
+     * belonging to the same component also disqualifies that
+     * component).
+     */
+    for (y = 1; y < state->sy-1; y++)
+        for (x = 1; x < state->sx-1; x++) {
+            space *sp = &SPACE(state, x, y);
+
+            if (sp->flags & F_DOT) {
+                /*
+                 * There's a dot here. Use it to disqualify any
+                 * component which deserves it.
+                 */
+                int cx, cy;
+                for (cy = (y-1) >> 1; cy <= y >> 1; cy++)
+                    for (cx = (x-1) >> 1; cx <= x >> 1; cx++) {
+                        i = dsf_canonify(dsf, cy*w+cx);
+                        if (x != sqdata[i].cx || y != sqdata[i].cy)
+                            sqdata[i].valid = FALSE;
+                    }
+            }
+
+            if (sp->flags & F_EDGE_SET) {
+                /*
+                 * There's an edge here. Use it to disqualify a
+                 * component if necessary.
+                 */
+                int cx1 = (x-1) >> 1, cx2 = x >> 1;
+                int cy1 = (y-1) >> 1, cy2 = y >> 1;
+                assert((cx1==cx2) ^ (cy1==cy2));
+                i = dsf_canonify(dsf, cy1*w+cx1);
+                if (i == dsf_canonify(dsf, cy2*w+cx2))
+                    sqdata[i].valid = FALSE;
+            }
+        }
+
+    /*
+     * And finally we test rotational symmetry: for each square in
+     * the grid, find which component it's in, test that that
+     * component also has a square in the symmetric position, and
+     * disqualify it if it doesn't.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int x2, y2;
+
+            i = dsf_canonify(dsf, y*w+x);
+
+            x2 = sqdata[i].cx - 1 - x;
+            y2 = sqdata[i].cy - 1 - y;
+            if (i != dsf_canonify(dsf, y2*w+x2))
+                sqdata[i].valid = FALSE;
+        }
+
+    /*
+     * That's it. We now have all the connected components marked
+     * as valid or not valid. So now we return a `colours' array if
+     * we were asked for one, and also we return an overall
+     * true/false value depending on whether _every_ square in the
+     * grid is part of a valid component.
+     */
+    ret = TRUE;
+    for (i = 0; i < w*h; i++) {
+        int ci = dsf_canonify(dsf, i);
+        int thisok = sqdata[ci].valid;
+        if (colours)
+            colours[i] = thisok ? sqdata[ci].colour : 0;
+        ret = ret && thisok;
+    }
+
+    sfree(sqdata);
+    if (free_dsf)
+        sfree(dsf);
+
+    return ret;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int x, y, ax, ay, n, dx, dy;
+    game_state *ret = dup_game(state);
+    space *sp, *dot;
+    int currently_solving = FALSE;
+
+    debug(("%s\n", move));
+
+    while (*move) {
+        char c = *move;
+        if (c == 'E' || c == 'U' || c == 'M'
+#ifdef EDITOR
+            || c == 'D' || c == 'd'
+#endif
+            ) {
+            move++;
+            if (sscanf(move, "%d,%d%n", &x, &y, &n) != 2 ||
+                !INUI(ret, x, y))
+                goto badmove;
+
+            sp = &SPACE(ret, x, y);
+#ifdef EDITOR
+            if (c == 'D' || c == 'd') {
+                unsigned int currf, newf, maskf;
+
+                if (!dot_is_possible(ret, sp, 1)) goto badmove;
+
+                newf = F_DOT | (c == 'd' ? F_DOT_BLACK : 0);
+                currf = GRID(ret, grid, x, y).flags;
+                maskf = F_DOT | F_DOT_BLACK;
+                /* if we clicked 'white dot':
+                 *   white --> empty, empty --> white, black --> white.
+                 * if we clicked 'black dot':
+                 *   black --> empty, empty --> black, white --> black.
+                 */
+                if (currf & maskf) {
+                    sp->flags &= ~maskf;
+                    if ((currf & maskf) != newf)
+                        sp->flags |= newf;
+                } else
+                    sp->flags |= newf;
+                sp->nassoc = 0; /* edit-mode disallows associations. */
+                game_update_dots(ret);
+            } else
+#endif
+                   if (c == 'E') {
+                if (sp->type != s_edge) goto badmove;
+                sp->flags ^= F_EDGE_SET;
+            } else if (c == 'U') {
+                if (sp->type != s_tile || !(sp->flags & F_TILE_ASSOC))
+                    goto badmove;
+                /* The solver doesn't assume we'll mirror things */
+                if (currently_solving)
+                    remove_assoc(ret, sp);
+                else
+                    remove_assoc_with_opposite(ret, sp);
+            } else if (c == 'M') {
+                if (!(sp->flags & F_DOT)) goto badmove;
+                sp->flags ^= F_DOT_HOLD;
+            }
+            move += n;
+        } else if (c == 'A' || c == 'a') {
+            move++;
+            if (sscanf(move, "%d,%d,%d,%d%n", &x, &y, &ax, &ay, &n) != 4 ||
+                x < 1 || y < 1 || x >= (ret->sx-1) || y >= (ret->sy-1) ||
+                ax < 1 || ay < 1 || ax >= (ret->sx-1) || ay >= (ret->sy-1))
+                goto badmove;
+
+            dot = &GRID(ret, grid, ax, ay);
+            if (!(dot->flags & F_DOT))goto badmove;
+            if (dot->flags & F_DOT_HOLD) goto badmove;
+
+            for (dx = -1; dx <= 1; dx++) {
+                for (dy = -1; dy <= 1; dy++) {
+                    sp = &GRID(ret, grid, x+dx, y+dy);
+                    if (sp->type != s_tile) continue;
+                    if (sp->flags & F_TILE_ASSOC) {
+                        space *dot = &SPACE(ret, sp->dotx, sp->doty);
+                        if (dot->flags & F_DOT_HOLD) continue;
+                    }
+                    /* The solver doesn't assume we'll mirror things */
+                    if (currently_solving)
+                        add_assoc(ret, sp, dot);
+                    else
+                        add_assoc_with_opposite(ret, sp, dot);
+                }
+            }
+            move += n;
+#ifdef EDITOR
+        } else if (c == 'C') {
+            move++;
+            clear_game(ret, 1);
+#endif
+        } else if (c == 'S') {
+            move++;
+            ret->used_solve = 1;
+            currently_solving = TRUE;
+        } else
+            goto badmove;
+
+        if (*move == ';')
+            move++;
+        else if (*move)
+            goto badmove;
+    }
+    if (check_complete(ret, NULL, NULL))
+        ret->completed = 1;
+    return ret;
+
+badmove:
+    free_game(ret);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+/* Lines will be much smaller size than squares; say, 1/8 the size?
+ *
+ * Need a 'top-left corner of location XxY' to take this into account;
+ * alternaticaly, that could give the middle of that location, and the
+ * drawing code would just know the expected dimensions.
+ *
+ * We also need something to take a click and work out what it was
+ * we were interested in. Clicking on vertices is required because
+ * we may want to drag from them, for example.
+ */
+
+static void game_compute_size(const game_params *params, int sz,
+                              int *x, int *y)
+{
+    struct { int tilesize, w, h; } ads, *ds = &ads;
+
+    ds->tilesize = sz;
+    ds->w = params->w;
+    ds->h = params->h;
+
+    *x = DRAW_WIDTH;
+    *y = DRAW_HEIGHT;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int sz)
+{
+    ds->tilesize = sz;
+
+    assert(TILE_SIZE > 0);
+
+    assert(!ds->bl);
+    ds->bl = blitter_new(dr, TILE_SIZE, TILE_SIZE);
+
+    assert(!ds->blmirror);
+    ds->blmirror = blitter_new(dr, TILE_SIZE, TILE_SIZE);
+
+    assert(!ds->cur_bl);
+    ds->cur_bl = blitter_new(dr, TILE_SIZE, TILE_SIZE);
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    /*
+     * We call game_mkhighlight to ensure the background colour
+     * isn't completely white. We don't actually use the high- and
+     * lowlight colours it generates.
+     */
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_WHITEBG, COL_BLACKBG);
+
+    for (i = 0; i < 3; i++) {
+        /*
+         * Currently, white dots and white-background squares are
+         * both pure white.
+         */
+        ret[COL_WHITEDOT * 3 + i] = 1.0F;
+        ret[COL_WHITEBG * 3 + i] = 1.0F;
+
+        /*
+         * But black-background squares are a dark grey, whereas
+         * black dots are really black.
+         */
+        ret[COL_BLACKDOT * 3 + i] = 0.0F;
+        ret[COL_BLACKBG * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 0.3F;
+
+        /*
+         * In unfilled squares, we draw a faint gridwork.
+         */
+        ret[COL_GRID * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 0.8F;
+
+        /*
+         * Edges and arrows are filled in in pure black.
+         */
+        ret[COL_EDGE * 3 + i] = 0.0F;
+        ret[COL_ARROW * 3 + i] = 0.0F;
+    }
+
+#ifdef EDITOR
+    /* tinge the edit background to bluey */
+    ret[COL_BACKGROUND * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.8F;
+    ret[COL_BACKGROUND * 3 + 1] = ret[COL_BACKGROUND * 3 + 0] * 0.8F;
+    ret[COL_BACKGROUND * 3 + 2] = min(ret[COL_BACKGROUND * 3 + 0] * 1.4F, 1.0F);
+#endif
+
+    ret[COL_CURSOR * 3 + 0] = min(ret[COL_BACKGROUND * 3 + 0] * 1.4F, 1.0F);
+    ret[COL_CURSOR * 3 + 1] = ret[COL_BACKGROUND * 3 + 0] * 0.8F;
+    ret[COL_CURSOR * 3 + 2] = ret[COL_BACKGROUND * 3 + 0] * 0.8F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->started = 0;
+    ds->w = state->w;
+    ds->h = state->h;
+
+    ds->grid = snewn(ds->w*ds->h, unsigned long);
+    for (i = 0; i < ds->w*ds->h; i++)
+        ds->grid[i] = 0xFFFFFFFFUL;
+    ds->dx = snewn(ds->w*ds->h, int);
+    ds->dy = snewn(ds->w*ds->h, int);
+
+    ds->bl = NULL;
+    ds->blmirror = NULL;
+    ds->dragging = FALSE;
+    ds->dragx = ds->dragy = 0;
+
+    ds->colour_scratch = snewn(ds->w * ds->h, int);
+
+    ds->cur_bl = NULL;
+    ds->cx = ds->cy = 0;
+    ds->cur_visible = 0;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    if (ds->cur_bl) blitter_free(dr, ds->cur_bl);
+    sfree(ds->colour_scratch);
+    if (ds->blmirror) blitter_free(dr, ds->blmirror);
+    if (ds->bl) blitter_free(dr, ds->bl);
+    sfree(ds->dx);
+    sfree(ds->dy);
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+#define DRAW_EDGE_L    0x0001
+#define DRAW_EDGE_R    0x0002
+#define DRAW_EDGE_U    0x0004
+#define DRAW_EDGE_D    0x0008
+#define DRAW_CORNER_UL 0x0010
+#define DRAW_CORNER_UR 0x0020
+#define DRAW_CORNER_DL 0x0040
+#define DRAW_CORNER_DR 0x0080
+#define DRAW_WHITE     0x0100
+#define DRAW_BLACK     0x0200
+#define DRAW_ARROW     0x0400
+#define DRAW_CURSOR    0x0800
+#define DOT_SHIFT_C    12
+#define DOT_SHIFT_M    2
+#define DOT_WHITE      1UL
+#define DOT_BLACK      2UL
+
+/*
+ * Draw an arrow centred on (cx,cy), pointing in the direction
+ * (ddx,ddy). (I.e. pointing at the point (cx+ddx, cy+ddy).
+ */
+static void draw_arrow(drawing *dr, game_drawstate *ds,
+                       int cx, int cy, int ddx, int ddy, int col)
+{
+    float vlen = (float)sqrt(ddx*ddx+ddy*ddy);
+    float xdx = ddx/vlen, xdy = ddy/vlen;
+    float ydx = -xdy, ydy = xdx;
+    int e1x = cx + (int)(xdx*TILE_SIZE/3), e1y = cy + (int)(xdy*TILE_SIZE/3);
+    int e2x = cx - (int)(xdx*TILE_SIZE/3), e2y = cy - (int)(xdy*TILE_SIZE/3);
+    int adx = (int)((ydx-xdx)*TILE_SIZE/8), ady = (int)((ydy-xdy)*TILE_SIZE/8);
+    int adx2 = (int)((-ydx-xdx)*TILE_SIZE/8), ady2 = (int)((-ydy-xdy)*TILE_SIZE/8);
+
+    draw_line(dr, e1x, e1y, e2x, e2y, col);
+    draw_line(dr, e1x, e1y, e1x+adx, e1y+ady, col);
+    draw_line(dr, e1x, e1y, e1x+adx2, e1y+ady2, col);
+}
+
+static void draw_square(drawing *dr, game_drawstate *ds, int x, int y,
+                        unsigned long flags, int ddx, int ddy)
+{
+    int lx = COORD(x), ly = COORD(y);
+    int dx, dy;
+    int gridcol;
+
+    clip(dr, lx, ly, TILE_SIZE, TILE_SIZE);
+
+    /*
+     * Draw the tile background.
+     */
+    draw_rect(dr, lx, ly, TILE_SIZE, TILE_SIZE,
+              (flags & DRAW_WHITE ? COL_WHITEBG :
+               flags & DRAW_BLACK ? COL_BLACKBG : COL_BACKGROUND));
+
+    /*
+     * Draw the grid.
+     */
+    gridcol = (flags & DRAW_BLACK ? COL_BLACKDOT : COL_GRID);
+    draw_rect(dr, lx, ly, 1, TILE_SIZE, gridcol);
+    draw_rect(dr, lx, ly, TILE_SIZE, 1, gridcol);
+
+    /*
+     * Draw the arrow, if present, or the cursor, if here.
+     */
+    if (flags & DRAW_ARROW)
+        draw_arrow(dr, ds, lx + TILE_SIZE/2, ly + TILE_SIZE/2, ddx, ddy,
+                   (flags & DRAW_CURSOR) ? COL_CURSOR : COL_ARROW);
+    else if (flags & DRAW_CURSOR)
+        draw_rect_outline(dr,
+                          lx + TILE_SIZE/2 - CURSOR_SIZE,
+                          ly + TILE_SIZE/2 - CURSOR_SIZE,
+                          2*CURSOR_SIZE+1, 2*CURSOR_SIZE+1,
+                          COL_CURSOR);
+
+    /*
+     * Draw the edges.
+     */
+    if (flags & DRAW_EDGE_L)
+        draw_rect(dr, lx, ly, EDGE_THICKNESS, TILE_SIZE, COL_EDGE);
+    if (flags & DRAW_EDGE_R)
+        draw_rect(dr, lx + TILE_SIZE - EDGE_THICKNESS + 1, ly,
+                  EDGE_THICKNESS - 1, TILE_SIZE, COL_EDGE);
+    if (flags & DRAW_EDGE_U)
+        draw_rect(dr, lx, ly, TILE_SIZE, EDGE_THICKNESS, COL_EDGE);
+    if (flags & DRAW_EDGE_D)
+        draw_rect(dr, lx, ly + TILE_SIZE - EDGE_THICKNESS + 1,
+                  TILE_SIZE, EDGE_THICKNESS - 1, COL_EDGE);
+    if (flags & DRAW_CORNER_UL)
+        draw_rect(dr, lx, ly, EDGE_THICKNESS, EDGE_THICKNESS, COL_EDGE);
+    if (flags & DRAW_CORNER_UR)
+        draw_rect(dr, lx + TILE_SIZE - EDGE_THICKNESS + 1, ly,
+                  EDGE_THICKNESS - 1, EDGE_THICKNESS, COL_EDGE);
+    if (flags & DRAW_CORNER_DL)
+        draw_rect(dr, lx, ly + TILE_SIZE - EDGE_THICKNESS + 1,
+                  EDGE_THICKNESS, EDGE_THICKNESS - 1, COL_EDGE);
+    if (flags & DRAW_CORNER_DR)
+        draw_rect(dr, lx + TILE_SIZE - EDGE_THICKNESS + 1,
+                  ly + TILE_SIZE - EDGE_THICKNESS + 1,
+                  EDGE_THICKNESS - 1, EDGE_THICKNESS - 1, COL_EDGE);
+
+    /*
+     * Draw the dots.
+     */
+    for (dy = 0; dy < 3; dy++)
+        for (dx = 0; dx < 3; dx++) {
+            int dotval = (flags >> (DOT_SHIFT_C + DOT_SHIFT_M*(dy*3+dx)));
+            dotval &= (1 << DOT_SHIFT_M)-1;
+
+            if (dotval)
+                draw_circle(dr, lx+dx*TILE_SIZE/2, ly+dy*TILE_SIZE/2,
+                            DOT_SIZE,
+                            (dotval == 1 ? COL_WHITEDOT : COL_BLACKDOT),
+                            COL_BLACKDOT);
+        }
+
+    unclip(dr);
+    draw_update(dr, lx, ly, TILE_SIZE, TILE_SIZE);
+}
+
+static void calculate_opposite_point(const game_ui *ui,
+                                     const game_drawstate *ds, const int x,
+                                     const int y, int *oppositex,
+                                     int *oppositey)
+{
+    /* oppositex - dotx = dotx - x <=> oppositex = 2 * dotx - x */
+    *oppositex = 2 * SCOORD(ui->dotx) - x;
+    *oppositey = 2 * SCOORD(ui->doty) - y;
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = ds->w, h = ds->h;
+    int x, y, flashing = FALSE;
+    int oppx, oppy;
+
+    if (flashtime > 0) {
+        int frame = (int)(flashtime / FLASH_TIME);
+        flashing = (frame % 2 == 0);
+    }
+
+    if (ds->dragging) {
+        assert(ds->bl);
+        assert(ds->blmirror);
+        calculate_opposite_point(ui, ds, ds->dragx + TILE_SIZE/2,
+                                 ds->dragy + TILE_SIZE/2, &oppx, &oppy);
+        oppx -= TILE_SIZE/2;
+        oppy -= TILE_SIZE/2;
+        blitter_load(dr, ds->bl, ds->dragx, ds->dragy);
+        draw_update(dr, ds->dragx, ds->dragy, TILE_SIZE, TILE_SIZE);
+        blitter_load(dr, ds->blmirror, oppx, oppy);
+        draw_update(dr, oppx, oppy, TILE_SIZE, TILE_SIZE);
+        ds->dragging = FALSE;
+    }
+    if (ds->cur_visible) {
+        assert(ds->cur_bl);
+        blitter_load(dr, ds->cur_bl, ds->cx, ds->cy);
+        draw_update(dr, ds->cx, ds->cy, CURSOR_SIZE*2+1, CURSOR_SIZE*2+1);
+        ds->cur_visible = FALSE;
+    }
+
+    if (!ds->started) {
+        draw_rect(dr, 0, 0, DRAW_WIDTH, DRAW_HEIGHT, COL_BACKGROUND);
+        draw_rect(dr, BORDER - EDGE_THICKNESS + 1, BORDER - EDGE_THICKNESS + 1,
+                  w*TILE_SIZE + EDGE_THICKNESS*2 - 1,
+                  h*TILE_SIZE + EDGE_THICKNESS*2 - 1, COL_EDGE);
+        draw_update(dr, 0, 0, DRAW_WIDTH, DRAW_HEIGHT);
+        ds->started = TRUE;
+    }
+
+    check_complete(state, NULL, ds->colour_scratch);
+
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            unsigned long flags = 0;
+            int ddx = 0, ddy = 0;
+            space *sp, *opp;
+            int dx, dy;
+
+            /*
+             * Set up the flags for this square. Firstly, see if we
+             * have edges.
+             */
+            if (SPACE(state, x*2, y*2+1).flags & F_EDGE_SET)
+                flags |= DRAW_EDGE_L;
+            if (SPACE(state, x*2+2, y*2+1).flags & F_EDGE_SET)
+                flags |= DRAW_EDGE_R;
+            if (SPACE(state, x*2+1, y*2).flags & F_EDGE_SET)
+                flags |= DRAW_EDGE_U;
+            if (SPACE(state, x*2+1, y*2+2).flags & F_EDGE_SET)
+                flags |= DRAW_EDGE_D;
+
+            /*
+             * Also, mark corners of neighbouring edges.
+             */
+            if ((x > 0 && SPACE(state, x*2-1, y*2).flags & F_EDGE_SET) ||
+                (y > 0 && SPACE(state, x*2, y*2-1).flags & F_EDGE_SET))
+                flags |= DRAW_CORNER_UL;
+            if ((x+1 < w && SPACE(state, x*2+3, y*2).flags & F_EDGE_SET) ||
+                (y > 0 && SPACE(state, x*2+2, y*2-1).flags & F_EDGE_SET))
+                flags |= DRAW_CORNER_UR;
+            if ((x > 0 && SPACE(state, x*2-1, y*2+2).flags & F_EDGE_SET) ||
+                (y+1 < h && SPACE(state, x*2, y*2+3).flags & F_EDGE_SET))
+                flags |= DRAW_CORNER_DL;
+            if ((x+1 < w && SPACE(state, x*2+3, y*2+2).flags & F_EDGE_SET) ||
+                (y+1 < h && SPACE(state, x*2+2, y*2+3).flags & F_EDGE_SET))
+                flags |= DRAW_CORNER_DR;
+
+            /*
+             * If this square is part of a valid region, paint it
+             * that region's colour. Exception: if we're flashing,
+             * everything goes briefly back to background colour.
+             */
+            sp = &SPACE(state, x*2+1, y*2+1);
+            if (sp->flags & F_TILE_ASSOC) {
+                opp = tile_opposite(state, sp);
+            } else {
+                opp = NULL;
+            }
+            if (ds->colour_scratch[y*w+x] && !flashing) {
+                flags |= (ds->colour_scratch[y*w+x] == 2 ?
+                          DRAW_BLACK : DRAW_WHITE);
+            }
+
+            /*
+             * If this square is associated with a dot but it isn't
+             * part of a valid region, draw an arrow in it pointing
+             * in the direction of that dot.
+             * 
+             * Exception: if this is the source point of an active
+             * drag, we don't draw the arrow.
+             */
+            if ((sp->flags & F_TILE_ASSOC) && !ds->colour_scratch[y*w+x]) {
+                if (ui->dragging && ui->srcx == x*2+1 && ui->srcy == y*2+1) {
+                    /* tile is the source, don't do it */
+                } else if (ui->dragging && opp && ui->srcx == opp->x && ui->srcy == opp->y) {
+                    /* opposite tile is the source, don't do it */
+                } else if (sp->doty != y*2+1 || sp->dotx != x*2+1) {
+                    flags |= DRAW_ARROW;
+                    ddy = sp->doty - (y*2+1);
+                    ddx = sp->dotx - (x*2+1);
+                }
+            }
+
+            /*
+             * Now go through the nine possible places we could
+             * have dots.
+             */
+            for (dy = 0; dy < 3; dy++)
+                for (dx = 0; dx < 3; dx++) {
+                    sp = &SPACE(state, x*2+dx, y*2+dy);
+                    if (sp->flags & F_DOT) {
+                        unsigned long dotval = (sp->flags & F_DOT_BLACK ?
+                                                DOT_BLACK : DOT_WHITE);
+                        flags |= dotval << (DOT_SHIFT_C +
+                                            DOT_SHIFT_M*(dy*3+dx));
+                    }
+                }
+
+            /*
+             * Now work out if we have to draw a cursor for this square;
+             * cursors-on-lines are taken care of below.
+             */
+            if (ui->cur_visible &&
+                ui->cur_x == x*2+1 && ui->cur_y == y*2+1 &&
+                !(SPACE(state, x*2+1, y*2+1).flags & F_DOT))
+                flags |= DRAW_CURSOR;
+
+            /*
+             * Now we have everything we're going to need. Draw the
+             * square.
+             */
+            if (ds->grid[y*w+x] != flags ||
+                ds->dx[y*w+x] != ddx ||
+                ds->dy[y*w+x] != ddy) {
+                draw_square(dr, ds, x, y, flags, ddx, ddy);
+                ds->grid[y*w+x] = flags;
+                ds->dx[y*w+x] = ddx;
+                ds->dy[y*w+x] = ddy;
+            }
+        }
+
+    /*
+     * Draw a cursor. This secondary blitter is much less invasive than trying
+     * to fix up all of the rest of the code with sufficient flags to be able to
+     * display this sensibly.
+     */
+    if (ui->cur_visible) {
+        space *sp = &SPACE(state, ui->cur_x, ui->cur_y);
+        ds->cur_visible = TRUE;
+        ds->cx = SCOORD(ui->cur_x) - CURSOR_SIZE;
+        ds->cy = SCOORD(ui->cur_y) - CURSOR_SIZE;
+        blitter_save(dr, ds->cur_bl, ds->cx, ds->cy);
+        if (sp->flags & F_DOT) {
+            /* draw a red dot (over the top of whatever would be there already) */
+            draw_circle(dr, SCOORD(ui->cur_x), SCOORD(ui->cur_y), DOT_SIZE,
+                        COL_CURSOR, COL_BLACKDOT);
+        } else if (sp->type != s_tile) {
+            /* draw an edge/vertex square; tile cursors are dealt with above. */
+            int dx = (ui->cur_x % 2) ? CURSOR_SIZE : CURSOR_SIZE/3;
+            int dy = (ui->cur_y % 2) ? CURSOR_SIZE : CURSOR_SIZE/3;
+            int x1 = SCOORD(ui->cur_x)-dx, y1 = SCOORD(ui->cur_y)-dy;
+            int xs = dx*2+1, ys = dy*2+1;
+
+            draw_rect(dr, x1, y1, xs, ys, COL_CURSOR);
+        }
+        draw_update(dr, ds->cx, ds->cy, CURSOR_SIZE*2+1, CURSOR_SIZE*2+1);
+    }
+
+    if (ui->dragging) {
+        ds->dragging = TRUE;
+        ds->dragx = ui->dx - TILE_SIZE/2;
+        ds->dragy = ui->dy - TILE_SIZE/2;
+        calculate_opposite_point(ui, ds, ui->dx, ui->dy, &oppx, &oppy);
+        blitter_save(dr, ds->bl, ds->dragx, ds->dragy);
+        blitter_save(dr, ds->blmirror, oppx - TILE_SIZE/2, oppy - TILE_SIZE/2);
+        draw_arrow(dr, ds, ui->dx, ui->dy, SCOORD(ui->dotx) - ui->dx,
+                   SCOORD(ui->doty) - ui->dy, COL_ARROW);
+        draw_arrow(dr, ds, oppx, oppy, SCOORD(ui->dotx) - oppx,
+                   SCOORD(ui->doty) - oppy, COL_ARROW);
+    }
+#ifdef EDITOR
+    {
+        char buf[256];
+        if (state->cdiff != -1)
+            sprintf(buf, "Puzzle is %s.", galaxies_diffnames[state->cdiff]);
+        else
+            buf[0] = '\0';
+        status_bar(dr, buf);
+    }
+#endif
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if ((!oldstate->completed && newstate->completed) &&
+        !(newstate->used_solve))
+        return 3 * FLASH_TIME;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+#ifndef EDITOR
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+   int pw, ph;
+
+   /*
+    * 8mm squares by default. (There isn't all that much detail
+    * that needs to go in each square.)
+    */
+   game_compute_size(params, 800, &pw, &ph);
+   *x = pw / 100.0F;
+   *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int sz)
+{
+    int w = state->w, h = state->h;
+    int white, black, blackish;
+    int x, y, i, j;
+    int *colours, *dsf;
+    int *coords = NULL;
+    int ncoords = 0, coordsize = 0;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    ds->tilesize = sz;
+
+    white = print_mono_colour(dr, 1);
+    black = print_mono_colour(dr, 0);
+    blackish = print_hatched_colour(dr, HATCH_X);
+
+    /*
+     * Get the completion information.
+     */
+    dsf = snewn(w * h, int);
+    colours = snewn(w * h, int);
+    check_complete(state, dsf, colours);
+
+    /*
+     * Draw the grid.
+     */
+    print_line_width(dr, TILE_SIZE / 64);
+    for (x = 1; x < w; x++)
+        draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h), black);
+    for (y = 1; y < h; y++)
+        draw_line(dr, COORD(0), COORD(y), COORD(w), COORD(y), black);
+
+    /*
+     * Shade the completed regions. Just in case any particular
+     * printing platform deals badly with adjacent
+     * similarly-hatched regions, we'll fill each one as a single
+     * polygon.
+     */
+    for (i = 0; i < w*h; i++) {
+        j = dsf_canonify(dsf, i);
+        if (colours[j] != 0) {
+            int dx, dy, t;
+
+            /*
+             * This is the first square we've run into belonging to
+             * this polyomino, which means an edge of the polyomino
+             * is certain to be to our left. (After we finish
+             * tracing round it, we'll set the colours[] entry to
+             * zero to prevent accidentally doing it again.)
+             */
+
+            x = i % w;
+            y = i / w;
+            dx = -1;
+            dy = 0;
+            ncoords = 0;
+            while (1) {
+                /*
+                 * We are currently sitting on square (x,y), which
+                 * we know to be in our polyomino, and we also know
+                 * that (x+dx,y+dy) is not. The way I visualise
+                 * this is that we're standing to the right of a
+                 * boundary line, stretching our left arm out to
+                 * point to the exterior square on the far side.
+                 */
+
+                /*
+                 * First, check if we've gone round the entire
+                 * polyomino.
+                 */
+                if (ncoords > 0 &&
+                    (x == i%w && y == i/w && dx == -1 && dy == 0))
+                    break;
+
+                /*
+                 * Add to our coordinate list the coordinate
+                 * backwards and to the left of where we are.
+                 */
+                if (ncoords + 2 > coordsize) {
+                    coordsize = (ncoords * 3 / 2) + 64;
+                    coords = sresize(coords, coordsize, int);
+                }
+                coords[ncoords++] = COORD((2*x+1 + dx + dy) / 2);
+                coords[ncoords++] = COORD((2*y+1 + dy - dx) / 2);
+
+                /*
+                 * Follow the edge round. If the square directly in
+                 * front of us is not part of the polyomino, we
+                 * turn right; if it is and so is the square in
+                 * front of (x+dx,y+dy), we turn left; otherwise we
+                 * go straight on.
+                 */
+                if (x-dy < 0 || x-dy >= w || y+dx < 0 || y+dx >= h ||
+                    dsf_canonify(dsf, (y+dx)*w+(x-dy)) != j) {
+                    /* Turn right. */
+                    t = dx;
+                    dx = -dy;
+                    dy = t;
+                } else if (x+dx-dy >= 0 && x+dx-dy < w &&
+                           y+dy+dx >= 0 && y+dy+dx < h &&
+                           dsf_canonify(dsf, (y+dy+dx)*w+(x+dx-dy)) == j) {
+                    /* Turn left. */
+                    x += dx;
+                    y += dy;
+                    t = dx;
+                    dx = dy;
+                    dy = -t;
+                    x -= dx;
+                    y -= dy;
+                } else {
+                    /* Straight on. */
+                    x -= dy;
+                    y += dx;
+                }
+            }
+
+            /*
+             * Now we have our polygon complete, so fill it.
+             */
+            draw_polygon(dr, coords, ncoords/2,
+                         colours[j] == 2 ? blackish : -1, black);
+
+            /*
+             * And mark this polyomino as done.
+             */
+            colours[j] = 0;
+        }
+    }
+
+    /*
+     * Draw the edges.
+     */
+    for (y = 0; y <= h; y++)
+        for (x = 0; x <= w; x++) {
+            if (x < w && SPACE(state, x*2+1, y*2).flags & F_EDGE_SET)
+                draw_rect(dr, COORD(x)-EDGE_THICKNESS, COORD(y)-EDGE_THICKNESS,
+                          EDGE_THICKNESS * 2 + TILE_SIZE, EDGE_THICKNESS * 2,
+                          black);
+            if (y < h && SPACE(state, x*2, y*2+1).flags & F_EDGE_SET)
+                draw_rect(dr, COORD(x)-EDGE_THICKNESS, COORD(y)-EDGE_THICKNESS,
+                          EDGE_THICKNESS * 2, EDGE_THICKNESS * 2 + TILE_SIZE,
+                          black);
+        }
+
+    /*
+     * Draw the dots.
+     */
+    for (y = 0; y <= 2*h; y++)
+        for (x = 0; x <= 2*w; x++)
+            if (SPACE(state, x, y).flags & F_DOT) {
+                draw_circle(dr, (int)COORD(x/2.0), (int)COORD(y/2.0), DOT_SIZE,
+                            (SPACE(state, x, y).flags & F_DOT_BLACK ?
+                             black : white), black);
+            }
+
+    sfree(dsf);
+    sfree(colours);
+    sfree(coords);
+}
+#endif
+
+#ifdef COMBINED
+#define thegame galaxies
+#endif
+
+const struct game thegame = {
+    "Galaxies", "games.galaxies", "galaxies",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+#ifdef EDITOR
+    FALSE, NULL,
+#else
+    TRUE, solve_game,
+#endif
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+#ifdef EDITOR
+    FALSE, FALSE, NULL, NULL,
+    TRUE,                              /* wants_statusbar */
+#else
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+#endif
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON,                   /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+const char *quis;
+
+#include <time.h>
+
+static void usage_exit(const char *msg)
+{
+    if (msg)
+        fprintf(stderr, "%s: %s\n", quis, msg);
+    fprintf(stderr, "Usage: %s [--seed SEED] --soak <params> | [game_id [game_id ...]]\n", quis);
+    exit(1);
+}
+
+static void dump_state(game_state *state)
+{
+    char *temp = game_text_format(state);
+    printf("%s\n", temp);
+    sfree(temp);
+}
+
+static int gen(game_params *p, random_state *rs, int debug)
+{
+    char *desc;
+    int diff;
+    game_state *state;
+
+#ifndef DEBUGGING
+    solver_show_working = debug;
+#endif
+    printf("Generating a %dx%d %s puzzle.\n",
+           p->w, p->h, galaxies_diffnames[p->diff]);
+
+    desc = new_game_desc(p, rs, NULL, 0);
+    state = new_game(NULL, p, desc);
+    dump_state(state);
+
+    diff = solver_state(state, DIFF_UNREASONABLE);
+    printf("Generated %s game %dx%d:%s\n",
+           galaxies_diffnames[diff], p->w, p->h, desc);
+    dump_state(state);
+
+    free_game(state);
+    sfree(desc);
+
+    return diff;
+}
+
+static void soak(game_params *p, random_state *rs)
+{
+    time_t tt_start, tt_now, tt_last;
+    char *desc;
+    game_state *st;
+    int diff, n = 0, i, diffs[DIFF_MAX], ndots = 0, nspaces = 0;
+
+#ifndef DEBUGGING
+    solver_show_working = 0;
+#endif
+    tt_start = tt_now = time(NULL);
+    for (i = 0; i < DIFF_MAX; i++) diffs[i] = 0;
+    maxtries = 1;
+
+    printf("Soak-generating a %dx%d grid, max. diff %s.\n",
+           p->w, p->h, galaxies_diffnames[p->diff]);
+    printf("   [");
+    for (i = 0; i < DIFF_MAX; i++)
+        printf("%s%s", (i == 0) ? "" : ", ", galaxies_diffnames[i]);
+    printf("]\n");
+
+    while (1) {
+        desc = new_game_desc(p, rs, NULL, 0);
+        st = new_game(NULL, p, desc);
+        diff = solver_state(st, p->diff);
+        nspaces += st->w*st->h;
+        for (i = 0; i < st->sx*st->sy; i++)
+            if (st->grid[i].flags & F_DOT) ndots++;
+        free_game(st);
+        sfree(desc);
+
+        diffs[diff]++;
+        n++;
+        tt_last = time(NULL);
+        if (tt_last > tt_now) {
+            tt_now = tt_last;
+            printf("%d total, %3.1f/s, [",
+                   n, (double)n / ((double)tt_now - tt_start));
+            for (i = 0; i < DIFF_MAX; i++)
+                printf("%s%.1f%%", (i == 0) ? "" : ", ",
+                       100.0 * ((double)diffs[i] / (double)n));
+            printf("], %.1f%% dots\n",
+                   100.0 * ((double)ndots / (double)nspaces));
+        }
+    }
+}
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    char *id = NULL, *desc, *err;
+    game_state *s;
+    int diff, do_soak = 0, verbose = 0;
+    random_state *rs;
+    time_t seed = time(NULL);
+
+    quis = argv[0];
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            verbose = 1;
+        } else if (!strcmp(p, "--seed")) {
+            if (argc == 0) usage_exit("--seed needs an argument");
+            seed = (time_t)atoi(*++argv);
+            argc--;
+        } else if (!strcmp(p, "--soak")) {
+            do_soak = 1;
+        } else if (*p == '-') {
+            usage_exit("unrecognised option");
+        } else {
+            id = p;
+        }
+    }
+
+    maxtries = 50;
+
+    p = default_params();
+    rs = random_new((void*)&seed, sizeof(time_t));
+
+    if (do_soak) {
+        if (!id) usage_exit("need one argument for --soak");
+        decode_params(p, *argv);
+        soak(p, rs);
+        return 0;
+    }
+
+    if (!id) {
+        while (1) {
+            p->w = random_upto(rs, 15) + 3;
+            p->h = random_upto(rs, 15) + 3;
+            p->diff = random_upto(rs, DIFF_UNREASONABLE);
+            diff = gen(p, rs, 0);
+        }
+        return 0;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        decode_params(p, id);
+        gen(p, rs, verbose);
+    } else {
+#ifndef DEBUGGING
+        solver_show_working = 1;
+#endif
+        *desc++ = '\0';
+        decode_params(p, id);
+        err = validate_desc(p, desc);
+        if (err) {
+            fprintf(stderr, "%s: %s\n", argv[0], err);
+            exit(1);
+        }
+        s = new_game(NULL, p, desc);
+        diff = solver_state(s, DIFF_UNREASONABLE);
+        dump_state(s);
+        printf("Puzzle is %s.\n", galaxies_diffnames[diff]);
+        free_game(s);
+    }
+
+    free_params(p);
+
+    return 0;
+}
+
+#endif
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+
+/*
+ * Main program for the standalone picture generator. To use it,
+ * simply provide it with an XBM-format bitmap file (note XBM, not
+ * XPM) on standard input, and it will output a game ID in return.
+ * For example:
+ *
+ *   $ ./galaxiespicture < badly-drawn-cat.xbm
+ *   11x11:eloMBLzFeEzLNMWifhaWYdDbixCymBbBMLoDdewGg
+ *
+ * If you want a puzzle with a non-standard difficulty level, pass
+ * a partial parameters string as a command-line argument (e.g.
+ * `./galaxiespicture du < foo.xbm', where `du' is the same suffix
+ * which if it appeared in a random-seed game ID would set the
+ * difficulty level to Unreasonable). However, be aware that if the
+ * generator fails to produce an adequately difficult puzzle too
+ * many times then it will give up and return an easier one (just
+ * as it does during normal GUI play). To be sure you really have
+ * the difficulty you asked for, use galaxiessolver to
+ * double-check.
+ * 
+ * (Perhaps I ought to include an option to make this standalone
+ * generator carry on looping until it really does get the right
+ * difficulty. Hmmm.)
+ */
+
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+    game_params *par;
+    char *params, *desc;
+    random_state *rs;
+    time_t seed = time(NULL);
+    char buf[4096];
+    int i;
+    int x, y;
+
+    par = default_params();
+    if (argc > 1)
+        decode_params(par, argv[1]);   /* get difficulty */
+    par->w = par->h = -1;
+
+    /*
+     * Now read an XBM file from standard input. This is simple and
+     * hacky and will do very little error detection, so don't feed
+     * it bogus data.
+     */
+    picture = NULL;
+    x = y = 0;
+    while (fgets(buf, sizeof(buf), stdin)) {
+        buf[strcspn(buf, "\r\n")] = '\0';
+        if (!strncmp(buf, "#define", 7)) {
+            /*
+             * Lines starting `#define' give the width and height.
+             */
+            char *num = buf + strlen(buf);
+            char *symend;
+
+            while (num > buf && isdigit((unsigned char)num[-1]))
+                num--;
+            symend = num;
+            while (symend > buf && isspace((unsigned char)symend[-1]))
+                symend--;
+
+            if (symend-5 >= buf && !strncmp(symend-5, "width", 5))
+                par->w = atoi(num);
+            else if (symend-6 >= buf && !strncmp(symend-6, "height", 6))
+                par->h = atoi(num);
+        } else {
+            /*
+             * Otherwise, break the string up into words and take
+             * any word of the form `0x' plus hex digits to be a
+             * byte.
+             */
+            char *p, *wordstart;
+
+            if (!picture) {
+                if (par->w < 0 || par->h < 0) {
+                    printf("failed to read width and height\n");
+                    return 1;
+                }
+                picture = snewn(par->w * par->h, int);
+                for (i = 0; i < par->w * par->h; i++)
+                    picture[i] = -1;
+            }
+
+            p = buf;
+            while (*p) {
+                while (*p && (*p == ',' || isspace((unsigned char)*p)))
+                    p++;
+                wordstart = p;
+                while (*p && !(*p == ',' || *p == '}' ||
+                               isspace((unsigned char)*p)))
+                    p++;
+                if (*p)
+                    *p++ = '\0';
+
+                if (wordstart[0] == '0' &&
+                    (wordstart[1] == 'x' || wordstart[1] == 'X') &&
+                    !wordstart[2 + strspn(wordstart+2,
+                                          "0123456789abcdefABCDEF")]) {
+                    unsigned long byte = strtoul(wordstart+2, NULL, 16);
+                    for (i = 0; i < 8; i++) {
+                        int bit = (byte >> i) & 1;
+                        if (y < par->h && x < par->w)
+                            picture[y * par->w + x] = bit;
+                        x++;
+                    }
+
+                    if (x >= par->w) {
+                        x = 0;
+                        y++;
+                    }
+                }
+            }
+        }
+    }
+
+    for (i = 0; i < par->w * par->h; i++)
+        if (picture[i] < 0) {
+            fprintf(stderr, "failed to read enough bitmap data\n");
+            return 1;
+        }
+
+    rs = random_new((void*)&seed, sizeof(time_t));
+
+    desc = new_game_desc(par, rs, NULL, FALSE);
+    params = encode_params(par, FALSE);
+    printf("%s:%s\n", params, desc);
+
+    sfree(desc);
+    sfree(params);
+    free_params(par);
+    random_free(rs);
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/grid.c b/apps/plugins/puzzles/grid.c
new file mode 100644
index 0000000000..112162d4df
--- /dev/null
+++ b/apps/plugins/puzzles/grid.c
@@ -0,0 +1,2896 @@
+/*
+ * (c) Lambros Lambrou 2008
+ *
+ * Code for working with general grids, which can be any planar graph
+ * with faces, edges and vertices (dots).  Includes generators for a few
+ * types of grid, including square, hexagonal, triangular and others.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+#include <float.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+#include "grid.h"
+#include "penrose.h"
+
+/* Debugging options */
+
+/*
+#define DEBUG_GRID
+*/
+
+/* ----------------------------------------------------------------------
+ * Deallocate or dereference a grid
+ */
+void grid_free(grid *g)
+{
+    assert(g->refcount);
+
+    g->refcount--;
+    if (g->refcount == 0) {
+        int i;
+        for (i = 0; i < g->num_faces; i++) {
+            sfree(g->faces[i].dots);
+            sfree(g->faces[i].edges);
+        }
+        for (i = 0; i < g->num_dots; i++) {
+            sfree(g->dots[i].faces);
+            sfree(g->dots[i].edges);
+        }
+        sfree(g->faces);
+        sfree(g->edges);
+        sfree(g->dots);
+        sfree(g);
+    }
+}
+
+/* Used by the other grid generators.  Create a brand new grid with nothing
+ * initialised (all lists are NULL) */
+static grid *grid_empty(void)
+{
+    grid *g = snew(grid);
+    g->faces = NULL;
+    g->edges = NULL;
+    g->dots = NULL;
+    g->num_faces = g->num_edges = g->num_dots = 0;
+    g->refcount = 1;
+    g->lowest_x = g->lowest_y = g->highest_x = g->highest_y = 0;
+    return g;
+}
+
+/* Helper function to calculate perpendicular distance from
+ * a point P to a line AB.  A and B mustn't be equal here.
+ *
+ * Well-known formula for area A of a triangle:
+ *                             /  1   1   1 \
+ * 2A = determinant of matrix  | px  ax  bx |
+ *                             \ py  ay  by /
+ *
+ * Also well-known: 2A = base * height
+ *                     = perpendicular distance * line-length.
+ *
+ * Combining gives: distance = determinant / line-length(a,b)
+ */
+static double point_line_distance(long px, long py,
+                                  long ax, long ay,
+                                  long bx, long by)
+{
+    long det = ax*by - bx*ay + bx*py - px*by + px*ay - ax*py;
+    double len;
+    det = max(det, -det);
+    len = sqrt(SQ(ax - bx) + SQ(ay - by));
+    return det / len;
+}
+
+/* Determine nearest edge to where the user clicked.
+ * (x, y) is the clicked location, converted to grid coordinates.
+ * Returns the nearest edge, or NULL if no edge is reasonably
+ * near the position.
+ *
+ * Just judging edges by perpendicular distance is not quite right -
+ * the edge might be "off to one side". So we insist that the triangle
+ * with (x,y) has acute angles at the edge's dots.
+ *
+ *     edge1
+ *  *---------*------
+ *            |
+ *            |      *(x,y)
+ *      edge2 |
+ *            |   edge2 is OK, but edge1 is not, even though
+ *            |   edge1 is perpendicularly closer to (x,y)
+ *            *
+ *
+ */
+grid_edge *grid_nearest_edge(grid *g, int x, int y)
+{
+    grid_edge *best_edge;
+    double best_distance = 0;
+    int i;
+
+    best_edge = NULL;
+
+    for (i = 0; i < g->num_edges; i++) {
+        grid_edge *e = &g->edges[i];
+        long e2; /* squared length of edge */
+        long a2, b2; /* squared lengths of other sides */
+        double dist;
+
+        /* See if edge e is eligible - the triangle must have acute angles
+         * at the edge's dots.
+         * Pythagoras formula h^2 = a^2 + b^2 detects right-angles,
+         * so detect acute angles by testing for h^2 < a^2 + b^2 */
+        e2 = SQ((long)e->dot1->x - (long)e->dot2->x) + SQ((long)e->dot1->y - (long)e->dot2->y);
+        a2 = SQ((long)e->dot1->x - (long)x) + SQ((long)e->dot1->y - (long)y);
+        b2 = SQ((long)e->dot2->x - (long)x) + SQ((long)e->dot2->y - (long)y);
+        if (a2 >= e2 + b2) continue;
+        if (b2 >= e2 + a2) continue;
+         
+        /* e is eligible so far.  Now check the edge is reasonably close
+         * to where the user clicked.  Don't want to toggle an edge if the
+         * click was way off the grid.
+         * There is room for experimentation here.  We could check the
+         * perpendicular distance is within a certain fraction of the length
+         * of the edge.  That amounts to testing a rectangular region around
+         * the edge.
+         * Alternatively, we could check that the angle at the point is obtuse.
+         * That would amount to testing a circular region with the edge as
+         * diameter. */
+        dist = point_line_distance((long)x, (long)y,
+                                   (long)e->dot1->x, (long)e->dot1->y,
+                                   (long)e->dot2->x, (long)e->dot2->y);
+        /* Is dist more than half edge length ? */
+        if (4 * SQ(dist) > e2)
+            continue;
+
+        if (best_edge == NULL || dist < best_distance) {
+            best_edge = e;
+            best_distance = dist;
+        }
+    }
+    return best_edge;
+}
+
+/* ----------------------------------------------------------------------
+ * Grid generation
+ */
+
+#ifdef SVG_GRID
+
+#define SVG_DOTS  1
+#define SVG_EDGES 2
+#define SVG_FACES 4
+
+#define FACE_COLOUR "red"
+#define EDGE_COLOUR "blue"
+#define DOT_COLOUR "black"
+
+static void grid_output_svg(FILE *fp, grid *g, int which)
+{
+    int i, j;
+
+    fprintf(fp,"\
+<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n\
+<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 20010904//EN\"\n\
+\"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n\
+\n\
+<svg xmlns=\"http://www.w3.org/2000/svg\"\n\
+xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n\n");
+
+    if (which & SVG_FACES) {
+        fprintf(fp, "<g>\n");
+        for (i = 0; i < g->num_faces; i++) {
+            grid_face *f = g->faces + i;
+            fprintf(fp, "<polygon points=\"");
+            for (j = 0; j < f->order; j++) {
+                grid_dot *d = f->dots[j];
+                fprintf(fp, "%s%d,%d", (j == 0) ? "" : " ",
+                        d->x, d->y);
+            }
+            fprintf(fp, "\" style=\"fill: %s; fill-opacity: 0.2; stroke: %s\" />\n",
+                    FACE_COLOUR, FACE_COLOUR);
+        }
+        fprintf(fp, "</g>\n");
+    }
+    if (which & SVG_EDGES) {
+        fprintf(fp, "<g>\n");
+        for (i = 0; i < g->num_edges; i++) {
+            grid_edge *e = g->edges + i;
+            grid_dot *d1 = e->dot1, *d2 = e->dot2;
+
+            fprintf(fp, "<line x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" "
+                        "style=\"stroke: %s\" />\n",
+                        d1->x, d1->y, d2->x, d2->y, EDGE_COLOUR);
+        }
+        fprintf(fp, "</g>\n");
+    }
+
+    if (which & SVG_DOTS) {
+        fprintf(fp, "<g>\n");
+        for (i = 0; i < g->num_dots; i++) {
+            grid_dot *d = g->dots + i;
+            fprintf(fp, "<ellipse cx=\"%d\" cy=\"%d\" rx=\"%d\" ry=\"%d\" fill=\"%s\" />",
+                    d->x, d->y, g->tilesize/20, g->tilesize/20, DOT_COLOUR);
+        }
+        fprintf(fp, "</g>\n");
+    }
+
+    fprintf(fp, "</svg>\n");
+}
+#endif
+
+#ifdef SVG_GRID
+#include <errno.h>
+
+static void grid_try_svg(grid *g, int which)
+{
+    char *svg = getenv("PUZZLES_SVG_GRID");
+    if (svg) {
+        FILE *svgf = fopen(svg, "w");
+        if (svgf) {
+            grid_output_svg(svgf, g, which);
+            fclose(svgf);
+        } else {
+            fprintf(stderr, "Unable to open file `%s': %s", svg, strerror(errno));
+        }
+    }
+}
+#endif
+
+/* Show the basic grid information, before doing grid_make_consistent */
+static void grid_debug_basic(grid *g)
+{
+    /* TODO: Maybe we should generate an SVG image of the dots and lines
+     * of the grid here, before grid_make_consistent.
+     * Would help with debugging grid generation. */
+#ifdef DEBUG_GRID
+    int i;
+    printf("--- Basic Grid Data ---\n");
+    for (i = 0; i < g->num_faces; i++) {
+        grid_face *f = g->faces + i;
+        printf("Face %d: dots[", i);
+        int j;
+        for (j = 0; j < f->order; j++) {
+            grid_dot *d = f->dots[j];
+            printf("%s%d", j ? "," : "", (int)(d - g->dots)); 
+        }
+        printf("]\n");
+    }
+#endif
+#ifdef SVG_GRID
+    grid_try_svg(g, SVG_FACES);
+#endif
+}
+
+/* Show the derived grid information, computed by grid_make_consistent */
+static void grid_debug_derived(grid *g)
+{
+#ifdef DEBUG_GRID
+    /* edges */
+    int i;
+    printf("--- Derived Grid Data ---\n");
+    for (i = 0; i < g->num_edges; i++) {
+        grid_edge *e = g->edges + i;
+        printf("Edge %d: dots[%d,%d] faces[%d,%d]\n",
+            i, (int)(e->dot1 - g->dots), (int)(e->dot2 - g->dots),
+            e->face1 ? (int)(e->face1 - g->faces) : -1,
+            e->face2 ? (int)(e->face2 - g->faces) : -1);
+    }
+    /* faces */
+    for (i = 0; i < g->num_faces; i++) {
+        grid_face *f = g->faces + i;
+        int j;
+        printf("Face %d: faces[", i);
+        for (j = 0; j < f->order; j++) {
+            grid_edge *e = f->edges[j];
+            grid_face *f2 = (e->face1 == f) ? e->face2 : e->face1;
+            printf("%s%d", j ? "," : "", f2 ? (int)(f2 - g->faces) : -1);
+        }
+        printf("]\n");
+    }
+    /* dots */
+    for (i = 0; i < g->num_dots; i++) {
+        grid_dot *d = g->dots + i;
+        int j;
+        printf("Dot %d: dots[", i);
+        for (j = 0; j < d->order; j++) {
+            grid_edge *e = d->edges[j];
+            grid_dot *d2 = (e->dot1 == d) ? e->dot2 : e->dot1;
+            printf("%s%d", j ? "," : "", (int)(d2 - g->dots));
+        }
+        printf("] faces[");
+        for (j = 0; j < d->order; j++) {
+            grid_face *f = d->faces[j];
+            printf("%s%d", j ? "," : "", f ? (int)(f - g->faces) : -1);
+        }
+        printf("]\n");
+    }
+#endif
+#ifdef SVG_GRID
+    grid_try_svg(g, SVG_DOTS | SVG_EDGES | SVG_FACES);
+#endif
+}
+
+/* Helper function for building incomplete-edges list in
+ * grid_make_consistent() */
+static int grid_edge_bydots_cmpfn(void *v1, void *v2)
+{
+    grid_edge *a = v1;
+    grid_edge *b = v2;
+    grid_dot *da, *db;
+
+    /* Pointer subtraction is valid here, because all dots point into the
+     * same dot-list (g->dots).
+     * Edges are not "normalised" - the 2 dots could be stored in any order,
+     * so we need to take this into account when comparing edges. */
+
+    /* Compare first dots */
+    da = (a->dot1 < a->dot2) ? a->dot1 : a->dot2;
+    db = (b->dot1 < b->dot2) ? b->dot1 : b->dot2;
+    if (da != db)
+        return db - da;
+    /* Compare last dots */
+    da = (a->dot1 < a->dot2) ? a->dot2 : a->dot1;
+    db = (b->dot1 < b->dot2) ? b->dot2 : b->dot1;
+    if (da != db)
+        return db - da;
+
+    return 0;
+}
+
+/*
+ * 'Vigorously trim' a grid, by which I mean deleting any isolated or
+ * uninteresting faces. By which, in turn, I mean: ensure that the
+ * grid is composed solely of faces adjacent to at least one
+ * 'landlocked' dot (i.e. one not in contact with the infinite
+ * exterior face), and that all those dots are in a single connected
+ * component.
+ *
+ * This function operates on, and returns, a grid satisfying the
+ * preconditions to grid_make_consistent() rather than the
+ * postconditions. (So call it first.)
+ */
+static void grid_trim_vigorously(grid *g)
+{
+    int *dotpairs, *faces, *dots;
+    int *dsf;
+    int i, j, k, size, newfaces, newdots;
+
+    /*
+     * First construct a matrix in which each ordered pair of dots is
+     * mapped to the index of the face in which those dots occur in
+     * that order.
+     */
+    dotpairs = snewn(g->num_dots * g->num_dots, int);
+    for (i = 0; i < g->num_dots; i++)
+        for (j = 0; j < g->num_dots; j++)
+            dotpairs[i*g->num_dots+j] = -1;
+    for (i = 0; i < g->num_faces; i++) {
+        grid_face *f = g->faces + i;
+        int dot0 = f->dots[f->order-1] - g->dots;
+        for (j = 0; j < f->order; j++) {
+            int dot1 = f->dots[j] - g->dots;
+            dotpairs[dot0 * g->num_dots + dot1] = i;
+            dot0 = dot1;
+        }
+    }
+
+    /*
+     * Now we can identify landlocked dots: they're the ones all of
+     * whose edges have a mirror-image counterpart in this matrix.
+     */
+    dots = snewn(g->num_dots, int);
+    for (i = 0; i < g->num_dots; i++) {
+        dots[i] = TRUE;
+        for (j = 0; j < g->num_dots; j++) {
+            if ((dotpairs[i*g->num_dots+j] >= 0) ^
+                (dotpairs[j*g->num_dots+i] >= 0))
+                dots[i] = FALSE;    /* non-duplicated edge: coastal dot */
+        }
+    }
+
+    /*
+     * Now identify connected pairs of landlocked dots, and form a dsf
+     * unifying them.
+     */
+    dsf = snew_dsf(g->num_dots);
+    for (i = 0; i < g->num_dots; i++)
+        for (j = 0; j < i; j++)
+            if (dots[i] && dots[j] &&
+                dotpairs[i*g->num_dots+j] >= 0 &&
+                dotpairs[j*g->num_dots+i] >= 0)
+                dsf_merge(dsf, i, j);
+
+    /*
+     * Now look for the largest component.
+     */
+    size = 0;
+    j = -1;
+    for (i = 0; i < g->num_dots; i++) {
+        int newsize;
+        if (dots[i] && dsf_canonify(dsf, i) == i &&
+            (newsize = dsf_size(dsf, i)) > size) {
+            j = i;
+            size = newsize;
+        }
+    }
+
+    /*
+     * Work out which faces we're going to keep (precisely those with
+     * at least one dot in the same connected component as j) and
+     * which dots (those required by any face we're keeping).
+     *
+     * At this point we reuse the 'dots' array to indicate the dots
+     * we're keeping, rather than the ones that are landlocked.
+     */
+    faces = snewn(g->num_faces, int);
+    for (i = 0; i < g->num_faces; i++)
+        faces[i] = 0;
+    for (i = 0; i < g->num_dots; i++)
+        dots[i] = 0;
+    for (i = 0; i < g->num_faces; i++) {
+        grid_face *f = g->faces + i;
+        int keep = FALSE;
+        for (k = 0; k < f->order; k++)
+            if (dsf_canonify(dsf, f->dots[k] - g->dots) == j)
+                keep = TRUE;
+        if (keep) {
+            faces[i] = TRUE;
+            for (k = 0; k < f->order; k++)
+                dots[f->dots[k]-g->dots] = TRUE;
+        }
+    }
+
+    /*
+     * Work out the new indices of those faces and dots, when we
+     * compact the arrays containing them.
+     */
+    for (i = newfaces = 0; i < g->num_faces; i++)
+        faces[i] = (faces[i] ? newfaces++ : -1);
+    for (i = newdots = 0; i < g->num_dots; i++)
+        dots[i] = (dots[i] ? newdots++ : -1);
+
+    /*
+     * Free the dynamically allocated 'dots' pointer lists in faces
+     * we're going to discard.
+     */
+    for (i = 0; i < g->num_faces; i++)
+        if (faces[i] < 0)
+            sfree(g->faces[i].dots);
+
+    /*
+     * Go through and compact the arrays.
+     */
+    for (i = 0; i < g->num_dots; i++)
+        if (dots[i] >= 0) {
+            grid_dot *dnew = g->dots + dots[i], *dold = g->dots + i;
+            *dnew = *dold;             /* structure copy */
+        }
+    for (i = 0; i < g->num_faces; i++)
+        if (faces[i] >= 0) {
+            grid_face *fnew = g->faces + faces[i], *fold = g->faces + i;
+            *fnew = *fold;             /* structure copy */
+            for (j = 0; j < fnew->order; j++) {
+                /*
+                 * Reindex the dots in this face.
+                 */
+                k = fnew->dots[j] - g->dots;
+                fnew->dots[j] = g->dots + dots[k];
+            }
+        }
+    g->num_faces = newfaces;
+    g->num_dots = newdots;
+
+    sfree(dotpairs);
+    sfree(dsf);
+    sfree(dots);
+    sfree(faces);
+}
+
+/* Input: grid has its dots and faces initialised:
+ * - dots have (optionally) x and y coordinates, but no edges or faces
+ * (pointers are NULL).
+ * - edges not initialised at all
+ * - faces initialised and know which dots they have (but no edges yet).  The
+ * dots around each face are assumed to be clockwise.
+ *
+ * Output: grid is complete and valid with all relationships defined.
+ */
+static void grid_make_consistent(grid *g)
+{
+    int i;
+    tree234 *incomplete_edges;
+    grid_edge *next_new_edge; /* Where new edge will go into g->edges */
+
+    grid_debug_basic(g);
+
+    /* ====== Stage 1 ======
+     * Generate edges
+     */
+
+    /* We know how many dots and faces there are, so we can find the exact
+     * number of edges from Euler's polyhedral formula: F + V = E + 2 .
+     * We use "-1", not "-2" here, because Euler's formula includes the
+     * infinite face, which we don't count. */
+    g->num_edges = g->num_faces + g->num_dots - 1;
+    g->edges = snewn(g->num_edges, grid_edge);
+    next_new_edge = g->edges;
+
+    /* Iterate over faces, and over each face's dots, generating edges as we
+     * go.  As we find each new edge, we can immediately fill in the edge's
+     * dots, but only one of the edge's faces.  Later on in the iteration, we
+     * will find the same edge again (unless it's on the border), but we will
+     * know the other face.
+     * For efficiency, maintain a list of the incomplete edges, sorted by
+     * their dots. */
+    incomplete_edges = newtree234(grid_edge_bydots_cmpfn);
+    for (i = 0; i < g->num_faces; i++) {
+        grid_face *f = g->faces + i;
+        int j;
+        for (j = 0; j < f->order; j++) {
+            grid_edge e; /* fake edge for searching */
+            grid_edge *edge_found;
+            int j2 = j + 1;
+            if (j2 == f->order)
+                j2 = 0;
+            e.dot1 = f->dots[j];
+            e.dot2 = f->dots[j2];
+            /* Use del234 instead of find234, because we always want to
+             * remove the edge if found */
+            edge_found = del234(incomplete_edges, &e);
+            if (edge_found) {
+                /* This edge already added, so fill out missing face.
+                 * Edge is already removed from incomplete_edges. */
+                edge_found->face2 = f;
+            } else {
+                assert(next_new_edge - g->edges < g->num_edges);
+                next_new_edge->dot1 = e.dot1;
+                next_new_edge->dot2 = e.dot2;
+                next_new_edge->face1 = f;
+                next_new_edge->face2 = NULL; /* potentially infinite face */
+                add234(incomplete_edges, next_new_edge);
+                ++next_new_edge;
+            }
+        }
+    }
+    freetree234(incomplete_edges);
+    
+    /* ====== Stage 2 ======
+     * For each face, build its edge list.
+     */
+
+    /* Allocate space for each edge list.  Can do this, because each face's
+     * edge-list is the same size as its dot-list. */
+    for (i = 0; i < g->num_faces; i++) {
+        grid_face *f = g->faces + i;
+        int j;
+        f->edges = snewn(f->order, grid_edge*);
+        /* Preload with NULLs, to help detect potential bugs. */
+        for (j = 0; j < f->order; j++)
+            f->edges[j] = NULL;
+    }
+    
+    /* Iterate over each edge, and over both its faces.  Add this edge to
+     * the face's edge-list, after finding where it should go in the
+     * sequence. */
+    for (i = 0; i < g->num_edges; i++) {
+        grid_edge *e = g->edges + i;
+        int j;
+        for (j = 0; j < 2; j++) {
+            grid_face *f = j ? e->face2 : e->face1;
+            int k, k2;
+            if (f == NULL) continue;
+            /* Find one of the dots around the face */
+            for (k = 0; k < f->order; k++) {
+                if (f->dots[k] == e->dot1)
+                    break; /* found dot1 */
+            }
+            assert(k != f->order); /* Must find the dot around this face */
+
+            /* Labelling scheme: as we walk clockwise around the face,
+             * starting at dot0 (f->dots[0]), we hit:
+             * (dot0), edge0, dot1, edge1, dot2,...
+             *
+             *     0
+             *  0-----1
+             *        |
+             *        |1
+             *        |
+             *  3-----2
+             *     2
+             *
+             * Therefore, edgeK joins dotK and dot{K+1}
+             */
+            
+            /* Around this face, either the next dot or the previous dot
+             * must be e->dot2.  Otherwise the edge is wrong. */
+            k2 = k + 1;
+            if (k2 == f->order)
+                k2 = 0;
+            if (f->dots[k2] == e->dot2) {
+                /* dot1(k) and dot2(k2) go clockwise around this face, so add
+                 * this edge at position k (see diagram). */
+                assert(f->edges[k] == NULL);
+                f->edges[k] = e;
+                continue;
+            }
+            /* Try previous dot */
+            k2 = k - 1;
+            if (k2 == -1)
+                k2 = f->order - 1;
+            if (f->dots[k2] == e->dot2) {
+                /* dot1(k) and dot2(k2) go anticlockwise around this face. */
+                assert(f->edges[k2] == NULL);
+                f->edges[k2] = e;
+                continue;
+            }
+            assert(!"Grid broken: bad edge-face relationship");
+        }
+    }
+
+    /* ====== Stage 3 ======
+     * For each dot, build its edge-list and face-list.
+     */
+
+    /* We don't know how many edges/faces go around each dot, so we can't
+     * allocate the right space for these lists.  Pre-compute the sizes by
+     * iterating over each edge and recording a tally against each dot. */
+    for (i = 0; i < g->num_dots; i++) {
+        g->dots[i].order = 0;
+    }
+    for (i = 0; i < g->num_edges; i++) {
+        grid_edge *e = g->edges + i;
+        ++(e->dot1->order);
+        ++(e->dot2->order);
+    }
+    /* Now we have the sizes, pre-allocate the edge and face lists. */
+    for (i = 0; i < g->num_dots; i++) {
+        grid_dot *d = g->dots + i;
+        int j;
+        assert(d->order >= 2); /* sanity check */
+        d->edges = snewn(d->order, grid_edge*);
+        d->faces = snewn(d->order, grid_face*);
+        for (j = 0; j < d->order; j++) {
+            d->edges[j] = NULL;
+            d->faces[j] = NULL;
+        }
+    }
+    /* For each dot, need to find a face that touches it, so we can seed
+     * the edge-face-edge-face process around each dot. */
+    for (i = 0; i < g->num_faces; i++) {
+        grid_face *f = g->faces + i;
+        int j;
+        for (j = 0; j < f->order; j++) {
+            grid_dot *d = f->dots[j];
+            d->faces[0] = f;
+        }
+    }
+    /* Each dot now has a face in its first slot.  Generate the remaining
+     * faces and edges around the dot, by searching both clockwise and
+     * anticlockwise from the first face.  Need to do both directions,
+     * because of the possibility of hitting the infinite face, which
+     * blocks progress.  But there's only one such face, so we will
+     * succeed in finding every edge and face this way. */
+    for (i = 0; i < g->num_dots; i++) {
+        grid_dot *d = g->dots + i;
+        int current_face1 = 0; /* ascends clockwise */
+        int current_face2 = 0; /* descends anticlockwise */
+        
+        /* Labelling scheme: as we walk clockwise around the dot, starting
+         * at face0 (d->faces[0]), we hit:
+         * (face0), edge0, face1, edge1, face2,...
+         *
+         *       0
+         *       |
+         *    0  |  1
+         *       |
+         *  -----d-----1
+         *       |
+         *       |  2
+         *       |
+         *       2
+         *
+         * So, for example, face1 should be joined to edge0 and edge1,
+         * and those edges should appear in an anticlockwise sense around
+         * that face (see diagram). */
+ 
+        /* clockwise search */
+        while (TRUE) {
+            grid_face *f = d->faces[current_face1];
+            grid_edge *e;
+            int j;
+            assert(f != NULL);
+            /* find dot around this face */
+            for (j = 0; j < f->order; j++) {
+                if (f->dots[j] == d)
+                    break;
+            }
+            assert(j != f->order); /* must find dot */
+            
+            /* Around f, required edge is anticlockwise from the dot.  See
+             * the other labelling scheme higher up, for why we subtract 1
+             * from j. */
+            j--;
+            if (j == -1)
+                j = f->order - 1;
+            e = f->edges[j];
+            d->edges[current_face1] = e; /* set edge */
+            current_face1++;
+            if (current_face1 == d->order)
+                break;
+            else {
+                /* set face */
+                d->faces[current_face1] =
+                    (e->face1 == f) ? e->face2 : e->face1;
+                if (d->faces[current_face1] == NULL)
+                    break; /* cannot progress beyond infinite face */
+            }
+        }
+        /* If the clockwise search made it all the way round, don't need to
+         * bother with the anticlockwise search. */
+        if (current_face1 == d->order)
+            continue; /* this dot is complete, move on to next dot */
+        
+        /* anticlockwise search */
+        while (TRUE) {
+            grid_face *f = d->faces[current_face2];
+            grid_edge *e;
+            int j;
+            assert(f != NULL);
+            /* find dot around this face */
+            for (j = 0; j < f->order; j++) {
+                if (f->dots[j] == d)
+                    break;
+            }
+            assert(j != f->order); /* must find dot */
+            
+            /* Around f, required edge is clockwise from the dot. */
+            e = f->edges[j];
+            
+            current_face2--;
+            if (current_face2 == -1)
+                current_face2 = d->order - 1;
+            d->edges[current_face2] = e; /* set edge */
+
+            /* set face */
+            if (current_face2 == current_face1)
+                break;
+            d->faces[current_face2] =
+                    (e->face1 == f) ? e->face2 : e->face1;
+            /* There's only 1 infinite face, so we must get all the way
+             * to current_face1 before we hit it. */
+            assert(d->faces[current_face2]);
+        }
+    }
+
+    /* ====== Stage 4 ======
+     * Compute other grid settings
+     */
+
+    /* Bounding rectangle */
+    for (i = 0; i < g->num_dots; i++) {
+        grid_dot *d = g->dots + i;
+        if (i == 0) {
+            g->lowest_x = g->highest_x = d->x;
+            g->lowest_y = g->highest_y = d->y;
+        } else {
+            g->lowest_x = min(g->lowest_x, d->x);
+            g->highest_x = max(g->highest_x, d->x);
+            g->lowest_y = min(g->lowest_y, d->y);
+            g->highest_y = max(g->highest_y, d->y);
+        }
+    }
+
+    grid_debug_derived(g);
+}
+
+/* Helpers for making grid-generation easier.  These functions are only
+ * intended for use during grid generation. */
+
+/* Comparison function for the (tree234) sorted dot list */
+static int grid_point_cmp_fn(void *v1, void *v2)
+{
+    grid_dot *p1 = v1;
+    grid_dot *p2 = v2;
+    if (p1->y != p2->y)
+        return p2->y - p1->y;
+    else
+        return p2->x - p1->x;
+}
+/* Add a new face to the grid, with its dot list allocated.
+ * Assumes there's enough space allocated for the new face in grid->faces */
+static void grid_face_add_new(grid *g, int face_size)
+{
+    int i;
+    grid_face *new_face = g->faces + g->num_faces;
+    new_face->order = face_size;
+    new_face->dots = snewn(face_size, grid_dot*);
+    for (i = 0; i < face_size; i++)
+        new_face->dots[i] = NULL;
+    new_face->edges = NULL;
+    new_face->has_incentre = FALSE;
+    g->num_faces++;
+}
+/* Assumes dot list has enough space */
+static grid_dot *grid_dot_add_new(grid *g, int x, int y)
+{
+    grid_dot *new_dot = g->dots + g->num_dots;
+    new_dot->order = 0;
+    new_dot->edges = NULL;
+    new_dot->faces = NULL;
+    new_dot->x = x;
+    new_dot->y = y;
+    g->num_dots++;
+    return new_dot;
+}
+/* Retrieve a dot with these (x,y) coordinates.  Either return an existing dot
+ * in the dot_list, or add a new dot to the grid (and the dot_list) and
+ * return that.
+ * Assumes g->dots has enough capacity allocated */
+static grid_dot *grid_get_dot(grid *g, tree234 *dot_list, int x, int y)
+{
+    grid_dot test, *ret;
+
+    test.order = 0;
+    test.edges = NULL;
+    test.faces = NULL;
+    test.x = x;
+    test.y = y;
+    ret = find234(dot_list, &test, NULL);
+    if (ret)
+        return ret;
+
+    ret = grid_dot_add_new(g, x, y);
+    add234(dot_list, ret);
+    return ret;
+}
+
+/* Sets the last face of the grid to include this dot, at this position
+ * around the face. Assumes num_faces is at least 1 (a new face has
+ * previously been added, with the required number of dots allocated) */
+static void grid_face_set_dot(grid *g, grid_dot *d, int position)
+{
+    grid_face *last_face = g->faces + g->num_faces - 1;
+    last_face->dots[position] = d;
+}
+
+/*
+ * Helper routines for grid_find_incentre.
+ */
+static int solve_2x2_matrix(double mx[4], double vin[2], double vout[2])
+{
+    double inv[4];
+    double det;
+    det = (mx[0]*mx[3] - mx[1]*mx[2]);
+    if (det == 0)
+        return FALSE;
+
+    inv[0] = mx[3] / det;
+    inv[1] = -mx[1] / det;
+    inv[2] = -mx[2] / det;
+    inv[3] = mx[0] / det;
+
+    vout[0] = inv[0]*vin[0] + inv[1]*vin[1];
+    vout[1] = inv[2]*vin[0] + inv[3]*vin[1];
+
+    return TRUE;
+}
+static int solve_3x3_matrix(double mx[9], double vin[3], double vout[3])
+{
+    double inv[9];
+    double det;
+
+    det = (mx[0]*mx[4]*mx[8] + mx[1]*mx[5]*mx[6] + mx[2]*mx[3]*mx[7] -
+           mx[0]*mx[5]*mx[7] - mx[1]*mx[3]*mx[8] - mx[2]*mx[4]*mx[6]);
+    if (det == 0)
+        return FALSE;
+
+    inv[0] = (mx[4]*mx[8] - mx[5]*mx[7]) / det;
+    inv[1] = (mx[2]*mx[7] - mx[1]*mx[8]) / det;
+    inv[2] = (mx[1]*mx[5] - mx[2]*mx[4]) / det;
+    inv[3] = (mx[5]*mx[6] - mx[3]*mx[8]) / det;
+    inv[4] = (mx[0]*mx[8] - mx[2]*mx[6]) / det;
+    inv[5] = (mx[2]*mx[3] - mx[0]*mx[5]) / det;
+    inv[6] = (mx[3]*mx[7] - mx[4]*mx[6]) / det;
+    inv[7] = (mx[1]*mx[6] - mx[0]*mx[7]) / det;
+    inv[8] = (mx[0]*mx[4] - mx[1]*mx[3]) / det;
+
+    vout[0] = inv[0]*vin[0] + inv[1]*vin[1] + inv[2]*vin[2];
+    vout[1] = inv[3]*vin[0] + inv[4]*vin[1] + inv[5]*vin[2];
+    vout[2] = inv[6]*vin[0] + inv[7]*vin[1] + inv[8]*vin[2];
+
+    return TRUE;
+}
+
+void grid_find_incentre(grid_face *f)
+{
+    double xbest, ybest, bestdist;
+    int i, j, k, m;
+    grid_dot *edgedot1[3], *edgedot2[3];
+    grid_dot *dots[3];
+    int nedges, ndots;
+
+    if (f->has_incentre)
+        return;
+
+    /*
+     * Find the point in the polygon with the maximum distance to any
+     * edge or corner.
+     *
+     * Such a point must exist which is in contact with at least three
+     * edges and/or vertices. (Proof: if it's only in contact with two
+     * edges and/or vertices, it can't even be at a _local_ maximum -
+     * any such circle can always be expanded in some direction.) So
+     * we iterate through all 3-subsets of the combined set of edges
+     * and vertices; for each subset we generate one or two candidate
+     * points that might be the incentre, and then we vet each one to
+     * see if it's inside the polygon and what its maximum radius is.
+     *
+     * (There's one case which this algorithm will get noticeably
+     * wrong, and that's when a continuum of equally good answers
+     * exists due to parallel edges. Consider a long thin rectangle,
+     * for instance, or a parallelogram. This algorithm will pick a
+     * point near one end, and choose the end arbitrarily; obviously a
+     * nicer point to choose would be in the centre. To fix this I
+     * would have to introduce a special-case system which detected
+     * parallel edges in advance, set aside all candidate points
+     * generated using both edges in a parallel pair, and generated
+     * some additional candidate points half way between them. Also,
+     * of course, I'd have to cope with rounding error making such a
+     * point look worse than one of its endpoints. So I haven't done
+     * this for the moment, and will cross it if necessary when I come
+     * to it.)
+     *
+     * We don't actually iterate literally over _edges_, in the sense
+     * of grid_edge structures. Instead, we fill in edgedot1[] and
+     * edgedot2[] with a pair of dots adjacent in the face's list of
+     * vertices. This ensures that we get the edges in consistent
+     * orientation, which we could not do from the grid structure
+     * alone. (A moment's consideration of an order-3 vertex should
+     * make it clear that if a notional arrow was written on each
+     * edge, _at least one_ of the three faces bordering that vertex
+     * would have to have the two arrows tip-to-tip or tail-to-tail
+     * rather than tip-to-tail.)
+     */
+    nedges = ndots = 0;
+    bestdist = 0;
+    xbest = ybest = 0;
+
+    for (i = 0; i+2 < 2*f->order; i++) {
+        if (i < f->order) {
+            edgedot1[nedges] = f->dots[i];
+            edgedot2[nedges++] = f->dots[(i+1)%f->order];
+        } else
+            dots[ndots++] = f->dots[i - f->order];
+
+        for (j = i+1; j+1 < 2*f->order; j++) {
+            if (j < f->order) {
+                edgedot1[nedges] = f->dots[j];
+                edgedot2[nedges++] = f->dots[(j+1)%f->order];
+            } else
+                dots[ndots++] = f->dots[j - f->order];
+
+            for (k = j+1; k < 2*f->order; k++) {
+                double cx[2], cy[2];   /* candidate positions */
+                int cn = 0;            /* number of candidates */
+
+                if (k < f->order) {
+                    edgedot1[nedges] = f->dots[k];
+                    edgedot2[nedges++] = f->dots[(k+1)%f->order];
+                } else
+                    dots[ndots++] = f->dots[k - f->order];
+
+                /*
+                 * Find a point, or pair of points, equidistant from
+                 * all the specified edges and/or vertices.
+                 */
+                if (nedges == 3) {
+                    /*
+                     * Three edges. This is a linear matrix equation:
+                     * each row of the matrix represents the fact that
+                     * the point (x,y) we seek is at distance r from
+                     * that edge, and we solve three of those
+                     * simultaneously to obtain x,y,r. (We ignore r.)
+                     */
+                    double matrix[9], vector[3], vector2[3];
+                    int m;
+
+                    for (m = 0; m < 3; m++) {
+                        int x1 = edgedot1[m]->x, x2 = edgedot2[m]->x;
+                        int y1 = edgedot1[m]->y, y2 = edgedot2[m]->y;
+                        int dx = x2-x1, dy = y2-y1;
+
+                        /*
+                         * ((x,y) - (x1,y1)) . (dy,-dx) = r |(dx,dy)|
+                         *
+                         * => x dy - y dx - r |(dx,dy)| = (x1 dy - y1 dx)
+                         */
+                        matrix[3*m+0] = dy;
+                        matrix[3*m+1] = -dx;
+                        matrix[3*m+2] = -sqrt((double)dx*dx+(double)dy*dy);
+                        vector[m] = (double)x1*dy - (double)y1*dx;
+                    }
+
+                    if (solve_3x3_matrix(matrix, vector, vector2)) {
+                        cx[cn] = vector2[0];
+                        cy[cn] = vector2[1];
+                        cn++;
+                    }
+                } else if (nedges == 2) {
+                    /*
+                     * Two edges and a dot. This will end up in a
+                     * quadratic equation.
+                     *
+                     * First, look at the two edges. Having our point
+                     * be some distance r from both of them gives rise
+                     * to a pair of linear equations in x,y,r of the
+                     * form
+                     *
+                     *   (x-x1) dy - (y-y1) dx = r sqrt(dx^2+dy^2)
+                     *
+                     * We eliminate r between those equations to give
+                     * us a single linear equation in x,y describing
+                     * the locus of points equidistant from both lines
+                     * - i.e. the angle bisector. 
+                     *
+                     * We then choose one of x,y to be a parameter t,
+                     * and derive linear formulae for x,y,r in terms
+                     * of t. This enables us to write down the
+                     * circular equation (x-xd)^2+(y-yd)^2=r^2 as a
+                     * quadratic in t; solving that and substituting
+                     * in for x,y gives us two candidate points.
+                     */
+                    double eqs[2][4];  /* a,b,c,d : ax+by+cr=d */
+                    double eq[3];      /* a,b,c: ax+by=c */
+                    double xt[2], yt[2], rt[2]; /* a,b: {x,y,r}=at+b */
+                    double q[3];                /* a,b,c: at^2+bt+c=0 */
+                    double disc;
+
+                    /* Find equations of the two input lines. */
+                    for (m = 0; m < 2; m++) {
+                        int x1 = edgedot1[m]->x, x2 = edgedot2[m]->x;
+                        int y1 = edgedot1[m]->y, y2 = edgedot2[m]->y;
+                        int dx = x2-x1, dy = y2-y1;
+
+                        eqs[m][0] = dy;
+                        eqs[m][1] = -dx;
+                        eqs[m][2] = -sqrt(dx*dx+dy*dy);
+                        eqs[m][3] = x1*dy - y1*dx;
+                    }
+
+                    /* Derive the angle bisector by eliminating r. */
+                    eq[0] = eqs[0][0]*eqs[1][2] - eqs[1][0]*eqs[0][2];
+                    eq[1] = eqs[0][1]*eqs[1][2] - eqs[1][1]*eqs[0][2];
+                    eq[2] = eqs[0][3]*eqs[1][2] - eqs[1][3]*eqs[0][2];
+
+                    /* Parametrise x and y in terms of some t. */
+                    if (fabs(eq[0]) < fabs(eq[1])) {
+                        /* Parameter is x. */
+                        xt[0] = 1; xt[1] = 0;
+                        yt[0] = -eq[0]/eq[1]; yt[1] = eq[2]/eq[1];
+                    } else {
+                        /* Parameter is y. */
+                        yt[0] = 1; yt[1] = 0;
+                        xt[0] = -eq[1]/eq[0]; xt[1] = eq[2]/eq[0];
+                    }
+
+                    /* Find a linear representation of r using eqs[0]. */
+                    rt[0] = -(eqs[0][0]*xt[0] + eqs[0][1]*yt[0])/eqs[0][2];
+                    rt[1] = (eqs[0][3] - eqs[0][0]*xt[1] -
+                             eqs[0][1]*yt[1])/eqs[0][2];
+
+                    /* Construct the quadratic equation. */
+                    q[0] = -rt[0]*rt[0];
+                    q[1] = -2*rt[0]*rt[1];
+                    q[2] = -rt[1]*rt[1];
+                    q[0] += xt[0]*xt[0];
+                    q[1] += 2*xt[0]*(xt[1]-dots[0]->x);
+                    q[2] += (xt[1]-dots[0]->x)*(xt[1]-dots[0]->x);
+                    q[0] += yt[0]*yt[0];
+                    q[1] += 2*yt[0]*(yt[1]-dots[0]->y);
+                    q[2] += (yt[1]-dots[0]->y)*(yt[1]-dots[0]->y);
+
+                    /* And solve it. */
+                    disc = q[1]*q[1] - 4*q[0]*q[2];
+                    if (disc >= 0) {
+                        double t;
+
+                        disc = sqrt(disc);
+
+                        t = (-q[1] + disc) / (2*q[0]);
+                        cx[cn] = xt[0]*t + xt[1];
+                        cy[cn] = yt[0]*t + yt[1];
+                        cn++;
+
+                        t = (-q[1] - disc) / (2*q[0]);
+                        cx[cn] = xt[0]*t + xt[1];
+                        cy[cn] = yt[0]*t + yt[1];
+                        cn++;
+                    }
+                } else if (nedges == 1) {
+                    /*
+                     * Two dots and an edge. This one's another
+                     * quadratic equation.
+                     *
+                     * The point we want must lie on the perpendicular
+                     * bisector of the two dots; that much is obvious.
+                     * So we can construct a parametrisation of that
+                     * bisecting line, giving linear formulae for x,y
+                     * in terms of t. We can also express the distance
+                     * from the edge as such a linear formula.
+                     *
+                     * Then we set that equal to the radius of the
+                     * circle passing through the two points, which is
+                     * a Pythagoras exercise; that gives rise to a
+                     * quadratic in t, which we solve.
+                     */
+                    double xt[2], yt[2], rt[2]; /* a,b: {x,y,r}=at+b */
+                    double q[3];                /* a,b,c: at^2+bt+c=0 */
+                    double disc;
+                    double halfsep;
+
+                    /* Find parametric formulae for x,y. */
+                    {
+                        int x1 = dots[0]->x, x2 = dots[1]->x;
+                        int y1 = dots[0]->y, y2 = dots[1]->y;
+                        int dx = x2-x1, dy = y2-y1;
+                        double d = sqrt((double)dx*dx + (double)dy*dy);
+
+                        xt[1] = (x1+x2)/2.0;
+                        yt[1] = (y1+y2)/2.0;
+                        /* It's convenient if we have t at standard scale. */
+                        xt[0] = -dy/d;
+                        yt[0] = dx/d;
+
+                        /* Also note down half the separation between
+                         * the dots, for use in computing the circle radius. */
+                        halfsep = 0.5*d;
+                    }
+
+                    /* Find a parametric formula for r. */
+                    {
+                        int x1 = edgedot1[0]->x, x2 = edgedot2[0]->x;
+                        int y1 = edgedot1[0]->y, y2 = edgedot2[0]->y;
+                        int dx = x2-x1, dy = y2-y1;
+                        double d = sqrt((double)dx*dx + (double)dy*dy);
+                        rt[0] = (xt[0]*dy - yt[0]*dx) / d;
+                        rt[1] = ((xt[1]-x1)*dy - (yt[1]-y1)*dx) / d;
+                    }
+
+                    /* Construct the quadratic equation. */
+                    q[0] = rt[0]*rt[0];
+                    q[1] = 2*rt[0]*rt[1];
+                    q[2] = rt[1]*rt[1];
+                    q[0] -= 1;
+                    q[2] -= halfsep*halfsep;
+
+                    /* And solve it. */
+                    disc = q[1]*q[1] - 4*q[0]*q[2];
+                    if (disc >= 0) {
+                        double t;
+
+                        disc = sqrt(disc);
+
+                        t = (-q[1] + disc) / (2*q[0]);
+                        cx[cn] = xt[0]*t + xt[1];
+                        cy[cn] = yt[0]*t + yt[1];
+                        cn++;
+
+                        t = (-q[1] - disc) / (2*q[0]);
+                        cx[cn] = xt[0]*t + xt[1];
+                        cy[cn] = yt[0]*t + yt[1];
+                        cn++;
+                    }
+                } else if (nedges == 0) {
+                    /*
+                     * Three dots. This is another linear matrix
+                     * equation, this time with each row of the matrix
+                     * representing the perpendicular bisector between
+                     * two of the points. Of course we only need two
+                     * such lines to find their intersection, so we
+                     * need only solve a 2x2 matrix equation.
+                     */
+
+                    double matrix[4], vector[2], vector2[2];
+                    int m;
+
+                    for (m = 0; m < 2; m++) {
+                        int x1 = dots[m]->x, x2 = dots[m+1]->x;
+                        int y1 = dots[m]->y, y2 = dots[m+1]->y;
+                        int dx = x2-x1, dy = y2-y1;
+
+                        /*
+                         * ((x,y) - (x1,y1)) . (dx,dy) = 1/2 |(dx,dy)|^2
+                         *
+                         * => 2x dx + 2y dy = dx^2+dy^2 + (2 x1 dx + 2 y1 dy)
+                         */
+                        matrix[2*m+0] = 2*dx;
+                        matrix[2*m+1] = 2*dy;
+                        vector[m] = ((double)dx*dx + (double)dy*dy +
+                                     2.0*x1*dx + 2.0*y1*dy);
+                    }
+
+                    if (solve_2x2_matrix(matrix, vector, vector2)) {
+                        cx[cn] = vector2[0];
+                        cy[cn] = vector2[1];
+                        cn++;
+                    }
+                }
+
+                /*
+                 * Now go through our candidate points and see if any
+                 * of them are better than what we've got so far.
+                 */
+                for (m = 0; m < cn; m++) {
+                    double x = cx[m], y = cy[m];
+
+                    /*
+                     * First, disqualify the point if it's not inside
+                     * the polygon, which we work out by counting the
+                     * edges to the right of the point. (For
+                     * tiebreaking purposes when edges start or end on
+                     * our y-coordinate or go right through it, we
+                     * consider our point to be offset by a small
+                     * _positive_ epsilon in both the x- and
+                     * y-direction.)
+                     */
+                    int e, in = 0;
+                    for (e = 0; e < f->order; e++) {
+                        int xs = f->edges[e]->dot1->x;
+                        int xe = f->edges[e]->dot2->x;
+                        int ys = f->edges[e]->dot1->y;
+                        int ye = f->edges[e]->dot2->y;
+                        if ((y >= ys && y < ye) || (y >= ye && y < ys)) {
+                            /*
+                             * The line goes past our y-position. Now we need
+                             * to know if its x-coordinate when it does so is
+                             * to our right.
+                             *
+                             * The x-coordinate in question is mathematically
+                             * (y - ys) * (xe - xs) / (ye - ys), and we want
+                             * to know whether (x - xs) >= that. Of course we
+                             * avoid the division, so we can work in integers;
+                             * to do this we must multiply both sides of the
+                             * inequality by ye - ys, which means we must
+                             * first check that's not negative.
+                             */
+                            int num = xe - xs, denom = ye - ys;
+                            if (denom < 0) {
+                                num = -num;
+                                denom = -denom;
+                            }
+                            if ((x - xs) * denom >= (y - ys) * num)
+                                in ^= 1;
+                        }
+                    }
+
+                    if (in) {
+#ifdef HUGE_VAL
+                        double mindist = HUGE_VAL;
+#else
+#ifdef DBL_MAX
+                        double mindist = DBL_MAX;
+#else
+#error No way to get maximum floating-point number.
+#endif
+#endif
+                        int e, d;
+
+                        /*
+                         * This point is inside the polygon, so now we check
+                         * its minimum distance to every edge and corner.
+                         * First the corners ...
+                         */
+                        for (d = 0; d < f->order; d++) {
+                            int xp = f->dots[d]->x;
+                            int yp = f->dots[d]->y;
+                            double dx = x - xp, dy = y - yp;
+                            double dist = dx*dx + dy*dy;
+                            if (mindist > dist)
+                                mindist = dist;
+                        }
+
+                        /*
+                         * ... and now also check the perpendicular distance
+                         * to every edge, if the perpendicular lies between
+                         * the edge's endpoints.
+                         */
+                        for (e = 0; e < f->order; e++) {
+                            int xs = f->edges[e]->dot1->x;
+                            int xe = f->edges[e]->dot2->x;
+                            int ys = f->edges[e]->dot1->y;
+                            int ye = f->edges[e]->dot2->y;
+
+                            /*
+                             * If s and e are our endpoints, and p our
+                             * candidate circle centre, the foot of a
+                             * perpendicular from p to the line se lies
+                             * between s and e if and only if (p-s).(e-s) lies
+                             * strictly between 0 and (e-s).(e-s).
+                             */
+                            int edx = xe - xs, edy = ye - ys;
+                            double pdx = x - xs, pdy = y - ys;
+                            double pde = pdx * edx + pdy * edy;
+                            long ede = (long)edx * edx + (long)edy * edy;
+                            if (0 < pde && pde < ede) {
+                                /*
+                                 * Yes, the nearest point on this edge is
+                                 * closer than either endpoint, so we must
+                                 * take it into account by measuring the
+                                 * perpendicular distance to the edge and
+                                 * checking its square against mindist.
+                                 */
+
+                                double pdre = pdx * edy - pdy * edx;
+                                double sqlen = pdre * pdre / ede;
+
+                                if (mindist > sqlen)
+                                    mindist = sqlen;
+                            }
+                        }
+
+                        /*
+                         * Right. Now we know the biggest circle around this
+                         * point, so we can check it against bestdist.
+                         */
+                        if (bestdist < mindist) {
+                            bestdist = mindist;
+                            xbest = x;
+                            ybest = y;
+                        }
+                    }
+                }
+
+                if (k < f->order)
+                    nedges--;
+                else
+                    ndots--;
+            }
+            if (j < f->order)
+                nedges--;
+            else
+                ndots--;
+        }
+        if (i < f->order)
+            nedges--;
+        else
+            ndots--;
+    }
+
+    assert(bestdist > 0);
+
+    f->has_incentre = TRUE;
+    f->ix = xbest + 0.5;               /* round to nearest */
+    f->iy = ybest + 0.5;
+}
+
+/* ------ Generate various types of grid ------ */
+
+/* General method is to generate faces, by calculating their dot coordinates.
+ * As new faces are added, we keep track of all the dots so we can tell when
+ * a new face reuses an existing dot.  For example, two squares touching at an
+ * edge would generate six unique dots: four dots from the first face, then
+ * two additional dots for the second face, because we detect the other two
+ * dots have already been taken up.  This list is stored in a tree234
+ * called "points".  No extra memory-allocation needed here - we store the
+ * actual grid_dot* pointers, which all point into the g->dots list.
+ * For this reason, we have to calculate coordinates in such a way as to
+ * eliminate any rounding errors, so we can detect when a dot on one
+ * face precisely lands on a dot of a different face.  No floating-point
+ * arithmetic here!
+ */
+
+#define SQUARE_TILESIZE 20
+
+static void grid_size_square(int width, int height,
+                      int *tilesize, int *xextent, int *yextent)
+{
+    int a = SQUARE_TILESIZE;
+
+    *tilesize = a;
+    *xextent = width * a;
+    *yextent = height * a;
+}
+
+static grid *grid_new_square(int width, int height, const char *desc)
+{
+    int x, y;
+    /* Side length */
+    int a = SQUARE_TILESIZE;
+
+    /* Upper bounds - don't have to be exact */
+    int max_faces = width * height;
+    int max_dots = (width + 1) * (height + 1);
+
+    tree234 *points;
+
+    grid *g = grid_empty();
+    g->tilesize = a;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    /* generate square faces */
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            grid_dot *d;
+            /* face position */
+            int px = a * x;
+            int py = a * y;
+
+            grid_face_add_new(g, 4);
+            d = grid_get_dot(g, points, px, py);
+            grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px + a, py);
+            grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px + a, py + a);
+            grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px, py + a);
+            grid_face_set_dot(g, d, 3);
+        }
+    }
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    grid_make_consistent(g);
+    return g;
+}
+
+#define HONEY_TILESIZE 45
+/* Vector for side of hexagon - ratio is close to sqrt(3) */
+#define HONEY_A 15
+#define HONEY_B 26
+
+static void grid_size_honeycomb(int width, int height,
+                         int *tilesize, int *xextent, int *yextent)
+{
+    int a = HONEY_A;
+    int b = HONEY_B;
+
+    *tilesize = HONEY_TILESIZE;
+    *xextent = (3 * a * (width-1)) + 4*a;
+    *yextent = (2 * b * (height-1)) + 3*b;
+}
+
+static grid *grid_new_honeycomb(int width, int height, const char *desc)
+{
+    int x, y;
+    int a = HONEY_A;
+    int b = HONEY_B;
+
+    /* Upper bounds - don't have to be exact */
+    int max_faces = width * height;
+    int max_dots = 2 * (width + 1) * (height + 1);
+
+    tree234 *points;
+
+    grid *g = grid_empty();
+    g->tilesize = HONEY_TILESIZE;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    /* generate hexagonal faces */
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            grid_dot *d;
+            /* face centre */
+            int cx = 3 * a * x;
+            int cy = 2 * b * y;
+            if (x % 2)
+                cy += b;
+            grid_face_add_new(g, 6);
+
+            d = grid_get_dot(g, points, cx - a, cy - b);
+            grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, cx + a, cy - b);
+            grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, cx + 2*a, cy);
+            grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, cx + a, cy + b);
+            grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, cx - a, cy + b);
+            grid_face_set_dot(g, d, 4);
+            d = grid_get_dot(g, points, cx - 2*a, cy);
+            grid_face_set_dot(g, d, 5);
+        }
+    }
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    grid_make_consistent(g);
+    return g;
+}
+
+#define TRIANGLE_TILESIZE 18
+/* Vector for side of triangle - ratio is close to sqrt(3) */
+#define TRIANGLE_VEC_X 15
+#define TRIANGLE_VEC_Y 26
+
+static void grid_size_triangular(int width, int height,
+                          int *tilesize, int *xextent, int *yextent)
+{
+    int vec_x = TRIANGLE_VEC_X;
+    int vec_y = TRIANGLE_VEC_Y;
+
+    *tilesize = TRIANGLE_TILESIZE;
+    *xextent = (width+1) * 2 * vec_x;
+    *yextent = height * vec_y;
+}
+
+static char *grid_validate_desc_triangular(grid_type type, int width,
+                                           int height, const char *desc)
+{
+    /*
+     * Triangular grids: an absent description is valid (indicating
+     * the old-style approach which had 'ears', i.e. triangles
+     * connected to only one other face, at some grid corners), and so
+     * is a description reading just "0" (indicating the new-style
+     * approach in which those ears are trimmed off). Anything else is
+     * illegal.
+     */
+
+    if (!desc || !strcmp(desc, "0"))
+        return NULL;
+
+    return "Unrecognised grid description.";
+}
+
+/* Doesn't use the previous method of generation, it pre-dates it!
+ * A triangular grid is just about simple enough to do by "brute force" */
+static grid *grid_new_triangular(int width, int height, const char *desc)
+{
+    int x,y;
+    int version = (desc == NULL ? -1 : atoi(desc));
+    
+    /* Vector for side of triangle - ratio is close to sqrt(3) */
+    int vec_x = TRIANGLE_VEC_X;
+    int vec_y = TRIANGLE_VEC_Y;
+    
+    int index;
+
+    /* convenient alias */
+    int w = width + 1;
+
+    grid *g = grid_empty();
+    g->tilesize = TRIANGLE_TILESIZE;
+
+    if (version == -1) {
+        /*
+         * Old-style triangular grid generation, preserved as-is for
+         * backwards compatibility with old game ids, in which it's
+         * just a little asymmetric and there are 'ears' (faces linked
+         * to only one other face) at two grid corners.
+         *
+         * Example old-style game ids, which should still work, and in
+         * which you should see the ears in the TL/BR corners on the
+         * first one and in the TL/BL corners on the second:
+         *
+         *   5x5t1:2c2a1a2a201a1a1a1112a1a2b1211f0b21a2a2a0a
+         *   5x6t1:a022a212h1a1d1a12c2b11a012b1a20d1a0a12e
+         */
+
+        g->num_faces = width * height * 2;
+        g->num_dots = (width + 1) * (height + 1);
+        g->faces = snewn(g->num_faces, grid_face);
+        g->dots = snewn(g->num_dots, grid_dot);
+
+        /* generate dots */
+        index = 0;
+        for (y = 0; y <= height; y++) {
+            for (x = 0; x <= width; x++) {
+                grid_dot *d = g->dots + index;
+                /* odd rows are offset to the right */
+                d->order = 0;
+                d->edges = NULL;
+                d->faces = NULL;
+                d->x = x * 2 * vec_x + ((y % 2) ? vec_x : 0);
+                d->y = y * vec_y;
+                index++;
+            }
+        }
+    
+        /* generate faces */
+        index = 0;
+        for (y = 0; y < height; y++) {
+            for (x = 0; x < width; x++) {
+                /* initialise two faces for this (x,y) */
+                grid_face *f1 = g->faces + index;
+                grid_face *f2 = f1 + 1;
+                f1->edges = NULL;
+                f1->order = 3;
+                f1->dots = snewn(f1->order, grid_dot*);
+                f1->has_incentre = FALSE;
+                f2->edges = NULL;
+                f2->order = 3;
+                f2->dots = snewn(f2->order, grid_dot*);
+                f2->has_incentre = FALSE;
+
+                /* face descriptions depend on whether the row-number is
+                 * odd or even */
+                if (y % 2) {
+                    f1->dots[0] = g->dots + y       * w + x;
+                    f1->dots[1] = g->dots + (y + 1) * w + x + 1;
+                    f1->dots[2] = g->dots + (y + 1) * w + x;
+                    f2->dots[0] = g->dots + y       * w + x;
+                    f2->dots[1] = g->dots + y       * w + x + 1;
+                    f2->dots[2] = g->dots + (y + 1) * w + x + 1;
+                } else {
+                    f1->dots[0] = g->dots + y       * w + x;
+                    f1->dots[1] = g->dots + y       * w + x + 1;
+                    f1->dots[2] = g->dots + (y + 1) * w + x;
+                    f2->dots[0] = g->dots + y       * w + x + 1;
+                    f2->dots[1] = g->dots + (y + 1) * w + x + 1;
+                    f2->dots[2] = g->dots + (y + 1) * w + x;
+                }
+                index += 2;
+            }
+        }
+    } else {
+        /*
+         * New-style approach, in which there are never any 'ears',
+         * and if height is even then the grid is nicely 4-way
+         * symmetric.
+         *
+         * Example new-style grids:
+         *
+         *   5x5t1:0_21120b11a1a01a1a00c1a0b211021c1h1a2a1a0a
+         *   5x6t1:0_a1212c22c2a02a2f22a0c12a110d0e1c0c0a101121a1
+         */
+        tree234 *points = newtree234(grid_point_cmp_fn);
+        /* Upper bounds - don't have to be exact */
+        int max_faces = height * (2*width+1);
+        int max_dots = (height+1) * (width+1) * 4;
+
+        g->faces = snewn(max_faces, grid_face);
+        g->dots = snewn(max_dots, grid_dot);
+
+        for (y = 0; y < height; y++) {
+            /*
+             * Each row contains (width+1) triangles one way up, and
+             * (width) triangles the other way up. Which way up is
+             * which varies with parity of y. Also, the dots around
+             * each face will flip direction with parity of y, so we
+             * set up n1 and n2 to cope with that easily.
+             */
+            int y0, y1, n1, n2;
+            y0 = y1 = y * vec_y;
+            if (y % 2) {
+                y1 += vec_y;
+                n1 = 2; n2 = 1;
+            } else {
+                y0 += vec_y;
+                n1 = 1; n2 = 2;
+            }
+
+            for (x = 0; x <= width; x++) {
+                int x0 = 2*x * vec_x, x1 = x0 + vec_x, x2 = x1 + vec_x;
+
+                /*
+                 * If the grid has odd height, then we skip the first
+                 * and last triangles on this row, otherwise they'll
+                 * end up as ears.
+                 */
+                if (height % 2 == 1 && y == height-1 && (x == 0 || x == width))
+                    continue;
+
+                grid_face_add_new(g, 3);
+                grid_face_set_dot(g, grid_get_dot(g, points, x0, y0), 0);
+                grid_face_set_dot(g, grid_get_dot(g, points, x1, y1), n1);
+                grid_face_set_dot(g, grid_get_dot(g, points, x2, y0), n2);
+            }
+
+            for (x = 0; x < width; x++) {
+                int x0 = (2*x+1) * vec_x, x1 = x0 + vec_x, x2 = x1 + vec_x;
+
+                grid_face_add_new(g, 3);
+                grid_face_set_dot(g, grid_get_dot(g, points, x0, y1), 0);
+                grid_face_set_dot(g, grid_get_dot(g, points, x1, y0), n2);
+                grid_face_set_dot(g, grid_get_dot(g, points, x2, y1), n1);
+            }
+        }
+
+        freetree234(points);
+        assert(g->num_faces <= max_faces);
+        assert(g->num_dots <= max_dots);
+    }
+
+    grid_make_consistent(g);
+    return g;
+}
+
+#define SNUBSQUARE_TILESIZE 18
+/* Vector for side of triangle - ratio is close to sqrt(3) */
+#define SNUBSQUARE_A 15
+#define SNUBSQUARE_B 26
+
+static void grid_size_snubsquare(int width, int height,
+                          int *tilesize, int *xextent, int *yextent)
+{
+    int a = SNUBSQUARE_A;
+    int b = SNUBSQUARE_B;
+
+    *tilesize = SNUBSQUARE_TILESIZE;
+    *xextent = (a+b) * (width-1) + a + b;
+    *yextent = (a+b) * (height-1) + a + b;
+}
+
+static grid *grid_new_snubsquare(int width, int height, const char *desc)
+{
+    int x, y;
+    int a = SNUBSQUARE_A;
+    int b = SNUBSQUARE_B;
+
+    /* Upper bounds - don't have to be exact */
+    int max_faces = 3 * width * height;
+    int max_dots = 2 * (width + 1) * (height + 1);
+
+    tree234 *points;
+
+    grid *g = grid_empty();
+    g->tilesize = SNUBSQUARE_TILESIZE;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            grid_dot *d;
+            /* face position */
+            int px = (a + b) * x;
+            int py = (a + b) * y;
+
+            /* generate square faces */
+            grid_face_add_new(g, 4);
+            if ((x + y) % 2) {
+                d = grid_get_dot(g, points, px + a, py);
+                grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px + a + b, py + a);
+                grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px + b, py + a + b);
+                grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px, py + b);
+                grid_face_set_dot(g, d, 3);
+            } else {
+                d = grid_get_dot(g, points, px + b, py);
+                grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px + a + b, py + b);
+                grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px + a, py + a + b);
+                grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px, py + a);
+                grid_face_set_dot(g, d, 3);
+            }
+
+            /* generate up/down triangles */
+            if (x > 0) {
+                grid_face_add_new(g, 3);
+                if ((x + y) % 2) {
+                    d = grid_get_dot(g, points, px + a, py);
+                    grid_face_set_dot(g, d, 0);
+                    d = grid_get_dot(g, points, px, py + b);
+                    grid_face_set_dot(g, d, 1);
+                    d = grid_get_dot(g, points, px - a, py);
+                    grid_face_set_dot(g, d, 2);
+                } else {
+                    d = grid_get_dot(g, points, px, py + a);
+                    grid_face_set_dot(g, d, 0);
+                    d = grid_get_dot(g, points, px + a, py + a + b);
+                    grid_face_set_dot(g, d, 1);
+                    d = grid_get_dot(g, points, px - a, py + a + b);
+                    grid_face_set_dot(g, d, 2);
+                }
+            }
+
+            /* generate left/right triangles */
+            if (y > 0) {
+                grid_face_add_new(g, 3);
+                if ((x + y) % 2) {
+                    d = grid_get_dot(g, points, px + a, py);
+                    grid_face_set_dot(g, d, 0);
+                    d = grid_get_dot(g, points, px + a + b, py - a);
+                    grid_face_set_dot(g, d, 1);
+                    d = grid_get_dot(g, points, px + a + b, py + a);
+                    grid_face_set_dot(g, d, 2);
+                } else {
+                    d = grid_get_dot(g, points, px, py - a);
+                    grid_face_set_dot(g, d, 0);
+                    d = grid_get_dot(g, points, px + b, py);
+                    grid_face_set_dot(g, d, 1);
+                    d = grid_get_dot(g, points, px, py + a);
+                    grid_face_set_dot(g, d, 2);
+                }
+            }
+        }
+    }
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    grid_make_consistent(g);
+    return g;
+}
+
+#define CAIRO_TILESIZE 40
+/* Vector for side of pentagon - ratio is close to (4+sqrt(7))/3 */
+#define CAIRO_A 14
+#define CAIRO_B 31
+
+static void grid_size_cairo(int width, int height,
+                          int *tilesize, int *xextent, int *yextent)
+{
+    int b = CAIRO_B; /* a unused in determining grid size. */
+
+    *tilesize = CAIRO_TILESIZE;
+    *xextent = 2*b*(width-1) + 2*b;
+    *yextent = 2*b*(height-1) + 2*b;
+}
+
+static grid *grid_new_cairo(int width, int height, const char *desc)
+{
+    int x, y;
+    int a = CAIRO_A;
+    int b = CAIRO_B;
+
+    /* Upper bounds - don't have to be exact */
+    int max_faces = 2 * width * height;
+    int max_dots = 3 * (width + 1) * (height + 1);
+
+    tree234 *points;
+
+    grid *g = grid_empty();
+    g->tilesize = CAIRO_TILESIZE;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            grid_dot *d;
+            /* cell position */
+            int px = 2 * b * x;
+            int py = 2 * b * y;
+
+            /* horizontal pentagons */
+            if (y > 0) {
+                grid_face_add_new(g, 5);
+                if ((x + y) % 2) {
+                    d = grid_get_dot(g, points, px + a, py - b);
+                    grid_face_set_dot(g, d, 0);
+                    d = grid_get_dot(g, points, px + 2*b - a, py - b);
+                    grid_face_set_dot(g, d, 1);
+                    d = grid_get_dot(g, points, px + 2*b, py);
+                    grid_face_set_dot(g, d, 2);
+                    d = grid_get_dot(g, points, px + b, py + a);
+                    grid_face_set_dot(g, d, 3);
+                    d = grid_get_dot(g, points, px, py);
+                    grid_face_set_dot(g, d, 4);
+                } else {
+                    d = grid_get_dot(g, points, px, py);
+                    grid_face_set_dot(g, d, 0);
+                    d = grid_get_dot(g, points, px + b, py - a);
+                    grid_face_set_dot(g, d, 1);
+                    d = grid_get_dot(g, points, px + 2*b, py);
+                    grid_face_set_dot(g, d, 2);
+                    d = grid_get_dot(g, points, px + 2*b - a, py + b);
+                    grid_face_set_dot(g, d, 3);
+                    d = grid_get_dot(g, points, px + a, py + b);
+                    grid_face_set_dot(g, d, 4);
+                }
+            }
+            /* vertical pentagons */
+            if (x > 0) {
+                grid_face_add_new(g, 5);
+                if ((x + y) % 2) {
+                    d = grid_get_dot(g, points, px, py);
+                    grid_face_set_dot(g, d, 0);
+                    d = grid_get_dot(g, points, px + b, py + a);
+                    grid_face_set_dot(g, d, 1);
+                    d = grid_get_dot(g, points, px + b, py + 2*b - a);
+                    grid_face_set_dot(g, d, 2);
+                    d = grid_get_dot(g, points, px, py + 2*b);
+                    grid_face_set_dot(g, d, 3);
+                    d = grid_get_dot(g, points, px - a, py + b);
+                    grid_face_set_dot(g, d, 4);
+                } else {
+                    d = grid_get_dot(g, points, px, py);
+                    grid_face_set_dot(g, d, 0);
+                    d = grid_get_dot(g, points, px + a, py + b);
+                    grid_face_set_dot(g, d, 1);
+                    d = grid_get_dot(g, points, px, py + 2*b);
+                    grid_face_set_dot(g, d, 2);
+                    d = grid_get_dot(g, points, px - b, py + 2*b - a);
+                    grid_face_set_dot(g, d, 3);
+                    d = grid_get_dot(g, points, px - b, py + a);
+                    grid_face_set_dot(g, d, 4);
+                }
+            }
+        }
+    }
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    grid_make_consistent(g);
+    return g;
+}
+
+#define GREATHEX_TILESIZE 18
+/* Vector for side of triangle - ratio is close to sqrt(3) */
+#define GREATHEX_A 15
+#define GREATHEX_B 26
+
+static void grid_size_greathexagonal(int width, int height,
+                          int *tilesize, int *xextent, int *yextent)
+{
+    int a = GREATHEX_A;
+    int b = GREATHEX_B;
+
+    *tilesize = GREATHEX_TILESIZE;
+    *xextent = (3*a + b) * (width-1) + 4*a;
+    *yextent = (2*a + 2*b) * (height-1) + 3*b + a;
+}
+
+static grid *grid_new_greathexagonal(int width, int height, const char *desc)
+{
+    int x, y;
+    int a = GREATHEX_A;
+    int b = GREATHEX_B;
+
+    /* Upper bounds - don't have to be exact */
+    int max_faces = 6 * (width + 1) * (height + 1);
+    int max_dots = 6 * width * height;
+
+    tree234 *points;
+
+    grid *g = grid_empty();
+    g->tilesize = GREATHEX_TILESIZE;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            grid_dot *d;
+            /* centre of hexagon */
+            int px = (3*a + b) * x;
+            int py = (2*a + 2*b) * y;
+            if (x % 2)
+                py += a + b;
+
+            /* hexagon */
+            grid_face_add_new(g, 6);
+            d = grid_get_dot(g, points, px - a, py - b);
+            grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px + a, py - b);
+            grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px + 2*a, py);
+            grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px + a, py + b);
+            grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, px - a, py + b);
+            grid_face_set_dot(g, d, 4);
+            d = grid_get_dot(g, points, px - 2*a, py);
+            grid_face_set_dot(g, d, 5);
+
+            /* square below hexagon */
+            if (y < height - 1) {
+                grid_face_add_new(g, 4);
+                d = grid_get_dot(g, points, px - a, py + b);
+                grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px + a, py + b);
+                grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px + a, py + 2*a + b);
+                grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px - a, py + 2*a + b);
+                grid_face_set_dot(g, d, 3);
+            }
+
+            /* square below right */
+            if ((x < width - 1) && (((x % 2) == 0) || (y < height - 1))) {
+                grid_face_add_new(g, 4);
+                d = grid_get_dot(g, points, px + 2*a, py);
+                grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px + 2*a + b, py + a);
+                grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px + a + b, py + a + b);
+                grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px + a, py + b);
+                grid_face_set_dot(g, d, 3);
+            }
+
+            /* square below left */
+            if ((x > 0) && (((x % 2) == 0) || (y < height - 1))) {
+                grid_face_add_new(g, 4);
+                d = grid_get_dot(g, points, px - 2*a, py);
+                grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px - a, py + b);
+                grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px - a - b, py + a + b);
+                grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px - 2*a - b, py + a);
+                grid_face_set_dot(g, d, 3);
+            }
+           
+            /* Triangle below right */
+            if ((x < width - 1) && (y < height - 1)) {
+                grid_face_add_new(g, 3);
+                d = grid_get_dot(g, points, px + a, py + b);
+                grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px + a + b, py + a + b);
+                grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px + a, py + 2*a + b);
+                grid_face_set_dot(g, d, 2);
+            }
+
+            /* Triangle below left */
+            if ((x > 0) && (y < height - 1)) {
+                grid_face_add_new(g, 3);
+                d = grid_get_dot(g, points, px - a, py + b);
+                grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px - a, py + 2*a + b);
+                grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px - a - b, py + a + b);
+                grid_face_set_dot(g, d, 2);
+            }
+        }
+    }
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    grid_make_consistent(g);
+    return g;
+}
+
+#define OCTAGONAL_TILESIZE 40
+/* b/a approx sqrt(2) */
+#define OCTAGONAL_A 29
+#define OCTAGONAL_B 41
+
+static void grid_size_octagonal(int width, int height,
+                          int *tilesize, int *xextent, int *yextent)
+{
+    int a = OCTAGONAL_A;
+    int b = OCTAGONAL_B;
+
+    *tilesize = OCTAGONAL_TILESIZE;
+    *xextent = (2*a + b) * width;
+    *yextent = (2*a + b) * height;
+}
+
+static grid *grid_new_octagonal(int width, int height, const char *desc)
+{
+    int x, y;
+    int a = OCTAGONAL_A;
+    int b = OCTAGONAL_B;
+
+    /* Upper bounds - don't have to be exact */
+    int max_faces = 2 * width * height;
+    int max_dots = 4 * (width + 1) * (height + 1);
+
+    tree234 *points;
+
+    grid *g = grid_empty();
+    g->tilesize = OCTAGONAL_TILESIZE;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            grid_dot *d;
+            /* cell position */
+            int px = (2*a + b) * x;
+            int py = (2*a + b) * y;
+            /* octagon */
+            grid_face_add_new(g, 8);
+            d = grid_get_dot(g, points, px + a, py);
+            grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px + a + b, py);
+            grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px + 2*a + b, py + a);
+            grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px + 2*a + b, py + a + b);
+            grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, px + a + b, py + 2*a + b);
+            grid_face_set_dot(g, d, 4);
+            d = grid_get_dot(g, points, px + a, py + 2*a + b);
+            grid_face_set_dot(g, d, 5);
+            d = grid_get_dot(g, points, px, py + a + b);
+            grid_face_set_dot(g, d, 6);
+            d = grid_get_dot(g, points, px, py + a);
+            grid_face_set_dot(g, d, 7);
+
+            /* diamond */
+            if ((x > 0) && (y > 0)) {
+                grid_face_add_new(g, 4);
+                d = grid_get_dot(g, points, px, py - a);
+                grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px + a, py);
+                grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px, py + a);
+                grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px - a, py);
+                grid_face_set_dot(g, d, 3);
+            }
+        }
+    }
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    grid_make_consistent(g);
+    return g;
+}
+
+#define KITE_TILESIZE 40
+/* b/a approx sqrt(3) */
+#define KITE_A 15
+#define KITE_B 26
+
+static void grid_size_kites(int width, int height,
+                     int *tilesize, int *xextent, int *yextent)
+{
+    int a = KITE_A;
+    int b = KITE_B;
+
+    *tilesize = KITE_TILESIZE;
+    *xextent = 4*b * width + 2*b;
+    *yextent = 6*a * (height-1) + 8*a;
+}
+
+static grid *grid_new_kites(int width, int height, const char *desc)
+{
+    int x, y;
+    int a = KITE_A;
+    int b = KITE_B;
+
+    /* Upper bounds - don't have to be exact */
+    int max_faces = 6 * width * height;
+    int max_dots = 6 * (width + 1) * (height + 1);
+
+    tree234 *points;
+
+    grid *g = grid_empty();
+    g->tilesize = KITE_TILESIZE;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            grid_dot *d;
+            /* position of order-6 dot */
+            int px = 4*b * x;
+            int py = 6*a * y;
+            if (y % 2)
+                px += 2*b;
+
+            /* kite pointing up-left */
+            grid_face_add_new(g, 4);
+            d = grid_get_dot(g, points, px, py);
+            grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px + 2*b, py);
+            grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px + 2*b, py + 2*a);
+            grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px + b, py + 3*a);
+            grid_face_set_dot(g, d, 3);
+
+            /* kite pointing up */
+            grid_face_add_new(g, 4);
+            d = grid_get_dot(g, points, px, py);
+            grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px + b, py + 3*a);
+            grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px, py + 4*a);
+            grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px - b, py + 3*a);
+            grid_face_set_dot(g, d, 3);
+
+            /* kite pointing up-right */
+            grid_face_add_new(g, 4);
+            d = grid_get_dot(g, points, px, py);
+            grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px - b, py + 3*a);
+            grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px - 2*b, py + 2*a);
+            grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px - 2*b, py);
+            grid_face_set_dot(g, d, 3);
+
+            /* kite pointing down-right */
+            grid_face_add_new(g, 4);
+            d = grid_get_dot(g, points, px, py);
+            grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px - 2*b, py);
+            grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px - 2*b, py - 2*a);
+            grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px - b, py - 3*a);
+            grid_face_set_dot(g, d, 3);
+
+            /* kite pointing down */
+            grid_face_add_new(g, 4);
+            d = grid_get_dot(g, points, px, py);
+            grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px - b, py - 3*a);
+            grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px, py - 4*a);
+            grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px + b, py - 3*a);
+            grid_face_set_dot(g, d, 3);
+
+            /* kite pointing down-left */
+            grid_face_add_new(g, 4);
+            d = grid_get_dot(g, points, px, py);
+            grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px + b, py - 3*a);
+            grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px + 2*b, py - 2*a);
+            grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px + 2*b, py);
+            grid_face_set_dot(g, d, 3);
+        }
+    }
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    grid_make_consistent(g);
+    return g;
+}
+
+#define FLORET_TILESIZE 150
+/* -py/px is close to tan(30 - atan(sqrt(3)/9))
+ * using py=26 makes everything lean to the left, rather than right
+ */
+#define FLORET_PX 75
+#define FLORET_PY -26
+
+static void grid_size_floret(int width, int height,
+                          int *tilesize, int *xextent, int *yextent)
+{
+    int px = FLORET_PX, py = FLORET_PY;         /* |( 75, -26)| = 79.43 */
+    int qx = 4*px/5, qy = -py*2;                /* |( 60,  52)| = 79.40 */
+    int ry = qy-py;
+    /* rx unused in determining grid size. */
+
+    *tilesize = FLORET_TILESIZE;
+    *xextent = (6*px+3*qx)/2 * (width-1) + 4*qx + 2*px;
+    *yextent = (5*qy-4*py) * (height-1) + 4*qy + 2*ry;
+}
+
+static grid *grid_new_floret(int width, int height, const char *desc)
+{
+    int x, y;
+    /* Vectors for sides; weird numbers needed to keep puzzle aligned with window
+     * -py/px is close to tan(30 - atan(sqrt(3)/9))
+     * using py=26 makes everything lean to the left, rather than right
+     */
+    int px = FLORET_PX, py = FLORET_PY;         /* |( 75, -26)| = 79.43 */
+    int qx = 4*px/5, qy = -py*2;                /* |( 60,  52)| = 79.40 */
+    int rx = qx-px, ry = qy-py;                 /* |(-15,  78)| = 79.38 */
+
+    /* Upper bounds - don't have to be exact */
+    int max_faces = 6 * width * height;
+    int max_dots = 9 * (width + 1) * (height + 1);
+
+    tree234 *points;
+
+    grid *g = grid_empty();
+    g->tilesize = FLORET_TILESIZE;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    /* generate pentagonal faces */
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            grid_dot *d;
+            /* face centre */
+            int cx = (6*px+3*qx)/2 * x;
+            int cy = (4*py-5*qy) * y;
+            if (x % 2)
+                cy -= (4*py-5*qy)/2;
+            else if (y && y == height-1)
+                continue; /* make better looking grids?  try 3x3 for instance */
+
+            grid_face_add_new(g, 5);
+            d = grid_get_dot(g, points, cx        , cy        ); grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, cx+2*rx   , cy+2*ry   ); grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, cx+2*rx+qx, cy+2*ry+qy); grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, cx+2*qx+rx, cy+2*qy+ry); grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, cx+2*qx   , cy+2*qy   ); grid_face_set_dot(g, d, 4);
+
+            grid_face_add_new(g, 5);
+            d = grid_get_dot(g, points, cx        , cy        ); grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, cx+2*qx   , cy+2*qy   ); grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, cx+2*qx+px, cy+2*qy+py); grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, cx+2*px+qx, cy+2*py+qy); grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, cx+2*px   , cy+2*py   ); grid_face_set_dot(g, d, 4);
+
+            grid_face_add_new(g, 5);
+            d = grid_get_dot(g, points, cx        , cy        ); grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, cx+2*px   , cy+2*py   ); grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, cx+2*px-rx, cy+2*py-ry); grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, cx-2*rx+px, cy-2*ry+py); grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, cx-2*rx   , cy-2*ry   ); grid_face_set_dot(g, d, 4);
+
+            grid_face_add_new(g, 5);
+            d = grid_get_dot(g, points, cx        , cy        ); grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, cx-2*rx   , cy-2*ry   ); grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, cx-2*rx-qx, cy-2*ry-qy); grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, cx-2*qx-rx, cy-2*qy-ry); grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, cx-2*qx   , cy-2*qy   ); grid_face_set_dot(g, d, 4);
+
+            grid_face_add_new(g, 5);
+            d = grid_get_dot(g, points, cx        , cy        ); grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, cx-2*qx   , cy-2*qy   ); grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, cx-2*qx-px, cy-2*qy-py); grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, cx-2*px-qx, cy-2*py-qy); grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, cx-2*px   , cy-2*py   ); grid_face_set_dot(g, d, 4);
+
+            grid_face_add_new(g, 5);
+            d = grid_get_dot(g, points, cx        , cy        ); grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, cx-2*px   , cy-2*py   ); grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, cx-2*px+rx, cy-2*py+ry); grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, cx+2*rx-px, cy+2*ry-py); grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, cx+2*rx   , cy+2*ry   ); grid_face_set_dot(g, d, 4);
+        }
+    }
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    grid_make_consistent(g);
+    return g;
+}
+
+/* DODEC_* are used for dodecagonal and great-dodecagonal grids. */
+#define DODEC_TILESIZE 26
+/* Vector for side of triangle - ratio is close to sqrt(3) */
+#define DODEC_A 15
+#define DODEC_B 26
+
+static void grid_size_dodecagonal(int width, int height,
+                          int *tilesize, int *xextent, int *yextent)
+{
+    int a = DODEC_A;
+    int b = DODEC_B;
+
+    *tilesize = DODEC_TILESIZE;
+    *xextent = (4*a + 2*b) * (width-1) + 3*(2*a + b);
+    *yextent = (3*a + 2*b) * (height-1) + 2*(2*a + b);
+}
+
+static grid *grid_new_dodecagonal(int width, int height, const char *desc)
+{
+    int x, y;
+    int a = DODEC_A;
+    int b = DODEC_B;
+
+    /* Upper bounds - don't have to be exact */
+    int max_faces = 3 * width * height;
+    int max_dots = 14 * width * height;
+
+    tree234 *points;
+
+    grid *g = grid_empty();
+    g->tilesize = DODEC_TILESIZE;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            grid_dot *d;
+            /* centre of dodecagon */
+            int px = (4*a + 2*b) * x;
+            int py = (3*a + 2*b) * y;
+            if (y % 2)
+                px += 2*a + b;
+
+            /* dodecagon */
+            grid_face_add_new(g, 12);
+            d = grid_get_dot(g, points, px + (  a    ), py - (2*a + b)); grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px + (  a + b), py - (  a + b)); grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px + (2*a + b), py - (  a    )); grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px + (2*a + b), py + (  a    )); grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, px + (  a + b), py + (  a + b)); grid_face_set_dot(g, d, 4);
+            d = grid_get_dot(g, points, px + (  a    ), py + (2*a + b)); grid_face_set_dot(g, d, 5);
+            d = grid_get_dot(g, points, px - (  a    ), py + (2*a + b)); grid_face_set_dot(g, d, 6);
+            d = grid_get_dot(g, points, px - (  a + b), py + (  a + b)); grid_face_set_dot(g, d, 7);
+            d = grid_get_dot(g, points, px - (2*a + b), py + (  a    )); grid_face_set_dot(g, d, 8);
+            d = grid_get_dot(g, points, px - (2*a + b), py - (  a    )); grid_face_set_dot(g, d, 9);
+            d = grid_get_dot(g, points, px - (  a + b), py - (  a + b)); grid_face_set_dot(g, d, 10);
+            d = grid_get_dot(g, points, px - (  a    ), py - (2*a + b)); grid_face_set_dot(g, d, 11);
+
+            /* triangle below dodecagon */
+            if ((y < height - 1 && (x < width - 1 || !(y % 2)) && (x > 0 || (y % 2)))) {
+                grid_face_add_new(g, 3);
+                d = grid_get_dot(g, points, px + a, py + (2*a +   b)); grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px    , py + (2*a + 2*b)); grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px - a, py + (2*a +   b)); grid_face_set_dot(g, d, 2);
+            }
+
+            /* triangle above dodecagon */
+            if ((y && (x < width - 1 || !(y % 2)) && (x > 0 || (y % 2)))) {
+                grid_face_add_new(g, 3);
+                d = grid_get_dot(g, points, px - a, py - (2*a +   b)); grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px    , py - (2*a + 2*b)); grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px + a, py - (2*a +   b)); grid_face_set_dot(g, d, 2);
+            }
+        }
+    }
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    grid_make_consistent(g);
+    return g;
+}
+
+static void grid_size_greatdodecagonal(int width, int height,
+                          int *tilesize, int *xextent, int *yextent)
+{
+    int a = DODEC_A;
+    int b = DODEC_B;
+
+    *tilesize = DODEC_TILESIZE;
+    *xextent = (6*a + 2*b) * (width-1) + 2*(2*a + b) + 3*a + b;
+    *yextent = (3*a + 3*b) * (height-1) + 2*(2*a + b);
+}
+
+static grid *grid_new_greatdodecagonal(int width, int height, const char *desc)
+{
+    int x, y;
+    /* Vector for side of triangle - ratio is close to sqrt(3) */
+    int a = DODEC_A;
+    int b = DODEC_B;
+
+    /* Upper bounds - don't have to be exact */
+    int max_faces = 30 * width * height;
+    int max_dots = 200 * width * height;
+
+    tree234 *points;
+
+    grid *g = grid_empty();
+    g->tilesize = DODEC_TILESIZE;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            grid_dot *d;
+            /* centre of dodecagon */
+            int px = (6*a + 2*b) * x;
+            int py = (3*a + 3*b) * y;
+            if (y % 2)
+                px += 3*a + b;
+
+            /* dodecagon */
+            grid_face_add_new(g, 12);
+            d = grid_get_dot(g, points, px + (  a    ), py - (2*a + b)); grid_face_set_dot(g, d, 0);
+            d = grid_get_dot(g, points, px + (  a + b), py - (  a + b)); grid_face_set_dot(g, d, 1);
+            d = grid_get_dot(g, points, px + (2*a + b), py - (  a    )); grid_face_set_dot(g, d, 2);
+            d = grid_get_dot(g, points, px + (2*a + b), py + (  a    )); grid_face_set_dot(g, d, 3);
+            d = grid_get_dot(g, points, px + (  a + b), py + (  a + b)); grid_face_set_dot(g, d, 4);
+            d = grid_get_dot(g, points, px + (  a    ), py + (2*a + b)); grid_face_set_dot(g, d, 5);
+            d = grid_get_dot(g, points, px - (  a    ), py + (2*a + b)); grid_face_set_dot(g, d, 6);
+            d = grid_get_dot(g, points, px - (  a + b), py + (  a + b)); grid_face_set_dot(g, d, 7);
+            d = grid_get_dot(g, points, px - (2*a + b), py + (  a    )); grid_face_set_dot(g, d, 8);
+            d = grid_get_dot(g, points, px - (2*a + b), py - (  a    )); grid_face_set_dot(g, d, 9);
+            d = grid_get_dot(g, points, px - (  a + b), py - (  a + b)); grid_face_set_dot(g, d, 10);
+            d = grid_get_dot(g, points, px - (  a    ), py - (2*a + b)); grid_face_set_dot(g, d, 11);
+
+            /* hexagon below dodecagon */
+            if (y < height - 1 && (x < width - 1 || !(y % 2)) && (x > 0 || (y % 2))) {
+                grid_face_add_new(g, 6);
+                d = grid_get_dot(g, points, px +   a, py + (2*a +   b)); grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px + 2*a, py + (2*a + 2*b)); grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px +   a, py + (2*a + 3*b)); grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px -   a, py + (2*a + 3*b)); grid_face_set_dot(g, d, 3);
+                d = grid_get_dot(g, points, px - 2*a, py + (2*a + 2*b)); grid_face_set_dot(g, d, 4);
+                d = grid_get_dot(g, points, px -   a, py + (2*a +   b)); grid_face_set_dot(g, d, 5);
+            }
+
+            /* hexagon above dodecagon */
+            if (y && (x < width - 1 || !(y % 2)) && (x > 0 || (y % 2))) {
+                grid_face_add_new(g, 6);
+                d = grid_get_dot(g, points, px -   a, py - (2*a +   b)); grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px - 2*a, py - (2*a + 2*b)); grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px -   a, py - (2*a + 3*b)); grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px +   a, py - (2*a + 3*b)); grid_face_set_dot(g, d, 3);
+                d = grid_get_dot(g, points, px + 2*a, py - (2*a + 2*b)); grid_face_set_dot(g, d, 4);
+                d = grid_get_dot(g, points, px +   a, py - (2*a +   b)); grid_face_set_dot(g, d, 5);
+            }
+
+            /* square on right of dodecagon */
+            if (x < width - 1) {
+                grid_face_add_new(g, 4);
+                d = grid_get_dot(g, points, px + 2*a + b, py - a); grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px + 4*a + b, py - a); grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px + 4*a + b, py + a); grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px + 2*a + b, py + a); grid_face_set_dot(g, d, 3);
+            }
+
+            /* square on top right of dodecagon */
+            if (y && (x < width - 1 || !(y % 2))) {
+                grid_face_add_new(g, 4);
+                d = grid_get_dot(g, points, px + (  a    ), py - (2*a +   b)); grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px + (2*a    ), py - (2*a + 2*b)); grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px + (2*a + b), py - (  a + 2*b)); grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px + (  a + b), py - (  a +   b)); grid_face_set_dot(g, d, 3);
+            }
+
+            /* square on top left of dodecagon */
+            if (y && (x || (y % 2))) {
+                grid_face_add_new(g, 4);
+                d = grid_get_dot(g, points, px - (  a + b), py - (  a +   b)); grid_face_set_dot(g, d, 0);
+                d = grid_get_dot(g, points, px - (2*a + b), py - (  a + 2*b)); grid_face_set_dot(g, d, 1);
+                d = grid_get_dot(g, points, px - (2*a    ), py - (2*a + 2*b)); grid_face_set_dot(g, d, 2);
+                d = grid_get_dot(g, points, px - (  a    ), py - (2*a +   b)); grid_face_set_dot(g, d, 3);
+            }
+        }
+    }
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    grid_make_consistent(g);
+    return g;
+}
+
+typedef struct setface_ctx
+{
+    int xmin, xmax, ymin, ymax;
+
+    grid *g;
+    tree234 *points;
+} setface_ctx;
+
+static double round_int_nearest_away(double r)
+{
+    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
+}
+
+static int set_faces(penrose_state *state, vector *vs, int n, int depth)
+{
+    setface_ctx *sf_ctx = (setface_ctx *)state->ctx;
+    int i;
+    int xs[4], ys[4];
+
+    if (depth < state->max_depth) return 0;
+#ifdef DEBUG_PENROSE
+    if (n != 4) return 0; /* triangles are sent as debugging. */
+#endif
+
+    for (i = 0; i < n; i++) {
+        double tx = v_x(vs, i), ty = v_y(vs, i);
+
+        xs[i] = (int)round_int_nearest_away(tx);
+        ys[i] = (int)round_int_nearest_away(ty);
+
+        if (xs[i] < sf_ctx->xmin || xs[i] > sf_ctx->xmax) return 0;
+        if (ys[i] < sf_ctx->ymin || ys[i] > sf_ctx->ymax) return 0;
+    }
+
+    grid_face_add_new(sf_ctx->g, n);
+    debug(("penrose: new face l=%f gen=%d...",
+           penrose_side_length(state->start_size, depth), depth));
+    for (i = 0; i < n; i++) {
+        grid_dot *d = grid_get_dot(sf_ctx->g, sf_ctx->points,
+                                   xs[i], ys[i]);
+        grid_face_set_dot(sf_ctx->g, d, i);
+        debug((" ... dot 0x%x (%d,%d) (was %2.2f,%2.2f)",
+               d, d->x, d->y, v_x(vs, i), v_y(vs, i)));
+    }
+
+    return 0;
+}
+
+#define PENROSE_TILESIZE 100
+
+static void grid_size_penrose(int width, int height,
+                       int *tilesize, int *xextent, int *yextent)
+{
+    int l = PENROSE_TILESIZE;
+
+    *tilesize = l;
+    *xextent = l * width;
+    *yextent = l * height;
+}
+
+static grid *grid_new_penrose(int width, int height, int which, const char *desc); /* forward reference */
+
+static char *grid_new_desc_penrose(grid_type type, int width, int height, random_state *rs)
+{
+    int tilesize = PENROSE_TILESIZE, startsz, depth, xoff, yoff, aoff;
+    double outer_radius;
+    int inner_radius;
+    char gd[255];
+    int which = (type == GRID_PENROSE_P2 ? PENROSE_P2 : PENROSE_P3);
+    grid *g;
+
+    while (1) {
+        /* We want to produce a random bit of penrose tiling, so we
+         * calculate a random offset (within the patch that penrose.c
+         * calculates for us) and an angle (multiple of 36) to rotate
+         * the patch. */
+
+        penrose_calculate_size(which, tilesize, width, height,
+                               &outer_radius, &startsz, &depth);
+
+        /* Calculate radius of (circumcircle of) patch, subtract from
+         * radius calculated. */
+        inner_radius = (int)(outer_radius - sqrt(width*width + height*height));
+
+        /* Pick a random offset (the easy way: choose within outer
+         * square, discarding while it's outside the circle) */
+        do {
+            xoff = random_upto(rs, 2*inner_radius) - inner_radius;
+            yoff = random_upto(rs, 2*inner_radius) - inner_radius;
+        } while (sqrt(xoff*xoff+yoff*yoff) > inner_radius);
+
+        aoff = random_upto(rs, 360/36) * 36;
+
+        debug(("grid_desc: ts %d, %dx%d patch, orad %2.2f irad %d",
+               tilesize, width, height, outer_radius, inner_radius));
+        debug(("    -> xoff %d yoff %d aoff %d", xoff, yoff, aoff));
+
+        sprintf(gd, "G%d,%d,%d", xoff, yoff, aoff);
+
+        /*
+         * Now test-generate our grid, to make sure it actually
+         * produces something.
+         */
+        g = grid_new_penrose(width, height, which, gd);
+        if (g) {
+            grid_free(g);
+            break;
+        }
+        /* If not, go back to the top of this while loop and try again
+         * with a different random offset. */
+    }
+
+    return dupstr(gd);
+}
+
+static char *grid_validate_desc_penrose(grid_type type, int width, int height,
+                                        const char *desc)
+{
+    int tilesize = PENROSE_TILESIZE, startsz, depth, xoff, yoff, aoff, inner_radius;
+    double outer_radius;
+    int which = (type == GRID_PENROSE_P2 ? PENROSE_P2 : PENROSE_P3);
+    grid *g;
+
+    if (!desc)
+        return "Missing grid description string.";
+
+    penrose_calculate_size(which, tilesize, width, height,
+                           &outer_radius, &startsz, &depth);
+    inner_radius = (int)(outer_radius - sqrt(width*width + height*height));
+
+    if (sscanf(desc, "G%d,%d,%d", &xoff, &yoff, &aoff) != 3)
+        return "Invalid format grid description string.";
+
+    if (sqrt(xoff*xoff + yoff*yoff) > inner_radius)
+        return "Patch offset out of bounds.";
+    if ((aoff % 36) != 0 || aoff < 0 || aoff >= 360)
+        return "Angle offset out of bounds.";
+
+    /*
+     * Test-generate to ensure these parameters don't end us up with
+     * no grid at all.
+     */
+    g = grid_new_penrose(width, height, which, desc);
+    if (!g)
+        return "Patch coordinates do not identify a usable grid fragment";
+    grid_free(g);
+
+    return NULL;
+}
+
+/*
+ * We're asked for a grid of a particular size, and we generate enough
+ * of the tiling so we can be sure to have enough random grid from which
+ * to pick.
+ */
+
+static grid *grid_new_penrose(int width, int height, int which, const char *desc)
+{
+    int max_faces, max_dots, tilesize = PENROSE_TILESIZE;
+    int xsz, ysz, xoff, yoff, aoff;
+    double rradius;
+
+    tree234 *points;
+    grid *g;
+
+    penrose_state ps;
+    setface_ctx sf_ctx;
+
+    penrose_calculate_size(which, tilesize, width, height,
+                           &rradius, &ps.start_size, &ps.max_depth);
+
+    debug(("penrose: w%d h%d, tile size %d, start size %d, depth %d",
+           width, height, tilesize, ps.start_size, ps.max_depth));
+
+    ps.new_tile = set_faces;
+    ps.ctx = &sf_ctx;
+
+    max_faces = (width*3) * (height*3); /* somewhat paranoid... */
+    max_dots = max_faces * 4; /* ditto... */
+
+    g = grid_empty();
+    g->tilesize = tilesize;
+    g->faces = snewn(max_faces, grid_face);
+    g->dots = snewn(max_dots, grid_dot);
+
+    points = newtree234(grid_point_cmp_fn);
+
+    memset(&sf_ctx, 0, sizeof(sf_ctx));
+    sf_ctx.g = g;
+    sf_ctx.points = points;
+
+    if (desc != NULL) {
+        if (sscanf(desc, "G%d,%d,%d", &xoff, &yoff, &aoff) != 3)
+            assert(!"Invalid grid description.");
+    } else {
+        xoff = yoff = aoff = 0;
+    }
+
+    xsz = width * tilesize;
+    ysz = height * tilesize;
+
+    sf_ctx.xmin = xoff - xsz/2;
+    sf_ctx.xmax = xoff + xsz/2;
+    sf_ctx.ymin = yoff - ysz/2;
+    sf_ctx.ymax = yoff + ysz/2;
+
+    debug(("penrose: centre (%f, %f) xsz %f ysz %f",
+           0.0, 0.0, xsz, ysz));
+    debug(("penrose: x range (%f --> %f), y range (%f --> %f)",
+           sf_ctx.xmin, sf_ctx.xmax, sf_ctx.ymin, sf_ctx.ymax));
+
+    penrose(&ps, which, aoff);
+
+    freetree234(points);
+    assert(g->num_faces <= max_faces);
+    assert(g->num_dots <= max_dots);
+
+    debug(("penrose: %d faces total (equivalent to %d wide by %d high)",
+           g->num_faces, g->num_faces/height, g->num_faces/width));
+
+    /*
+     * Return NULL if we ended up with an empty grid, either because
+     * the initial generation was over too small a rectangle to
+     * encompass any face or because grid_trim_vigorously ended up
+     * removing absolutely everything.
+     */
+    if (g->num_faces == 0 || g->num_dots == 0) {
+        grid_free(g);
+        return NULL;
+    }
+    grid_trim_vigorously(g);
+    if (g->num_faces == 0 || g->num_dots == 0) {
+        grid_free(g);
+        return NULL;
+    }
+
+    grid_make_consistent(g);
+
+    /*
+     * Centre the grid in its originally promised rectangle.
+     */
+    g->lowest_x -= ((sf_ctx.xmax - sf_ctx.xmin) -
+                    (g->highest_x - g->lowest_x)) / 2;
+    g->highest_x = g->lowest_x + (sf_ctx.xmax - sf_ctx.xmin);
+    g->lowest_y -= ((sf_ctx.ymax - sf_ctx.ymin) -
+                    (g->highest_y - g->lowest_y)) / 2;
+    g->highest_y = g->lowest_y + (sf_ctx.ymax - sf_ctx.ymin);
+
+    return g;
+}
+
+static void grid_size_penrose_p2_kite(int width, int height,
+                       int *tilesize, int *xextent, int *yextent)
+{
+    grid_size_penrose(width, height, tilesize, xextent, yextent);
+}
+
+static void grid_size_penrose_p3_thick(int width, int height,
+                       int *tilesize, int *xextent, int *yextent)
+{
+    grid_size_penrose(width, height, tilesize, xextent, yextent);
+}
+
+static grid *grid_new_penrose_p2_kite(int width, int height, const char *desc)
+{
+    return grid_new_penrose(width, height, PENROSE_P2, desc);
+}
+
+static grid *grid_new_penrose_p3_thick(int width, int height, const char *desc)
+{
+    return grid_new_penrose(width, height, PENROSE_P3, desc);
+}
+
+/* ----------- End of grid generators ------------- */
+
+#define FNNEW(upper,lower) &grid_new_ ## lower,
+#define FNSZ(upper,lower) &grid_size_ ## lower,
+
+static grid *(*(grid_news[]))(int, int, const char*) = { GRIDGEN_LIST(FNNEW) };
+static void(*(grid_sizes[]))(int, int, int*, int*, int*) = { GRIDGEN_LIST(FNSZ) };
+
+char *grid_new_desc(grid_type type, int width, int height, random_state *rs)
+{
+    if (type == GRID_PENROSE_P2 || type == GRID_PENROSE_P3) {
+        return grid_new_desc_penrose(type, width, height, rs);
+    } else if (type == GRID_TRIANGULAR) {
+        return dupstr("0"); /* up-to-date version of triangular grid */
+    } else {
+        return NULL;
+    }
+}
+
+char *grid_validate_desc(grid_type type, int width, int height,
+                         const char *desc)
+{
+    if (type == GRID_PENROSE_P2 || type == GRID_PENROSE_P3) {
+        return grid_validate_desc_penrose(type, width, height, desc);
+    } else if (type == GRID_TRIANGULAR) {
+        return grid_validate_desc_triangular(type, width, height, desc);
+    } else {
+        if (desc != NULL)
+            return "Grid description strings not used with this grid type";
+        return NULL;
+    }
+}
+
+grid *grid_new(grid_type type, int width, int height, const char *desc)
+{
+    char *err = grid_validate_desc(type, width, height, desc);
+    if (err) assert(!"Invalid grid description.");
+
+    return grid_news[type](width, height, desc);
+}
+
+void grid_compute_size(grid_type type, int width, int height,
+                       int *tilesize, int *xextent, int *yextent)
+{
+    grid_sizes[type](width, height, tilesize, xextent, yextent);
+}
+
+/* ----------- End of grid helpers ------------- */
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/grid.h b/apps/plugins/puzzles/grid.h
new file mode 100644
index 0000000000..17d0aa1961
--- /dev/null
+++ b/apps/plugins/puzzles/grid.h
@@ -0,0 +1,132 @@
+/*
+ * (c) Lambros Lambrou 2008
+ *
+ * Code for working with general grids, which can be any planar graph
+ * with faces, edges and vertices (dots).  Includes generators for a few
+ * types of grid, including square, hexagonal, triangular and others.
+ */
+
+#ifndef PUZZLES_GRID_H
+#define PUZZLES_GRID_H
+
+#include "puzzles.h" /* for random_state */
+
+/* Useful macros */
+#define SQ(x) ( (x) * (x) )
+
+/* ----------------------------------------------------------------------
+ * Grid structures:
+ * A grid is made up of faces, edges and dots.  These structures hold
+ * the incidence relationships between these types.  For example, an
+ * edge always joins two dots, and is adjacent to two faces.
+ * The "grid_xxx **" members are lists of pointers which are dynamically
+ * allocated during grid generation.
+ * A pointer to a face/edge/dot will always point somewhere inside one of the
+ * three lists of the main "grid" structure: faces, edges, dots.
+ * Could have used integer offsets into these lists, but using actual
+ * pointers instead gives us type-safety.
+ */
+
+/* Need forward declarations */
+typedef struct grid_face grid_face;
+typedef struct grid_edge grid_edge;
+typedef struct grid_dot grid_dot;
+
+struct grid_face {
+  int order; /* Number of edges, also the number of dots */
+  grid_edge **edges; /* edges around this face */
+  grid_dot **dots; /* corners of this face */
+  /*
+   * For each face, we optionally compute and store its 'incentre'.
+   * The incentre of a triangle is the centre of a circle tangent to
+   * all three edges; I generalise the concept to arbitrary polygons
+   * by defining it to be the centre of the largest circle you can fit
+   * anywhere in the polygon. It's a useful thing to know because if
+   * you want to draw any symbol or text in the face (e.g. clue
+   * numbers in Loopy), that's the place it will most easily fit.
+   *
+   * When a grid is first generated, no face has this information
+   * computed, because it's fiddly to do. You can call
+   * grid_find_incentre() on a face, and it will fill in ix,iy below
+   * and set has_incentre to indicate that it's done so.
+   */
+  int has_incentre;
+  int ix, iy;      /* incentre (centre of largest inscribed circle) */
+};
+struct grid_edge {
+  grid_dot *dot1, *dot2;
+  grid_face *face1, *face2; /* Use NULL for the infinite outside face */
+};
+struct grid_dot {
+  int order;
+  grid_edge **edges;
+  grid_face **faces; /* A NULL grid_face* means infinite outside face */
+
+  /* Position in some fairly arbitrary (Cartesian) coordinate system.
+   * Use large enough values such that we can get away with
+   * integer arithmetic, but small enough such that arithmetic
+   * won't overflow. */
+  int x, y;
+};
+typedef struct grid {
+  /* These are (dynamically allocated) arrays of all the
+   * faces, edges, dots that are in the grid. */
+  int num_faces; grid_face *faces;
+  int num_edges; grid_edge *edges;
+  int num_dots;  grid_dot *dots;
+
+  /* Cache the bounding-box of the grid, so the drawing-code can quickly
+   * figure out the proper scaling to draw onto a given area. */
+  int lowest_x, lowest_y, highest_x, highest_y;
+
+  /* A measure of tile size for this grid (in grid coordinates), to help
+   * the renderer decide how large to draw the grid.
+   * Roughly the size of a single tile - for example the side-length
+   * of a square cell. */
+  int tilesize;
+
+  /* We really don't want to copy this monstrosity!
+   * A grid is immutable once generated.
+   */
+  int refcount;
+} grid;
+
+/* Grids are specified by type: GRID_SQUARE, GRID_KITE, etc. */
+
+#define GRIDGEN_LIST(A) \
+  A(SQUARE,square) \
+  A(HONEYCOMB,honeycomb) \
+  A(TRIANGULAR,triangular) \
+  A(SNUBSQUARE,snubsquare) \
+  A(CAIRO,cairo) \
+  A(GREATHEXAGONAL,greathexagonal) \
+  A(OCTAGONAL,octagonal) \
+  A(KITE,kites) \
+  A(FLORET,floret) \
+  A(DODECAGONAL,dodecagonal) \
+  A(GREATDODECAGONAL,greatdodecagonal) \
+  A(PENROSE_P2,penrose_p2_kite) \
+  A(PENROSE_P3,penrose_p3_thick)
+
+#define ENUM(upper,lower) GRID_ ## upper,
+typedef enum grid_type { GRIDGEN_LIST(ENUM) GRID_TYPE_MAX } grid_type;
+#undef ENUM
+
+/* Free directly after use if non-NULL. Will never contain an underscore
+ * (so clients can safely use that as a separator). */
+char *grid_new_desc(grid_type type, int width, int height, random_state *rs);
+char *grid_validate_desc(grid_type type, int width, int height,
+                         const char *desc);
+
+grid *grid_new(grid_type type, int width, int height, const char *desc);
+
+void grid_free(grid *g);
+
+grid_edge *grid_nearest_edge(grid *g, int x, int y);
+
+void grid_compute_size(grid_type type, int width, int height,
+                       int *tilesize, int *xextent, int *yextent);
+
+void grid_find_incentre(grid_face *f);
+
+#endif /* PUZZLES_GRID_H */
diff --git a/apps/plugins/puzzles/gtk.c b/apps/plugins/puzzles/gtk.c
new file mode 100644
index 0000000000..aa3ba06eed
--- /dev/null
+++ b/apps/plugins/puzzles/gtk.c
@@ -0,0 +1,3215 @@
+/*
+ * gtk.c: GTK front end for my puzzle collection.
+ */
+
+#include <stdio.h>
+#include "rbassert.h"
+#include <stdlib.h>
+#include <time.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+#include <math.h>
+
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include <gdk/gdkx.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+
+#include "puzzles.h"
+
+#if GTK_CHECK_VERSION(2,0,0)
+# define USE_PANGO
+# ifdef PANGO_VERSION_CHECK
+#  if PANGO_VERSION_CHECK(1,8,0)
+#   define HAVE_SENSIBLE_ABSOLUTE_SIZE_FUNCTION
+#  endif
+# endif
+#endif
+#if !GTK_CHECK_VERSION(2,4,0)
+# define OLD_FILESEL
+#endif
+#if GTK_CHECK_VERSION(2,8,0)
+# define USE_CAIRO
+# if GTK_CHECK_VERSION(3,0,0) || defined(GDK_DISABLE_DEPRECATED)
+#  define USE_CAIRO_WITHOUT_PIXMAP
+# endif
+#endif
+
+#if GTK_CHECK_VERSION(3,0,0)
+/* The old names are still more concise! */
+#define gtk_hbox_new(x,y) gtk_box_new(GTK_ORIENTATION_HORIZONTAL,y)
+#define gtk_vbox_new(x,y) gtk_box_new(GTK_ORIENTATION_VERTICAL,y)
+/* GTK 3 has retired stock button labels */
+#define LABEL_OK "_OK"
+#define LABEL_CANCEL "_Cancel"
+#define LABEL_NO "_No"
+#define LABEL_YES "_Yes"
+#define LABEL_SAVE "_Save"
+#define LABEL_OPEN "_Open"
+#define gtk_button_new_with_our_label gtk_button_new_with_mnemonic
+#else
+#define LABEL_OK GTK_STOCK_OK
+#define LABEL_CANCEL GTK_STOCK_CANCEL
+#define LABEL_NO GTK_STOCK_NO
+#define LABEL_YES GTK_STOCK_YES
+#define LABEL_SAVE GTK_STOCK_SAVE
+#define LABEL_OPEN GTK_STOCK_OPEN
+#define gtk_button_new_with_our_label gtk_button_new_from_stock
+#endif
+
+/* #undef USE_CAIRO */
+/* #define NO_THICK_LINE */
+#ifdef DEBUGGING
+static FILE *debug_fp = NULL;
+
+void dputs(char *buf)
+{
+    if (!debug_fp) {
+        debug_fp = fopen("debug.log", "w");
+    }
+
+    fputs(buf, stderr);
+
+    if (debug_fp) {
+        fputs(buf, debug_fp);
+        fflush(debug_fp);
+    }
+}
+
+void debug_printf(char *fmt, ...)
+{
+    char buf[4096];
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsprintf(buf, fmt, ap);
+    dputs(buf);
+    va_end(ap);
+}
+#endif
+
+/* ----------------------------------------------------------------------
+ * Error reporting functions used elsewhere.
+ */
+
+void fatal(char *fmt, ...)
+{
+    va_list ap;
+
+    fprintf(stderr, "fatal error: ");
+
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+
+    fprintf(stderr, "\n");
+    exit(1);
+}
+
+/* ----------------------------------------------------------------------
+ * GTK front end to puzzles.
+ */
+
+static void changed_preset(frontend *fe);
+
+struct font {
+#ifdef USE_PANGO
+    PangoFontDescription *desc;
+#else
+    GdkFont *font;
+#endif
+    int type;
+    int size;
+};
+
+/*
+ * This structure holds all the data relevant to a single window.
+ * In principle this would allow us to open multiple independent
+ * puzzle windows, although I can't currently see any real point in
+ * doing so. I'm just coding cleanly because there's no
+ * particularly good reason not to.
+ */
+struct frontend {
+    GtkWidget *window;
+    GtkAccelGroup *accelgroup;
+    GtkWidget *area;
+    GtkWidget *statusbar;
+    GtkWidget *menubar;
+    guint statusctx;
+    int w, h;
+    midend *me;
+#ifdef USE_CAIRO
+    const float *colours;
+    cairo_t *cr;
+    cairo_surface_t *image;
+#ifndef USE_CAIRO_WITHOUT_PIXMAP
+    GdkPixmap *pixmap;
+#endif
+    GdkColor background;               /* for painting outside puzzle area */
+#else
+    GdkPixmap *pixmap;
+    GdkGC *gc;
+    GdkColor *colours;
+    GdkColormap *colmap;
+    int backgroundindex;               /* which of colours[] is background */
+#endif
+    int ncolours;
+    int bbox_l, bbox_r, bbox_u, bbox_d;
+    int timer_active, timer_id;
+    struct timeval last_time;
+    struct font *fonts;
+    int nfonts, fontsize;
+    config_item *cfg;
+    int cfg_which, cfgret;
+    GtkWidget *cfgbox;
+    void *paste_data;
+    int paste_data_len;
+    int pw, ph;                        /* pixmap size (w, h are area size) */
+    int ox, oy;                        /* offset of pixmap in drawing area */
+#ifdef OLD_FILESEL
+    char *filesel_name;
+#endif
+    GSList *preset_radio;
+    int n_preset_menu_items;
+    int preset_threaded;
+    GtkWidget *preset_custom;
+    GtkWidget *copy_menu_item;
+#if !GTK_CHECK_VERSION(3,0,0)
+    int drawing_area_shrink_pending;
+    int menubar_is_local;
+#endif
+};
+
+struct blitter {
+#ifdef USE_CAIRO
+    cairo_surface_t *image;
+#else
+    GdkPixmap *pixmap;
+#endif
+    int w, h, x, y;
+};
+
+void get_random_seed(void **randseed, int *randseedsize)
+{
+    struct timeval *tvp = snew(struct timeval);
+    gettimeofday(tvp, NULL);
+    *randseed = (void *)tvp;
+    *randseedsize = sizeof(struct timeval);
+}
+
+void frontend_default_colour(frontend *fe, float *output)
+{
+#if !GTK_CHECK_VERSION(3,0,0)
+    /*
+     * Use the widget style's default background colour as the
+     * background for the puzzle drawing area.
+     */
+    GdkColor col = gtk_widget_get_style(fe->window)->bg[GTK_STATE_NORMAL];
+    output[0] = col.red / 65535.0;
+    output[1] = col.green / 65535.0;
+    output[2] = col.blue / 65535.0;
+#else
+    /*
+     * GTK 3 has decided that there's no such thing as a 'default
+     * background colour' any more, because widget styles might set
+     * the background to something more complicated like a background
+     * image. We don't want to get into overlaying our entire puzzle
+     * on an arbitrary background image, so we'll just make up a
+     * reasonable shade of grey.
+     */
+    output[0] = output[1] = output[2] = 0.9F;
+#endif
+}
+
+void gtk_status_bar(void *handle, char *text)
+{
+    frontend *fe = (frontend *)handle;
+
+    assert(fe->statusbar);
+
+    gtk_statusbar_pop(GTK_STATUSBAR(fe->statusbar), fe->statusctx);
+    gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, text);
+}
+
+/* ----------------------------------------------------------------------
+ * Cairo drawing functions.
+ */
+
+#ifdef USE_CAIRO
+
+static void setup_drawing(frontend *fe)
+{
+    fe->cr = cairo_create(fe->image);
+    cairo_set_antialias(fe->cr, CAIRO_ANTIALIAS_GRAY);
+    cairo_set_line_width(fe->cr, 1.0);
+    cairo_set_line_cap(fe->cr, CAIRO_LINE_CAP_SQUARE);
+    cairo_set_line_join(fe->cr, CAIRO_LINE_JOIN_ROUND);
+}
+
+static void teardown_drawing(frontend *fe)
+{
+    cairo_destroy(fe->cr);
+    fe->cr = NULL;
+
+#ifndef USE_CAIRO_WITHOUT_PIXMAP
+    {
+        cairo_t *cr = gdk_cairo_create(fe->pixmap);
+        cairo_set_source_surface(cr, fe->image, 0, 0);
+        cairo_rectangle(cr,
+                        fe->bbox_l - 1,
+                        fe->bbox_u - 1,
+                        fe->bbox_r - fe->bbox_l + 2,
+                        fe->bbox_d - fe->bbox_u + 2);
+        cairo_fill(cr);
+        cairo_destroy(cr);
+    }
+#endif
+}
+
+static void snaffle_colours(frontend *fe)
+{
+    fe->colours = midend_colours(fe->me, &fe->ncolours);
+}
+
+static void set_colour(frontend *fe, int colour)
+{
+    cairo_set_source_rgb(fe->cr,
+                         fe->colours[3*colour + 0],
+                         fe->colours[3*colour + 1],
+                         fe->colours[3*colour + 2]);
+}
+
+static void set_window_background(frontend *fe, int colour)
+{
+#if GTK_CHECK_VERSION(3,0,0)
+    GdkRGBA rgba;
+    rgba.red = fe->colours[3*colour + 0];
+    rgba.green = fe->colours[3*colour + 1];
+    rgba.blue = fe->colours[3*colour + 2];
+    rgba.alpha = 1.0;
+    gdk_window_set_background_rgba(gtk_widget_get_window(fe->area), &rgba);
+    gdk_window_set_background_rgba(gtk_widget_get_window(fe->window), &rgba);
+#else
+    GdkColormap *colmap;
+
+    colmap = gdk_colormap_get_system();
+    fe->background.red = fe->colours[3*colour + 0] * 65535;
+    fe->background.green = fe->colours[3*colour + 1] * 65535;
+    fe->background.blue = fe->colours[3*colour + 2] * 65535;
+    if (!gdk_colormap_alloc_color(colmap, &fe->background, FALSE, FALSE)) {
+        g_error("couldn't allocate background (#%02x%02x%02x)\n",
+                fe->background.red >> 8, fe->background.green >> 8,
+                fe->background.blue >> 8);
+    }
+    gdk_window_set_background(gtk_widget_get_window(fe->area),
+                              &fe->background);
+    gdk_window_set_background(gtk_widget_get_window(fe->window),
+                              &fe->background);
+#endif
+}
+
+static PangoLayout *make_pango_layout(frontend *fe)
+{
+    return (pango_cairo_create_layout(fe->cr));
+}
+
+static void draw_pango_layout(frontend *fe, PangoLayout *layout,
+                              int x, int y)
+{
+    cairo_move_to(fe->cr, x, y);
+    pango_cairo_show_layout(fe->cr, layout);
+}
+
+static void save_screenshot_png(frontend *fe, const char *screenshot_file)
+{
+    cairo_surface_write_to_png(fe->image, screenshot_file);
+}
+
+static void do_clip(frontend *fe, int x, int y, int w, int h)
+{
+    cairo_new_path(fe->cr);
+    cairo_rectangle(fe->cr, x, y, w, h);
+    cairo_clip(fe->cr);
+}
+
+static void do_unclip(frontend *fe)
+{
+    cairo_reset_clip(fe->cr);
+}
+
+static void do_draw_rect(frontend *fe, int x, int y, int w, int h)
+{
+    cairo_save(fe->cr);
+    cairo_new_path(fe->cr);
+    cairo_set_antialias(fe->cr, CAIRO_ANTIALIAS_NONE);
+    cairo_rectangle(fe->cr, x, y, w, h);
+    cairo_fill(fe->cr);
+    cairo_restore(fe->cr);
+}
+
+static void do_draw_line(frontend *fe, int x1, int y1, int x2, int y2)
+{
+    cairo_new_path(fe->cr);
+    cairo_move_to(fe->cr, x1 + 0.5, y1 + 0.5);
+    cairo_line_to(fe->cr, x2 + 0.5, y2 + 0.5);
+    cairo_stroke(fe->cr);
+}
+
+static void do_draw_thick_line(frontend *fe, float thickness,
+                               float x1, float y1, float x2, float y2)
+{
+    cairo_save(fe->cr);
+    cairo_set_line_width(fe->cr, thickness);
+    cairo_new_path(fe->cr);
+    cairo_move_to(fe->cr, x1, y1);
+    cairo_line_to(fe->cr, x2, y2);
+    cairo_stroke(fe->cr);
+    cairo_restore(fe->cr);
+}
+
+static void do_draw_poly(frontend *fe, int *coords, int npoints,
+                         int fillcolour, int outlinecolour)
+{
+    int i;
+
+    cairo_new_path(fe->cr);
+    for (i = 0; i < npoints; i++)
+        cairo_line_to(fe->cr, coords[i*2] + 0.5, coords[i*2 + 1] + 0.5);
+    cairo_close_path(fe->cr);
+    if (fillcolour >= 0) {
+        set_colour(fe, fillcolour);
+        cairo_fill_preserve(fe->cr);
+    }
+    assert(outlinecolour >= 0);
+    set_colour(fe, outlinecolour);
+    cairo_stroke(fe->cr);
+}
+
+static void do_draw_circle(frontend *fe, int cx, int cy, int radius,
+                           int fillcolour, int outlinecolour)
+{
+    cairo_new_path(fe->cr);
+    cairo_arc(fe->cr, cx + 0.5, cy + 0.5, radius, 0, 2*PI);
+    cairo_close_path(fe->cr);           /* Just in case... */
+    if (fillcolour >= 0) {
+        set_colour(fe, fillcolour);
+        cairo_fill_preserve(fe->cr);
+    }
+    assert(outlinecolour >= 0);
+    set_colour(fe, outlinecolour);
+    cairo_stroke(fe->cr);
+}
+
+static void setup_blitter(blitter *bl, int w, int h)
+{
+    bl->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, w, h);
+}
+
+static void teardown_blitter(blitter *bl)
+{
+    cairo_surface_destroy(bl->image);
+}
+
+static void do_blitter_save(frontend *fe, blitter *bl, int x, int y)
+{
+    cairo_t *cr = cairo_create(bl->image);
+
+    cairo_set_source_surface(cr, fe->image, -x, -y);
+    cairo_paint(cr);
+    cairo_destroy(cr);
+}
+
+static void do_blitter_load(frontend *fe, blitter *bl, int x, int y)
+{
+    cairo_set_source_surface(fe->cr, bl->image, x, y);
+    cairo_paint(fe->cr);
+}
+
+static void clear_backing_store(frontend *fe)
+{
+    fe->image = NULL;
+}
+
+static void wipe_and_destroy_cairo(frontend *fe, cairo_t *cr)
+{
+    cairo_set_source_rgb(cr, fe->colours[0], fe->colours[1], fe->colours[2]);
+    cairo_paint(cr);
+    cairo_destroy(cr);
+}
+
+static void setup_backing_store(frontend *fe)
+{
+#ifndef USE_CAIRO_WITHOUT_PIXMAP
+    fe->pixmap = gdk_pixmap_new(gtk_widget_get_window(fe->area),
+                                fe->pw, fe->ph, -1);
+#endif
+    fe->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24,
+                                           fe->pw, fe->ph);
+
+    wipe_and_destroy_cairo(fe, cairo_create(fe->image));
+#ifndef USE_CAIRO_WITHOUT_PIXMAP
+    wipe_and_destroy_cairo(fe, gdk_cairo_create(fe->pixmap));
+#endif
+    wipe_and_destroy_cairo(fe, gdk_cairo_create
+                           (gtk_widget_get_window(fe->area)));
+}
+
+static int backing_store_ok(frontend *fe)
+{
+    return (!!fe->image);
+}
+
+static void teardown_backing_store(frontend *fe)
+{
+    cairo_surface_destroy(fe->image);
+#ifndef USE_CAIRO_WITHOUT_PIXMAP
+    gdk_pixmap_unref(fe->pixmap);
+#endif
+    fe->image = NULL;
+}
+
+#endif
+
+/* ----------------------------------------------------------------------
+ * GDK drawing functions.
+ */
+
+#ifndef USE_CAIRO
+
+static void setup_drawing(frontend *fe)
+{
+    fe->gc = gdk_gc_new(fe->area->window);
+}
+
+static void teardown_drawing(frontend *fe)
+{
+    gdk_gc_unref(fe->gc);
+    fe->gc = NULL;
+}
+
+static void snaffle_colours(frontend *fe)
+{
+    int i, ncolours;
+    float *colours;
+    gboolean *success;
+
+    fe->colmap = gdk_colormap_get_system();
+    colours = midend_colours(fe->me, &ncolours);
+    fe->ncolours = ncolours;
+    fe->colours = snewn(ncolours, GdkColor);
+    for (i = 0; i < ncolours; i++) {
+        fe->colours[i].red = colours[i*3] * 0xFFFF;
+        fe->colours[i].green = colours[i*3+1] * 0xFFFF;
+        fe->colours[i].blue = colours[i*3+2] * 0xFFFF;
+    }
+    success = snewn(ncolours, gboolean);
+    gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours,
+                              FALSE, FALSE, success);
+    for (i = 0; i < ncolours; i++) {
+        if (!success[i]) {
+            g_error("couldn't allocate colour %d (#%02x%02x%02x)\n",
+                    i, fe->colours[i].red >> 8,
+                    fe->colours[i].green >> 8,
+                    fe->colours[i].blue >> 8);
+        }
+    }
+}
+
+static void set_window_background(frontend *fe, int colour)
+{
+    fe->backgroundindex = colour;
+    gdk_window_set_background(fe->area->window, &fe->colours[colour]);
+    gdk_window_set_background(fe->window->window, &fe->colours[colour]);
+}
+
+static void set_colour(frontend *fe, int colour)
+{
+    gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
+}
+
+#ifdef USE_PANGO
+static PangoLayout *make_pango_layout(frontend *fe)
+{
+    return (pango_layout_new(gtk_widget_get_pango_context(fe->area)));
+}
+
+static void draw_pango_layout(frontend *fe, PangoLayout *layout,
+                              int x, int y)
+{
+    gdk_draw_layout(fe->pixmap, fe->gc, x, y, layout);
+}
+#endif
+
+static void save_screenshot_png(frontend *fe, const char *screenshot_file)
+{
+    GdkPixbuf *pb;
+    GError *gerror = NULL;
+
+    midend_redraw(fe->me);
+
+    pb = gdk_pixbuf_get_from_drawable(NULL, fe->pixmap,
+                                      NULL, 0, 0, 0, 0, -1, -1);
+    gdk_pixbuf_save(pb, screenshot_file, "png", &gerror, NULL);
+}
+
+static void do_clip(frontend *fe, int x, int y, int w, int h)
+{
+    GdkRectangle rect;
+
+    rect.x = x;
+    rect.y = y;
+    rect.width = w;
+    rect.height = h;
+    gdk_gc_set_clip_rectangle(fe->gc, &rect);
+}
+
+static void do_unclip(frontend *fe)
+{
+    GdkRectangle rect;
+
+    rect.x = 0;
+    rect.y = 0;
+    rect.width = fe->w;
+    rect.height = fe->h;
+    gdk_gc_set_clip_rectangle(fe->gc, &rect);
+}
+
+static void do_draw_rect(frontend *fe, int x, int y, int w, int h)
+{
+    gdk_draw_rectangle(fe->pixmap, fe->gc, 1, x, y, w, h);
+}
+
+static void do_draw_line(frontend *fe, int x1, int y1, int x2, int y2)
+{
+    gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2);
+}
+
+static void do_draw_thick_line(frontend *fe, float thickness,
+                               float x1, float y1, float x2, float y2)
+{
+    GdkGCValues save;
+
+    gdk_gc_get_values(fe->gc, &save);
+    gdk_gc_set_line_attributes(fe->gc,
+                               thickness,
+                               GDK_LINE_SOLID,
+                               GDK_CAP_BUTT,
+                               GDK_JOIN_BEVEL);
+    gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2);
+    gdk_gc_set_line_attributes(fe->gc,
+                               save.line_width,
+                               save.line_style,
+                               save.cap_style,
+                               save.join_style);
+}
+
+static void do_draw_poly(frontend *fe, int *coords, int npoints,
+                         int fillcolour, int outlinecolour)
+{
+    GdkPoint *points = snewn(npoints, GdkPoint);
+    int i;
+
+    for (i = 0; i < npoints; i++) {
+        points[i].x = coords[i*2];
+        points[i].y = coords[i*2+1];
+    }
+
+    if (fillcolour >= 0) {
+        set_colour(fe, fillcolour);
+        gdk_draw_polygon(fe->pixmap, fe->gc, TRUE, points, npoints);
+    }
+    assert(outlinecolour >= 0);
+    set_colour(fe, outlinecolour);
+
+    /*
+     * In principle we ought to be able to use gdk_draw_polygon for
+     * the outline as well. In fact, it turns out to interact badly
+     * with a clipping region, for no terribly obvious reason, so I
+     * draw the outline as a sequence of lines instead.
+     */
+    for (i = 0; i < npoints; i++)
+        gdk_draw_line(fe->pixmap, fe->gc,
+                      points[i].x, points[i].y,
+                      points[(i+1)%npoints].x, points[(i+1)%npoints].y);
+
+    sfree(points);
+}
+
+static void do_draw_circle(frontend *fe, int cx, int cy, int radius,
+                           int fillcolour, int outlinecolour)
+{
+    if (fillcolour >= 0) {
+        set_colour(fe, fillcolour);
+        gdk_draw_arc(fe->pixmap, fe->gc, TRUE,
+                     cx - radius, cy - radius,
+                     2 * radius, 2 * radius, 0, 360 * 64);
+    }
+
+    assert(outlinecolour >= 0);
+    set_colour(fe, outlinecolour);
+    gdk_draw_arc(fe->pixmap, fe->gc, FALSE,
+                 cx - radius, cy - radius,
+                 2 * radius, 2 * radius, 0, 360 * 64);
+}
+
+static void setup_blitter(blitter *bl, int w, int h)
+{
+    /*
+     * We can't create the pixmap right now, because fe->window
+     * might not yet exist. So we just cache w and h and create it
+     * during the firs call to blitter_save.
+     */
+    bl->pixmap = NULL;
+}
+
+static void teardown_blitter(blitter *bl)
+{
+    if (bl->pixmap)
+        gdk_pixmap_unref(bl->pixmap);
+}
+
+static void do_blitter_save(frontend *fe, blitter *bl, int x, int y)
+{
+    if (!bl->pixmap)
+        bl->pixmap = gdk_pixmap_new(fe->area->window, bl->w, bl->h, -1);
+    gdk_draw_pixmap(bl->pixmap,
+                    fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)],
+                    fe->pixmap,
+                    x, y, 0, 0, bl->w, bl->h);
+}
+
+static void do_blitter_load(frontend *fe, blitter *bl, int x, int y)
+{
+    assert(bl->pixmap);
+    gdk_draw_pixmap(fe->pixmap,
+                    fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)],
+                    bl->pixmap,
+                    0, 0, x, y, bl->w, bl->h);
+}
+
+static void clear_backing_store(frontend *fe)
+{
+    fe->pixmap = NULL;
+}
+
+static void setup_backing_store(frontend *fe)
+{
+    GdkGC *gc;
+
+    fe->pixmap = gdk_pixmap_new(fe->area->window, fe->pw, fe->ph, -1);
+
+    gc = gdk_gc_new(fe->area->window);
+    gdk_gc_set_foreground(gc, &fe->colours[0]);
+    gdk_draw_rectangle(fe->pixmap, gc, 1, 0, 0, fe->pw, fe->ph);
+    gdk_draw_rectangle(fe->area->window, gc, 1, 0, 0, fe->w, fe->h);
+    gdk_gc_unref(gc);
+}
+
+static int backing_store_ok(frontend *fe)
+{
+    return (!!fe->pixmap);
+}
+
+static void teardown_backing_store(frontend *fe)
+{
+    gdk_pixmap_unref(fe->pixmap);
+    fe->pixmap = NULL;
+}
+
+#endif
+
+#ifndef USE_CAIRO_WITHOUT_PIXMAP
+static void repaint_rectangle(frontend *fe, GtkWidget *widget,
+                              int x, int y, int w, int h)
+{
+    GdkGC *gc = gdk_gc_new(gtk_widget_get_window(widget));
+#ifdef USE_CAIRO
+    gdk_gc_set_foreground(gc, &fe->background);
+#else
+    gdk_gc_set_foreground(gc, &fe->colours[fe->backgroundindex]);
+#endif
+    if (x < fe->ox) {
+        gdk_draw_rectangle(gtk_widget_get_window(widget), gc,
+                           TRUE, x, y, fe->ox - x, h);
+        w -= (fe->ox - x);
+        x = fe->ox;
+    }
+    if (y < fe->oy) {
+        gdk_draw_rectangle(gtk_widget_get_window(widget), gc,
+                           TRUE, x, y, w, fe->oy - y);
+        h -= (fe->oy - y);
+        y = fe->oy;
+    }
+    if (w > fe->pw) {
+        gdk_draw_rectangle(gtk_widget_get_window(widget), gc,
+                           TRUE, x + fe->pw, y, w - fe->pw, h);
+        w = fe->pw;
+    }
+    if (h > fe->ph) {
+        gdk_draw_rectangle(gtk_widget_get_window(widget), gc,
+                           TRUE, x, y + fe->ph, w, h - fe->ph);
+        h = fe->ph;
+    }
+    gdk_draw_pixmap(gtk_widget_get_window(widget), gc, fe->pixmap,
+                    x - fe->ox, y - fe->oy, x, y, w, h);
+    gdk_gc_unref(gc);
+}
+#endif
+
+/* ----------------------------------------------------------------------
+ * Pango font functions.
+ */
+
+#ifdef USE_PANGO
+
+static void add_font(frontend *fe, int index, int fonttype, int fontsize)
+{
+    /*
+     * Use Pango to find the closest match to the requested
+     * font.
+     */
+    PangoFontDescription *fd;
+
+    fd = pango_font_description_new();
+    /* `Monospace' and `Sans' are meta-families guaranteed to exist */
+    pango_font_description_set_family(fd, fonttype == FONT_FIXED ?
+                                      "Monospace" : "Sans");
+    pango_font_description_set_weight(fd, PANGO_WEIGHT_BOLD);
+    /*
+     * I found some online Pango documentation which
+     * described a function called
+     * pango_font_description_set_absolute_size(), which is
+     * _exactly_ what I want here. Unfortunately, none of
+     * my local Pango installations have it (presumably
+     * they're too old), so I'm going to have to hack round
+     * it by figuring out the point size myself. This
+     * limits me to X and probably also breaks in later
+     * Pango installations, so ideally I should add another
+     * CHECK_VERSION type ifdef and use set_absolute_size
+     * where available. All very annoying.
+     */
+#ifdef HAVE_SENSIBLE_ABSOLUTE_SIZE_FUNCTION
+    pango_font_description_set_absolute_size(fd, PANGO_SCALE*fontsize);
+#else
+    {
+        Display *d = GDK_DISPLAY();
+        int s = DefaultScreen(d);
+        double resolution =
+            (PANGO_SCALE * 72.27 / 25.4) *
+            ((double) DisplayWidthMM(d, s) / DisplayWidth (d, s));
+        pango_font_description_set_size(fd, resolution * fontsize);
+    }
+#endif
+    fe->fonts[index].desc = fd;
+}
+
+static void align_and_draw_text(frontend *fe,
+                                int index, int align, int x, int y,
+                                const char *text)
+{
+    PangoLayout *layout;
+    PangoRectangle rect;
+
+    layout = make_pango_layout(fe);
+
+    /*
+     * Create a layout.
+     */
+    pango_layout_set_font_description(layout, fe->fonts[index].desc);
+    pango_layout_set_text(layout, text, strlen(text));
+    pango_layout_get_pixel_extents(layout, NULL, &rect);
+
+    if (align & ALIGN_VCENTRE)
+        rect.y -= rect.height / 2;
+    else
+        rect.y -= rect.height;
+
+    if (align & ALIGN_HCENTRE)
+        rect.x -= rect.width / 2;
+    else if (align & ALIGN_HRIGHT)
+        rect.x -= rect.width;
+
+    draw_pango_layout(fe, layout, rect.x + x, rect.y + y);
+
+    g_object_unref(layout);
+}
+
+#endif
+
+/* ----------------------------------------------------------------------
+ * Old-fashioned font functions.
+ */
+
+#ifndef USE_PANGO
+
+static void add_font(int index, int fonttype, int fontsize)
+{
+    /*
+     * In GTK 1.2, I don't know of any plausible way to
+     * pick a suitable font, so I'm just going to be
+     * tedious.
+     */
+    fe->fonts[i].font = gdk_font_load(fonttype == FONT_FIXED ?
+                                      "fixed" : "variable");
+}
+
+static void align_and_draw_text(int index, int align, int x, int y,
+                                const char *text)
+{
+    int lb, rb, wid, asc, desc;
+
+    /*
+     * Measure vertical string extents with respect to the same
+     * string always...
+     */
+    gdk_string_extents(fe->fonts[i].font,
+                       "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+                       &lb, &rb, &wid, &asc, &desc);
+    if (align & ALIGN_VCENTRE)
+        y += asc - (asc+desc)/2;
+    else
+        y += asc;
+
+    /*
+     * ... but horizontal extents with respect to the provided
+     * string. This means that multiple pieces of text centred
+     * on the same y-coordinate don't have different baselines.
+     */
+    gdk_string_extents(fe->fonts[i].font, text,
+                       &lb, &rb, &wid, &asc, &desc);
+
+    if (align & ALIGN_HCENTRE)
+        x -= wid / 2;
+    else if (align & ALIGN_HRIGHT)
+        x -= wid;
+
+    /*
+     * Actually draw the text.
+     */
+    gdk_draw_string(fe->pixmap, fe->fonts[i].font, fe->gc, x, y, text);
+}
+
+#endif
+
+/* ----------------------------------------------------------------------
+ * The exported drawing functions.
+ */
+
+void gtk_start_draw(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+    fe->bbox_l = fe->w;
+    fe->bbox_r = 0;
+    fe->bbox_u = fe->h;
+    fe->bbox_d = 0;
+    setup_drawing(fe);
+}
+
+void gtk_clip(void *handle, int x, int y, int w, int h)
+{
+    frontend *fe = (frontend *)handle;
+    do_clip(fe, x, y, w, h);
+}
+
+void gtk_unclip(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+    do_unclip(fe);
+}
+
+void gtk_draw_text(void *handle, int x, int y, int fonttype, int fontsize,
+                   int align, int colour, char *text)
+{
+    frontend *fe = (frontend *)handle;
+    int i;
+
+    /*
+     * Find or create the font.
+     */
+    for (i = 0; i < fe->nfonts; i++)
+        if (fe->fonts[i].type == fonttype && fe->fonts[i].size == fontsize)
+            break;
+
+    if (i == fe->nfonts) {
+        if (fe->fontsize <= fe->nfonts) {
+            fe->fontsize = fe->nfonts + 10;
+            fe->fonts = sresize(fe->fonts, fe->fontsize, struct font);
+        }
+
+        fe->nfonts++;
+
+        fe->fonts[i].type = fonttype;
+        fe->fonts[i].size = fontsize;
+        add_font(fe, i, fonttype, fontsize);
+    }
+
+    /*
+     * Do the job.
+     */
+    set_colour(fe, colour);
+    align_and_draw_text(fe, i, align, x, y, text);
+}
+
+void gtk_draw_rect(void *handle, int x, int y, int w, int h, int colour)
+{
+    frontend *fe = (frontend *)handle;
+    set_colour(fe, colour);
+    do_draw_rect(fe, x, y, w, h);
+}
+
+void gtk_draw_line(void *handle, int x1, int y1, int x2, int y2, int colour)
+{
+    frontend *fe = (frontend *)handle;
+    set_colour(fe, colour);
+    do_draw_line(fe, x1, y1, x2, y2);
+}
+
+void gtk_draw_thick_line(void *handle, float thickness,
+                         float x1, float y1, float x2, float y2, int colour)
+{
+    frontend *fe = (frontend *)handle;
+    set_colour(fe, colour);
+    do_draw_thick_line(fe, thickness, x1, y1, x2, y2);
+}
+
+void gtk_draw_poly(void *handle, int *coords, int npoints,
+                   int fillcolour, int outlinecolour)
+{
+    frontend *fe = (frontend *)handle;
+    do_draw_poly(fe, coords, npoints, fillcolour, outlinecolour);
+}
+
+void gtk_draw_circle(void *handle, int cx, int cy, int radius,
+                     int fillcolour, int outlinecolour)
+{
+    frontend *fe = (frontend *)handle;
+    do_draw_circle(fe, cx, cy, radius, fillcolour, outlinecolour);
+}
+
+blitter *gtk_blitter_new(void *handle, int w, int h)
+{
+    blitter *bl = snew(blitter);
+    setup_blitter(bl, w, h);
+    bl->w = w;
+    bl->h = h;
+    return bl;
+}
+
+void gtk_blitter_free(void *handle, blitter *bl)
+{
+    teardown_blitter(bl);
+    sfree(bl);
+}
+
+void gtk_blitter_save(void *handle, blitter *bl, int x, int y)
+{
+    frontend *fe = (frontend *)handle;
+    do_blitter_save(fe, bl, x, y);
+    bl->x = x;
+    bl->y = y;
+}
+
+void gtk_blitter_load(void *handle, blitter *bl, int x, int y)
+{
+    frontend *fe = (frontend *)handle;
+    if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) {
+        x = bl->x;
+        y = bl->y;
+    }
+    do_blitter_load(fe, bl, x, y);
+}
+
+void gtk_draw_update(void *handle, int x, int y, int w, int h)
+{
+    frontend *fe = (frontend *)handle;
+    if (fe->bbox_l > x  ) fe->bbox_l = x  ;
+    if (fe->bbox_r < x+w) fe->bbox_r = x+w;
+    if (fe->bbox_u > y  ) fe->bbox_u = y  ;
+    if (fe->bbox_d < y+h) fe->bbox_d = y+h;
+}
+
+void gtk_end_draw(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+
+    teardown_drawing(fe);
+
+    if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d) {
+#ifdef USE_CAIRO_WITHOUT_PIXMAP
+        gtk_widget_queue_draw_area(fe->area,
+                                   fe->bbox_l - 1 + fe->ox,
+                                   fe->bbox_u - 1 + fe->oy,
+                                   fe->bbox_r - fe->bbox_l + 2,
+                                   fe->bbox_d - fe->bbox_u + 2);
+#else
+        repaint_rectangle(fe, fe->area,
+                          fe->bbox_l - 1 + fe->ox,
+                          fe->bbox_u - 1 + fe->oy,
+                          fe->bbox_r - fe->bbox_l + 2,
+                          fe->bbox_d - fe->bbox_u + 2);
+#endif
+    }
+}
+
+#ifdef USE_PANGO
+char *gtk_text_fallback(void *handle, const char *const *strings, int nstrings)
+{
+    /*
+     * We assume Pango can cope with any UTF-8 likely to be emitted
+     * by a puzzle.
+     */
+    return dupstr(strings[0]);
+}
+#endif
+
+const struct drawing_api gtk_drawing = {
+    gtk_draw_text,
+    gtk_draw_rect,
+    gtk_draw_line,
+    gtk_draw_poly,
+    gtk_draw_circle,
+    gtk_draw_update,
+    gtk_clip,
+    gtk_unclip,
+    gtk_start_draw,
+    gtk_end_draw,
+    gtk_status_bar,
+    gtk_blitter_new,
+    gtk_blitter_free,
+    gtk_blitter_save,
+    gtk_blitter_load,
+    NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */
+    NULL, NULL,                        /* line_width, line_dotted */
+#ifdef USE_PANGO
+    gtk_text_fallback,
+#else
+    NULL,
+#endif
+#ifdef NO_THICK_LINE
+    NULL,
+#else
+    gtk_draw_thick_line,
+#endif
+};
+
+static void destroy(GtkWidget *widget, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    deactivate_timer(fe);
+    midend_free(fe->me);
+    gtk_main_quit();
+}
+
+static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    int keyval;
+    int shift = (event->state & GDK_SHIFT_MASK) ? MOD_SHFT : 0;
+    int ctrl = (event->state & GDK_CONTROL_MASK) ? MOD_CTRL : 0;
+
+    if (!backing_store_ok(fe))
+        return TRUE;
+
+#if !GTK_CHECK_VERSION(2,0,0)
+    /* Gtk 1.2 passes a key event to this function even if it's also
+     * defined as an accelerator.
+     * Gtk 2 doesn't do this, and this function appears not to exist there. */
+    if (fe->accelgroup &&
+        gtk_accel_group_get_entry(fe->accelgroup,
+        event->keyval, event->state))
+        return TRUE;
+#endif
+
+    /* Handle mnemonics. */
+    if (gtk_window_activate_key(GTK_WINDOW(fe->window), event))
+        return TRUE;
+
+    if (event->keyval == GDK_KEY_Up)
+        keyval = shift | ctrl | CURSOR_UP;
+    else if (event->keyval == GDK_KEY_KP_Up ||
+             event->keyval == GDK_KEY_KP_8)
+        keyval = MOD_NUM_KEYPAD | '8';
+    else if (event->keyval == GDK_KEY_Down)
+        keyval = shift | ctrl | CURSOR_DOWN;
+    else if (event->keyval == GDK_KEY_KP_Down ||
+             event->keyval == GDK_KEY_KP_2)
+        keyval = MOD_NUM_KEYPAD | '2';
+    else if (event->keyval == GDK_KEY_Left)
+        keyval = shift | ctrl | CURSOR_LEFT;
+    else if (event->keyval == GDK_KEY_KP_Left ||
+             event->keyval == GDK_KEY_KP_4)
+        keyval = MOD_NUM_KEYPAD | '4';
+    else if (event->keyval == GDK_KEY_Right)
+        keyval = shift | ctrl | CURSOR_RIGHT;
+    else if (event->keyval == GDK_KEY_KP_Right ||
+             event->keyval == GDK_KEY_KP_6)
+        keyval = MOD_NUM_KEYPAD | '6';
+    else if (event->keyval == GDK_KEY_KP_Home ||
+             event->keyval == GDK_KEY_KP_7)
+        keyval = MOD_NUM_KEYPAD | '7';
+    else if (event->keyval == GDK_KEY_KP_End ||
+             event->keyval == GDK_KEY_KP_1)
+        keyval = MOD_NUM_KEYPAD | '1';
+    else if (event->keyval == GDK_KEY_KP_Page_Up ||
+             event->keyval == GDK_KEY_KP_9)
+        keyval = MOD_NUM_KEYPAD | '9';
+    else if (event->keyval == GDK_KEY_KP_Page_Down ||
+             event->keyval == GDK_KEY_KP_3)
+        keyval = MOD_NUM_KEYPAD | '3';
+    else if (event->keyval == GDK_KEY_KP_Insert ||
+             event->keyval == GDK_KEY_KP_0)
+        keyval = MOD_NUM_KEYPAD | '0';
+    else if (event->keyval == GDK_KEY_KP_Begin ||
+             event->keyval == GDK_KEY_KP_5)
+        keyval = MOD_NUM_KEYPAD | '5';
+    else if (event->keyval == GDK_KEY_BackSpace ||
+             event->keyval == GDK_KEY_Delete ||
+             event->keyval == GDK_KEY_KP_Delete)
+        keyval = '\177';
+    else if (event->string[0] && !event->string[1])
+        keyval = (unsigned char)event->string[0];
+    else
+        keyval = -1;
+
+    if (keyval >= 0 &&
+        !midend_process_key(fe->me, 0, 0, keyval))
+        gtk_widget_destroy(fe->window);
+
+    return TRUE;
+}
+
+static gint button_event(GtkWidget *widget, GdkEventButton *event,
+                         gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    int button;
+
+    if (!backing_store_ok(fe))
+        return TRUE;
+
+    if (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE)
+        return TRUE;
+
+    if (event->button == 2 || (event->state & GDK_SHIFT_MASK))
+        button = MIDDLE_BUTTON;
+    else if (event->button == 3 || (event->state & GDK_MOD1_MASK))
+        button = RIGHT_BUTTON;
+    else if (event->button == 1)
+        button = LEFT_BUTTON;
+    else if (event->button == 8 && event->type == GDK_BUTTON_PRESS)
+        button = 'u';
+    else if (event->button == 9 && event->type == GDK_BUTTON_PRESS)
+        button = 'r';
+    else
+        return FALSE;                  /* don't even know what button! */
+
+    if (event->type == GDK_BUTTON_RELEASE && button >= LEFT_BUTTON)
+        button += LEFT_RELEASE - LEFT_BUTTON;
+
+    if (!midend_process_key(fe->me, event->x - fe->ox,
+                            event->y - fe->oy, button))
+        gtk_widget_destroy(fe->window);
+
+    return TRUE;
+}
+
+static gint motion_event(GtkWidget *widget, GdkEventMotion *event,
+                         gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    int button;
+
+    if (!backing_store_ok(fe))
+        return TRUE;
+
+    if (event->state & (GDK_BUTTON2_MASK | GDK_SHIFT_MASK))
+        button = MIDDLE_DRAG;
+    else if (event->state & GDK_BUTTON1_MASK)
+        button = LEFT_DRAG;
+    else if (event->state & GDK_BUTTON3_MASK)
+        button = RIGHT_DRAG;
+    else
+        return FALSE;                  /* don't even know what button! */
+
+    if (!midend_process_key(fe->me, event->x - fe->ox,
+                            event->y - fe->oy, button))
+        gtk_widget_destroy(fe->window);
+#if GTK_CHECK_VERSION(2,12,0)
+    gdk_event_request_motions(event);
+#else
+    gdk_window_get_pointer(gtk_widget_get_window(widget), NULL, NULL, NULL);
+#endif
+
+    return TRUE;
+}
+
+#if GTK_CHECK_VERSION(3,0,0)
+static gint draw_area(GtkWidget *widget, cairo_t *cr, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    GdkRectangle dirtyrect;
+
+    gdk_cairo_get_clip_rectangle(cr, &dirtyrect);
+    cairo_set_source_surface(cr, fe->image, fe->ox, fe->oy);
+    cairo_rectangle(cr, dirtyrect.x, dirtyrect.y,
+                    dirtyrect.width, dirtyrect.height);
+    cairo_fill(cr);
+
+    return TRUE;
+}
+#else
+static gint expose_area(GtkWidget *widget, GdkEventExpose *event,
+                        gpointer data)
+{
+    frontend *fe = (frontend *)data;
+
+    if (backing_store_ok(fe)) {
+#ifdef USE_CAIRO_WITHOUT_PIXMAP
+        cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget));
+        cairo_set_source_surface(cr, fe->image, fe->ox, fe->oy);
+        cairo_rectangle(cr, event->area.x, event->area.y,
+                        event->area.width, event->area.height);
+        cairo_fill(cr);
+        cairo_destroy(cr);
+#else
+        repaint_rectangle(fe, widget,
+                          event->area.x, event->area.y,
+                          event->area.width, event->area.height);
+#endif
+    }
+    return TRUE;
+}
+#endif
+
+static gint map_window(GtkWidget *widget, GdkEvent *event,
+                       gpointer data)
+{
+    frontend *fe = (frontend *)data;
+
+    /*
+     * Apparently we need to do this because otherwise the status
+     * bar will fail to update immediately. Annoying, but there we
+     * go.
+     */
+    gtk_widget_queue_draw(fe->window);
+
+    return TRUE;
+}
+
+static gint configure_area(GtkWidget *widget,
+                           GdkEventConfigure *event, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    int x, y;
+    int oldw = fe->w, oldpw = fe->pw, oldh = fe->h, oldph = fe->ph;
+
+    x = event->width;
+    y = event->height;
+    fe->w = x;
+    fe->h = y;
+    midend_size(fe->me, &x, &y, TRUE);
+    fe->pw = x;
+    fe->ph = y;
+    fe->ox = (fe->w - fe->pw) / 2;
+    fe->oy = (fe->h - fe->ph) / 2;
+
+    if (oldw != fe->w || oldpw != fe->pw ||
+        oldh != fe->h || oldph != fe->ph || !backing_store_ok(fe)) {
+        if (backing_store_ok(fe))
+            teardown_backing_store(fe);
+        setup_backing_store(fe);
+    }
+
+    midend_force_redraw(fe->me);
+
+    return TRUE;
+}
+
+static gint timer_func(gpointer data)
+{
+    frontend *fe = (frontend *)data;
+
+    if (fe->timer_active) {
+        struct timeval now;
+        float elapsed;
+        gettimeofday(&now, NULL);
+        elapsed = ((now.tv_usec - fe->last_time.tv_usec) * 0.000001F +
+                   (now.tv_sec - fe->last_time.tv_sec));
+        midend_timer(fe->me, elapsed);  /* may clear timer_active */
+        fe->last_time = now;
+    }
+
+    return fe->timer_active;
+}
+
+void deactivate_timer(frontend *fe)
+{
+    if (!fe)
+        return;                        /* can happen due to --generate */
+    if (fe->timer_active)
+        g_source_remove(fe->timer_id);
+    fe->timer_active = FALSE;
+}
+
+void activate_timer(frontend *fe)
+{
+    if (!fe)
+        return;                        /* can happen due to --generate */
+    if (!fe->timer_active) {
+        fe->timer_id = g_timeout_add(20, timer_func, fe);
+        gettimeofday(&fe->last_time, NULL);
+    }
+    fe->timer_active = TRUE;
+}
+
+static void window_destroy(GtkWidget *widget, gpointer data)
+{
+    gtk_main_quit();
+}
+
+static int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
+{
+    GObject *cancelbutton = G_OBJECT(data);
+
+    /*
+     * `Escape' effectively clicks the cancel button
+     */
+    if (event->keyval == GDK_KEY_Escape) {
+        g_signal_emit_by_name(cancelbutton, "clicked");
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+enum { MB_OK, MB_YESNO };
+
+static void align_label(GtkLabel *label, double x, double y)
+{
+#if GTK_CHECK_VERSION(3,16,0)
+    gtk_label_set_xalign(label, x);
+    gtk_label_set_yalign(label, y);
+#elif GTK_CHECK_VERSION(3,14,0)
+    gtk_widget_set_halign(GTK_WIDGET(label),
+                          x == 0 ? GTK_ALIGN_START :
+                          x == 1 ? GTK_ALIGN_END : GTK_ALIGN_CENTER);
+    gtk_widget_set_valign(GTK_WIDGET(label),
+                          y == 0 ? GTK_ALIGN_START :
+                          y == 1 ? GTK_ALIGN_END : GTK_ALIGN_CENTER);
+#else
+    gtk_misc_set_alignment(GTK_MISC(label), x, y);
+#endif
+}
+
+#if GTK_CHECK_VERSION(3,0,0)
+int message_box(GtkWidget *parent, char *title, char *msg, int centre,
+                int type)
+{
+    GtkWidget *window;
+    gint ret;
+
+    window = gtk_message_dialog_new
+        (GTK_WINDOW(parent),
+         (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
+         (type == MB_OK ? GTK_MESSAGE_INFO : GTK_MESSAGE_QUESTION),
+         (type == MB_OK ? GTK_BUTTONS_OK   : GTK_BUTTONS_YES_NO),
+         "%s", msg);
+    gtk_window_set_title(GTK_WINDOW(window), title);
+    ret = gtk_dialog_run(GTK_DIALOG(window));
+    gtk_widget_destroy(window);
+    return (type == MB_OK ? TRUE : (ret == GTK_RESPONSE_YES));
+}
+#else /* GTK_CHECK_VERSION(3,0,0) */
+static void msgbox_button_clicked(GtkButton *button, gpointer data)
+{
+    GtkWidget *window = GTK_WIDGET(data);
+    int v, *ip;
+
+    ip = (int *)g_object_get_data(G_OBJECT(window), "user-data");
+    v = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "user-data"));
+    *ip = v;
+
+    gtk_widget_destroy(GTK_WIDGET(data));
+}
+
+int message_box(GtkWidget *parent, char *title, char *msg, int centre,
+                int type)
+{
+    GtkWidget *window, *hbox, *text, *button;
+    char *titles;
+    int i, def, cancel;
+
+    window = gtk_dialog_new();
+    text = gtk_label_new(msg);
+    align_label(GTK_LABEL(text), 0.0, 0.0);
+    hbox = gtk_hbox_new(FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(hbox), text, FALSE, FALSE, 20);
+    gtk_box_pack_start
+        (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(window))),
+         hbox, FALSE, FALSE, 20);
+    gtk_widget_show(text);
+    gtk_widget_show(hbox);
+    gtk_window_set_title(GTK_WINDOW(window), title);
+    gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
+
+    if (type == MB_OK) {
+        titles = LABEL_OK "\0";
+        def = cancel = 0;
+    } else {
+        assert(type == MB_YESNO);
+        titles = LABEL_NO "\0" LABEL_YES "\0";
+        def = 1;
+        cancel = 0;
+    }
+    i = 0;
+    
+    while (*titles) {
+        button = gtk_button_new_with_our_label(titles);
+        gtk_box_pack_end
+            (GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(window))),
+             button, FALSE, FALSE, 0);
+        gtk_widget_show(button);
+        if (i == def) {
+            gtk_widget_set_can_default(button, TRUE);
+            gtk_window_set_default(GTK_WINDOW(window), button);
+        }
+        if (i == cancel) {
+            g_signal_connect(G_OBJECT(window), "key_press_event",
+                             G_CALLBACK(win_key_press), button);
+        }
+        g_signal_connect(G_OBJECT(button), "clicked",
+                         G_CALLBACK(msgbox_button_clicked), window);
+        g_object_set_data(G_OBJECT(button), "user-data",
+                          GINT_TO_POINTER(i));
+        titles += strlen(titles)+1;
+        i++;
+    }
+    g_object_set_data(G_OBJECT(window), "user-data", &i);
+    g_signal_connect(G_OBJECT(window), "destroy",
+                     G_CALLBACK(window_destroy), NULL);
+    gtk_window_set_modal(GTK_WINDOW(window), TRUE);
+    gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(parent));
+    /* set_transient_window_pos(parent, window); */
+    gtk_widget_show(window);
+    i = -1;
+    gtk_main();
+    return (type == MB_YESNO ? i == 1 : TRUE);
+}
+#endif /* GTK_CHECK_VERSION(3,0,0) */
+
+void error_box(GtkWidget *parent, char *msg)
+{
+    message_box(parent, "Error", msg, FALSE, MB_OK);
+}
+
+static void config_ok_button_clicked(GtkButton *button, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    char *err;
+
+    err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
+
+    if (err)
+        error_box(fe->cfgbox, err);
+    else {
+        fe->cfgret = TRUE;
+        gtk_widget_destroy(fe->cfgbox);
+        changed_preset(fe);
+    }
+}
+
+static void config_cancel_button_clicked(GtkButton *button, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+
+    gtk_widget_destroy(fe->cfgbox);
+}
+
+static int editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data)
+{
+    /*
+     * GtkEntry has a nasty habit of eating the Return key, which
+     * is unhelpful since it doesn't actually _do_ anything with it
+     * (it calls gtk_widget_activate, but our edit boxes never need
+     * activating). So I catch Return before GtkEntry sees it, and
+     * pass it straight on to the parent widget. Effect: hitting
+     * Return in an edit box will now activate the default button
+     * in the dialog just like it will everywhere else.
+     */
+    if (event->keyval == GDK_KEY_Return &&
+        gtk_widget_get_parent(widget) != NULL) {
+        gint return_val;
+        g_signal_stop_emission_by_name(G_OBJECT(widget), "key_press_event");
+        g_signal_emit_by_name(G_OBJECT(gtk_widget_get_parent(widget)),
+                              "key_press_event", event, &return_val);
+        return return_val;
+    }
+    return FALSE;
+}
+
+static void editbox_changed(GtkEditable *ed, gpointer data)
+{
+    config_item *i = (config_item *)data;
+
+    sfree(i->sval);
+    i->sval = dupstr(gtk_entry_get_text(GTK_ENTRY(ed)));
+}
+
+static void button_toggled(GtkToggleButton *tb, gpointer data)
+{
+    config_item *i = (config_item *)data;
+
+    i->ival = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb));
+}
+
+static void droplist_sel(GtkComboBox *combo, gpointer data)
+{
+    config_item *i = (config_item *)data;
+
+    i->ival = gtk_combo_box_get_active(combo);
+}
+
+static int get_config(frontend *fe, int which)
+{
+    GtkWidget *w, *table, *cancel;
+    GtkBox *content_box, *button_box;
+    char *title;
+    config_item *i;
+    int y;
+
+    fe->cfg = midend_get_config(fe->me, which, &title);
+    fe->cfg_which = which;
+    fe->cfgret = FALSE;
+
+#if GTK_CHECK_VERSION(3,0,0)
+    /* GtkDialog isn't quite flexible enough */
+    fe->cfgbox = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    content_box = GTK_BOX(gtk_vbox_new(FALSE, 8));
+    g_object_set(G_OBJECT(content_box), "margin", 8, (const char *)NULL);
+    gtk_widget_show(GTK_WIDGET(content_box));
+    gtk_container_add(GTK_CONTAINER(fe->cfgbox), GTK_WIDGET(content_box));
+    button_box = GTK_BOX(gtk_hbox_new(FALSE, 8));
+    gtk_widget_show(GTK_WIDGET(button_box));
+    gtk_box_pack_end(content_box, GTK_WIDGET(button_box), FALSE, FALSE, 0);
+    {
+        GtkWidget *sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
+        gtk_widget_show(sep);
+        gtk_box_pack_end(content_box, sep, FALSE, FALSE, 0);
+    }
+#else
+    fe->cfgbox = gtk_dialog_new();
+    content_box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(fe->cfgbox)));
+    button_box = GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(fe->cfgbox)));
+#endif
+    gtk_window_set_title(GTK_WINDOW(fe->cfgbox), title);
+    sfree(title);
+
+    w = gtk_button_new_with_our_label(LABEL_CANCEL);
+    gtk_box_pack_end(button_box, w, FALSE, FALSE, 0);
+    gtk_widget_show(w);
+    g_signal_connect(G_OBJECT(w), "clicked",
+                     G_CALLBACK(config_cancel_button_clicked), fe);
+    cancel = w;
+
+    w = gtk_button_new_with_our_label(LABEL_OK);
+    gtk_box_pack_end(button_box, w, FALSE, FALSE, 0);
+    gtk_widget_show(w);
+    gtk_widget_set_can_default(w, TRUE);
+    gtk_window_set_default(GTK_WINDOW(fe->cfgbox), w);
+    g_signal_connect(G_OBJECT(w), "clicked",
+                     G_CALLBACK(config_ok_button_clicked), fe);
+
+#if GTK_CHECK_VERSION(3,0,0)
+    table = gtk_grid_new();
+#else
+    table = gtk_table_new(1, 2, FALSE);
+#endif
+    y = 0;
+    gtk_box_pack_start(content_box, table, FALSE, FALSE, 0);
+    gtk_widget_show(table);
+
+    for (i = fe->cfg; i->type != C_END; i++) {
+#if !GTK_CHECK_VERSION(3,0,0)
+        gtk_table_resize(GTK_TABLE(table), y+1, 2);
+#endif
+
+        switch (i->type) {
+          case C_STRING:
+            /*
+             * Edit box with a label beside it.
+             */
+
+            w = gtk_label_new(i->name);
+            align_label(GTK_LABEL(w), 0.0, 0.5);
+#if GTK_CHECK_VERSION(3,0,0)
+            gtk_grid_attach(GTK_GRID(table), w, 0, y, 1, 1);
+#else
+            gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
+                             GTK_SHRINK | GTK_FILL,
+                             GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+                             3, 3);
+#endif
+            gtk_widget_show(w);
+
+            w = gtk_entry_new();
+#if GTK_CHECK_VERSION(3,0,0)
+            gtk_grid_attach(GTK_GRID(table), w, 1, y, 1, 1);
+            g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
+#else
+            gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
+                             GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+                             GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+                             3, 3);
+#endif
+            gtk_entry_set_text(GTK_ENTRY(w), i->sval);
+            g_signal_connect(G_OBJECT(w), "changed",
+                             G_CALLBACK(editbox_changed), i);
+            g_signal_connect(G_OBJECT(w), "key_press_event",
+                             G_CALLBACK(editbox_key), NULL);
+            gtk_widget_show(w);
+
+            break;
+
+          case C_BOOLEAN:
+            /*
+             * Simple checkbox.
+             */
+            w = gtk_check_button_new_with_label(i->name);
+            g_signal_connect(G_OBJECT(w), "toggled",
+                             G_CALLBACK(button_toggled), i);
+#if GTK_CHECK_VERSION(3,0,0)
+            gtk_grid_attach(GTK_GRID(table), w, 0, y, 2, 1);
+            g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
+#else
+            gtk_table_attach(GTK_TABLE(table), w, 0, 2, y, y+1,
+                             GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+                             GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+                             3, 3);
+#endif
+            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), i->ival);
+            gtk_widget_show(w);
+            break;
+
+          case C_CHOICES:
+            /*
+             * Drop-down list (GtkComboBox).
+             */
+
+            w = gtk_label_new(i->name);
+            align_label(GTK_LABEL(w), 0.0, 0.5);
+#if GTK_CHECK_VERSION(3,0,0)
+            gtk_grid_attach(GTK_GRID(table), w, 0, y, 1, 1);
+#else
+            gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
+                             GTK_SHRINK | GTK_FILL,
+                             GTK_EXPAND | GTK_SHRINK | GTK_FILL ,
+                             3, 3);
+#endif
+            gtk_widget_show(w);
+
+            {
+                int c;
+                char *p, *q, *name;
+                GtkListStore *model;
+                GtkCellRenderer *cr;
+                GtkTreeIter iter;
+
+                model = gtk_list_store_new(1, G_TYPE_STRING);
+
+                c = *i->sval;
+                p = i->sval+1;
+
+                while (*p) {
+                    q = p;
+                    while (*q && *q != c)
+                        q++;
+
+                    name = snewn(q-p+1, char);
+                    strncpy(name, p, q-p);
+                    name[q-p] = '\0';
+
+                    if (*q) q++;       /* eat delimiter */
+
+                    gtk_list_store_append(model, &iter);
+                    gtk_list_store_set(model, &iter, 0, name, -1);
+
+                    p = q;
+                }
+
+                w = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
+
+                gtk_combo_box_set_active(GTK_COMBO_BOX(w), i->ival);
+
+                cr = gtk_cell_renderer_text_new();
+                gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(w), cr, TRUE);
+                gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(w), cr,
+                                               "text", 0, NULL);
+
+                g_signal_connect(G_OBJECT(w), "changed",
+                                 G_CALLBACK(droplist_sel), i);
+            }
+
+#if GTK_CHECK_VERSION(3,0,0)
+            gtk_grid_attach(GTK_GRID(table), w, 1, y, 1, 1);
+            g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
+#else
+            gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
+                             GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+                             GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+                             3, 3);
+#endif
+            gtk_widget_show(w);
+            break;
+        }
+
+        y++;
+    }
+
+    g_signal_connect(G_OBJECT(fe->cfgbox), "destroy",
+                     G_CALLBACK(window_destroy), NULL);
+    g_signal_connect(G_OBJECT(fe->cfgbox), "key_press_event",
+                     G_CALLBACK(win_key_press), cancel);
+    gtk_window_set_modal(GTK_WINDOW(fe->cfgbox), TRUE);
+    gtk_window_set_transient_for(GTK_WINDOW(fe->cfgbox),
+                                 GTK_WINDOW(fe->window));
+    /* set_transient_window_pos(fe->window, fe->cfgbox); */
+    gtk_widget_show(fe->cfgbox);
+    gtk_main();
+
+    free_cfg(fe->cfg);
+
+    return fe->cfgret;
+}
+
+static void menu_key_event(GtkMenuItem *menuitem, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    int key = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem),
+                                                "user-data"));
+    if (!midend_process_key(fe->me, 0, 0, key))
+        gtk_widget_destroy(fe->window);
+}
+
+static void get_size(frontend *fe, int *px, int *py)
+{
+    int x, y;
+
+    /*
+     * Currently I don't want to make the GTK port scale large
+     * puzzles to fit on the screen. This is because X does permit
+     * extremely large windows and many window managers provide a
+     * means of navigating round them, and the users I consulted
+     * before deciding said that they'd rather have enormous puzzle
+     * windows spanning multiple screen pages than have them
+     * shrunk. I could change my mind later or introduce
+     * configurability; this would be the place to do so, by
+     * replacing the initial values of x and y with the screen
+     * dimensions.
+     */
+    x = INT_MAX;
+    y = INT_MAX;
+    midend_size(fe->me, &x, &y, FALSE);
+    *px = x;
+    *py = y;
+}
+
+#if !GTK_CHECK_VERSION(2,0,0)
+#define gtk_window_resize(win, x, y) \
+        gdk_window_resize(GTK_WIDGET(win)->window, x, y)
+#endif
+
+/*
+ * Called when any other code in this file has changed the
+ * selected game parameters.
+ */
+static void changed_preset(frontend *fe)
+{
+    int n = midend_which_preset(fe->me);
+
+    fe->preset_threaded = TRUE;
+    if (n < 0 && fe->preset_custom) {
+        gtk_check_menu_item_set_active(
+            GTK_CHECK_MENU_ITEM(fe->preset_custom),
+            TRUE);
+    } else {
+        GSList *gs = fe->preset_radio;
+        int i = fe->n_preset_menu_items - 1 - n;
+        if (fe->preset_custom)
+            gs = gs->next;
+        while (i && gs) {
+            i--;
+            gs = gs->next;
+        }
+        if (gs) {
+            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gs->data),
+                                           TRUE);
+        } else for (gs = fe->preset_radio; gs; gs = gs->next) {
+            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gs->data),
+                                           FALSE);
+        }
+    }
+    fe->preset_threaded = FALSE;
+
+    /*
+     * Update the greying on the Copy menu option.
+     */
+    if (fe->copy_menu_item) {
+        int enabled = midend_can_format_as_text_now(fe->me);
+        gtk_widget_set_sensitive(fe->copy_menu_item, enabled);
+    }
+}
+
+#if !GTK_CHECK_VERSION(3,0,0)
+static gboolean not_size_allocated_yet(GtkWidget *w)
+{
+    /*
+     * This function tests whether a widget has not yet taken up space
+     * on the screen which it will occupy in future. (Therefore, it
+     * returns true only if the widget does exist but does not have a
+     * size allocation. A null widget is already taking up all the
+     * space it ever will.)
+     */
+    if (!w)
+        return FALSE;        /* nonexistent widgets aren't a problem */
+
+#if GTK_CHECK_VERSION(2,18,0)  /* skip if no gtk_widget_get_allocation */
+    {
+        GtkAllocation a;
+        gtk_widget_get_allocation(w, &a);
+        if (a.height == 0 || a.width == 0)
+            return TRUE;       /* widget exists but has no size yet */
+    }
+#endif
+
+    return FALSE;
+}
+
+static void try_shrink_drawing_area(frontend *fe)
+{
+    if (fe->drawing_area_shrink_pending &&
+        (!fe->menubar_is_local || !not_size_allocated_yet(fe->menubar)) &&
+        !not_size_allocated_yet(fe->statusbar)) {
+        /*
+         * In order to permit the user to resize the window smaller as
+         * well as bigger, we call this function after the window size
+         * has ended up where we want it. This shouldn't shrink the
+         * window immediately; it just arranges that the next time the
+         * user tries to shrink it, they can.
+         *
+         * However, at puzzle creation time, we defer the first of
+         * these operations until after the menu bar and status bar
+         * are actually visible. On Ubuntu 12.04 I've found that these
+         * can take a while to be displayed, and that it's a mistake
+         * to reduce the drawing area's size allocation before they've
+         * turned up or else the drawing area makes room for them by
+         * shrinking to less than the size we intended.
+         */
+        gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), 1, 1);
+        fe->drawing_area_shrink_pending = FALSE;
+    }
+}
+#endif /* !GTK_CHECK_VERSION(3,0,0) */
+
+static gint configure_window(GtkWidget *widget,
+                             GdkEventConfigure *event, gpointer data)
+{
+#if !GTK_CHECK_VERSION(3,0,0)
+    /*
+     * When the main puzzle window changes size, it might be because
+     * the menu bar or status bar has turned up after starting off
+     * absent, in which case we should have another go at enacting a
+     * pending shrink of the drawing area.
+     */
+    frontend *fe = (frontend *)data;
+    try_shrink_drawing_area(fe);
+#endif
+    return FALSE;
+}
+
+static void resize_fe(frontend *fe)
+{
+    int x, y;
+
+    get_size(fe, &x, &y);
+
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_window_resize_to_geometry(GTK_WINDOW(fe->window), x, y);
+#else
+    fe->drawing_area_shrink_pending = FALSE;
+    gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
+    {
+        GtkRequisition req;
+        gtk_widget_size_request(GTK_WIDGET(fe->window), &req);
+        gtk_window_resize(GTK_WINDOW(fe->window), req.width, req.height);
+    }
+    fe->drawing_area_shrink_pending = TRUE;
+    try_shrink_drawing_area(fe);
+#endif
+}
+
+static void menu_preset_event(GtkMenuItem *menuitem, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    game_params *params =
+        (game_params *)g_object_get_data(G_OBJECT(menuitem), "user-data");
+
+    if (fe->preset_threaded ||
+        (GTK_IS_CHECK_MENU_ITEM(menuitem) &&
+         !gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))))
+        return;
+    midend_set_params(fe->me, params);
+    midend_new_game(fe->me);
+    changed_preset(fe);
+    resize_fe(fe);
+}
+
+GdkAtom compound_text_atom, utf8_string_atom;
+int paste_initialised = FALSE;
+
+static void set_selection(frontend *fe, GdkAtom selection)
+{
+    if (!paste_initialised) {
+        compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", FALSE);
+        utf8_string_atom = gdk_atom_intern("UTF8_STRING", FALSE);
+        paste_initialised = TRUE;
+    }
+
+    /*
+     * For this simple application we can safely assume that the
+     * data passed to this function is pure ASCII, which means we
+     * can return precisely the same stuff for types STRING,
+     * COMPOUND_TEXT or UTF8_STRING.
+     */
+
+    if (gtk_selection_owner_set(fe->area, selection, CurrentTime)) {
+        gtk_selection_clear_targets(fe->area, selection);
+        gtk_selection_add_target(fe->area, selection,
+                                 GDK_SELECTION_TYPE_STRING, 1);
+        gtk_selection_add_target(fe->area, selection, compound_text_atom, 1);
+        gtk_selection_add_target(fe->area, selection, utf8_string_atom, 1);
+    }
+}
+
+void write_clip(frontend *fe, char *data)
+{
+    if (fe->paste_data)
+        sfree(fe->paste_data);
+
+    fe->paste_data = data;
+    fe->paste_data_len = strlen(data);
+
+    set_selection(fe, GDK_SELECTION_PRIMARY);
+    set_selection(fe, GDK_SELECTION_CLIPBOARD);
+}
+
+void selection_get(GtkWidget *widget, GtkSelectionData *seldata,
+                   guint info, guint time_stamp, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    gtk_selection_data_set(seldata, gtk_selection_data_get_target(seldata), 8,
+                           fe->paste_data, fe->paste_data_len);
+}
+
+gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata,
+                     gpointer data)
+{
+    frontend *fe = (frontend *)data;
+
+    if (fe->paste_data)
+        sfree(fe->paste_data);
+    fe->paste_data = NULL;
+    fe->paste_data_len = 0;
+    return TRUE;
+}
+
+static void menu_copy_event(GtkMenuItem *menuitem, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    char *text;
+
+    text = midend_text_format(fe->me);
+
+    if (text) {
+        write_clip(fe, text);
+    } else {
+        gdk_beep();
+    }
+}
+
+#ifdef OLD_FILESEL
+
+static void filesel_ok(GtkButton *button, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+
+    gpointer filesel = g_object_get_data(G_OBJECT(button), "user-data");
+
+    const char *name =
+        gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel));
+
+    fe->filesel_name = dupstr(name);
+}
+
+static char *file_selector(frontend *fe, char *title, int save)
+{
+    GtkWidget *filesel =
+        gtk_file_selection_new(title);
+
+    fe->filesel_name = NULL;
+
+    gtk_window_set_modal(GTK_WINDOW(filesel), TRUE);
+    g_object_set_data
+        (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "user-data",
+         (gpointer)filesel);
+    g_signal_connect
+        (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked",
+         G_CALLBACK(filesel_ok), fe);
+    g_signal_connect_swapped
+        (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked",
+         G_CALLBACK(gtk_widget_destroy), (gpointer)filesel);
+    g_signal_connect_object
+        (G_OBJECT(GTK_FILE_SELECTION(filesel)->cancel_button), "clicked",
+         G_CALLBACK(gtk_widget_destroy), (gpointer)filesel);
+    g_signal_connect(G_OBJECT(filesel), "destroy",
+                     G_CALLBACK(window_destroy), NULL);
+    gtk_widget_show(filesel);
+    gtk_window_set_transient_for(GTK_WINDOW(filesel), GTK_WINDOW(fe->window));
+    gtk_main();
+
+    return fe->filesel_name;
+}
+
+#else
+
+static char *file_selector(frontend *fe, char *title, int save)
+{
+    char *filesel_name = NULL;
+
+    GtkWidget *filesel =
+        gtk_file_chooser_dialog_new(title,
+                                    GTK_WINDOW(fe->window),
+                                    save ? GTK_FILE_CHOOSER_ACTION_SAVE :
+                                    GTK_FILE_CHOOSER_ACTION_OPEN,
+                                    LABEL_CANCEL, GTK_RESPONSE_CANCEL,
+                                    save ? LABEL_SAVE : LABEL_OPEN,
+                                    GTK_RESPONSE_ACCEPT,
+                                    NULL);
+
+    if (gtk_dialog_run(GTK_DIALOG(filesel)) == GTK_RESPONSE_ACCEPT) {
+        char *name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filesel));
+        filesel_name = dupstr(name);
+        g_free(name);
+    }
+
+    gtk_widget_destroy(filesel);
+
+    return filesel_name;
+}
+
+#endif
+
+struct savefile_write_ctx {
+    FILE *fp;
+    int error;
+};
+
+static void savefile_write(void *wctx, void *buf, int len)
+{
+    struct savefile_write_ctx *ctx = (struct savefile_write_ctx *)wctx;
+    if (fwrite(buf, 1, len, ctx->fp) < len)
+        ctx->error = errno;
+}
+
+static int savefile_read(void *wctx, void *buf, int len)
+{
+    FILE *fp = (FILE *)wctx;
+    int ret;
+
+    ret = fread(buf, 1, len, fp);
+    return (ret == len);
+}
+
+static void menu_save_event(GtkMenuItem *menuitem, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    char *name;
+
+    name = file_selector(fe, "Enter name of game file to save", TRUE);
+
+    if (name) {
+        FILE *fp;
+
+        if ((fp = fopen(name, "r")) != NULL) {
+            char buf[256 + FILENAME_MAX];
+            fclose(fp);
+            /* file exists */
+
+            sprintf(buf, "Are you sure you want to overwrite the"
+                    " file \"%.*s\"?",
+                    FILENAME_MAX, name);
+            if (!message_box(fe->window, "Question", buf, TRUE, MB_YESNO))
+                goto free_and_return;
+        }
+
+        fp = fopen(name, "w");
+
+        if (!fp) {
+            error_box(fe->window, "Unable to open save file");
+            goto free_and_return;
+        }
+
+        {
+            struct savefile_write_ctx ctx;
+            ctx.fp = fp;
+            ctx.error = 0;
+            midend_serialise(fe->me, savefile_write, &ctx);
+            fclose(fp);
+            if (ctx.error) {
+                char boxmsg[512];
+                sprintf(boxmsg, "Error writing save file: %.400s",
+                        strerror(errno));
+                error_box(fe->window, boxmsg);
+                goto free_and_return;
+            }
+        }
+    free_and_return:
+        sfree(name);
+    }
+}
+
+static void menu_load_event(GtkMenuItem *menuitem, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    char *name, *err;
+
+    name = file_selector(fe, "Enter name of saved game file to load", FALSE);
+
+    if (name) {
+        FILE *fp = fopen(name, "r");
+        sfree(name);
+
+        if (!fp) {
+            error_box(fe->window, "Unable to open saved game file");
+            return;
+        }
+
+        err = midend_deserialise(fe->me, savefile_read, fp);
+
+        fclose(fp);
+
+        if (err) {
+            error_box(fe->window, err);
+            return;
+        }
+
+        changed_preset(fe);
+        resize_fe(fe);
+    }
+}
+
+static void menu_solve_event(GtkMenuItem *menuitem, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    char *msg;
+
+    msg = midend_solve(fe->me);
+
+    if (msg)
+        error_box(fe->window, msg);
+}
+
+static void menu_restart_event(GtkMenuItem *menuitem, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+
+    midend_restart_game(fe->me);
+}
+
+static void menu_config_event(GtkMenuItem *menuitem, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    int which = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem),
+                                                  "user-data"));
+
+    if (fe->preset_threaded ||
+        (GTK_IS_CHECK_MENU_ITEM(menuitem) &&
+         !gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))))
+        return;
+    changed_preset(fe);                 /* Put the old preset back! */
+    if (!get_config(fe, which))
+        return;
+
+    midend_new_game(fe->me);
+    resize_fe(fe);
+}
+
+static void menu_about_event(GtkMenuItem *menuitem, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+
+#if GTK_CHECK_VERSION(3,0,0)
+    extern char *const *const xpm_icons[];
+    extern const int n_xpm_icons;
+    GdkPixbuf *icon = gdk_pixbuf_new_from_xpm_data
+        ((const gchar **)xpm_icons[n_xpm_icons-1]);
+    gtk_show_about_dialog
+        (GTK_WINDOW(fe->window),
+         "program-name", thegame.name,
+         "version", ver,
+         "comments", "Part of Simon Tatham's Portable Puzzle Collection",
+         "logo", icon,
+         (const gchar *)NULL);
+    g_object_unref(G_OBJECT(icon));
+#else
+    char titlebuf[256];
+    char textbuf[1024];
+
+    sprintf(titlebuf, "About %.200s", thegame.name);
+    sprintf(textbuf,
+            "%.200s\n\n"
+            "from Simon Tatham's Portable Puzzle Collection\n\n"
+            "%.500s", thegame.name, ver);
+
+    message_box(fe->window, titlebuf, textbuf, TRUE, MB_OK);
+#endif
+}
+
+static GtkWidget *add_menu_item_with_key(frontend *fe, GtkContainer *cont,
+                                         char *text, int key)
+{
+    GtkWidget *menuitem = gtk_menu_item_new_with_label(text);
+    int keyqual;
+    gtk_container_add(cont, menuitem);
+    g_object_set_data(G_OBJECT(menuitem), "user-data", GINT_TO_POINTER(key));
+    g_signal_connect(G_OBJECT(menuitem), "activate",
+                     G_CALLBACK(menu_key_event), fe);
+    switch (key & ~0x1F) {
+      case 0x00:
+        key += 0x60;
+        keyqual = GDK_CONTROL_MASK;
+        break;
+      case 0x40:
+        key += 0x20;
+        keyqual = GDK_SHIFT_MASK;
+        break;
+      default:
+        keyqual = 0;
+        break;
+    }
+    gtk_widget_add_accelerator(menuitem,
+                               "activate", fe->accelgroup,
+                               key, keyqual,
+                               GTK_ACCEL_VISIBLE);
+    gtk_widget_show(menuitem);
+    return menuitem;
+}
+
+static void add_menu_separator(GtkContainer *cont)
+{
+    GtkWidget *menuitem = gtk_menu_item_new();
+    gtk_container_add(cont, menuitem);
+    gtk_widget_show(menuitem);
+}
+
+enum { ARG_EITHER, ARG_SAVE, ARG_ID }; /* for argtype */
+
+static frontend *new_window(char *arg, int argtype, char **error)
+{
+    frontend *fe;
+    GtkBox *vbox, *hbox;
+    GtkWidget *menu, *menuitem;
+    GList *iconlist;
+    int x, y, n;
+    char errbuf[1024];
+    extern char *const *const xpm_icons[];
+    extern const int n_xpm_icons;
+
+    fe = snew(frontend);
+
+    fe->timer_active = FALSE;
+    fe->timer_id = -1;
+
+    fe->me = midend_new(fe, &thegame, &gtk_drawing, fe);
+
+    if (arg) {
+        char *err;
+        FILE *fp;
+
+        errbuf[0] = '\0';
+
+        switch (argtype) {
+          case ARG_ID:
+            err = midend_game_id(fe->me, arg);
+            if (!err)
+                midend_new_game(fe->me);
+            else
+                sprintf(errbuf, "Invalid game ID: %.800s", err);
+            break;
+          case ARG_SAVE:
+            fp = fopen(arg, "r");
+            if (!fp) {
+                sprintf(errbuf, "Error opening file: %.800s", strerror(errno));
+            } else {
+                err = midend_deserialise(fe->me, savefile_read, fp);
+                if (err)
+                    sprintf(errbuf, "Invalid save file: %.800s", err);
+                fclose(fp);
+            }
+            break;
+          default /*case ARG_EITHER*/:
+            /*
+             * First try treating the argument as a game ID.
+             */
+            err = midend_game_id(fe->me, arg);
+            if (!err) {
+                /*
+                 * It's a valid game ID.
+                 */
+                midend_new_game(fe->me);
+            } else {
+                FILE *fp = fopen(arg, "r");
+                if (!fp) {
+                    sprintf(errbuf, "Supplied argument is neither a game ID (%.400s)"
+                            " nor a save file (%.400s)", err, strerror(errno));
+                } else {
+                    err = midend_deserialise(fe->me, savefile_read, fp);
+                    if (err)
+                        sprintf(errbuf, "%.800s", err);
+                    fclose(fp);
+                }
+            }
+            break;
+        }
+        if (*errbuf) {
+            *error = dupstr(errbuf);
+            midend_free(fe->me);
+            sfree(fe);
+            return NULL;
+        }
+
+    } else {
+        midend_new_game(fe->me);
+    }
+
+#if !GTK_CHECK_VERSION(3,0,0)
+    {
+        /*
+         * try_shrink_drawing_area() will do some fiddling with the
+         * window size request (see comment in that function) after
+         * all the bits and pieces such as the menu bar and status bar
+         * have appeared in the puzzle window.
+         *
+         * However, on Unity systems, the menu bar _doesn't_ appear in
+         * the puzzle window, because the Unity shell hijacks it into
+         * the menu bar at the very top of the screen. We therefore
+         * try to detect that situation here, so that we don't sit
+         * here forever waiting for a menu bar.
+         */
+        const char prop[] = "gtk-shell-shows-menubar";
+        GtkSettings *settings = gtk_settings_get_default();
+        if (!g_object_class_find_property(G_OBJECT_GET_CLASS(settings),
+                                          prop)) {
+            fe->menubar_is_local = TRUE;
+        } else {
+            int unity_mode;
+            g_object_get(gtk_settings_get_default(),
+                         prop, &unity_mode,
+                         (const gchar *)NULL);
+            fe->menubar_is_local = !unity_mode;
+        }
+    }
+#endif
+
+    fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_title(GTK_WINDOW(fe->window), thegame.name);
+
+    vbox = GTK_BOX(gtk_vbox_new(FALSE, 0));
+    gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox));
+    gtk_widget_show(GTK_WIDGET(vbox));
+
+    fe->accelgroup = gtk_accel_group_new();
+    gtk_window_add_accel_group(GTK_WINDOW(fe->window), fe->accelgroup);
+
+    hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
+    gtk_box_pack_start(vbox, GTK_WIDGET(hbox), FALSE, FALSE, 0);
+    gtk_widget_show(GTK_WIDGET(hbox));
+
+    fe->menubar = gtk_menu_bar_new();
+    gtk_box_pack_start(hbox, fe->menubar, TRUE, TRUE, 0);
+    gtk_widget_show(fe->menubar);
+
+    menuitem = gtk_menu_item_new_with_mnemonic("_Game");
+    gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem);
+    gtk_widget_show(menuitem);
+
+    menu = gtk_menu_new();
+    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
+
+    add_menu_item_with_key(fe, GTK_CONTAINER(menu), "New", 'n');
+
+    menuitem = gtk_menu_item_new_with_label("Restart");
+    gtk_container_add(GTK_CONTAINER(menu), menuitem);
+    g_signal_connect(G_OBJECT(menuitem), "activate",
+                     G_CALLBACK(menu_restart_event), fe);
+    gtk_widget_show(menuitem);
+
+    menuitem = gtk_menu_item_new_with_label("Specific...");
+    g_object_set_data(G_OBJECT(menuitem), "user-data",
+                      GINT_TO_POINTER(CFG_DESC));
+    gtk_container_add(GTK_CONTAINER(menu), menuitem);
+    g_signal_connect(G_OBJECT(menuitem), "activate",
+                     G_CALLBACK(menu_config_event), fe);
+    gtk_widget_show(menuitem);
+
+    menuitem = gtk_menu_item_new_with_label("Random Seed...");
+    g_object_set_data(G_OBJECT(menuitem), "user-data",
+                      GINT_TO_POINTER(CFG_SEED));
+    gtk_container_add(GTK_CONTAINER(menu), menuitem);
+    g_signal_connect(G_OBJECT(menuitem), "activate",
+                     G_CALLBACK(menu_config_event), fe);
+    gtk_widget_show(menuitem);
+
+    fe->preset_radio = NULL;
+    fe->preset_custom = NULL;
+    fe->n_preset_menu_items = 0;
+    fe->preset_threaded = FALSE;
+    if ((n = midend_num_presets(fe->me)) > 0 || thegame.can_configure) {
+        GtkWidget *submenu;
+        int i;
+
+        menuitem = gtk_menu_item_new_with_mnemonic("_Type");
+        gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem);
+        gtk_widget_show(menuitem);
+
+        submenu = gtk_menu_new();
+        gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
+
+        for (i = 0; i < n; i++) {
+            char *name;
+            game_params *params;
+
+            midend_fetch_preset(fe->me, i, &name, &params);
+
+            menuitem =
+                gtk_radio_menu_item_new_with_label(fe->preset_radio, name);
+            fe->preset_radio =
+                gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem));
+            fe->n_preset_menu_items++;
+            gtk_container_add(GTK_CONTAINER(submenu), menuitem);
+            g_object_set_data(G_OBJECT(menuitem), "user-data", params);
+            g_signal_connect(G_OBJECT(menuitem), "activate",
+                             G_CALLBACK(menu_preset_event), fe);
+            gtk_widget_show(menuitem);
+        }
+
+        if (thegame.can_configure) {
+            menuitem = fe->preset_custom =
+                gtk_radio_menu_item_new_with_label(fe->preset_radio,
+                                                   "Custom...");
+            fe->preset_radio =
+                gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem));
+            gtk_container_add(GTK_CONTAINER(submenu), menuitem);
+            g_object_set_data(G_OBJECT(menuitem), "user-data",
+                              GINT_TO_POINTER(CFG_SETTINGS));
+            g_signal_connect(G_OBJECT(menuitem), "activate",
+                             G_CALLBACK(menu_config_event), fe);
+            gtk_widget_show(menuitem);
+        }
+
+    }
+
+    add_menu_separator(GTK_CONTAINER(menu));
+    menuitem = gtk_menu_item_new_with_label("Load...");
+    gtk_container_add(GTK_CONTAINER(menu), menuitem);
+    g_signal_connect(G_OBJECT(menuitem), "activate",
+                     G_CALLBACK(menu_load_event), fe);
+    gtk_widget_show(menuitem);
+    menuitem = gtk_menu_item_new_with_label("Save...");
+    gtk_container_add(GTK_CONTAINER(menu), menuitem);
+    g_signal_connect(G_OBJECT(menuitem), "activate",
+                     G_CALLBACK(menu_save_event), fe);
+    gtk_widget_show(menuitem);
+#ifndef STYLUS_BASED
+    add_menu_separator(GTK_CONTAINER(menu));
+    add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Undo", 'u');
+    add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Redo", 'r');
+#endif
+    if (thegame.can_format_as_text_ever) {
+        add_menu_separator(GTK_CONTAINER(menu));
+        menuitem = gtk_menu_item_new_with_label("Copy");
+        gtk_container_add(GTK_CONTAINER(menu), menuitem);
+        g_signal_connect(G_OBJECT(menuitem), "activate",
+                         G_CALLBACK(menu_copy_event), fe);
+        gtk_widget_show(menuitem);
+        fe->copy_menu_item = menuitem;
+    } else {
+        fe->copy_menu_item = NULL;
+    }
+    if (thegame.can_solve) {
+        add_menu_separator(GTK_CONTAINER(menu));
+        menuitem = gtk_menu_item_new_with_label("Solve");
+        gtk_container_add(GTK_CONTAINER(menu), menuitem);
+        g_signal_connect(G_OBJECT(menuitem), "activate",
+                         G_CALLBACK(menu_solve_event), fe);
+        gtk_widget_show(menuitem);
+    }
+    add_menu_separator(GTK_CONTAINER(menu));
+    add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Exit", 'q');
+
+    menuitem = gtk_menu_item_new_with_mnemonic("_Help");
+    gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem);
+    gtk_widget_show(menuitem);
+
+    menu = gtk_menu_new();
+    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
+
+    menuitem = gtk_menu_item_new_with_label("About");
+    gtk_container_add(GTK_CONTAINER(menu), menuitem);
+    g_signal_connect(G_OBJECT(menuitem), "activate",
+                     G_CALLBACK(menu_about_event), fe);
+    gtk_widget_show(menuitem);
+
+#ifdef STYLUS_BASED
+    menuitem=gtk_button_new_with_mnemonic("_Redo");
+    g_object_set_data(G_OBJECT(menuitem), "user-data",
+                      GINT_TO_POINTER((int)('r')));
+    g_signal_connect(G_OBJECT(menuitem), "clicked",
+                     G_CALLBACK(menu_key_event), fe);
+    gtk_box_pack_end(hbox, menuitem, FALSE, FALSE, 0);
+    gtk_widget_show(menuitem);
+
+    menuitem=gtk_button_new_with_mnemonic("_Undo");
+    g_object_set_data(G_OBJECT(menuitem), "user-data",
+                      GINT_TO_POINTER((int)('u')));
+    g_signal_connect(G_OBJECT(menuitem), "clicked",
+                     G_CALLBACK(menu_key_event), fe);
+    gtk_box_pack_end(hbox, menuitem, FALSE, FALSE, 0);
+    gtk_widget_show(menuitem);
+
+    if (thegame.flags & REQUIRE_NUMPAD) {
+        hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
+        gtk_box_pack_start(vbox, GTK_WIDGET(hbox), FALSE, FALSE, 0);
+        gtk_widget_show(GTK_WIDGET(hbox));
+
+        *((int*)errbuf)=0;
+        errbuf[1]='\0';
+        for(errbuf[0]='0';errbuf[0]<='9';errbuf[0]++) {
+            menuitem=gtk_button_new_with_label(errbuf);
+            g_object_set_data(G_OBJECT(menuitem), "user-data",
+                              GINT_TO_POINTER((int)(errbuf[0])));
+            g_signal_connect(G_OBJECT(menuitem), "clicked",
+                             G_CALLBACK(menu_key_event), fe);
+            gtk_box_pack_start(hbox, menuitem, TRUE, TRUE, 0);
+            gtk_widget_show(menuitem);
+        }
+    }
+#endif /* STYLUS_BASED */
+
+    changed_preset(fe);
+
+    snaffle_colours(fe);
+
+    if (midend_wants_statusbar(fe->me)) {
+        GtkWidget *viewport;
+        GtkRequisition req;
+
+        viewport = gtk_viewport_new(NULL, NULL);
+        gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
+        fe->statusbar = gtk_statusbar_new();
+        gtk_container_add(GTK_CONTAINER(viewport), fe->statusbar);
+        gtk_widget_show(viewport);
+        gtk_box_pack_end(vbox, viewport, FALSE, FALSE, 0);
+        gtk_widget_show(fe->statusbar);
+        fe->statusctx = gtk_statusbar_get_context_id
+            (GTK_STATUSBAR(fe->statusbar), "game");
+        gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx,
+                           DEFAULT_STATUSBAR_TEXT);
+#if GTK_CHECK_VERSION(3,0,0)
+        gtk_widget_get_preferred_size(fe->statusbar, &req, NULL);
+#else
+        gtk_widget_size_request(fe->statusbar, &req);
+#endif
+        gtk_widget_set_size_request(viewport, -1, req.height);
+    } else
+        fe->statusbar = NULL;
+
+    fe->area = gtk_drawing_area_new();
+#if GTK_CHECK_VERSION(2,0,0) && !GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_double_buffered(fe->area, FALSE);
+#endif
+    {
+        GdkGeometry geom;
+        geom.base_width = geom.base_height = 0;
+        gtk_window_set_geometry_hints(GTK_WINDOW(fe->window), fe->area,
+                                      &geom, GDK_HINT_BASE_SIZE);
+    }
+    fe->w = -1;
+    fe->h = -1;
+    get_size(fe, &x, &y);
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_window_set_default_geometry(GTK_WINDOW(fe->window), x, y);
+#else
+    fe->drawing_area_shrink_pending = FALSE;
+    gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
+#endif
+
+    gtk_box_pack_end(vbox, fe->area, TRUE, TRUE, 0);
+
+    clear_backing_store(fe);
+    fe->fonts = NULL;
+    fe->nfonts = fe->fontsize = 0;
+
+    fe->paste_data = NULL;
+    fe->paste_data_len = 0;
+
+    g_signal_connect(G_OBJECT(fe->window), "destroy",
+                     G_CALLBACK(destroy), fe);
+    g_signal_connect(G_OBJECT(fe->window), "key_press_event",
+                     G_CALLBACK(key_event), fe);
+    g_signal_connect(G_OBJECT(fe->area), "button_press_event",
+                     G_CALLBACK(button_event), fe);
+    g_signal_connect(G_OBJECT(fe->area), "button_release_event",
+                     G_CALLBACK(button_event), fe);
+    g_signal_connect(G_OBJECT(fe->area), "motion_notify_event",
+                     G_CALLBACK(motion_event), fe);
+    g_signal_connect(G_OBJECT(fe->area), "selection_get",
+                     G_CALLBACK(selection_get), fe);
+    g_signal_connect(G_OBJECT(fe->area), "selection_clear_event",
+                     G_CALLBACK(selection_clear), fe);
+#if GTK_CHECK_VERSION(3,0,0)
+    g_signal_connect(G_OBJECT(fe->area), "draw",
+                     G_CALLBACK(draw_area), fe);
+#else
+    g_signal_connect(G_OBJECT(fe->area), "expose_event",
+                     G_CALLBACK(expose_area), fe);
+#endif
+    g_signal_connect(G_OBJECT(fe->window), "map_event",
+                     G_CALLBACK(map_window), fe);
+    g_signal_connect(G_OBJECT(fe->area), "configure_event",
+                     G_CALLBACK(configure_area), fe);
+    g_signal_connect(G_OBJECT(fe->window), "configure_event",
+                     G_CALLBACK(configure_window), fe);
+
+    gtk_widget_add_events(GTK_WIDGET(fe->area),
+                          GDK_BUTTON_PRESS_MASK |
+                          GDK_BUTTON_RELEASE_MASK |
+                          GDK_BUTTON_MOTION_MASK |
+                          GDK_POINTER_MOTION_HINT_MASK);
+
+    if (n_xpm_icons) {
+        gtk_window_set_icon(GTK_WINDOW(fe->window),
+                            gdk_pixbuf_new_from_xpm_data
+                            ((const gchar **)xpm_icons[0]));
+
+        iconlist = NULL;
+        for (n = 0; n < n_xpm_icons; n++) {
+            iconlist =
+                g_list_append(iconlist,
+                              gdk_pixbuf_new_from_xpm_data((const gchar **)
+                                                           xpm_icons[n]));
+        }
+        gtk_window_set_icon_list(GTK_WINDOW(fe->window), iconlist);
+    }
+
+    gtk_widget_show(fe->area);
+    gtk_widget_show(fe->window);
+
+#if !GTK_CHECK_VERSION(3,0,0)
+    fe->drawing_area_shrink_pending = TRUE;
+    try_shrink_drawing_area(fe);
+#endif
+
+    set_window_background(fe, 0);
+
+    return fe;
+}
+
+char *fgetline(FILE *fp)
+{
+    char *ret = snewn(512, char);
+    int size = 512, len = 0;
+    while (fgets(ret + len, size - len, fp)) {
+        len += strlen(ret + len);
+        if (ret[len-1] == '\n')
+            break;                     /* got a newline, we're done */
+        size = len + 512;
+        ret = sresize(ret, size, char);
+    }
+    if (len == 0) {                    /* first fgets returned NULL */
+        sfree(ret);
+        return NULL;
+    }
+    ret[len] = '\0';
+    return ret;
+}
+
+int main(int argc, char **argv)
+{
+    char *pname = argv[0];
+    char *error;
+    int ngenerate = 0, print = FALSE, px = 1, py = 1;
+    int time_generation = FALSE, test_solve = FALSE, list_presets = FALSE;
+    int soln = FALSE, colour = FALSE;
+    float scale = 1.0F;
+    float redo_proportion = 0.0F;
+    char *savefile = NULL, *savesuffix = NULL;
+    char *arg = NULL;
+    int argtype = ARG_EITHER;
+    char *screenshot_file = NULL;
+    int doing_opts = TRUE;
+    int ac = argc;
+    char **av = argv;
+    char errbuf[500];
+
+    /*
+     * Command line parsing in this function is rather fiddly,
+     * because GTK wants to have a go at argc/argv _first_ - and
+     * yet we can't let it, because gtk_init() will bomb out if it
+     * can't open an X display, whereas in fact we want to permit
+     * our --generate and --print modes to run without an X
+     * display.
+     * 
+     * So what we do is:
+     *  - we parse the command line ourselves, without modifying
+     *    argc/argv
+     *  - if we encounter an error which might plausibly be the
+     *    result of a GTK command line (i.e. not detailed errors in
+     *    particular options of ours) we store the error message
+     *    and terminate parsing.
+     *  - if we got enough out of the command line to know it
+     *    specifies a non-X mode of operation, we either display
+     *    the stored error and return failure, or if there is no
+     *    stored error we do the non-X operation and return
+     *    success.
+     *  - otherwise, we go straight to gtk_init().
+     */
+
+    errbuf[0] = '\0';
+    while (--ac > 0) {
+        char *p = *++av;
+        if (doing_opts && !strcmp(p, "--version")) {
+            printf("%s, from Simon Tatham's Portable Puzzle Collection\n%s\n",
+                   thegame.name, ver);
+            return 0;
+        } else if (doing_opts && !strcmp(p, "--generate")) {
+            if (--ac > 0) {
+                ngenerate = atoi(*++av);
+                if (!ngenerate) {
+                    fprintf(stderr, "%s: '--generate' expected a number\n",
+                            pname);
+                    return 1;
+                }
+            } else
+                ngenerate = 1;
+        } else if (doing_opts && !strcmp(p, "--time-generation")) {
+            time_generation = TRUE;
+        } else if (doing_opts && !strcmp(p, "--test-solve")) {
+            test_solve = TRUE;
+        } else if (doing_opts && !strcmp(p, "--list-presets")) {
+            list_presets = TRUE;
+        } else if (doing_opts && !strcmp(p, "--save")) {
+            if (--ac > 0) {
+                savefile = *++av;
+            } else {
+                fprintf(stderr, "%s: '--save' expected a filename\n",
+                        pname);
+                return 1;
+            }
+        } else if (doing_opts && (!strcmp(p, "--save-suffix") ||
+                                  !strcmp(p, "--savesuffix"))) {
+            if (--ac > 0) {
+                savesuffix = *++av;
+            } else {
+                fprintf(stderr, "%s: '--save-suffix' expected a filename\n",
+                        pname);
+                return 1;
+            }
+        } else if (doing_opts && !strcmp(p, "--print")) {
+            if (!thegame.can_print) {
+                fprintf(stderr, "%s: this game does not support printing\n",
+                        pname);
+                return 1;
+            }
+            print = TRUE;
+            if (--ac > 0) {
+                char *dim = *++av;
+                if (sscanf(dim, "%dx%d", &px, &py) != 2) {
+                    fprintf(stderr, "%s: unable to parse argument '%s' to "
+                            "'--print'\n", pname, dim);
+                    return 1;
+                }
+            } else {
+                px = py = 1;
+            }
+        } else if (doing_opts && !strcmp(p, "--scale")) {
+            if (--ac > 0) {
+                scale = atof(*++av);
+            } else {
+                fprintf(stderr, "%s: no argument supplied to '--scale'\n",
+                        pname);
+                return 1;
+            }
+        } else if (doing_opts && !strcmp(p, "--redo")) {
+            /*
+             * This is an internal option which I don't expect
+             * users to have any particular use for. The effect of
+             * --redo is that once the game has been loaded and
+             * initialised, the next move in the redo chain is
+             * replayed, and the game screen is redrawn part way
+             * through the making of the move. This is only
+             * meaningful if there _is_ a next move in the redo
+             * chain, which means in turn that this option is only
+             * useful if you're also passing a save file on the
+             * command line.
+             *
+             * This option is used by the script which generates
+             * the puzzle icons and website screenshots, and I
+             * don't imagine it's useful for anything else.
+             * (Unless, I suppose, users don't like my screenshots
+             * and want to generate their own in the same way for
+             * some repackaged version of the puzzles.)
+             */
+            if (--ac > 0) {
+                redo_proportion = atof(*++av);
+            } else {
+                fprintf(stderr, "%s: no argument supplied to '--redo'\n",
+                        pname);
+                return 1;
+            }
+        } else if (doing_opts && !strcmp(p, "--screenshot")) {
+            /*
+             * Another internal option for the icon building
+             * script. This causes a screenshot of the central
+             * drawing area (i.e. not including the menu bar or
+             * status bar) to be saved to a PNG file once the
+             * window has been drawn, and then the application
+             * quits immediately.
+             */
+            if (--ac > 0) {
+                screenshot_file = *++av;
+            } else {
+                fprintf(stderr, "%s: no argument supplied to '--screenshot'\n",
+                        pname);
+                return 1;
+            }
+        } else if (doing_opts && (!strcmp(p, "--with-solutions") ||
+                                  !strcmp(p, "--with-solution") ||
+                                  !strcmp(p, "--with-solns") ||
+                                  !strcmp(p, "--with-soln") ||
+                                  !strcmp(p, "--solutions") ||
+                                  !strcmp(p, "--solution") ||
+                                  !strcmp(p, "--solns") ||
+                                  !strcmp(p, "--soln"))) {
+            soln = TRUE;
+        } else if (doing_opts && !strcmp(p, "--colour")) {
+            if (!thegame.can_print_in_colour) {
+                fprintf(stderr, "%s: this game does not support colour"
+                        " printing\n", pname);
+                return 1;
+            }
+            colour = TRUE;
+        } else if (doing_opts && !strcmp(p, "--load")) {
+            argtype = ARG_SAVE;
+        } else if (doing_opts && !strcmp(p, "--game")) {
+            argtype = ARG_ID;
+        } else if (doing_opts && !strcmp(p, "--")) {
+            doing_opts = FALSE;
+        } else if (!doing_opts || p[0] != '-') {
+            if (arg) {
+                fprintf(stderr, "%s: more than one argument supplied\n",
+                        pname);
+                return 1;
+            }
+            arg = p;
+        } else {
+            sprintf(errbuf, "%.100s: unrecognised option '%.100s'\n",
+                    pname, p);
+            break;
+        }
+    }
+
+    /*
+     * Special standalone mode for generating puzzle IDs on the
+     * command line. Useful for generating puzzles to be printed
+     * out and solved offline (for puzzles where that even makes
+     * sense - Solo, for example, is a lot more pencil-and-paper
+     * friendly than Twiddle!)
+     * 
+     * Usage:
+     * 
+     *   <puzzle-name> --generate [<n> [<params>]]
+     * 
+     * <n>, if present, is the number of puzzle IDs to generate.
+     * <params>, if present, is the same type of parameter string
+     * you would pass to the puzzle when running it in GUI mode,
+     * including optional extras such as the expansion factor in
+     * Rectangles and the difficulty level in Solo.
+     * 
+     * If you specify <params>, you must also specify <n> (although
+     * you may specify it to be 1). Sorry; that was the
+     * simplest-to-parse command-line syntax I came up with.
+     */
+    if (ngenerate > 0 || print || savefile || savesuffix) {
+        int i, n = 1;
+        midend *me;
+        char *id;
+        document *doc = NULL;
+
+        /*
+         * If we're in this branch, we should display any pending
+         * error message from the command line, since GTK isn't going
+         * to take another crack at making sense of it.
+         */
+        if (*errbuf) {
+            fputs(errbuf, stderr);
+            return 1;
+        }
+
+        n = ngenerate;
+
+        me = midend_new(NULL, &thegame, NULL, NULL);
+        i = 0;
+
+        if (savefile && !savesuffix)
+            savesuffix = "";
+        if (!savefile && savesuffix)
+            savefile = "";
+
+        if (print)
+            doc = document_new(px, py, scale);
+
+        /*
+         * In this loop, we either generate a game ID or read one
+         * from stdin depending on whether we're in generate mode;
+         * then we either write it to stdout or print it, depending
+         * on whether we're in print mode. Thus, this loop handles
+         * generate-to-stdout, print-from-stdin and generate-and-
+         * immediately-print modes.
+         * 
+         * (It could also handle a copy-stdin-to-stdout mode,
+         * although there's currently no combination of options
+         * which will cause this loop to be activated in that mode.
+         * It wouldn't be _entirely_ pointless, though, because
+         * stdin could contain bare params strings or random-seed
+         * IDs, and stdout would contain nothing but fully
+         * generated descriptive game IDs.)
+         */
+        while (ngenerate == 0 || i < n) {
+            char *pstr, *err, *seed;
+            struct rusage before, after;
+
+            if (ngenerate == 0) {
+                pstr = fgetline(stdin);
+                if (!pstr)
+                    break;
+                pstr[strcspn(pstr, "\r\n")] = '\0';
+            } else {
+                if (arg) {
+                    pstr = snewn(strlen(arg) + 40, char);
+
+                    strcpy(pstr, arg);
+                    if (i > 0 && strchr(arg, '#'))
+                        sprintf(pstr + strlen(pstr), "-%d", i);
+                } else
+                    pstr = NULL;
+            }
+
+            if (pstr) {
+                err = midend_game_id(me, pstr);
+                if (err) {
+                    fprintf(stderr, "%s: error parsing '%s': %s\n",
+                            pname, pstr, err);
+                    return 1;
+                }
+            }
+
+            if (time_generation)
+                getrusage(RUSAGE_SELF, &before);
+
+            midend_new_game(me);
+
+            seed = midend_get_random_seed(me);
+
+            if (time_generation) {
+                double elapsed;
+
+                getrusage(RUSAGE_SELF, &after);
+
+                elapsed = (after.ru_utime.tv_sec -
+                           before.ru_utime.tv_sec);
+                elapsed += (after.ru_utime.tv_usec -
+                            before.ru_utime.tv_usec) / 1000000.0;
+
+                printf("%s %s: %.6f\n", thegame.name, seed, elapsed);
+            }
+
+            if (test_solve && thegame.can_solve) {
+                /*
+                 * Now destroy the aux_info in the midend, by means of
+                 * re-entering the same game id, and then try to solve
+                 * it.
+                 */
+                char *game_id, *err;
+
+                game_id = midend_get_game_id(me);
+                err = midend_game_id(me, game_id);
+                if (err) {
+                    fprintf(stderr, "%s %s: game id re-entry error: %s\n",
+                            thegame.name, seed, err);
+                    return 1;
+                }
+                midend_new_game(me);
+                sfree(game_id);
+
+                err = midend_solve(me);
+                /*
+                 * If the solve operation returned the error "Solution
+                 * not known for this puzzle", that's OK, because that
+                 * just means it's a puzzle for which we don't have an
+                 * algorithmic solver and hence can't solve it without
+                 * the aux_info, e.g. Netslide. Any other error is a
+                 * problem, though.
+                 */
+                if (err && strcmp(err, "Solution not known for this puzzle")) {
+                    fprintf(stderr, "%s %s: solve error: %s\n",
+                            thegame.name, seed, err);
+                    return 1;
+                }
+            }
+
+            sfree(pstr);
+            sfree(seed);
+
+            if (doc) {
+                err = midend_print_puzzle(me, doc, soln);
+                if (err) {
+                    fprintf(stderr, "%s: error in printing: %s\n", pname, err);
+                    return 1;
+                }
+            }
+            if (savefile) {
+                struct savefile_write_ctx ctx;
+                char *realname = snewn(40 + strlen(savefile) +
+                                       strlen(savesuffix), char);
+                sprintf(realname, "%s%d%s", savefile, i, savesuffix);
+
+                if (soln) {
+                    char *err = midend_solve(me);
+                    if (err) {
+                        fprintf(stderr, "%s: unable to show solution: %s\n",
+                                realname, err);
+                        return 1;
+                    }
+                }
+
+                ctx.fp = fopen(realname, "w");
+                if (!ctx.fp) {
+                    fprintf(stderr, "%s: open: %s\n", realname,
+                            strerror(errno));
+                    return 1;
+                }
+                ctx.error = 0;
+                midend_serialise(me, savefile_write, &ctx);
+                if (ctx.error) {
+                    fprintf(stderr, "%s: write: %s\n", realname,
+                            strerror(ctx.error));
+                    return 1;
+                }
+                if (fclose(ctx.fp)) {
+                    fprintf(stderr, "%s: close: %s\n", realname,
+                            strerror(errno));
+                    return 1;
+                }
+                sfree(realname);
+            }
+            if (!doc && !savefile && !time_generation) {
+                id = midend_get_game_id(me);
+                puts(id);
+                sfree(id);
+            }
+
+            i++;
+        }
+
+        if (doc) {
+            psdata *ps = ps_init(stdout, colour);
+            document_print(doc, ps_drawing_api(ps));
+            document_free(doc);
+            ps_free(ps);
+        }
+
+        midend_free(me);
+
+        return 0;
+    } else if (list_presets) {
+        /*
+         * Another specialist mode which causes the puzzle to list the
+         * game_params strings for all its preset configurations.
+         */
+        int i, npresets;
+        midend *me;
+
+        me = midend_new(NULL, &thegame, NULL, NULL);
+        npresets = midend_num_presets(me);
+
+        for (i = 0; i < npresets; i++) {
+            game_params *params;
+            char *name, *paramstr;
+
+            midend_fetch_preset(me, i, &name, &params);
+            paramstr = thegame.encode_params(params, TRUE);
+
+            printf("%s %s\n", paramstr, name);
+            sfree(paramstr);
+        }
+
+        midend_free(me);
+        return 0;
+    } else {
+        frontend *fe;
+
+        gtk_init(&argc, &argv);
+
+        fe = new_window(arg, argtype, &error);
+
+        if (!fe) {
+            fprintf(stderr, "%s: %s\n", pname, error);
+            return 1;
+        }
+
+        if (screenshot_file) {
+            /*
+             * Some puzzles will not redraw their entire area if
+             * given a partially completed animation, which means
+             * we must redraw now and _then_ redraw again after
+             * freezing the move timer.
+             */
+            midend_force_redraw(fe->me);
+        }
+
+        if (redo_proportion) {
+            /* Start a redo. */
+            midend_process_key(fe->me, 0, 0, 'r');
+            /* And freeze the timer at the specified position. */
+            midend_freeze_timer(fe->me, redo_proportion);
+        }
+
+        if (screenshot_file) {
+            save_screenshot_png(fe, screenshot_file);
+            exit(0);
+        }
+
+        gtk_main();
+    }
+
+    return 0;
+}
diff --git a/apps/plugins/puzzles/guess.R b/apps/plugins/puzzles/guess.R
new file mode 100644
index 0000000000..0e1a00c073
--- /dev/null
+++ b/apps/plugins/puzzles/guess.R
@@ -0,0 +1,19 @@
+# -*- makefile -*-
+
+guess    : [X] GTK COMMON guess guess-icon|no-icon
+
+guess    : [G] WINDOWS COMMON guess guess.res|noicon.res
+
+ALL += guess[COMBINED]
+
+!begin am gtk
+GAMES += guess
+!end
+
+!begin >list.c
+    A(guess) \
+!end
+
+!begin >gamedesc.txt
+guess:guess.exe:Guess:Combination-guessing puzzle:Guess the hidden combination of colours.
+!end
diff --git a/apps/plugins/puzzles/guess.c b/apps/plugins/puzzles/guess.c
new file mode 100644
index 0000000000..d1187f3e3c
--- /dev/null
+++ b/apps/plugins/puzzles/guess.c
@@ -0,0 +1,1518 @@
+/*
+ * guess.c: Mastermind clone.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#define FLASH_FRAME 0.5F
+
+enum {
+    COL_BACKGROUND,
+    COL_FRAME, COL_CURSOR, COL_FLASH, COL_HOLD,
+    COL_EMPTY, /* must be COL_1 - 1 */
+    COL_1, COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8, COL_9, COL_10,
+    COL_CORRECTPLACE, COL_CORRECTCOLOUR,
+    NCOLOURS
+};
+
+struct game_params {
+    int ncolours, npegs, nguesses;
+    int allow_blank, allow_multiple;
+};
+
+#define FEEDBACK_CORRECTPLACE  1
+#define FEEDBACK_CORRECTCOLOUR 2
+
+typedef struct pegrow {
+    int npegs;
+    int *pegs;          /* 0 is 'empty' */
+    int *feedback;      /* may well be unused */
+} *pegrow;
+
+struct game_state {
+    game_params params;
+    pegrow *guesses;  /* length params->nguesses */
+    int *holds;
+    pegrow solution;
+    int next_go; /* from 0 to nguesses-1;
+                    if next_go == nguesses then they've lost. */
+    int solved;   /* +1 = win, -1 = lose, 0 = still playing */
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    /* AFAIK this is the canonical Mastermind ruleset. */
+    ret->ncolours = 6;
+    ret->npegs = 4;
+    ret->nguesses = 10;
+
+    ret->allow_blank = 0;
+    ret->allow_multiple = 1;
+
+    return ret;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static const struct {
+    char *name;
+    game_params params;
+} guess_presets[] = {
+    {"Standard", {6, 4, 10, FALSE, TRUE}},
+    {"Super", {8, 5, 12, FALSE, TRUE}},
+};
+
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    if (i < 0 || i >= lenof(guess_presets))
+        return FALSE;
+
+    *name = dupstr(guess_presets[i].name);
+    /*
+     * get round annoying const issues
+     */
+    {
+        game_params tmp = guess_presets[i].params;
+        *params = dup_params(&tmp);
+    }
+
+    return TRUE;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    char const *p = string;
+    game_params *defs = default_params();
+
+    *params = *defs; free_params(defs);
+
+    while (*p) {
+        switch (*p++) {
+        case 'c':
+            params->ncolours = atoi(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+            break;
+
+        case 'p':
+            params->npegs = atoi(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+            break;
+
+        case 'g':
+            params->nguesses = atoi(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+            break;
+
+        case 'b':
+            params->allow_blank = 1;
+            break;
+
+        case 'B':
+            params->allow_blank = 0;
+            break;
+
+        case 'm':
+            params->allow_multiple = 1;
+            break;
+
+        case 'M':
+            params->allow_multiple = 0;
+            break;
+
+        default:
+            ;
+        }
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    sprintf(data, "c%dp%dg%d%s%s",
+            params->ncolours, params->npegs, params->nguesses,
+            params->allow_blank ? "b" : "B", params->allow_multiple ? "m" : "M");
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(6, config_item);
+
+    ret[0].name = "Colours";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->ncolours);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Pegs per guess";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->npegs);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Guesses";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->nguesses);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = "Allow blanks";
+    ret[3].type = C_BOOLEAN;
+    ret[3].sval = NULL;
+    ret[3].ival = params->allow_blank;
+
+    ret[4].name = "Allow duplicates";
+    ret[4].type = C_BOOLEAN;
+    ret[4].sval = NULL;
+    ret[4].ival = params->allow_multiple;
+
+    ret[5].name = NULL;
+    ret[5].type = C_END;
+    ret[5].sval = NULL;
+    ret[5].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->ncolours = atoi(cfg[0].sval);
+    ret->npegs = atoi(cfg[1].sval);
+    ret->nguesses = atoi(cfg[2].sval);
+
+    ret->allow_blank = cfg[3].ival;
+    ret->allow_multiple = cfg[4].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->ncolours < 2 || params->npegs < 2)
+        return "Trivial solutions are uninteresting";
+    /* NB as well as the no. of colours we define, max(ncolours) must
+     * also fit in an unsigned char; see new_game_desc. */
+    if (params->ncolours > 10)
+        return "Too many colours";
+    if (params->nguesses < 1)
+        return "Must have at least one guess";
+    if (!params->allow_multiple && params->ncolours < params->npegs)
+        return "Disallowing multiple colours requires at least as many colours as pegs";
+    return NULL;
+}
+
+static pegrow new_pegrow(int npegs)
+{
+    pegrow pegs = snew(struct pegrow);
+
+    pegs->npegs = npegs;
+    pegs->pegs = snewn(pegs->npegs, int);
+    memset(pegs->pegs, 0, pegs->npegs * sizeof(int));
+    pegs->feedback = snewn(pegs->npegs, int);
+    memset(pegs->feedback, 0, pegs->npegs * sizeof(int));
+
+    return pegs;
+}
+
+static pegrow dup_pegrow(pegrow pegs)
+{
+    pegrow newpegs = new_pegrow(pegs->npegs);
+
+    memcpy(newpegs->pegs, pegs->pegs, newpegs->npegs * sizeof(int));
+    memcpy(newpegs->feedback, pegs->feedback, newpegs->npegs * sizeof(int));
+
+    return newpegs;
+}
+
+static void invalidate_pegrow(pegrow pegs)
+{
+    memset(pegs->pegs, -1, pegs->npegs * sizeof(int));
+    memset(pegs->feedback, -1, pegs->npegs * sizeof(int));
+}
+
+static void free_pegrow(pegrow pegs)
+{
+    sfree(pegs->pegs);
+    sfree(pegs->feedback);
+    sfree(pegs);
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    unsigned char *bmp = snewn(params->npegs, unsigned char);
+    char *ret;
+    int i, c;
+    pegrow colcount = new_pegrow(params->ncolours);
+
+    for (i = 0; i < params->npegs; i++) {
+newcol:
+        c = random_upto(rs, params->ncolours);
+        if (!params->allow_multiple && colcount->pegs[c]) goto newcol;
+        colcount->pegs[c]++;
+        bmp[i] = (unsigned char)(c+1);
+    }
+    obfuscate_bitmap(bmp, params->npegs*8, FALSE);
+
+    ret = bin2hex(bmp, params->npegs);
+    sfree(bmp);
+    free_pegrow(colcount);
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    unsigned char *bmp;
+    int i;
+
+    /* desc is just an (obfuscated) bitmap of the solution; check that
+     * it's the correct length and (when unobfuscated) contains only
+     * sensible colours. */
+    if (strlen(desc) != params->npegs * 2)
+        return "Game description is wrong length";
+    bmp = hex2bin(desc, params->npegs);
+    obfuscate_bitmap(bmp, params->npegs*8, TRUE);
+    for (i = 0; i < params->npegs; i++) {
+        if (bmp[i] < 1 || bmp[i] > params->ncolours) {
+            sfree(bmp);
+            return "Game description is corrupted";
+        }
+    }
+    sfree(bmp);
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    unsigned char *bmp;
+    int i;
+
+    state->params = *params;
+    state->guesses = snewn(params->nguesses, pegrow);
+    for (i = 0; i < params->nguesses; i++)
+        state->guesses[i] = new_pegrow(params->npegs);
+    state->holds = snewn(params->npegs, int);
+    state->solution = new_pegrow(params->npegs);
+
+    bmp = hex2bin(desc, params->npegs);
+    obfuscate_bitmap(bmp, params->npegs*8, TRUE);
+    for (i = 0; i < params->npegs; i++)
+        state->solution->pegs[i] = (int)bmp[i];
+    sfree(bmp);
+
+    memset(state->holds, 0, sizeof(int) * params->npegs);
+    state->next_go = state->solved = 0;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+    int i;
+
+    *ret = *state;
+
+    ret->guesses = snewn(state->params.nguesses, pegrow);
+    for (i = 0; i < state->params.nguesses; i++)
+        ret->guesses[i] = dup_pegrow(state->guesses[i]);
+    ret->holds = snewn(state->params.npegs, int);
+    memcpy(ret->holds, state->holds, sizeof(int) * state->params.npegs);
+    ret->solution = dup_pegrow(state->solution);
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    int i;
+
+    free_pegrow(state->solution);
+    for (i = 0; i < state->params.nguesses; i++)
+        free_pegrow(state->guesses[i]);
+    sfree(state->holds);
+    sfree(state->guesses);
+
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return dupstr("S");
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+static int is_markable(const game_params *params, pegrow pegs)
+{
+    int i, nset = 0, nrequired, ret = 0;
+    pegrow colcount = new_pegrow(params->ncolours);
+
+    nrequired = params->allow_blank ? 1 : params->npegs;
+
+    for (i = 0; i < params->npegs; i++) {
+        int c = pegs->pegs[i];
+        if (c > 0) {
+            colcount->pegs[c-1]++;
+            nset++;
+        }
+    }
+    if (nset < nrequired) goto done;
+
+    if (!params->allow_multiple) {
+        for (i = 0; i < params->ncolours; i++) {
+            if (colcount->pegs[i] > 1) goto done;
+        }
+    }
+    ret = 1;
+done:
+    free_pegrow(colcount);
+    return ret;
+}
+
+struct game_ui {
+    game_params params;
+    pegrow curr_pegs; /* half-finished current move */
+    int *holds;
+    int colour_cur;   /* position of up-down colour picker cursor */
+    int peg_cur;      /* position of left-right peg picker cursor */
+    int display_cur, markable;
+
+    int drag_col, drag_x, drag_y; /* x and y are *center* of peg! */
+    int drag_opeg; /* peg index, if dragged from a peg (from current guess), otherwise -1 */
+
+    int show_labels;                   /* label the colours with letters */
+    pegrow hint;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    memset(ui, 0, sizeof(game_ui));
+    ui->params = state->params;        /* structure copy */
+    ui->curr_pegs = new_pegrow(state->params.npegs);
+    ui->holds = snewn(state->params.npegs, int);
+    memset(ui->holds, 0, sizeof(int)*state->params.npegs);
+    ui->drag_opeg = -1;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    if (ui->hint)
+        free_pegrow(ui->hint);
+    free_pegrow(ui->curr_pegs);
+    sfree(ui->holds);
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    char *ret, *p, *sep;
+    int i;
+
+    /*
+     * For this game it's worth storing the contents of the current
+     * guess, and the current set of holds.
+     */
+    ret = snewn(40 * ui->curr_pegs->npegs, char);
+    p = ret;
+    sep = "";
+    for (i = 0; i < ui->curr_pegs->npegs; i++) {
+        p += sprintf(p, "%s%d%s", sep, ui->curr_pegs->pegs[i],
+                     ui->holds[i] ? "_" : "");
+        sep = ",";
+    }
+    *p++ = '\0';
+    assert(p - ret < 40 * ui->curr_pegs->npegs);
+    return sresize(ret, p - ret, char);
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+    int i;
+    const char *p = encoding;
+    for (i = 0; i < ui->curr_pegs->npegs; i++) {
+        ui->curr_pegs->pegs[i] = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+        if (*p == '_') {
+            /* NB: old versions didn't store holds */
+            ui->holds[i] = 1;
+            p++;
+        } else
+            ui->holds[i] = 0;
+        if (*p == ',') p++;
+    }
+    ui->markable = is_markable(&ui->params, ui->curr_pegs);
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    int i;
+
+    if (newstate->next_go < oldstate->next_go) {
+        sfree(ui->hint);
+        ui->hint = NULL;
+    }
+
+    /* Implement holds, clear other pegs.
+     * This does something that is arguably the Right Thing even
+     * for undo. */
+    for (i = 0; i < newstate->solution->npegs; i++) {
+        if (newstate->solved)
+            ui->holds[i] = 0;
+        else
+            ui->holds[i] = newstate->holds[i];
+        if (newstate->solved || (newstate->next_go == 0) || !ui->holds[i]) {
+            ui->curr_pegs->pegs[i] = 0;
+        } else
+            ui->curr_pegs->pegs[i] =
+                newstate->guesses[newstate->next_go-1]->pegs[i];
+    }
+    ui->markable = is_markable(&newstate->params, ui->curr_pegs);
+    /* Clean up cursor position */
+    if (!ui->markable && ui->peg_cur == newstate->solution->npegs)
+        ui->peg_cur--;
+}
+
+#define PEGSZ   (ds->pegsz)
+#define PEGOFF  (ds->pegsz + ds->gapsz)
+#define HINTSZ  (ds->hintsz)
+#define HINTOFF (ds->hintsz + ds->gapsz)
+
+#define GAP     (ds->gapsz)
+#define CGAP    (ds->gapsz / 2)
+
+#define PEGRAD  (ds->pegrad)
+#define HINTRAD (ds->hintrad)
+
+#define COL_OX          (ds->colx)
+#define COL_OY          (ds->coly)
+#define COL_X(c)        (COL_OX)
+#define COL_Y(c)        (COL_OY + (c)*PEGOFF)
+#define COL_W           PEGOFF
+#define COL_H           (ds->colours->npegs*PEGOFF)
+
+#define GUESS_OX        (ds->guessx)
+#define GUESS_OY        (ds->guessy)
+#define GUESS_X(g,p)    (GUESS_OX + (p)*PEGOFF)
+#define GUESS_Y(g,p)    (GUESS_OY + (g)*PEGOFF)
+#define GUESS_W         (ds->solution->npegs*PEGOFF)
+#define GUESS_H         (ds->nguesses*PEGOFF)
+
+#define HINT_OX         (GUESS_OX + GUESS_W + ds->gapsz)
+#define HINT_OY         (GUESS_OY + (PEGSZ - HINTOFF - HINTSZ) / 2)
+#define HINT_X(g)       HINT_OX
+#define HINT_Y(g)       (HINT_OY + (g)*PEGOFF)
+#define HINT_W          ((ds->hintw*HINTOFF) - GAP)
+#define HINT_H          GUESS_H
+
+#define SOLN_OX         GUESS_OX
+#define SOLN_OY         (GUESS_OY + GUESS_H + ds->gapsz + 2)
+#define SOLN_W          GUESS_W
+#define SOLN_H          PEGOFF
+
+struct game_drawstate {
+    int nguesses;
+    pegrow *guesses;    /* same size as state->guesses */
+    pegrow solution;    /* only displayed if state->solved */
+    pegrow colours;     /* length ncolours, not npegs */
+
+    int pegsz, hintsz, gapsz; /* peg size (diameter), etc. */
+    int pegrad, hintrad;      /* radius of peg, hint */
+    int border;
+    int colx, coly;     /* origin of colours vertical bar */
+    int guessx, guessy; /* origin of guesses */
+    int solnx, solny;   /* origin of solution */
+    int hintw;          /* no. of hint tiles we're wide per row */
+    int w, h, started, solved;
+
+    int next_go;
+
+    blitter *blit_peg;
+    int drag_col, blit_ox, blit_oy;
+};
+
+static void set_peg(const game_params *params, game_ui *ui, int peg, int col)
+{
+    ui->curr_pegs->pegs[peg] = col;
+    ui->markable = is_markable(params, ui->curr_pegs);
+}
+
+static int mark_pegs(pegrow guess, const pegrow solution, int ncols)
+{
+    int nc_place = 0, nc_colour = 0, i, j;
+
+    assert(guess && solution && (guess->npegs == solution->npegs));
+
+    for (i = 0; i < guess->npegs; i++) {
+        if (guess->pegs[i] == solution->pegs[i]) nc_place++;
+    }
+
+    /* slight bit of cleverness: we have the following formula, from
+     * http://mathworld.wolfram.com/Mastermind.html that gives:
+     *
+     * nc_colour = sum(colours, min(#solution, #guess)) - nc_place
+     *
+     * I think this is due to Knuth.
+     */
+    for (i = 1; i <= ncols; i++) {
+        int n_guess = 0, n_solution = 0;
+        for (j = 0; j < guess->npegs; j++) {
+            if (guess->pegs[j] == i) n_guess++;
+            if (solution->pegs[j] == i) n_solution++;
+        }
+        nc_colour += min(n_guess, n_solution);
+    }
+    nc_colour -= nc_place;
+
+    debug(("mark_pegs, %d pegs, %d right place, %d right colour",
+           guess->npegs, nc_place, nc_colour));
+    assert((nc_colour + nc_place) <= guess->npegs);
+
+    memset(guess->feedback, 0, guess->npegs*sizeof(int));
+    for (i = 0, j = 0; i < nc_place; i++)
+        guess->feedback[j++] = FEEDBACK_CORRECTPLACE;
+    for (i = 0; i < nc_colour; i++)
+        guess->feedback[j++] = FEEDBACK_CORRECTCOLOUR;
+
+    return nc_place;
+}
+
+static char *encode_move(const game_state *from, game_ui *ui)
+{
+    char *buf, *p, *sep;
+    int len, i;
+
+    len = ui->curr_pegs->npegs * 20 + 2;
+    buf = snewn(len, char);
+    p = buf;
+    *p++ = 'G';
+    sep = "";
+    for (i = 0; i < ui->curr_pegs->npegs; i++) {
+        p += sprintf(p, "%s%d%s", sep, ui->curr_pegs->pegs[i],
+                     ui->holds[i] ? "_" : "");
+        sep = ",";
+    }
+    *p++ = '\0';
+    assert(p - buf <= len);
+    buf = sresize(buf, len, char);
+
+    return buf;
+}
+
+static void compute_hint(const game_state *state, game_ui *ui)
+{
+    /* Suggest the lexicographically first row consistent with all
+     * previous feedback.  This is not only a useful hint, but also
+     * a reasonable strategy if applied consistently.  If the user
+     * uses hints in every turn, they may be able to intuit this
+     * strategy, or one similar to it.  I (Jonas Kölker) came up
+     * with something close to it without seeing it in action. */
+
+    /* Some performance characteristics: I want to ask for each n,
+     * how many solutions are guessed in exactly n guesses if you
+     * use the hint in each turn.
+     *
+     * With 4 pegs and 6 colours you get the following histogram:
+     *
+     *  1 guesses:     1 solution
+     *  2 guesses:     4 solutions
+     *  3 guesses:    25 solutions
+     *  4 guesses:   108 solutions
+     *  5 guesses:   305 solutions
+     *  6 guesses:   602 solutions
+     *  7 guesses:   196 solutions
+     *  8 guesses:    49 solutions
+     *  9 guesses:     6 solutions
+     * (note: the tenth guess is never necessary.)
+     *
+     * With 5 pegs and 8 colours you get the following histogram:
+     *
+     *  1 guesses:     1 solution
+     *  2 guesses:     5 solutions
+     *  3 guesses:    43 solutions
+     *  4 guesses:   278 solutions
+     *  5 guesses:  1240 solutions
+     *  6 guesses:  3515 solutions
+     *  7 guesses:  7564 solutions
+     *  8 guesses: 14086 solutions
+     *  9 guesses:  4614 solutions
+     * 10 guesses:  1239 solutions
+     * 11 guesses:   175 solutions
+     * 12 guesses:     7 solutions
+     * 13 guesses:     1 solution
+     *
+     * The solution which takes too many guesses is {8, 8, 5, 6, 7}.
+     * The game ID is c8p5g12Bm:4991e5e41a. */
+
+    int mincolour = 1, maxcolour = 0, i, j;
+
+    /* For large values of npegs and ncolours, the lexicographically
+     * next guess make take a while to find.  Finding upper and
+     * lower limits on which colours we have to consider will speed
+     * this up, as will caching our progress from one invocation to
+     * the next.  The latter strategy works, since if we have ruled
+     * out a candidate we will never reverse this judgment in the
+     * light of new information.  Removing information, i.e. undo,
+     * will require us to backtrack somehow.  We backtrack by fully
+     * forgetting our progress (and recomputing it if required). */
+
+    for (i = 0; i < state->next_go; ++i)
+        for (j = 0; j < state->params.npegs; ++j)
+            if (state->guesses[i]->pegs[j] > maxcolour)
+                maxcolour = state->guesses[i]->pegs[j];
+    maxcolour = min(maxcolour + 1, state->params.ncolours);
+
+increase_mincolour:
+    for (i = 0; i < state->next_go; ++i) {
+        if (state->guesses[i]->feedback[0])
+            goto next_iteration;
+        for (j = 0; j < state->params.npegs; ++j)
+            if (state->guesses[i]->pegs[j] != mincolour)
+                goto next_iteration;
+        ++mincolour;
+        goto increase_mincolour;
+    next_iteration:
+        ;
+    }
+
+    if (!ui->hint) {
+        ui->hint = new_pegrow(state->params.npegs);
+        for (i = 0; i < state->params.npegs; ++i)
+            ui->hint->pegs[i] = 1;
+    }
+
+    while (ui->hint->pegs[0] <= state->params.ncolours) {
+        for (i = 0; i < state->next_go; ++i) {
+            mark_pegs(ui->hint, state->guesses[i], maxcolour);
+            for (j = 0; j < state->params.npegs; ++j)
+                if (ui->hint->feedback[j] != state->guesses[i]->feedback[j])
+                    goto increment_pegrow;
+        }
+        /* a valid guess was found; install it and return */
+        for (i = 0; i < state->params.npegs; ++i)
+            ui->curr_pegs->pegs[i] = ui->hint->pegs[i];
+
+        ui->markable = TRUE;
+        ui->peg_cur = state->params.npegs;
+        ui->display_cur = 1;
+        return;
+
+    increment_pegrow:
+        for (i = ui->hint->npegs;
+             ++ui->hint->pegs[--i], i && ui->hint->pegs[i] > maxcolour;
+             ui->hint->pegs[i] = mincolour);
+    }
+    /* No solution is compatible with the given hints.  Impossible! */
+    /* (hack new_game_desc to create invalid solutions to get here) */
+
+    /* For some values of npegs and ncolours, the hinting function takes a
+     * long time to complete.  To visually indicate completion with failure,
+     * should it ever happen, update the ui in some trivial way.  This gives
+     * the user a sense of broken(ish)ness and futility. */
+    if (!ui->display_cur) {
+        ui->display_cur = 1;
+    } else if (state->params.npegs == 1) {
+        ui->display_cur = 0;
+    } else {
+        ui->peg_cur = (ui->peg_cur + 1) % state->params.npegs;
+    }
+}
+
+static char *interpret_move(const game_state *from, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int over_col = 0;           /* one-indexed */
+    int over_guess = -1;        /* zero-indexed */
+    int over_past_guess_y = -1; /* zero-indexed */
+    int over_past_guess_x = -1; /* zero-indexed */
+    int over_hint = 0;          /* zero or one */
+    char *ret = NULL;
+
+    int guess_ox = GUESS_X(from->next_go, 0);
+    int guess_oy = GUESS_Y(from->next_go, 0);
+
+    /*
+     * Enable or disable labels on colours.
+     */
+    if (button == 'l' || button == 'L') {
+        ui->show_labels = !ui->show_labels;
+        return "";
+    }
+
+    if (from->solved) return NULL;
+
+    if (x >= COL_OX && x < (COL_OX + COL_W) &&
+        y >= COL_OY && y < (COL_OY + COL_H)) {
+        over_col = ((y - COL_OY) / PEGOFF) + 1;
+        assert(over_col >= 1 && over_col <= ds->colours->npegs);
+    } else if (x >= guess_ox &&
+               y >= guess_oy && y < (guess_oy + GUESS_H)) {
+        if (x < (guess_ox + GUESS_W)) {
+            over_guess = (x - guess_ox) / PEGOFF;
+            assert(over_guess >= 0 && over_guess < ds->solution->npegs);
+        } else {
+            over_hint = 1;
+        }
+    } else if (x >= guess_ox && x < (guess_ox + GUESS_W) &&
+               y >= GUESS_OY && y < guess_oy) {
+        over_past_guess_y = (y - GUESS_OY) / PEGOFF;
+        over_past_guess_x = (x - guess_ox) / PEGOFF;
+        assert(over_past_guess_y >= 0 && over_past_guess_y < from->next_go);
+        assert(over_past_guess_x >= 0 && over_past_guess_x < ds->solution->npegs);
+    }
+    debug(("make_move: over_col %d, over_guess %d, over_hint %d,"
+           " over_past_guess (%d,%d)", over_col, over_guess, over_hint,
+           over_past_guess_x, over_past_guess_y));
+
+    assert(ds->blit_peg);
+
+    /* mouse input */
+    if (button == LEFT_BUTTON) {
+        if (over_col > 0) {
+            ui->drag_col = over_col;
+            ui->drag_opeg = -1;
+            debug(("Start dragging from colours"));
+        } else if (over_guess > -1) {
+            int col = ui->curr_pegs->pegs[over_guess];
+            if (col) {
+                ui->drag_col = col;
+                ui->drag_opeg = over_guess;
+                debug(("Start dragging from a guess"));
+            }
+        } else if (over_past_guess_y > -1) {
+            int col =
+                from->guesses[over_past_guess_y]->pegs[over_past_guess_x];
+            if (col) {
+                ui->drag_col = col;
+                ui->drag_opeg = -1;
+                debug(("Start dragging from a past guess"));
+            }
+        }
+        if (ui->drag_col) {
+            ui->drag_x = x;
+            ui->drag_y = y;
+            debug(("Start dragging, col = %d, (%d,%d)",
+                   ui->drag_col, ui->drag_x, ui->drag_y));
+            ret = "";
+        }
+    } else if (button == LEFT_DRAG && ui->drag_col) {
+        ui->drag_x = x;
+        ui->drag_y = y;
+        debug(("Keep dragging, (%d,%d)", ui->drag_x, ui->drag_y));
+        ret = "";
+    } else if (button == LEFT_RELEASE && ui->drag_col) {
+        if (over_guess > -1) {
+            debug(("Dropping colour %d onto guess peg %d",
+                   ui->drag_col, over_guess));
+            set_peg(&from->params, ui, over_guess, ui->drag_col);
+        } else {
+            if (ui->drag_opeg > -1) {
+                debug(("Removing colour %d from peg %d",
+                       ui->drag_col, ui->drag_opeg));
+                set_peg(&from->params, ui, ui->drag_opeg, 0);
+            }
+        }
+        ui->drag_col = 0;
+        ui->drag_opeg = -1;
+        ui->display_cur = 0;
+        debug(("Stop dragging."));
+        ret = "";
+    } else if (button == RIGHT_BUTTON) {
+        if (over_guess > -1) {
+            /* we use ths feedback in the game_ui to signify
+             * 'carry this peg to the next guess as well'. */
+            ui->holds[over_guess] = 1 - ui->holds[over_guess];
+            ret = "";
+        }
+    } else if (button == LEFT_RELEASE && over_hint && ui->markable) {
+        /* NB this won't trigger if on the end of a drag; that's on
+         * purpose, in case you drop by mistake... */
+        ret = encode_move(from, ui);
+    }
+
+    /* keyboard input */
+    if (button == CURSOR_UP || button == CURSOR_DOWN) {
+        ui->display_cur = 1;
+        if (button == CURSOR_DOWN && (ui->colour_cur+1) < from->params.ncolours)
+            ui->colour_cur++;
+        if (button == CURSOR_UP && ui->colour_cur > 0)
+            ui->colour_cur--;
+        ret = "";
+    } else if (button == 'h' || button == 'H' || button == '?') {
+        compute_hint(from, ui);
+        ret = "";
+    } else if (button == CURSOR_LEFT || button == CURSOR_RIGHT) {
+        int maxcur = from->params.npegs;
+        if (ui->markable) maxcur++;
+
+        ui->display_cur = 1;
+        if (button == CURSOR_RIGHT && (ui->peg_cur+1) < maxcur)
+            ui->peg_cur++;
+        if (button == CURSOR_LEFT && ui->peg_cur > 0)
+            ui->peg_cur--;
+        ret = "";
+    } else if (IS_CURSOR_SELECT(button)) {
+        ui->display_cur = 1;
+        if (ui->peg_cur == from->params.npegs) {
+            ret = encode_move(from, ui);
+        } else {
+            set_peg(&from->params, ui, ui->peg_cur, ui->colour_cur+1);
+            ret = "";
+        }
+    } else if (button == 'D' || button == 'd' || button == '\b') {
+        ui->display_cur = 1;
+        set_peg(&from->params, ui, ui->peg_cur, 0);
+        ret = "";
+    } else if (button == CURSOR_SELECT2) {
+        if (ui->peg_cur == from->params.npegs)
+            return NULL;
+        ui->display_cur = 1;
+        ui->holds[ui->peg_cur] = 1 - ui->holds[ui->peg_cur];
+        ret = "";
+    }
+    return ret;
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    int i, nc_place;
+    game_state *ret;
+    const char *p;
+
+    if (!strcmp(move, "S")) {
+        ret = dup_game(from);
+        ret->solved = -1;
+        return ret;
+    } else if (move[0] == 'G') {
+        p = move+1;
+
+        ret = dup_game(from);
+
+        for (i = 0; i < from->solution->npegs; i++) {
+            int val = atoi(p);
+            int min_colour = from->params.allow_blank? 0 : 1;
+            if (val < min_colour || val > from->params.ncolours) {
+                free_game(ret);
+                return NULL;
+            }
+            ret->guesses[from->next_go]->pegs[i] = atoi(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+            if (*p == '_') {
+                ret->holds[i] = 1;
+                p++;
+            } else
+                ret->holds[i] = 0;
+            if (*p == ',') p++;
+        }
+
+        nc_place = mark_pegs(ret->guesses[from->next_go], ret->solution, ret->params.ncolours);
+
+        if (nc_place == ret->solution->npegs) {
+            ret->solved = +1; /* win! */
+        } else {
+            ret->next_go = from->next_go + 1;
+            if (ret->next_go >= ret->params.nguesses)
+                ret->solved = -1; /* lose, meaning we show the pegs. */
+        }
+
+        return ret;
+    } else
+        return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define PEG_PREFER_SZ 32
+
+/* next three are multipliers for pegsz. It will look much nicer if
+ * (2*PEG_HINT) + PEG_GAP = 1.0 as the hints are formatted like that. */
+#define PEG_GAP   0.10
+#define PEG_HINT  0.35
+
+#define BORDER    0.5
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    double hmul, vmul_c, vmul_g, vmul;
+    int hintw = (params->npegs+1)/2;
+
+    hmul = BORDER   * 2.0 +               /* border */
+           1.0      * 2.0 +               /* vertical colour bar */
+           1.0      * params->npegs +     /* guess pegs */
+           PEG_GAP  * params->npegs +     /* guess gaps */
+           PEG_HINT * hintw +             /* hint pegs */
+           PEG_GAP  * (hintw - 1);        /* hint gaps */
+
+    vmul_c = BORDER  * 2.0 +                    /* border */
+             1.0     * params->ncolours +       /* colour pegs */
+             PEG_GAP * (params->ncolours - 1);  /* colour gaps */
+
+    vmul_g = BORDER  * 2.0 +                    /* border */
+             1.0     * (params->nguesses + 1) + /* guesses plus solution */
+             PEG_GAP * (params->nguesses + 1);  /* gaps plus gap above soln */
+
+    vmul = max(vmul_c, vmul_g);
+
+    *x = (int)ceil((double)tilesize * hmul);
+    *y = (int)ceil((double)tilesize * vmul);
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    int colh, guessh;
+
+    ds->pegsz = tilesize;
+
+    ds->hintsz = (int)((double)ds->pegsz * PEG_HINT);
+    ds->gapsz  = (int)((double)ds->pegsz * PEG_GAP);
+    ds->border = (int)((double)ds->pegsz * BORDER);
+
+    ds->pegrad  = (ds->pegsz -1)/2; /* radius of peg to fit in pegsz (which is 2r+1) */
+    ds->hintrad = (ds->hintsz-1)/2;
+
+    colh = ((ds->pegsz + ds->gapsz) * params->ncolours) - ds->gapsz;
+    guessh = ((ds->pegsz + ds->gapsz) * params->nguesses);      /* guesses */
+    guessh += ds->gapsz + ds->pegsz;                            /* solution */
+
+    game_compute_size(params, tilesize, &ds->w, &ds->h);
+    ds->colx = ds->border;
+    ds->coly = (ds->h - colh) / 2;
+
+    ds->guessx = ds->solnx = ds->border + ds->pegsz * 2;     /* border + colours */
+    ds->guessy = (ds->h - guessh) / 2;
+    ds->solny = ds->guessy + ((ds->pegsz + ds->gapsz) * params->nguesses) + ds->gapsz;
+
+    assert(ds->pegsz > 0);
+    assert(!ds->blit_peg);             /* set_size is never called twice */
+    ds->blit_peg = blitter_new(dr, ds->pegsz+2, ds->pegsz+2);
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float), max;
+    int i;
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    /* red */
+    ret[COL_1 * 3 + 0] = 1.0F;
+    ret[COL_1 * 3 + 1] = 0.0F;
+    ret[COL_1 * 3 + 2] = 0.0F;
+
+    /* yellow */
+    ret[COL_2 * 3 + 0] = 1.0F;
+    ret[COL_2 * 3 + 1] = 1.0F;
+    ret[COL_2 * 3 + 2] = 0.0F;
+
+    /* green */
+    ret[COL_3 * 3 + 0] = 0.0F;
+    ret[COL_3 * 3 + 1] = 1.0F;
+    ret[COL_3 * 3 + 2] = 0.0F;
+
+    /* blue */
+    ret[COL_4 * 3 + 0] = 0.2F;
+    ret[COL_4 * 3 + 1] = 0.3F;
+    ret[COL_4 * 3 + 2] = 1.0F;
+
+    /* orange */
+    ret[COL_5 * 3 + 0] = 1.0F;
+    ret[COL_5 * 3 + 1] = 0.5F;
+    ret[COL_5 * 3 + 2] = 0.0F;
+
+    /* purple */
+    ret[COL_6 * 3 + 0] = 0.5F;
+    ret[COL_6 * 3 + 1] = 0.0F;
+    ret[COL_6 * 3 + 2] = 0.7F;
+
+    /* brown */
+    ret[COL_7 * 3 + 0] = 0.5F;
+    ret[COL_7 * 3 + 1] = 0.3F;
+    ret[COL_7 * 3 + 2] = 0.3F;
+
+    /* light blue */
+    ret[COL_8 * 3 + 0] = 0.4F;
+    ret[COL_8 * 3 + 1] = 0.8F;
+    ret[COL_8 * 3 + 2] = 1.0F;
+
+    /* light green */
+    ret[COL_9 * 3 + 0] = 0.7F;
+    ret[COL_9 * 3 + 1] = 1.0F;
+    ret[COL_9 * 3 + 2] = 0.7F;
+
+    /* pink */
+    ret[COL_10 * 3 + 0] = 1.0F;
+    ret[COL_10 * 3 + 1] = 0.6F;
+    ret[COL_10 * 3 + 2] = 1.0F;
+
+    ret[COL_FRAME * 3 + 0] = 0.0F;
+    ret[COL_FRAME * 3 + 1] = 0.0F;
+    ret[COL_FRAME * 3 + 2] = 0.0F;
+
+    ret[COL_CURSOR * 3 + 0] = 0.0F;
+    ret[COL_CURSOR * 3 + 1] = 0.0F;
+    ret[COL_CURSOR * 3 + 2] = 0.0F;
+
+    ret[COL_FLASH * 3 + 0] = 0.5F;
+    ret[COL_FLASH * 3 + 1] = 1.0F;
+    ret[COL_FLASH * 3 + 2] = 1.0F;
+
+    ret[COL_HOLD * 3 + 0] = 1.0F;
+    ret[COL_HOLD * 3 + 1] = 0.5F;
+    ret[COL_HOLD * 3 + 2] = 0.5F;
+
+    ret[COL_CORRECTPLACE*3 + 0] = 0.0F;
+    ret[COL_CORRECTPLACE*3 + 1] = 0.0F;
+    ret[COL_CORRECTPLACE*3 + 2] = 0.0F;
+
+    ret[COL_CORRECTCOLOUR*3 + 0] = 1.0F;
+    ret[COL_CORRECTCOLOUR*3 + 1] = 1.0F;
+    ret[COL_CORRECTCOLOUR*3 + 2] = 1.0F;
+
+    /* We want to make sure we can distinguish COL_CORRECTCOLOUR
+     * (which we hard-code as white) from COL_BACKGROUND (which
+     * could default to white on some platforms).
+     * Code borrowed from fifteen.c. */
+    max = ret[COL_BACKGROUND*3];
+    for (i = 1; i < 3; i++)
+        if (ret[COL_BACKGROUND*3+i] > max)
+            max = ret[COL_BACKGROUND*3+i];
+    if (max * 1.2F > 1.0F) {
+        for (i = 0; i < 3; i++)
+            ret[COL_BACKGROUND*3+i] /= (max * 1.2F);
+    }
+
+    /* We also want to be able to tell the difference between BACKGROUND
+     * and EMPTY, for similar distinguishing-hint reasons. */
+    ret[COL_EMPTY * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 2.0F / 3.0F;
+    ret[COL_EMPTY * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 2.0F / 3.0F;
+    ret[COL_EMPTY * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 2.0F / 3.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    memset(ds, 0, sizeof(struct game_drawstate));
+
+    ds->guesses = snewn(state->params.nguesses, pegrow);
+    ds->nguesses = state->params.nguesses;
+    for (i = 0; i < state->params.nguesses; i++) {
+        ds->guesses[i] = new_pegrow(state->params.npegs);
+        invalidate_pegrow(ds->guesses[i]);
+    }
+    ds->solution = new_pegrow(state->params.npegs);
+    invalidate_pegrow(ds->solution);
+    ds->colours = new_pegrow(state->params.ncolours);
+    invalidate_pegrow(ds->colours);
+
+    ds->hintw = (state->params.npegs+1)/2; /* must round up */
+
+    ds->blit_peg = NULL;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    int i;
+
+    if (ds->blit_peg) blitter_free(dr, ds->blit_peg);
+    free_pegrow(ds->colours);
+    free_pegrow(ds->solution);
+    for (i = 0; i < ds->nguesses; i++)
+        free_pegrow(ds->guesses[i]);
+    sfree(ds->guesses);
+    sfree(ds);
+}
+
+static void draw_peg(drawing *dr, game_drawstate *ds, int cx, int cy,
+                     int moving, int labelled, int col)
+{
+    /*
+     * Some platforms antialias circles, which means we shouldn't
+     * overwrite a circle of one colour with a circle of another
+     * colour without erasing the background first. However, if the
+     * peg is the one being dragged, we don't erase the background
+     * because we _want_ it to alpha-blend nicely into whatever's
+     * behind it.
+     */
+    if (!moving)
+        draw_rect(dr, cx-CGAP, cy-CGAP, PEGSZ+CGAP*2, PEGSZ+CGAP*2,
+                  COL_BACKGROUND);
+    if (PEGRAD > 0) {
+        draw_circle(dr, cx+PEGRAD, cy+PEGRAD, PEGRAD,
+                    COL_EMPTY + col, (col ? COL_FRAME : COL_EMPTY));
+    } else
+        draw_rect(dr, cx, cy, PEGSZ, PEGSZ, COL_EMPTY + col);
+
+    if (labelled && col) {
+        char buf[2];
+        buf[0] = 'a'-1 + col;
+        buf[1] = '\0';
+        draw_text(dr, cx+PEGRAD, cy+PEGRAD, FONT_VARIABLE, PEGRAD,
+                  ALIGN_HCENTRE|ALIGN_VCENTRE, COL_FRAME, buf);
+    }
+
+    draw_update(dr, cx-CGAP, cy-CGAP, PEGSZ+CGAP*2, PEGSZ+CGAP*2);
+}
+
+static void draw_cursor(drawing *dr, game_drawstate *ds, int x, int y)
+{
+    draw_circle(dr, x+PEGRAD, y+PEGRAD, PEGRAD+CGAP, -1, COL_CURSOR);
+
+    draw_update(dr, x-CGAP, y-CGAP, PEGSZ+CGAP*2, PEGSZ+CGAP*2);
+}
+
+static void guess_redraw(drawing *dr, game_drawstate *ds, int guess,
+                         pegrow src, int *holds, int cur_col, int force,
+                         int labelled)
+{
+    pegrow dest;
+    int rowx, rowy, i, scol;
+
+    if (guess == -1) {
+        dest = ds->solution;
+        rowx = SOLN_OX;
+        rowy = SOLN_OY;
+    } else {
+        dest = ds->guesses[guess];
+        rowx = GUESS_X(guess,0);
+        rowy = GUESS_Y(guess,0);
+    }
+    if (src) assert(src->npegs == dest->npegs);
+
+    for (i = 0; i < dest->npegs; i++) {
+        scol = src ? src->pegs[i] : 0;
+        if (i == cur_col)
+            scol |= 0x1000;
+        if (holds && holds[i])
+            scol |= 0x2000;
+        if (labelled)
+            scol |= 0x4000;
+        if ((dest->pegs[i] != scol) || force) {
+            draw_peg(dr, ds, rowx + PEGOFF * i, rowy, FALSE, labelled,
+                     scol &~ 0x7000);
+            /*
+             * Hold marker.
+             */
+            draw_rect(dr, rowx + PEGOFF * i, rowy + PEGSZ + ds->gapsz/2,
+                      PEGSZ, 2, (scol & 0x2000 ? COL_HOLD : COL_BACKGROUND));
+            draw_update(dr, rowx + PEGOFF * i, rowy + PEGSZ + ds->gapsz/2,
+                        PEGSZ, 2);
+            if (scol & 0x1000)
+                draw_cursor(dr, ds, rowx + PEGOFF * i, rowy);
+        }
+        dest->pegs[i] = scol;
+    }
+}
+
+static void hint_redraw(drawing *dr, game_drawstate *ds, int guess,
+                        pegrow src, int force, int cursor, int markable)
+{
+    pegrow dest = ds->guesses[guess];
+    int rowx, rowy, i, scol, col, hintlen;
+    int need_redraw;
+    int emptycol = (markable ? COL_FLASH : COL_EMPTY);
+
+    if (src) assert(src->npegs == dest->npegs);
+
+    hintlen = (dest->npegs + 1)/2;
+
+    /*
+     * Because of the possible presence of the cursor around this
+     * entire section, we redraw all or none of it but never part.
+     */
+    need_redraw = FALSE;
+
+    for (i = 0; i < dest->npegs; i++) {
+        scol = src ? src->feedback[i] : 0;
+        if (i == 0 && cursor)
+            scol |= 0x1000;
+        if (i == 0 && markable)
+            scol |= 0x2000;
+        if ((scol != dest->feedback[i]) || force) {
+            need_redraw = TRUE;
+        }
+        dest->feedback[i] = scol;
+    }
+
+    if (need_redraw) {
+        int hinth = HINTSZ + GAP + HINTSZ;
+        int hx,hy,hw,hh;
+
+        hx = HINT_X(guess)-GAP; hy = HINT_Y(guess)-GAP;
+        hw = HINT_W+GAP*2; hh = hinth+GAP*2;
+
+        /* erase a large background rectangle */
+        draw_rect(dr, hx, hy, hw, hh, COL_BACKGROUND);
+
+        for (i = 0; i < dest->npegs; i++) {
+            scol = src ? src->feedback[i] : 0;
+            col = ((scol == FEEDBACK_CORRECTPLACE) ? COL_CORRECTPLACE :
+                   (scol == FEEDBACK_CORRECTCOLOUR) ? COL_CORRECTCOLOUR :
+                   emptycol);
+
+            rowx = HINT_X(guess);
+            rowy = HINT_Y(guess);
+            if (i < hintlen) {
+                rowx += HINTOFF * i;
+            } else {
+                rowx += HINTOFF * (i - hintlen);
+                rowy += HINTOFF;
+            }
+            if (HINTRAD > 0) {
+                draw_circle(dr, rowx+HINTRAD, rowy+HINTRAD, HINTRAD, col,
+                            (col == emptycol ? emptycol : COL_FRAME));
+            } else {
+                draw_rect(dr, rowx, rowy, HINTSZ, HINTSZ, col);
+            }
+        }
+        if (cursor) {
+            int x1,y1,x2,y2;
+            x1 = hx + CGAP; y1 = hy + CGAP;
+            x2 = hx + hw - CGAP; y2 = hy + hh - CGAP;
+            draw_line(dr, x1, y1, x2, y1, COL_CURSOR);
+            draw_line(dr, x2, y1, x2, y2, COL_CURSOR);
+            draw_line(dr, x2, y2, x1, y2, COL_CURSOR);
+            draw_line(dr, x1, y2, x1, y1, COL_CURSOR);
+        }
+
+        draw_update(dr, hx, hy, hw, hh);
+    }
+}
+
+static void currmove_redraw(drawing *dr, game_drawstate *ds, int guess, int col)
+{
+    int ox = GUESS_X(guess, 0), oy = GUESS_Y(guess, 0), off = PEGSZ/4;
+
+    draw_rect(dr, ox-off-1, oy, 2, PEGSZ, col);
+    draw_update(dr, ox-off-1, oy, 2, PEGSZ);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int i, new_move;
+
+    new_move = (state->next_go != ds->next_go) || !ds->started;
+
+    if (!ds->started) {
+      draw_rect(dr, 0, 0, ds->w, ds->h, COL_BACKGROUND);
+      draw_rect(dr, SOLN_OX, SOLN_OY - ds->gapsz - 1, SOLN_W, 2, COL_FRAME);
+      draw_update(dr, 0, 0, ds->w, ds->h);
+    }
+
+    if (ds->drag_col != 0) {
+        debug(("Loading from blitter."));
+        blitter_load(dr, ds->blit_peg, ds->blit_ox, ds->blit_oy);
+        draw_update(dr, ds->blit_ox, ds->blit_oy, PEGSZ, PEGSZ);
+    }
+
+    /* draw the colours */
+    for (i = 0; i < state->params.ncolours; i++) {
+        int val = i+1;
+        if (ui->display_cur && ui->colour_cur == i)
+            val |= 0x1000;
+        if (ui->show_labels)
+            val |= 0x2000;
+        if (ds->colours->pegs[i] != val) {
+            draw_peg(dr, ds, COL_X(i), COL_Y(i), FALSE, ui->show_labels, i+1);
+            if (val & 0x1000)
+                draw_cursor(dr, ds, COL_X(i), COL_Y(i));
+            ds->colours->pegs[i] = val;
+        }
+    }
+
+    /* draw the guesses (so far) and the hints
+     * (in reverse order to avoid trampling holds, and postponing the
+     * next_go'th to not overrender the top of the circular cursor) */
+    for (i = state->params.nguesses - 1; i >= 0; i--) {
+        if (i < state->next_go || state->solved) {
+            /* this info is stored in the game_state already */
+            guess_redraw(dr, ds, i, state->guesses[i], NULL, -1, 0,
+                         ui->show_labels);
+            hint_redraw(dr, ds, i, state->guesses[i],
+                        i == (state->next_go-1) ? 1 : 0, FALSE, FALSE);
+        } else if (i > state->next_go) {
+            /* we've not got here yet; it's blank. */
+            guess_redraw(dr, ds, i, NULL, NULL, -1, 0, ui->show_labels);
+            hint_redraw(dr, ds, i, NULL, 0, FALSE, FALSE);
+        }
+    }
+    if (!state->solved) {
+        /* this is the one we're on; the (incomplete) guess is stored in
+         * the game_ui. */
+        guess_redraw(dr, ds, state->next_go, ui->curr_pegs,
+                     ui->holds, ui->display_cur ? ui->peg_cur : -1, 0,
+                     ui->show_labels);
+        hint_redraw(dr, ds, state->next_go, NULL, 1,
+                    ui->display_cur && ui->peg_cur == state->params.npegs,
+                    ui->markable);
+    }
+
+    /* draw the 'current move' and 'able to mark' sign. */
+    if (new_move)
+        currmove_redraw(dr, ds, ds->next_go, COL_BACKGROUND);
+    if (!state->solved)
+        currmove_redraw(dr, ds, state->next_go, COL_HOLD);
+
+    /* draw the solution (or the big rectangle) */
+    if ((!state->solved ^ !ds->solved) || !ds->started) {
+        draw_rect(dr, SOLN_OX, SOLN_OY, SOLN_W, SOLN_H,
+                  state->solved ? COL_BACKGROUND : COL_EMPTY);
+        draw_update(dr, SOLN_OX, SOLN_OY, SOLN_W, SOLN_H);
+    }
+    if (state->solved)
+        guess_redraw(dr, ds, -1, state->solution, NULL, -1, !ds->solved,
+                     ui->show_labels);
+    ds->solved = state->solved;
+
+    ds->next_go = state->next_go;
+
+    /* if ui->drag_col != 0, save the screen to the blitter,
+     * draw the peg where we saved, and set ds->drag_* == ui->drag_*. */
+    if (ui->drag_col != 0) {
+        int ox = ui->drag_x - (PEGSZ/2);
+        int oy = ui->drag_y - (PEGSZ/2);
+        ds->blit_ox = ox - 1; ds->blit_oy = oy - 1;
+        debug(("Saving to blitter at (%d,%d)", ds->blit_ox, ds->blit_oy));
+        blitter_save(dr, ds->blit_peg, ds->blit_ox, ds->blit_oy);
+        draw_peg(dr, ds, ox, oy, TRUE, ui->show_labels, ui->drag_col);
+    }
+    ds->drag_col = ui->drag_col;
+
+    ds->started = 1;
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    /*
+     * We return nonzero whenever the solution has been revealed, even
+     * (on spoiler grounds) if it wasn't guessed correctly. The
+     * correct return value from this function is already in
+     * state->solved.
+     */
+    return state->solved;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame guess
+#endif
+
+const struct game thegame = {
+    "Guess", "games.guess", "guess",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PEG_PREFER_SZ, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/html/blackbox.html b/apps/plugins/puzzles/html/blackbox.html
new file mode 100644
index 0000000000..f98604f12f
--- /dev/null
+++ b/apps/plugins/puzzles/html/blackbox.html
@@ -0,0 +1,16 @@
+Black Box
+<p>
+Determine where the hidden balls are in the box, by observing the
+behaviour of light beams fired into the box from the sides.
+<p>
+Click in a square around the edge of the box to send a beam into the
+box. Possible results are 'H' (the beam hit a ball dead-on and
+stopped), 'R' (the beam was either reflected back the way it came or
+there was a ball just to one side of its entry point) or a number
+appearing in two squares (indicating that the beam entered one of
+those squares and emerged from the other).
+<p>
+Click in the middle of the box to place your guessed ball positions.
+When you have placed enough, a green button will appear in the top
+left; click that to indicate that you think you have the answer.
+You can also right-click to mark squares as definitely known.
diff --git a/apps/plugins/puzzles/html/bridges.html b/apps/plugins/puzzles/html/bridges.html
new file mode 100644
index 0000000000..06ec2d4d4b
--- /dev/null
+++ b/apps/plugins/puzzles/html/bridges.html
@@ -0,0 +1,13 @@
+Bridges
+<p>
+Draw horizontal or vertical bridges to link up all the islands.
+Bridges may be single or double; they may not cross; the islands
+must all end up connected to each other; the number in each island
+must match the number of bridges that end at that island (counting
+double bridges as two). Note that loops of bridges are permitted.
+<p>
+Click on an island and drag left, right, up or down to draw a bridge
+to the next island in that direction. Do the same again to create a
+double bridge, and again to remove the bridge if you change your
+mind. Click on an island without dragging to mark the island as
+completed once you think you have placed all its bridges.
diff --git a/apps/plugins/puzzles/html/cube.html b/apps/plugins/puzzles/html/cube.html
new file mode 100644
index 0000000000..f08e16c38d
--- /dev/null
+++ b/apps/plugins/puzzles/html/cube.html
@@ -0,0 +1,14 @@
+Cube
+<p>
+Roll the cube around the grid, picking up the blue squares on its
+faces. Try to get all the blue squares on to the object at the same
+time, in as few moves as possible.
+<p>
+Use the arrow keys to roll the cube, or click the mouse where you
+want it to roll towards. After every roll, the grid square and cube
+face that you brought into contact swap their colours, so that a
+non-blue cube face can pick up a blue square, but a blue face rolled
+on to a non-blue square puts it down again.
+<p>
+When you have mastered the cube, use the Type menu to select other
+regular solids!
diff --git a/apps/plugins/puzzles/html/dominosa.html b/apps/plugins/puzzles/html/dominosa.html
new file mode 100644
index 0000000000..d2f672806a
--- /dev/null
+++ b/apps/plugins/puzzles/html/dominosa.html
@@ -0,0 +1,10 @@
+Dominosa
+<p>
+Tile the rectangle with dominoes (1&times;2 rectangles) so that
+every possible domino appears exactly once (that is, every possible
+pair of numbers, including doubles).
+<p>
+Click between two adjacent numbers to place or remove a domino.
+Right-click to place a line between numbers if you think a domino
+definitely cannot go there. Dominoes light up red if two identical
+ones appear on the grid.
diff --git a/apps/plugins/puzzles/html/fifteen.html b/apps/plugins/puzzles/html/fifteen.html
new file mode 100644
index 0000000000..53053b440d
--- /dev/null
+++ b/apps/plugins/puzzles/html/fifteen.html
@@ -0,0 +1,6 @@
+Fifteen
+<p>
+Slide the tiles around the box until they appear in numerical order
+from the top left, with the hole in the bottom right corner.
+<p>
+Click on a tile to slide it towards the hole.
diff --git a/apps/plugins/puzzles/html/filling.html b/apps/plugins/puzzles/html/filling.html
new file mode 100644
index 0000000000..70ce16d4a9
--- /dev/null
+++ b/apps/plugins/puzzles/html/filling.html
@@ -0,0 +1,12 @@
+Filling
+<p>
+Write a number in every blank square of the grid. When the grid is
+full, every orthogonally connected group of identical numbers should
+have an area equal to that number: so 1s always appear alone, 2s in
+pairs, and so on.
+<p>
+To place a number, click the mouse in a blank square to select it,
+then type the number you want on the keyboard. You can also drag to
+select multiple squares, and then type a number to place it in all
+of them. To erase numbers, select one or more squares in the same
+way and then press Backspace.
diff --git a/apps/plugins/puzzles/html/flip.html b/apps/plugins/puzzles/html/flip.html
new file mode 100644
index 0000000000..404aae6b9a
--- /dev/null
+++ b/apps/plugins/puzzles/html/flip.html
@@ -0,0 +1,10 @@
+Flip
+<p>
+Try to light up all the squares in the grid by flipping combinations
+of them.
+<p>
+Click in a square to flip it and some of its neighbours. The diagram
+in each square indicates which other squares will flip.
+<p>
+Select one of the 'Random' settings from the Type menu for more
+varied puzzles.
diff --git a/apps/plugins/puzzles/html/flood.html b/apps/plugins/puzzles/html/flood.html
new file mode 100644
index 0000000000..cf09eac766
--- /dev/null
+++ b/apps/plugins/puzzles/html/flood.html
@@ -0,0 +1,8 @@
+Flood
+<p>
+Try to get the whole grid to be the same colour within the given
+number of moves, by repeatedly flood-filling the top left corner in
+different colours.
+<p>
+Click in a square to flood-fill the top left corner with that square's
+colour.
diff --git a/apps/plugins/puzzles/html/galaxies.html b/apps/plugins/puzzles/html/galaxies.html
new file mode 100644
index 0000000000..8041a95cee
--- /dev/null
+++ b/apps/plugins/puzzles/html/galaxies.html
@@ -0,0 +1,11 @@
+Galaxies
+<p>
+Draw lines along grid edges so as to divide the grid up into
+regions. Every region should have two-way rotational symmetry, and
+should contain exactly one dot which is in its centre.
+<p>
+Click on a grid edge to add or remove a line. Right-click on a dot
+and drag the mouse to place an arrow in a grid square pointing to
+that dot, to indicate that you think that square must belong in the
+same region as that dot. Right-drag an existing arrow to move it, or
+drop it off the edge of the grid to remove it.
diff --git a/apps/plugins/puzzles/html/group.html b/apps/plugins/puzzles/html/group.html
new file mode 100644
index 0000000000..c0f52de629
--- /dev/null
+++ b/apps/plugins/puzzles/html/group.html
@@ -0,0 +1,52 @@
+unfinished:Group
+<p>
+Fill in the grid with the letters shown to the top and left of it, so
+that the full grid is a valid
+<a href="http://en.wikipedia.org/wiki/Cayley_table">Cayley table</a>
+for a
+<a href="http://en.wikipedia.org/wiki/Group_(mathematics)">group</a>.
+<p>
+If you don't already know what a group is, I don't really recommend
+trying to play this game. But if you want to try anyway, the above is
+equivalent to saying that the following conditions must be satisfied:
+<ul>
+<li>
+<strong>Latin square</strong>. Every row and column must contain
+exactly one of each letter.
+<li>
+<strong>Identity</strong>. There must be some letter <i>e</i> such
+that, for all <i>a</i>, the letter in row <i>e</i> column <i>a</i> and
+the one in row <i>a</i> column <i>e</i> are both <i>a</i>. In the
+default mode, this letter is always <i>e</i> and its row and column
+are filled in for you; by reconfiguring the game using the Type menu,
+you can select a mode in which you have to work out which letter is
+the identity.
+<li>
+<strong>Inverses</strong>. For every letter <i>a</i>, there must be
+some letter <i>b</i> (which may sometimes be the same letter
+as <i>a</i>) such that the letters in row <i>a</i> column <i>b</i> and
+in row <i>b</i> column <i>a</i> are both the identity letter (as
+defined above).
+<li>
+<strong>Associativity</strong>. For every combination of
+letters <i>a</i>, <i>b</i>, and <i>c</i>, denote the letter in
+row <i>a</i> column <i>b</i> by <i>d</i>, and the one in row <i>b</i>
+column <i>c</i> by <i>e</i>. Then the letters in row <i>d</i>
+column <i>c</i> and in row <i>a</i> column <i>e</i> must be the same.
+</ul>
+<p>
+To place a letter, click in a square to select it, then type the
+letter on the keyboard. To erase a letter, click to select a square
+and then press Backspace.
+<p>
+Right-click in a square and then type a letter to add or remove the
+number as a pencil mark, indicating letters that you think
+<em>might</em> go in that square.
+<p>
+You can rearrange the order of elements in the rows and columns by
+dragging the column or row headings back and forth. (The rows and
+columns will stay in sync with each other.) Also,
+left-clicking <em>between</em> two row or column headings will add or
+remove a thick line between those two rows and the corresponding pair
+of columns (which is useful if you're considering a subgroup and its
+cosets).
diff --git a/apps/plugins/puzzles/html/guess.html b/apps/plugins/puzzles/html/guess.html
new file mode 100644
index 0000000000..1e4fc1ed04
--- /dev/null
+++ b/apps/plugins/puzzles/html/guess.html
@@ -0,0 +1,12 @@
+Guess
+<p>
+Try to guess the hidden combination of colours. You will be given
+limited information about each guess you make, enabling you to
+refine the next guess.
+<p>
+Drag from the colours on the left into the topmost unfilled row to
+make a guess; then click on the small circles to submit that guess.
+The small circles give you your feedback: black pegs indicate how
+many of the colours you guessed were the right colour in the right
+place, and white pegs indicate how many of the rest were the right
+colours but in the wrong place.
diff --git a/apps/plugins/puzzles/html/inertia.html b/apps/plugins/puzzles/html/inertia.html
new file mode 100644
index 0000000000..20077c0048
--- /dev/null
+++ b/apps/plugins/puzzles/html/inertia.html
@@ -0,0 +1,14 @@
+Inertia
+<p>
+Slide the ball around the grid picking up the gems. Every time the
+ball moves, it will keep sliding until it either hits a wall, or
+stops on a stop square (the broken circles). Try to collect every
+gem without running into any of the mines.
+<p>
+Use the numeric keypad to slide the ball horizontally, vertically or
+diagonally. Alternatively, click on the grid to make the ball move
+towards where you clicked.
+<p>
+If you hit a mine and explode, you can select Undo from the Game
+menu and continue playing; the game will track how many times you
+died.
diff --git a/apps/plugins/puzzles/html/javapage.pl b/apps/plugins/puzzles/html/javapage.pl
new file mode 100755
index 0000000000..cd5e6a1669
--- /dev/null
+++ b/apps/plugins/puzzles/html/javapage.pl
@@ -0,0 +1,104 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+
+open my $footerfile, "<", shift @ARGV or die "footer: open: $!\n";
+my $footer = "";
+$footer .= $_ while <$footerfile>;
+close $footerfile;
+
+for my $arg (@ARGV) {
+    $arg =~ /(.*\/)?([^\/]+)\.html$/ or die;
+    my $filename = $2;
+    open my $gamefile, "<", $arg or die "$arg: open: $!\n";
+    my $unfinished = 0;
+    my $docname = $filename;
+    chomp(my $puzzlename = <$gamefile>);
+    while ($puzzlename =~ s/^([^:=]+)(=([^:]+))?://) {
+        if ($1 eq "unfinished") {
+            $unfinished = 1;
+        } elsif ($1 eq "docname") {
+            $docname = $3;
+        } else {
+            die "$arg: unknown keyword '$1'\n";
+        }
+    }
+    my $instructions = "";
+    $instructions .= $_ while <$gamefile>;
+    close $gamefile;
+
+    open my $outpage, ">", "${filename}.html";
+
+    my $unfinishedtitlefragment = $unfinished ? "an unfinished puzzle " : "";
+    my $unfinishedheading = $unfinished ? "<h2 align=center>an unfinished puzzle</h2>\n" : "";
+    my $unfinishedpara;
+    my $links;
+    if ($unfinished) {
+        $unfinishedpara = <<EOF;
+<p>
+You have found your way to a page containing an <em>unfinished</em>
+puzzle in my collection, not linked from the <a href="../">main
+puzzles page</a>. Don't be surprised if things are hard to understand
+or don't work as you expect.
+EOF
+        $links = <<EOF;
+<p align="center">
+<a href="../">Back to main puzzles page</a> (which does not link to this)
+EOF
+    } else {
+        $unfinishedpara = "";
+        $links = <<EOF;
+<p align="center">
+<a href="../doc/${docname}.html#${docname}">Full instructions</a>
+|
+<a href="../">Back to main puzzles page</a>
+EOF
+    }
+
+    print $outpage <<EOF;
+<html>
+<head>
+<title>${puzzlename}, ${unfinishedtitlefragment}from Simon Tatham's Portable Puzzle Collection</title>
+<link rel="stylesheet" type="text/css" href="../../sitestyle.css" name="Simon Tatham's Home Page Style">
+<script type="text/javascript" src="resize-puzzle-applet.js"></script>
+</head>
+<body onLoad="initResizablePuzzleApplet();">
+<h1 align=center>${puzzlename}</h1>
+${unfinishedheading}
+<h2 align=center>from Simon Tatham's Portable Puzzle Collection</h2>
+
+${unfinishedpara}
+
+<p align="center">
+<table cellpadding="0">
+<tr>
+<td>
+<applet id="applet" archive="${filename}.jar" code="PuzzleApplet"
+        width="700" height="500">
+</applet>
+</td>
+<td>
+<div id="eresize" style="width:5px;height:500px;cursor:e-resize;"></div>
+</td>
+</tr>
+<td>
+<div id="sresize" style="width:700px;height:5px;cursor:s-resize;"></div>
+</td>
+<td>
+<div id="seresize" style="width:5px;height:5px;cursor:se-resize;"></div>
+</td>
+</tr>
+</table>
+
+${instructions}
+
+${links}
+
+${footer}
+</body>
+</html>
+EOF
+
+    close $outpage;
+}
diff --git a/apps/plugins/puzzles/html/jspage.pl b/apps/plugins/puzzles/html/jspage.pl
new file mode 100755
index 0000000000..19868bd948
--- /dev/null
+++ b/apps/plugins/puzzles/html/jspage.pl
@@ -0,0 +1,120 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+
+open my $footerfile, "<", shift @ARGV or die "footer: open: $!\n";
+my $footer = "";
+$footer .= $_ while <$footerfile>;
+close $footerfile;
+
+for my $arg (@ARGV) {
+    $arg =~ /(.*\/)?([^\/]+)\.html$/ or die;
+    my $filename = $2;
+    open my $gamefile, "<", $arg or die "$arg: open: $!\n";
+    my $unfinished = 0;
+    my $docname = $filename;
+    chomp(my $puzzlename = <$gamefile>);
+    while ($puzzlename =~ s/^([^:=]+)(=([^:]+))?://) {
+        if ($1 eq "unfinished") {
+            $unfinished = 1;
+        } elsif ($1 eq "docname") {
+            $docname = $3;
+        } else {
+            die "$arg: unknown keyword '$1'\n";
+        }
+    }
+    my $instructions = "";
+    $instructions .= $_ while <$gamefile>;
+    close $gamefile;
+
+    open my $outpage, ">", "${filename}.html";
+
+    my $unfinishedtitlefragment = $unfinished ? "an unfinished puzzle " : "";
+    my $unfinishedheading = $unfinished ? "<h2 align=center>an unfinished puzzle</h2>\n" : "";
+    my $unfinishedpara;
+    my $links;
+    if ($unfinished) {
+        $unfinishedpara = <<EOF;
+<p>
+You have found your way to a page containing an <em>unfinished</em>
+puzzle in my collection, not linked from the <a href="../">main
+puzzles page</a>. Don't be surprised if things are hard to understand
+or don't work as you expect.
+EOF
+        $links = <<EOF;
+<p align="center">
+<a href="../">Back to main puzzles page</a> (which does not link to this)
+EOF
+    } else {
+        $unfinishedpara = "";
+        $links = <<EOF;
+<p align="center">
+<a href="../doc/${docname}.html#${docname}">Full instructions</a>
+|
+<a href="../">Back to main puzzles page</a>
+EOF
+    }
+
+    print $outpage <<EOF;
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ASCII" />
+<title>${puzzlename}, ${unfinishedtitlefragment}from Simon Tatham's Portable Puzzle Collection</title>
+<script type="text/javascript" src="${filename}.js"></script>
+</head>
+<body onLoad="initPuzzle();">
+<h1 align=center>${puzzlename}</h1>
+${unfinishedheading}
+<h2 align=center>from Simon Tatham's Portable Puzzle Collection</h2>
+
+${unfinishedpara}
+
+<hr>
+<div id="puzzle" style="display: none">
+<p align=center>
+  <input type="button" id="new" value="New game">
+  <input type="button" id="restart" value="Restart game">
+  <input type="button" id="undo" value="Undo move">
+  <input type="button" id="redo" value="Redo move">
+  <input type="button" id="solve" value="Solve game">
+  <input type="button" id="specific" value="Enter game ID">
+  <input type="button" id="random" value="Enter random seed">
+  <select id="gametype"></select>
+</p>
+<div align=center>
+  <div id="resizable" style="position:relative; left:0; top:0">
+  <canvas style="display: block" id="puzzlecanvas" width="1px" height="1px" tabindex="1">
+  </canvas>
+  <div id="statusbarholder" style="display: block">
+  </div>
+  </div>
+  <p>
+    Link to this puzzle:
+    <a id="permalink-desc">by game ID</a>
+    <a id="permalink-seed">by random seed</a>
+  </p>
+</div>
+</div>
+<div id="apology">
+Sorry, this Javascript puzzle doesn't seem to work in your web
+browser. Perhaps you have Javascript disabled, or perhaps your browser
+doesn't provide a feature that the puzzle code requires (such as
+<a href="https://developer.mozilla.org/en-US/docs/JavaScript/Typed_arrays">typed arrays</a>).
+These puzzles have been successfully run in Firefox 19, Chrome 26,
+Internet Explorer 10 and Safari 6.
+</div>
+<hr>
+
+${instructions}
+
+${links}
+
+${footer}
+</body>
+</html>
+EOF
+
+    close $outpage;
+}
diff --git a/apps/plugins/puzzles/html/keen.html b/apps/plugins/puzzles/html/keen.html
new file mode 100644
index 0000000000..bd0eb3644d
--- /dev/null
+++ b/apps/plugins/puzzles/html/keen.html
@@ -0,0 +1,15 @@
+Keen
+<p>
+Fill in the grid with digits from 1 to the grid size, so that every
+digit appears exactly once in each row and column, and so that all
+the arithmetic clues are satisfied (i.e. the clue number in each
+thick box should be possible to construct from the digits in the box
+using the specified arithmetic operation).
+<p>
+To place a number, click in a square to select it, then type the
+number on the keyboard. To erase a number, click to select a square
+and then press Backspace.
+<p>
+Right-click in a square and then type a number to add or remove the
+number as a pencil mark, indicating numbers that you think
+<em>might</em> go in that square.
diff --git a/apps/plugins/puzzles/html/lightup.html b/apps/plugins/puzzles/html/lightup.html
new file mode 100644
index 0000000000..2de2f91bb9
--- /dev/null
+++ b/apps/plugins/puzzles/html/lightup.html
@@ -0,0 +1,10 @@
+Light Up
+<p>
+Place light bulbs in the grid so as to light up all the blank
+squares. A light illuminates its own square and all the squares in
+the same row or column unless blocked by walls (black squares).
+Lights may not illuminate each other. Each numbered square must be
+orthogonally adjacent to exactly the given number of lights.
+<p>
+Click on a square to place or remove a light. Right-click to place a
+dot indicating that you think there is no light in that square.
diff --git a/apps/plugins/puzzles/html/loopy.html b/apps/plugins/puzzles/html/loopy.html
new file mode 100644
index 0000000000..96f3a9d908
--- /dev/null
+++ b/apps/plugins/puzzles/html/loopy.html
@@ -0,0 +1,13 @@
+Loopy
+<p>
+Form a single closed loop out of the grid edges, in such a way that
+every numbered square has exactly that many of its edges included in
+the loop.
+<p>
+Click on a grid edge to mark it as part of the loop (black), and
+again to return to marking it as undecided (yellow). Right-click on
+a grid edge to mark it as definitely not part of the loop (faint
+grey), and again to mark it as undecided again.
+<p>
+When you have mastered the square grid, look in the Type menu for
+many other types of tiling!
diff --git a/apps/plugins/puzzles/html/magnets.html b/apps/plugins/puzzles/html/magnets.html
new file mode 100644
index 0000000000..2807569a6c
--- /dev/null
+++ b/apps/plugins/puzzles/html/magnets.html
@@ -0,0 +1,17 @@
+Magnets
+<p>
+Fill each domino shape with either a magnet (consisting of a + and
+&#8722; pole) or a neutral domino (green).
+<p>
+The number of + poles that in each row and column must match the
+numbers along the top and left; the number of &#8722; poles must
+match the numbers along the bottom and right. Two + poles may not be
+orthogonally adjacent to each other, and similarly two &#8722; poles.
+<p>
+Left-click a domino to toggle it between being empty and being a
+magnet (the + is placed in the end you click). Right-click to toggle
+between empty, neutral, and a ?? mark indicating that you're sure
+it's a magnet but don't yet know which way round it goes.
+<p>
+Left-click a clue to mark it as done (grey it out). To unmark a clue
+as done, left-click it again.
diff --git a/apps/plugins/puzzles/html/map.html b/apps/plugins/puzzles/html/map.html
new file mode 100644
index 0000000000..5f81793054
--- /dev/null
+++ b/apps/plugins/puzzles/html/map.html
@@ -0,0 +1,15 @@
+Map
+<p>
+Colour the map with four colours, so that no two adjacent regions
+have the same colour. (Regions touching at only one corner do not
+count as adjacent.) There is a unique colouring consistent with the
+coloured regions you are already given.
+<p>
+Drag from a coloured region to a blank one to colour the latter the
+same colour as the former. Drag from outside the grid into a region
+to erase its colour. (You cannot change the colours of the regions
+you are given at the start of the game.)
+<p>
+Right-drag from a coloured region to a blank one to add dots marking
+the latter region as <em>possibly</em> the same colour as the
+former, or to remove those dots again.
diff --git a/apps/plugins/puzzles/html/mines.html b/apps/plugins/puzzles/html/mines.html
new file mode 100644
index 0000000000..d17d6ffa80
--- /dev/null
+++ b/apps/plugins/puzzles/html/mines.html
@@ -0,0 +1,18 @@
+Mines
+<p>
+Try to expose every square in the grid that is not one of the hidden
+mines, without opening any square that is a mine.
+<p>
+Click in a square to open it. Every opened square are marked with
+the number of mines in the surrounding 8 squares, if there are any;
+if not, all the surrounding squares are automatically opened.
+<p>
+Right-click in a square to mark it with a flag if you think it is a
+mine. If a numbered square has exactly the right number of flags
+around it, you can click in it to open all the squares around it
+that are not flagged.
+<p>
+The first square you open is guaranteed to be safe, and (by default)
+you are guaranteed to be able to solve the whole grid by deduction
+rather than guesswork. (Deductions may require you to think about
+the total number of mines.)
diff --git a/apps/plugins/puzzles/html/net.html b/apps/plugins/puzzles/html/net.html
new file mode 100644
index 0000000000..08bffbac3e
--- /dev/null
+++ b/apps/plugins/puzzles/html/net.html
@@ -0,0 +1,17 @@
+Net
+<p>
+Rotate the grid squares so that they all join up into a single
+connected network with no loops.
+<p>
+Left-click in a square to rotate it anticlockwise. Right-click to
+rotate it clockwise. Middle-click, or shift-left-click if you have
+no middle mouse button, to lock a square once you think it is
+correct (so you don't accidentally rotate it again); do the same
+again to unlock it if you change your mind.
+<p>
+Squares connected to the middle square are lit up. Aim to light up
+every square in the grid (not just the endpoint blobs).
+<p>
+When this gets too easy, select a 'wrapping' variant from the Type
+menu to enable grid lines to run off one edge of the playing area
+and come back on the opposite edge!
diff --git a/apps/plugins/puzzles/html/netslide.html b/apps/plugins/puzzles/html/netslide.html
new file mode 100644
index 0000000000..f1877417d4
--- /dev/null
+++ b/apps/plugins/puzzles/html/netslide.html
@@ -0,0 +1,14 @@
+Netslide
+<p>
+Slide the grid squares around so that they all join up into a single
+connected network with no loops.
+<p>
+Click on the arrows at the edges of the grid to move a row or column
+left, right, up or down. The square that falls off the end of the
+row comes back on the other end.
+<p>
+Squares connected to the middle square are lit up. Aim to light up
+every square in the grid (not just the endpoint blobs).
+<p>
+Connecting across a red barrier line is forbidden. On harder levels,
+there are fewer barriers, which makes it harder rather than easier!
diff --git a/apps/plugins/puzzles/html/palisade.html b/apps/plugins/puzzles/html/palisade.html
new file mode 100644
index 0000000000..5b6b933104
--- /dev/null
+++ b/apps/plugins/puzzles/html/palisade.html
@@ -0,0 +1,11 @@
+Palisade
+<p>
+Draw lines along the grid edges, in such a way that the grid is
+divided into connected regions, all of the size shown in the status
+line. Also, each square containing a number should have that many of
+its edges drawn in.
+<p>
+Click on a grid edge to mark it as a division between regions (black),
+and again to return to marking it as undecided (yellow). Right-click
+on a grid edge to mark it as definitely not part of the loop (faint
+grey), and again to mark it as undecided again.
diff --git a/apps/plugins/puzzles/html/pattern.html b/apps/plugins/puzzles/html/pattern.html
new file mode 100644
index 0000000000..54e05d6416
--- /dev/null
+++ b/apps/plugins/puzzles/html/pattern.html
@@ -0,0 +1,12 @@
+Pattern
+<p>
+Fill in the grid with a pattern of black and white squares, so that
+the numbers in each row and column match the lengths of consecutive
+runs of black squares.
+<p>
+Left-click in a square to mark it black; right-click (or hold Ctrl
+while left-clicking) to mark it white. Click and drag along a row or
+column to mark multiple squares black or white at once. Middle-click
+(or hold Shift while left-clicking) to return a square to grey
+(meaning undecided): dragging like that can erase a whole rectangle,
+not just a row or column.
diff --git a/apps/plugins/puzzles/html/pearl.html b/apps/plugins/puzzles/html/pearl.html
new file mode 100644
index 0000000000..2ca25a5ee0
--- /dev/null
+++ b/apps/plugins/puzzles/html/pearl.html
@@ -0,0 +1,13 @@
+Pearl
+<p>
+Draw a single closed loop by connecting together the centres of
+adjacent grid squares, so that some squares end up as corners, some as
+straights (horizontal or vertical), and some may be empty. Every
+square containing a black circle must be a corner not connected
+directly to another corner; every square containing a white circle
+must be a straight which is connected to <em>at least one</em> corner.
+<p>
+Drag between squares to draw or undraw pieces of the loop.
+Alternatively, left-click the edge between two squares to turn it on
+or off. Right-click an edge to mark it with a cross indicating that
+you are sure the loop does not go through it.
diff --git a/apps/plugins/puzzles/html/pegs.html b/apps/plugins/puzzles/html/pegs.html
new file mode 100644
index 0000000000..4a2378873e
--- /dev/null
+++ b/apps/plugins/puzzles/html/pegs.html
@@ -0,0 +1,8 @@
+Pegs
+<p>
+Jump one peg over another to remove the one you jumped over. Try to
+remove all but one peg.
+<p>
+Drag a peg into an empty space to make a move. The target space must
+be exactly two holes away from the starting peg, in an orthogonal
+direction, and there must be a peg in the hole in between.
diff --git a/apps/plugins/puzzles/html/range.html b/apps/plugins/puzzles/html/range.html
new file mode 100644
index 0000000000..bb5b59c4d2
--- /dev/null
+++ b/apps/plugins/puzzles/html/range.html
@@ -0,0 +1,21 @@
+Range
+<p>
+Colour some squares black, so as to meet the following conditions:
+<ul>
+<li>
+No two black squares are orthogonally adjacent.
+<li>
+No group of white squares is separated from the rest of the grid by
+black squares.
+<li>
+Each numbered cell can see precisely that many white squares in
+total by looking in all four orthogonal directions, counting itself.
+(Black squares block the view. So, for example, a 2 clue must be
+adjacent to three black squares or grid edges, and in the fourth
+direction there must be one white square and then a black one beyond
+it.)
+</ul>
+
+<p>
+Left-click to colour a square black. Right-click to mark a square
+with a dot, if you know it should not be black.
diff --git a/apps/plugins/puzzles/html/rect.html b/apps/plugins/puzzles/html/rect.html
new file mode 100644
index 0000000000..d23d827663
--- /dev/null
+++ b/apps/plugins/puzzles/html/rect.html
@@ -0,0 +1,10 @@
+docname=rectangles:Rectangles
+<p>
+Draw lines along the grid edges to divide the grid into rectangles,
+so that each rectangle contains exactly one numbered square and its
+area is equal to the number written in that square.
+<p>
+Click and drag from one grid corner to another, or from one square
+centre to another, to draw a rectangle. You can also drag along a
+grid line to just draw a line at a time, or just click on a single
+grid edge to draw or erase it.
diff --git a/apps/plugins/puzzles/html/samegame.html b/apps/plugins/puzzles/html/samegame.html
new file mode 100644
index 0000000000..e6de095210
--- /dev/null
+++ b/apps/plugins/puzzles/html/samegame.html
@@ -0,0 +1,14 @@
+Same Game
+<p>
+Try to empty the playing area completely, by removing connected
+groups of two or more squares of the same colour. Then try to score
+as much as possible, by removing large groups at a time instead of
+small ones.
+<p>
+Click on a coloured square to highlight the rest of its connected
+group. The status line will print the number of squares selected,
+and the score you would gain by removing them. Click again to remove
+the group; other squares will fall down to fill the space, and if
+you empty a whole column then the other columns will move up. You
+cannot remove a single isolated square: try to avoid dead-end
+positions where all remaining squares are isolated.
diff --git a/apps/plugins/puzzles/html/signpost.html b/apps/plugins/puzzles/html/signpost.html
new file mode 100644
index 0000000000..fa23e99de0
--- /dev/null
+++ b/apps/plugins/puzzles/html/signpost.html
@@ -0,0 +1,14 @@
+Signpost
+<p>
+Connect all the squares together into a sequence, so that every
+square's arrow points towards the square that follows it (though the
+next square can be any distance away in that direction).
+
+<p>
+Left-drag from a square to the square that should follow it, or
+right-drag from a square to the square that should precede it.
+
+<p>
+Left-drag a square off the grid to break all links to it. Right-drag
+a square off the grid to break all links to it and everything else
+in its connected chain.
diff --git a/apps/plugins/puzzles/html/singles.html b/apps/plugins/puzzles/html/singles.html
new file mode 100644
index 0000000000..252bffb380
--- /dev/null
+++ b/apps/plugins/puzzles/html/singles.html
@@ -0,0 +1,11 @@
+Singles
+<p>
+Black out some of the squares, in such a way that:
+<ul><li>no number appears twice in any row or column
+<li>no two black squares are adjacent
+<li>the white squares form a single connected group (connections
+along diagonals do not count).</ul>
+<p>
+Click in a square to black it out, and again to uncover it.
+Right-click in a square to mark it with a circle, indicating that
+you're sure it should <em>not</em> be blacked out.
diff --git a/apps/plugins/puzzles/html/sixteen.html b/apps/plugins/puzzles/html/sixteen.html
new file mode 100644
index 0000000000..4530469fe6
--- /dev/null
+++ b/apps/plugins/puzzles/html/sixteen.html
@@ -0,0 +1,8 @@
+Sixteen
+<p>
+Slide the grid squares around so that the numbers end up in
+consecutive order from the top left corner.
+<p>
+Click on the arrows at the edges of the grid to move a row or column
+left, right, up or down. The square that falls off the end of the
+row comes back on the other end.
diff --git a/apps/plugins/puzzles/html/slant.html b/apps/plugins/puzzles/html/slant.html
new file mode 100644
index 0000000000..d6d31aa302
--- /dev/null
+++ b/apps/plugins/puzzles/html/slant.html
@@ -0,0 +1,9 @@
+Slant
+<p>
+Fill in a diagonal line in every grid square so that there are no
+loops in the grid, and so that every numbered point has that many
+lines meeting at it.
+<p>
+Left-click in a square to mark it with a <code>\</code>; right-click
+to mark it with a <code>/</code>. Keep clicking in a square to
+cycle it between <code>\</code>, <code>/</code> and empty.
diff --git a/apps/plugins/puzzles/html/solo.html b/apps/plugins/puzzles/html/solo.html
new file mode 100644
index 0000000000..88ebd5cb29
--- /dev/null
+++ b/apps/plugins/puzzles/html/solo.html
@@ -0,0 +1,20 @@
+Solo
+<p>
+Fill in a number in every square so that every number appears
+exactly once in each row, each column and each block marked by thick
+lines.
+<p>
+To place a number, click in a square to select it, then type the
+number on the keyboard. To erase a number, click to select a square
+and then press Backspace.
+<p>
+Right-click in a square and then type a number to add or remove the
+number as a pencil mark, indicating numbers that you think
+<em>might</em> go in that square.
+<p>
+When you master the basic game, try Jigsaw mode (irregularly shaped
+blocks), X mode (the two main diagonals of the grid must also
+contain every number once), Killer mode (instead of single-cell
+clues you are given regions of the grid each of which must add up to
+a given total, again without reusing any digits), or all of those at
+once!
diff --git a/apps/plugins/puzzles/html/tents.html b/apps/plugins/puzzles/html/tents.html
new file mode 100644
index 0000000000..e3f6d5f0ea
--- /dev/null
+++ b/apps/plugins/puzzles/html/tents.html
@@ -0,0 +1,20 @@
+Tents
+<p>
+Place tents in the empty squares in such a way that:
+<ul>
+<li>no two tents are adjacent, even diagonally
+<li>the number of tents in each row and column matches the numbers
+around the edge of the grid
+<li>it is possible to match tents to trees so that each tree is
+orthogonally adjacent to its own tent (but may also be adjacent to
+other tents).
+</ul>
+<p>
+Click in a square to place or remove a tent. Right-click to mark a
+square as empty (not a tent). Right-click and drag along a row or
+column to mark many squares at once as empty.
+<p>
+Warning '!' marks appear to indicate adjacent tents. Numbers round
+the edge of the grid light up red to indicate they do not match the
+number of tents in the row. Groups of tents light up red to indicate
+that they have too few trees between them, and vice versa.
diff --git a/apps/plugins/puzzles/html/towers.html b/apps/plugins/puzzles/html/towers.html
new file mode 100644
index 0000000000..a710e0ab6e
--- /dev/null
+++ b/apps/plugins/puzzles/html/towers.html
@@ -0,0 +1,22 @@
+Towers
+<p>
+Fill in the grid with towers whose heights range from 1 to the grid
+size, so that every possible height appears exactly once in each row
+and column, and so that each clue around the edge counts the number
+of towers that are visible when looking into the grid from that
+direction. (Taller towers hide shorter ones behind them. So the
+sequence 2,1,4,3,5 would match a clue of 3 on the left, because the
+1 is hidden behind the 2 and the 3 is hidden behind the 4. On the
+right, it would match a clue of 1 because the 5 hides everything
+else.)
+<p>
+To place a tower, click in a square to select it, then type the
+desired height on the keyboard. To erase a tower, click to select a
+square and then press Backspace.
+<p>
+Right-click in a square and then type a number to add or remove the
+number as a pencil mark, indicating tower heights that you think
+<em>might</em> go in that square.
+<p>
+Left-click on a clue to mark it as done (grey it out). To unmark a
+clue as done, left-click on it again.
\ No newline at end of file
diff --git a/apps/plugins/puzzles/html/tracks.html b/apps/plugins/puzzles/html/tracks.html
new file mode 100644
index 0000000000..afabed37ac
--- /dev/null
+++ b/apps/plugins/puzzles/html/tracks.html
@@ -0,0 +1,19 @@
+Tracks
+<p>
+Complete the track from A to B so that the rows and
+columns contain the same number of track segments as are indicated in the
+clues to the top and right of the grid. There are only straight and
+90-degree curved rail sections, and the track may not cross itself.
+<p>
+Left-click on an edge between two squares to add a track segment between
+the two squares. Right-click on an edge to add a cross on the edge,
+indicating no track is possible there.
+<p>
+Left-click in a square to add a colour indicator showing that you know the
+square must contain a track, even if you don't know which edges it crosses
+yet. Right-click in a square to add a cross indicating it contains no
+track segment.
+<p>
+Left- or right-drag between squares to lay a straight line of is-track or
+is-not-track indicators, useful for filling in rows or columns to match the
+clue.
diff --git a/apps/plugins/puzzles/html/twiddle.html b/apps/plugins/puzzles/html/twiddle.html
new file mode 100644
index 0000000000..5f94e4e120
--- /dev/null
+++ b/apps/plugins/puzzles/html/twiddle.html
@@ -0,0 +1,15 @@
+Twiddle
+<p>
+Rotate square sections of the grid to arrange the squares into
+numerical order starting from the top left.
+<p>
+In the basic game, you rotate a 2&times;2 square section. Left-click
+in the centre of that section (i.e. on a corner point between four
+squares) to rotate the whole section anticlockwise. Right-click to
+rotate the section clockwise.
+<p>
+When you master the basic game, go to the Type menu to try it with
+larger rotating groups (for a 3&times;3 group you must click in the
+centre of a square to rotate the block around it). Or select the
+'orientable' mode in which every square must end up the right way
+round as well as in the right place. Or both!
diff --git a/apps/plugins/puzzles/html/undead.html b/apps/plugins/puzzles/html/undead.html
new file mode 100644
index 0000000000..c21374f6dc
--- /dev/null
+++ b/apps/plugins/puzzles/html/undead.html
@@ -0,0 +1,22 @@
+Undead
+<p>
+Fill in every grid square which doesn't contain a mirror with either a
+ghost, a vampire, or a zombie. The numbers round the grid edges show
+how many monsters must be visible along your line of sight if you look
+directly into the grid from that position, along a row or column.
+Zombies are always visible; ghosts are only visible when reflected in
+at least one mirror; vampires are only visible when not reflected in
+any mirror.
+
+<p>
+To place a monster, click in a square to select it, then type the
+monster's letter on the keyboard: G for a ghost, V for a vampire or Z
+for a zombie. To erase a monster, click to select a square and then
+press Backspace.
+<p>
+Right-click in a square and then type a letter to add or remove the
+monster as a pencil mark, indicating monsters that you think
+<em>might</em> go in that square.
+<p>
+Left-click on a clue to mark it as done (grey it out). To unmark a
+clue as done, left-click on it again.
diff --git a/apps/plugins/puzzles/html/unequal.html b/apps/plugins/puzzles/html/unequal.html
new file mode 100644
index 0000000000..085f82effc
--- /dev/null
+++ b/apps/plugins/puzzles/html/unequal.html
@@ -0,0 +1,14 @@
+Unequal
+<p>
+Fill in the grid with numbers from 1 to the grid size, so that every
+number appears exactly once in each row and column, and so that all
+the <code>&lt;</code> signs represent true inequalities (i.e. the
+number at the pointed end is smaller than the number at the open end).
+<p>
+To place a number, click in a square to select it, then type the
+number on the keyboard. To erase a number, click to select a square
+and then press Backspace.
+<p>
+Right-click in a square and then type a number to add or remove the
+number as a pencil mark, indicating numbers that you think
+<em>might</em> go in that square.
diff --git a/apps/plugins/puzzles/html/unruly.html b/apps/plugins/puzzles/html/unruly.html
new file mode 100644
index 0000000000..2cd3fb25f5
--- /dev/null
+++ b/apps/plugins/puzzles/html/unruly.html
@@ -0,0 +1,11 @@
+Unruly
+<p>
+Colour every square either black or white, in such a way that:
+<ul><li>no three consecutive squares, horizontally or vertically, are
+the same colour
+<li>each row and column contains the same number of black and white
+squares.</ul>
+<p>
+Left-click in an empty square to turn it black, or right-click to turn
+it white. Click again in an already-filled square to cycle it between
+black and white and empty; middle-click to reset any square to empty.
diff --git a/apps/plugins/puzzles/html/untangle.html b/apps/plugins/puzzles/html/untangle.html
new file mode 100644
index 0000000000..7171a3d55d
--- /dev/null
+++ b/apps/plugins/puzzles/html/untangle.html
@@ -0,0 +1,5 @@
+Untangle
+<p>
+Move the points around so that none of the lines cross.
+<p>
+Click on a point and drag it to move it.
diff --git a/apps/plugins/puzzles/icons/Makefile b/apps/plugins/puzzles/icons/Makefile
new file mode 100644
index 0000000000..00dae1f841
--- /dev/null
+++ b/apps/plugins/puzzles/icons/Makefile
@@ -0,0 +1,153 @@
+# Makefile for Puzzles icons.
+
+PUZZLES = blackbox bridges cube dominosa fifteen filling flip flood     \
+          galaxies guess inertia keen lightup loopy magnets map mines   \
+          net netslide palisade pattern pearl pegs range rect           \
+          samegame signpost singles sixteen slant solo tents towers     \
+          twiddle tracks undead unequal unruly untangle
+
+BASE = $(patsubst %,%-base.png,$(PUZZLES))
+WEB = $(patsubst %,%-web.png,$(PUZZLES))
+
+IBASE = $(patsubst %,%-ibase.png,$(PUZZLES))
+IBASE4 = $(patsubst %,%-ibase4.png,$(PUZZLES))
+P48D24 = $(patsubst %,%-48d24.png,$(PUZZLES))
+P48D8 = $(patsubst %,%-48d8.png,$(PUZZLES))
+P48D4 = $(patsubst %,%-48d4.png,$(PUZZLES))
+P32D24 = $(patsubst %,%-32d24.png,$(PUZZLES))
+P32D8 = $(patsubst %,%-32d8.png,$(PUZZLES))
+P32D4 = $(patsubst %,%-32d4.png,$(PUZZLES))
+P16D24 = $(patsubst %,%-16d24.png,$(PUZZLES))
+P16D8 = $(patsubst %,%-16d8.png,$(PUZZLES))
+P16D4 = $(patsubst %,%-16d4.png,$(PUZZLES))
+ICONS = $(patsubst %,%.ico,$(PUZZLES))
+CICONS = $(patsubst %,%-icon.c,$(PUZZLES))
+RC = $(patsubst %,%.rc,$(PUZZLES))
+
+BIN = ../
+PIC = ./
+
+# Work around newer ImageMagick unilaterally distorting colours when
+# converting to PNG.
+CSP = -set colorspace RGB
+
+base: $(BASE)
+web: $(WEB)
+pngicons: $(P48D24) $(P32D24) $(P16D24)
+winicons: $(ICONS) $(RC)
+gtkicons: $(CICONS)
+all: base web pngicons winicons gtkicons
+
+# Build the base puzzle screenshots from which all the other images
+# are derived. Some of them involve showing a move animation
+# part-way through.
+fifteen-base.png : override REDO=0.3
+flip-base.png : override REDO=0.3
+netslide-base.png : override REDO=0.3
+sixteen-base.png : override REDO=0.3
+twiddle-base.png : override REDO=0.3
+$(BASE): %-base.png: $(BIN)% $(PIC)%.sav
+        $(PIC)screenshot.sh $(BIN)$* $(PIC)$*.sav $@ $(REDO)
+
+# Build the screenshots for the web, by scaling the original base
+# images to a uniform size.
+$(WEB): %-web.png: %-base.png
+        $(PIC)square.pl 150 5 $^ $@
+
+# Build the base _icon_ images, by careful cropping of the base
+# images: icons are very small so it's often necessary to zoom in
+# on a smaller portion of the screenshot.
+blackbox-ibase.png : override CROP=352x352 144x144+0+208
+bridges-ibase.png : override CROP=264x264 107x107+157+157
+dominosa-ibase.png : override CROP=304x272 152x152+152+0
+fifteen-ibase.png : override CROP=240x240 120x120+0+120
+filling-ibase.png : override CROP=256x256 133x133+14+78
+flip-ibase.png : override CROP=288x288 145x145+120+72
+galaxies-ibase.png : override CROP=288x288 165x165+0+0
+guess-ibase.png : override CROP=263x420 178x178+75+17
+inertia-ibase.png : override CROP=321x321 128x128+193+0
+keen-ibase.png : override CROP=288x288 96x96+24+120
+lightup-ibase.png : override CROP=256x256 112x112+144+0
+loopy-ibase.png : override CROP=257x257 113x113+0+0
+magnets-ibase.png : override CROP=264x232 96x96+36+100
+mines-ibase.png : override CROP=240x240 110x110+130+130
+net-ibase.png : override CROP=193x193 113x113+0+80
+netslide-ibase.png : override CROP=289x289 144x144+0+0
+palisade-ibase.png : override CROP=288x288 192x192+0+0
+pattern-ibase.png : override CROP=384x384 223x223+0+0
+pearl-ibase.png : override CROP=216x216 94x94+108+15
+pegs-ibase.png : override CROP=263x263 147x147+116+0
+range-ibase.png : override CROP=256x256 98x98+111+15
+rect-ibase.png : override CROP=205x205 115x115+90+0
+signpost-ibase.png : override CROP=240x240 98x98+23+23
+singles-ibase.png : override CROP=224x224 98x98+15+15
+sixteen-ibase.png : override CROP=288x288 144x144+144+144
+slant-ibase.png : override CROP=321x321 160x160+160+160
+solo-ibase.png : override CROP=481x481 145x145+24+24
+tents-ibase.png : override CROP=320x320 165x165+142+0
+towers-ibase.png : override CROP=300x300 102x102+151+6
+tracks-ibase.png : override CROP=246x246 118x118+6+6
+twiddle-ibase.png : override CROP=192x192 102x102+69+21
+undead-ibase.png : override CROP=416x480 192x192+16+80
+unequal-ibase.png : override CROP=208x208 104x104+104+104
+untangle-ibase.png : override CROP=320x320 164x164+3+116
+$(IBASE): %-ibase.png: %-base.png
+        $(PIC)crop.sh $^ $@ $(CROP)
+
+# Convert the full-size icon images to 4-bit colour, because that
+# seems to work better than reducing it in 24 bits and then
+# dithering.
+$(IBASE4): %-ibase4.png: %-ibase.png
+        convert -colors 16 +dither $(CSP) -map $(PIC)win16pal.xpm $^ $@
+
+# Build the 24-bit PNGs for the icons, at three sizes.
+$(P48D24): %-48d24.png: %-ibase.png
+        $(PIC)square.pl 48 4 $^ $@
+$(P32D24): %-32d24.png: %-ibase.png
+        $(PIC)square.pl 32 2 $^ $@
+$(P16D24): %-16d24.png: %-ibase.png
+        $(PIC)square.pl 16 1 $^ $@
+
+# The 8-bit icon PNGs are just custom-paletted quantisations of the
+# 24-bit ones.
+$(P48D8) $(P32D8) $(P16D8): %d8.png: %d24.png
+        convert -colors 256 $^ $@
+
+# But the depth-4 images work better if we re-shrink from the
+# ibase4 versions of the images, and then normalise the colours
+# again afterwards. (They're still not very good, but my hope is
+# that on most modern Windows machines this won't matter too
+# much...)
+$(P48D4): %-48d4.png: %-ibase4.png
+        $(PIC)square.pl 48 1 $^ $@-tmp2.png
+        convert -colors 16 $(CSP) -map $(PIC)win16pal.xpm $@-tmp2.png $@
+        rm -f $@-tmp2.png
+$(P32D4): %-32d4.png: %-ibase.png
+        $(PIC)square.pl 32 1 $^ $@-tmp2.png
+        convert -colors 16 $(CSP) -map $(PIC)win16pal.xpm $@-tmp2.png $@
+        rm -f $@-tmp2.png
+$(P16D4): %-16d4.png: %-ibase.png
+        $(PIC)square.pl 16 1 $^ $@-tmp2.png
+        convert -colors 16 $(CSP) -map $(PIC)win16pal.xpm $@-tmp2.png $@
+        rm -f $@-tmp2.png
+
+# Build the actual Windows icons themselves, by feeding all those
+# PNGs to my icon builder script.
+$(ICONS): %.ico: %-48d24.png %-48d8.png %-48d4.png \
+                 %-32d24.png %-32d8.png %-32d4.png \
+                 %-16d24.png %-16d8.png %-16d4.png
+        $(PIC)icon.pl -24 $*-48d24.png $*-32d24.png $*-16d24.png \
+                      -8  $*-48d8.png  $*-32d8.png  $*-16d8.png  \
+                      -4  $*-48d4.png  $*-32d4.png  $*-16d4.png  > $@
+
+# Build the .RC files which bind the icons into the applications.
+$(RC): %.rc:
+        echo '#include "puzzles.rc2"' > $@
+        echo '200 ICON "$*.ico"' >> $@
+
+# Build the GTK icon source files.
+$(CICONS): %-icon.c: %-16d24.png %-32d24.png %-48d24.png
+        $(PIC)cicon.pl $^ > $@  
+
+clean:
+        rm -f *.png *.ico *.rc *-icon.c
diff --git a/apps/plugins/puzzles/icons/blackbox.sav b/apps/plugins/puzzles/icons/blackbox.sav
new file mode 100644
index 0000000000..4483f3c81a
--- /dev/null
+++ b/apps/plugins/puzzles/icons/blackbox.sav
@@ -0,0 +1,27 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :9:Black Box
+PARAMS  :8:w8h8m5M5
+CPARAMS :8:w8h8m5M5
+SEED    :15:999785320716678
+DESC    :24:c8b9f8528193756b9a2fd24d
+UI      :2:E0
+NSTATES :2:18
+STATEPOS:2:13
+MOVE    :2:F2
+MOVE    :2:F4
+MOVE    :2:F5
+MOVE    :3:F25
+MOVE    :3:F26
+MOVE    :3:F11
+MOVE    :3:F12
+MOVE    :3:F15
+MOVE    :4:T7,7
+MOVE    :4:T7,4
+MOVE    :4:T1,7
+MOVE    :2:F3
+MOVE    :2:F9
+MOVE    :3:F27
+MOVE    :4:T5,7
+MOVE    :4:T1,8
+MOVE    :1:R
diff --git a/apps/plugins/puzzles/icons/bridges.sav b/apps/plugins/puzzles/icons/bridges.sav
new file mode 100644
index 0000000000..ddae7085cd
--- /dev/null
+++ b/apps/plugins/puzzles/icons/bridges.sav
@@ -0,0 +1,72 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :7:Bridges
+PARAMS  :15:10x10i30e10m2d2
+CPARAMS :15:10x10i30e10m2d2
+SEED    :15:944199396008454
+DESC    :49:a1a4a4b4k4b6b2a4b2b2b1e2e1a4b4c3j25d2a1f2c3a4d4c3
+AUXINFO :838:bd75eb5f7b129109b5cdcff0925c77ca5c0a135365002b93b44c5013c7a307b9504affcfb8ad934263196fc3e6d0b023abe48d254d46d29520e50a5e423c0fb1bc01ccc51cad61045c439e7c2bb8e5788bc7f3622aaa3a8125ebde11c9cd69b6f2393246fd094ad91e81ae58cd557b73bd1c9839cfad5835c8519e44298204eaca58dfd79289546959bfbabdc5f3cb7a27b8d3fb2d0b062bd5c2e469493c19f8c89989df73d8a3ab02d9afcbfedf245306d15881a01d153122f8374c7526abecc90919f99ff62e9789cabc402249af095ceb14c8c59c0d9ffbcdd731d50114e7c30c31ef0638f4d352abbfd04b4315d368d65bbfe005b6586245bc5244e5050098cf4c1b6986120f40d5ce038c10a3f309286f950cdc287e495aa13c70ab0c1f113a135556d7ce895fd8244afcbad43fe51f275837f223a1cb95151de8a158cb0add7fa8c9f1fa0e09a1ce842136c1679144cead56b164c4ef1a09ed36fd9704ba191b5957bc3d5bb97d8a1f7451d357a6638ac320b0beb0cd35aa404c8f1621c6d400960aa97bf6ce3a944339d7e401c4d98c31773b2a8881352d5653fdb5e8f7c04b
+NSTATES :2:63
+STATEPOS:2:41
+MOVE    :10:L8,0,5,0,1
+MOVE    :10:L8,0,5,0,2
+MOVE    :10:L8,0,8,2,1
+MOVE    :10:L8,0,8,2,2
+MOVE    :4:M8,0
+MOVE    :10:L0,2,3,2,1
+MOVE    :10:L0,2,3,2,2
+MOVE    :10:L0,2,0,7,1
+MOVE    :10:L0,2,0,7,2
+MOVE    :4:M0,2
+MOVE    :10:L1,0,3,0,1
+MOVE    :4:M1,0
+MOVE    :10:L3,0,5,0,1
+MOVE    :10:L3,0,3,2,1
+MOVE    :10:L1,3,1,5,1
+MOVE    :10:L0,7,5,7,1
+MOVE    :10:L0,7,0,9,1
+MOVE    :10:L0,9,5,9,1
+MOVE    :10:L0,9,5,9,2
+MOVE    :10:L0,9,0,7,2
+MOVE    :4:M0,9
+MOVE    :4:M0,7
+MOVE    :10:L4,8,8,8,1
+MOVE    :10:L4,8,8,8,2
+MOVE    :4:M4,8
+MOVE    :10:L5,9,9,9,1
+MOVE    :10:L5,9,9,9,2
+MOVE    :4:M5,9
+MOVE    :10:L9,9,9,6,1
+MOVE    :4:M9,9
+MOVE    :10:L8,8,8,5,1
+MOVE    :4:M8,8
+MOVE    :10:L9,6,9,4,1
+MOVE    :4:M9,6
+MOVE    :4:M9,4
+MOVE    :10:L1,5,4,5,1
+MOVE    :10:L1,5,4,5,2
+MOVE    :10:L1,5,1,3,2
+MOVE    :4:M1,3
+MOVE    :4:M1,5
+MOVE    :10:L3,4,3,2,1
+MOVE    :10:L3,4,3,2,2
+MOVE    :4:M3,4
+MOVE    :10:L4,5,8,5,1
+MOVE    :10:L7,7,5,7,1
+MOVE    :4:M5,7
+MOVE    :4:M7,7
+MOVE    :10:L7,3,4,3,1
+MOVE    :4:M7,3
+MOVE    :10:L5,0,3,0,2
+MOVE    :4:M5,0
+MOVE    :4:M3,0
+MOVE    :10:L3,2,6,2,1
+MOVE    :4:M3,2
+MOVE    :10:L6,2,8,2,1
+MOVE    :4:M6,2
+MOVE    :10:L8,2,8,5,1
+MOVE    :4:M8,2
+MOVE    :4:M8,5
+MOVE    :10:L4,5,4,3,1
+MOVE    :4:M4,3
+MOVE    :4:M4,5
diff --git a/apps/plugins/puzzles/icons/cicon.pl b/apps/plugins/puzzles/icons/cicon.pl
new file mode 100755
index 0000000000..3578bd33fe
--- /dev/null
+++ b/apps/plugins/puzzles/icons/cicon.pl
@@ -0,0 +1,27 @@
+#!/usr/bin/perl 
+
+# Given a list of input PNGs, create a C source file file
+# containing a const array of XPMs, under the name `xpm_icon'.
+
+$k = 0;
+@xpms = ();
+foreach $f (@ARGV) {
+  # XPM format is generated directly by ImageMagick, so that's easy
+  # enough. We just have to adjust the declaration line so that it
+  # has the right name, linkage and storage class.
+  @lines = ();
+  open XPM, "convert $f xpm:- |";
+  push @lines, $_ while <XPM>;
+  close XPM;
+  die "XPM from $f in unexpected format\n" unless $lines[1] =~ /^static.*\{$/;
+  $lines[1] = "static const char *const xpm_icon_$k"."[] = {\n";
+  $k++;
+  push @xpms, @lines, "\n";
+}
+
+# Now output.
+foreach $line (@xpms) { print $line; }
+print "const char *const *const xpm_icons[] = {\n";
+for ($i = 0; $i < $k; $i++) { print "    xpm_icon_$i,\n"; }
+print "};\n";
+print "const int n_xpm_icons = $k;\n";
diff --git a/apps/plugins/puzzles/icons/crop.sh b/apps/plugins/puzzles/icons/crop.sh
new file mode 100755
index 0000000000..0d15d3c9b9
--- /dev/null
+++ b/apps/plugins/puzzles/icons/crop.sh
@@ -0,0 +1,37 @@
+#!/bin/sh 
+
+# Crop one image into another, after first checking that the source
+# image has the expected size in pixels.
+#
+# This is used in the Puzzles icon build scripts to construct icons
+# which are zoomed in on a particular sub-area of the puzzle's
+# basic screenshot. This way I can define crop areas in pixels,
+# while not having to worry too much that if I adjust the source
+# puzzle so as to alter the layout the crop area might start
+# hitting the wrong bit of picture. Most layout changes I can
+# conveniently imagine will also alter the overall image size, so
+# this script will give a build error and alert me to the fact that
+# I need to fiddle with the icon makefile.
+
+infile="$1"
+outfile="$2"
+insize="$3"
+crop="$4"
+
+# Special case: if no input size or crop parameter was specified at
+# all, we just copy the input to the output file.
+
+if test $# -lt 3; then
+  cp "$infile" "$outfile"
+  exit 0
+fi
+
+# Check the input image size.
+realsize=`identify -format %wx%h "$infile"`
+if test "x$insize" != "x$realsize"; then
+  echo "crop.sh: '$infile' has wrong initial size: $realsize != $insize" >&2
+  exit 1
+fi
+
+# And crop.
+convert -crop "$crop" "$infile" "$outfile"
diff --git a/apps/plugins/puzzles/icons/cube.sav b/apps/plugins/puzzles/icons/cube.sav
new file mode 100644
index 0000000000..bb123f4e74
--- /dev/null
+++ b/apps/plugins/puzzles/icons/cube.sav
@@ -0,0 +1,22 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :4:Cube
+PARAMS  :4:c4x4
+CPARAMS :4:c4x4
+SEED    :15:125146248070163
+DESC    :6:C461,3
+NSTATES :2:14
+STATEPOS:1:5
+MOVE    :1:D
+MOVE    :1:D
+MOVE    :1:D
+MOVE    :1:U
+MOVE    :1:L
+MOVE    :1:L
+MOVE    :1:D
+MOVE    :1:U
+MOVE    :1:D
+MOVE    :1:U
+MOVE    :1:U
+MOVE    :1:U
+MOVE    :1:L
diff --git a/apps/plugins/puzzles/icons/dominosa.sav b/apps/plugins/puzzles/icons/dominosa.sav
new file mode 100644
index 0000000000..5991f3e57e
--- /dev/null
+++ b/apps/plugins/puzzles/icons/dominosa.sav
@@ -0,0 +1,53 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :8:Dominosa
+PARAMS  :1:6
+CPARAMS :1:6
+DESC    :56:55521461210004364611033535444421636022603153156422620503
+NSTATES :2:46
+STATEPOS:2:33
+MOVE    :6:D18,19
+MOVE    :6:E22,23
+MOVE    :6:E22,30
+MOVE    :5:E9,17
+MOVE    :6:D38,46
+MOVE    :6:E14,15
+MOVE    :5:E6,14
+MOVE    :6:E33,34
+MOVE    :6:E34,42
+MOVE    :6:E26,34
+MOVE    :6:D34,35
+MOVE    :6:E42,50
+MOVE    :6:E16,24
+MOVE    :4:D4,5
+MOVE    :4:D6,7
+MOVE    :6:D15,23
+MOVE    :6:E17,25
+MOVE    :6:D16,17
+MOVE    :6:E11,12
+MOVE    :6:D51,52
+MOVE    :5:E3,11
+MOVE    :6:D10,11
+MOVE    :4:D2,3
+MOVE    :6:E37,45
+MOVE    :6:D49,50
+MOVE    :6:D40,48
+MOVE    :6:D25,26
+MOVE    :6:D24,32
+MOVE    :6:D33,41
+MOVE    :6:D42,43
+MOVE    :6:D27,28
+MOVE    :6:E21,29
+MOVE    :6:D31,39
+MOVE    :6:D47,55
+MOVE    :6:E13,21
+MOVE    :6:E13,14
+MOVE    :6:D12,13
+MOVE    :6:D20,21
+MOVE    :6:D14,22
+MOVE    :6:D29,30
+MOVE    :6:D36,37
+MOVE    :6:D44,45
+MOVE    :6:D53,54
+MOVE    :4:D0,1
+MOVE    :4:D8,9
diff --git a/apps/plugins/puzzles/icons/fifteen.sav b/apps/plugins/puzzles/icons/fifteen.sav
new file mode 100644
index 0000000000..d81345a7d8
--- /dev/null
+++ b/apps/plugins/puzzles/icons/fifteen.sav
@@ -0,0 +1,74 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :7:Fifteen
+PARAMS  :3:4x4
+CPARAMS :3:4x4
+SEED    :15:307905346810973
+DESC    :37:8,11,3,6,14,13,4,2,0,9,12,10,5,1,7,15
+NSTATES :2:66
+STATEPOS:2:47
+MOVE    :4:M1,2
+MOVE    :4:M1,3
+MOVE    :4:M0,3
+MOVE    :4:M0,1
+MOVE    :4:M1,1
+MOVE    :4:M1,2
+MOVE    :4:M0,2
+MOVE    :4:M0,0
+MOVE    :4:M1,0
+MOVE    :4:M1,1
+MOVE    :4:M0,1
+MOVE    :4:M0,0
+MOVE    :4:M1,0
+MOVE    :4:M3,0
+MOVE    :4:M3,1
+MOVE    :4:M1,1
+MOVE    :4:M1,0
+MOVE    :4:M3,0
+MOVE    :4:M3,1
+MOVE    :4:M1,1
+MOVE    :4:M1,0
+MOVE    :4:M2,0
+MOVE    :4:M2,1
+MOVE    :4:M1,1
+MOVE    :4:M1,3
+MOVE    :4:M0,3
+MOVE    :4:M0,1
+MOVE    :4:M1,1
+MOVE    :4:M1,2
+MOVE    :4:M0,2
+MOVE    :4:M0,1
+MOVE    :4:M2,1
+MOVE    :4:M3,1
+MOVE    :4:M3,2
+MOVE    :4:M2,2
+MOVE    :4:M2,3
+MOVE    :4:M3,3
+MOVE    :4:M3,1
+MOVE    :4:M2,1
+MOVE    :4:M2,2
+MOVE    :4:M1,2
+MOVE    :4:M1,3
+MOVE    :4:M2,3
+MOVE    :4:M2,2
+MOVE    :4:M1,2
+MOVE    :4:M0,2
+MOVE    :4:M0,3
+MOVE    :4:M1,3
+MOVE    :4:M1,2
+MOVE    :4:M2,2
+MOVE    :4:M2,3
+MOVE    :4:M0,3
+MOVE    :4:M0,2
+MOVE    :4:M1,2
+MOVE    :4:M2,2
+MOVE    :4:M2,3
+MOVE    :4:M1,3
+MOVE    :4:M1,2
+MOVE    :4:M3,2
+MOVE    :4:M3,3
+MOVE    :4:M1,3
+MOVE    :4:M1,2
+MOVE    :4:M2,2
+MOVE    :4:M2,3
+MOVE    :4:M3,3
diff --git a/apps/plugins/puzzles/icons/filling.sav b/apps/plugins/puzzles/icons/filling.sav
new file mode 100644
index 0000000000..caf0bb2d4c
--- /dev/null
+++ b/apps/plugins/puzzles/icons/filling.sav
@@ -0,0 +1,38 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :7:Filling
+PARAMS  :3:7x7
+CPARAMS :3:7x7
+SEED    :15:279172739852696
+DESC    :49:0000000031051240010004000001106171000400001013105
+NSTATES :2:30
+STATEPOS:2:13
+MOVE    :4:38_3
+MOVE    :4:39_3
+MOVE    :4:36_4
+MOVE    :4:43_4
+MOVE    :4:35_4
+MOVE    :4:47_5
+MOVE    :4:40_5
+MOVE    :4:34_5
+MOVE    :4:41_5
+MOVE    :4:25_7
+MOVE    :4:23_6
+MOVE    :4:16_6
+MOVE    :4:18_7
+MOVE    :4:19_7
+MOVE    :4:20_7
+MOVE    :4:26_7
+MOVE    :4:24_7
+MOVE    :4:29_6
+MOVE    :4:22_6
+MOVE    :4:15_6
+MOVE    :3:7_4
+MOVE    :3:0_4
+MOVE    :3:1_3
+MOVE    :3:2_3
+MOVE    :3:6_2
+MOVE    :3:5_5
+MOVE    :3:4_5
+MOVE    :3:3_5
+MOVE    :4:10_5
diff --git a/apps/plugins/puzzles/icons/flip.sav b/apps/plugins/puzzles/icons/flip.sav
new file mode 100644
index 0000000000..82b4c49357
--- /dev/null
+++ b/apps/plugins/puzzles/icons/flip.sav
@@ -0,0 +1,20 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :4:Flip
+PARAMS  :4:5x5c
+CPARAMS :4:5x5c
+SEED    :15:158897339725978
+DESC    :165:c400007100001c4000071000018400043100011c400047100011c400046100010c400047100011c4000471000118400043100011c400047100011c400046100010c000047000011c0000470000118,5c18b48
+NSTATES :2:12
+STATEPOS:1:4
+MOVE    :4:M4,3
+MOVE    :4:M3,0
+MOVE    :4:M2,2
+MOVE    :4:M3,2
+MOVE    :4:M2,3
+MOVE    :4:M0,2
+MOVE    :4:M0,3
+MOVE    :4:M1,4
+MOVE    :4:M0,0
+MOVE    :4:M1,0
+MOVE    :4:M1,1
diff --git a/apps/plugins/puzzles/icons/flood.sav b/apps/plugins/puzzles/icons/flood.sav
new file mode 100644
index 0000000000..ac4adf7020
--- /dev/null
+++ b/apps/plugins/puzzles/icons/flood.sav
@@ -0,0 +1,14 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :5:Flood
+PARAMS  :7:6x6c6m5
+CPARAMS :7:6x6c6m5
+SEED    :15:967543368167853
+DESC    :39:032242034203340350204502505323231342,17
+NSTATES :1:6
+STATEPOS:1:6
+MOVE    :2:M3
+MOVE    :2:M2
+MOVE    :2:M0
+MOVE    :2:M5
+MOVE    :2:M3
diff --git a/apps/plugins/puzzles/icons/galaxies.sav b/apps/plugins/puzzles/icons/galaxies.sav
new file mode 100644
index 0000000000..42d18bc335
--- /dev/null
+++ b/apps/plugins/puzzles/icons/galaxies.sav
@@ -0,0 +1,51 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :8:Galaxies
+PARAMS  :5:7x7dh
+CPARAMS :5:7x7dh
+SEED    :15:483644862786314
+DESC    :13:ikrqfedzljjsp
+NSTATES :2:43
+STATEPOS:2:37
+MOVE    :5:E12,9
+MOVE    :5:E8,11
+MOVE    :5:E5,12
+MOVE    :5:E7,12
+MOVE    :5:E4,13
+MOVE    :5:E2,11
+MOVE    :5:E3,10
+MOVE    :4:E2,5
+MOVE    :4:E4,5
+MOVE    :4:E6,7
+MOVE    :4:E8,1
+MOVE    :5:E10,1
+MOVE    :4:E9,2
+MOVE    :4:E6,3
+MOVE    :4:E7,4
+MOVE    :5:E10,3
+MOVE    :5:E10,5
+MOVE    :5:E11,6
+MOVE    :5:E13,6
+MOVE    :5:E8,13
+MOVE    :5:E12,7
+MOVE    :6:E12,11
+MOVE    :6:E13,12
+MOVE    :4:E8,9
+MOVE    :4:E7,8
+MOVE    :4:E7,6
+MOVE    :4:E9,6
+MOVE    :4:E8,5
+MOVE    :4:E9,4
+MOVE    :4:E5,2
+MOVE    :4:E4,1
+MOVE    :4:E3,6
+MOVE    :4:E2,7
+MOVE    :4:E3,8
+MOVE    :4:E3,4
+MOVE    :4:E4,9
+MOVE    :4:E2,9
+MOVE    :5:E5,10
+MOVE    :5:E6,11
+MOVE    :4:E2,3
+MOVE    :4:E2,1
+MOVE    :5:E1,12
diff --git a/apps/plugins/puzzles/icons/guess.sav b/apps/plugins/puzzles/icons/guess.sav
new file mode 100644
index 0000000000..69852bf769
--- /dev/null
+++ b/apps/plugins/puzzles/icons/guess.sav
@@ -0,0 +1,15 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :5:Guess
+PARAMS  :9:c6p4g10Bm
+CPARAMS :9:c6p4g10Bm
+SEED    :15:313100730915729
+DESC    :8:b5f3faed
+UI      :7:0,0,0,0
+NSTATES :1:6
+STATEPOS:1:6
+MOVE    :8:G1,1,2,2
+MOVE    :8:G4,3,1,1
+MOVE    :8:G5,5,1,1
+MOVE    :8:G4,2,1,6
+MOVE    :8:G2,3,1,6
diff --git a/apps/plugins/puzzles/icons/icon.pl b/apps/plugins/puzzles/icons/icon.pl
new file mode 100755
index 0000000000..fcb1aa3e2c
--- /dev/null
+++ b/apps/plugins/puzzles/icons/icon.pl
@@ -0,0 +1,270 @@
+#!/usr/bin/perl 
+
+# Take a collection of input image files and convert them into a
+# multi-resolution Windows .ICO icon file.
+#
+# The input images can be treated as having four different colour
+# depths:
+#
+#  - 24-bit true colour
+#  - 8-bit with custom palette
+#  - 4-bit using the Windows 16-colour palette (see comment below
+#    for details)
+#  - 1-bit using black and white only.
+#
+# The images can be supplied in any input format acceptable to
+# ImageMagick, but their actual colour usage must already be
+# appropriate for the specified mode; this script will not do any
+# substantive conversion. So if an image intended to be used in 4-
+# or 1-bit mode contains any colour not in the appropriate fixed
+# palette, that's a fatal error; if an image to be used in 8-bit
+# mode contains more than 256 distinct colours, that's also a fatal
+# error.
+#
+# Command-line syntax is:
+#
+#   icon.pl -depth imagefile [imagefile...] [-depth imagefile [imagefile...]]
+#
+# where `-depth' is one of `-24', `-8', `-4' or `-1', and tells the
+# script how to treat all the image files given after that option
+# until the next depth option. For example, you might execute
+#
+#   icon.pl -24 48x48x24.png 32x32x24.png -8 32x32x8.png -1 monochrome.png
+#
+# to build an icon file containing two differently sized 24-bit
+# images, one 8-bit image and one black and white image.
+#
+# Windows .ICO files support a 1-bit alpha channel on all these
+# image types. That is, any pixel can be either opaque or fully
+# transparent, but not partially transparent. The alpha channel is
+# separate from the main image data, meaning that `transparent' is
+# not required to take up a palette entry. (So an 8-bit image can
+# have 256 distinct _opaque_ colours, plus transparent pixels as
+# well.) If the input images have alpha channels, they will be used
+# to determine which pixels of the icon are transparent, by simple
+# quantisation half way up (e.g. in a PNG image with an 8-bit alpha
+# channel, alpha values of 00-7F will be mapped to transparent
+# pixels, and 80-FF will become opaque).
+
+# The Windows 16-colour palette consists of:
+#  - the eight corners of the colour cube (000000, 0000FF, 00FF00,
+#    00FFFF, FF0000, FF00FF, FFFF00, FFFFFF)
+#  - dim versions of the seven non-black corners, at 128/255 of the
+#    brightness (000080, 008000, 008080, 800000, 800080, 808000,
+#    808080)
+#  - light grey at 192/255 of full brightness (C0C0C0).
+%win16pal = (
+    "\x00\x00\x00\x00" => 0,
+    "\x00\x00\x80\x00" => 1,
+    "\x00\x80\x00\x00" => 2,
+    "\x00\x80\x80\x00" => 3,
+    "\x80\x00\x00\x00" => 4,
+    "\x80\x00\x80\x00" => 5,
+    "\x80\x80\x00\x00" => 6,
+    "\xC0\xC0\xC0\x00" => 7,
+    "\x80\x80\x80\x00" => 8,
+    "\x00\x00\xFF\x00" => 9,
+    "\x00\xFF\x00\x00" => 10,
+    "\x00\xFF\xFF\x00" => 11,
+    "\xFF\x00\x00\x00" => 12,
+    "\xFF\x00\xFF\x00" => 13,
+    "\xFF\xFF\x00\x00" => 14,
+    "\xFF\xFF\xFF\x00" => 15,
+);
+@win16pal = sort { $win16pal{$a} <=> $win16pal{$b} } keys %win16pal;
+
+# The black and white palette consists of black (000000) and white
+# (FFFFFF), obviously.
+%win2pal = (
+    "\x00\x00\x00\x00" => 0,
+    "\xFF\xFF\xFF\x00" => 1,
+);
+@win2pal = sort { $win16pal{$a} <=> $win2pal{$b} } keys %win2pal;
+
+@hdr = ();
+@dat = ();
+
+$depth = undef;
+foreach $_ (@ARGV) {
+    if (/^-(24|8|4|1)$/) {
+        $depth = $1;
+    } elsif (defined $depth) {
+        &readicon($_, $depth);
+    } else {
+        $usage = 1;
+    }
+}
+if ($usage || length @hdr == 0) {
+    print "usage: icon.pl ( -24 | -8 | -4 | -1 ) image [image...]\n";
+    print "             [ ( -24 | -8 | -4 | -1 ) image [image...] ...]\n";
+    exit 0;
+}
+
+# Now write out the output icon file.
+print pack "vvv", 0, 1, scalar @hdr; # file-level header
+$filepos = 6 + 16 * scalar @hdr;
+for ($i = 0; $i < scalar @hdr; $i++) {
+    print $hdr[$i];
+    print pack "V", $filepos;
+    $filepos += length($dat[$i]);
+}
+for ($i = 0; $i < scalar @hdr; $i++) {
+    print $dat[$i];
+}
+
+sub readicon {
+    my $filename = shift @_;
+    my $depth = shift @_;
+    my $pix;
+    my $i;
+    my %pal;
+
+    # Determine the icon's width and height.
+    my $w = `identify -format %w $filename`;
+    my $h = `identify -format %h $filename`;
+
+    # Read the file in as RGBA data. We flip vertically at this
+    # point, to avoid having to do it ourselves (.BMP and hence
+    # .ICO are bottom-up).
+    my $data = [];
+    open IDATA, "convert -set colorspace sRGB -flip -depth 8 $filename rgba:- |";
+    push @$data, $rgb while (read IDATA,$rgb,4,0) == 4;
+    close IDATA;
+    # Check we have the right amount of data.
+    $xl = $w * $h;
+    $al = scalar @$data;
+    die "wrong amount of image data ($al, expected $xl) from $filename\n"
+      unless $al == $xl;
+
+    # Build the alpha channel now, so we can exclude transparent
+    # pixels from the palette analysis. We replace transparent
+    # pixels with undef in the data array.
+    #
+    # We quantise the alpha channel half way up, so that alpha of
+    # 0x80 or more is taken to be fully opaque and 0x7F or less is
+    # fully transparent. Nasty, but the best we can do without
+    # dithering (and don't even suggest we do that!).
+    my $x;
+    my $y;
+    my $alpha = "";
+
+    for ($y = 0; $y < $h; $y++) {
+        my $currbyte = 0, $currbits = 0;
+        for ($x = 0; $x < (($w+31)|31)-31; $x++) {
+            $pix = ($x < $w ? $data->[$y*$w+$x] : "\x00\x00\x00\xFF");
+            my @rgba = unpack "CCCC", $pix;
+            $currbyte <<= 1;
+            $currbits++;
+            if ($rgba[3] < 0x80) {
+                if ($x < $w) {
+                    $data->[$y*$w+$x] = undef;
+                }
+                $currbyte |= 1; # MS has the alpha channel inverted :-)
+            } else {
+                # Might as well flip RGBA into BGR0 while we're here.
+                if ($x < $w) {
+                    $data->[$y*$w+$x] = pack "CCCC",
+                      $rgba[2], $rgba[1], $rgba[0], 0;
+                }
+            }
+            if ($currbits >= 8) {
+                $alpha .= pack "C", $currbyte;
+                $currbits -= 8;
+            }
+        }
+    }
+
+    # For an 8-bit image, check we have at most 256 distinct
+    # colours, and build the palette.
+    %pal = ();
+    if ($depth == 8) {
+        my $palindex = 0;
+        foreach $pix (@$data) {
+            next unless defined $pix;
+            $pal{$pix} = $palindex++ unless defined $pal{$pix};
+        }
+        die "too many colours in 8-bit image $filename\n" unless $palindex <= 256;
+    } elsif ($depth == 4) {
+        %pal = %win16pal;
+    } elsif ($depth == 1) {
+        %pal = %win2pal;
+    }
+
+    my $raster = "";
+    if ($depth < 24) {
+        # For a non-24-bit image, flatten the image into one palette
+        # index per pixel.
+        $pad = 32 / $depth; # number of pixels to pad scanline to 4-byte align
+        $pmask = $pad-1;
+        for ($y = 0; $y < $h; $y++) {
+            my $currbyte = 0, $currbits = 0;
+            for ($x = 0; $x < (($w+$pmask)|$pmask)-$pmask; $x++) {
+                $currbyte <<= $depth;
+                $currbits += $depth;
+                if ($x < $w && defined ($pix = $data->[$y*$w+$x])) {
+                    if (!defined $pal{$pix}) {
+                        my $pixprintable = unpack "H*", $pix;
+                        die "illegal colour value $pixprintable at pixel ($x,$y) in $filename\n";
+                    }
+                    $currbyte |= $pal{$pix};
+                }
+                if ($currbits >= 8) {
+                    $raster .= pack "C", $currbyte;
+                    $currbits -= 8;
+                }
+            }
+        }
+    } else {
+        # For a 24-bit image, reverse the order of the R,G,B values
+        # and stick a padding zero on the end.
+        #
+        # (In this loop we don't need to bother padding the
+        # scanline out to a multiple of four bytes, because every
+        # pixel takes four whole bytes anyway.)
+        for ($i = 0; $i < scalar @$data; $i++) {
+            if (defined $data->[$i]) {
+                $raster .= $data->[$i];
+            } else {
+                $raster .= "\x00\x00\x00\x00";
+            }
+        }
+        $depth = 32; # and adjust this
+    }
+
+    # Prepare the icon data. First the header...
+    my $data = pack "VVVvvVVVVVV",
+      40, # size of bitmap info header
+      $w, # icon width
+      $h*2, # icon height (x2 to indicate the subsequent alpha channel)
+      1, # 1 plane (common to all MS image formats)
+      $depth, # bits per pixel
+      0, # no compression
+      length $raster, # image size
+      0, 0, 0, 0; # resolution, colours used, colours important (ignored)
+    # ... then the palette ...
+    if ($depth <= 8) {
+        my $ncols = (1 << $depth);
+        my $palette = "\x00\x00\x00\x00" x $ncols;
+        foreach $i (keys %pal) {
+            substr($palette, $pal{$i}*4, 4) = $i;
+        }
+        $data .= $palette;
+    }
+    # ... the raster data we already had ready ...
+    $data .= $raster;
+    # ... and the alpha channel we already had as well.
+    $data .= $alpha;
+
+    # Prepare the header which will represent this image in the
+    # icon file.
+    my $header = pack "CCCCvvV",
+      $w, $h, # width and height (this time the real height)
+      1 << $depth, # number of colours, if less than 256
+      0, # reserved
+      1, # planes
+      $depth, # bits per pixel
+      length $data; # size of real icon data
+
+    push @hdr, $header;
+    push @dat, $data;
+}
diff --git a/apps/plugins/puzzles/icons/inertia.sav b/apps/plugins/puzzles/icons/inertia.sav
new file mode 100644
index 0000000000..a6d6faed1b
--- /dev/null
+++ b/apps/plugins/puzzles/icons/inertia.sav
@@ -0,0 +1,30 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :7:Inertia
+PARAMS  :3:8x8
+CPARAMS :3:8x8
+SEED    :15:739970145068932
+DESC    :64:sbgwsmswwgggwggmmbwgwbssbwbsbwbbwsSmgbbsbbmsgbmssgmggbmmwmbmmwsw
+UI      :2:D0
+NSTATES :2:21
+STATEPOS:1:5
+MOVE    :1:6
+MOVE    :1:5
+MOVE    :1:3
+MOVE    :1:1
+MOVE    :1:6
+MOVE    :1:0
+MOVE    :1:5
+MOVE    :1:7
+MOVE    :1:5
+MOVE    :1:6
+MOVE    :1:1
+MOVE    :1:3
+MOVE    :1:4
+MOVE    :1:2
+MOVE    :1:6
+MOVE    :1:5
+MOVE    :1:3
+MOVE    :1:1
+MOVE    :1:5
+MOVE    :1:3
diff --git a/apps/plugins/puzzles/icons/keen.sav b/apps/plugins/puzzles/icons/keen.sav
new file mode 100644
index 0000000000..4adbd42d17
--- /dev/null
+++ b/apps/plugins/puzzles/icons/keen.sav
@@ -0,0 +1,62 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :4:Keen
+PARAMS  :3:5de
+CPARAMS :3:5de
+SEED    :15:846699649745236
+DESC    :48:a__a_3a_5a_a_a_3b_bac_,a5m15a7a10s2s2d2s3m40m2s2
+AUXINFO :52:6105af67c6ebc8de056b59ebc9a463aa54e75f647055c0a6c1bd
+NSTATES :2:53
+STATEPOS:2:39
+MOVE    :6:P0,4,2
+MOVE    :6:P0,4,4
+MOVE    :6:P0,4,5
+MOVE    :6:P1,4,2
+MOVE    :6:P1,4,4
+MOVE    :6:P1,4,5
+MOVE    :6:P1,3,2
+MOVE    :6:P1,3,4
+MOVE    :6:P1,3,5
+MOVE    :6:R2,2,4
+MOVE    :6:R1,2,2
+MOVE    :6:P1,3,2
+MOVE    :6:P1,4,2
+MOVE    :6:R0,4,2
+MOVE    :6:R2,3,2
+MOVE    :6:R2,4,1
+MOVE    :6:R1,4,4
+MOVE    :6:R1,3,5
+MOVE    :6:P3,4,3
+MOVE    :6:P3,4,5
+MOVE    :6:P4,4,3
+MOVE    :6:P4,4,5
+MOVE    :6:R4,4,5
+MOVE    :6:R3,4,3
+MOVE    :6:P3,1,2
+MOVE    :6:P3,1,5
+MOVE    :6:P3,0,2
+MOVE    :6:P3,0,5
+MOVE    :6:R3,2,1
+MOVE    :6:R3,3,4
+MOVE    :6:P2,0,3
+MOVE    :6:P2,0,5
+MOVE    :6:P2,1,3
+MOVE    :6:P2,1,5
+MOVE    :6:P0,1,1
+MOVE    :6:P0,1,3
+MOVE    :6:P1,1,1
+MOVE    :6:P1,1,3
+MOVE    :6:R2,0,3
+MOVE    :6:R2,1,5
+MOVE    :6:R3,0,5
+MOVE    :6:R3,1,2
+MOVE    :6:R4,1,4
+MOVE    :6:R4,2,3
+MOVE    :6:R4,0,2
+MOVE    :6:R4,3,1
+MOVE    :6:R0,2,5
+MOVE    :6:R0,3,3
+MOVE    :6:R1,1,3
+MOVE    :6:R0,1,1
+MOVE    :6:R1,0,1
+MOVE    :6:R0,0,4
diff --git a/apps/plugins/puzzles/icons/lightup.sav b/apps/plugins/puzzles/icons/lightup.sav
new file mode 100644
index 0000000000..21b59bdec4
--- /dev/null
+++ b/apps/plugins/puzzles/icons/lightup.sav
@@ -0,0 +1,24 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :8:Light Up
+PARAMS  :10:7x7b20s4d1
+CPARAMS :10:7x7b25s4d1
+SEED    :15:538922615851330
+DESC    :25:b3gB0c0dBaBaBa1aBd1c01g0b
+NSTATES :2:16
+STATEPOS:2:16
+MOVE    :4:L1,0
+MOVE    :4:L2,1
+MOVE    :4:L3,0
+MOVE    :4:L0,3
+MOVE    :4:L6,1
+MOVE    :4:L3,4
+MOVE    :4:I6,5
+MOVE    :4:I1,5
+MOVE    :4:I2,6
+MOVE    :4:I3,6
+MOVE    :4:I4,5
+MOVE    :4:I5,6
+MOVE    :4:L5,5
+MOVE    :4:I6,4
+MOVE    :4:I4,2
diff --git a/apps/plugins/puzzles/icons/loopy.sav b/apps/plugins/puzzles/icons/loopy.sav
new file mode 100644
index 0000000000..11611818af
--- /dev/null
+++ b/apps/plugins/puzzles/icons/loopy.sav
@@ -0,0 +1,120 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :5:Loopy
+PARAMS  :7:7x7t0de
+CPARAMS :7:7x7t0de
+DESC    :31:02g222b3b2e2a2b322b2a2a3a2a1d1b
+NSTATES :3:113
+STATEPOS:2:75
+MOVE    :2:3n
+MOVE    :2:0n
+MOVE    :2:1n
+MOVE    :2:2n
+MOVE    :2:4n
+MOVE    :2:6y
+MOVE    :2:5y
+MOVE    :3:25n
+MOVE    :2:9n
+MOVE    :3:28y
+MOVE    :3:27y
+MOVE    :3:42n
+MOVE    :3:30n
+MOVE    :3:45y
+MOVE    :3:44y
+MOVE    :3:59n
+MOVE    :3:47n
+MOVE    :3:62y
+MOVE    :3:61y
+MOVE    :3:76n
+MOVE    :3:64n
+MOVE    :3:79y
+MOVE    :3:78y
+MOVE    :3:93n
+MOVE    :3:81n
+MOVE    :4:110y
+MOVE    :4:111y
+MOVE    :3:99y
+MOVE    :3:98y
+MOVE    :3:24n
+MOVE    :3:39y
+MOVE    :3:23y
+MOVE    :3:22y
+MOVE    :3:26n
+MOVE    :3:37n
+MOVE    :3:38y
+MOVE    :3:54n
+MOVE    :3:69y
+MOVE    :3:53y
+MOVE    :3:40y
+MOVE    :2:7y
+MOVE    :3:88y
+MOVE    :3:87y
+MOVE    :4:102n
+MOVE    :3:90n
+MOVE    :3:52n
+MOVE    :3:41y
+MOVE    :3:55n
+MOVE    :3:43n
+MOVE    :2:8n
+MOVE    :3:10y
+MOVE    :3:12y
+MOVE    :3:11n
+MOVE    :3:13y
+MOVE    :3:29n
+MOVE    :3:15y
+MOVE    :3:14n
+MOVE    :3:16y
+MOVE    :3:32y
+MOVE    :3:31n
+MOVE    :3:18y
+MOVE    :3:17n
+MOVE    :3:19y
+MOVE    :3:20y
+MOVE    :3:21n
+MOVE    :3:33y
+MOVE    :3:35y
+MOVE    :3:36n
+MOVE    :3:50y
+MOVE    :3:57y
+MOVE    :3:58y
+MOVE    :3:72n
+MOVE    :3:60n
+MOVE    :3:74y
+MOVE    :4:104y
+MOVE    :4:107n
+MOVE    :4:106n
+MOVE    :3:92n
+MOVE    :4:109n
+MOVE    :3:89y
+MOVE    :3:77n
+MOVE    :3:75n
+MOVE    :3:73y
+MOVE    :3:85n
+MOVE    :3:70n
+MOVE    :3:56y
+MOVE    :3:67n
+MOVE    :3:71y
+MOVE    :3:68y
+MOVE    :3:84n
+MOVE    :3:82n
+MOVE    :3:83y
+MOVE    :3:97n
+MOVE    :3:86y
+MOVE    :4:101y
+MOVE    :4:100n
+MOVE    :4:103y
+MOVE    :4:105y
+MOVE    :4:108y
+MOVE    :3:96n
+MOVE    :3:95y
+MOVE    :3:94y
+MOVE    :3:91y
+MOVE    :3:80y
+MOVE    :3:66n
+MOVE    :3:65y
+MOVE    :3:63y
+MOVE    :3:51n
+MOVE    :3:46n
+MOVE    :3:34y
+MOVE    :3:48n
+MOVE    :3:49y
diff --git a/apps/plugins/puzzles/icons/magnets.sav b/apps/plugins/puzzles/icons/magnets.sav
new file mode 100644
index 0000000000..3c317b70ce
--- /dev/null
+++ b/apps/plugins/puzzles/icons/magnets.sav
@@ -0,0 +1,33 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :7:Magnets
+PARAMS  :6:6x5dtS
+CPARAMS :6:6x5dtS
+SEED    :15:705856238774945
+DESC    :56:2.2..1,.3.2.,2.21..,2..0.,TLRTLRBLRBTTLRLRBBLRTTTTLRBBBB
+AUXINFO :60:ebae280db3eec279c628b6cfe4aca5a03ba24d7eba91169f1bdf275fce3f
+NSTATES :2:24
+STATEPOS:2:15
+MOVE    :4:.1,3
+MOVE    :4:.0,1
+MOVE    :4:?0,1
+MOVE    :4:.2,1
+MOVE    :4:?2,1
+MOVE    :4:.2,4
+MOVE    :4:?2,4
+MOVE    :4:+2,3
+MOVE    :4:.3,3
+MOVE    :4:.0,2
+MOVE    :4:?0,2
+MOVE    :4:+1,4
+MOVE    :4:+0,2
+MOVE    :4:+0,0
+MOVE    :4:+1,1
+MOVE    :4:.2,2
+MOVE    :4:+2,0
+MOVE    :4:+3,1
+MOVE    :4:.4,0
+MOVE    :4:+5,1
+MOVE    :4:.5,3
+MOVE    :4:+4,3
+MOVE    :4:.4,2
diff --git a/apps/plugins/puzzles/icons/map.sav b/apps/plugins/puzzles/icons/map.sav
new file mode 100644
index 0000000000..33863e1eeb
--- /dev/null
+++ b/apps/plugins/puzzles/icons/map.sav
@@ -0,0 +1,27 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :3:Map
+PARAMS  :10:20x20n30dn
+CPARAMS :10:20x20n30dn
+SEED    :15:794003990129265
+DESC    :264:dcbakatgcaaedaccabfabadbaaaagaiaaaeaiadcaaaafabccbdcaaecabggedfaebqbadgbngcblabdaadaaaeagabaaaacaacacbcaebabaabaebaafaaakabdhcdanaaceagakacbbajaaadbacbaaccbcbicdafbadgbaccbkcdaafbacbcaaabcddacaaaaddbabcdbbacabbhagajabbobcdjaecaafabahaaaffead,23a01c3c1a3d2a20b01a3a
+AUXINFO :282:738e7a68c5d32445002968f3726646962b3604ef27a3657e0fdc0fd8180d5b747febd4619487bbc8bec5a48c709b154eb8da39c9b49be1e312a381fc2394e53126714079bd82e8444dad92419429635d1c816c53774b8c77b4ce03884c94d12bfb757cd93b5600471cb9726b3f2afe74d9932abeaa2efd6a496cad793ce5b221f943d620e883794f9d56741908
+NSTATES :2:18
+STATEPOS:2:12
+MOVE    :4:3:20
+MOVE    :4:0:24
+MOVE    :4:3:10
+MOVE    :4:1:18
+MOVE    :4:2:11
+MOVE    :4:3:17
+MOVE    :4:1:23
+MOVE    :4:3:27
+MOVE    :4:1:29
+MOVE    :4:0:16
+MOVE    :4:2:13
+MOVE    :3:1:6
+MOVE    :3:2:2
+MOVE    :3:0:7
+MOVE    :3:2:9
+MOVE    :4:0:15
+MOVE    :3:3:5
diff --git a/apps/plugins/puzzles/icons/mines.sav b/apps/plugins/puzzles/icons/mines.sav
new file mode 100644
index 0000000000..a827541163
--- /dev/null
+++ b/apps/plugins/puzzles/icons/mines.sav
@@ -0,0 +1,67 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :5:Mines
+PARAMS  :6:9x9n35
+CPARAMS :6:9x9n35
+SEED    :15:698938038698621
+DESC    :26:0,0,me0691ca8a278f3c371688
+PRIVDESC:22:me0691ca8a278f3c371688
+UI      :3:D0C
+TIME    :7:75.2958
+NSTATES :2:56
+STATEPOS:2:41
+MOVE    :4:O0,0
+MOVE    :4:F1,2
+MOVE    :4:F0,2
+MOVE    :4:O2,2
+MOVE    :4:F2,1
+MOVE    :4:F3,1
+MOVE    :4:F3,2
+MOVE    :4:F3,3
+MOVE    :4:F1,3
+MOVE    :4:F2,3
+MOVE    :4:C1,0
+MOVE    :4:C2,0
+MOVE    :4:C3,0
+MOVE    :4:F5,0
+MOVE    :4:F5,1
+MOVE    :4:C4,1
+MOVE    :4:O6,1
+MOVE    :4:O6,2
+MOVE    :4:O6,3
+MOVE    :4:F7,1
+MOVE    :4:O7,4
+MOVE    :4:O5,4
+MOVE    :4:F5,3
+MOVE    :4:F5,5
+MOVE    :4:F6,6
+MOVE    :4:C6,5
+MOVE    :4:F8,6
+MOVE    :4:C6,3
+MOVE    :4:F8,2
+MOVE    :4:C7,2
+MOVE    :4:F8,0
+MOVE    :4:F7,0
+MOVE    :4:F6,0
+MOVE    :4:C4,2
+MOVE    :4:F4,4
+MOVE    :4:F4,5
+MOVE    :4:F3,4
+MOVE    :4:C5,6
+MOVE    :4:F7,7
+MOVE    :4:F8,7
+MOVE    :4:F7,8
+MOVE    :4:O4,8
+MOVE    :4:F3,6
+MOVE    :4:C4,6
+MOVE    :4:F3,8
+MOVE    :4:F5,8
+MOVE    :4:C6,7
+MOVE    :4:C3,7
+MOVE    :4:F2,5
+MOVE    :4:F2,4
+MOVE    :4:F1,8
+MOVE    :4:F1,7
+MOVE    :4:C2,7
+MOVE    :4:C2,6
+MOVE    :4:C1,6
diff --git a/apps/plugins/puzzles/icons/net.sav b/apps/plugins/puzzles/icons/net.sav
new file mode 100644
index 0000000000..06a5426280
--- /dev/null
+++ b/apps/plugins/puzzles/icons/net.sav
@@ -0,0 +1,53 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :3:Net
+PARAMS  :3:5x5
+CPARAMS :3:5x5
+DESC    :25:1115337157375775157135131
+UI      :9:O0,0;C2,2
+NSTATES :2:45
+STATEPOS:2:45
+MOVE    :4:C0,0
+MOVE    :4:L0,0
+MOVE    :4:L0,1
+MOVE    :4:C0,2
+MOVE    :4:L0,2
+MOVE    :4:A0,3
+MOVE    :4:L0,3
+MOVE    :4:L0,4
+MOVE    :4:L1,4
+MOVE    :4:A2,4
+MOVE    :4:A2,4
+MOVE    :4:L2,4
+MOVE    :4:C1,0
+MOVE    :4:L1,0
+MOVE    :4:L3,0
+MOVE    :4:L2,0
+MOVE    :4:A4,0
+MOVE    :4:A4,0
+MOVE    :4:L4,0
+MOVE    :4:A4,1
+MOVE    :4:L4,1
+MOVE    :4:L3,1
+MOVE    :4:A3,2
+MOVE    :4:A3,2
+MOVE    :4:L3,2
+MOVE    :4:L2,2
+MOVE    :4:A2,1
+MOVE    :4:A2,1
+MOVE    :4:A1,1
+MOVE    :4:A1,1
+MOVE    :4:A1,1
+MOVE    :4:A1,1
+MOVE    :4:A1,1
+MOVE    :4:A1,1
+MOVE    :4:A1,2
+MOVE    :4:A1,2
+MOVE    :4:A1,3
+MOVE    :4:C2,3
+MOVE    :4:A3,3
+MOVE    :4:A4,4
+MOVE    :4:A4,4
+MOVE    :4:A4,3
+MOVE    :4:A4,2
+MOVE    :4:A4,2
diff --git a/apps/plugins/puzzles/icons/netslide.sav b/apps/plugins/puzzles/icons/netslide.sav
new file mode 100644
index 0000000000..f37178ee0c
--- /dev/null
+++ b/apps/plugins/puzzles/icons/netslide.sav
@@ -0,0 +1,47 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :8:Netslide
+PARAMS  :3:4x4
+CPARAMS :3:4x4
+SEED    :15:344208514520242
+DESC    :16:49b59aca247714b4
+AUXINFO :34:60d28a22f68cdb6078d67a4d6069b9ff54
+NSTATES :2:38
+STATEPOS:2:31
+MOVE    :4:R0,1
+MOVE    :4:C1,1
+MOVE    :4:R1,1
+MOVE    :4:R1,1
+MOVE    :4:C3,1
+MOVE    :4:C1,1
+MOVE    :4:R1,1
+MOVE    :4:R1,1
+MOVE    :4:R3,1
+MOVE    :4:R0,1
+MOVE    :4:C1,1
+MOVE    :5:R3,-1
+MOVE    :5:R0,-1
+MOVE    :4:R0,1
+MOVE    :4:R0,1
+MOVE    :4:C0,1
+MOVE    :5:R0,-1
+MOVE    :5:R0,-1
+MOVE    :5:C1,-1
+MOVE    :4:R1,1
+MOVE    :4:C1,1
+MOVE    :5:R1,-1
+MOVE    :5:C0,-1
+MOVE    :5:C0,-1
+MOVE    :4:R3,1
+MOVE    :4:C0,1
+MOVE    :4:C0,1
+MOVE    :5:R3,-1
+MOVE    :4:C0,1
+MOVE    :5:R3,-1
+MOVE    :5:C1,-1
+MOVE    :4:R0,1
+MOVE    :4:C0,1
+MOVE    :5:R0,-1
+MOVE    :5:C0,-1
+MOVE    :4:C1,1
+MOVE    :4:R3,1
diff --git a/apps/plugins/puzzles/icons/palisade.sav b/apps/plugins/puzzles/icons/palisade.sav
new file mode 100644
index 0000000000..a935e890bb
--- /dev/null
+++ b/apps/plugins/puzzles/icons/palisade.sav
@@ -0,0 +1,50 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :8:Palisade
+PARAMS  :5:5x5n5
+CPARAMS :5:5x5n5
+SEED    :15:930059588777257
+DESC    :13:2d23c33e2c1b2
+AUXINFO :52:14a191be1282597737537139d11d87fb4f21ad4a8f31e67b4441
+NSTATES :2:41
+STATEPOS:2:27
+MOVE    :14:F0,1,16F0,0,64
+MOVE    :15:F0,0,32F1,0,128
+MOVE    :12:F1,1,8F0,1,2
+MOVE    :12:F1,0,4F1,1,1
+MOVE    :14:F0,2,16F0,1,64
+MOVE    :12:F1,2,8F0,2,2
+MOVE    :12:F0,3,1F0,2,4
+MOVE    :15:F2,0,128F1,0,32
+MOVE    :12:F2,0,4F2,1,1
+MOVE    :12:F3,0,8F2,0,2
+MOVE    :15:F1,4,128F0,4,32
+MOVE    :14:F1,4,16F1,3,64
+MOVE    :15:F2,4,128F1,4,32
+MOVE    :14:F0,3,64F0,4,16
+MOVE    :15:F1,3,128F0,3,32
+MOVE    :12:F1,3,1F1,2,4
+MOVE    :15:F4,4,128F3,4,32
+MOVE    :14:F4,4,16F4,3,64
+MOVE    :12:F3,4,8F2,4,2
+MOVE    :12:F2,4,1F2,3,4
+MOVE    :12:F2,3,8F1,3,2
+MOVE    :14:F2,2,64F2,3,16
+MOVE    :15:F2,3,32F3,3,128
+MOVE    :12:F3,3,4F3,4,1
+MOVE    :12:F4,3,8F3,3,2
+MOVE    :14:F4,3,16F4,2,64
+MOVE    :12:F1,2,1F1,1,4
+MOVE    :15:F2,1,128F1,1,32
+MOVE    :15:F2,2,128F1,2,32
+MOVE    :12:F2,2,1F2,1,4
+MOVE    :15:F3,2,128F2,2,32
+MOVE    :14:F3,2,64F3,3,16
+MOVE    :12:F4,2,8F3,2,2
+MOVE    :12:F3,2,1F3,1,4
+MOVE    :15:F2,1,32F3,1,128
+MOVE    :14:F4,2,16F4,1,64
+MOVE    :12:F4,1,8F3,1,2
+MOVE    :14:F3,0,64F3,1,16
+MOVE    :15:F4,0,128F3,0,32
+MOVE    :12:F4,1,1F4,0,4
diff --git a/apps/plugins/puzzles/icons/pattern.sav b/apps/plugins/puzzles/icons/pattern.sav
new file mode 100644
index 0000000000..97c2396052
--- /dev/null
+++ b/apps/plugins/puzzles/icons/pattern.sav
@@ -0,0 +1,29 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :7:Pattern
+PARAMS  :5:10x10
+CPARAMS :5:10x10
+DESC    :67:3.4/2.2/4.1/2.3/2.3.2/4/6/6/3.1/1/5/5/1.1/4/5/6/2.3/3.3/1.1.3/1.1.4
+NSTATES :2:22
+STATEPOS:2:22
+MOVE    :8:F6,4,1,2
+MOVE    :8:F7,4,1,2
+MOVE    :8:F4,5,2,1
+MOVE    :8:F5,4,1,1
+MOVE    :8:E0,5,2,1
+MOVE    :8:E0,4,3,1
+MOVE    :8:F0,6,1,4
+MOVE    :8:F0,1,1,2
+MOVE    :8:F0,1,5,1
+MOVE    :8:E1,2,1,1
+MOVE    :8:F2,0,1,4
+MOVE    :8:E3,2,1,1
+MOVE    :8:F3,0,1,1
+MOVE    :8:F4,0,1,1
+MOVE    :8:F3,3,1,1
+MOVE    :8:E6,3,4,1
+MOVE    :8:F6,6,1,4
+MOVE    :8:F7,6,1,4
+MOVE    :8:E6,0,1,4
+MOVE    :8:E7,0,1,3
+MOVE    :8:E5,1,1,1
diff --git a/apps/plugins/puzzles/icons/pearl.sav b/apps/plugins/puzzles/icons/pearl.sav
new file mode 100644
index 0000000000..730ca85149
--- /dev/null
+++ b/apps/plugins/puzzles/icons/pearl.sav
@@ -0,0 +1,23 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :5:Pearl
+PARAMS  :5:6x6dt
+CPARAMS :5:6x6dt
+SEED    :15:901944054393278
+DESC    :17:BbBfWcWbWBaBeWgWa
+AUXINFO :72:f8bbe71b9be753d5fa143df207d7797ba62a9b3996eb8b8889487e1a2bd659d91a5e73e1
+NSTATES :2:14
+STATEPOS:1:7
+MOVE    :55:F4,2,0;F1,1,0;F4,1,0;F1,0,0;F8,0,0;F2,0,1;F8,0,1;F2,0,2
+MOVE    :27:F1,0,3;F4,1,3;F1,1,3;F4,2,3
+MOVE    :27:F8,3,0;F2,3,1;F8,3,1;F2,3,2
+MOVE    :97:F2,4,2;F8,4,1;F2,4,1;F8,4,0;F1,4,0;F4,5,0;F8,5,0;F2,5,1;F8,5,1;F2,5,2;F8,5,2;F2,5,3;F4,5,3;F1,4,3
+MOVE    :13:F4,4,2;F1,3,2
+MOVE    :13:F4,3,0;F1,2,0
+MOVE    :69:F2,2,3;F8,2,2;F2,2,2;F8,2,1;F4,2,1;F1,1,1;F8,1,1;F2,1,2;F4,1,2;F1,0,2
+MOVE    :41:F8,0,3;F2,0,4;F8,0,4;F2,0,5;F1,0,5;F4,1,5
+MOVE    :27:F1,1,4;F4,2,4;F1,2,4;F4,3,4
+MOVE    :13:F8,1,4;F2,1,5
+MOVE    :55:F1,3,5;F4,4,5;F1,4,5;F4,5,5;F2,5,5;F8,5,4;F4,5,4;F1,4,4
+MOVE    :13:F2,3,5;F8,3,4
+MOVE    :13:F2,4,4;F8,4,3
diff --git a/apps/plugins/puzzles/icons/pegs.sav b/apps/plugins/puzzles/icons/pegs.sav
new file mode 100644
index 0000000000..22b8a0d82f
--- /dev/null
+++ b/apps/plugins/puzzles/icons/pegs.sav
@@ -0,0 +1,16 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :4:Pegs
+PARAMS  :8:7x7cross
+CPARAMS :8:7x7cross
+SEED    :15:103342250484448
+DESC    :49:OOPPPOOOOPPPOOPPPPPPPPPPHPPPPPPPPPPOOPPPOOOOPPPOO
+NSTATES :1:8
+STATEPOS:1:8
+MOVE    :7:3,1-3,3
+MOVE    :7:5,2-3,2
+MOVE    :7:5,4-5,2
+MOVE    :7:3,4-5,4
+MOVE    :7:6,4-4,4
+MOVE    :7:4,0-4,2
+MOVE    :7:2,0-4,0
diff --git a/apps/plugins/puzzles/icons/range.sav b/apps/plugins/puzzles/icons/range.sav
new file mode 100644
index 0000000000..708e7db248
--- /dev/null
+++ b/apps/plugins/puzzles/icons/range.sav
@@ -0,0 +1,36 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :5:Range
+PARAMS  :3:7x7
+CPARAMS :3:7x7
+SEED    :15:989032078841515
+DESC    :22:d7b3e8e5c7a7c13e4e8b4d
+UI      :1:0
+NSTATES :2:27
+STATEPOS:2:27
+MOVE    :5:W,4,2
+MOVE    :5:W,4,3
+MOVE    :5:W,4,4
+MOVE    :5:W,4,5
+MOVE    :5:W,4,6
+MOVE    :5:W,4,0
+MOVE    :5:W,3,1
+MOVE    :5:W,2,1
+MOVE    :5:W,1,1
+MOVE    :5:W,0,1
+MOVE    :5:W,6,1
+MOVE    :5:W,5,1
+MOVE    :5:W,5,5
+MOVE    :5:W,1,5
+MOVE    :5:B,5,2
+MOVE    :5:W,5,3
+MOVE    :5:W,6,3
+MOVE    :5:W,3,6
+MOVE    :5:W,2,6
+MOVE    :5:B,3,5
+MOVE    :5:W,2,4
+MOVE    :5:W,2,2
+MOVE    :5:B,2,3
+MOVE    :5:W,1,3
+MOVE    :5:W,3,3
+MOVE    :5:W,0,5
diff --git a/apps/plugins/puzzles/icons/rect.sav b/apps/plugins/puzzles/icons/rect.sav
new file mode 100644
index 0000000000..17264daeeb
--- /dev/null
+++ b/apps/plugins/puzzles/icons/rect.sav
@@ -0,0 +1,17 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :10:Rectangles
+PARAMS  :3:7x7
+CPARAMS :3:7x7
+DESC    :33:a3d2b2a3_2a4a8h2a3c4_2b2c3a3_3c3b
+NSTATES :2:10
+STATEPOS:2:10
+MOVE    :8:R0,6,3,1
+MOVE    :8:R6,4,1,3
+MOVE    :8:R3,6,3,1
+MOVE    :8:R4,4,2,1
+MOVE    :8:R3,5,3,1
+MOVE    :8:R6,1,1,3
+MOVE    :8:R5,0,2,1
+MOVE    :8:R5,1,1,2
+MOVE    :8:R4,3,2,1
diff --git a/apps/plugins/puzzles/icons/samegame.sav b/apps/plugins/puzzles/icons/samegame.sav
new file mode 100644
index 0000000000..f92b52d1b6
--- /dev/null
+++ b/apps/plugins/puzzles/icons/samegame.sav
@@ -0,0 +1,34 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :9:Same Game
+PARAMS  :9:10x10c3s2
+CPARAMS :9:10x10c3s2
+SEED    :15:785412408200083
+DESC    :199:1,1,3,1,2,2,1,2,3,2,2,2,3,3,2,1,1,1,3,2,3,3,2,3,1,3,2,1,1,3,1,2,2,2,3,2,3,2,3,2,1,3,1,2,1,2,3,2,1,3,2,3,1,1,3,3,1,3,3,3,1,1,3,2,2,1,1,2,1,2,2,2,3,1,3,2,2,1,2,3,3,1,2,3,1,3,3,2,1,3,3,1,3,1,2,2,1,3,1,2
+NSTATES :2:26
+STATEPOS:2:13
+MOVE    :6:M94,95
+MOVE    :6:M83,84
+MOVE    :9:M83,93,94
+MOVE    :6:M93,94
+MOVE    :6:M20,21
+MOVE    :15:M20,21,22,31,32
+MOVE    :6:M70,71
+MOVE    :6:M80,90
+MOVE    :9:M73,82,83
+MOVE    :18:M72,73,74,82,83,92
+MOVE    :12:M51,61,62,72
+MOVE    :9:M35,36,46
+MOVE    :12:M49,57,58,59
+MOVE    :6:M59,69
+MOVE    :9:M69,79,89
+MOVE    :12:M78,79,89,99
+MOVE    :24:M45,46,47,54,55,57,64,67
+MOVE    :36:M36,46,55,56,57,66,67,68,77,78,88,98
+MOVE    :9:M76,77,87
+MOVE    :6:M97,98
+MOVE    :6:M94,95
+MOVE    :45:M50,60,61,70,71,81,82,83,84,85,90,91,92,93,94
+MOVE    :12:M73,81,82,83
+MOVE    :6:M92,93
+MOVE    :9:M81,90,91
diff --git a/apps/plugins/puzzles/icons/screenshot.sh b/apps/plugins/puzzles/icons/screenshot.sh
new file mode 100755
index 0000000000..0e2a06eea7
--- /dev/null
+++ b/apps/plugins/puzzles/icons/screenshot.sh
@@ -0,0 +1,25 @@
+#!/bin/sh 
+
+# Generate a screenshot from a puzzle save file. Takes the
+# following arguments, in order:
+#
+#  - the name of the puzzle binary
+#  - the name of the save file
+#  - the name of the output image file
+#  - (optionally) the proportion of the next move to redo before
+#    taking the screenshot.
+#
+# This script requires access to an X server in order to run, but
+# seems to work fine under xvfb-run if you haven't got a real one
+# available (or if you don't want to use it for some reason).
+
+binary="$1"
+save="$2"
+image="$3"
+if test "x$4" != "x"; then
+  redo="--redo $4"
+else
+  redo=
+fi
+
+"$binary" $redo --screenshot "$image" --load "$save"
diff --git a/apps/plugins/puzzles/icons/signpost.sav b/apps/plugins/puzzles/icons/signpost.sav
new file mode 100644
index 0000000000..9ad1958ddf
--- /dev/null
+++ b/apps/plugins/puzzles/icons/signpost.sav
@@ -0,0 +1,23 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :8:Signpost
+PARAMS  :4:4x4c
+CPARAMS :4:4x4c
+SEED    :15:230468784719861
+DESC    :19:1eceebecfbfhgcaa16a
+NSTATES :2:15
+STATEPOS:2:11
+MOVE    :8:L2,1-3,1
+MOVE    :8:L0,1-1,0
+MOVE    :8:L2,2-1,1
+MOVE    :8:L1,2-0,3
+MOVE    :8:L0,2-2,0
+MOVE    :8:L1,3-1,2
+MOVE    :8:L1,1-1,3
+MOVE    :8:L1,0-3,0
+MOVE    :8:L0,0-0,1
+MOVE    :8:L3,0-3,2
+MOVE    :8:L3,2-0,2
+MOVE    :8:L3,1-2,2
+MOVE    :8:L2,3-2,1
+MOVE    :8:L2,0-2,3
diff --git a/apps/plugins/puzzles/icons/singles.sav b/apps/plugins/puzzles/icons/singles.sav
new file mode 100644
index 0000000000..260fd1f2b3
--- /dev/null
+++ b/apps/plugins/puzzles/icons/singles.sav
@@ -0,0 +1,45 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :7:Singles
+PARAMS  :5:6x6dk
+CPARAMS :5:6x6dk
+SEED    :15:781273601054598
+DESC    :36:361566412253452144234115163346553461
+NSTATES :2:37
+STATEPOS:2:22
+MOVE    :4:B1,0
+MOVE    :4:C0,0
+MOVE    :4:C1,1
+MOVE    :4:C2,0
+MOVE    :4:C0,1
+MOVE    :4:B0,2
+MOVE    :4:C0,3
+MOVE    :4:C1,2
+MOVE    :4:C4,3
+MOVE    :4:B3,3
+MOVE    :4:C3,2
+MOVE    :4:C2,3
+MOVE    :4:C3,4
+MOVE    :4:B2,4
+MOVE    :4:C1,4
+MOVE    :4:C2,5
+MOVE    :4:B1,5
+MOVE    :4:C0,5
+MOVE    :4:C0,4
+MOVE    :4:C1,3
+MOVE    :4:C3,5
+MOVE    :4:B5,4
+MOVE    :4:C4,4
+MOVE    :4:C5,5
+MOVE    :4:C5,3
+MOVE    :4:C4,5
+MOVE    :4:B4,0
+MOVE    :4:C3,0
+MOVE    :4:C4,1
+MOVE    :4:C5,0
+MOVE    :4:C5,1
+MOVE    :4:B4,2
+MOVE    :4:C5,2
+MOVE    :4:C3,1
+MOVE    :4:B2,1
+MOVE    :4:C2,2
diff --git a/apps/plugins/puzzles/icons/sixteen.sav b/apps/plugins/puzzles/icons/sixteen.sav
new file mode 100644
index 0000000000..076b1fbd4d
--- /dev/null
+++ b/apps/plugins/puzzles/icons/sixteen.sav
@@ -0,0 +1,39 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :7:Sixteen
+PARAMS  :3:4x4
+CPARAMS :3:4x4
+SEED    :15:601798566229573
+DESC    :38:2,16,3,10,13,8,7,4,9,14,12,11,15,1,5,6
+NSTATES :2:31
+STATEPOS:2:24
+MOVE    :5:C3,-1
+MOVE    :4:R0,1
+MOVE    :4:C1,1
+MOVE    :5:R0,-1
+MOVE    :5:C1,-1
+MOVE    :5:C3,-1
+MOVE    :4:R2,1
+MOVE    :4:R2,1
+MOVE    :4:C3,1
+MOVE    :5:C2,-1
+MOVE    :5:C2,-1
+MOVE    :4:R1,1
+MOVE    :4:R1,1
+MOVE    :4:C2,1
+MOVE    :4:C2,1
+MOVE    :4:R3,1
+MOVE    :4:R3,1
+MOVE    :4:C1,1
+MOVE    :5:R2,-1
+MOVE    :5:R2,-1
+MOVE    :5:C1,-1
+MOVE    :4:R2,1
+MOVE    :4:C0,1
+MOVE    :4:R3,1
+MOVE    :5:R2,-1
+MOVE    :5:C1,-1
+MOVE    :4:R2,1
+MOVE    :4:C1,1
+MOVE    :5:R3,-1
+MOVE    :5:C0,-1
diff --git a/apps/plugins/puzzles/icons/slant.sav b/apps/plugins/puzzles/icons/slant.sav
new file mode 100644
index 0000000000..02017e5d48
--- /dev/null
+++ b/apps/plugins/puzzles/icons/slant.sav
@@ -0,0 +1,51 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :5:Slant
+PARAMS  :5:8x8de
+CPARAMS :5:8x8de
+DESC    :47:a10h23a32a02b22e3a2c1g3a20d32a0c221a210i0a101b0
+NSTATES :2:44
+STATEPOS:2:44
+MOVE    :4:/7,0
+MOVE    :4:\7,1
+MOVE    :4:\1,0
+MOVE    :4:/2,0
+MOVE    :4:\0,4
+MOVE    :4:/0,5
+MOVE    :4:\0,6
+MOVE    :4:/0,7
+MOVE    :4:\1,7
+MOVE    :4:/7,7
+MOVE    :4:/3,7
+MOVE    :4:\4,7
+MOVE    :4:\5,7
+MOVE    :4:/2,7
+MOVE    :4:/7,4
+MOVE    :4:\7,5
+MOVE    :4:\7,3
+MOVE    :4:\7,2
+MOVE    :4:/6,2
+MOVE    :4:\6,3
+MOVE    :4:\7,6
+MOVE    :4:/3,0
+MOVE    :4:/2,1
+MOVE    :4:\3,1
+MOVE    :4:/2,2
+MOVE    :4:\3,2
+MOVE    :4:/2,3
+MOVE    :4:\3,3
+MOVE    :4:\1,1
+MOVE    :4:/0,1
+MOVE    :4:\0,2
+MOVE    :4:\1,2
+MOVE    :4:\1,3
+MOVE    :4:/0,3
+MOVE    :4:\1,4
+MOVE    :4:\0,0
+MOVE    :4:\5,3
+MOVE    :4:\6,4
+MOVE    :4:/5,4
+MOVE    :4:/5,5
+MOVE    :4:\6,5
+MOVE    :4:/4,5
+MOVE    :4:\4,6
diff --git a/apps/plugins/puzzles/icons/solo.sav b/apps/plugins/puzzles/icons/solo.sav
new file mode 100644
index 0000000000..385cc68fe5
--- /dev/null
+++ b/apps/plugins/puzzles/icons/solo.sav
@@ -0,0 +1,36 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :4:Solo
+PARAMS  :3:3x3
+CPARAMS :3:3x3
+DESC    :73:a2e9a5b6a2b3_7a1_4a9_6a2b4_1a7_2b1_7e6_9b2_5a8_1b6a5_9a3_8a7_2b8a6b1a1e4a
+NSTATES :2:29
+STATEPOS:2:29
+MOVE    :6:R7,1,1
+MOVE    :6:R4,6,1
+MOVE    :6:R5,0,1
+MOVE    :6:R0,0,4
+MOVE    :6:R2,0,6
+MOVE    :6:R1,2,3
+MOVE    :6:R0,3,9
+MOVE    :6:R1,3,5
+MOVE    :6:R2,4,8
+MOVE    :6:R0,5,3
+MOVE    :6:R1,5,6
+MOVE    :6:R1,6,4
+MOVE    :6:R4,7,4
+MOVE    :6:R7,6,2
+MOVE    :6:R7,7,5
+MOVE    :6:R8,8,6
+MOVE    :6:R7,3,3
+MOVE    :6:R8,3,7
+MOVE    :6:R8,3,8
+MOVE    :6:R6,4,5
+MOVE    :6:R7,5,7
+MOVE    :6:R8,5,4
+MOVE    :6:R7,2,8
+MOVE    :6:R8,0,5
+MOVE    :6:R4,2,5
+MOVE    :6:R4,3,6
+MOVE    :6:R5,4,4
+MOVE    :6:R4,5,9
diff --git a/apps/plugins/puzzles/icons/square.pl b/apps/plugins/puzzles/icons/square.pl
new file mode 100755
index 0000000000..815b94b532
--- /dev/null
+++ b/apps/plugins/puzzles/icons/square.pl
@@ -0,0 +1,95 @@
+#!/usr/bin/perl 
+
+# Read an input image, crop its border to a standard width, and
+# convert it into a square output image. Parameters are:
+#
+#  - the required total image size
+#  - the output border thickness
+#  - the input image file name
+#  - the output image file name.
+
+($osize, $oborder, $infile, $outfile) = @ARGV;
+
+# Determine the input image's size.
+$ident = `identify -format "%w %h" $infile`;
+$ident =~ /(\d+) (\d+)/ or die "unable to get size for $infile\n";
+($w, $h) = ($1, $2);
+
+# Read the input image data.
+$data = [];
+open IDATA, "convert -depth 8 $infile rgb:- |";
+push @$data, $rgb while (read IDATA,$rgb,3,0) == 3;
+close IDATA;
+# Check we have the right amount of data.
+$xl = $w * $h;
+$al = scalar @$data;
+die "wrong amount of image data ($al, expected $xl) from $infile\n"
+  unless $al == $xl;
+
+# Find the background colour, by looking around the entire border
+# and finding the most popular pixel colour.
+for ($i = 0; $i < $w; $i++) {
+    $pcount{$data->[$i]}++; # top row
+    $pcount{$data->[($h-1)*$w+$i]}++; # bottom row
+}
+for ($i = 1; $i < $h-1; $i++) {
+    $pcount{$data->[$i*$w]}++; # left column
+    $pcount{$data->[$i*$w+$w-1]}++; # right column
+}
+@plist = sort { $pcount{$b} <=> $pcount{$a} } keys %pcount;
+$back = $plist[0];
+
+# Crop rows and columns off the image to find the central rectangle
+# of non-background stuff.
+$ystart = 0;
+$ystart++ while $ystart < $h and scalar(grep { $_ ne $back } map { $data->[$ystart*$w+$_] } 0 .. ($w-1)) == 0;
+$yend = $h-1;
+$yend-- while $yend >= $ystart and scalar(grep { $_ ne $back } map { $data->[$yend*$w+$_] } 0 .. ($w-1)) == 0;
+$xstart = 0;
+$xstart++ while $xstart < $w and scalar(grep { $_ ne $back } map { $data->[$_*$w+$xstart] } 0 .. ($h-1)) == 0;
+$xend = $w-1;
+$xend-- while $xend >= $xstart and scalar(grep { $_ ne $back } map { $data->[$_*$w+$xend] } 0 .. ($h-1)) == 0;
+
+# Decide how much border we're going to put back on to make the
+# image perfectly square.
+$hexpand = ($yend-$ystart) - ($xend-$xstart);
+if ($hexpand > 0) {
+    $left = int($hexpand / 2);
+    $xstart -= $left;
+    $xend += $hexpand - $left;
+} elsif ($hexpand < 0) {
+    $vexpand = -$hexpand;
+    $top = int($vexpand / 2);
+    $ystart -= $top;
+    $yend += $vexpand - $top;
+}
+$ow = $xend - $xstart + 1;
+$oh = $yend - $ystart + 1;
+die "internal computation problem" if $ow != $oh; # should be square
+
+# And decide how much _more_ border goes on to add the bit around
+# the edge.
+$realow = int($ow * ($osize / ($osize - 2*$oborder)));
+$extra = $realow - $ow;
+$left = int($extra / 2);
+$xstart -= $left;
+$xend += $extra - $left;
+$top = int($extra / 2);
+$ystart -= $top;
+$yend += $extra - $top;
+$ow = $xend - $xstart + 1;
+$oh = $yend - $ystart + 1;
+die "internal computation problem" if $ow != $oh; # should be square
+
+# Now write out the resulting image, and resize it appropriately.
+open IDATA, "| convert -size ${ow}x${oh} -depth 8 -resize ${osize}x${osize}! rgb:- $outfile";
+for ($y = $ystart; $y <= $yend; $y++) {
+    for ($x = $xstart; $x <= $xend; $x++) {
+        if ($x >= 0 && $x < $w && $y >= 0 && $y < $h) {
+            print IDATA $data->[$y*$w+$x];
+        } else {
+            print IDATA $back;
+        }
+    }
+}
+close IDATA;
diff --git a/apps/plugins/puzzles/icons/tents.sav b/apps/plugins/puzzles/icons/tents.sav
new file mode 100644
index 0000000000..292c2d2d75
--- /dev/null
+++ b/apps/plugins/puzzles/icons/tents.sav
@@ -0,0 +1,32 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :5:Tents
+PARAMS  :5:8x8de
+CPARAMS :5:8x8de
+DESC    :45:ea_ddidfaabkd,3,0,2,1,2,2,1,1,3,1,1,1,1,1,3,1
+NSTATES :2:25
+STATEPOS:2:25
+MOVE    :9:N5,6;N6,6
+MOVE    :14:N5,7;N6,7;N7,7
+MOVE    :9:N0,7;N1,7
+MOVE    :4:N1,6
+MOVE    :14:N6,2;N6,3;N6,4
+MOVE    :9:N7,2;N7,3
+MOVE    :14:N1,0;N2,0;N3,0
+MOVE    :4:N3,1
+MOVE    :4:N0,3
+MOVE    :4:N3,4
+MOVE    :4:N5,4
+MOVE    :4:T6,0
+MOVE    :4:T4,0
+MOVE    :4:T0,0
+MOVE    :4:N1,1
+MOVE    :4:N4,1
+MOVE    :9:N6,1;N7,1
+MOVE    :4:T2,1
+MOVE    :9:N1,2;N3,2
+MOVE    :4:T5,2
+MOVE    :4:N4,2
+MOVE    :4:N5,3
+MOVE    :4:N0,2
+MOVE    :9:N1,3;N1,5
diff --git a/apps/plugins/puzzles/icons/towers.sav b/apps/plugins/puzzles/icons/towers.sav
new file mode 100644
index 0000000000..351d473a63
--- /dev/null
+++ b/apps/plugins/puzzles/icons/towers.sav
@@ -0,0 +1,26 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :6:Towers
+PARAMS  :3:4de
+CPARAMS :3:4de
+SEED    :15:888431554483015
+DESC    :31:2/2/1/3/2/2/3/1/3/1/2/2/2/3/2/1
+AUXINFO :34:297d7a2fcf9e14403a74c976fe0fefd306
+NSTATES :2:17
+STATEPOS:2:10
+MOVE    :6:R2,0,4
+MOVE    :6:R0,1,4
+MOVE    :6:R3,3,4
+MOVE    :6:R1,2,4
+MOVE    :6:R0,3,3
+MOVE    :6:R1,0,3
+MOVE    :6:R3,2,3
+MOVE    :6:R2,1,3
+MOVE    :6:R3,0,2
+MOVE    :6:R3,1,1
+MOVE    :6:R1,1,2
+MOVE    :6:R1,3,1
+MOVE    :6:R2,3,2
+MOVE    :6:R2,2,1
+MOVE    :6:R0,2,2
+MOVE    :6:R0,0,1
diff --git a/apps/plugins/puzzles/icons/tracks.sav b/apps/plugins/puzzles/icons/tracks.sav
new file mode 100644
index 0000000000..ca30644506
--- /dev/null
+++ b/apps/plugins/puzzles/icons/tracks.sav
@@ -0,0 +1,31 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :12:Train Tracks
+PARAMS  :5:6x6dt
+CPARAMS :5:6x6dt
+SEED    :15:145870397370785
+DESC    :31:l6t9b,3,2,1,S4,5,4,2,6,S3,2,3,3
+NSTATES :2:23
+STATEPOS:2:20
+MOVE    :5:TD0,0
+MOVE    :5:TR0,0
+MOVE    :5:TL5,5
+MOVE    :5:TU5,5
+MOVE    :29:TS1,1;TS2,1;TS3,1;TS4,1;TS5,1
+MOVE    :29:NS2,0;NS2,2;NS2,3;NS2,4;NS2,5
+MOVE    :5:TU1,1
+MOVE    :17:NS0,3;NS0,4;NS0,5
+MOVE    :23:NS1,2;NS1,3;NS1,4;NS1,5
+MOVE    :5:TL2,1
+MOVE    :5:TL3,1
+MOVE    :5:TS4,4
+MOVE    :5:TS3,4
+MOVE    :17:NS3,0;NS4,0;NS5,0
+MOVE    :5:TS4,2
+MOVE    :5:TS4,3
+MOVE    :5:TU3,4
+MOVE    :5:TL4,4
+MOVE    :5:TL5,1
+MOVE    :5:TU5,2
+MOVE    :5:NS5,3
+MOVE    :5:NS3,2
diff --git a/apps/plugins/puzzles/icons/twiddle.sav b/apps/plugins/puzzles/icons/twiddle.sav
new file mode 100644
index 0000000000..2863033f99
--- /dev/null
+++ b/apps/plugins/puzzles/icons/twiddle.sav
@@ -0,0 +1,35 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :7:Twiddle
+PARAMS  :5:3x3n2
+CPARAMS :5:3x3n2
+SEED    :15:635499951462226
+DESC    :17:3,7,2,6,5,1,8,4,9
+NSTATES :2:27
+STATEPOS:2:22
+MOVE    :7:M0,0,-1
+MOVE    :7:M1,0,-1
+MOVE    :6:M1,1,1
+MOVE    :6:M0,1,1
+MOVE    :6:M0,0,1
+MOVE    :6:M0,0,1
+MOVE    :7:M1,1,-1
+MOVE    :7:M0,1,-1
+MOVE    :7:M0,1,-1
+MOVE    :7:M1,1,-1
+MOVE    :6:M0,1,1
+MOVE    :7:M0,1,-1
+MOVE    :6:M1,1,1
+MOVE    :6:M1,1,1
+MOVE    :6:M0,1,1
+MOVE    :6:M0,1,1
+MOVE    :7:M0,1,-1
+MOVE    :7:M1,1,-1
+MOVE    :7:M0,1,-1
+MOVE    :7:M1,1,-1
+MOVE    :6:M0,1,1
+MOVE    :7:M1,0,-1
+MOVE    :7:M0,1,-1
+MOVE    :6:M1,0,1
+MOVE    :6:M1,1,1
+MOVE    :6:M1,1,1
diff --git a/apps/plugins/puzzles/icons/undead.sav b/apps/plugins/puzzles/icons/undead.sav
new file mode 100644
index 0000000000..3c314dde8a
--- /dev/null
+++ b/apps/plugins/puzzles/icons/undead.sav
@@ -0,0 +1,14 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :6:Undead
+PARAMS  :6:4x4de2
+CPARAMS :6:4x4de2
+DESC    :48:5,2,2,aRLgLLaLRL,2,0,1,2,1,1,2,5,0,0,0,2,1,3,1,1
+NSTATES :1:7
+STATEPOS:1:7
+MOVE    :2:G0
+MOVE    :2:V0
+MOVE    :2:G2
+MOVE    :2:G3
+MOVE    :2:V3
+MOVE    :2:Z3
diff --git a/apps/plugins/puzzles/icons/unequal.sav b/apps/plugins/puzzles/icons/unequal.sav
new file mode 100644
index 0000000000..c414513a22
--- /dev/null
+++ b/apps/plugins/puzzles/icons/unequal.sav
@@ -0,0 +1,25 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :7:Unequal
+PARAMS  :3:4de
+CPARAMS :3:4de
+SEED    :15:143029490219212
+DESC    :37:0D,0,0L,0,0,0,0,0,0D,0U,0R,0,0,0,0,4,
+AUXINFO :34:f51274dc41e0a39caa38942fc525ed0108
+NSTATES :2:16
+STATEPOS:1:6
+MOVE    :6:R2,1,4
+MOVE    :6:R1,2,4
+MOVE    :6:R0,0,4
+MOVE    :6:R2,3,1
+MOVE    :6:R3,2,1
+MOVE    :6:R0,2,3
+MOVE    :6:R2,2,2
+MOVE    :6:R0,3,2
+MOVE    :6:R1,3,3
+MOVE    :6:R0,1,1
+MOVE    :6:R1,1,2
+MOVE    :6:R3,1,3
+MOVE    :6:R3,0,2
+MOVE    :6:R2,0,3
+MOVE    :6:R1,0,1
diff --git a/apps/plugins/puzzles/icons/unruly.sav b/apps/plugins/puzzles/icons/unruly.sav
new file mode 100644
index 0000000000..0f7ca1b9dd
--- /dev/null
+++ b/apps/plugins/puzzles/icons/unruly.sav
@@ -0,0 +1,22 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :6:Unruly
+PARAMS  :5:6x6de
+CPARAMS :5:6x6de
+DESC    :10:faCADAJeBd
+NSTATES :2:15
+STATEPOS:2:15
+MOVE    :6:P0,1,2
+MOVE    :6:P0,4,2
+MOVE    :6:P0,3,3
+MOVE    :6:P0,3,0
+MOVE    :6:P0,5,1
+MOVE    :6:P0,2,1
+MOVE    :6:P1,4,0
+MOVE    :6:P1,1,1
+MOVE    :6:P1,5,2
+MOVE    :6:P0,0,2
+MOVE    :6:P1,0,3
+MOVE    :6:P1,0,0
+MOVE    :6:P1,0,4
+MOVE    :6:P0,2,4
diff --git a/apps/plugins/puzzles/icons/untangle.sav b/apps/plugins/puzzles/icons/untangle.sav
new file mode 100644
index 0000000000..016318a521
--- /dev/null
+++ b/apps/plugins/puzzles/icons/untangle.sav
@@ -0,0 +1,16 @@
+SAVEFILE:41:Simon Tatham's Portable Puzzle Collection
+VERSION :1:1
+GAME    :8:Untangle
+PARAMS  :2:10
+CPARAMS :2:10
+SEED    :15:761628688787632
+DESC    :63:0-1,0-5,0-8,0-9,1-4,1-8,2-6,2-7,3-5,3-6,3-9,4-5,4-7,5-7,6-7,8-9
+AUXINFO :182:01bee8258e3164fe966f294b2837b6584b965b8d8e97571ba48f26c9bc0a91ac4b49fb4652bfaa5c340c82c57afbaa4620f2f6d49d7a7b330a66594d2b88c499d57c4093379b7dc322f2afa1ebab81004585751c39c19f8f9930c4
+NSTATES :1:7
+STATEPOS:1:6
+MOVE    :12:P8:168,16/64
+MOVE    :12:P0:186,85/64
+MOVE    :12:P2:47,254/64
+MOVE    :13:P5:131,153/64
+MOVE    :12:P3:75,126/64
+MOVE    :12:P7:93,303/64
diff --git a/apps/plugins/puzzles/icons/win16pal.xpm b/apps/plugins/puzzles/icons/win16pal.xpm
new file mode 100644
index 0000000000..66fd60a480
--- /dev/null
+++ b/apps/plugins/puzzles/icons/win16pal.xpm
@@ -0,0 +1,23 @@
+/* XPM */
+static char *win16pal[] = {
+/* columns rows colors chars-per-pixel */
+"16 1 16 1",
+"  c #000000",
+". c #800000",
+"X c #008000",
+"o c #808000",
+"O c #000080",
+"+ c #800080",
+"@ c #008080",
+"# c #C0C0C0",
+"$ c #808080",
+"% c #FF0000",
+"& c #00FF00",
+"* c #FFFF00",
+"= c #0000FF",
+"- c #FF00FF",
+"; c #00FFFF",
+": c #FFFFFF",
+/* pixels */
+" .XoO+@#$%&*=-;:"
+};
diff --git a/apps/plugins/puzzles/inertia.R b/apps/plugins/puzzles/inertia.R
new file mode 100644
index 0000000000..e6e86beaec
--- /dev/null
+++ b/apps/plugins/puzzles/inertia.R
@@ -0,0 +1,19 @@
+# -*- makefile -*-
+
+inertia  : [X] GTK COMMON inertia inertia-icon|no-icon
+
+inertia  : [G] WINDOWS COMMON inertia inertia.res|noicon.res
+
+ALL += inertia[COMBINED]
+
+!begin am gtk
+GAMES += inertia
+!end
+
+!begin >list.c
+    A(inertia) \
+!end
+
+!begin >gamedesc.txt
+inertia:inertia.exe:Inertia:Gem-collecting puzzle:Collect all the gems without running into any of the mines.
+!end
diff --git a/apps/plugins/puzzles/inertia.c b/apps/plugins/puzzles/inertia.c
new file mode 100644
index 0000000000..a0e1c45fb1
--- /dev/null
+++ b/apps/plugins/puzzles/inertia.c
@@ -0,0 +1,2249 @@
+/*
+ * inertia.c: Game involving navigating round a grid picking up
+ * gems.
+ * 
+ * Game rules and basic generator design by Ben Olmstead.
+ * This re-implementation was written by Simon Tatham.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+/* Used in the game_state */
+#define BLANK   'b'
+#define GEM     'g'
+#define MINE    'm'
+#define STOP    's'
+#define WALL    'w'
+
+/* Used in the game IDs */
+#define START   'S'
+
+/* Used in the game generation */
+#define POSSGEM 'G'
+
+/* Used only in the game_drawstate*/
+#define UNDRAWN '?'
+
+#define DIRECTIONS 8
+#define DP1 (DIRECTIONS+1)
+#define DX(dir) ( (dir) & 3 ? (((dir) & 7) > 4 ? -1 : +1) : 0 )
+#define DY(dir) ( DX((dir)+6) )
+
+/*
+ * Lvalue macro which expects x and y to be in range.
+ */
+#define LV_AT(w, h, grid, x, y) ( (grid)[(y)*(w)+(x)] )
+
+/*
+ * Rvalue macro which can cope with x and y being out of range.
+ */
+#define AT(w, h, grid, x, y) ( (x)<0 || (x)>=(w) || (y)<0 || (y)>=(h) ? \
+                               WALL : LV_AT(w, h, grid, x, y) )
+
+enum {
+    COL_BACKGROUND,
+    COL_OUTLINE,
+    COL_HIGHLIGHT,
+    COL_LOWLIGHT,
+    COL_PLAYER,
+    COL_DEAD_PLAYER,
+    COL_MINE,
+    COL_GEM,
+    COL_WALL,
+    COL_HINT,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h;
+};
+
+typedef struct soln {
+    int refcount;
+    int len;
+    unsigned char *list;
+} soln;
+
+struct game_state {
+    game_params p;
+    int px, py;
+    int gems;
+    char *grid;
+    int distance_moved;
+    int dead;
+    int cheated;
+    int solnpos;
+    soln *soln;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = 10;
+#ifdef PORTRAIT_SCREEN
+    ret->h = 10;
+#else
+    ret->h = 8;
+#endif
+    return ret;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static const struct game_params inertia_presets[] = {
+#ifdef PORTRAIT_SCREEN
+    { 10, 10 },
+    { 12, 12 },
+    { 16, 16 },
+#else
+    { 10, 8 },
+    { 15, 12 },
+    { 20, 16 },
+#endif
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params p, *ret;
+    char *retname;
+    char namebuf[80];
+
+    if (i < 0 || i >= lenof(inertia_presets))
+        return FALSE;
+
+    p = inertia_presets[i];
+    ret = dup_params(&p);
+    sprintf(namebuf, "%dx%d", ret->w, ret->h);
+    retname = dupstr(namebuf);
+
+    *params = ret;
+    *name = retname;
+    return TRUE;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->w = params->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        params->h = atoi(string);
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    sprintf(data, "%dx%d", params->w, params->h);
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(3, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = NULL;
+    ret[2].type = C_END;
+    ret[2].sval = NULL;
+    ret[2].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    /*
+     * Avoid completely degenerate cases which only have one
+     * row/column. We probably could generate completable puzzles
+     * of that shape, but they'd be forced to be extremely boring
+     * and at large sizes would take a while to happen upon at
+     * random as well.
+     */
+    if (params->w < 2 || params->h < 2)
+        return "Width and height must both be at least two";
+
+    /*
+     * The grid construction algorithm creates 1/5 as many gems as
+     * grid squares, and must create at least one gem to have an
+     * actual puzzle. However, an area-five grid is ruled out by
+     * the above constraint, so the practical minimum is six.
+     */
+    if (params->w * params->h < 6)
+        return "Grid area must be at least six squares";
+
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver used by grid generator.
+ */
+
+struct solver_scratch {
+    unsigned char *reachable_from, *reachable_to;
+    int *positions;
+};
+
+static struct solver_scratch *new_scratch(int w, int h)
+{
+    struct solver_scratch *sc = snew(struct solver_scratch);
+
+    sc->reachable_from = snewn(w * h * DIRECTIONS, unsigned char);
+    sc->reachable_to = snewn(w * h * DIRECTIONS, unsigned char);
+    sc->positions = snewn(w * h * DIRECTIONS, int);
+
+    return sc;
+}
+
+static void free_scratch(struct solver_scratch *sc)
+{
+    sfree(sc->reachable_from);
+    sfree(sc->reachable_to);
+    sfree(sc->positions);
+    sfree(sc);
+}
+
+static int can_go(int w, int h, char *grid,
+                  int x1, int y1, int dir1, int x2, int y2, int dir2)
+{
+    /*
+     * Returns TRUE if we can transition directly from (x1,y1)
+     * going in direction dir1, to (x2,y2) going in direction dir2.
+     */
+
+    /*
+     * If we're actually in the middle of an unoccupyable square,
+     * we cannot make any move.
+     */
+    if (AT(w, h, grid, x1, y1) == WALL ||
+        AT(w, h, grid, x1, y1) == MINE)
+        return FALSE;
+
+    /*
+     * If a move is capable of stopping at x1,y1,dir1, and x2,y2 is
+     * the same coordinate as x1,y1, then we can make the
+     * transition (by stopping and changing direction).
+     * 
+     * For this to be the case, we have to either have a wall
+     * beyond x1,y1,dir1, or have a stop on x1,y1.
+     */
+    if (x2 == x1 && y2 == y1 &&
+        (AT(w, h, grid, x1, y1) == STOP ||
+         AT(w, h, grid, x1, y1) == START ||
+         AT(w, h, grid, x1+DX(dir1), y1+DY(dir1)) == WALL))
+        return TRUE;
+
+    /*
+     * If a move is capable of continuing here, then x1,y1,dir1 can
+     * move one space further on.
+     */
+    if (x2 == x1+DX(dir1) && y2 == y1+DY(dir1) && dir1 == dir2 &&
+        (AT(w, h, grid, x2, y2) == BLANK ||
+         AT(w, h, grid, x2, y2) == GEM ||
+         AT(w, h, grid, x2, y2) == STOP ||
+         AT(w, h, grid, x2, y2) == START))
+        return TRUE;
+
+    /*
+     * That's it.
+     */
+    return FALSE;
+}
+
+static int find_gem_candidates(int w, int h, char *grid,
+                               struct solver_scratch *sc)
+{
+    int wh = w*h;
+    int head, tail;
+    int sx, sy, gx, gy, gd, pass, possgems;
+
+    /*
+     * This function finds all the candidate gem squares, which are
+     * precisely those squares which can be picked up on a loop
+     * from the starting point back to the starting point. Doing
+     * this may involve passing through such a square in the middle
+     * of a move; so simple breadth-first search over the _squares_
+     * of the grid isn't quite adequate, because it might be that
+     * we can only reach a gem from the start by moving over it in
+     * one direction, but can only return to the start if we were
+     * moving over it in another direction.
+     * 
+     * Instead, we BFS over a space which mentions each grid square
+     * eight times - once for each direction. We also BFS twice:
+     * once to find out what square+direction pairs we can reach
+     * _from_ the start point, and once to find out what pairs we
+     * can reach the start point from. Then a square is reachable
+     * if any of the eight directions for that square has both
+     * flags set.
+     */
+
+    memset(sc->reachable_from, 0, wh * DIRECTIONS);
+    memset(sc->reachable_to, 0, wh * DIRECTIONS);
+
+    /*
+     * Find the starting square.
+     */
+    sx = -1;                           /* placate optimiser */
+    for (sy = 0; sy < h; sy++) {
+        for (sx = 0; sx < w; sx++)
+            if (AT(w, h, grid, sx, sy) == START)
+                break;
+        if (sx < w)
+            break;
+    }
+    assert(sy < h);
+
+    for (pass = 0; pass < 2; pass++) {
+        unsigned char *reachable = (pass == 0 ? sc->reachable_from :
+                                    sc->reachable_to);
+        int sign = (pass == 0 ? +1 : -1);
+        int dir;
+
+#ifdef SOLVER_DIAGNOSTICS
+        printf("starting pass %d\n", pass);
+#endif
+
+        /*
+         * `head' and `tail' are indices within sc->positions which
+         * track the list of board positions left to process.
+         */
+        head = tail = 0;
+        for (dir = 0; dir < DIRECTIONS; dir++) {
+            int index = (sy*w+sx)*DIRECTIONS+dir;
+            sc->positions[tail++] = index;
+            reachable[index] = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+            printf("starting point %d,%d,%d\n", sx, sy, dir);
+#endif
+        }
+
+        /*
+         * Now repeatedly pick an element off the list and process
+         * it.
+         */
+        while (head < tail) {
+            int index = sc->positions[head++];
+            int dir = index % DIRECTIONS;
+            int x = (index / DIRECTIONS) % w;
+            int y = index / (w * DIRECTIONS);
+            int n, x2, y2, d2, i2;
+
+#ifdef SOLVER_DIAGNOSTICS
+            printf("processing point %d,%d,%d\n", x, y, dir);
+#endif
+            /*
+             * The places we attempt to switch to here are:
+             *  - each possible direction change (all the other
+             *    directions in this square)
+             *  - one step further in the direction we're going (or
+             *    one step back, if we're in the reachable_to pass).
+             */
+            for (n = -1; n < DIRECTIONS; n++) {
+                if (n < 0) {
+                    x2 = x + sign * DX(dir);
+                    y2 = y + sign * DY(dir);
+                    d2 = dir;
+                } else {
+                    x2 = x;
+                    y2 = y;
+                    d2 = n;
+                }
+                i2 = (y2*w+x2)*DIRECTIONS+d2;
+                if (x2 >= 0 && x2 < w &&
+                    y2 >= 0 && y2 < h &&
+                    !reachable[i2]) {
+                    int ok;
+#ifdef SOLVER_DIAGNOSTICS
+                    printf("  trying point %d,%d,%d", x2, y2, d2);
+#endif
+                    if (pass == 0)
+                        ok = can_go(w, h, grid, x, y, dir, x2, y2, d2);
+                    else
+                        ok = can_go(w, h, grid, x2, y2, d2, x, y, dir);
+#ifdef SOLVER_DIAGNOSTICS
+                    printf(" - %sok\n", ok ? "" : "not ");
+#endif
+                    if (ok) {
+                        sc->positions[tail++] = i2;
+                        reachable[i2] = TRUE;
+                    }
+                }
+            }
+        }
+    }
+
+    /*
+     * And that should be it. Now all we have to do is find the
+     * squares for which there exists _some_ direction such that
+     * the square plus that direction form a tuple which is both
+     * reachable from the start and reachable to the start.
+     */
+    possgems = 0;
+    for (gy = 0; gy < h; gy++)
+        for (gx = 0; gx < w; gx++)
+            if (AT(w, h, grid, gx, gy) == BLANK) {
+                for (gd = 0; gd < DIRECTIONS; gd++) {
+                    int index = (gy*w+gx)*DIRECTIONS+gd;
+                    if (sc->reachable_from[index] && sc->reachable_to[index]) {
+#ifdef SOLVER_DIAGNOSTICS
+                        printf("space at %d,%d is reachable via"
+                               " direction %d\n", gx, gy, gd);
+#endif
+                        LV_AT(w, h, grid, gx, gy) = POSSGEM;
+                        possgems++;
+                        break;
+                    }
+                }
+            }
+
+    return possgems;
+}
+
+/* ----------------------------------------------------------------------
+ * Grid generation code.
+ */
+
+static char *gengrid(int w, int h, random_state *rs)
+{
+    int wh = w*h;
+    char *grid = snewn(wh+1, char);
+    struct solver_scratch *sc = new_scratch(w, h);
+    int maxdist_threshold, tries;
+
+    maxdist_threshold = 2;
+    tries = 0;
+
+    while (1) {
+        int i, j;
+        int possgems;
+        int *dist, *list, head, tail, maxdist;
+
+        /*
+         * We're going to fill the grid with the five basic piece
+         * types in about 1/5 proportion. For the moment, though,
+         * we leave out the gems, because we'll put those in
+         * _after_ we run the solver to tell us where the viable
+         * locations are.
+         */
+        i = 0;
+        for (j = 0; j < wh/5; j++)
+            grid[i++] = WALL;
+        for (j = 0; j < wh/5; j++)
+            grid[i++] = STOP;
+        for (j = 0; j < wh/5; j++)
+            grid[i++] = MINE;
+        assert(i < wh);
+        grid[i++] = START;
+        while (i < wh)
+            grid[i++] = BLANK;
+        shuffle(grid, wh, sizeof(*grid), rs);
+
+        /*
+         * Find the viable gem locations, and immediately give up
+         * and try again if there aren't enough of them.
+         */
+        possgems = find_gem_candidates(w, h, grid, sc);
+        if (possgems < wh/5)
+            continue;
+
+        /*
+         * We _could_ now select wh/5 of the POSSGEMs and set them
+         * to GEM, and have a viable level. However, there's a
+         * chance that a large chunk of the level will turn out to
+         * be unreachable, so first we test for that.
+         * 
+         * We do this by finding the largest distance from any
+         * square to the nearest POSSGEM, by breadth-first search.
+         * If this is above a critical threshold, we abort and try
+         * again.
+         * 
+         * (This search is purely geometric, without regard to
+         * walls and long ways round.)
+         */
+        dist = sc->positions;
+        list = sc->positions + wh;
+        for (i = 0; i < wh; i++)
+            dist[i] = -1;
+        head = tail = 0;
+        for (i = 0; i < wh; i++)
+            if (grid[i] == POSSGEM) {
+                dist[i] = 0;
+                list[tail++] = i;
+            }
+        maxdist = 0;
+        while (head < tail) {
+            int pos, x, y, d;
+
+            pos = list[head++];
+            if (maxdist < dist[pos])
+                maxdist = dist[pos];
+
+            x = pos % w;
+            y = pos / w;
+
+            for (d = 0; d < DIRECTIONS; d++) {
+                int x2, y2, p2;
+
+                x2 = x + DX(d);
+                y2 = y + DY(d);
+
+                if (x2 >= 0 && x2 < w && y2 >= 0 && y2 < h) {
+                    p2 = y2*w+x2;
+                    if (dist[p2] < 0) {
+                        dist[p2] = dist[pos] + 1;
+                        list[tail++] = p2;
+                    }
+                }
+            }
+        }
+        assert(head == wh && tail == wh);
+
+        /*
+         * Now abandon this grid and go round again if maxdist is
+         * above the required threshold.
+         * 
+         * We can safely start the threshold as low as 2. As we
+         * accumulate failed generation attempts, we gradually
+         * raise it as we get more desperate.
+         */
+        if (maxdist > maxdist_threshold) {
+            tries++;
+            if (tries == 50) {
+                maxdist_threshold++;
+                tries = 0;
+            }
+            continue;
+        }
+
+        /*
+         * Now our reachable squares are plausibly evenly
+         * distributed over the grid. I'm not actually going to
+         * _enforce_ that I place the gems in such a way as not to
+         * increase that maxdist value; I'm now just going to trust
+         * to the RNG to pick a sensible subset of the POSSGEMs.
+         */
+        j = 0;
+        for (i = 0; i < wh; i++)
+            if (grid[i] == POSSGEM)
+                list[j++] = i;
+        shuffle(list, j, sizeof(*list), rs);
+        for (i = 0; i < j; i++)
+            grid[list[i]] = (i < wh/5 ? GEM : BLANK);
+        break;
+    }
+
+    free_scratch(sc);
+
+    grid[wh] = '\0';
+
+    return grid;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    return gengrid(params->w, params->h, rs);
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    int starts = 0, gems = 0, i;
+
+    for (i = 0; i < wh; i++) {
+        if (!desc[i])
+            return "Not enough data to fill grid";
+        if (desc[i] != WALL && desc[i] != START && desc[i] != STOP &&
+            desc[i] != GEM && desc[i] != MINE && desc[i] != BLANK)
+            return "Unrecognised character in game description";
+        if (desc[i] == START)
+            starts++;
+        if (desc[i] == GEM)
+            gems++;
+    }
+    if (desc[i])
+        return "Too much data to fill grid";
+    if (starts < 1)
+        return "No starting square specified";
+    if (starts > 1)
+        return "More than one starting square specified";
+    if (gems < 1)
+        return "No gems specified";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    int i;
+    game_state *state = snew(game_state);
+
+    state->p = *params;                /* structure copy */
+
+    state->grid = snewn(wh, char);
+    assert(strlen(desc) == wh);
+    memcpy(state->grid, desc, wh);
+
+    state->px = state->py = -1;
+    state->gems = 0;
+    for (i = 0; i < wh; i++) {
+        if (state->grid[i] == START) {
+            state->grid[i] = STOP;
+            state->px = i % w;
+            state->py = i / w;
+        } else if (state->grid[i] == GEM) {
+            state->gems++;
+        }
+    }
+
+    assert(state->gems > 0);
+    assert(state->px >= 0 && state->py >= 0);
+
+    state->distance_moved = 0;
+    state->dead = FALSE;
+
+    state->cheated = FALSE;
+    state->solnpos = 0;
+    state->soln = NULL;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w = state->p.w, h = state->p.h, wh = w*h;
+    game_state *ret = snew(game_state);
+
+    ret->p = state->p;
+    ret->px = state->px;
+    ret->py = state->py;
+    ret->gems = state->gems;
+    ret->grid = snewn(wh, char);
+    ret->distance_moved = state->distance_moved;
+    ret->dead = FALSE;
+    memcpy(ret->grid, state->grid, wh);
+    ret->cheated = state->cheated;
+    ret->soln = state->soln;
+    if (ret->soln)
+        ret->soln->refcount++;
+    ret->solnpos = state->solnpos;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (state->soln && --state->soln->refcount == 0) {
+        sfree(state->soln->list);
+        sfree(state->soln);
+    }
+    sfree(state->grid);
+    sfree(state);
+}
+
+/*
+ * Internal function used by solver.
+ */
+static int move_goes_to(int w, int h, char *grid, int x, int y, int d)
+{
+    int dr;
+
+    /*
+     * See where we'd get to if we made this move.
+     */
+    dr = -1;                           /* placate optimiser */
+    while (1) {
+        if (AT(w, h, grid, x+DX(d), y+DY(d)) == WALL) {
+            dr = DIRECTIONS;           /* hit a wall, so end up stationary */
+            break;
+        }
+        x += DX(d);
+        y += DY(d);
+        if (AT(w, h, grid, x, y) == STOP) {
+            dr = DIRECTIONS;           /* hit a stop, so end up stationary */
+            break;
+        }
+        if (AT(w, h, grid, x, y) == GEM) {
+            dr = d;                    /* hit a gem, so we're still moving */
+            break;
+        }
+        if (AT(w, h, grid, x, y) == MINE)
+            return -1;                 /* hit a mine, so move is invalid */
+    }
+    assert(dr >= 0);
+    return (y*w+x)*DP1+dr;
+}
+
+static int compare_integers(const void *av, const void *bv)
+{
+    const int *a = (const int *)av;
+    const int *b = (const int *)bv;
+    if (*a < *b)
+        return -1;
+    else if (*a > *b)
+        return +1;
+    else
+        return 0;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int w = currstate->p.w, h = currstate->p.h, wh = w*h;
+    int *nodes, *nodeindex, *edges, *backedges, *edgei, *backedgei, *circuit;
+    int nedges;
+    int *dist, *dist2, *list;
+    int *unvisited;
+    int circuitlen, circuitsize;
+    int head, tail, pass, i, j, n, x, y, d, dd;
+    char *err, *soln, *p;
+
+    /*
+     * Before anything else, deal with the special case in which
+     * all the gems are already collected.
+     */
+    for (i = 0; i < wh; i++)
+        if (currstate->grid[i] == GEM)
+            break;
+    if (i == wh) {
+        *error = "Game is already solved";
+        return NULL;
+    }
+
+    /*
+     * Solving Inertia is a question of first building up the graph
+     * of where you can get to from where, and secondly finding a
+     * tour of the graph which takes in every gem.
+     * 
+     * This is of course a close cousin of the travelling salesman
+     * problem, which is NP-complete; so I rather doubt that any
+     * _optimal_ tour can be found in plausible time. Hence I'll
+     * restrict myself to merely finding a not-too-bad one.
+     * 
+     * First construct the graph, by bfsing out move by move from
+     * the current player position. Graph vertices will be
+     *  - every endpoint of a move (place the ball can be
+     *    stationary)
+     *  - every gem (place the ball can go through in motion).
+     *    Vertices of this type have an associated direction, since
+     *    if a gem can be collected by sliding through it in two
+     *    different directions it doesn't follow that you can
+     *    change direction at it.
+     * 
+     * I'm going to refer to a non-directional vertex as
+     * (y*w+x)*DP1+DIRECTIONS, and a directional one as
+     * (y*w+x)*DP1+d.
+     */
+
+    /*
+     * nodeindex[] maps node codes as shown above to numeric
+     * indices in the nodes[] array.
+     */
+    nodeindex = snewn(DP1*wh, int);
+    for (i = 0; i < DP1*wh; i++)
+        nodeindex[i] = -1;
+
+    /*
+     * Do the bfs to find all the interesting graph nodes.
+     */
+    nodes = snewn(DP1*wh, int);
+    head = tail = 0;
+
+    nodes[tail] = (currstate->py * w + currstate->px) * DP1 + DIRECTIONS;
+    nodeindex[nodes[0]] = tail;
+    tail++;
+
+    while (head < tail) {
+        int nc = nodes[head++], nnc;
+
+        d = nc % DP1;
+
+        /*
+         * Plot all possible moves from this node. If the node is
+         * directed, there's only one.
+         */
+        for (dd = 0; dd < DIRECTIONS; dd++) {
+            x = nc / DP1;
+            y = x / w;
+            x %= w;
+
+            if (d < DIRECTIONS && d != dd)
+                continue;
+
+            nnc = move_goes_to(w, h, currstate->grid, x, y, dd);
+            if (nnc >= 0 && nnc != nc) {
+                if (nodeindex[nnc] < 0) {
+                    nodes[tail] = nnc;
+                    nodeindex[nnc] = tail;
+                    tail++;
+                }
+            }
+        }
+    }
+    n = head;
+
+    /*
+     * Now we know how many nodes we have, allocate the edge array
+     * and go through setting up the edges.
+     */
+    edges = snewn(DIRECTIONS*n, int);
+    edgei = snewn(n+1, int);
+    nedges = 0;
+
+    for (i = 0; i < n; i++) {
+        int nc = nodes[i];
+
+        edgei[i] = nedges;
+
+        d = nc % DP1;
+        x = nc / DP1;
+        y = x / w;
+        x %= w;
+
+        for (dd = 0; dd < DIRECTIONS; dd++) {
+            int nnc;
+
+            if (d >= DIRECTIONS || d == dd) {
+                nnc = move_goes_to(w, h, currstate->grid, x, y, dd);
+
+                if (nnc >= 0 && nnc != nc)
+                    edges[nedges++] = nodeindex[nnc];
+            }
+        }
+    }
+    edgei[n] = nedges;
+
+    /*
+     * Now set up the backedges array.
+     */
+    backedges = snewn(nedges, int);
+    backedgei = snewn(n+1, int);
+    for (i = j = 0; i < nedges; i++) {
+        while (j+1 < n && i >= edgei[j+1])
+            j++;
+        backedges[i] = edges[i] * n + j;
+    }
+    qsort(backedges, nedges, sizeof(int), compare_integers);
+    backedgei[0] = 0;
+    for (i = j = 0; i < nedges; i++) {
+        int k = backedges[i] / n;
+        backedges[i] %= n;
+        while (j < k)
+            backedgei[++j] = i;
+    }
+    backedgei[n] = nedges;
+
+    /*
+     * Set up the initial tour. At all times, our tour is a circuit
+     * of graph vertices (which may, and probably will often,
+     * repeat vertices). To begin with, it's got exactly one vertex
+     * in it, which is the player's current starting point.
+     */
+    circuitsize = 256;
+    circuit = snewn(circuitsize, int);
+    circuitlen = 0;
+    circuit[circuitlen++] = 0;         /* node index 0 is the starting posn */
+
+    /*
+     * Track which gems are as yet unvisited.
+     */
+    unvisited = snewn(wh, int);
+    for (i = 0; i < wh; i++)
+        unvisited[i] = FALSE;
+    for (i = 0; i < wh; i++)
+        if (currstate->grid[i] == GEM)
+            unvisited[i] = TRUE;
+
+    /*
+     * Allocate space for doing bfses inside the main loop.
+     */
+    dist = snewn(n, int);
+    dist2 = snewn(n, int);
+    list = snewn(n, int);
+
+    err = NULL;
+    soln = NULL;
+
+    /*
+     * Now enter the main loop, in each iteration of which we
+     * extend the tour to take in an as yet uncollected gem.
+     */
+    while (1) {
+        int target, n1, n2, bestdist, extralen, targetpos;
+
+#ifdef TSP_DIAGNOSTICS
+        printf("circuit is");
+        for (i = 0; i < circuitlen; i++) {
+            int nc = nodes[circuit[i]];
+            printf(" (%d,%d,%d)", nc/DP1%w, nc/(DP1*w), nc%DP1);
+        }
+        printf("\n");
+        printf("moves are ");
+        x = nodes[circuit[0]] / DP1 % w;
+        y = nodes[circuit[0]] / DP1 / w;
+        for (i = 1; i < circuitlen; i++) {
+            int x2, y2, dx, dy;
+            if (nodes[circuit[i]] % DP1 != DIRECTIONS)
+                continue;
+            x2 = nodes[circuit[i]] / DP1 % w;
+            y2 = nodes[circuit[i]] / DP1 / w;
+            dx = (x2 > x ? +1 : x2 < x ? -1 : 0);
+            dy = (y2 > y ? +1 : y2 < y ? -1 : 0);
+            for (d = 0; d < DIRECTIONS; d++)
+                if (DX(d) == dx && DY(d) == dy)
+                    printf("%c", "89632147"[d]);
+            x = x2;
+            y = y2;
+        }
+        printf("\n");
+#endif
+
+        /*
+         * First, start a pair of bfses at _every_ vertex currently
+         * in the tour, and extend them outwards to find the
+         * nearest as yet unreached gem vertex.
+         * 
+         * This is largely a heuristic: we could pick _any_ doubly
+         * reachable node here and still get a valid tour as
+         * output. I hope that picking a nearby one will result in
+         * generally good tours.
+         */
+        for (pass = 0; pass < 2; pass++) {
+            int *ep = (pass == 0 ? edges : backedges);
+            int *ei = (pass == 0 ? edgei : backedgei);
+            int *dp = (pass == 0 ? dist : dist2);
+            head = tail = 0;
+            for (i = 0; i < n; i++)
+                dp[i] = -1;
+            for (i = 0; i < circuitlen; i++) {
+                int ni = circuit[i];
+                if (dp[ni] < 0) {
+                    dp[ni] = 0;
+                    list[tail++] = ni;
+                }
+            }
+            while (head < tail) {
+                int ni = list[head++];
+                for (i = ei[ni]; i < ei[ni+1]; i++) {
+                    int ti = ep[i];
+                    if (ti >= 0 && dp[ti] < 0) {
+                        dp[ti] = dp[ni] + 1;
+                        list[tail++] = ti;
+                    }
+                }
+            }
+        }
+        /* Now find the nearest unvisited gem. */
+        bestdist = -1;
+        target = -1;
+        for (i = 0; i < n; i++) {
+            if (unvisited[nodes[i] / DP1] &&
+                dist[i] >= 0 && dist2[i] >= 0) {
+                int thisdist = dist[i] + dist2[i];
+                if (bestdist < 0 || bestdist > thisdist) {
+                    bestdist = thisdist;
+                    target = i;
+                }
+            }
+        }
+
+        if (target < 0) {
+            /*
+             * If we get to here, we haven't found a gem we can get
+             * at all, which means we terminate this loop.
+             */
+            break;
+        }
+
+        /*
+         * Now we have a graph vertex at list[tail-1] which is an
+         * unvisited gem. We want to add that vertex to our tour.
+         * So we run two more breadth-first searches: one starting
+         * from that vertex and following forward edges, and
+         * another starting from the same vertex and following
+         * backward edges. This allows us to determine, for each
+         * node on the current tour, how quickly we can get both to
+         * and from the target vertex from that node.
+         */
+#ifdef TSP_DIAGNOSTICS
+        printf("target node is %d (%d,%d,%d)\n", target, nodes[target]/DP1%w,
+               nodes[target]/DP1/w, nodes[target]%DP1);
+#endif
+
+        for (pass = 0; pass < 2; pass++) {
+            int *ep = (pass == 0 ? edges : backedges);
+            int *ei = (pass == 0 ? edgei : backedgei);
+            int *dp = (pass == 0 ? dist : dist2);
+
+            for (i = 0; i < n; i++)
+                dp[i] = -1;
+            head = tail = 0;
+
+            dp[target] = 0;
+            list[tail++] = target;
+
+            while (head < tail) {
+                int ni = list[head++];
+                for (i = ei[ni]; i < ei[ni+1]; i++) {
+                    int ti = ep[i];
+                    if (ti >= 0 && dp[ti] < 0) {
+                        dp[ti] = dp[ni] + 1;
+/*printf("pass %d: set dist of vertex %d to %d (via %d)\n", pass, ti, dp[ti], ni);*/
+                        list[tail++] = ti;
+                    }
+                }
+            }
+        }
+
+        /*
+         * Now for every node n, dist[n] gives the length of the
+         * shortest path from the target vertex to n, and dist2[n]
+         * gives the length of the shortest path from n to the
+         * target vertex.
+         * 
+         * Our next step is to search linearly along the tour to
+         * find the optimum place to insert a trip to the target
+         * vertex and back. Our two options are either
+         *  (a) to find two adjacent vertices A,B in the tour and
+         *      replace the edge A->B with the path A->target->B
+         *  (b) to find a single vertex X in the tour and replace
+         *      it with the complete round trip X->target->X.
+         * We do whichever takes the fewest moves.
+         */
+        n1 = n2 = -1;
+        bestdist = -1;
+        for (i = 0; i < circuitlen; i++) {
+            int thisdist;
+
+            /*
+             * Try a round trip from vertex i.
+             */
+            if (dist[circuit[i]] >= 0 &&
+                dist2[circuit[i]] >= 0) {
+                thisdist = dist[circuit[i]] + dist2[circuit[i]];
+                if (bestdist < 0 || thisdist < bestdist) {
+                    bestdist = thisdist;
+                    n1 = n2 = i;
+                }
+            }
+
+            /*
+             * Try a trip from vertex i via target to vertex i+1.
+             */
+            if (i+1 < circuitlen &&
+                dist2[circuit[i]] >= 0 &&
+                dist[circuit[i+1]] >= 0) {
+                thisdist = dist2[circuit[i]] + dist[circuit[i+1]];
+                if (bestdist < 0 || thisdist < bestdist) {
+                    bestdist = thisdist;
+                    n1 = i;
+                    n2 = i+1;
+                }
+            }
+        }
+        if (bestdist < 0) {
+            /*
+             * We couldn't find a round trip taking in this gem _at
+             * all_. Give up.
+             */
+            err = "Unable to find a solution from this starting point";
+            break;
+        }
+#ifdef TSP_DIAGNOSTICS
+        printf("insertion point: n1=%d, n2=%d, dist=%d\n", n1, n2, bestdist);
+#endif
+
+#ifdef TSP_DIAGNOSTICS
+        printf("circuit before lengthening is");
+        for (i = 0; i < circuitlen; i++) {
+            printf(" %d", circuit[i]);
+        }
+        printf("\n");
+#endif
+
+        /*
+         * Now actually lengthen the tour to take in this round
+         * trip.
+         */
+        extralen = dist2[circuit[n1]] + dist[circuit[n2]];
+        if (n1 != n2)
+            extralen--;
+        circuitlen += extralen;
+        if (circuitlen >= circuitsize) {
+            circuitsize = circuitlen + 256;
+            circuit = sresize(circuit, circuitsize, int);
+        }
+        memmove(circuit + n2 + extralen, circuit + n2,
+                (circuitlen - n2 - extralen) * sizeof(int));
+        n2 += extralen;
+
+#ifdef TSP_DIAGNOSTICS
+        printf("circuit in middle of lengthening is");
+        for (i = 0; i < circuitlen; i++) {
+            printf(" %d", circuit[i]);
+        }
+        printf("\n");
+#endif
+
+        /*
+         * Find the shortest-path routes to and from the target,
+         * and write them into the circuit.
+         */
+        targetpos = n1 + dist2[circuit[n1]];
+        assert(targetpos - dist2[circuit[n1]] == n1);
+        assert(targetpos + dist[circuit[n2]] == n2);
+        for (pass = 0; pass < 2; pass++) {
+            int dir = (pass == 0 ? -1 : +1);
+            int *ep = (pass == 0 ? backedges : edges);
+            int *ei = (pass == 0 ? backedgei : edgei);
+            int *dp = (pass == 0 ? dist : dist2);
+            int nn = (pass == 0 ? n2 : n1);
+            int ni = circuit[nn], ti, dest = nn;
+
+            while (1) {
+                circuit[dest] = ni;
+                if (dp[ni] == 0)
+                    break;
+                dest += dir;
+                ti = -1;
+/*printf("pass %d: looking at vertex %d\n", pass, ni);*/
+                for (i = ei[ni]; i < ei[ni+1]; i++) {
+                    ti = ep[i];
+                    if (ti >= 0 && dp[ti] == dp[ni] - 1)
+                        break;
+                }
+                assert(i < ei[ni+1] && ti >= 0);
+                ni = ti;
+            }
+        }
+
+#ifdef TSP_DIAGNOSTICS
+        printf("circuit after lengthening is");
+        for (i = 0; i < circuitlen; i++) {
+            printf(" %d", circuit[i]);
+        }
+        printf("\n");
+#endif
+
+        /*
+         * Finally, mark all gems that the new piece of circuit
+         * passes through as visited.
+         */
+        for (i = n1; i <= n2; i++) {
+            int pos = nodes[circuit[i]] / DP1;
+            assert(pos >= 0 && pos < wh);
+            unvisited[pos] = FALSE;
+        }
+    }
+
+#ifdef TSP_DIAGNOSTICS
+    printf("before reduction, moves are ");
+    x = nodes[circuit[0]] / DP1 % w;
+    y = nodes[circuit[0]] / DP1 / w;
+    for (i = 1; i < circuitlen; i++) {
+        int x2, y2, dx, dy;
+        if (nodes[circuit[i]] % DP1 != DIRECTIONS)
+            continue;
+        x2 = nodes[circuit[i]] / DP1 % w;
+        y2 = nodes[circuit[i]] / DP1 / w;
+        dx = (x2 > x ? +1 : x2 < x ? -1 : 0);
+        dy = (y2 > y ? +1 : y2 < y ? -1 : 0);
+        for (d = 0; d < DIRECTIONS; d++)
+            if (DX(d) == dx && DY(d) == dy)
+                printf("%c", "89632147"[d]);
+        x = x2;
+        y = y2;
+    }
+    printf("\n");
+#endif
+
+    /*
+     * That's got a basic solution. Now optimise it by removing
+     * redundant sections of the circuit: it's entirely possible
+     * that a piece of circuit we carefully inserted at one stage
+     * to collect a gem has become pointless because the steps
+     * required to collect some _later_ gem necessarily passed
+     * through the same one.
+     * 
+     * So first we go through and work out how many times each gem
+     * is collected. Then we look for maximal sections of circuit
+     * which are redundant in the sense that their removal would
+     * not reduce any gem's collection count to zero, and replace
+     * each one with a bfs-derived fastest path between their
+     * endpoints.
+     */
+    while (1) {
+        int oldlen = circuitlen;
+        int dir;
+
+        for (dir = +1; dir >= -1; dir -= 2) {
+
+            for (i = 0; i < wh; i++)
+                unvisited[i] = 0;
+            for (i = 0; i < circuitlen; i++) {
+                int xy = nodes[circuit[i]] / DP1;
+                if (currstate->grid[xy] == GEM)
+                    unvisited[xy]++;
+            }
+
+            /*
+             * If there's any gem we didn't end up visiting at all,
+             * give up.
+             */
+            for (i = 0; i < wh; i++) {
+                if (currstate->grid[i] == GEM && unvisited[i] == 0) {
+                    err = "Unable to find a solution from this starting point";
+                    break;
+                }
+            }
+            if (i < wh)
+                break;
+
+            for (i = j = (dir > 0 ? 0 : circuitlen-1);
+                 i < circuitlen && i >= 0;
+                 i += dir) {
+                int xy = nodes[circuit[i]] / DP1;
+                if (currstate->grid[xy] == GEM && unvisited[xy] > 1) {
+                    unvisited[xy]--;
+                } else if (currstate->grid[xy] == GEM || i == circuitlen-1) {
+                    /*
+                     * circuit[i] collects a gem for the only time,
+                     * or is the last node in the circuit.
+                     * Therefore it cannot be removed; so we now
+                     * want to replace the path from circuit[j] to
+                     * circuit[i] with a bfs-shortest path.
+                     */
+                    int p, q, k, dest, ni, ti, thisdist;
+
+                    /*
+                     * Set up the upper and lower bounds of the
+                     * reduced section.
+                     */
+                    p = min(i, j);
+                    q = max(i, j);
+
+#ifdef TSP_DIAGNOSTICS
+                    printf("optimising section from %d - %d\n", p, q);
+#endif
+
+                    for (k = 0; k < n; k++)
+                        dist[k] = -1;
+                    head = tail = 0;
+
+                    dist[circuit[p]] = 0;
+                    list[tail++] = circuit[p];
+
+                    while (head < tail && dist[circuit[q]] < 0) {
+                        int ni = list[head++];
+                        for (k = edgei[ni]; k < edgei[ni+1]; k++) {
+                            int ti = edges[k];
+                            if (ti >= 0 && dist[ti] < 0) {
+                                dist[ti] = dist[ni] + 1;
+                                list[tail++] = ti;
+                            }
+                        }
+                    }
+
+                    thisdist = dist[circuit[q]];
+                    assert(thisdist >= 0 && thisdist <= q-p);
+
+                    memmove(circuit+p+thisdist, circuit+q,
+                            (circuitlen - q) * sizeof(int));
+                    circuitlen -= q-p;
+                    q = p + thisdist;
+                    circuitlen += q-p;
+
+                    if (dir > 0)
+                        i = q;         /* resume loop from the right place */
+
+#ifdef TSP_DIAGNOSTICS
+                    printf("new section runs from %d - %d\n", p, q);
+#endif
+
+                    dest = q;
+                    assert(dest >= 0);
+                    ni = circuit[q];
+
+                    while (1) {
+                        /* printf("dest=%d circuitlen=%d ni=%d dist[ni]=%d\n", dest, circuitlen, ni, dist[ni]); */
+                        circuit[dest] = ni;
+                        if (dist[ni] == 0)
+                            break;
+                        dest--;
+                        ti = -1;
+                        for (k = backedgei[ni]; k < backedgei[ni+1]; k++) {
+                            ti = backedges[k];
+                            if (ti >= 0 && dist[ti] == dist[ni] - 1)
+                                break;
+                        }
+                        assert(k < backedgei[ni+1] && ti >= 0);
+                        ni = ti;
+                    }
+
+                    /*
+                     * Now re-increment the visit counts for the
+                     * new path.
+                     */
+                    while (++p < q) {
+                        int xy = nodes[circuit[p]] / DP1;
+                        if (currstate->grid[xy] == GEM)
+                            unvisited[xy]++;
+                    }
+
+                    j = i;
+
+#ifdef TSP_DIAGNOSTICS
+                    printf("during reduction, circuit is");
+                    for (k = 0; k < circuitlen; k++) {
+                        int nc = nodes[circuit[k]];
+                        printf(" (%d,%d,%d)", nc/DP1%w, nc/(DP1*w), nc%DP1);
+                    }
+                    printf("\n");
+                    printf("moves are ");
+                    x = nodes[circuit[0]] / DP1 % w;
+                    y = nodes[circuit[0]] / DP1 / w;
+                    for (k = 1; k < circuitlen; k++) {
+                        int x2, y2, dx, dy;
+                        if (nodes[circuit[k]] % DP1 != DIRECTIONS)
+                            continue;
+                        x2 = nodes[circuit[k]] / DP1 % w;
+                        y2 = nodes[circuit[k]] / DP1 / w;
+                        dx = (x2 > x ? +1 : x2 < x ? -1 : 0);
+                        dy = (y2 > y ? +1 : y2 < y ? -1 : 0);
+                        for (d = 0; d < DIRECTIONS; d++)
+                            if (DX(d) == dx && DY(d) == dy)
+                                printf("%c", "89632147"[d]);
+                        x = x2;
+                        y = y2;
+                    }
+                    printf("\n");
+#endif
+                }
+            }
+
+#ifdef TSP_DIAGNOSTICS
+            printf("after reduction, moves are ");
+            x = nodes[circuit[0]] / DP1 % w;
+            y = nodes[circuit[0]] / DP1 / w;
+            for (i = 1; i < circuitlen; i++) {
+                int x2, y2, dx, dy;
+                if (nodes[circuit[i]] % DP1 != DIRECTIONS)
+                    continue;
+                x2 = nodes[circuit[i]] / DP1 % w;
+                y2 = nodes[circuit[i]] / DP1 / w;
+                dx = (x2 > x ? +1 : x2 < x ? -1 : 0);
+                dy = (y2 > y ? +1 : y2 < y ? -1 : 0);
+                for (d = 0; d < DIRECTIONS; d++)
+                    if (DX(d) == dx && DY(d) == dy)
+                        printf("%c", "89632147"[d]);
+                x = x2;
+                y = y2;
+            }
+            printf("\n");
+#endif
+        }
+
+        /*
+         * If we've managed an entire reduction pass in each
+         * direction and not made the solution any shorter, we're
+         * _really_ done.
+         */
+        if (circuitlen == oldlen)
+            break;
+    }
+
+    /*
+     * Encode the solution as a move string.
+     */
+    if (!err) {
+        soln = snewn(circuitlen+2, char);
+        p = soln;
+        *p++ = 'S';
+        x = nodes[circuit[0]] / DP1 % w;
+        y = nodes[circuit[0]] / DP1 / w;
+        for (i = 1; i < circuitlen; i++) {
+            int x2, y2, dx, dy;
+            if (nodes[circuit[i]] % DP1 != DIRECTIONS)
+                continue;
+            x2 = nodes[circuit[i]] / DP1 % w;
+            y2 = nodes[circuit[i]] / DP1 / w;
+            dx = (x2 > x ? +1 : x2 < x ? -1 : 0);
+            dy = (y2 > y ? +1 : y2 < y ? -1 : 0);
+            for (d = 0; d < DIRECTIONS; d++)
+                if (DX(d) == dx && DY(d) == dy) {
+                    *p++ = '0' + d;
+                    break;
+                }
+            assert(d < DIRECTIONS);
+            x = x2;
+            y = y2;
+        }
+        *p++ = '\0';
+        assert(p - soln < circuitlen+2);
+    }
+
+    sfree(list);
+    sfree(dist);
+    sfree(dist2);
+    sfree(unvisited);
+    sfree(circuit);
+    sfree(backedgei);
+    sfree(backedges);
+    sfree(edgei);
+    sfree(edges);
+    sfree(nodeindex);
+    sfree(nodes);
+
+    if (err)
+        *error = err;
+
+    return soln;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->p.w, h = state->p.h, r, c;
+    int cw = 4, ch = 2, gw = cw*w + 2, gh = ch * h + 1, len = gw * gh;
+    char *board = snewn(len + 1, char);
+
+    sprintf(board, "%*s+\n", len - 2, "");
+
+    for (r = 0; r < h; ++r) {
+        for (c = 0; c < w; ++c) {
+            int cell = r*ch*gw + cw*c, center = cell + gw*ch/2 + cw/2;
+            int i = r*w + c;
+            switch (state->grid[i]) {
+            case BLANK: break;
+            case GEM: board[center] = 'o'; break;
+            case MINE: board[center] = 'M'; break;
+            case STOP: board[center-1] = '('; board[center+1] = ')'; break;
+            case WALL: memset(board + center - 1, 'X', 3);
+            }
+
+            if (r == state->py && c == state->px) {
+                if (!state->dead) board[center] = '@';
+                else memcpy(board + center - 1, ":-(", 3);
+            }
+            board[cell] = '+';
+            memset(board + cell + 1, '-', cw - 1);
+            for (i = 1; i < ch; ++i) board[cell + i*gw] = '|';
+        }
+        for (c = 0; c < ch; ++c) {
+            board[(r*ch+c)*gw + gw - 2] = "|+"[!c];
+            board[(r*ch+c)*gw + gw - 1] = '\n';
+        }
+    }
+    memset(board + len - gw, '-', gw - 2);
+    for (c = 0; c < w; ++c) board[len - gw + cw*c] = '+';
+
+    return board;
+}
+
+struct game_ui {
+    float anim_length;
+    int flashtype;
+    int deaths;
+    int just_made_move;
+    int just_died;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->anim_length = 0.0F;
+    ui->flashtype = 0;
+    ui->deaths = 0;
+    ui->just_made_move = FALSE;
+    ui->just_died = FALSE;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    char buf[80];
+    /*
+     * The deaths counter needs preserving across a serialisation.
+     */
+    sprintf(buf, "D%d", ui->deaths);
+    return dupstr(buf);
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+    int p = 0;
+    sscanf(encoding, "D%d%n", &ui->deaths, &p);
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    /*
+     * Increment the deaths counter. We only do this if
+     * ui->just_made_move is set (redoing a suicide move doesn't
+     * kill you _again_), and also we only do it if the game wasn't
+     * already completed (once you're finished, you can play).
+     */
+    if (!oldstate->dead && newstate->dead && ui->just_made_move &&
+        oldstate->gems) {
+        ui->deaths++;
+        ui->just_died = TRUE;
+    } else {
+        ui->just_died = FALSE;
+    }
+    ui->just_made_move = FALSE;
+}
+
+struct game_drawstate {
+    game_params p;
+    int tilesize;
+    int started;
+    unsigned short *grid;
+    blitter *player_background;
+    int player_bg_saved, pbgx, pbgy;
+};
+
+#define PREFERRED_TILESIZE 32
+#define TILESIZE (ds->tilesize)
+#ifdef SMALL_SCREEN
+#define BORDER    (TILESIZE / 4)
+#else
+#define BORDER    (TILESIZE)
+#endif
+#define HIGHLIGHT_WIDTH (TILESIZE / 10)
+#define COORD(x)  ( (x) * TILESIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILESIZE) / TILESIZE - 1 )
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->p.w, h = state->p.h /*, wh = w*h */;
+    int dir;
+    char buf[80];
+
+    dir = -1;
+
+    if (button == LEFT_BUTTON) {
+        /*
+         * Mouse-clicking near the target point (or, more
+         * accurately, in the appropriate octant) is an alternative
+         * way to input moves.
+         */
+
+        if (FROMCOORD(x) != state->px || FROMCOORD(y) != state->py) {
+            int dx, dy;
+            float angle;
+
+            dx = FROMCOORD(x) - state->px;
+            dy = FROMCOORD(y) - state->py;
+            /* I pass dx,dy rather than dy,dx so that the octants
+             * end up the right way round. */
+            angle = atan2(dx, -dy);
+
+            angle = (angle + (PI/8)) / (PI/4);
+            assert(angle > -16.0F);
+            dir = (int)(angle + 16.0F) & 7;
+        }
+    } else if (button == CURSOR_UP || button == (MOD_NUM_KEYPAD | '8'))
+        dir = 0;
+    else if (button == CURSOR_DOWN || button == (MOD_NUM_KEYPAD | '2'))
+        dir = 4;
+    else if (button == CURSOR_LEFT || button == (MOD_NUM_KEYPAD | '4'))
+        dir = 6;
+    else if (button == CURSOR_RIGHT || button == (MOD_NUM_KEYPAD | '6'))
+        dir = 2;
+    else if (button == (MOD_NUM_KEYPAD | '7'))
+        dir = 7;
+    else if (button == (MOD_NUM_KEYPAD | '1'))
+        dir = 5;
+    else if (button == (MOD_NUM_KEYPAD | '9'))
+        dir = 1;
+    else if (button == (MOD_NUM_KEYPAD | '3'))
+        dir = 3;
+    else if (IS_CURSOR_SELECT(button) &&
+             state->soln && state->solnpos < state->soln->len)
+        dir = state->soln->list[state->solnpos];
+
+    if (dir < 0)
+        return NULL;
+
+    /*
+     * Reject the move if we can't make it at all due to a wall
+     * being in the way.
+     */
+    if (AT(w, h, state->grid, state->px+DX(dir), state->py+DY(dir)) == WALL)
+        return NULL;
+
+    /*
+     * Reject the move if we're dead!
+     */
+    if (state->dead)
+        return NULL;
+
+    /*
+     * Otherwise, we can make the move. All we need to specify is
+     * the direction.
+     */
+    ui->just_made_move = TRUE;
+    sprintf(buf, "%d", dir);
+    return dupstr(buf);
+}
+
+static void install_new_solution(game_state *ret, const char *move)
+{
+    int i;
+    soln *sol;
+    assert (*move == 'S');
+    ++move;
+
+    sol = snew(soln);
+    sol->len = strlen(move);
+    sol->list = snewn(sol->len, unsigned char);
+    for (i = 0; i < sol->len; ++i) sol->list[i] = move[i] - '0';
+
+    if (ret->soln && --ret->soln->refcount == 0) {
+        sfree(ret->soln->list);
+        sfree(ret->soln);
+    }
+
+    ret->soln = sol;
+    sol->refcount = 1;
+
+    ret->cheated = TRUE;
+    ret->solnpos = 0;
+}
+
+static void discard_solution(game_state *ret)
+{
+    --ret->soln->refcount;
+    assert(ret->soln->refcount > 0); /* ret has a soln-pointing dup */
+    ret->soln = NULL;
+    ret->solnpos = 0;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int w = state->p.w, h = state->p.h /*, wh = w*h */;
+    int dir;
+    game_state *ret;
+
+    if (*move == 'S') {
+        /*
+         * This is a solve move, so we don't actually _change_ the
+         * grid but merely set up a stored solution path.
+         */
+        ret = dup_game(state);
+        install_new_solution(ret, move);
+        return ret;
+    }
+
+    dir = atoi(move);
+    if (dir < 0 || dir >= DIRECTIONS)
+        return NULL;                   /* huh? */
+
+    if (state->dead)
+        return NULL;
+
+    if (AT(w, h, state->grid, state->px+DX(dir), state->py+DY(dir)) == WALL)
+        return NULL;                   /* wall in the way! */
+
+    /*
+     * Now make the move.
+     */
+    ret = dup_game(state);
+    ret->distance_moved = 0;
+    while (1) {
+        ret->px += DX(dir);
+        ret->py += DY(dir);
+        ret->distance_moved++;
+
+        if (AT(w, h, ret->grid, ret->px, ret->py) == GEM) {
+            LV_AT(w, h, ret->grid, ret->px, ret->py) = BLANK;
+            ret->gems--;
+        }
+
+        if (AT(w, h, ret->grid, ret->px, ret->py) == MINE) {
+            ret->dead = TRUE;
+            break;
+        }
+
+        if (AT(w, h, ret->grid, ret->px, ret->py) == STOP ||
+            AT(w, h, ret->grid, ret->px+DX(dir),
+               ret->py+DY(dir)) == WALL)
+            break;
+    }
+
+    if (ret->soln) {
+        if (ret->dead || ret->gems == 0)
+            discard_solution(ret);
+        else if (ret->soln->list[ret->solnpos] == dir) {
+            ++ret->solnpos;
+            assert(ret->solnpos < ret->soln->len); /* or gems == 0 */
+            assert(!ret->dead); /* or not a solution */
+        } else {
+            char *error = NULL, *soln = solve_game(NULL, ret, NULL, &error);
+            if (!error) {
+                install_new_solution(ret, soln);
+                sfree(soln);
+            } else discard_solution(ret);
+        }
+    }
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = 2 * BORDER + 1 + params->w * TILESIZE;
+    *y = 2 * BORDER + 1 + params->h * TILESIZE;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+
+    assert(!ds->player_background);    /* set_size is never called twice */
+    assert(!ds->player_bg_saved);
+
+    ds->player_background = blitter_new(dr, TILESIZE, TILESIZE);
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    ret[COL_OUTLINE * 3 + 0] = 0.0F;
+    ret[COL_OUTLINE * 3 + 1] = 0.0F;
+    ret[COL_OUTLINE * 3 + 2] = 0.0F;
+
+    ret[COL_PLAYER * 3 + 0] = 0.0F;
+    ret[COL_PLAYER * 3 + 1] = 1.0F;
+    ret[COL_PLAYER * 3 + 2] = 0.0F;
+
+    ret[COL_DEAD_PLAYER * 3 + 0] = 1.0F;
+    ret[COL_DEAD_PLAYER * 3 + 1] = 0.0F;
+    ret[COL_DEAD_PLAYER * 3 + 2] = 0.0F;
+
+    ret[COL_MINE * 3 + 0] = 0.0F;
+    ret[COL_MINE * 3 + 1] = 0.0F;
+    ret[COL_MINE * 3 + 2] = 0.0F;
+
+    ret[COL_GEM * 3 + 0] = 0.6F;
+    ret[COL_GEM * 3 + 1] = 1.0F;
+    ret[COL_GEM * 3 + 2] = 1.0F;
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_WALL * 3 + i] = (3 * ret[COL_BACKGROUND * 3 + i] +
+                                 1 * ret[COL_HIGHLIGHT * 3 + i]) / 4;
+    }
+
+    ret[COL_HINT * 3 + 0] = 1.0F;
+    ret[COL_HINT * 3 + 1] = 1.0F;
+    ret[COL_HINT * 3 + 2] = 0.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int w = state->p.w, h = state->p.h, wh = w*h;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = 0;
+
+    /* We can't allocate the blitter rectangle for the player background
+     * until we know what size to make it. */
+    ds->player_background = NULL;
+    ds->player_bg_saved = FALSE;
+    ds->pbgx = ds->pbgy = -1;
+
+    ds->p = state->p;                  /* structure copy */
+    ds->started = FALSE;
+    ds->grid = snewn(wh, unsigned short);
+    for (i = 0; i < wh; i++)
+        ds->grid[i] = UNDRAWN;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    if (ds->player_background)
+        blitter_free(dr, ds->player_background);
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+static void draw_player(drawing *dr, game_drawstate *ds, int x, int y,
+                        int dead, int hintdir)
+{
+    if (dead) {
+        int coords[DIRECTIONS*4];
+        int d;
+
+        for (d = 0; d < DIRECTIONS; d++) {
+            float x1, y1, x2, y2, x3, y3, len;
+
+            x1 = DX(d);
+            y1 = DY(d);
+            len = sqrt(x1*x1+y1*y1); x1 /= len; y1 /= len;
+
+            x3 = DX(d+1);
+            y3 = DY(d+1);
+            len = sqrt(x3*x3+y3*y3); x3 /= len; y3 /= len;
+
+            x2 = (x1+x3) / 4;
+            y2 = (y1+y3) / 4;
+
+            coords[d*4+0] = x + TILESIZE/2 + (int)((TILESIZE*3/7) * x1);
+            coords[d*4+1] = y + TILESIZE/2 + (int)((TILESIZE*3/7) * y1);
+            coords[d*4+2] = x + TILESIZE/2 + (int)((TILESIZE*3/7) * x2);
+            coords[d*4+3] = y + TILESIZE/2 + (int)((TILESIZE*3/7) * y2);
+        }
+        draw_polygon(dr, coords, DIRECTIONS*2, COL_DEAD_PLAYER, COL_OUTLINE);
+    } else {
+        draw_circle(dr, x + TILESIZE/2, y + TILESIZE/2,
+                    TILESIZE/3, COL_PLAYER, COL_OUTLINE);
+    }
+
+    if (!dead && hintdir >= 0) {
+        float scale = (DX(hintdir) && DY(hintdir) ? 0.8F : 1.0F);
+        int ax = (TILESIZE*2/5) * scale * DX(hintdir);
+        int ay = (TILESIZE*2/5) * scale * DY(hintdir);
+        int px = -ay, py = ax;
+        int ox = x + TILESIZE/2, oy = y + TILESIZE/2;
+        int coords[14], *c;
+
+        c = coords;
+        *c++ = ox + px/9;
+        *c++ = oy + py/9;
+        *c++ = ox + px/9 + ax*2/3;
+        *c++ = oy + py/9 + ay*2/3;
+        *c++ = ox + px/3 + ax*2/3;
+        *c++ = oy + py/3 + ay*2/3;
+        *c++ = ox + ax;
+        *c++ = oy + ay;
+        *c++ = ox - px/3 + ax*2/3;
+        *c++ = oy - py/3 + ay*2/3;
+        *c++ = ox - px/9 + ax*2/3;
+        *c++ = oy - py/9 + ay*2/3;
+        *c++ = ox - px/9;
+        *c++ = oy - py/9;
+        draw_polygon(dr, coords, 7, COL_HINT, COL_OUTLINE);
+    }
+
+    draw_update(dr, x, y, TILESIZE, TILESIZE);
+}
+
+#define FLASH_DEAD 0x100
+#define FLASH_WIN  0x200
+#define FLASH_MASK 0x300
+
+static void draw_tile(drawing *dr, game_drawstate *ds, int x, int y, int v)
+{
+    int tx = COORD(x), ty = COORD(y);
+    int bg = (v & FLASH_DEAD ? COL_DEAD_PLAYER :
+              v & FLASH_WIN ? COL_HIGHLIGHT : COL_BACKGROUND);
+
+    v &= ~FLASH_MASK;
+
+    clip(dr, tx+1, ty+1, TILESIZE-1, TILESIZE-1);
+    draw_rect(dr, tx+1, ty+1, TILESIZE-1, TILESIZE-1, bg);
+
+    if (v == WALL) {
+        int coords[6];
+
+        coords[0] = tx + TILESIZE;
+        coords[1] = ty + TILESIZE;
+        coords[2] = tx + TILESIZE;
+        coords[3] = ty + 1;
+        coords[4] = tx + 1;
+        coords[5] = ty + TILESIZE;
+        draw_polygon(dr, coords, 3, COL_LOWLIGHT, COL_LOWLIGHT);
+
+        coords[0] = tx + 1;
+        coords[1] = ty + 1;
+        draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+
+        draw_rect(dr, tx + 1 + HIGHLIGHT_WIDTH, ty + 1 + HIGHLIGHT_WIDTH,
+                  TILESIZE - 2*HIGHLIGHT_WIDTH,
+                  TILESIZE - 2*HIGHLIGHT_WIDTH, COL_WALL);
+    } else if (v == MINE) {
+        int cx = tx + TILESIZE / 2;
+        int cy = ty + TILESIZE / 2;
+        int r = TILESIZE / 2 - 3;
+
+        draw_circle(dr, cx, cy, 5*r/6, COL_MINE, COL_MINE);
+        draw_rect(dr, cx - r/6, cy - r, 2*(r/6)+1, 2*r+1, COL_MINE);
+        draw_rect(dr, cx - r, cy - r/6, 2*r+1, 2*(r/6)+1, COL_MINE);
+        draw_rect(dr, cx-r/3, cy-r/3, r/3, r/4, COL_HIGHLIGHT);
+    } else if (v == STOP) {
+        draw_circle(dr, tx + TILESIZE/2, ty + TILESIZE/2,
+                    TILESIZE*3/7, -1, COL_OUTLINE);
+        draw_rect(dr, tx + TILESIZE*3/7, ty+1,
+                  TILESIZE - 2*(TILESIZE*3/7) + 1, TILESIZE-1, bg);
+        draw_rect(dr, tx+1, ty + TILESIZE*3/7,
+                  TILESIZE-1, TILESIZE - 2*(TILESIZE*3/7) + 1, bg);
+    } else if (v == GEM) {
+        int coords[8];
+
+        coords[0] = tx+TILESIZE/2;
+        coords[1] = ty+TILESIZE/2-TILESIZE*5/14;
+        coords[2] = tx+TILESIZE/2-TILESIZE*5/14;
+        coords[3] = ty+TILESIZE/2;
+        coords[4] = tx+TILESIZE/2;
+        coords[5] = ty+TILESIZE/2+TILESIZE*5/14;
+        coords[6] = tx+TILESIZE/2+TILESIZE*5/14;
+        coords[7] = ty+TILESIZE/2;
+
+        draw_polygon(dr, coords, 4, COL_GEM, COL_OUTLINE);
+    }
+
+    unclip(dr);
+    draw_update(dr, tx, ty, TILESIZE, TILESIZE);
+}
+
+#define BASE_ANIM_LENGTH 0.1F
+#define FLASH_LENGTH 0.3F
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->p.w, h = state->p.h /*, wh = w*h */;
+    int x, y;
+    float ap;
+    int player_dist;
+    int flashtype;
+    int gems, deaths;
+    char status[256];
+
+    if (flashtime &&
+        !((int)(flashtime * 3 / FLASH_LENGTH) % 2))
+        flashtype = ui->flashtype;
+    else
+        flashtype = 0;
+
+    /*
+     * Erase the player sprite.
+     */
+    if (ds->player_bg_saved) {
+        assert(ds->player_background);
+        blitter_load(dr, ds->player_background, ds->pbgx, ds->pbgy);
+        draw_update(dr, ds->pbgx, ds->pbgy, TILESIZE, TILESIZE);
+        ds->player_bg_saved = FALSE;
+    }
+
+    /*
+     * Initialise a fresh drawstate.
+     */
+    if (!ds->started) {
+        int wid, ht;
+
+        /*
+         * Blank out the window initially.
+         */
+        game_compute_size(&ds->p, TILESIZE, &wid, &ht);
+        draw_rect(dr, 0, 0, wid, ht, COL_BACKGROUND);
+        draw_update(dr, 0, 0, wid, ht);
+
+        /*
+         * Draw the grid lines.
+         */
+        for (y = 0; y <= h; y++)
+            draw_line(dr, COORD(0), COORD(y), COORD(w), COORD(y),
+                      COL_LOWLIGHT);
+        for (x = 0; x <= w; x++)
+            draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h),
+                      COL_LOWLIGHT);
+
+        ds->started = TRUE;
+    }
+
+    /*
+     * If we're in the process of animating a move, let's start by
+     * working out how far the player has moved from their _older_
+     * state.
+     */
+    if (oldstate) {
+        ap = animtime / ui->anim_length;
+        player_dist = ap * (dir > 0 ? state : oldstate)->distance_moved;
+    } else {
+        player_dist = 0;
+        ap = 0.0F;
+    }
+
+    /*
+     * Draw the grid contents.
+     * 
+     * We count the gems as we go round this loop, for the purposes
+     * of the status bar. Of course we have a gems counter in the
+     * game_state already, but if we do the counting in this loop
+     * then it tracks gems being picked up in a sliding move, and
+     * updates one by one.
+     */
+    gems = 0;
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            unsigned short v = (unsigned char)state->grid[y*w+x];
+
+            /*
+             * Special case: if the player is in the process of
+             * moving over a gem, we draw the gem iff they haven't
+             * gone past it yet.
+             */
+            if (oldstate && oldstate->grid[y*w+x] != state->grid[y*w+x]) {
+                /*
+                 * Compute the distance from this square to the
+                 * original player position.
+                 */
+                int dist = max(abs(x - oldstate->px), abs(y - oldstate->py));
+
+                /*
+                 * If the player has reached here, use the new grid
+                 * element. Otherwise use the old one.
+                 */
+                if (player_dist < dist)
+                    v = oldstate->grid[y*w+x];
+                else
+                    v = state->grid[y*w+x];
+            }
+
+            /*
+             * Special case: erase the mine the dead player is
+             * sitting on. Only at the end of the move.
+             */
+            if (v == MINE && !oldstate && state->dead &&
+                x == state->px && y == state->py)
+                v = BLANK;
+
+            if (v == GEM)
+                gems++;
+
+            v |= flashtype;
+
+            if (ds->grid[y*w+x] != v) {
+                draw_tile(dr, ds, x, y, v);
+                ds->grid[y*w+x] = v;
+            }
+        }
+
+    /*
+     * Gem counter in the status bar. We replace it with
+     * `COMPLETED!' when it reaches zero ... or rather, when the
+     * _current state_'s gem counter is zero. (Thus, `Gems: 0' is
+     * shown between the collection of the last gem and the
+     * completion of the move animation that did it.)
+     */
+    if (state->dead && (!oldstate || oldstate->dead)) {
+        sprintf(status, "DEAD!");
+    } else if (state->gems || (oldstate && oldstate->gems)) {
+        if (state->cheated)
+            sprintf(status, "Auto-solver used. ");
+        else
+            *status = '\0';
+        sprintf(status + strlen(status), "Gems: %d", gems);
+    } else if (state->cheated) {
+        sprintf(status, "Auto-solved.");
+    } else {
+        sprintf(status, "COMPLETED!");
+    }
+    /* We subtract one from the visible death counter if we're still
+     * animating the move at the end of which the death took place. */
+    deaths = ui->deaths;
+    if (oldstate && ui->just_died) {
+        assert(deaths > 0);
+        deaths--;
+    }
+    if (deaths)
+        sprintf(status + strlen(status), "   Deaths: %d", deaths);
+    status_bar(dr, status);
+
+    /*
+     * Draw the player sprite.
+     */
+    assert(!ds->player_bg_saved);
+    assert(ds->player_background);
+    {
+        int ox, oy, nx, ny;
+        nx = COORD(state->px);
+        ny = COORD(state->py);
+        if (oldstate) {
+            ox = COORD(oldstate->px);
+            oy = COORD(oldstate->py);
+        } else {
+            ox = nx;
+            oy = ny;
+        }
+        ds->pbgx = ox + ap * (nx - ox);
+        ds->pbgy = oy + ap * (ny - oy);
+    }
+    blitter_save(dr, ds->player_background, ds->pbgx, ds->pbgy);
+    draw_player(dr, ds, ds->pbgx, ds->pbgy,
+                (state->dead && !oldstate),
+                (!oldstate && state->soln ?
+                 state->soln->list[state->solnpos] : -1));
+    ds->player_bg_saved = TRUE;
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    int dist;
+    if (dir > 0)
+        dist = newstate->distance_moved;
+    else
+        dist = oldstate->distance_moved;
+    ui->anim_length = sqrt(dist) * BASE_ANIM_LENGTH;
+    return ui->anim_length;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->dead && newstate->dead) {
+        ui->flashtype = FLASH_DEAD;
+        return FLASH_LENGTH;
+    } else if (oldstate->gems && !newstate->gems) {
+        ui->flashtype = FLASH_WIN;
+        return FLASH_LENGTH;
+    }
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    /*
+     * We never report the game as lost, on the grounds that if the
+     * player has died they're quite likely to want to undo and carry
+     * on.
+     */
+    return state->gems == 0 ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame inertia
+#endif
+
+const struct game thegame = {
+    "Inertia", "games.inertia", "inertia",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
diff --git a/apps/plugins/puzzles/keen.R b/apps/plugins/puzzles/keen.R
new file mode 100644
index 0000000000..77609bc7fa
--- /dev/null
+++ b/apps/plugins/puzzles/keen.R
@@ -0,0 +1,25 @@
+# -*- makefile -*-
+
+KEEN_LATIN_EXTRA = tree234 maxflow dsf
+KEEN_EXTRA = latin KEEN_LATIN_EXTRA
+
+keen    : [X] GTK COMMON keen KEEN_EXTRA keen-icon|no-icon
+
+keen    : [G] WINDOWS COMMON keen KEEN_EXTRA keen.res|noicon.res
+
+keensolver : [U] keen[STANDALONE_SOLVER] latin[STANDALONE_SOLVER] KEEN_LATIN_EXTRA STANDALONE
+keensolver : [C] keen[STANDALONE_SOLVER] latin[STANDALONE_SOLVER] KEEN_LATIN_EXTRA STANDALONE
+
+ALL += keen[COMBINED] KEEN_EXTRA
+
+!begin am gtk
+GAMES += keen
+!end
+
+!begin >list.c
+    A(keen) \
+!end
+
+!begin >gamedesc.txt
+keen:keen.exe:Keen:Arithmetic Latin square puzzle:Complete the latin square in accordance with the arithmetic clues.
+!end
diff --git a/apps/plugins/puzzles/keen.c b/apps/plugins/puzzles/keen.c
new file mode 100644
index 0000000000..32d6288f88
--- /dev/null
+++ b/apps/plugins/puzzles/keen.c
@@ -0,0 +1,2479 @@
+/*
+ * keen.c: an implementation of the Times's 'KenKen' puzzle, and
+ * also of Nikoli's very similar 'Inshi No Heya' puzzle.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "latin.h"
+
+/*
+ * Difficulty levels. I do some macro ickery here to ensure that my
+ * enum and the various forms of my name list always match up.
+ */
+#define DIFFLIST(A) \
+    A(EASY,Easy,solver_easy,e) \
+    A(NORMAL,Normal,solver_normal,n) \
+    A(HARD,Hard,solver_hard,h) \
+    A(EXTREME,Extreme,NULL,x) \
+    A(UNREASONABLE,Unreasonable,NULL,u)
+#define ENUM(upper,title,func,lower) DIFF_ ## upper,
+#define TITLE(upper,title,func,lower) #title,
+#define ENCODE(upper,title,func,lower) #lower
+#define CONFIG(upper,title,func,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const keen_diffnames[] = { DIFFLIST(TITLE) };
+static char const keen_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+/*
+ * Clue notation. Important here that ADD and MUL come before SUB
+ * and DIV, and that DIV comes last. 
+ */
+#define C_ADD 0x00000000L
+#define C_MUL 0x20000000L
+#define C_SUB 0x40000000L
+#define C_DIV 0x60000000L
+#define CMASK 0x60000000L
+#define CUNIT 0x20000000L
+
+/*
+ * Maximum size of any clue block. Very large ones are annoying in UI
+ * terms (if they're multiplicative you end up with too many digits to
+ * fit in the square) and also in solver terms (too many possibilities
+ * to iterate over).
+ */
+#define MAXBLK 6
+
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_USER,
+    COL_HIGHLIGHT,
+    COL_ERROR,
+    COL_PENCIL,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, diff, multiplication_only;
+};
+
+struct clues {
+    int refcount;
+    int w;
+    int *dsf;
+    long *clues;
+};
+
+struct game_state {
+    game_params par;
+    struct clues *clues;
+    digit *grid;
+    int *pencil;                       /* bitmaps using bits 1<<1..1<<n */
+    int completed, cheated;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = 6;
+    ret->diff = DIFF_NORMAL;
+    ret->multiplication_only = FALSE;
+
+    return ret;
+}
+
+const static struct game_params keen_presets[] = {
+    {  4, DIFF_EASY,         FALSE },
+    {  5, DIFF_EASY,         FALSE },
+    {  5, DIFF_EASY,         TRUE  },
+    {  6, DIFF_EASY,         FALSE },
+    {  6, DIFF_NORMAL,       FALSE },
+    {  6, DIFF_NORMAL,       TRUE  },
+    {  6, DIFF_HARD,         FALSE },
+    {  6, DIFF_EXTREME,      FALSE },
+    {  6, DIFF_UNREASONABLE, FALSE },
+    {  9, DIFF_NORMAL,       FALSE },
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(keen_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = keen_presets[i]; /* structure copy */
+
+    sprintf(buf, "%dx%d %s%s", ret->w, ret->w, keen_diffnames[ret->diff],
+            ret->multiplication_only ? ", multiplication only" : "");
+
+    *name = dupstr(buf);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    char const *p = string;
+
+    params->w = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+
+    if (*p == 'd') {
+        int i;
+        p++;
+        params->diff = DIFFCOUNT+1; /* ...which is invalid */
+        if (*p) {
+            for (i = 0; i < DIFFCOUNT; i++) {
+                if (*p == keen_diffchars[i])
+                    params->diff = i;
+            }
+            p++;
+        }
+    }
+
+    if (*p == 'm') {
+        p++;
+        params->multiplication_only = TRUE;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char ret[80];
+
+    sprintf(ret, "%d", params->w);
+    if (full)
+        sprintf(ret + strlen(ret), "d%c%s", keen_diffchars[params->diff],
+                params->multiplication_only ? "m" : "");
+
+    return dupstr(ret);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Grid size";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Difficulty";
+    ret[1].type = C_CHOICES;
+    ret[1].sval = DIFFCONFIG;
+    ret[1].ival = params->diff;
+
+    ret[2].name = "Multiplication only";
+    ret[2].type = C_BOOLEAN;
+    ret[2].sval = NULL;
+    ret[2].ival = params->multiplication_only;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->diff = cfg[1].ival;
+    ret->multiplication_only = cfg[2].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 3 || params->w > 9)
+        return "Grid size must be between 3 and 9";
+    if (params->diff >= DIFFCOUNT)
+        return "Unknown difficulty rating";
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver.
+ */
+
+struct solver_ctx {
+    int w, diff;
+    int nboxes;
+    int *boxes, *boxlist, *whichbox;
+    long *clues;
+    digit *soln;
+    digit *dscratch;
+    int *iscratch;
+};
+
+static void solver_clue_candidate(struct solver_ctx *ctx, int diff, int box)
+{
+    int w = ctx->w;
+    int n = ctx->boxes[box+1] - ctx->boxes[box];
+    int j;
+
+    /*
+     * This function is called from the main clue-based solver
+     * routine when we discover a candidate layout for a given clue
+     * box consistent with everything we currently know about the
+     * digit constraints in that box. We expect to find the digits
+     * of the candidate layout in ctx->dscratch, and we update
+     * ctx->iscratch as appropriate.
+     *
+     * The contents of ctx->iscratch are completely different
+     * depending on whether diff == DIFF_HARD or not. This function
+     * uses iscratch completely differently between the two cases, and
+     * the code in solver_common() which consumes the result must
+     * likewise have an if statement with completely different
+     * branches for the two cases.
+     *
+     * In DIFF_EASY and DIFF_NORMAL modes, the valid entries in
+     * ctx->iscratch are 0,...,n-1, and each of those entries
+     * ctx->iscratch[i] gives a bitmap of the possible digits in the
+     * ith square of the clue box currently under consideration. So
+     * each entry of iscratch starts off as an empty bitmap, and we
+     * set bits in it as possible layouts for the clue box are
+     * considered (and the difference between DIFF_EASY and
+     * DIFF_NORMAL is just that in DIFF_EASY mode we deliberately set
+     * more bits than absolutely necessary, hence restricting our own
+     * knowledge).
+     *
+     * But in DIFF_HARD mode, the valid entries are 0,...,2*w-1 (at
+     * least outside *this* function - inside this function, we also
+     * use 2*w,...,4*w-1 as scratch space in the loop below); the
+     * first w of those give the possible digits in the intersection
+     * of the current clue box with each column of the puzzle, and the
+     * next w do the same for each row. In this mode, each iscratch
+     * entry starts off as a _full_ bitmap, and in this function we
+     * _clear_ bits for digits that are absent from a given row or
+     * column in each candidate layout, so that the only bits which
+     * remain set are those for digits which have to appear in a given
+     * row/column no matter how the clue box is laid out.
+     */
+    if (diff == DIFF_EASY) {
+        unsigned mask = 0;
+        /*
+         * Easy-mode clue deductions: we do not record information
+         * about which squares take which values, so we amalgamate
+         * all the values in dscratch and OR them all into
+         * everywhere.
+         */
+        for (j = 0; j < n; j++)
+            mask |= 1 << ctx->dscratch[j];
+        for (j = 0; j < n; j++)
+            ctx->iscratch[j] |= mask;
+    } else if (diff == DIFF_NORMAL) {
+        /*
+         * Normal-mode deductions: we process the information in
+         * dscratch in the obvious way.
+         */
+        for (j = 0; j < n; j++)
+            ctx->iscratch[j] |= 1 << ctx->dscratch[j];
+    } else if (diff == DIFF_HARD) {
+        /*
+         * Hard-mode deductions: instead of ruling things out
+         * _inside_ the clue box, we look for numbers which occur in
+         * a given row or column in all candidate layouts, and rule
+         * them out of all squares in that row or column that
+         * _aren't_ part of this clue box.
+         */
+        int *sq = ctx->boxlist + ctx->boxes[box];
+
+        for (j = 0; j < 2*w; j++)
+            ctx->iscratch[2*w+j] = 0;
+        for (j = 0; j < n; j++) {
+            int x = sq[j] / w, y = sq[j] % w;
+            ctx->iscratch[2*w+x] |= 1 << ctx->dscratch[j];
+            ctx->iscratch[3*w+y] |= 1 << ctx->dscratch[j];
+        }
+        for (j = 0; j < 2*w; j++)
+            ctx->iscratch[j] &= ctx->iscratch[2*w+j];
+    }
+}
+
+static int solver_common(struct latin_solver *solver, void *vctx, int diff)
+{
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    int w = ctx->w;
+    int box, i, j, k;
+    int ret = 0, total;
+
+    /*
+     * Iterate over each clue box and deduce what we can.
+     */
+    for (box = 0; box < ctx->nboxes; box++) {
+        int *sq = ctx->boxlist + ctx->boxes[box];
+        int n = ctx->boxes[box+1] - ctx->boxes[box];
+        long value = ctx->clues[box] & ~CMASK;
+        long op = ctx->clues[box] & CMASK;
+
+        /*
+         * Initialise ctx->iscratch for this clue box. At different
+         * difficulty levels we must initialise a different amount of
+         * it to different things; see the comments in
+         * solver_clue_candidate explaining what each version does.
+         */
+        if (diff == DIFF_HARD) {
+            for (i = 0; i < 2*w; i++)
+                ctx->iscratch[i] = (1 << (w+1)) - (1 << 1);
+        } else {
+            for (i = 0; i < n; i++)
+                ctx->iscratch[i] = 0;
+        }
+
+        switch (op) {
+          case C_SUB:
+          case C_DIV:
+            /*
+             * These two clue types must always apply to a box of
+             * area 2. Also, the two digits in these boxes can never
+             * be the same (because any domino must have its two
+             * squares in either the same row or the same column).
+             * So we simply iterate over all possibilities for the
+             * two squares (both ways round), rule out any which are
+             * inconsistent with the digit constraints we already
+             * have, and update the digit constraints with any new
+             * information thus garnered.
+             */
+            assert(n == 2);
+
+            for (i = 1; i <= w; i++) {
+                j = (op == C_SUB ? i + value : i * value);
+                if (j > w) break;
+
+                /* (i,j) is a valid digit pair. Try it both ways round. */
+
+                if (solver->cube[sq[0]*w+i-1] &&
+                    solver->cube[sq[1]*w+j-1]) {
+                    ctx->dscratch[0] = i;
+                    ctx->dscratch[1] = j;
+                    solver_clue_candidate(ctx, diff, box);
+                }
+
+                if (solver->cube[sq[0]*w+j-1] &&
+                    solver->cube[sq[1]*w+i-1]) {
+                    ctx->dscratch[0] = j;
+                    ctx->dscratch[1] = i;
+                    solver_clue_candidate(ctx, diff, box);
+                }
+            }
+
+            break;
+
+          case C_ADD:
+          case C_MUL:
+            /*
+             * For these clue types, I have no alternative but to go
+             * through all possible number combinations.
+             *
+             * Instead of a tedious physical recursion, I iterate in
+             * the scratch array through all possibilities. At any
+             * given moment, i indexes the element of the box that
+             * will next be incremented.
+             */
+            i = 0;
+            ctx->dscratch[i] = 0;
+            total = value;             /* start with the identity */
+            while (1) {
+                if (i < n) {
+                    /*
+                     * Find the next valid value for cell i.
+                     */
+                    for (j = ctx->dscratch[i] + 1; j <= w; j++) {
+                        if (op == C_ADD ? (total < j) : (total % j != 0))
+                            continue;  /* this one won't fit */
+                        if (!solver->cube[sq[i]*w+j-1])
+                            continue;  /* this one is ruled out already */
+                        for (k = 0; k < i; k++)
+                            if (ctx->dscratch[k] == j &&
+                                (sq[k] % w == sq[i] % w ||
+                                 sq[k] / w == sq[i] / w))
+                                break; /* clashes with another row/col */
+                        if (k < i)
+                            continue;
+
+                        /* Found one. */
+                        break;
+                    }
+
+                    if (j > w) {
+                        /* No valid values left; drop back. */
+                        i--;
+                        if (i < 0)
+                            break;     /* overall iteration is finished */
+                        if (op == C_ADD)
+                            total += ctx->dscratch[i];
+                        else
+                            total *= ctx->dscratch[i];
+                    } else {
+                        /* Got a valid value; store it and move on. */
+                        ctx->dscratch[i++] = j;
+                        if (op == C_ADD)
+                            total -= j;
+                        else
+                            total /= j;
+                        ctx->dscratch[i] = 0;
+                    }
+                } else {
+                    if (total == (op == C_ADD ? 0 : 1))
+                        solver_clue_candidate(ctx, diff, box);
+                    i--;
+                    if (op == C_ADD)
+                        total += ctx->dscratch[i];
+                    else
+                        total *= ctx->dscratch[i];
+                }
+            }
+
+            break;
+        }
+
+        /*
+         * Do deductions based on the information we've now
+         * accumulated in ctx->iscratch. See the comments above in
+         * solver_clue_candidate explaining what data is left in here,
+         * and how it differs between DIFF_HARD and lower difficulty
+         * levels (hence the big if statement here).
+         */
+        if (diff < DIFF_HARD) {
+#ifdef STANDALONE_SOLVER
+            char prefix[256];
+
+            if (solver_show_working)
+                sprintf(prefix, "%*susing clue at (%d,%d):\n",
+                        solver_recurse_depth*4, "",
+                        sq[0]/w+1, sq[0]%w+1);
+            else
+                prefix[0] = '\0';              /* placate optimiser */
+#endif
+
+            for (i = 0; i < n; i++)
+                for (j = 1; j <= w; j++) {
+                    if (solver->cube[sq[i]*w+j-1] &&
+                        !(ctx->iscratch[i] & (1 << j))) {
+#ifdef STANDALONE_SOLVER
+                        if (solver_show_working) {
+                            printf("%s%*s  ruling out %d at (%d,%d)\n",
+                                   prefix, solver_recurse_depth*4, "",
+                                   j, sq[i]/w+1, sq[i]%w+1);
+                            prefix[0] = '\0';
+                        }
+#endif
+                        solver->cube[sq[i]*w+j-1] = 0;
+                        ret = 1;
+                    }
+                }
+        } else {
+#ifdef STANDALONE_SOLVER
+            char prefix[256];
+
+            if (solver_show_working)
+                sprintf(prefix, "%*susing clue at (%d,%d):\n",
+                        solver_recurse_depth*4, "",
+                        sq[0]/w+1, sq[0]%w+1);
+            else
+                prefix[0] = '\0';              /* placate optimiser */
+#endif
+
+            for (i = 0; i < 2*w; i++) {
+                int start = (i < w ? i*w : i-w);
+                int step = (i < w ? 1 : w);
+                for (j = 1; j <= w; j++) if (ctx->iscratch[i] & (1 << j)) {
+#ifdef STANDALONE_SOLVER
+                    char prefix2[256];
+
+                    if (solver_show_working)
+                        sprintf(prefix2, "%*s  this clue requires %d in"
+                                " %s %d:\n", solver_recurse_depth*4, "",
+                                j, i < w ? "column" : "row", i%w+1);
+                    else
+                        prefix2[0] = '\0';   /* placate optimiser */
+#endif
+
+                    for (k = 0; k < w; k++) {
+                        int pos = start + k*step;
+                        if (ctx->whichbox[pos] != box &&
+                            solver->cube[pos*w+j-1]) {
+#ifdef STANDALONE_SOLVER
+                            if (solver_show_working) {
+                                printf("%s%s%*s   ruling out %d at (%d,%d)\n",
+                                       prefix, prefix2,
+                                       solver_recurse_depth*4, "",
+                                       j, pos/w+1, pos%w+1);
+                                prefix[0] = prefix2[0] = '\0';
+                            }
+#endif
+                            solver->cube[pos*w+j-1] = 0;
+                            ret = 1;
+                        }
+                    }
+                }
+            }
+
+            /*
+             * Once we find one block we can do something with in
+             * this way, revert to trying easier deductions, so as
+             * not to generate solver diagnostics that make the
+             * problem look harder than it is. (We have to do this
+             * for the Hard deductions but not the Easy/Normal ones,
+             * because only the Hard deductions are cross-box.)
+             */
+            if (ret)
+                return ret;
+        }
+    }
+
+    return ret;
+}
+
+static int solver_easy(struct latin_solver *solver, void *vctx)
+{
+    /*
+     * Omit the EASY deductions when solving at NORMAL level, since
+     * the NORMAL deductions are a superset of them anyway and it
+     * saves on time and confusing solver diagnostics.
+     *
+     * Note that this breaks the natural semantics of the return
+     * value of latin_solver. Without this hack, you could determine
+     * a puzzle's difficulty in one go by trying to solve it at
+     * maximum difficulty and seeing what difficulty value was
+     * returned; but with this hack, solving an Easy puzzle on
+     * Normal difficulty will typically return Normal. Hence the
+     * uses of the solver to determine difficulty are all arranged
+     * so as to double-check by re-solving at the next difficulty
+     * level down and making sure it failed.
+     */
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    if (ctx->diff > DIFF_EASY)
+        return 0;
+    return solver_common(solver, vctx, DIFF_EASY);
+}
+
+static int solver_normal(struct latin_solver *solver, void *vctx)
+{
+    return solver_common(solver, vctx, DIFF_NORMAL);
+}
+
+static int solver_hard(struct latin_solver *solver, void *vctx)
+{
+    return solver_common(solver, vctx, DIFF_HARD);
+}
+
+#define SOLVER(upper,title,func,lower) func,
+static usersolver_t const keen_solvers[] = { DIFFLIST(SOLVER) };
+
+static int solver(int w, int *dsf, long *clues, digit *soln, int maxdiff)
+{
+    int a = w*w;
+    struct solver_ctx ctx;
+    int ret;
+    int i, j, n, m;
+    
+    ctx.w = w;
+    ctx.soln = soln;
+    ctx.diff = maxdiff;
+
+    /*
+     * Transform the dsf-formatted clue list into one over which we
+     * can iterate more easily.
+     *
+     * Also transpose the x- and y-coordinates at this point,
+     * because the 'cube' array in the general Latin square solver
+     * puts x first (oops).
+     */
+    for (ctx.nboxes = i = 0; i < a; i++)
+        if (dsf_canonify(dsf, i) == i)
+            ctx.nboxes++;
+    ctx.boxlist = snewn(a, int);
+    ctx.boxes = snewn(ctx.nboxes+1, int);
+    ctx.clues = snewn(ctx.nboxes, long);
+    ctx.whichbox = snewn(a, int);
+    for (n = m = i = 0; i < a; i++)
+        if (dsf_canonify(dsf, i) == i) {
+            ctx.clues[n] = clues[i];
+            ctx.boxes[n] = m;
+            for (j = 0; j < a; j++)
+                if (dsf_canonify(dsf, j) == i) {
+                    ctx.boxlist[m++] = (j % w) * w + (j / w);   /* transpose */
+                    ctx.whichbox[ctx.boxlist[m-1]] = n;
+                }
+            n++;
+        }
+    assert(n == ctx.nboxes);
+    assert(m == a);
+    ctx.boxes[n] = m;
+
+    ctx.dscratch = snewn(a+1, digit);
+    ctx.iscratch = snewn(max(a+1, 4*w), int);
+
+    ret = latin_solver(soln, w, maxdiff,
+                       DIFF_EASY, DIFF_HARD, DIFF_EXTREME,
+                       DIFF_EXTREME, DIFF_UNREASONABLE,
+                       keen_solvers, &ctx, NULL, NULL);
+
+    sfree(ctx.dscratch);
+    sfree(ctx.iscratch);
+    sfree(ctx.whichbox);
+    sfree(ctx.boxlist);
+    sfree(ctx.boxes);
+    sfree(ctx.clues);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Grid generation.
+ */
+
+static char *encode_block_structure(char *p, int w, int *dsf)
+{
+    int i, currrun = 0;
+    char *orig, *q, *r, c;
+
+    orig = p;
+
+    /*
+     * Encode the block structure. We do this by encoding the
+     * pattern of dividing lines: first we iterate over the w*(w-1)
+     * internal vertical grid lines in ordinary reading order, then
+     * over the w*(w-1) internal horizontal ones in transposed
+     * reading order.
+     *
+     * We encode the number of non-lines between the lines; _ means
+     * zero (two adjacent divisions), a means 1, ..., y means 25,
+     * and z means 25 non-lines _and no following line_ (so that za
+     * means 26, zb 27 etc).
+     */
+    for (i = 0; i <= 2*w*(w-1); i++) {
+        int x, y, p0, p1, edge;
+
+        if (i == 2*w*(w-1)) {
+            edge = TRUE;       /* terminating virtual edge */
+        } else {
+            if (i < w*(w-1)) {
+                y = i/(w-1);
+                x = i%(w-1);
+                p0 = y*w+x;
+                p1 = y*w+x+1;
+            } else {
+                x = i/(w-1) - w;
+                y = i%(w-1);
+                p0 = y*w+x;
+                p1 = (y+1)*w+x;
+            }
+            edge = (dsf_canonify(dsf, p0) != dsf_canonify(dsf, p1));
+        }
+
+        if (edge) {
+            while (currrun > 25)
+                *p++ = 'z', currrun -= 25;
+            if (currrun)
+                *p++ = 'a'-1 + currrun;
+            else
+                *p++ = '_';
+            currrun = 0;
+        } else
+            currrun++;
+    }
+
+    /*
+     * Now go through and compress the string by replacing runs of
+     * the same letter with a single copy of that letter followed by
+     * a repeat count, where that makes it shorter. (This puzzle
+     * seems to generate enough long strings of _ to make this a
+     * worthwhile step.)
+     */
+    for (q = r = orig; r < p ;) {
+        *q++ = c = *r;
+
+        for (i = 0; r+i < p && r[i] == c; i++);
+        r += i;
+
+        if (i == 2) {
+            *q++ = c;
+        } else if (i > 2) {
+            q += sprintf(q, "%d", i);
+        }
+    }
+    
+    return q;
+}
+
+static char *parse_block_structure(const char **p, int w, int *dsf)
+{
+    int a = w*w;
+    int pos = 0;
+    int repc = 0, repn = 0;
+
+    dsf_init(dsf, a);
+
+    while (**p && (repn > 0 || **p != ',')) {
+        int c, adv;
+
+        if (repn > 0) {
+            repn--;
+            c = repc;
+        } else if (**p == '_' || (**p >= 'a' && **p <= 'z')) {
+            c = (**p == '_' ? 0 : **p - 'a' + 1);
+            (*p)++;
+            if (**p && isdigit((unsigned char)**p)) {
+                repc = c;
+                repn = atoi(*p)-1;
+                while (**p && isdigit((unsigned char)**p)) (*p)++;
+            }
+        } else
+            return "Invalid character in game description";
+
+        adv = (c != 25);               /* 'z' is a special case */
+
+        while (c-- > 0) {
+            int p0, p1;
+
+            /*
+             * Non-edge; merge the two dsf classes on either
+             * side of it.
+             */
+            if (pos >= 2*w*(w-1))
+                return "Too much data in block structure specification";
+            if (pos < w*(w-1)) {
+                int y = pos/(w-1);
+                int x = pos%(w-1);
+                p0 = y*w+x;
+                p1 = y*w+x+1;
+            } else {
+                int x = pos/(w-1) - w;
+                int y = pos%(w-1);
+                p0 = y*w+x;
+                p1 = (y+1)*w+x;
+            }
+            dsf_merge(dsf, p0, p1);
+
+            pos++;
+        }
+        if (adv) {
+            pos++;
+            if (pos > 2*w*(w-1)+1)
+                return "Too much data in block structure specification";
+        }
+    }
+
+    /*
+     * When desc is exhausted, we expect to have gone exactly
+     * one space _past_ the end of the grid, due to the dummy
+     * edge at the end.
+     */
+    if (pos != 2*w*(w-1)+1)
+        return "Not enough data in block structure specification";
+
+    return NULL;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, a = w*w;
+    digit *grid, *soln;
+    int *order, *revorder, *singletons, *dsf;
+    long *clues, *cluevals;
+    int i, j, k, n, x, y, ret;
+    int diff = params->diff;
+    char *desc, *p;
+
+    /*
+     * Difficulty exceptions: 3x3 puzzles at difficulty Hard or
+     * higher are currently not generable - the generator will spin
+     * forever looking for puzzles of the appropriate difficulty. We
+     * dial each of these down to the next lower difficulty.
+     *
+     * Remember to re-test this whenever a change is made to the
+     * solver logic!
+     *
+     * I tested it using the following shell command:
+
+for d in e n h x u; do
+  for i in {3..9}; do
+    echo ./keen --generate 1 ${i}d${d}
+    perl -e 'alarm 30; exec @ARGV' ./keen --generate 5 ${i}d${d} >/dev/null \
+      || echo broken
+  done
+done
+
+     * Of course, it's better to do that after taking the exceptions
+     * _out_, so as to detect exceptions that should be removed as
+     * well as those which should be added.
+     */
+    if (w == 3 && diff > DIFF_NORMAL)
+        diff = DIFF_NORMAL;
+
+    grid = NULL;
+
+    order = snewn(a, int);
+    revorder = snewn(a, int);
+    singletons = snewn(a, int);
+    dsf = snew_dsf(a);
+    clues = snewn(a, long);
+    cluevals = snewn(a, long);
+    soln = snewn(a, digit);
+
+    while (1) {
+        /*
+         * First construct a latin square to be the solution.
+         */
+        sfree(grid);
+        grid = latin_generate(w, rs);
+
+        /*
+         * Divide the grid into arbitrarily sized blocks, but so as
+         * to arrange plenty of dominoes which can be SUB/DIV clues.
+         * We do this by first placing dominoes at random for a
+         * while, then tying the remaining singletons one by one
+         * into neighbouring blocks.
+         */
+        for (i = 0; i < a; i++)
+            order[i] = i;
+        shuffle(order, a, sizeof(*order), rs);
+        for (i = 0; i < a; i++)
+            revorder[order[i]] = i;
+
+        for (i = 0; i < a; i++)
+            singletons[i] = TRUE;
+
+        dsf_init(dsf, a);
+
+        /* Place dominoes. */
+        for (i = 0; i < a; i++) {
+            if (singletons[i]) {
+                int best = -1;
+
+                x = i % w;
+                y = i / w;
+
+                if (x > 0 && singletons[i-1] &&
+                    (best == -1 || revorder[i-1] < revorder[best]))
+                    best = i-1;
+                if (x+1 < w && singletons[i+1] &&
+                    (best == -1 || revorder[i+1] < revorder[best]))
+                    best = i+1;
+                if (y > 0 && singletons[i-w] &&
+                    (best == -1 || revorder[i-w] < revorder[best]))
+                    best = i-w;
+                if (y+1 < w && singletons[i+w] &&
+                    (best == -1 || revorder[i+w] < revorder[best]))
+                    best = i+w;
+
+                /*
+                 * When we find a potential domino, we place it with
+                 * probability 3/4, which seems to strike a decent
+                 * balance between plenty of dominoes and leaving
+                 * enough singletons to make interesting larger
+                 * shapes.
+                 */
+                if (best >= 0 && random_upto(rs, 4)) {
+                    singletons[i] = singletons[best] = FALSE;
+                    dsf_merge(dsf, i, best);
+                }
+            }
+        }
+
+        /* Fold in singletons. */
+        for (i = 0; i < a; i++) {
+            if (singletons[i]) {
+                int best = -1;
+
+                x = i % w;
+                y = i / w;
+
+                if (x > 0 && dsf_size(dsf, i-1) < MAXBLK &&
+                    (best == -1 || revorder[i-1] < revorder[best]))
+                    best = i-1;
+                if (x+1 < w && dsf_size(dsf, i+1) < MAXBLK &&
+                    (best == -1 || revorder[i+1] < revorder[best]))
+                    best = i+1;
+                if (y > 0 && dsf_size(dsf, i-w) < MAXBLK &&
+                    (best == -1 || revorder[i-w] < revorder[best]))
+                    best = i-w;
+                if (y+1 < w && dsf_size(dsf, i+w) < MAXBLK &&
+                    (best == -1 || revorder[i+w] < revorder[best]))
+                    best = i+w;
+
+                if (best >= 0) {
+                    singletons[i] = singletons[best] = FALSE;
+                    dsf_merge(dsf, i, best);
+                }
+            }
+        }
+
+        /* Quit and start again if we have any singletons left over
+         * which we weren't able to do anything at all with. */
+        for (i = 0; i < a; i++)
+            if (singletons[i])
+                break;
+        if (i < a)
+            continue;
+
+        /*
+         * Decide what would be acceptable clues for each block.
+         *
+         * Blocks larger than 2 have free choice of ADD or MUL;
+         * blocks of size 2 can be anything in principle (except
+         * that they can only be DIV if the two numbers have an
+         * integer quotient, of course), but we rule out (or try to
+         * avoid) some clues because they're of low quality.
+         *
+         * Hence, we iterate once over the grid, stopping at the
+         * canonical element of every >2 block and the _non_-
+         * canonical element of every 2-block; the latter means that
+         * we can make our decision about a 2-block in the knowledge
+         * of both numbers in it.
+         *
+         * We reuse the 'singletons' array (finished with in the
+         * above loop) to hold information about which blocks are
+         * suitable for what.
+         */
+#define F_ADD     0x01
+#define F_SUB     0x02
+#define F_MUL     0x04
+#define F_DIV     0x08
+#define BAD_SHIFT 4
+
+        for (i = 0; i < a; i++) {
+            singletons[i] = 0;
+            j = dsf_canonify(dsf, i);
+            k = dsf_size(dsf, j);
+            if (params->multiplication_only)
+                singletons[j] = F_MUL;
+            else if (j == i && k > 2) {
+                singletons[j] |= F_ADD | F_MUL;
+            } else if (j != i && k == 2) {
+                /* Fetch the two numbers and sort them into order. */
+                int p = grid[j], q = grid[i], v;
+                if (p < q) {
+                    int t = p; p = q; q = t;
+                }
+
+                /*
+                 * Addition clues are always allowed, but we try to
+                 * avoid sums of 3, 4, (2w-1) and (2w-2) if we can,
+                 * because they're too easy - they only leave one
+                 * option for the pair of numbers involved.
+                 */
+                v = p + q;
+                if (v > 4 && v < 2*w-2)
+                    singletons[j] |= F_ADD;
+                else
+                    singletons[j] |= F_ADD << BAD_SHIFT;
+
+                /*
+                 * Multiplication clues: above Normal difficulty, we
+                 * prefer (but don't absolutely insist on) clues of
+                 * this type which leave multiple options open.
+                 */
+                v = p * q;
+                n = 0;
+                for (k = 1; k <= w; k++)
+                    if (v % k == 0 && v / k <= w && v / k != k)
+                        n++;
+                if (n <= 2 && diff > DIFF_NORMAL)
+                    singletons[j] |= F_MUL << BAD_SHIFT;
+                else
+                    singletons[j] |= F_MUL;
+
+                /*
+                 * Subtraction: we completely avoid a difference of
+                 * w-1.
+                 */
+                v = p - q;
+                if (v < w-1)
+                    singletons[j] |= F_SUB;
+
+                /*
+                 * Division: for a start, the quotient must be an
+                 * integer or the clue type is impossible. Also, we
+                 * never use quotients strictly greater than w/2,
+                 * because they're not only too easy but also
+                 * inelegant.
+                 */
+                if (p % q == 0 && 2 * (p / q) <= w)
+                    singletons[j] |= F_DIV;
+            }
+        }
+
+        /*
+         * Actually choose a clue for each block, trying to keep the
+         * numbers of each type even, and starting with the
+         * preferred candidates for each type where possible.
+         *
+         * I'm sure there should be a faster algorithm for doing
+         * this, but I can't be bothered: O(N^2) is good enough when
+         * N is at most the number of dominoes that fits into a 9x9
+         * square.
+         */
+        shuffle(order, a, sizeof(*order), rs);
+        for (i = 0; i < a; i++)
+            clues[i] = 0;
+        while (1) {
+            int done_something = FALSE;
+
+            for (k = 0; k < 4; k++) {
+                long clue;
+                int good, bad;
+                switch (k) {
+                  case 0:                clue = C_DIV; good = F_DIV; break;
+                  case 1:                clue = C_SUB; good = F_SUB; break;
+                  case 2:                clue = C_MUL; good = F_MUL; break;
+                  default /* case 3 */ : clue = C_ADD; good = F_ADD; break;
+                }
+
+                for (i = 0; i < a; i++) {
+                    j = order[i];
+                    if (singletons[j] & good) {
+                        clues[j] = clue;
+                        singletons[j] = 0;
+                        break;
+                    }
+                }
+                if (i == a) {
+                    /* didn't find a nice one, use a nasty one */
+                    bad = good << BAD_SHIFT;
+                    for (i = 0; i < a; i++) {
+                        j = order[i];
+                        if (singletons[j] & bad) {
+                            clues[j] = clue;
+                            singletons[j] = 0;
+                            break;
+                        }
+                    }
+                }
+                if (i < a)
+                    done_something = TRUE;
+            }
+
+            if (!done_something)
+                break;
+        }
+#undef F_ADD
+#undef F_SUB
+#undef F_MUL
+#undef F_DIV
+#undef BAD_SHIFT
+
+        /*
+         * Having chosen the clue types, calculate the clue values.
+         */
+        for (i = 0; i < a; i++) {
+            j = dsf_canonify(dsf, i);
+            if (j == i) {
+                cluevals[j] = grid[i];
+            } else {
+                switch (clues[j]) {
+                  case C_ADD:
+                    cluevals[j] += grid[i];
+                    break;
+                  case C_MUL:
+                    cluevals[j] *= grid[i];
+                    break;
+                  case C_SUB:
+                    cluevals[j] = abs(cluevals[j] - grid[i]);
+                    break;
+                  case C_DIV:
+                    {
+                        int d1 = cluevals[j], d2 = grid[i];
+                        if (d1 == 0 || d2 == 0)
+                            cluevals[j] = 0;
+                        else
+                            cluevals[j] = d2/d1 + d1/d2;/* one is 0 :-) */
+                    }
+                    break;
+                }
+            }
+        }
+
+        for (i = 0; i < a; i++) {
+            j = dsf_canonify(dsf, i);
+            if (j == i) {
+                clues[j] |= cluevals[j];
+            }
+        }
+
+        /*
+         * See if the game can be solved at the specified difficulty
+         * level, but not at the one below.
+         */
+        if (diff > 0) {
+            memset(soln, 0, a);
+            ret = solver(w, dsf, clues, soln, diff-1);
+            if (ret <= diff-1)
+                continue;
+        }
+        memset(soln, 0, a);
+        ret = solver(w, dsf, clues, soln, diff);
+        if (ret != diff)
+            continue;                  /* go round again */
+
+        /*
+         * I wondered if at this point it would be worth trying to
+         * merge adjacent blocks together, to make the puzzle
+         * gradually more difficult if it's currently easier than
+         * specced, increasing the chance of a given generation run
+         * being successful.
+         *
+         * It doesn't seem to be critical for the generation speed,
+         * though, so for the moment I'm leaving it out.
+         */
+
+        /*
+         * We've got a usable puzzle!
+         */
+        break;
+    }
+
+    /*
+     * Encode the puzzle description.
+     */
+    desc = snewn(40*a, char);
+    p = desc;
+    p = encode_block_structure(p, w, dsf);
+    *p++ = ',';
+    for (i = 0; i < a; i++) {
+        j = dsf_canonify(dsf, i);
+        if (j == i) {
+            switch (clues[j] & CMASK) {
+              case C_ADD: *p++ = 'a'; break;
+              case C_SUB: *p++ = 's'; break;
+              case C_MUL: *p++ = 'm'; break;
+              case C_DIV: *p++ = 'd'; break;
+            }
+            p += sprintf(p, "%ld", clues[j] & ~CMASK);
+        }
+    }
+    *p++ = '\0';
+    desc = sresize(desc, p - desc, char);
+
+    /*
+     * Encode the solution.
+     */
+    assert(memcmp(soln, grid, a) == 0);
+    *aux = snewn(a+2, char);
+    (*aux)[0] = 'S';
+    for (i = 0; i < a; i++)
+        (*aux)[i+1] = '0' + soln[i];
+    (*aux)[a+1] = '\0';
+
+    sfree(grid);
+    sfree(order);
+    sfree(revorder);
+    sfree(singletons);
+    sfree(dsf);
+    sfree(clues);
+    sfree(cluevals);
+    sfree(soln);
+
+    return desc;
+}
+
+/* ----------------------------------------------------------------------
+ * Gameplay.
+ */
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, a = w*w;
+    int *dsf;
+    char *ret;
+    const char *p = desc;
+    int i;
+
+    /*
+     * Verify that the block structure makes sense.
+     */
+    dsf = snew_dsf(a);
+    ret = parse_block_structure(&p, w, dsf);
+    if (ret) {
+        sfree(dsf);
+        return ret;
+    }
+
+    if (*p != ',')
+        return "Expected ',' after block structure description";
+    p++;
+
+    /*
+     * Verify that the right number of clues are given, and that SUB
+     * and DIV clues don't apply to blocks of the wrong size.
+     */
+    for (i = 0; i < a; i++) {
+        if (dsf_canonify(dsf, i) == i) {
+            if (*p == 'a' || *p == 'm') {
+                /* these clues need no validation */
+            } else if (*p == 'd' || *p == 's') {
+                if (dsf_size(dsf, i) != 2)
+                    return "Subtraction and division blocks must have area 2";
+            } else if (!*p) {
+                return "Too few clues for block structure";
+            } else {
+                return "Unrecognised clue type";
+            }
+            p++;
+            while (*p && isdigit((unsigned char)*p)) p++;
+        }
+    }
+    if (*p)
+        return "Too many clues for block structure";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, a = w*w;
+    game_state *state = snew(game_state);
+    const char *p = desc;
+    int i;
+
+    state->par = *params;              /* structure copy */
+    state->clues = snew(struct clues);
+    state->clues->refcount = 1;
+    state->clues->w = w;
+    state->clues->dsf = snew_dsf(a);
+    parse_block_structure(&p, w, state->clues->dsf);
+
+    assert(*p == ',');
+    p++;
+
+    state->clues->clues = snewn(a, long);
+    for (i = 0; i < a; i++) {
+        if (dsf_canonify(state->clues->dsf, i) == i) {
+            long clue = 0;
+            switch (*p) {
+              case 'a':
+                clue = C_ADD;
+                break;
+              case 'm':
+                clue = C_MUL;
+                break;
+              case 's':
+                clue = C_SUB;
+                assert(dsf_size(state->clues->dsf, i) == 2);
+                break;
+              case 'd':
+                clue = C_DIV;
+                assert(dsf_size(state->clues->dsf, i) == 2);
+                break;
+              default:
+                assert(!"Bad description in new_game");
+            }
+            p++;
+            clue |= atol(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+            state->clues->clues[i] = clue;
+        } else
+            state->clues->clues[i] = 0;
+    }
+
+    state->grid = snewn(a, digit);
+    state->pencil = snewn(a, int);
+    for (i = 0; i < a; i++) {
+        state->grid[i] = 0;
+        state->pencil[i] = 0;
+    }
+
+    state->completed = state->cheated = FALSE;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w = state->par.w, a = w*w;
+    game_state *ret = snew(game_state);
+
+    ret->par = state->par;             /* structure copy */
+
+    ret->clues = state->clues;
+    ret->clues->refcount++;
+
+    ret->grid = snewn(a, digit);
+    ret->pencil = snewn(a, int);
+    memcpy(ret->grid, state->grid, a*sizeof(digit));
+    memcpy(ret->pencil, state->pencil, a*sizeof(int));
+
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    sfree(state->pencil);
+    if (--state->clues->refcount <= 0) {
+        sfree(state->clues->dsf);
+        sfree(state->clues->clues);
+        sfree(state->clues);
+    }
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int w = state->par.w, a = w*w;
+    int i, ret;
+    digit *soln;
+    char *out;
+
+    if (aux)
+        return dupstr(aux);
+
+    soln = snewn(a, digit);
+    memset(soln, 0, a);
+
+    ret = solver(w, state->clues->dsf, state->clues->clues,
+                 soln, DIFFCOUNT-1);
+
+    if (ret == diff_impossible) {
+        *error = "No solution exists for this puzzle";
+        out = NULL;
+    } else if (ret == diff_ambiguous) {
+        *error = "Multiple solutions exist for this puzzle";
+        out = NULL;
+    } else {
+        out = snewn(a+2, char);
+        out[0] = 'S';
+        for (i = 0; i < a; i++)
+            out[i+1] = '0' + soln[i];
+        out[a+1] = '\0';
+    }
+
+    sfree(soln);
+    return out;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+struct game_ui {
+    /*
+     * These are the coordinates of the currently highlighted
+     * square on the grid, if hshow = 1.
+     */
+    int hx, hy;
+    /*
+     * This indicates whether the current highlight is a
+     * pencil-mark one or a real one.
+     */
+    int hpencil;
+    /*
+     * This indicates whether or not we're showing the highlight
+     * (used to be hx = hy = -1); important so that when we're
+     * using the cursor keys it doesn't keep coming back at a
+     * fixed position. When hshow = 1, pressing a valid number
+     * or letter key or Space will enter that number or letter in the grid.
+     */
+    int hshow;
+    /*
+     * This indicates whether we're using the highlight as a cursor;
+     * it means that it doesn't vanish on a keypress, and that it is
+     * allowed on immutable squares.
+     */
+    int hcursor;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->hx = ui->hy = 0;
+    ui->hpencil = ui->hshow = ui->hcursor = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    int w = newstate->par.w;
+    /*
+     * We prevent pencil-mode highlighting of a filled square, unless
+     * we're using the cursor keys. So if the user has just filled in
+     * a square which we had a pencil-mode highlight in (by Undo, or
+     * by Redo, or by Solve), then we cancel the highlight.
+     */
+    if (ui->hshow && ui->hpencil && !ui->hcursor &&
+        newstate->grid[ui->hy * w + ui->hx] != 0) {
+        ui->hshow = 0;
+    }
+}
+
+#define PREFERRED_TILESIZE 48
+#define TILESIZE (ds->tilesize)
+#define BORDER (TILESIZE / 2)
+#define GRIDEXTRA max((TILESIZE / 32),1)
+#define COORD(x) ((x)*TILESIZE + BORDER)
+#define FROMCOORD(x) (((x)+(TILESIZE-BORDER)) / TILESIZE - 1)
+
+#define FLASH_TIME 0.4F
+
+#define DF_PENCIL_SHIFT 16
+#define DF_ERR_LATIN 0x8000
+#define DF_ERR_CLUE 0x4000
+#define DF_HIGHLIGHT 0x2000
+#define DF_HIGHLIGHT_PENCIL 0x1000
+#define DF_DIGIT_MASK 0x000F
+
+struct game_drawstate {
+    int tilesize;
+    int started;
+    long *tiles;
+    long *errors;
+    char *minus_sign, *times_sign, *divide_sign;
+};
+
+static int check_errors(const game_state *state, long *errors)
+{
+    int w = state->par.w, a = w*w;
+    int i, j, x, y, errs = FALSE;
+    long *cluevals;
+    int *full;
+
+    cluevals = snewn(a, long);
+    full = snewn(a, int);
+
+    if (errors)
+        for (i = 0; i < a; i++) {
+            errors[i] = 0;
+            full[i] = TRUE;
+        }
+
+    for (i = 0; i < a; i++) {
+        long clue;
+
+        j = dsf_canonify(state->clues->dsf, i);
+        if (j == i) {
+            cluevals[i] = state->grid[i];
+        } else {
+            clue = state->clues->clues[j] & CMASK;
+
+            switch (clue) {
+              case C_ADD:
+                cluevals[j] += state->grid[i];
+                break;
+              case C_MUL:
+                cluevals[j] *= state->grid[i];
+                break;
+              case C_SUB:
+                cluevals[j] = abs(cluevals[j] - state->grid[i]);
+                break;
+              case C_DIV:
+                {
+                    int d1 = min(cluevals[j], state->grid[i]);
+                    int d2 = max(cluevals[j], state->grid[i]);
+                    if (d1 == 0 || d2 % d1 != 0)
+                        cluevals[j] = 0;
+                    else
+                        cluevals[j] = d2 / d1;
+                }
+                break;
+            }
+        }
+
+        if (!state->grid[i])
+            full[j] = FALSE;
+    }
+
+    for (i = 0; i < a; i++) {
+        j = dsf_canonify(state->clues->dsf, i);
+        if (j == i) {
+            if ((state->clues->clues[j] & ~CMASK) != cluevals[i]) {
+                errs = TRUE;
+                if (errors && full[j])
+                    errors[j] |= DF_ERR_CLUE;
+            }
+        }
+    }
+
+    sfree(cluevals);
+    sfree(full);
+
+    for (y = 0; y < w; y++) {
+        int mask = 0, errmask = 0;
+        for (x = 0; x < w; x++) {
+            int bit = 1 << state->grid[y*w+x];
+            errmask |= (mask & bit);
+            mask |= bit;
+        }
+
+        if (mask != (1 << (w+1)) - (1 << 1)) {
+            errs = TRUE;
+            errmask &= ~1;
+            if (errors) {
+                for (x = 0; x < w; x++)
+                    if (errmask & (1 << state->grid[y*w+x]))
+                        errors[y*w+x] |= DF_ERR_LATIN;
+            }
+        }
+    }
+
+    for (x = 0; x < w; x++) {
+        int mask = 0, errmask = 0;
+        for (y = 0; y < w; y++) {
+            int bit = 1 << state->grid[y*w+x];
+            errmask |= (mask & bit);
+            mask |= bit;
+        }
+
+        if (mask != (1 << (w+1)) - (1 << 1)) {
+            errs = TRUE;
+            errmask &= ~1;
+            if (errors) {
+                for (y = 0; y < w; y++)
+                    if (errmask & (1 << state->grid[y*w+x]))
+                        errors[y*w+x] |= DF_ERR_LATIN;
+            }
+        }
+    }
+
+    return errs;
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->par.w;
+    int tx, ty;
+    char buf[80];
+
+    button &= ~MOD_MASK;
+
+    tx = FROMCOORD(x);
+    ty = FROMCOORD(y);
+
+    if (tx >= 0 && tx < w && ty >= 0 && ty < w) {
+        if (button == LEFT_BUTTON) {
+            if (tx == ui->hx && ty == ui->hy &&
+                ui->hshow && ui->hpencil == 0) {
+                ui->hshow = 0;
+            } else {
+                ui->hx = tx;
+                ui->hy = ty;
+                ui->hshow = 1;
+                ui->hpencil = 0;
+            }
+            ui->hcursor = 0;
+            return "";                 /* UI activity occurred */
+        }
+        if (button == RIGHT_BUTTON) {
+            /*
+             * Pencil-mode highlighting for non filled squares.
+             */
+            if (state->grid[ty*w+tx] == 0) {
+                if (tx == ui->hx && ty == ui->hy &&
+                    ui->hshow && ui->hpencil) {
+                    ui->hshow = 0;
+                } else {
+                    ui->hpencil = 1;
+                    ui->hx = tx;
+                    ui->hy = ty;
+                    ui->hshow = 1;
+                }
+            } else {
+                ui->hshow = 0;
+            }
+            ui->hcursor = 0;
+            return "";                 /* UI activity occurred */
+        }
+    }
+    if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->hx, &ui->hy, w, w, 0);
+        ui->hshow = ui->hcursor = 1;
+        return "";
+    }
+    if (ui->hshow &&
+        (button == CURSOR_SELECT)) {
+        ui->hpencil = 1 - ui->hpencil;
+        ui->hcursor = 1;
+        return "";
+    }
+
+    if (ui->hshow &&
+        ((button >= '0' && button <= '9' && button - '0' <= w) ||
+         button == CURSOR_SELECT2 || button == '\b')) {
+        int n = button - '0';
+        if (button == CURSOR_SELECT2 || button == '\b')
+            n = 0;
+
+        /*
+         * Can't make pencil marks in a filled square. This can only
+         * become highlighted if we're using cursor keys.
+         */
+        if (ui->hpencil && state->grid[ui->hy*w+ui->hx])
+            return NULL;
+
+        sprintf(buf, "%c%d,%d,%d",
+                (char)(ui->hpencil && n > 0 ? 'P' : 'R'), ui->hx, ui->hy, n);
+
+        if (!ui->hcursor) ui->hshow = 0;
+
+        return dupstr(buf);
+    }
+
+    if (button == 'M' || button == 'm')
+        return dupstr("M");
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    int w = from->par.w, a = w*w;
+    game_state *ret;
+    int x, y, i, n;
+
+    if (move[0] == 'S') {
+        ret = dup_game(from);
+        ret->completed = ret->cheated = TRUE;
+
+        for (i = 0; i < a; i++) {
+            if (move[i+1] < '1' || move[i+1] > '0'+w) {
+                free_game(ret);
+                return NULL;
+            }
+            ret->grid[i] = move[i+1] - '0';
+            ret->pencil[i] = 0;
+        }
+
+        if (move[a+1] != '\0') {
+            free_game(ret);
+            return NULL;
+        }
+
+        return ret;
+    } else if ((move[0] == 'P' || move[0] == 'R') &&
+        sscanf(move+1, "%d,%d,%d", &x, &y, &n) == 3 &&
+        x >= 0 && x < w && y >= 0 && y < w && n >= 0 && n <= w) {
+
+        ret = dup_game(from);
+        if (move[0] == 'P' && n > 0) {
+            ret->pencil[y*w+x] ^= 1 << n;
+        } else {
+            ret->grid[y*w+x] = n;
+            ret->pencil[y*w+x] = 0;
+
+            if (!ret->completed && !check_errors(ret, NULL))
+                ret->completed = TRUE;
+        }
+        return ret;
+    } else if (move[0] == 'M') {
+        /*
+         * Fill in absolutely all pencil marks everywhere. (I
+         * wouldn't use this for actual play, but it's a handy
+         * starting point when following through a set of
+         * diagnostics output by the standalone solver.)
+         */
+        ret = dup_game(from);
+        for (i = 0; i < a; i++) {
+            if (!ret->grid[i])
+                ret->pencil[i] = (1 << (w+1)) - (1 << 1);
+        }
+        return ret;
+    } else
+        return NULL;                   /* couldn't parse move string */
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define SIZE(w) ((w) * TILESIZE + 2*BORDER)
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = *y = SIZE(params->w);
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_GRID * 3 + 0] = 0.0F;
+    ret[COL_GRID * 3 + 1] = 0.0F;
+    ret[COL_GRID * 3 + 2] = 0.0F;
+
+    ret[COL_USER * 3 + 0] = 0.0F;
+    ret[COL_USER * 3 + 1] = 0.6F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_USER * 3 + 2] = 0.0F;
+
+    ret[COL_HIGHLIGHT * 3 + 0] = 0.78F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_HIGHLIGHT * 3 + 1] = 0.78F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_HIGHLIGHT * 3 + 2] = 0.78F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_PENCIL * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_PENCIL * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_PENCIL * 3 + 2] = ret[COL_BACKGROUND * 3 + 2];
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static const char *const minus_signs[] = { "\xE2\x88\x92", "-" };
+static const char *const times_signs[] = { "\xC3\x97", "*" };
+static const char *const divide_signs[] = { "\xC3\xB7", "/" };
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int w = state->par.w, a = w*w;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = 0;
+    ds->started = FALSE;
+    ds->tiles = snewn(a, long);
+    for (i = 0; i < a; i++)
+        ds->tiles[i] = -1;
+    ds->errors = snewn(a, long);
+    ds->minus_sign = text_fallback(dr, minus_signs, lenof(minus_signs));
+    ds->times_sign = text_fallback(dr, times_signs, lenof(times_signs));
+    ds->divide_sign = text_fallback(dr, divide_signs, lenof(divide_signs));
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->tiles);
+    sfree(ds->errors);
+    sfree(ds->minus_sign);
+    sfree(ds->times_sign);
+    sfree(ds->divide_sign);
+    sfree(ds);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds, struct clues *clues,
+                      int x, int y, long tile, int only_one_op)
+{
+    int w = clues->w /* , a = w*w */;
+    int tx, ty, tw, th;
+    int cx, cy, cw, ch;
+    char str[64];
+
+    tx = BORDER + x * TILESIZE + 1 + GRIDEXTRA;
+    ty = BORDER + y * TILESIZE + 1 + GRIDEXTRA;
+
+    cx = tx;
+    cy = ty;
+    cw = tw = TILESIZE-1-2*GRIDEXTRA;
+    ch = th = TILESIZE-1-2*GRIDEXTRA;
+
+    if (x > 0 && dsf_canonify(clues->dsf, y*w+x) == dsf_canonify(clues->dsf, y*w+x-1))
+        cx -= GRIDEXTRA, cw += GRIDEXTRA;
+    if (x+1 < w && dsf_canonify(clues->dsf, y*w+x) == dsf_canonify(clues->dsf, y*w+x+1))
+        cw += GRIDEXTRA;
+    if (y > 0 && dsf_canonify(clues->dsf, y*w+x) == dsf_canonify(clues->dsf, (y-1)*w+x))
+        cy -= GRIDEXTRA, ch += GRIDEXTRA;
+    if (y+1 < w && dsf_canonify(clues->dsf, y*w+x) == dsf_canonify(clues->dsf, (y+1)*w+x))
+        ch += GRIDEXTRA;
+
+    clip(dr, cx, cy, cw, ch);
+
+    /* background needs erasing */
+    draw_rect(dr, cx, cy, cw, ch,
+              (tile & DF_HIGHLIGHT) ? COL_HIGHLIGHT : COL_BACKGROUND);
+
+    /* pencil-mode highlight */
+    if (tile & DF_HIGHLIGHT_PENCIL) {
+        int coords[6];
+        coords[0] = cx;
+        coords[1] = cy;
+        coords[2] = cx+cw/2;
+        coords[3] = cy;
+        coords[4] = cx;
+        coords[5] = cy+ch/2;
+        draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+    }
+
+    /*
+     * Draw the corners of thick lines in corner-adjacent squares,
+     * which jut into this square by one pixel.
+     */
+    if (x > 0 && y > 0 && dsf_canonify(clues->dsf, y*w+x) != dsf_canonify(clues->dsf, (y-1)*w+x-1))
+        draw_rect(dr, tx-GRIDEXTRA, ty-GRIDEXTRA, GRIDEXTRA, GRIDEXTRA, COL_GRID);
+    if (x+1 < w && y > 0 && dsf_canonify(clues->dsf, y*w+x) != dsf_canonify(clues->dsf, (y-1)*w+x+1))
+        draw_rect(dr, tx+TILESIZE-1-2*GRIDEXTRA, ty-GRIDEXTRA, GRIDEXTRA, GRIDEXTRA, COL_GRID);
+    if (x > 0 && y+1 < w && dsf_canonify(clues->dsf, y*w+x) != dsf_canonify(clues->dsf, (y+1)*w+x-1))
+        draw_rect(dr, tx-GRIDEXTRA, ty+TILESIZE-1-2*GRIDEXTRA, GRIDEXTRA, GRIDEXTRA, COL_GRID);
+    if (x+1 < w && y+1 < w && dsf_canonify(clues->dsf, y*w+x) != dsf_canonify(clues->dsf, (y+1)*w+x+1))
+        draw_rect(dr, tx+TILESIZE-1-2*GRIDEXTRA, ty+TILESIZE-1-2*GRIDEXTRA, GRIDEXTRA, GRIDEXTRA, COL_GRID);
+
+    /* Draw the box clue. */
+    if (dsf_canonify(clues->dsf, y*w+x) == y*w+x) {
+        long clue = clues->clues[y*w+x];
+        long cluetype = clue & CMASK, clueval = clue & ~CMASK;
+        int size = dsf_size(clues->dsf, y*w+x);
+        /*
+         * Special case of clue-drawing: a box with only one square
+         * is written as just the number, with no operation, because
+         * it doesn't matter whether the operation is ADD or MUL.
+         * The generation code above should never produce puzzles
+         * containing such a thing - I think they're inelegant - but
+         * it's possible to type in game IDs from elsewhere, so I
+         * want to display them right if so.
+         */
+        sprintf (str, "%ld%s", clueval,
+                 (size == 1 || only_one_op ? "" :
+                  cluetype == C_ADD ? "+" :
+                  cluetype == C_SUB ? ds->minus_sign :
+                  cluetype == C_MUL ? ds->times_sign :
+                  /* cluetype == C_DIV ? */ ds->divide_sign));
+        draw_text(dr, tx + GRIDEXTRA * 2, ty + GRIDEXTRA * 2 + TILESIZE/4,
+                  FONT_VARIABLE, TILESIZE/4, ALIGN_VNORMAL | ALIGN_HLEFT,
+                  (tile & DF_ERR_CLUE ? COL_ERROR : COL_GRID), str);
+    }
+
+    /* new number needs drawing? */
+    if (tile & DF_DIGIT_MASK) {
+        str[1] = '\0';
+        str[0] = (tile & DF_DIGIT_MASK) + '0';
+        draw_text(dr, tx + TILESIZE/2, ty + TILESIZE/2,
+                  FONT_VARIABLE, TILESIZE/2, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                  (tile & DF_ERR_LATIN) ? COL_ERROR : COL_USER, str);
+    } else {
+        int i, j, npencil;
+        int pl, pr, pt, pb;
+        float bestsize;
+        int pw, ph, minph, pbest, fontsize;
+
+        /* Count the pencil marks required. */
+        for (i = 1, npencil = 0; i <= w; i++)
+            if (tile & (1L << (i + DF_PENCIL_SHIFT)))
+                npencil++;
+        if (npencil) {
+
+            minph = 2;
+
+            /*
+             * Determine the bounding rectangle within which we're going
+             * to put the pencil marks.
+             */
+            /* Start with the whole square */
+            pl = tx + GRIDEXTRA;
+            pr = pl + TILESIZE - GRIDEXTRA;
+            pt = ty + GRIDEXTRA;
+            pb = pt + TILESIZE - GRIDEXTRA;
+            if (dsf_canonify(clues->dsf, y*w+x) == y*w+x) {
+                /*
+                 * Make space for the clue text.
+                 */
+                pt += TILESIZE/4;
+                /* minph--; */
+            }
+
+            /*
+             * We arrange our pencil marks in a grid layout, with
+             * the number of rows and columns adjusted to allow the
+             * maximum font size.
+             *
+             * So now we work out what the grid size ought to be.
+             */
+            bestsize = 0.0;
+            pbest = 0;
+            /* Minimum */
+            for (pw = 3; pw < max(npencil,4); pw++) {
+                float fw, fh, fs;
+
+                ph = (npencil + pw - 1) / pw;
+                ph = max(ph, minph);
+                fw = (pr - pl) / (float)pw;
+                fh = (pb - pt) / (float)ph;
+                fs = min(fw, fh);
+                if (fs > bestsize) {
+                    bestsize = fs;
+                    pbest = pw;
+                }
+            }
+            assert(pbest > 0);
+            pw = pbest;
+            ph = (npencil + pw - 1) / pw;
+            ph = max(ph, minph);
+
+            /*
+             * Now we've got our grid dimensions, work out the pixel
+             * size of a grid element, and round it to the nearest
+             * pixel. (We don't want rounding errors to make the
+             * grid look uneven at low pixel sizes.)
+             */
+            fontsize = min((pr - pl) / pw, (pb - pt) / ph);
+
+            /*
+             * Centre the resulting figure in the square.
+             */
+            pl = tx + (TILESIZE - fontsize * pw) / 2;
+            pt = ty + (TILESIZE - fontsize * ph) / 2;
+
+            /*
+             * And move it down a bit if it's collided with some
+             * clue text.
+             */
+            if (dsf_canonify(clues->dsf, y*w+x) == y*w+x) {
+                pt = max(pt, ty + GRIDEXTRA * 3 + TILESIZE/4);
+            }
+
+            /*
+             * Now actually draw the pencil marks.
+             */
+            for (i = 1, j = 0; i <= w; i++)
+                if (tile & (1L << (i + DF_PENCIL_SHIFT))) {
+                    int dx = j % pw, dy = j / pw;
+
+                    str[1] = '\0';
+                    str[0] = i + '0';
+                    draw_text(dr, pl + fontsize * (2*dx+1) / 2,
+                              pt + fontsize * (2*dy+1) / 2,
+                              FONT_VARIABLE, fontsize,
+                              ALIGN_VCENTRE | ALIGN_HCENTRE, COL_PENCIL, str);
+                    j++;
+                }
+        }
+    }
+
+    unclip(dr);
+
+    draw_update(dr, cx, cy, cw, ch);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->par.w /*, a = w*w */;
+    int x, y;
+
+    if (!ds->started) {
+        /*
+         * The initial contents of the window are not guaranteed and
+         * can vary with front ends. To be on the safe side, all
+         * games should start by drawing a big background-colour
+         * rectangle covering the whole window.
+         */
+        draw_rect(dr, 0, 0, SIZE(w), SIZE(w), COL_BACKGROUND);
+
+        /*
+         * Big containing rectangle.
+         */
+        draw_rect(dr, COORD(0) - GRIDEXTRA, COORD(0) - GRIDEXTRA,
+                  w*TILESIZE+1+GRIDEXTRA*2, w*TILESIZE+1+GRIDEXTRA*2,
+                  COL_GRID);
+
+        draw_update(dr, 0, 0, SIZE(w), SIZE(w));
+
+        ds->started = TRUE;
+    }
+
+    check_errors(state, ds->errors);
+
+    for (y = 0; y < w; y++) {
+        for (x = 0; x < w; x++) {
+            long tile = 0L;
+
+            if (state->grid[y*w+x])
+                tile = state->grid[y*w+x];
+            else
+                tile = (long)state->pencil[y*w+x] << DF_PENCIL_SHIFT;
+
+            if (ui->hshow && ui->hx == x && ui->hy == y)
+                tile |= (ui->hpencil ? DF_HIGHLIGHT_PENCIL : DF_HIGHLIGHT);
+
+            if (flashtime > 0 &&
+                (flashtime <= FLASH_TIME/3 ||
+                 flashtime >= FLASH_TIME*2/3))
+                tile |= DF_HIGHLIGHT;  /* completion flash */
+
+            tile |= ds->errors[y*w+x];
+
+            if (ds->tiles[y*w+x] != tile) {
+                ds->tiles[y*w+x] = tile;
+                draw_tile(dr, ds, state->clues, x, y, tile,
+                          state->par.multiplication_only);
+            }
+        }
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    if (state->completed)
+        return FALSE;
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * We use 9mm squares by default, like Solo.
+     */
+    game_compute_size(params, 900, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+/*
+ * Subfunction to draw the thick lines between cells. In order to do
+ * this using the line-drawing rather than rectangle-drawing API (so
+ * as to get line thicknesses to scale correctly) and yet have
+ * correctly mitred joins between lines, we must do this by tracing
+ * the boundary of each sub-block and drawing it in one go as a
+ * single polygon.
+ */
+static void outline_block_structure(drawing *dr, game_drawstate *ds,
+                                    int w, int *dsf, int ink)
+{
+    int a = w*w;
+    int *coords;
+    int i, n;
+    int x, y, dx, dy, sx, sy, sdx, sdy;
+
+    coords = snewn(4*a, int);
+
+    /*
+     * Iterate over all the blocks.
+     */
+    for (i = 0; i < a; i++) {
+        if (dsf_canonify(dsf, i) != i)
+            continue;
+
+        /*
+         * For each block, we need a starting square within it which
+         * has a boundary at the left. Conveniently, we have one
+         * right here, by construction.
+         */
+        x = i % w;
+        y = i / w;
+        dx = -1;
+        dy = 0;
+
+        /*
+         * Now begin tracing round the perimeter. At all
+         * times, (x,y) describes some square within the
+         * block, and (x+dx,y+dy) is some adjacent square
+         * outside it; so the edge between those two squares
+         * is always an edge of the block.
+         */
+        sx = x, sy = y, sdx = dx, sdy = dy;   /* save starting position */
+        n = 0;
+        do {
+            int cx, cy, tx, ty, nin;
+
+            /*
+             * Advance to the next edge, by looking at the two
+             * squares beyond it. If they're both outside the block,
+             * we turn right (by leaving x,y the same and rotating
+             * dx,dy clockwise); if they're both inside, we turn
+             * left (by rotating dx,dy anticlockwise and contriving
+             * to leave x+dx,y+dy unchanged); if one of each, we go
+             * straight on (and may enforce by assertion that
+             * they're one of each the _right_ way round).
+             */
+            nin = 0;
+            tx = x - dy + dx;
+            ty = y + dx + dy;
+            nin += (tx >= 0 && tx < w && ty >= 0 && ty < w &&
+                    dsf_canonify(dsf, ty*w+tx) == i);
+            tx = x - dy;
+            ty = y + dx;
+            nin += (tx >= 0 && tx < w && ty >= 0 && ty < w &&
+                    dsf_canonify(dsf, ty*w+tx) == i);
+            if (nin == 0) {
+                /*
+                 * Turn right.
+                 */
+                int tmp;
+                tmp = dx;
+                dx = -dy;
+                dy = tmp;
+            } else if (nin == 2) {
+                /*
+                 * Turn left.
+                 */
+                int tmp;
+
+                x += dx;
+                y += dy;
+
+                tmp = dx;
+                dx = dy;
+                dy = -tmp;
+
+                x -= dx;
+                y -= dy;
+            } else {
+                /*
+                 * Go straight on.
+                 */
+                x -= dy;
+                y += dx;
+            }
+
+            /*
+             * Now enforce by assertion that we ended up
+             * somewhere sensible.
+             */
+            assert(x >= 0 && x < w && y >= 0 && y < w &&
+                   dsf_canonify(dsf, y*w+x) == i);
+            assert(x+dx < 0 || x+dx >= w || y+dy < 0 || y+dy >= w ||
+                   dsf_canonify(dsf, (y+dy)*w+(x+dx)) != i);
+
+            /*
+             * Record the point we just went past at one end of the
+             * edge. To do this, we translate (x,y) down and right
+             * by half a unit (so they're describing a point in the
+             * _centre_ of the square) and then translate back again
+             * in a manner rotated by dy and dx.
+             */
+            assert(n < 2*w+2);
+            cx = ((2*x+1) + dy + dx) / 2;
+            cy = ((2*y+1) - dx + dy) / 2;
+            coords[2*n+0] = BORDER + cx * TILESIZE;
+            coords[2*n+1] = BORDER + cy * TILESIZE;
+            n++;
+
+        } while (x != sx || y != sy || dx != sdx || dy != sdy);
+
+        /*
+         * That's our polygon; now draw it.
+         */
+        draw_polygon(dr, coords, n, -1, ink);
+    }
+
+    sfree(coords);
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->par.w;
+    int ink = print_mono_colour(dr, 0);
+    int x, y;
+    char *minus_sign, *times_sign, *divide_sign;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    minus_sign = text_fallback(dr, minus_signs, lenof(minus_signs));
+    times_sign = text_fallback(dr, times_signs, lenof(times_signs));
+    divide_sign = text_fallback(dr, divide_signs, lenof(divide_signs));
+
+    /*
+     * Border.
+     */
+    print_line_width(dr, 3 * TILESIZE / 40);
+    draw_rect_outline(dr, BORDER, BORDER, w*TILESIZE, w*TILESIZE, ink);
+
+    /*
+     * Main grid.
+     */
+    for (x = 1; x < w; x++) {
+        print_line_width(dr, TILESIZE / 40);
+        draw_line(dr, BORDER+x*TILESIZE, BORDER,
+                  BORDER+x*TILESIZE, BORDER+w*TILESIZE, ink);
+    }
+    for (y = 1; y < w; y++) {
+        print_line_width(dr, TILESIZE / 40);
+        draw_line(dr, BORDER, BORDER+y*TILESIZE,
+                  BORDER+w*TILESIZE, BORDER+y*TILESIZE, ink);
+    }
+
+    /*
+     * Thick lines between cells.
+     */
+    print_line_width(dr, 3 * TILESIZE / 40);
+    outline_block_structure(dr, ds, w, state->clues->dsf, ink);
+
+    /*
+     * Clues.
+     */
+    for (y = 0; y < w; y++)
+        for (x = 0; x < w; x++)
+            if (dsf_canonify(state->clues->dsf, y*w+x) == y*w+x) {
+                long clue = state->clues->clues[y*w+x];
+                long cluetype = clue & CMASK, clueval = clue & ~CMASK;
+                int size = dsf_size(state->clues->dsf, y*w+x);
+                char str[64];
+
+                /*
+                 * As in the drawing code, we omit the operator for
+                 * blocks of area 1.
+                 */
+                sprintf (str, "%ld%s", clueval,
+                         (size == 1 ? "" :
+                          cluetype == C_ADD ? "+" :
+                          cluetype == C_SUB ? minus_sign :
+                          cluetype == C_MUL ? times_sign :
+                          /* cluetype == C_DIV ? */ divide_sign));
+
+                draw_text(dr,
+                          BORDER+x*TILESIZE + 5*TILESIZE/80,
+                          BORDER+y*TILESIZE + 20*TILESIZE/80,
+                          FONT_VARIABLE, TILESIZE/4,
+                          ALIGN_VNORMAL | ALIGN_HLEFT,
+                          ink, str);
+            }
+
+    /*
+     * Numbers for the solution, if any.
+     */
+    for (y = 0; y < w; y++)
+        for (x = 0; x < w; x++)
+            if (state->grid[y*w+x]) {
+                char str[2];
+                str[1] = '\0';
+                str[0] = state->grid[y*w+x] + '0';
+                draw_text(dr, BORDER + x*TILESIZE + TILESIZE/2,
+                          BORDER + y*TILESIZE + TILESIZE/2,
+                          FONT_VARIABLE, TILESIZE/2,
+                          ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str);
+            }
+
+    sfree(minus_sign);
+    sfree(times_sign);
+    sfree(divide_sign);
+}
+
+#ifdef COMBINED
+#define thegame keen
+#endif
+
+const struct game thegame = {
+    "Keen", "games.keen", "keen",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON | REQUIRE_NUMPAD,  /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+#include <stdarg.h>
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err;
+    int grade = FALSE;
+    int ret, diff, really_show_working = FALSE;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            really_show_working = TRUE;
+        } else if (!strcmp(p, "-g")) {
+            grade = TRUE;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-g | -v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    /*
+     * When solving an Easy puzzle, we don't want to bother the
+     * user with Hard-level deductions. For this reason, we grade
+     * the puzzle internally before doing anything else.
+     */
+    ret = -1;                          /* placate optimiser */
+    solver_show_working = FALSE;
+    for (diff = 0; diff < DIFFCOUNT; diff++) {
+        memset(s->grid, 0, p->w * p->w);
+        ret = solver(p->w, s->clues->dsf, s->clues->clues,
+                     s->grid, diff);
+        if (ret <= diff)
+            break;
+    }
+
+    if (diff == DIFFCOUNT) {
+        if (grade)
+            printf("Difficulty rating: ambiguous\n");
+        else
+            printf("Unable to find a unique solution\n");
+    } else {
+        if (grade) {
+            if (ret == diff_impossible)
+                printf("Difficulty rating: impossible (no solution exists)\n");
+            else
+                printf("Difficulty rating: %s\n", keen_diffnames[ret]);
+        } else {
+            solver_show_working = really_show_working;
+            memset(s->grid, 0, p->w * p->w);
+            ret = solver(p->w, s->clues->dsf, s->clues->clues,
+                         s->grid, diff);
+            if (ret != diff)
+                printf("Puzzle is inconsistent\n");
+            else {
+                /*
+                 * We don't have a game_text_format for this game,
+                 * so we have to output the solution manually.
+                 */
+                int x, y;
+                for (y = 0; y < p->w; y++) {
+                    for (x = 0; x < p->w; x++) {
+                        printf("%s%c", x>0?" ":"", '0' + s->grid[y*p->w+x]);
+                    }
+                    putchar('\n');
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/keymaps.h b/apps/plugins/puzzles/keymaps.h
new file mode 100644
index 0000000000..651ecca250
--- /dev/null
+++ b/apps/plugins/puzzles/keymaps.h
@@ -0,0 +1,206 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2014 Franklin Wei, Benjamin Brown
+ *
+ * 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#ifndef _XWORLD_KEYMAPS_H
+#define _XWORLD_KEYMAPS_H
+
+/* Handle the "nice" targets that have directional buttons with normal names */
+#if (CONFIG_KEYPAD == PHILIPS_HDD1630_PAD)  || \
+    (CONFIG_KEYPAD == PHILIPS_HDD6330_PAD)  || \
+    (CONFIG_KEYPAD == PHILIPS_SA9200_PAD)   || \
+    (CONFIG_KEYPAD == CREATIVE_ZENXFI2_PAD) || \
+    (CONFIG_KEYPAD == CREATIVE_ZENXFI3_PAD) || \
+    (CONFIG_KEYPAD == SANSA_CONNECT_PAD)    || \
+    (CONFIG_KEYPAD == SANSA_C200_PAD)       || \
+    (CONFIG_KEYPAD == SANSA_CLIP_PAD)       || \
+    (CONFIG_KEYPAD == SANSA_E200_PAD)       || \
+    (CONFIG_KEYPAD == SANSA_FUZE_PAD)       || \
+    (CONFIG_KEYPAD == SANSA_FUZEPLUS_PAD)   || \
+    (CONFIG_KEYPAD == GIGABEAT_PAD)         || \
+    (CONFIG_KEYPAD == GIGABEAT_S_PAD)       || \
+    (CONFIG_KEYPAD == SAMSUNG_YH92X_PAD)    || \
+    (CONFIG_KEYPAD == SAMSUNG_YH820_PAD)    || \
+    (CONFIG_KEYPAD == IAUDIO_X5M5_PAD)      || \
+    (CONFIG_KEYPAD == CREATIVE_ZEN_PAD)     || \
+    (CONFIG_KEYPAD == SONY_NWZ_PAD)         || \
+    (CONFIG_KEYPAD == CREATIVEZVM_PAD)      || \
+    (CONFIG_KEYPAD == SAMSUNG_YPR0_PAD)     || \
+    (CONFIG_KEYPAD == IRIVER_H300_PAD)      || \
+    (CONFIG_KEYPAD == HM801_PAD)            || \
+    (CONFIG_KEYPAD == HM60X_PAD)
+#define BTN_UP         BUTTON_UP
+#define BTN_DOWN       BUTTON_DOWN
+#define BTN_LEFT       BUTTON_LEFT
+#define BTN_RIGHT      BUTTON_RIGHT
+
+#if (CONFIG_KEYPAD == SANSA_FUZEPLUS_PAD)
+#define BTN_UP_LEFT    BUTTON_BACK
+#define BTN_UP_RIGHT   BUTTON_PLAYPAUSE
+#define BTN_DOWN_LEFT  BUTTON_BOTTOMLEFT
+#define BTN_DOWN_RIGHT BUTTON_BOTTOMRIGHT
+#endif
+
+#if (CONFIG_KEYPAD == HM60X_PAD)
+#define BTN_FIRE       BUTTON_POWER
+#define BTN_PAUSE      BUTTON_SELECT
+#endif
+
+#if (CONFIG_KEYPAD == PHILIPS_HDD1630_PAD)  || \
+    (CONFIG_KEYPAD == PHILIPS_HDD6330_PAD)  || \
+    (CONFIG_KEYPAD == PHILIPS_SA9200_PAD)   || \
+    (CONFIG_KEYPAD == CREATIVE_ZENXFI2_PAD) || \
+    (CONFIG_KEYPAD == CREATIVE_ZENXFI3_PAD) || \
+    (CONFIG_KEYPAD == SANSA_CONNECT_PAD)    || \
+    (CONFIG_KEYPAD == SANSA_C200_PAD)       || \
+    (CONFIG_KEYPAD == SANSA_FUZEPLUS_PAD)   || \
+    (CONFIG_KEYPAD == ONDAVX747_PAD)
+#define BTN_FIRE       BUTTON_VOL_UP
+#define BTN_PAUSE      BUTTON_VOL_DOWN
+
+#elif (CONFIG_KEYPAD == SANSA_FUZE_PAD)
+#define BTN_FIRE       BUTTON_HOME
+#define BTN_PAUSE      BUTTON_SELECT
+
+#elif (CONFIG_KEYPAD == SAMSUNG_YH92X_PAD)
+#define BTN_FIRE       BUTTON_FFWD
+#define BTN_PAUSE      BUTTON_REW
+
+#elif (CONFIG_KEYPAD == SANSA_E200_PAD)
+#define BTN_FIRE       BUTTON_REC
+#define BTN_PAUSE      BUTTON_POWER
+
+#elif (CONFIG_KEYPAD == SANSA_CLIP_PAD)
+#define BTN_FIRE       BUTTON_SELECT
+#define BTN_PAUSE      BUTTON_POWER
+
+#elif (CONFIG_KEYPAD == CREATIVE_ZEN_PAD)
+#define BTN_FIRE       BUTTON_SELECT
+#define BTN_PAUSE      BUTTON_BACK
+
+#elif (CONFIG_KEYPAD == CREATIVEZVM_PAD)
+#define BTN_FIRE       BUTTON_PLAY
+#define BTN_PAUSE      BUTTON_MENU
+
+#elif (CONFIG_KEYPAD == SAMSUNG_YPR0_PAD)
+#define BTN_FIRE       BUTTON_USER
+#define BTN_PAUSE      BUTTON_MENU
+
+#elif (CONFIG_KEYPAD == SONY_NWZ_PAD)
+#define BTN_FIRE       BUTTON_PLAY
+#define BTN_PAUSE      BUTTON_BACK
+
+#elif (CONFIG_KEYPAD == IRIVER_H300_PAD)
+#define BTN_FIRE       BUTTON_REC
+#define BTN_PAUSE      BUTTON_MODE
+
+#elif (CONFIG_KEYPAD == HM801_PAD)
+#define BTN_FIRE       BUTTON_PREV
+#define BTN_PAUSE      BUTTON_NEXT
+
+#elif (CONFIG_KEYPAD == SAMSUNG_YH820_PAD) || \
+      (CONFIG_KEYPAD == IAUDIO_X5M5_PAD)
+#define BTN_FIRE       BUTTON_REC
+#define BTN_PAUSE      BUTTON_PLAY
+
+#elif (CONFIG_KEYPAD == GIGABEAT_PAD)      || \
+      (CONFIG_KEYPAD == GIGABEAT_S_PAD)
+#define BTN_FIRE       BUTTON_VOL_UP
+#define BTN_PAUSE      BUTTON_MENU
+/* #if CONFIG_KEYPAD == PHILIPS_HDD1630_PAD */
+#endif
+
+/* ... and now for the bad ones that don't have
+ * standard names for the directional buttons */
+#elif (CONFIG_KEYPAD == PBELL_VIBE500_PAD)
+#define BTN_UP         BUTTON_OK
+#define BTN_DOWN       BUTTON_CANCEL
+#define BTN_LEFT       BUTTON_MENU
+#define BTN_RIGHT      BUTTON_PLAY
+#define BTN_FIRE       BUTTON_POWER
+#define BTN_PAUSE      BUTTON_REC
+
+#elif (CONFIG_KEYPAD == IRIVER_H10_PAD)
+#define BTN_UP         BUTTON_SCROLL_UP
+#define BTN_DOWN       BUTTON_SCROLL_DOWN
+#define BTN_LEFT       BUTTON_LEFT
+#define BTN_RIGHT      BUTTON_RIGHT
+#define BTN_FIRE       BUTTON_REW
+#define BTN_PAUSE      BUTTON_PLAY
+
+#elif (CONFIG_KEYPAD == MROBE500_PAD)
+#define BTN_FIRE      BUTTON_POWER
+
+#elif (CONFIG_KEYPAD == MROBE_REMOTE)
+#define BTN_UP         BUTTON_RC_PLAY
+#define BTN_DOWN       BUTTON_RC_DOWN
+#define BTN_LEFT       BUTTON_RC_REW
+#define BTN_RIGHT      BUTTON_RC_FF
+
+#elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
+      (CONFIG_KEYPAD == IPOD_3G_PAD) || \
+      (CONFIG_KEYPAD == IPOD_1G2G_PAD)
+#define BTN_UP         BUTTON_MENU
+#define BTN_DOWN       BUTTON_PLAY
+#define BTN_LEFT       BUTTON_LEFT
+#define BTN_RIGHT      BUTTON_RIGHT
+#define BTN_FIRE       BUTTON_SELECT
+#define BTN_PAUSE      (BUTTON_MENU | BUTTON_SELECT)
+
+#elif (CONFIG_KEYPAD == ONDAVX777_PAD)
+#define BTN_FIRE       BUTTON_POWER
+
+#elif (CONFIG_KEYPAD == COWON_D2_PAD)
+#define BTN_FIRE       BUTTON_PLUS
+#define BTN_PAUSE      BUTTON_MINUS
+
+#elif (CONFIG_KEYPAD == ONDAVX747_PAD) || \
+      (CONFIG_KEYPAD == DX50_PAD)
+#define BTN_LEFT       BUTTON_LEFT
+#define BTN_RIGHT      BUTTON_RIGHT
+#define BTN_FIRE       BUTTON_BOTTOMLEFT
+#define BTN_PAUSE      BUTTON_TOPLEFT
+
+#else
+#error Unsupported keypad
+#endif
+
+#ifdef HAVE_TOUCHSCREEN
+#define BTN_UP         BUTTON_TOPMIDDLE
+#define BTN_DOWN       BUTTON_BOTTOMMIDDLE
+#define BTN_LEFT       BUTTON_LEFT
+#define BTN_RIGHT      BUTTON_RIGHT
+
+#if (CONFIG_KEYPAD == MROBE500_PAD) || \
+    (CONFIG_KEYPAD == ONDAVX777_PAD)
+#define BTN_PAUSE      BUTTON_BOTTOMLEFT
+
+#elif (CONFIG_KEYPAD != COWON_D2_PAD) && \
+      (CONFIG_KEYPAD != DX50_PAD)     && \
+      (CONFIG_KEYPAD != ONDAVX777_PAD)
+#define BTN_FIRE       BUTTON_BOTTOMLEFT
+#define BTN_PAUSE      BUTTON_TOPLEFT
+#endif
+
+/* HAVE_TOUCHSCREEN */
+#endif
+
+/* _XWORLD_KEYMAPS_H */
+#endif
diff --git a/apps/plugins/puzzles/latin.c b/apps/plugins/puzzles/latin.c
new file mode 100644
index 0000000000..f7e97a7fa6
--- /dev/null
+++ b/apps/plugins/puzzles/latin.c
@@ -0,0 +1,1436 @@
+#include "rbassert.h"
+#include <string.h>
+#include <stdarg.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+#include "maxflow.h"
+
+#ifdef STANDALONE_LATIN_TEST
+#define STANDALONE_SOLVER
+#endif
+
+#include "latin.h"
+
+/* --------------------------------------------------------
+ * Solver.
+ */
+
+static int latin_solver_top(struct latin_solver *solver, int maxdiff,
+                            int diff_simple, int diff_set_0, int diff_set_1,
+                            int diff_forcing, int diff_recursive,
+                            usersolver_t const *usersolvers, void *ctx,
+                            ctxnew_t ctxnew, ctxfree_t ctxfree);
+
+#ifdef STANDALONE_SOLVER
+int solver_show_working, solver_recurse_depth;
+#endif
+
+/*
+ * Function called when we are certain that a particular square has
+ * a particular number in it. The y-coordinate passed in here is
+ * transformed.
+ */
+void latin_solver_place(struct latin_solver *solver, int x, int y, int n)
+{
+    int i, o = solver->o;
+
+    assert(n <= o);
+    assert(cube(x,y,n));
+
+    /*
+     * Rule out all other numbers in this square.
+     */
+    for (i = 1; i <= o; i++)
+        if (i != n)
+            cube(x,y,i) = FALSE;
+
+    /*
+     * Rule out this number in all other positions in the row.
+     */
+    for (i = 0; i < o; i++)
+        if (i != y)
+            cube(x,i,n) = FALSE;
+
+    /*
+     * Rule out this number in all other positions in the column.
+     */
+    for (i = 0; i < o; i++)
+        if (i != x)
+            cube(i,y,n) = FALSE;
+
+    /*
+     * Enter the number in the result grid.
+     */
+    solver->grid[y*o+x] = n;
+
+    /*
+     * Cross out this number from the list of numbers left to place
+     * in its row, its column and its block.
+     */
+    solver->row[y*o+n-1] = solver->col[x*o+n-1] = TRUE;
+}
+
+int latin_solver_elim(struct latin_solver *solver, int start, int step
+#ifdef STANDALONE_SOLVER
+                      , char *fmt, ...
+#endif
+                      )
+{
+    int o = solver->o;
+#ifdef STANDALONE_SOLVER
+    char **names = solver->names;
+#endif
+    int fpos, m, i;
+
+    /*
+     * Count the number of set bits within this section of the
+     * cube.
+     */
+    m = 0;
+    fpos = -1;
+    for (i = 0; i < o; i++)
+        if (solver->cube[start+i*step]) {
+            fpos = start+i*step;
+            m++;
+        }
+
+    if (m == 1) {
+        int x, y, n;
+        assert(fpos >= 0);
+
+        n = 1 + fpos % o;
+        y = fpos / o;
+        x = y / o;
+        y %= o;
+
+        if (!solver->grid[y*o+x]) {
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working) {
+                va_list ap;
+                printf("%*s", solver_recurse_depth*4, "");
+                va_start(ap, fmt);
+                vprintf(fmt, ap);
+                va_end(ap);
+                printf(":\n%*s  placing %s at (%d,%d)\n",
+                       solver_recurse_depth*4, "", names[n-1],
+                       x+1, y+1);
+            }
+#endif
+            latin_solver_place(solver, x, y, n);
+            return +1;
+        }
+    } else if (m == 0) {
+#ifdef STANDALONE_SOLVER
+        if (solver_show_working) {
+            va_list ap;
+            printf("%*s", solver_recurse_depth*4, "");
+            va_start(ap, fmt);
+            vprintf(fmt, ap);
+            va_end(ap);
+            printf(":\n%*s  no possibilities available\n",
+                   solver_recurse_depth*4, "");
+        }
+#endif
+        return -1;
+    }
+
+    return 0;
+}
+
+struct latin_solver_scratch {
+    unsigned char *grid, *rowidx, *colidx, *set;
+    int *neighbours, *bfsqueue;
+#ifdef STANDALONE_SOLVER
+    int *bfsprev;
+#endif
+};
+
+int latin_solver_set(struct latin_solver *solver,
+                     struct latin_solver_scratch *scratch,
+                     int start, int step1, int step2
+#ifdef STANDALONE_SOLVER
+                     , char *fmt, ...
+#endif
+                     )
+{
+    int o = solver->o;
+#ifdef STANDALONE_SOLVER
+    char **names = solver->names;
+#endif
+    int i, j, n, count;
+    unsigned char *grid = scratch->grid;
+    unsigned char *rowidx = scratch->rowidx;
+    unsigned char *colidx = scratch->colidx;
+    unsigned char *set = scratch->set;
+
+    /*
+     * We are passed a o-by-o matrix of booleans. Our first job
+     * is to winnow it by finding any definite placements - i.e.
+     * any row with a solitary 1 - and discarding that row and the
+     * column containing the 1.
+     */
+    memset(rowidx, TRUE, o);
+    memset(colidx, TRUE, o);
+    for (i = 0; i < o; i++) {
+        int count = 0, first = -1;
+        for (j = 0; j < o; j++)
+            if (solver->cube[start+i*step1+j*step2])
+                first = j, count++;
+
+        if (count == 0) return -1;
+        if (count == 1)
+            rowidx[i] = colidx[first] = FALSE;
+    }
+
+    /*
+     * Convert each of rowidx/colidx from a list of 0s and 1s to a
+     * list of the indices of the 1s.
+     */
+    for (i = j = 0; i < o; i++)
+        if (rowidx[i])
+            rowidx[j++] = i;
+    n = j;
+    for (i = j = 0; i < o; i++)
+        if (colidx[i])
+            colidx[j++] = i;
+    assert(n == j);
+
+    /*
+     * And create the smaller matrix.
+     */
+    for (i = 0; i < n; i++)
+        for (j = 0; j < n; j++)
+            grid[i*o+j] = solver->cube[start+rowidx[i]*step1+colidx[j]*step2];
+
+    /*
+     * Having done that, we now have a matrix in which every row
+     * has at least two 1s in. Now we search to see if we can find
+     * a rectangle of zeroes (in the set-theoretic sense of
+     * `rectangle', i.e. a subset of rows crossed with a subset of
+     * columns) whose width and height add up to n.
+     */
+
+    memset(set, 0, n);
+    count = 0;
+    while (1) {
+        /*
+         * We have a candidate set. If its size is <=1 or >=n-1
+         * then we move on immediately.
+         */
+        if (count > 1 && count < n-1) {
+            /*
+             * The number of rows we need is n-count. See if we can
+             * find that many rows which each have a zero in all
+             * the positions listed in `set'.
+             */
+            int rows = 0;
+            for (i = 0; i < n; i++) {
+                int ok = TRUE;
+                for (j = 0; j < n; j++)
+                    if (set[j] && grid[i*o+j]) {
+                        ok = FALSE;
+                        break;
+                    }
+                if (ok)
+                    rows++;
+            }
+
+            /*
+             * We expect never to be able to get _more_ than
+             * n-count suitable rows: this would imply that (for
+             * example) there are four numbers which between them
+             * have at most three possible positions, and hence it
+             * indicates a faulty deduction before this point or
+             * even a bogus clue.
+             */
+            if (rows > n - count) {
+#ifdef STANDALONE_SOLVER
+                if (solver_show_working) {
+                    va_list ap;
+                    printf("%*s", solver_recurse_depth*4,
+                           "");
+                    va_start(ap, fmt);
+                    vprintf(fmt, ap);
+                    va_end(ap);
+                    printf(":\n%*s  contradiction reached\n",
+                           solver_recurse_depth*4, "");
+                }
+#endif
+                return -1;
+            }
+
+            if (rows >= n - count) {
+                int progress = FALSE;
+
+                /*
+                 * We've got one! Now, for each row which _doesn't_
+                 * satisfy the criterion, eliminate all its set
+                 * bits in the positions _not_ listed in `set'.
+                 * Return +1 (meaning progress has been made) if we
+                 * successfully eliminated anything at all.
+                 *
+                 * This involves referring back through
+                 * rowidx/colidx in order to work out which actual
+                 * positions in the cube to meddle with.
+                 */
+                for (i = 0; i < n; i++) {
+                    int ok = TRUE;
+                    for (j = 0; j < n; j++)
+                        if (set[j] && grid[i*o+j]) {
+                            ok = FALSE;
+                            break;
+                        }
+                    if (!ok) {
+                        for (j = 0; j < n; j++)
+                            if (!set[j] && grid[i*o+j]) {
+                                int fpos = (start+rowidx[i]*step1+
+                                            colidx[j]*step2);
+#ifdef STANDALONE_SOLVER
+                                if (solver_show_working) {
+                                    int px, py, pn;
+
+                                    if (!progress) {
+                                        va_list ap;
+                                        printf("%*s", solver_recurse_depth*4,
+                                               "");
+                                        va_start(ap, fmt);
+                                        vprintf(fmt, ap);
+                                        va_end(ap);
+                                        printf(":\n");
+                                    }
+
+                                    pn = 1 + fpos % o;
+                                    py = fpos / o;
+                                    px = py / o;
+                                    py %= o;
+
+                                    printf("%*s  ruling out %s at (%d,%d)\n",
+                                           solver_recurse_depth*4, "",
+                                           names[pn-1], px+1, py+1);
+                                }
+#endif
+                                progress = TRUE;
+                                solver->cube[fpos] = FALSE;
+                            }
+                    }
+                }
+
+                if (progress) {
+                    return +1;
+                }
+            }
+        }
+
+        /*
+         * Binary increment: change the rightmost 0 to a 1, and
+         * change all 1s to the right of it to 0s.
+         */
+        i = n;
+        while (i > 0 && set[i-1])
+            set[--i] = 0, count--;
+        if (i > 0)
+            set[--i] = 1, count++;
+        else
+            break;                     /* done */
+    }
+
+    return 0;
+}
+
+/*
+ * Look for forcing chains. A forcing chain is a path of
+ * pairwise-exclusive squares (i.e. each pair of adjacent squares
+ * in the path are in the same row, column or block) with the
+ * following properties:
+ *
+ *  (a) Each square on the path has precisely two possible numbers.
+ *
+ *  (b) Each pair of squares which are adjacent on the path share
+ *      at least one possible number in common.
+ *
+ *  (c) Each square in the middle of the path shares _both_ of its
+ *      numbers with at least one of its neighbours (not the same
+ *      one with both neighbours).
+ *
+ * These together imply that at least one of the possible number
+ * choices at one end of the path forces _all_ the rest of the
+ * numbers along the path. In order to make real use of this, we
+ * need further properties:
+ *
+ *  (c) Ruling out some number N from the square at one end
+ *      of the path forces the square at the other end to
+ *      take number N.
+ *
+ *  (d) The two end squares are both in line with some third
+ *      square.
+ *
+ *  (e) That third square currently has N as a possibility.
+ *
+ * If we can find all of that lot, we can deduce that at least one
+ * of the two ends of the forcing chain has number N, and that
+ * therefore the mutually adjacent third square does not.
+ *
+ * To find forcing chains, we're going to start a bfs at each
+ * suitable square, once for each of its two possible numbers.
+ */
+int latin_solver_forcing(struct latin_solver *solver,
+                         struct latin_solver_scratch *scratch)
+{
+    int o = solver->o;
+#ifdef STANDALONE_SOLVER
+    char **names = solver->names;
+#endif
+    int *bfsqueue = scratch->bfsqueue;
+#ifdef STANDALONE_SOLVER
+    int *bfsprev = scratch->bfsprev;
+#endif
+    unsigned char *number = scratch->grid;
+    int *neighbours = scratch->neighbours;
+    int x, y;
+
+    for (y = 0; y < o; y++)
+        for (x = 0; x < o; x++) {
+            int count, t, n;
+
+            /*
+             * If this square doesn't have exactly two candidate
+             * numbers, don't try it.
+             *
+             * In this loop we also sum the candidate numbers,
+             * which is a nasty hack to allow us to quickly find
+             * `the other one' (since we will shortly know there
+             * are exactly two).
+             */
+            for (count = t = 0, n = 1; n <= o; n++)
+                if (cube(x, y, n))
+                    count++, t += n;
+            if (count != 2)
+                continue;
+
+            /*
+             * Now attempt a bfs for each candidate.
+             */
+            for (n = 1; n <= o; n++)
+                if (cube(x, y, n)) {
+                    int orign, currn, head, tail;
+
+                    /*
+                     * Begin a bfs.
+                     */
+                    orign = n;
+
+                    memset(number, o+1, o*o);
+                    head = tail = 0;
+                    bfsqueue[tail++] = y*o+x;
+#ifdef STANDALONE_SOLVER
+                    bfsprev[y*o+x] = -1;
+#endif
+                    number[y*o+x] = t - n;
+
+                    while (head < tail) {
+                        int xx, yy, nneighbours, xt, yt, i;
+
+                        xx = bfsqueue[head++];
+                        yy = xx / o;
+                        xx %= o;
+
+                        currn = number[yy*o+xx];
+
+                        /*
+                         * Find neighbours of yy,xx.
+                         */
+                        nneighbours = 0;
+                        for (yt = 0; yt < o; yt++)
+                            neighbours[nneighbours++] = yt*o+xx;
+                        for (xt = 0; xt < o; xt++)
+                            neighbours[nneighbours++] = yy*o+xt;
+
+                        /*
+                         * Try visiting each of those neighbours.
+                         */
+                        for (i = 0; i < nneighbours; i++) {
+                            int cc, tt, nn;
+
+                            xt = neighbours[i] % o;
+                            yt = neighbours[i] / o;
+
+                            /*
+                             * We need this square to not be
+                             * already visited, and to include
+                             * currn as a possible number.
+                             */
+                            if (number[yt*o+xt] <= o)
+                                continue;
+                            if (!cube(xt, yt, currn))
+                                continue;
+
+                            /*
+                             * Don't visit _this_ square a second
+                             * time!
+                             */
+                            if (xt == xx && yt == yy)
+                                continue;
+
+                            /*
+                             * To continue with the bfs, we need
+                             * this square to have exactly two
+                             * possible numbers.
+                             */
+                            for (cc = tt = 0, nn = 1; nn <= o; nn++)
+                                if (cube(xt, yt, nn))
+                                    cc++, tt += nn;
+                            if (cc == 2) {
+                                bfsqueue[tail++] = yt*o+xt;
+#ifdef STANDALONE_SOLVER
+                                bfsprev[yt*o+xt] = yy*o+xx;
+#endif
+                                number[yt*o+xt] = tt - currn;
+                            }
+
+                            /*
+                             * One other possibility is that this
+                             * might be the square in which we can
+                             * make a real deduction: if it's
+                             * adjacent to x,y, and currn is equal
+                             * to the original number we ruled out.
+                             */
+                            if (currn == orign &&
+                                (xt == x || yt == y)) {
+#ifdef STANDALONE_SOLVER
+                                if (solver_show_working) {
+                                    char *sep = "";
+                                    int xl, yl;
+                                    printf("%*sforcing chain, %s at ends of ",
+                                           solver_recurse_depth*4, "",
+                                           names[orign-1]);
+                                    xl = xx;
+                                    yl = yy;
+                                    while (1) {
+                                        printf("%s(%d,%d)", sep, xl+1,
+                                               yl+1);
+                                        xl = bfsprev[yl*o+xl];
+                                        if (xl < 0)
+                                            break;
+                                        yl = xl / o;
+                                        xl %= o;
+                                        sep = "-";
+                                    }
+                                    printf("\n%*s  ruling out %s at (%d,%d)\n",
+                                           solver_recurse_depth*4, "",
+                                           names[orign-1],
+                                           xt+1, yt+1);
+                                }
+#endif
+                                cube(xt, yt, orign) = FALSE;
+                                return 1;
+                            }
+                        }
+                    }
+                }
+        }
+
+    return 0;
+}
+
+struct latin_solver_scratch *latin_solver_new_scratch(struct latin_solver *solver)
+{
+    struct latin_solver_scratch *scratch = snew(struct latin_solver_scratch);
+    int o = solver->o;
+    scratch->grid = snewn(o*o, unsigned char);
+    scratch->rowidx = snewn(o, unsigned char);
+    scratch->colidx = snewn(o, unsigned char);
+    scratch->set = snewn(o, unsigned char);
+    scratch->neighbours = snewn(3*o, int);
+    scratch->bfsqueue = snewn(o*o, int);
+#ifdef STANDALONE_SOLVER
+    scratch->bfsprev = snewn(o*o, int);
+#endif
+    return scratch;
+}
+
+void latin_solver_free_scratch(struct latin_solver_scratch *scratch)
+{
+#ifdef STANDALONE_SOLVER
+    sfree(scratch->bfsprev);
+#endif
+    sfree(scratch->bfsqueue);
+    sfree(scratch->neighbours);
+    sfree(scratch->set);
+    sfree(scratch->colidx);
+    sfree(scratch->rowidx);
+    sfree(scratch->grid);
+    sfree(scratch);
+}
+
+void latin_solver_alloc(struct latin_solver *solver, digit *grid, int o)
+{
+    int x, y;
+
+    solver->o = o;
+    solver->cube = snewn(o*o*o, unsigned char);
+    solver->grid = grid;                /* write straight back to the input */
+    memset(solver->cube, TRUE, o*o*o);
+
+    solver->row = snewn(o*o, unsigned char);
+    solver->col = snewn(o*o, unsigned char);
+    memset(solver->row, FALSE, o*o);
+    memset(solver->col, FALSE, o*o);
+
+    for (x = 0; x < o; x++)
+        for (y = 0; y < o; y++)
+            if (grid[y*o+x])
+                latin_solver_place(solver, x, y, grid[y*o+x]);
+
+#ifdef STANDALONE_SOLVER
+    solver->names = NULL;
+#endif
+}
+
+void latin_solver_free(struct latin_solver *solver)
+{
+    sfree(solver->cube);
+    sfree(solver->row);
+    sfree(solver->col);
+}
+
+int latin_solver_diff_simple(struct latin_solver *solver)
+{
+    int x, y, n, ret, o = solver->o;
+#ifdef STANDALONE_SOLVER
+    char **names = solver->names;
+#endif
+
+    /*
+     * Row-wise positional elimination.
+     */
+    for (y = 0; y < o; y++)
+        for (n = 1; n <= o; n++)
+            if (!solver->row[y*o+n-1]) {
+                ret = latin_solver_elim(solver, cubepos(0,y,n), o*o
+#ifdef STANDALONE_SOLVER
+                                        , "positional elimination,"
+                                        " %s in row %d", names[n-1],
+                                        y+1
+#endif
+                                        );
+                if (ret != 0) return ret;
+            }
+    /*
+     * Column-wise positional elimination.
+     */
+    for (x = 0; x < o; x++)
+        for (n = 1; n <= o; n++)
+            if (!solver->col[x*o+n-1]) {
+                ret = latin_solver_elim(solver, cubepos(x,0,n), o
+#ifdef STANDALONE_SOLVER
+                                        , "positional elimination,"
+                                        " %s in column %d", names[n-1], x+1
+#endif
+                                        );
+                if (ret != 0) return ret;
+            }
+
+    /*
+     * Numeric elimination.
+     */
+    for (x = 0; x < o; x++)
+        for (y = 0; y < o; y++)
+            if (!solver->grid[y*o+x]) {
+                ret = latin_solver_elim(solver, cubepos(x,y,1), 1
+#ifdef STANDALONE_SOLVER
+                                        , "numeric elimination at (%d,%d)",
+                                        x+1, y+1
+#endif
+                                        );
+                if (ret != 0) return ret;
+            }
+    return 0;
+}
+
+int latin_solver_diff_set(struct latin_solver *solver,
+                          struct latin_solver_scratch *scratch,
+                          int extreme)
+{
+    int x, y, n, ret, o = solver->o;
+#ifdef STANDALONE_SOLVER
+    char **names = solver->names;
+#endif
+
+    if (!extreme) {
+        /*
+         * Row-wise set elimination.
+         */
+        for (y = 0; y < o; y++) {
+            ret = latin_solver_set(solver, scratch, cubepos(0,y,1), o*o, 1
+#ifdef STANDALONE_SOLVER
+                                   , "set elimination, row %d", y+1
+#endif
+                                  );
+            if (ret != 0) return ret;
+        }
+        /*
+         * Column-wise set elimination.
+         */
+        for (x = 0; x < o; x++) {
+            ret = latin_solver_set(solver, scratch, cubepos(x,0,1), o, 1
+#ifdef STANDALONE_SOLVER
+                                   , "set elimination, column %d", x+1
+#endif
+                                  );
+            if (ret != 0) return ret;
+        }
+    } else {
+        /*
+         * Row-vs-column set elimination on a single number
+         * (much tricker for a human to do!)
+         */
+        for (n = 1; n <= o; n++) {
+            ret = latin_solver_set(solver, scratch, cubepos(0,0,n), o*o, o
+#ifdef STANDALONE_SOLVER
+                                   , "positional set elimination on %s",
+                                   names[n-1]
+#endif
+                                  );
+            if (ret != 0) return ret;
+        }
+    }
+    return 0;
+}
+
+/*
+ * Returns:
+ * 0 for 'didn't do anything' implying it was already solved.
+ * -1 for 'impossible' (no solution)
+ * 1 for 'single solution'
+ * >1 for 'multiple solutions' (you don't get to know how many, and
+ *     the first such solution found will be set.
+ *
+ * and this function may well assert if given an impossible board.
+ */
+static int latin_solver_recurse
+    (struct latin_solver *solver, int diff_simple, int diff_set_0,
+     int diff_set_1, int diff_forcing, int diff_recursive,
+     usersolver_t const *usersolvers, void *ctx,
+     ctxnew_t ctxnew, ctxfree_t ctxfree)
+{
+    int best, bestcount;
+    int o = solver->o, x, y, n;
+#ifdef STANDALONE_SOLVER
+    char **names = solver->names;
+#endif
+
+    best = -1;
+    bestcount = o+1;
+
+    for (y = 0; y < o; y++)
+        for (x = 0; x < o; x++)
+            if (!solver->grid[y*o+x]) {
+                int count;
+
+                /*
+                 * An unfilled square. Count the number of
+                 * possible digits in it.
+                 */
+                count = 0;
+                for (n = 1; n <= o; n++)
+                    if (cube(x,y,n))
+                        count++;
+
+                /*
+                 * We should have found any impossibilities
+                 * already, so this can safely be an assert.
+                 */
+                assert(count > 1);
+
+                if (count < bestcount) {
+                    bestcount = count;
+                    best = y*o+x;
+                }
+            }
+
+    if (best == -1)
+        /* we were complete already. */
+        return 0;
+    else {
+        int i, j;
+        digit *list, *ingrid, *outgrid;
+        int diff = diff_impossible;    /* no solution found yet */
+
+        /*
+         * Attempt recursion.
+         */
+        y = best / o;
+        x = best % o;
+
+        list = snewn(o, digit);
+        ingrid = snewn(o*o, digit);
+        outgrid = snewn(o*o, digit);
+        memcpy(ingrid, solver->grid, o*o);
+
+        /* Make a list of the possible digits. */
+        for (j = 0, n = 1; n <= o; n++)
+            if (cube(x,y,n))
+                list[j++] = n;
+
+#ifdef STANDALONE_SOLVER
+        if (solver_show_working) {
+            char *sep = "";
+            printf("%*srecursing on (%d,%d) [",
+                   solver_recurse_depth*4, "", x+1, y+1);
+            for (i = 0; i < j; i++) {
+                printf("%s%s", sep, names[list[i]-1]);
+                sep = " or ";
+            }
+            printf("]\n");
+        }
+#endif
+
+        /*
+         * And step along the list, recursing back into the
+         * main solver at every stage.
+         */
+        for (i = 0; i < j; i++) {
+            int ret;
+            void *newctx;
+            struct latin_solver subsolver;
+
+            memcpy(outgrid, ingrid, o*o);
+            outgrid[y*o+x] = list[i];
+
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working)
+                printf("%*sguessing %s at (%d,%d)\n",
+                       solver_recurse_depth*4, "", names[list[i]-1], x+1, y+1);
+            solver_recurse_depth++;
+#endif
+
+            if (ctxnew) {
+                newctx = ctxnew(ctx);
+            } else {
+                newctx = ctx;
+            }
+            latin_solver_alloc(&subsolver, outgrid, o);
+#ifdef STANDALONE_SOLVER
+            subsolver.names = solver->names;
+#endif
+            ret = latin_solver_top(&subsolver, diff_recursive,
+                                   diff_simple, diff_set_0, diff_set_1,
+                                   diff_forcing, diff_recursive,
+                                   usersolvers, newctx, ctxnew, ctxfree);
+            latin_solver_free(&subsolver);
+            if (ctxnew)
+                ctxfree(newctx);
+
+#ifdef STANDALONE_SOLVER
+            solver_recurse_depth--;
+            if (solver_show_working) {
+                printf("%*sretracting %s at (%d,%d)\n",
+                       solver_recurse_depth*4, "", names[list[i]-1], x+1, y+1);
+            }
+#endif
+            /* we recurse as deep as we can, so we should never find
+             * find ourselves giving up on a puzzle without declaring it
+             * impossible.  */
+            assert(ret != diff_unfinished);
+
+            /*
+             * If we have our first solution, copy it into the
+             * grid we will return.
+             */
+            if (diff == diff_impossible && ret != diff_impossible)
+                memcpy(solver->grid, outgrid, o*o);
+
+            if (ret == diff_ambiguous)
+                diff = diff_ambiguous;
+            else if (ret == diff_impossible)
+                /* do not change our return value */;
+            else {
+                /* the recursion turned up exactly one solution */
+                if (diff == diff_impossible)
+                    diff = diff_recursive;
+                else
+                    diff = diff_ambiguous;
+            }
+
+            /*
+             * As soon as we've found more than one solution,
+             * give up immediately.
+             */
+            if (diff == diff_ambiguous)
+                break;
+        }
+
+        sfree(outgrid);
+        sfree(ingrid);
+        sfree(list);
+
+        if (diff == diff_impossible)
+            return -1;
+        else if (diff == diff_ambiguous)
+            return 2;
+        else {
+            assert(diff == diff_recursive);
+            return 1;
+        }
+    }
+}
+
+static int latin_solver_top(struct latin_solver *solver, int maxdiff,
+                            int diff_simple, int diff_set_0, int diff_set_1,
+                            int diff_forcing, int diff_recursive,
+                            usersolver_t const *usersolvers, void *ctx,
+                            ctxnew_t ctxnew, ctxfree_t ctxfree)
+{
+    struct latin_solver_scratch *scratch = latin_solver_new_scratch(solver);
+    int ret, diff = diff_simple;
+
+    assert(maxdiff <= diff_recursive);
+    /*
+     * Now loop over the grid repeatedly trying all permitted modes
+     * of reasoning. The loop terminates if we complete an
+     * iteration without making any progress; we then return
+     * failure or success depending on whether the grid is full or
+     * not.
+     */
+    while (1) {
+        int i;
+
+        cont:
+
+        latin_solver_debug(solver->cube, solver->o);
+
+        for (i = 0; i <= maxdiff; i++) {
+            if (usersolvers[i])
+                ret = usersolvers[i](solver, ctx);
+            else
+                ret = 0;
+            if (ret == 0 && i == diff_simple)
+                ret = latin_solver_diff_simple(solver);
+            if (ret == 0 && i == diff_set_0)
+                ret = latin_solver_diff_set(solver, scratch, 0);
+            if (ret == 0 && i == diff_set_1)
+                ret = latin_solver_diff_set(solver, scratch, 1);
+            if (ret == 0 && i == diff_forcing)
+                ret = latin_solver_forcing(solver, scratch);
+
+            if (ret < 0) {
+                diff = diff_impossible;
+                goto got_result;
+            } else if (ret > 0) {
+                diff = max(diff, i);
+                goto cont;
+            }
+        }
+
+        /*
+         * If we reach here, we have made no deductions in this
+         * iteration, so the algorithm terminates.
+         */
+        break;
+    }
+
+    /*
+     * Last chance: if we haven't fully solved the puzzle yet, try
+     * recursing based on guesses for a particular square. We pick
+     * one of the most constrained empty squares we can find, which
+     * has the effect of pruning the search tree as much as
+     * possible.
+     */
+    if (maxdiff == diff_recursive) {
+        int nsol = latin_solver_recurse(solver,
+                                        diff_simple, diff_set_0, diff_set_1,
+                                        diff_forcing, diff_recursive,
+                                        usersolvers, ctx, ctxnew, ctxfree);
+        if (nsol < 0) diff = diff_impossible;
+        else if (nsol == 1) diff = diff_recursive;
+        else if (nsol > 1) diff = diff_ambiguous;
+        /* if nsol == 0 then we were complete anyway
+         * (and thus don't need to change diff) */
+    } else {
+        /*
+         * We're forbidden to use recursion, so we just see whether
+         * our grid is fully solved, and return diff_unfinished
+         * otherwise.
+         */
+        int x, y, o = solver->o;
+
+        for (y = 0; y < o; y++)
+            for (x = 0; x < o; x++)
+                if (!solver->grid[y*o+x])
+                    diff = diff_unfinished;
+    }
+
+    got_result:
+
+#ifdef STANDALONE_SOLVER
+    if (solver_show_working)
+        printf("%*s%s found\n",
+               solver_recurse_depth*4, "",
+               diff == diff_impossible ? "no solution (impossible)" :
+               diff == diff_unfinished ? "no solution (unfinished)" :
+               diff == diff_ambiguous ? "multiple solutions" :
+               "one solution");
+#endif
+
+    latin_solver_free_scratch(scratch);
+
+    return diff;
+}
+
+int latin_solver_main(struct latin_solver *solver, int maxdiff,
+                      int diff_simple, int diff_set_0, int diff_set_1,
+                      int diff_forcing, int diff_recursive,
+                      usersolver_t const *usersolvers, void *ctx,
+                      ctxnew_t ctxnew, ctxfree_t ctxfree)
+{
+    int diff;
+#ifdef STANDALONE_SOLVER
+    int o = solver->o;
+    char *text = NULL, **names = NULL;
+#endif
+
+#ifdef STANDALONE_SOLVER
+    if (!solver->names) {
+        char *p;
+        int i;
+
+        text = snewn(40 * o, char);
+        p = text;
+
+        solver->names = snewn(o, char *);
+
+        for (i = 0; i < o; i++) {
+            solver->names[i] = p;
+            p += 1 + sprintf(p, "%d", i+1);
+        }
+    }
+#endif
+
+    diff = latin_solver_top(solver, maxdiff,
+                            diff_simple, diff_set_0, diff_set_1,
+                            diff_forcing, diff_recursive,
+                            usersolvers, ctx, ctxnew, ctxfree);
+
+#ifdef STANDALONE_SOLVER
+    sfree(names);
+    sfree(text);
+#endif
+
+    return diff;
+}
+
+int latin_solver(digit *grid, int o, int maxdiff,
+                 int diff_simple, int diff_set_0, int diff_set_1,
+                 int diff_forcing, int diff_recursive,
+                 usersolver_t const *usersolvers, void *ctx,
+                 ctxnew_t ctxnew, ctxfree_t ctxfree)
+{
+    struct latin_solver solver;
+    int diff;
+
+    latin_solver_alloc(&solver, grid, o);
+    diff = latin_solver_main(&solver, maxdiff,
+                             diff_simple, diff_set_0, diff_set_1,
+                             diff_forcing, diff_recursive,
+                             usersolvers, ctx, ctxnew, ctxfree);
+    latin_solver_free(&solver);
+    return diff;
+}
+
+void latin_solver_debug(unsigned char *cube, int o)
+{
+#ifdef STANDALONE_SOLVER
+    if (solver_show_working > 1) {
+        struct latin_solver ls, *solver = &ls;
+        char *dbg;
+        int x, y, i, c = 0;
+
+        ls.cube = cube; ls.o = o; /* for cube() to work */
+
+        dbg = snewn(3*o*o*o, char);
+        for (y = 0; y < o; y++) {
+            for (x = 0; x < o; x++) {
+                for (i = 1; i <= o; i++) {
+                    if (cube(x,y,i))
+                        dbg[c++] = i + '0';
+                    else
+                        dbg[c++] = '.';
+                }
+                dbg[c++] = ' ';
+            }
+            dbg[c++] = '\n';
+        }
+        dbg[c++] = '\n';
+        dbg[c++] = '\0';
+
+        printf("%s", dbg);
+        sfree(dbg);
+    }
+#endif
+}
+
+void latin_debug(digit *sq, int o)
+{
+#ifdef STANDALONE_SOLVER
+    if (solver_show_working) {
+        int x, y;
+
+        for (y = 0; y < o; y++) {
+            for (x = 0; x < o; x++) {
+                printf("%2d ", sq[y*o+x]);
+            }
+            printf("\n");
+        }
+        printf("\n");
+    }
+#endif
+}
+
+/* --------------------------------------------------------
+ * Generation.
+ */
+
+digit *latin_generate(int o, random_state *rs)
+{
+    digit *sq;
+    int *edges, *backedges, *capacity, *flow;
+    void *scratch;
+    int ne, scratchsize;
+    int i, j, k;
+    digit *row, *col, *numinv, *num;
+
+    /*
+     * To efficiently generate a latin square in such a way that
+     * all possible squares are possible outputs from the function,
+     * we make use of a theorem which states that any r x n latin
+     * rectangle, with r < n, can be extended into an (r+1) x n
+     * latin rectangle. In other words, we can reliably generate a
+     * latin square row by row, by at every stage writing down any
+     * row at all which doesn't conflict with previous rows, and
+     * the theorem guarantees that we will never have to backtrack.
+     *
+     * To find a viable row at each stage, we can make use of the
+     * support functions in maxflow.c.
+     */
+
+    sq = snewn(o*o, digit);
+
+    /*
+     * In case this method of generation introduces a really subtle
+     * top-to-bottom directional bias, we'll generate the rows in
+     * random order.
+     */
+    row = snewn(o, digit);
+    col = snewn(o, digit);
+    numinv = snewn(o, digit);
+    num = snewn(o, digit);
+    for (i = 0; i < o; i++)
+        row[i] = i;
+    shuffle(row, i, sizeof(*row), rs);
+
+    /*
+     * Set up the infrastructure for the maxflow algorithm.
+     */
+    scratchsize = maxflow_scratch_size(o * 2 + 2);
+    scratch = smalloc(scratchsize);
+    backedges = snewn(o*o + 2*o, int);
+    edges = snewn((o*o + 2*o) * 2, int);
+    capacity = snewn(o*o + 2*o, int);
+    flow = snewn(o*o + 2*o, int);
+    /* Set up the edge array, and the initial capacities. */
+    ne = 0;
+    for (i = 0; i < o; i++) {
+        /* Each LHS vertex is connected to all RHS vertices. */
+        for (j = 0; j < o; j++) {
+            edges[ne*2] = i;
+            edges[ne*2+1] = j+o;
+            /* capacity for this edge is set later on */
+            ne++;
+        }
+    }
+    for (i = 0; i < o; i++) {
+        /* Each RHS vertex is connected to the distinguished sink vertex. */
+        edges[ne*2] = i+o;
+        edges[ne*2+1] = o*2+1;
+        capacity[ne] = 1;
+        ne++;
+    }
+    for (i = 0; i < o; i++) {
+        /* And the distinguished source vertex connects to each LHS vertex. */
+        edges[ne*2] = o*2;
+        edges[ne*2+1] = i;
+        capacity[ne] = 1;
+        ne++;
+    }
+    assert(ne == o*o + 2*o);
+    /* Now set up backedges. */
+    maxflow_setup_backedges(ne, edges, backedges);
+    
+    /*
+     * Now generate each row of the latin square.
+     */
+    for (i = 0; i < o; i++) {
+        /*
+         * To prevent maxflow from behaving deterministically, we
+         * separately permute the columns and the digits for the
+         * purposes of the algorithm, differently for every row.
+         */
+        for (j = 0; j < o; j++)
+            col[j] = num[j] = j;
+        shuffle(col, j, sizeof(*col), rs);
+        shuffle(num, j, sizeof(*num), rs);
+        /* We need the num permutation in both forward and inverse forms. */
+        for (j = 0; j < o; j++)
+            numinv[num[j]] = j;
+
+        /*
+         * Set up the capacities for the maxflow run, by examining
+         * the existing latin square.
+         */
+        for (j = 0; j < o*o; j++)
+            capacity[j] = 1;
+        for (j = 0; j < i; j++)
+            for (k = 0; k < o; k++) {
+                int n = num[sq[row[j]*o + col[k]] - 1];
+                capacity[k*o+n] = 0;
+            }
+
+        /*
+         * Run maxflow.
+         */
+        j = maxflow_with_scratch(scratch, o*2+2, 2*o, 2*o+1, ne,
+                                 edges, backedges, capacity, flow, NULL);
+        assert(j == o);   /* by the above theorem, this must have succeeded */
+
+        /*
+         * And examine the flow array to pick out the new row of
+         * the latin square.
+         */
+        for (j = 0; j < o; j++) {
+            for (k = 0; k < o; k++) {
+                if (flow[j*o+k])
+                    break;
+            }
+            assert(k < o);
+            sq[row[i]*o + col[j]] = numinv[k] + 1;
+        }
+    }
+
+    /*
+     * Done. Free our internal workspaces...
+     */
+    sfree(flow);
+    sfree(capacity);
+    sfree(edges);
+    sfree(backedges);
+    sfree(scratch);
+    sfree(numinv);
+    sfree(num);
+    sfree(col);
+    sfree(row);
+
+    /*
+     * ... and return our completed latin square.
+     */
+    return sq;
+}
+
+digit *latin_generate_rect(int w, int h, random_state *rs)
+{
+    int o = max(w, h), x, y;
+    digit *latin, *latin_rect;
+
+    latin = latin_generate(o, rs);
+    latin_rect = snewn(w*h, digit);
+
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            latin_rect[y*w + x] = latin[y*o + x];
+        }
+    }
+
+    sfree(latin);
+    return latin_rect;
+}
+
+/* --------------------------------------------------------
+ * Checking.
+ */
+
+typedef struct lcparams {
+    digit elt;
+    int count;
+} lcparams;
+
+static int latin_check_cmp(void *v1, void *v2)
+{
+    lcparams *lc1 = (lcparams *)v1;
+    lcparams *lc2 = (lcparams *)v2;
+
+    if (lc1->elt < lc2->elt) return -1;
+    if (lc1->elt > lc2->elt) return 1;
+    return 0;
+}
+
+#define ELT(sq,x,y) (sq[((y)*order)+(x)])
+
+/* returns non-zero if sq is not a latin square. */
+int latin_check(digit *sq, int order)
+{
+    tree234 *dict = newtree234(latin_check_cmp);
+    int c, r;
+    int ret = 0;
+    lcparams *lcp, lc, *aret;
+
+    /* Use a tree234 as a simple hash table, go through the square
+     * adding elements as we go or incrementing their counts. */
+    for (c = 0; c < order; c++) {
+        for (r = 0; r < order; r++) {
+            lc.elt = ELT(sq, c, r); lc.count = 0;
+            lcp = find234(dict, &lc, NULL);
+            if (!lcp) {
+                lcp = snew(lcparams);
+                lcp->elt = ELT(sq, c, r);
+                lcp->count = 1;
+                aret = add234(dict, lcp);
+                assert(aret == lcp);
+            } else {
+                lcp->count++;
+            }
+        }
+    }
+
+    /* There should be precisely 'order' letters in the alphabet,
+     * each occurring 'order' times (making the OxO tree) */
+    if (count234(dict) != order) ret = 1;
+    else {
+        for (c = 0; (lcp = index234(dict, c)) != NULL; c++) {
+            if (lcp->count != order) ret = 1;
+        }
+    }
+    for (c = 0; (lcp = index234(dict, c)) != NULL; c++)
+        sfree(lcp);
+    freetree234(dict);
+
+    return ret;
+}
+
+
+/* --------------------------------------------------------
+ * Testing (and printing).
+ */
+
+#ifdef STANDALONE_LATIN_TEST
+
+#include <stdio.h>
+#include <time.h>
+
+const char *quis;
+
+static void latin_print(digit *sq, int order)
+{
+    int x, y;
+
+    for (y = 0; y < order; y++) {
+        for (x = 0; x < order; x++) {
+            printf("%2u ", ELT(sq, x, y));
+        }
+        printf("\n");
+    }
+    printf("\n");
+}
+
+static void gen(int order, random_state *rs, int debug)
+{
+    digit *sq;
+
+    solver_show_working = debug;
+
+    sq = latin_generate(order, rs);
+    latin_print(sq, order);
+    if (latin_check(sq, order)) {
+        fprintf(stderr, "Square is not a latin square!");
+        exit(1);
+    }
+
+    sfree(sq);
+}
+
+void test_soak(int order, random_state *rs)
+{
+    digit *sq;
+    int n = 0;
+    time_t tt_start, tt_now, tt_last;
+
+    solver_show_working = 0;
+    tt_now = tt_start = time(NULL);
+
+    while(1) {
+        sq = latin_generate(order, rs);
+        sfree(sq);
+        n++;
+
+        tt_last = time(NULL);
+        if (tt_last > tt_now) {
+            tt_now = tt_last;
+            printf("%d total, %3.1f/s\n", n,
+                   (double)n / (double)(tt_now - tt_start));
+        }
+    }
+}
+
+void usage_exit(const char *msg)
+{
+    if (msg)
+        fprintf(stderr, "%s: %s\n", quis, msg);
+    fprintf(stderr, "Usage: %s [--seed SEED] --soak <params> | [game_id [game_id ...]]\n", quis);
+    exit(1);
+}
+
+int main(int argc, char *argv[])
+{
+    int i, soak = 0;
+    random_state *rs;
+    time_t seed = time(NULL);
+
+    quis = argv[0];
+    while (--argc > 0) {
+        const char *p = *++argv;
+        if (!strcmp(p, "--soak"))
+            soak = 1;
+        else if (!strcmp(p, "--seed")) {
+            if (argc == 0)
+                usage_exit("--seed needs an argument");
+            seed = (time_t)atoi(*++argv);
+            argc--;
+        } else if (*p == '-')
+                usage_exit("unrecognised option");
+        else
+            break; /* finished options */
+    }
+
+    rs = random_new((void*)&seed, sizeof(time_t));
+
+    if (soak == 1) {
+        if (argc != 1) usage_exit("only one argument for --soak");
+        test_soak(atoi(*argv), rs);
+    } else {
+        if (argc > 0) {
+            for (i = 0; i < argc; i++) {
+                gen(atoi(*argv++), rs, 1);
+            }
+        } else {
+            while (1) {
+                i = random_upto(rs, 20) + 1;
+                gen(i, rs, 0);
+            }
+        }
+    }
+    random_free(rs);
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/latin.h b/apps/plugins/puzzles/latin.h
new file mode 100644
index 0000000000..4b09f16ce1
--- /dev/null
+++ b/apps/plugins/puzzles/latin.h
@@ -0,0 +1,122 @@
+#ifndef LATIN_H
+#define LATIN_H
+
+#include "puzzles.h"
+
+typedef unsigned char digit;
+
+/* --- Solver structures, definitions --- */
+
+#ifdef STANDALONE_SOLVER
+extern int solver_show_working, solver_recurse_depth;
+#endif
+
+struct latin_solver {
+  int o;                /* order of latin square */
+  unsigned char *cube;  /* o^3, indexed by x, y, and digit:
+                           TRUE in that position indicates a possibility */
+  digit *grid;          /* o^2, indexed by x and y: for final deductions */
+
+  unsigned char *row;   /* o^2: row[y*cr+n-1] TRUE if n is in row y */
+  unsigned char *col;   /* o^2: col[x*cr+n-1] TRUE if n is in col x */
+
+#ifdef STANDALONE_SOLVER
+  char **names;         /* o: names[n-1] gives name of 'digit' n */
+#endif
+};
+#define cubepos(x,y,n) (((x)*solver->o+(y))*solver->o+(n)-1)
+#define cube(x,y,n) (solver->cube[cubepos(x,y,n)])
+
+#define gridpos(x,y) ((y)*solver->o+(x))
+#define grid(x,y) (solver->grid[gridpos(x,y)])
+
+
+/* --- Solver individual strategies --- */
+
+/* Place a value at a specific location. */
+void latin_solver_place(struct latin_solver *solver, int x, int y, int n);
+
+/* Positional elimination. */
+int latin_solver_elim(struct latin_solver *solver, int start, int step
+#ifdef STANDALONE_SOLVER
+                      , char *fmt, ...
+#endif
+                      );
+
+struct latin_solver_scratch; /* private to latin.c */
+/* Set elimination */
+int latin_solver_set(struct latin_solver *solver,
+                     struct latin_solver_scratch *scratch,
+                     int start, int step1, int step2
+#ifdef STANDALONE_SOLVER
+                     , char *fmt, ...
+#endif
+                     );
+
+/* Forcing chains */
+int latin_solver_forcing(struct latin_solver *solver,
+                         struct latin_solver_scratch *scratch);
+
+
+/* --- Solver allocation --- */
+
+/* Fills in (and allocates members for) a latin_solver struct.
+ * Will allocate members of snew, but not snew itself
+ * (allowing 'struct latin_solver' to be the first element in a larger
+ * struct, for example). */
+void latin_solver_alloc(struct latin_solver *solver, digit *grid, int o);
+void latin_solver_free(struct latin_solver *solver);
+
+/* Allocates scratch space (for _set and _forcing) */
+struct latin_solver_scratch *
+  latin_solver_new_scratch(struct latin_solver *solver);
+void latin_solver_free_scratch(struct latin_solver_scratch *scratch);
+
+
+/* --- Solver guts --- */
+
+/* Looped positional elimination */
+int latin_solver_diff_simple(struct latin_solver *solver);
+
+/* Looped set elimination; *extreme is set if it used
+ * the more difficult single-number elimination. */
+int latin_solver_diff_set(struct latin_solver *solver,
+                          struct latin_solver_scratch *scratch,
+                          int extreme);
+
+typedef int (*usersolver_t)(struct latin_solver *solver, void *ctx);
+typedef void *(*ctxnew_t)(void *ctx);
+typedef void (*ctxfree_t)(void *ctx);
+
+/* Individual puzzles should use their enumerations for their
+ * own difficulty levels, ensuring they don't clash with these. */
+enum { diff_impossible = 10, diff_ambiguous, diff_unfinished };
+
+/* Externally callable function that allocates and frees a latin_solver */
+int latin_solver(digit *grid, int o, int maxdiff,
+                 int diff_simple, int diff_set_0, int diff_set_1,
+                 int diff_forcing, int diff_recursive,
+                 usersolver_t const *usersolvers, void *ctx,
+                 ctxnew_t ctxnew, ctxfree_t ctxfree);
+
+/* Version you can call if you want to alloc and free latin_solver yourself */
+int latin_solver_main(struct latin_solver *solver, int maxdiff,
+                      int diff_simple, int diff_set_0, int diff_set_1,
+                      int diff_forcing, int diff_recursive,
+                      usersolver_t const *usersolvers, void *ctx,
+                      ctxnew_t ctxnew, ctxfree_t ctxfree);
+
+void latin_solver_debug(unsigned char *cube, int o);
+
+/* --- Generation and checking --- */
+
+digit *latin_generate(int o, random_state *rs);
+
+/* The order of the latin rectangle is max(w,h). */
+digit *latin_generate_rect(int w, int h, random_state *rs);
+
+int latin_check(digit *sq, int order); /* !0 => not a latin square */
+
+void latin_debug(digit *sq, int order);
+
+#endif
diff --git a/apps/plugins/puzzles/laydomino.c b/apps/plugins/puzzles/laydomino.c
new file mode 100644
index 0000000000..458027020b
--- /dev/null
+++ b/apps/plugins/puzzles/laydomino.c
@@ -0,0 +1,291 @@
+/*
+ * laydomino.c: code for performing a domino (2x1 tile) layout of
+ * a given area of code.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "rbassert.h"
+
+#include "puzzles.h"
+
+/*
+ * This function returns an array size w x h representing a grid:
+ * each grid[i] = j, where j is the other end of a 2x1 domino.
+ * If w*h is odd, one square will remain referring to itself.
+ */
+
+int *domino_layout(int w, int h, random_state *rs)
+{
+    int *grid, *grid2, *list;
+    int wh = w*h;
+
+    /*
+     * Allocate space in which to lay the grid out.
+     */
+    grid = snewn(wh, int);
+    grid2 = snewn(wh, int);
+    list = snewn(2*wh, int);
+
+    domino_layout_prealloc(w, h, rs, grid, grid2, list);
+
+    sfree(grid2);
+    sfree(list);
+
+    return grid;
+}
+
+/*
+ * As for domino_layout, but with preallocated buffers.
+ * grid and grid2 should be size w*h, and list size 2*w*h.
+ */
+void domino_layout_prealloc(int w, int h, random_state *rs,
+                            int *grid, int *grid2, int *list)
+{
+    int i, j, k, m, wh = w*h, todo, done;
+
+    /*
+     * To begin with, set grid[i] = i for all i to indicate
+     * that all squares are currently singletons. Later we'll
+     * set grid[i] to be the index of the other end of the
+     * domino on i.
+     */
+    for (i = 0; i < wh; i++)
+        grid[i] = i;
+
+    /*
+     * Now prepare a list of the possible domino locations. There
+     * are w*(h-1) possible vertical locations, and (w-1)*h
+     * horizontal ones, for a total of 2*wh - h - w.
+     *
+     * I'm going to denote the vertical domino placement with
+     * its top in square i as 2*i, and the horizontal one with
+     * its left half in square i as 2*i+1.
+     */
+    k = 0;
+    for (j = 0; j < h-1; j++)
+        for (i = 0; i < w; i++)
+            list[k++] = 2 * (j*w+i);   /* vertical positions */
+    for (j = 0; j < h; j++)
+        for (i = 0; i < w-1; i++)
+            list[k++] = 2 * (j*w+i) + 1;   /* horizontal positions */
+    assert(k == 2*wh - h - w);
+
+    /*
+     * Shuffle the list.
+     */
+    shuffle(list, k, sizeof(*list), rs);
+
+    /*
+     * Work down the shuffled list, placing a domino everywhere
+     * we can.
+     */
+    for (i = 0; i < k; i++) {
+        int horiz, xy, xy2;
+
+        horiz = list[i] % 2;
+        xy = list[i] / 2;
+        xy2 = xy + (horiz ? 1 : w);
+
+        if (grid[xy] == xy && grid[xy2] == xy2) {
+            /*
+             * We can place this domino. Do so.
+             */
+            grid[xy] = xy2;
+            grid[xy2] = xy;
+        }
+    }
+
+#ifdef GENERATION_DIAGNOSTICS
+    printf("generated initial layout\n");
+#endif
+
+    /*
+     * Now we've placed as many dominoes as we can immediately
+     * manage. There will be squares remaining, but they'll be
+     * singletons. So loop round and deal with the singletons
+     * two by two.
+     */
+    while (1) {
+#ifdef GENERATION_DIAGNOSTICS
+        for (j = 0; j < h; j++) {
+            for (i = 0; i < w; i++) {
+                int xy = j*w+i;
+                int v = grid[xy];
+                int c = (v == xy+1 ? '[' : v == xy-1 ? ']' :
+                         v == xy+w ? 'n' : v == xy-w ? 'U' : '.');
+                putchar(c);
+            }
+            putchar('\n');
+        }
+        putchar('\n');
+#endif
+
+        /*
+         * Our strategy is:
+         *
+         * First find a singleton square.
+         *
+         * Then breadth-first search out from the starting
+         * square. From that square (and any others we reach on
+         * the way), examine all four neighbours of the square.
+         * If one is an end of a domino, we move to the _other_
+         * end of that domino before looking at neighbours
+         * again. When we encounter another singleton on this
+         * search, stop.
+         *
+         * This will give us a path of adjacent squares such
+         * that all but the two ends are covered in dominoes.
+         * So we can now shuffle every domino on the path up by
+         * one.
+         *
+         * (Chessboard colours are mathematically important
+         * here: we always end up pairing each singleton with a
+         * singleton of the other colour. However, we never
+         * have to track this manually, since it's
+         * automatically taken care of by the fact that we
+         * always make an even number of orthogonal moves.)
+         */
+        k = 0;
+        for (j = 0; j < wh; j++) {
+            if (grid[j] == j) {
+                k++;
+                i = j;          /* start BFS here. */
+            }
+        }
+        if (k == (wh % 2))
+            break;              /* if area is even, we have no more singletons;
+                                   if area is odd, we have one singleton.
+                                   either way, we're done. */
+
+#ifdef GENERATION_DIAGNOSTICS
+        printf("starting b.f.s. at singleton %d\n", i);
+#endif
+        /*
+         * Set grid2 to -1 everywhere. It will hold our
+         * distance-from-start values, and also our
+         * backtracking data, during the b.f.s.
+         */
+        for (j = 0; j < wh; j++)
+            grid2[j] = -1;
+        grid2[i] = 0;              /* starting square has distance zero */
+
+        /*
+         * Start our to-do list of squares. It'll live in
+         * `list'; since the b.f.s can cover every square at
+         * most once there is no need for it to be circular.
+         * We'll just have two counters tracking the end of the
+         * list and the squares we've already dealt with.
+         */
+        done = 0;
+        todo = 1;
+        list[0] = i;
+
+        /*
+         * Now begin the b.f.s. loop.
+         */
+        while (done < todo) {
+            int d[4], nd, x, y;
+
+            i = list[done++];
+
+#ifdef GENERATION_DIAGNOSTICS
+            printf("b.f.s. iteration from %d\n", i);
+#endif
+            x = i % w;
+            y = i / w;
+            nd = 0;
+            if (x > 0)
+                d[nd++] = i - 1;
+            if (x+1 < w)
+                d[nd++] = i + 1;
+            if (y > 0)
+                d[nd++] = i - w;
+            if (y+1 < h)
+                d[nd++] = i + w;
+            /*
+             * To avoid directional bias, process the
+             * neighbours of this square in a random order.
+             */
+            shuffle(d, nd, sizeof(*d), rs);
+
+            for (j = 0; j < nd; j++) {
+                k = d[j];
+                if (grid[k] == k) {
+#ifdef GENERATION_DIAGNOSTICS
+                    printf("found neighbouring singleton %d\n", k);
+#endif
+                    grid2[k] = i;
+                    break;         /* found a target singleton! */
+                }
+
+                /*
+                 * We're moving through a domino here, so we
+                 * have two entries in grid2 to fill with
+                 * useful data. In grid[k] - the square
+                 * adjacent to where we came from - I'm going
+                 * to put the address _of_ the square we came
+                 * from. In the other end of the domino - the
+                 * square from which we will continue the
+                 * search - I'm going to put the distance.
+                 */
+                m = grid[k];
+
+                if (grid2[m] < 0 || grid2[m] > grid2[i]+1) {
+#ifdef GENERATION_DIAGNOSTICS
+                    printf("found neighbouring domino %d/%d\n", k, m);
+#endif
+                    grid2[m] = grid2[i]+1;
+                    grid2[k] = i;
+                    /*
+                     * And since we've now visited a new
+                     * domino, add m to the to-do list.
+                     */
+                    assert(todo < wh);
+                    list[todo++] = m;
+                }
+            }
+
+            if (j < nd) {
+                i = k;
+#ifdef GENERATION_DIAGNOSTICS
+                printf("terminating b.f.s. loop, i = %d\n", i);
+#endif
+                break;
+            }
+
+            i = -1;                /* just in case the loop terminates */
+        }
+
+        /*
+         * We expect this b.f.s. to have found us a target
+         * square.
+         */
+        assert(i >= 0);
+
+        /*
+         * Now we can follow the trail back to our starting
+         * singleton, re-laying dominoes as we go.
+         */
+        while (1) {
+            j = grid2[i];
+            assert(j >= 0 && j < wh);
+            k = grid[j];
+
+            grid[i] = j;
+            grid[j] = i;
+#ifdef GENERATION_DIAGNOSTICS
+            printf("filling in domino %d/%d (next %d)\n", i, j, k);
+#endif
+            if (j == k)
+                break;             /* we've reached the other singleton */
+            i = k;
+        }
+#ifdef GENERATION_DIAGNOSTICS
+        printf("fixup path completed\n");
+#endif
+    }
+}
+
+/* vim: set shiftwidth=4 :set textwidth=80: */
+
diff --git a/apps/plugins/puzzles/lightup.R b/apps/plugins/puzzles/lightup.R
new file mode 100644
index 0000000000..a474de815d
--- /dev/null
+++ b/apps/plugins/puzzles/lightup.R
@@ -0,0 +1,24 @@
+# -*- makefile -*-
+
+LIGHTUP_EXTRA = combi
+
+lightup  : [X] GTK COMMON lightup LIGHTUP_EXTRA lightup-icon|no-icon
+
+lightup  : [G] WINDOWS COMMON lightup LIGHTUP_EXTRA lightup.res|noicon.res
+
+lightupsolver : [U] lightup[STANDALONE_SOLVER] LIGHTUP_EXTRA STANDALONE
+lightupsolver : [C] lightup[STANDALONE_SOLVER] LIGHTUP_EXTRA STANDALONE
+
+ALL += lightup[COMBINED] LIGHTUP_EXTRA
+
+!begin am gtk
+GAMES += lightup
+!end
+
+!begin >list.c
+    A(lightup) \
+!end
+
+!begin >gamedesc.txt
+lightup:lightup.exe:Light Up:Light-bulb placing puzzle:Place bulbs to light up all the squares.
+!end
diff --git a/apps/plugins/puzzles/lightup.c b/apps/plugins/puzzles/lightup.c
new file mode 100644
index 0000000000..9ca37b19d2
--- /dev/null
+++ b/apps/plugins/puzzles/lightup.c
@@ -0,0 +1,2405 @@
+/*
+ * lightup.c: Implementation of the Nikoli game 'Light Up'.
+ *
+ * Possible future solver enhancements:
+ *
+ *  - In a situation where two clues are diagonally adjacent, you can
+ *    deduce bounds on the number of lights shared between them. For
+ *    instance, suppose a 3 clue is diagonally adjacent to a 1 clue:
+ *    of the two squares adjacent to both clues, at least one must be
+ *    a light (or the 3 would be unsatisfiable) and yet at most one
+ *    must be a light (or the 1 would be overcommitted), so in fact
+ *    _exactly_ one must be a light, and hence the other two squares
+ *    adjacent to the 3 must also be lights and the other two adjacent
+ *    to the 1 must not. Likewise if the 3 is replaced with a 2 but
+ *    one of its other two squares is known not to be a light, and so
+ *    on.
+ *
+ *  - In a situation where two clues are orthogonally separated (not
+ *    necessarily directly adjacent), you may be able to deduce
+ *    something about the squares that align with each other. For
+ *    instance, suppose two clues are vertically adjacent. Consider
+ *    the pair of squares A,B horizontally adjacent to the top clue,
+ *    and the pair C,D horizontally adjacent to the bottom clue.
+ *    Assuming no intervening obstacles, A and C align with each other
+ *    and hence at most one of them can be a light, and B and D
+ *    likewise, so we must have at most two lights between the four
+ *    squares. So if the clues indicate that there are at _least_ two
+ *    lights in those four squares because the top clue requires at
+ *    least one of AB to be a light and the bottom one requires at
+ *    least one of CD, then we can in fact deduce that there are
+ *    _exactly_ two lights between the four squares, and fill in the
+ *    other squares adjacent to each clue accordingly. For instance,
+ *    if both clues are 3s, then we instantly deduce that all four of
+ *    the squares _vertically_ adjacent to the two clues must be
+ *    lights. (For that to happen, of course, there'd also have to be
+ *    a black square in between the clues, so the two inner lights
+ *    don't light each other.)
+ *
+ *  - I haven't thought it through carefully, but there's always the
+ *    possibility that both of the above deductions are special cases
+ *    of some more general pattern which can be made computationally
+ *    feasible...
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+/*
+ * In standalone solver mode, `verbose' is a variable which can be
+ * set by command-line option; in debugging mode it's simply always
+ * true.
+ */
+#if defined STANDALONE_SOLVER
+#define SOLVER_DIAGNOSTICS
+int verbose = 0;
+#undef debug
+#define debug(x) printf x
+#elif defined SOLVER_DIAGNOSTICS
+#define verbose 2
+#endif
+
+/* --- Constants, structure definitions, etc. --- */
+
+#define PREFERRED_TILE_SIZE 32
+#define TILE_SIZE       (ds->tilesize)
+#define BORDER          (TILE_SIZE / 2)
+#define TILE_RADIUS     (ds->crad)
+
+#define COORD(x)  ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
+
+#define FLASH_TIME 0.30F
+
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_BLACK,                         /* black */
+    COL_LIGHT,                         /* white */
+    COL_LIT,                           /* yellow */
+    COL_ERROR,                         /* red */
+    COL_CURSOR,
+    NCOLOURS
+};
+
+enum { SYMM_NONE, SYMM_REF2, SYMM_ROT2, SYMM_REF4, SYMM_ROT4, SYMM_MAX };
+
+#define DIFFCOUNT 2
+
+struct game_params {
+    int w, h;
+    int blackpc;        /* %age of black squares */
+    int symm;
+    int difficulty;     /* 0 to DIFFCOUNT */
+};
+
+#define F_BLACK         1
+
+/* flags for black squares */
+#define F_NUMBERED      2       /* it has a number attached */
+#define F_NUMBERUSED    4       /* this number was useful for solving */
+
+/* flags for non-black squares */
+#define F_IMPOSSIBLE    8       /* can't put a light here */
+#define F_LIGHT         16
+
+#define F_MARK          32
+
+struct game_state {
+    int w, h, nlights;
+    int *lights;        /* For black squares, (optionally) the number
+                           of surrounding lights. For non-black squares,
+                           the number of times it's lit. size h*w*/
+    unsigned int *flags;        /* size h*w */
+    int completed, used_solve;
+};
+
+#define GRID(gs,grid,x,y) (gs->grid[(y)*((gs)->w) + (x)])
+
+/* A ll_data holds information about which lights would be lit by
+ * a particular grid location's light (or conversely, which locations
+ * could light a specific other location). */
+/* most things should consider this struct opaque. */
+typedef struct {
+    int ox,oy;
+    int minx, maxx, miny, maxy;
+    int include_origin;
+} ll_data;
+
+/* Macro that executes 'block' once per light in lld, including
+ * the origin if include_origin is specified. 'block' can use
+ * lx and ly as the coords. */
+#define FOREACHLIT(lld,block) do {                              \
+  int lx,ly;                                                    \
+  ly = (lld)->oy;                                               \
+  for (lx = (lld)->minx; lx <= (lld)->maxx; lx++) {             \
+    if (lx == (lld)->ox) continue;                              \
+    block                                                       \
+  }                                                             \
+  lx = (lld)->ox;                                               \
+  for (ly = (lld)->miny; ly <= (lld)->maxy; ly++) {             \
+    if (!(lld)->include_origin && ly == (lld)->oy) continue;    \
+    block                                                       \
+  }                                                             \
+} while(0)
+
+
+typedef struct {
+    struct { int x, y; unsigned int f; } points[4];
+    int npoints;
+} surrounds;
+
+/* Fills in (doesn't allocate) a surrounds structure with the grid locations
+ * around a given square, taking account of the edges. */
+static void get_surrounds(const game_state *state, int ox, int oy,
+                          surrounds *s)
+{
+    assert(ox >= 0 && ox < state->w && oy >= 0 && oy < state->h);
+    s->npoints = 0;
+#define ADDPOINT(cond,nx,ny) do {\
+    if (cond) { \
+        s->points[s->npoints].x = (nx); \
+        s->points[s->npoints].y = (ny); \
+        s->points[s->npoints].f = 0; \
+        s->npoints++; \
+    } } while(0)
+    ADDPOINT(ox > 0,            ox-1, oy);
+    ADDPOINT(ox < (state->w-1), ox+1, oy);
+    ADDPOINT(oy > 0,            ox,   oy-1);
+    ADDPOINT(oy < (state->h-1), ox,   oy+1);
+}
+
+/* --- Game parameter functions --- */
+
+#define DEFAULT_PRESET 0
+
+const struct game_params lightup_presets[] = {
+    { 7, 7, 20, SYMM_ROT4, 0 },
+    { 7, 7, 20, SYMM_ROT4, 1 },
+    { 7, 7, 20, SYMM_ROT4, 2 },
+    { 10, 10, 20, SYMM_ROT2, 0 },
+    { 10, 10, 20, SYMM_ROT2, 1 },
+#ifdef SLOW_SYSTEM
+    { 12, 12, 20, SYMM_ROT2, 0 },
+    { 12, 12, 20, SYMM_ROT2, 1 },
+#else
+    { 10, 10, 20, SYMM_ROT2, 2 },
+    { 14, 14, 20, SYMM_ROT2, 0 },
+    { 14, 14, 20, SYMM_ROT2, 1 },
+    { 14, 14, 20, SYMM_ROT2, 2 }
+#endif
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+    *ret = lightup_presets[DEFAULT_PRESET];
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(lightup_presets))
+        return FALSE;
+
+    ret = default_params();
+    *ret = lightup_presets[i];
+    *params = ret;
+
+    sprintf(buf, "%dx%d %s",
+            ret->w, ret->h,
+            ret->difficulty == 2 ? "hard" :
+            ret->difficulty == 1 ? "tricky" : "easy");
+    *name = dupstr(buf);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+#define EATNUM(x) do { \
+    (x) = atoi(string); \
+    while (*string && isdigit((unsigned char)*string)) string++; \
+} while(0)
+
+static void decode_params(game_params *params, char const *string)
+{
+    EATNUM(params->w);
+    if (*string == 'x') {
+        string++;
+        EATNUM(params->h);
+    }
+    if (*string == 'b') {
+        string++;
+        EATNUM(params->blackpc);
+    }
+    if (*string == 's') {
+        string++;
+        EATNUM(params->symm);
+    } else {
+        /* cope with user input such as '18x10' by ensuring symmetry
+         * is not selected by default to be incompatible with dimensions */
+        if (params->symm == SYMM_ROT4 && params->w != params->h)
+            params->symm = SYMM_ROT2;
+    }
+    params->difficulty = 0;
+    /* cope with old params */
+    if (*string == 'r') {
+        params->difficulty = 2;
+        string++;
+    }
+    if (*string == 'd') {
+        string++;
+        EATNUM(params->difficulty);
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[80];
+
+    if (full) {
+        sprintf(buf, "%dx%db%ds%dd%d",
+                params->w, params->h, params->blackpc,
+                params->symm,
+                params->difficulty);
+    } else {
+        sprintf(buf, "%dx%d", params->w, params->h);
+    }
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(6, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "%age of black squares";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->blackpc);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = "Symmetry";
+    ret[3].type = C_CHOICES;
+    ret[3].sval = ":None"
+                  ":2-way mirror:2-way rotational"
+                  ":4-way mirror:4-way rotational";
+    ret[3].ival = params->symm;
+
+    ret[4].name = "Difficulty";
+    ret[4].type = C_CHOICES;
+    ret[4].sval = ":Easy:Tricky:Hard";
+    ret[4].ival = params->difficulty;
+
+    ret[5].name = NULL;
+    ret[5].type = C_END;
+    ret[5].sval = NULL;
+    ret[5].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w =       atoi(cfg[0].sval);
+    ret->h =       atoi(cfg[1].sval);
+    ret->blackpc = atoi(cfg[2].sval);
+    ret->symm =    cfg[3].ival;
+    ret->difficulty = cfg[4].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 2 || params->h < 2)
+        return "Width and height must be at least 2";
+    if (full) {
+        if (params->blackpc < 5 || params->blackpc > 100)
+            return "Percentage of black squares must be between 5% and 100%";
+        if (params->w != params->h) {
+            if (params->symm == SYMM_ROT4)
+                return "4-fold symmetry is only available with square grids";
+        }
+        if (params->symm < 0 || params->symm >= SYMM_MAX)
+            return "Unknown symmetry type";
+        if (params->difficulty < 0 || params->difficulty > DIFFCOUNT)
+            return "Unknown difficulty level";
+    }
+    return NULL;
+}
+
+/* --- Game state construction/freeing helper functions --- */
+
+static game_state *new_state(const game_params *params)
+{
+    game_state *ret = snew(game_state);
+
+    ret->w = params->w;
+    ret->h = params->h;
+    ret->lights = snewn(ret->w * ret->h, int);
+    ret->nlights = 0;
+    memset(ret->lights, 0, ret->w * ret->h * sizeof(int));
+    ret->flags = snewn(ret->w * ret->h, unsigned int);
+    memset(ret->flags, 0, ret->w * ret->h * sizeof(unsigned int));
+    ret->completed = ret->used_solve = 0;
+    return ret;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->w = state->w;
+    ret->h = state->h;
+
+    ret->lights = snewn(ret->w * ret->h, int);
+    memcpy(ret->lights, state->lights, ret->w * ret->h * sizeof(int));
+    ret->nlights = state->nlights;
+
+    ret->flags = snewn(ret->w * ret->h, unsigned int);
+    memcpy(ret->flags, state->flags, ret->w * ret->h * sizeof(unsigned int));
+
+    ret->completed = state->completed;
+    ret->used_solve = state->used_solve;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->lights);
+    sfree(state->flags);
+    sfree(state);
+}
+
+static void debug_state(game_state *state)
+{
+    int x, y;
+    char c = '?';
+
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            c = '.';
+            if (GRID(state, flags, x, y) & F_BLACK) {
+                if (GRID(state, flags, x, y) & F_NUMBERED)
+                    c = GRID(state, lights, x, y) + '0';
+                else
+                    c = '#';
+            } else {
+                if (GRID(state, flags, x, y) & F_LIGHT)
+                    c = 'O';
+                else if (GRID(state, flags, x, y) & F_IMPOSSIBLE)
+                    c = 'X';
+            }
+            debug(("%c", (int)c));
+        }
+        debug(("     "));
+        for (x = 0; x < state->w; x++) {
+            if (GRID(state, flags, x, y) & F_BLACK)
+                c = '#';
+            else {
+                c = (GRID(state, flags, x, y) & F_LIGHT) ? 'A' : 'a';
+                c += GRID(state, lights, x, y);
+            }
+            debug(("%c", (int)c));
+        }
+        debug(("\n"));
+    }
+}
+
+/* --- Game completion test routines. --- */
+
+/* These are split up because occasionally functions are only
+ * interested in one particular aspect. */
+
+/* Returns non-zero if all grid spaces are lit. */
+static int grid_lit(game_state *state)
+{
+    int x, y;
+
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            if (GRID(state,flags,x,y) & F_BLACK) continue;
+            if (GRID(state,lights,x,y) == 0)
+                return 0;
+        }
+    }
+    return 1;
+}
+
+/* Returns non-zero if any lights are lit by other lights. */
+static int grid_overlap(game_state *state)
+{
+    int x, y;
+
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            if (!(GRID(state, flags, x, y) & F_LIGHT)) continue;
+            if (GRID(state, lights, x, y) > 1)
+                return 1;
+        }
+    }
+    return 0;
+}
+
+static int number_wrong(const game_state *state, int x, int y)
+{
+    surrounds s;
+    int i, n, empty, lights = GRID(state, lights, x, y);
+
+    /*
+     * This function computes the display hint for a number: we
+     * turn the number red if it is definitely wrong. This means
+     * that either
+     * 
+     *  (a) it has too many lights around it, or
+     *  (b) it would have too few lights around it even if all the
+     *      plausible squares (not black, lit or F_IMPOSSIBLE) were
+     *      filled with lights.
+     */
+
+    assert(GRID(state, flags, x, y) & F_NUMBERED);
+    get_surrounds(state, x, y, &s);
+
+    empty = n = 0;
+    for (i = 0; i < s.npoints; i++) {
+        if (GRID(state,flags,s.points[i].x,s.points[i].y) & F_LIGHT) {
+            n++;
+            continue;
+        }
+        if (GRID(state,flags,s.points[i].x,s.points[i].y) & F_BLACK)
+            continue;
+        if (GRID(state,flags,s.points[i].x,s.points[i].y) & F_IMPOSSIBLE)
+            continue;
+        if (GRID(state,lights,s.points[i].x,s.points[i].y))
+            continue;
+        empty++;
+    }
+    return (n > lights || (n + empty < lights));
+}
+
+static int number_correct(game_state *state, int x, int y)
+{
+    surrounds s;
+    int n = 0, i, lights = GRID(state, lights, x, y);
+
+    assert(GRID(state, flags, x, y) & F_NUMBERED);
+    get_surrounds(state, x, y, &s);
+    for (i = 0; i < s.npoints; i++) {
+        if (GRID(state,flags,s.points[i].x,s.points[i].y) & F_LIGHT)
+            n++;
+    }
+    return (n == lights) ? 1 : 0;
+}
+
+/* Returns non-zero if any numbers add up incorrectly. */
+static int grid_addsup(game_state *state)
+{
+    int x, y;
+
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            if (!(GRID(state, flags, x, y) & F_NUMBERED)) continue;
+            if (!number_correct(state, x, y)) return 0;
+        }
+    }
+    return 1;
+}
+
+static int grid_correct(game_state *state)
+{
+    if (grid_lit(state) &&
+        !grid_overlap(state) &&
+        grid_addsup(state)) return 1;
+    return 0;
+}
+
+/* --- Board initial setup (blacks, lights, numbers) --- */
+
+static void clean_board(game_state *state, int leave_blacks)
+{
+    int x,y;
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            if (leave_blacks)
+                GRID(state, flags, x, y) &= F_BLACK;
+            else
+                GRID(state, flags, x, y) = 0;
+            GRID(state, lights, x, y) = 0;
+        }
+    }
+    state->nlights = 0;
+}
+
+static void set_blacks(game_state *state, const game_params *params,
+                       random_state *rs)
+{
+    int x, y, degree = 0, rotate = 0, nblack;
+    int rh, rw, i;
+    int wodd = (state->w % 2) ? 1 : 0;
+    int hodd = (state->h % 2) ? 1 : 0;
+    int xs[4], ys[4];
+
+    switch (params->symm) {
+    case SYMM_NONE: degree = 1; rotate = 0; break;
+    case SYMM_ROT2: degree = 2; rotate = 1; break;
+    case SYMM_REF2: degree = 2; rotate = 0; break;
+    case SYMM_ROT4: degree = 4; rotate = 1; break;
+    case SYMM_REF4: degree = 4; rotate = 0; break;
+    default: assert(!"Unknown symmetry type");
+    }
+    if (params->symm == SYMM_ROT4 && (state->h != state->w))
+        assert(!"4-fold symmetry unavailable without square grid");
+
+    if (degree == 4) {
+        rw = state->w/2;
+        rh = state->h/2;
+        if (!rotate) rw += wodd; /* ... but see below. */
+        rh += hodd;
+    } else if (degree == 2) {
+        rw = state->w;
+        rh = state->h/2;
+        rh += hodd;
+    } else {
+        rw = state->w;
+        rh = state->h;
+    }
+
+    /* clear, then randomise, required region. */
+    clean_board(state, 0);
+    nblack = (rw * rh * params->blackpc) / 100;
+    for (i = 0; i < nblack; i++) {
+        do {
+            x = random_upto(rs,rw);
+            y = random_upto(rs,rh);
+        } while (GRID(state,flags,x,y) & F_BLACK);
+        GRID(state, flags, x, y) |= F_BLACK;
+    }
+
+    /* Copy required region. */
+    if (params->symm == SYMM_NONE) return;
+
+    for (x = 0; x < rw; x++) {
+        for (y = 0; y < rh; y++) {
+            if (degree == 4) {
+                xs[0] = x;
+                ys[0] = y;
+                xs[1] = state->w - 1 - (rotate ? y : x);
+                ys[1] = rotate ? x : y;
+                xs[2] = rotate ? (state->w - 1 - x) : x;
+                ys[2] = state->h - 1 - y;
+                xs[3] = rotate ? y : (state->w - 1 - x);
+                ys[3] = state->h - 1 - (rotate ? x : y);
+            } else {
+                xs[0] = x;
+                ys[0] = y;
+                xs[1] = rotate ? (state->w - 1 - x) : x;
+                ys[1] = state->h - 1 - y;
+            }
+            for (i = 1; i < degree; i++) {
+                GRID(state, flags, xs[i], ys[i]) =
+                    GRID(state, flags, xs[0], ys[0]);
+            }
+        }
+    }
+    /* SYMM_ROT4 misses the middle square above; fix that here. */
+    if (degree == 4 && rotate && wodd &&
+        (random_upto(rs,100) <= (unsigned int)params->blackpc))
+        GRID(state,flags,
+             state->w/2 + wodd - 1, state->h/2 + hodd - 1) |= F_BLACK;
+
+#ifdef SOLVER_DIAGNOSTICS
+    if (verbose) debug_state(state);
+#endif
+}
+
+/* Fills in (does not allocate) a ll_data with all the tiles that would
+ * be illuminated by a light at point (ox,oy). If origin=1 then the
+ * origin is included in this list. */
+static void list_lights(game_state *state, int ox, int oy, int origin,
+                        ll_data *lld)
+{
+    int x,y;
+
+    lld->ox = lld->minx = lld->maxx = ox;
+    lld->oy = lld->miny = lld->maxy = oy;
+    lld->include_origin = origin;
+
+    y = oy;
+    for (x = ox-1; x >= 0; x--) {
+        if (GRID(state, flags, x, y) & F_BLACK) break;
+        if (x < lld->minx) lld->minx = x;
+    }
+    for (x = ox+1; x < state->w; x++) {
+        if (GRID(state, flags, x, y) & F_BLACK) break;
+        if (x > lld->maxx) lld->maxx = x;
+    }
+
+    x = ox;
+    for (y = oy-1; y >= 0; y--) {
+        if (GRID(state, flags, x, y) & F_BLACK) break;
+        if (y < lld->miny) lld->miny = y;
+    }
+    for (y = oy+1; y < state->h; y++) {
+        if (GRID(state, flags, x, y) & F_BLACK) break;
+        if (y > lld->maxy) lld->maxy = y;
+    }
+}
+
+/* Makes sure a light is the given state, editing the lights table to suit the
+ * new state if necessary. */
+static void set_light(game_state *state, int ox, int oy, int on)
+{
+    ll_data lld;
+    int diff = 0;
+
+    assert(!(GRID(state,flags,ox,oy) & F_BLACK));
+
+    if (!on && GRID(state,flags,ox,oy) & F_LIGHT) {
+        diff = -1;
+        GRID(state,flags,ox,oy) &= ~F_LIGHT;
+        state->nlights--;
+    } else if (on && !(GRID(state,flags,ox,oy) & F_LIGHT)) {
+        diff = 1;
+        GRID(state,flags,ox,oy) |= F_LIGHT;
+        state->nlights++;
+    }
+
+    if (diff != 0) {
+        list_lights(state,ox,oy,1,&lld);
+        FOREACHLIT(&lld, GRID(state,lights,lx,ly) += diff; );
+    }
+}
+
+/* Returns 1 if removing a light at (x,y) would cause a square to go dark. */
+static int check_dark(game_state *state, int x, int y)
+{
+    ll_data lld;
+
+    list_lights(state, x, y, 1, &lld);
+    FOREACHLIT(&lld, if (GRID(state,lights,lx,ly) == 1) { return 1; } );
+    return 0;
+}
+
+/* Sets up an initial random correct position (i.e. every
+ * space lit, and no lights lit by other lights) by filling the
+ * grid with lights and then removing lights one by one at random. */
+static void place_lights(game_state *state, random_state *rs)
+{
+    int i, x, y, n, *numindices, wh = state->w*state->h;
+    ll_data lld;
+
+    numindices = snewn(wh, int);
+    for (i = 0; i < wh; i++) numindices[i] = i;
+    shuffle(numindices, wh, sizeof(*numindices), rs);
+
+    /* Place a light on all grid squares without lights. */
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            GRID(state, flags, x, y) &= ~F_MARK; /* we use this later. */
+            if (GRID(state, flags, x, y) & F_BLACK) continue;
+            set_light(state, x, y, 1);
+        }
+    }
+
+    for (i = 0; i < wh; i++) {
+        y = numindices[i] / state->w;
+        x = numindices[i] % state->w;
+        if (!(GRID(state, flags, x, y) & F_LIGHT)) continue;
+        if (GRID(state, flags, x, y) & F_MARK) continue;
+        list_lights(state, x, y, 0, &lld);
+
+        /* If we're not lighting any lights ourself, don't remove anything. */
+        n = 0;
+        FOREACHLIT(&lld, if (GRID(state,flags,lx,ly) & F_LIGHT) { n += 1; } );
+        if (n == 0) continue; /* [1] */
+
+        /* Check whether removing lights we're lighting would cause anything
+         * to go dark. */
+        n = 0;
+        FOREACHLIT(&lld, if (GRID(state,flags,lx,ly) & F_LIGHT) { n += check_dark(state,lx,ly); } );
+        if (n == 0) {
+            /* No, it wouldn't, so we can remove them all. */
+            FOREACHLIT(&lld, set_light(state,lx,ly, 0); );
+            GRID(state,flags,x,y) |= F_MARK;
+        }
+
+        if (!grid_overlap(state)) {
+            sfree(numindices);
+            return; /* we're done. */
+        }
+        assert(grid_lit(state));
+    }
+    /* could get here if the line at [1] continue'd out of the loop. */
+    if (grid_overlap(state)) {
+        debug_state(state);
+        assert(!"place_lights failed to resolve overlapping lights!");
+    }
+    sfree(numindices);
+}
+
+/* Fills in all black squares with numbers of adjacent lights. */
+static void place_numbers(game_state *state)
+{
+    int x, y, i, n;
+    surrounds s;
+
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            if (!(GRID(state,flags,x,y) & F_BLACK)) continue;
+            get_surrounds(state, x, y, &s);
+            n = 0;
+            for (i = 0; i < s.npoints; i++) {
+                if (GRID(state,flags,s.points[i].x, s.points[i].y) & F_LIGHT)
+                    n++;
+            }
+            GRID(state,flags,x,y) |= F_NUMBERED;
+            GRID(state,lights,x,y) = n;
+        }
+    }
+}
+
+/* --- Actual solver, with helper subroutines. --- */
+
+static void tsl_callback(game_state *state,
+                         int lx, int ly, int *x, int *y, int *n)
+{
+    if (GRID(state,flags,lx,ly) & F_IMPOSSIBLE) return;
+    if (GRID(state,lights,lx,ly) > 0) return;
+    *x = lx; *y = ly; (*n)++;
+}
+
+static int try_solve_light(game_state *state, int ox, int oy,
+                           unsigned int flags, int lights)
+{
+    ll_data lld;
+    int sx = 0, sy = 0, n = 0;
+
+    if (lights > 0) return 0;
+    if (flags & F_BLACK) return 0;
+
+    /* We have an unlit square; count how many ways there are left to
+     * place a light that lights us (including this square); if only
+     * one, we must put a light there. Squares that could light us
+     * are, of course, the same as the squares we would light... */
+    list_lights(state, ox, oy, 1, &lld);
+    FOREACHLIT(&lld, { tsl_callback(state, lx, ly, &sx, &sy, &n); });
+    if (n == 1) {
+        set_light(state, sx, sy, 1);
+#ifdef SOLVER_DIAGNOSTICS
+        debug(("(%d,%d) can only be lit from (%d,%d); setting to LIGHT\n",
+                ox,oy,sx,sy));
+        if (verbose) debug_state(state);
+#endif
+        return 1;
+    }
+
+    return 0;
+}
+
+static int could_place_light(unsigned int flags, int lights)
+{
+    if (flags & (F_BLACK | F_IMPOSSIBLE)) return 0;
+    return (lights > 0) ? 0 : 1;
+}
+
+static int could_place_light_xy(game_state *state, int x, int y)
+{
+    int lights = GRID(state,lights,x,y);
+    unsigned int flags = GRID(state,flags,x,y);
+    return (could_place_light(flags, lights)) ? 1 : 0;
+}
+
+/* For a given number square, determine whether we have enough info
+ * to unambiguously place its lights. */
+static int try_solve_number(game_state *state, int nx, int ny,
+                            unsigned int nflags, int nlights)
+{
+    surrounds s;
+    int x, y, nl, ns, i, ret = 0, lights;
+    unsigned int flags;
+
+    if (!(nflags & F_NUMBERED)) return 0;
+    nl = nlights;
+    get_surrounds(state,nx,ny,&s);
+    ns = s.npoints;
+
+    /* nl is no. of lights we need to place, ns is no. of spaces we
+     * have to place them in. Try and narrow these down, and mark
+     * points we can ignore later. */
+    for (i = 0; i < s.npoints; i++) {
+        x = s.points[i].x; y = s.points[i].y;
+        flags = GRID(state,flags,x,y);
+        lights = GRID(state,lights,x,y);
+        if (flags & F_LIGHT) {
+            /* light here already; one less light for one less place. */
+            nl--; ns--;
+            s.points[i].f |= F_MARK;
+        } else if (!could_place_light(flags, lights)) {
+            ns--;
+            s.points[i].f |= F_MARK;
+        }
+    }
+    if (ns == 0) return 0; /* nowhere to put anything. */
+    if (nl == 0) {
+        /* we have placed all lights we need to around here; all remaining
+         * surrounds are therefore IMPOSSIBLE. */
+        GRID(state,flags,nx,ny) |= F_NUMBERUSED;
+        for (i = 0; i < s.npoints; i++) {
+            if (!(s.points[i].f & F_MARK)) {
+                GRID(state,flags,s.points[i].x,s.points[i].y) |= F_IMPOSSIBLE;
+                ret = 1;
+            }
+        }
+#ifdef SOLVER_DIAGNOSTICS
+        printf("Clue at (%d,%d) full; setting unlit to IMPOSSIBLE.\n",
+               nx,ny);
+        if (verbose) debug_state(state);
+#endif
+    } else if (nl == ns) {
+        /* we have as many lights to place as spaces; fill them all. */
+        GRID(state,flags,nx,ny) |= F_NUMBERUSED;
+        for (i = 0; i < s.npoints; i++) {
+            if (!(s.points[i].f & F_MARK)) {
+                set_light(state, s.points[i].x,s.points[i].y, 1);
+                ret = 1;
+            }
+        }
+#ifdef SOLVER_DIAGNOSTICS
+        printf("Clue at (%d,%d) trivial; setting unlit to LIGHT.\n",
+               nx,ny);
+        if (verbose) debug_state(state);
+#endif
+    }
+    return ret;
+}
+
+struct setscratch {
+    int x, y;
+    int n;
+};
+
+#define SCRATCHSZ (state->w+state->h)
+
+/* New solver algorithm: overlapping sets can add IMPOSSIBLE flags.
+ * Algorithm thanks to Simon:
+ *
+ * (a) Any square where you can place a light has a set of squares
+ *     which would become non-lights as a result. (This includes
+ *     squares lit by the first square, and can also include squares
+ *     adjacent to the same clue square if the new light is the last
+ *     one around that clue.) Call this MAKESDARK(x,y) with (x,y) being
+ *     the square you place a light.
+
+ * (b) Any unlit square has a set of squares on which you could place
+ *     a light to illuminate it. (Possibly including itself, of
+ *     course.) This set of squares has the property that _at least
+ *     one_ of them must contain a light. Sets of this type also arise
+ *     from clue squares. Call this MAKESLIGHT(x,y), again with (x,y)
+ *     the square you would place a light.
+
+ * (c) If there exists (dx,dy) and (lx,ly) such that MAKESDARK(dx,dy) is
+ *     a superset of MAKESLIGHT(lx,ly), this implies that placing a light at
+ *     (dx,dy) would either leave no remaining way to illuminate a certain
+ *     square, or would leave no remaining way to fulfill a certain clue
+ *     (at lx,ly). In either case, a light can be ruled out at that position.
+ *
+ * So, we construct all possible MAKESLIGHT sets, both from unlit squares
+ * and clue squares, and then we look for plausible MAKESDARK sets that include
+ * our (lx,ly) to see if we can find a (dx,dy) to rule out. By the time we have
+ * constructed the MAKESLIGHT set we don't care about (lx,ly), just the set
+ * members.
+ *
+ * Once we have such a set, Simon came up with a Cunning Plan to find
+ * the most sensible MAKESDARK candidate:
+ *
+ * (a) for each square S in your set X, find all the squares which _would_
+ *     rule it out. That means any square which would light S, plus
+ *     any square adjacent to the same clue square as S (provided
+ *     that clue square has only one remaining light to be placed).
+ *     It's not hard to make this list. Don't do anything with this
+ *     data at the moment except _count_ the squares.
+
+ * (b) Find the square S_min in the original set which has the
+ *     _smallest_ number of other squares which would rule it out.
+
+ * (c) Find all the squares that rule out S_min (it's probably
+ *     better to recompute this than to have stored it during step
+ *     (a), since the CPU requirement is modest but the storage
+ *     cost would get ugly.) For each of these squares, see if it
+ *     rules out everything else in the set X. Any which does can
+ *     be marked as not-a-light.
+ *
+ */
+
+typedef void (*trl_cb)(game_state *state, int dx, int dy,
+                       struct setscratch *scratch, int n, void *ctx);
+
+static void try_rule_out(game_state *state, int x, int y,
+                         struct setscratch *scratch, int n,
+                         trl_cb cb, void *ctx);
+
+static void trl_callback_search(game_state *state, int dx, int dy,
+                       struct setscratch *scratch, int n, void *ignored)
+{
+    int i;
+
+#ifdef SOLVER_DIAGNOSTICS
+    if (verbose) debug(("discount cb: light at (%d,%d)\n", dx, dy));
+#endif
+
+    for (i = 0; i < n; i++) {
+        if (dx == scratch[i].x && dy == scratch[i].y) {
+            scratch[i].n = 1;
+            return;
+        }
+    }
+}
+
+static void trl_callback_discount(game_state *state, int dx, int dy,
+                       struct setscratch *scratch, int n, void *ctx)
+{
+    int *didsth = (int *)ctx;
+    int i;
+
+    if (GRID(state,flags,dx,dy) & F_IMPOSSIBLE) {
+#ifdef SOLVER_DIAGNOSTICS
+        debug(("Square at (%d,%d) already impossible.\n", dx,dy));
+#endif
+        return;
+    }
+
+    /* Check whether a light at (dx,dy) rules out everything
+     * in scratch, and mark (dx,dy) as IMPOSSIBLE if it does.
+     * We can use try_rule_out for this as well, as the set of
+     * squares which would rule out (x,y) is the same as the
+     * set of squares which (x,y) would rule out. */
+
+#ifdef SOLVER_DIAGNOSTICS
+    if (verbose) debug(("Checking whether light at (%d,%d) rules out everything in scratch.\n", dx, dy));
+#endif
+
+    for (i = 0; i < n; i++)
+        scratch[i].n = 0;
+    try_rule_out(state, dx, dy, scratch, n, trl_callback_search, NULL);
+    for (i = 0; i < n; i++) {
+        if (scratch[i].n == 0) return;
+    }
+    /* The light ruled out everything in scratch. Yay. */
+    GRID(state,flags,dx,dy) |= F_IMPOSSIBLE;
+#ifdef SOLVER_DIAGNOSTICS
+    debug(("Set reduction discounted square at (%d,%d):\n", dx,dy));
+    if (verbose) debug_state(state);
+#endif
+
+    *didsth = 1;
+}
+
+static void trl_callback_incn(game_state *state, int dx, int dy,
+                       struct setscratch *scratch, int n, void *ctx)
+{
+    struct setscratch *s = (struct setscratch *)ctx;
+    s->n++;
+}
+
+static void try_rule_out(game_state *state, int x, int y,
+                         struct setscratch *scratch, int n,
+                         trl_cb cb, void *ctx)
+{
+    /* XXX Find all the squares which would rule out (x,y); anything
+     * that would light it as well as squares adjacent to same clues
+     * as X assuming that clue only has one remaining light.
+     * Call the callback with each square. */
+    ll_data lld;
+    surrounds s, ss;
+    int i, j, curr_lights, tot_lights;
+
+    /* Find all squares that would rule out a light at (x,y) and call trl_cb
+     * with them: anything that would light (x,y)... */
+
+    list_lights(state, x, y, 0, &lld);
+    FOREACHLIT(&lld, { if (could_place_light_xy(state, lx, ly)) { cb(state, lx, ly, scratch, n, ctx); } });
+
+    /* ... as well as any empty space (that isn't x,y) next to any clue square
+     * next to (x,y) that only has one light left to place. */
+
+    get_surrounds(state, x, y, &s);
+    for (i = 0; i < s.npoints; i++) {
+        if (!(GRID(state,flags,s.points[i].x,s.points[i].y) & F_NUMBERED))
+            continue;
+        /* we have an adjacent clue square; find /its/ surrounds
+         * and count the remaining lights it needs. */
+        get_surrounds(state,s.points[i].x,s.points[i].y,&ss);
+        curr_lights = 0;
+        for (j = 0; j < ss.npoints; j++) {
+            if (GRID(state,flags,ss.points[j].x,ss.points[j].y) & F_LIGHT)
+                curr_lights++;
+        }
+        tot_lights = GRID(state, lights, s.points[i].x, s.points[i].y);
+        /* We have a clue with tot_lights to fill, and curr_lights currently
+         * around it. If adding a light at (x,y) fills up the clue (i.e.
+         * curr_lights + 1 = tot_lights) then we need to discount all other
+         * unlit squares around the clue. */
+        if ((curr_lights + 1) == tot_lights) {
+            for (j = 0; j < ss.npoints; j++) {
+                int lx = ss.points[j].x, ly = ss.points[j].y;
+                if (lx == x && ly == y) continue;
+                if (could_place_light_xy(state, lx, ly))
+                    cb(state, lx, ly, scratch, n, ctx);
+            }
+        }
+    }
+}
+
+#ifdef SOLVER_DIAGNOSTICS
+static void debug_scratch(const char *msg, struct setscratch *scratch, int n)
+{
+    int i;
+    debug(("%s scratch (%d elements):\n", msg, n));
+    for (i = 0; i < n; i++) {
+        debug(("  (%d,%d) n%d\n", scratch[i].x, scratch[i].y, scratch[i].n));
+    }
+}
+#endif
+
+static int discount_set(game_state *state,
+                        struct setscratch *scratch, int n)
+{
+    int i, besti, bestn, didsth = 0;
+
+#ifdef SOLVER_DIAGNOSTICS
+    if (verbose > 1) debug_scratch("discount_set", scratch, n);
+#endif
+    if (n == 0) return 0;
+
+    for (i = 0; i < n; i++) {
+        try_rule_out(state, scratch[i].x, scratch[i].y, scratch, n,
+                     trl_callback_incn, (void*)&(scratch[i]));
+    }
+#ifdef SOLVER_DIAGNOSTICS
+    if (verbose > 1) debug_scratch("discount_set after count", scratch, n);
+#endif
+
+    besti = -1; bestn = SCRATCHSZ;
+    for (i = 0; i < n; i++) {
+        if (scratch[i].n < bestn) {
+            bestn = scratch[i].n;
+            besti = i;
+        }
+    }
+#ifdef SOLVER_DIAGNOSTICS
+    if (verbose > 1) debug(("best square (%d,%d) with n%d.\n",
+           scratch[besti].x, scratch[besti].y, scratch[besti].n));
+#endif
+    try_rule_out(state, scratch[besti].x, scratch[besti].y, scratch, n,
+                 trl_callback_discount, (void*)&didsth);
+#ifdef SOLVER_DIAGNOSTICS
+    if (didsth) debug((" [from square (%d,%d)]\n",
+                       scratch[besti].x, scratch[besti].y));
+#endif
+
+    return didsth;
+}
+
+static void discount_clear(game_state *state, struct setscratch *scratch, int *n)
+{
+    *n = 0;
+    memset(scratch, 0, SCRATCHSZ * sizeof(struct setscratch));
+}
+
+static void unlit_cb(game_state *state, int lx, int ly,
+                     struct setscratch *scratch, int *n)
+{
+    if (could_place_light_xy(state, lx, ly)) {
+        scratch[*n].x = lx; scratch[*n].y = ly; (*n)++;
+    }
+}
+
+/* Construct a MAKESLIGHT set from an unlit square. */
+static int discount_unlit(game_state *state, int x, int y,
+                          struct setscratch *scratch)
+{
+    ll_data lld;
+    int n, didsth;
+
+#ifdef SOLVER_DIAGNOSTICS
+    if (verbose) debug(("Trying to discount for unlit square at (%d,%d).\n", x, y));
+    if (verbose > 1) debug_state(state);
+#endif
+
+    discount_clear(state, scratch, &n);
+
+    list_lights(state, x, y, 1, &lld);
+    FOREACHLIT(&lld, { unlit_cb(state, lx, ly, scratch, &n); });
+    didsth = discount_set(state, scratch, n);
+#ifdef SOLVER_DIAGNOSTICS
+    if (didsth) debug(("  [from unlit square at (%d,%d)].\n", x, y));
+#endif
+    return didsth;
+
+}
+
+/* Construct a series of MAKESLIGHT sets from a clue square.
+ *  for a clue square with N remaining spaces that must contain M lights, every
+ *  subset of size N-M+1 of those N spaces forms such a set.
+ */
+
+static int discount_clue(game_state *state, int x, int y,
+                          struct setscratch *scratch)
+{
+    int slen, m = GRID(state, lights, x, y), n, i, didsth = 0, lights;
+    unsigned int flags;
+    surrounds s, sempty;
+    combi_ctx *combi;
+
+    if (m == 0) return 0;
+
+#ifdef SOLVER_DIAGNOSTICS
+    if (verbose) debug(("Trying to discount for sets at clue (%d,%d).\n", x, y));
+    if (verbose > 1) debug_state(state);
+#endif
+
+    /* m is no. of lights still to place; starts off at the clue value
+     * and decreases when we find a light already down.
+     * n is no. of spaces left; starts off at 0 and goes up when we find
+     * a plausible space. */
+
+    get_surrounds(state, x, y, &s);
+    memset(&sempty, 0, sizeof(surrounds));
+    for (i = 0; i < s.npoints; i++) {
+        int lx = s.points[i].x, ly = s.points[i].y;
+        flags = GRID(state,flags,lx,ly);
+        lights = GRID(state,lights,lx,ly);
+
+        if (flags & F_LIGHT) m--;
+
+        if (could_place_light(flags, lights)) {
+            sempty.points[sempty.npoints].x = lx;
+            sempty.points[sempty.npoints].y = ly;
+            sempty.npoints++;
+        }
+    }
+    n = sempty.npoints; /* sempty is now a surrounds of only blank squares. */
+    if (n == 0) return 0; /* clue is full already. */
+
+    if (m < 0 || m > n) return 0; /* become impossible. */
+
+    combi = new_combi(n - m + 1, n);
+    while (next_combi(combi)) {
+        discount_clear(state, scratch, &slen);
+        for (i = 0; i < combi->r; i++) {
+            scratch[slen].x = sempty.points[combi->a[i]].x;
+            scratch[slen].y = sempty.points[combi->a[i]].y;
+            slen++;
+        }
+        if (discount_set(state, scratch, slen)) didsth = 1;
+    }
+    free_combi(combi);
+#ifdef SOLVER_DIAGNOSTICS
+    if (didsth) debug(("  [from clue at (%d,%d)].\n", x, y));
+#endif
+    return didsth;
+}
+
+#define F_SOLVE_FORCEUNIQUE     1
+#define F_SOLVE_DISCOUNTSETS    2
+#define F_SOLVE_ALLOWRECURSE    4
+
+static unsigned int flags_from_difficulty(int difficulty)
+{
+    unsigned int sflags = F_SOLVE_FORCEUNIQUE;
+    assert(difficulty <= DIFFCOUNT);
+    if (difficulty >= 1) sflags |= F_SOLVE_DISCOUNTSETS;
+    if (difficulty >= 2) sflags |= F_SOLVE_ALLOWRECURSE;
+    return sflags;
+}
+
+#define MAXRECURSE 5
+
+static int solve_sub(game_state *state,
+                     unsigned int solve_flags, int depth,
+                     int *maxdepth)
+{
+    unsigned int flags;
+    int x, y, didstuff, ncanplace, lights;
+    int bestx, besty, n, bestn, copy_soluble, self_soluble, ret, maxrecurse = 0;
+    game_state *scopy;
+    ll_data lld;
+    struct setscratch *sscratch = NULL;
+
+#ifdef SOLVER_DIAGNOSTICS
+    printf("solve_sub: depth = %d\n", depth);
+#endif
+    if (maxdepth && *maxdepth < depth) *maxdepth = depth;
+    if (solve_flags & F_SOLVE_ALLOWRECURSE) maxrecurse = MAXRECURSE;
+
+    while (1) {
+        if (grid_overlap(state)) {
+            /* Our own solver, from scratch, should never cause this to happen
+             * (assuming a soluble grid). However, if we're trying to solve
+             * from a half-completed *incorrect* grid this might occur; we
+             * just return the 'no solutions' code in this case. */
+            ret = 0; goto done;
+        }
+
+        if (grid_correct(state)) { ret = 1; goto done; }
+
+        ncanplace = 0;
+        didstuff = 0;
+        /* These 2 loops, and the functions they call, are the critical loops
+         * for timing; any optimisations should look here first. */
+        for (x = 0; x < state->w; x++) {
+            for (y = 0; y < state->h; y++) {
+                flags = GRID(state,flags,x,y);
+                lights = GRID(state,lights,x,y);
+                ncanplace += could_place_light(flags, lights);
+
+                if (try_solve_light(state, x, y, flags, lights)) didstuff = 1;
+                if (try_solve_number(state, x, y, flags, lights)) didstuff = 1;
+            }
+        }
+        if (didstuff) continue;
+        if (!ncanplace) {
+            /* nowhere to put a light, puzzle is unsoluble. */
+            ret = 0; goto done;
+        }
+
+        if (solve_flags & F_SOLVE_DISCOUNTSETS) {
+            if (!sscratch) sscratch = snewn(SCRATCHSZ, struct setscratch);
+            /* Try a more cunning (and more involved) way... more details above. */
+            for (x = 0; x < state->w; x++) {
+                for (y = 0; y < state->h; y++) {
+                    flags = GRID(state,flags,x,y);
+                    lights = GRID(state,lights,x,y);
+
+                    if (!(flags & F_BLACK) && lights == 0) {
+                        if (discount_unlit(state, x, y, sscratch)) {
+                            didstuff = 1;
+                            goto reduction_success;
+                        }
+                    } else if (flags & F_NUMBERED) {
+                        if (discount_clue(state, x, y, sscratch)) {
+                            didstuff = 1;
+                            goto reduction_success;
+                        }
+                    }
+                }
+            }
+        }
+reduction_success:
+        if (didstuff) continue;
+
+        /* We now have to make a guess; we have places to put lights but
+         * no definite idea about where they can go. */
+        if (depth >= maxrecurse) {
+            /* mustn't delve any deeper. */
+            ret = -1; goto done;
+        }
+        /* Of all the squares that we could place a light, pick the one
+         * that would light the most currently unlit squares. */
+        /* This heuristic was just plucked from the air; there may well be
+         * a more efficient way of choosing a square to flip to minimise
+         * recursion. */
+        bestn = 0;
+        bestx = besty = -1; /* suyb */
+        for (x = 0; x < state->w; x++) {
+            for (y = 0; y < state->h; y++) {
+                flags = GRID(state,flags,x,y);
+                lights = GRID(state,lights,x,y);
+                if (!could_place_light(flags, lights)) continue;
+
+                n = 0;
+                list_lights(state, x, y, 1, &lld);
+                FOREACHLIT(&lld, { if (GRID(state,lights,lx,ly) == 0) n++; });
+                if (n > bestn) {
+                    bestn = n; bestx = x; besty = y;
+                }
+            }
+        }
+        assert(bestn > 0);
+        assert(bestx >= 0 && besty >= 0);
+
+        /* Now we've chosen a plausible (x,y), try to solve it once as 'lit'
+         * and once as 'impossible'; we need to make one copy to do this. */
+
+        scopy = dup_game(state);
+#ifdef SOLVER_DIAGNOSTICS
+        debug(("Recursing #1: trying (%d,%d) as IMPOSSIBLE\n", bestx, besty));
+#endif
+        GRID(state,flags,bestx,besty) |= F_IMPOSSIBLE;
+        self_soluble = solve_sub(state, solve_flags,  depth+1, maxdepth);
+
+        if (!(solve_flags & F_SOLVE_FORCEUNIQUE) && self_soluble > 0) {
+            /* we didn't care about finding all solutions, and we just
+             * found one; return with it immediately. */
+            free_game(scopy);
+            ret = self_soluble;
+            goto done;
+        }
+
+#ifdef SOLVER_DIAGNOSTICS
+        debug(("Recursing #2: trying (%d,%d) as LIGHT\n", bestx, besty));
+#endif
+        set_light(scopy, bestx, besty, 1);
+        copy_soluble = solve_sub(scopy, solve_flags, depth+1, maxdepth);
+
+        /* If we wanted a unique solution but we hit our recursion limit
+         * (on either branch) then we have to assume we didn't find possible
+         * extra solutions, and return 'not soluble'. */
+        if ((solve_flags & F_SOLVE_FORCEUNIQUE) &&
+            ((copy_soluble < 0) || (self_soluble < 0))) {
+            ret = -1;
+        /* Make sure that whether or not it was self or copy (or both) that
+         * were soluble, that we return a solved state in self. */
+        } else if (copy_soluble <= 0) {
+            /* copy wasn't soluble; keep self state and return that result. */
+            ret = self_soluble;
+        } else if (self_soluble <= 0) {
+            /* copy solved and we didn't, so copy in copy's (now solved)
+             * flags and light state. */
+            memcpy(state->lights, scopy->lights,
+                   scopy->w * scopy->h * sizeof(int));
+            memcpy(state->flags, scopy->flags,
+                   scopy->w * scopy->h * sizeof(unsigned int));
+            ret = copy_soluble;
+        } else {
+            ret = copy_soluble + self_soluble;
+        }
+        free_game(scopy);
+        goto done;
+    }
+done:
+    if (sscratch) sfree(sscratch);
+#ifdef SOLVER_DIAGNOSTICS
+    if (ret < 0)
+        debug(("solve_sub: depth = %d returning, ran out of recursion.\n",
+               depth));
+    else
+        debug(("solve_sub: depth = %d returning, %d solutions.\n",
+               depth, ret));
+#endif
+    return ret;
+}
+
+/* Fills in the (possibly partially-complete) game_state as far as it can,
+ * returning the number of possible solutions. If it returns >0 then the
+ * game_state will be in a solved state, but you won't know which one. */
+static int dosolve(game_state *state, int solve_flags, int *maxdepth)
+{
+    int x, y, nsol;
+
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            GRID(state,flags,x,y) &= ~F_NUMBERUSED;
+        }
+    }
+    nsol = solve_sub(state, solve_flags, 0, maxdepth);
+    return nsol;
+}
+
+static int strip_unused_nums(game_state *state)
+{
+    int x,y,n=0;
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            if ((GRID(state,flags,x,y) & F_NUMBERED) &&
+                !(GRID(state,flags,x,y) & F_NUMBERUSED)) {
+                GRID(state,flags,x,y) &= ~F_NUMBERED;
+                GRID(state,lights,x,y) = 0;
+                n++;
+            }
+        }
+    }
+    debug(("Stripped %d unused numbers.\n", n));
+    return n;
+}
+
+static void unplace_lights(game_state *state)
+{
+    int x,y;
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            if (GRID(state,flags,x,y) & F_LIGHT)
+                set_light(state,x,y,0);
+            GRID(state,flags,x,y) &= ~F_IMPOSSIBLE;
+            GRID(state,flags,x,y) &= ~F_NUMBERUSED;
+        }
+    }
+}
+
+static int puzzle_is_good(game_state *state, int difficulty)
+{
+    int nsol, mdepth = 0;
+    unsigned int sflags = flags_from_difficulty(difficulty);
+
+    unplace_lights(state);
+
+#ifdef SOLVER_DIAGNOSTICS
+    debug(("Trying to solve with difficulty %d (0x%x):\n",
+           difficulty, sflags));
+    if (verbose) debug_state(state);
+#endif
+
+    nsol = dosolve(state, sflags, &mdepth);
+    /* if we wanted an easy puzzle, make sure we didn't need recursion. */
+    if (!(sflags & F_SOLVE_ALLOWRECURSE) && mdepth > 0) {
+        debug(("Ignoring recursive puzzle.\n"));
+        return 0;
+    }
+
+    debug(("%d solutions found.\n", nsol));
+    if (nsol <= 0) return 0;
+    if (nsol > 1) return 0;
+    return 1;
+}
+
+/* --- New game creation and user input code. --- */
+
+/* The basic algorithm here is to generate the most complex grid possible
+ * while honouring two restrictions:
+ *
+ *  * we require a unique solution, and
+ *  * either we require solubility with no recursion (!params->recurse)
+ *  * or we require some recursion. (params->recurse).
+ *
+ * The solver helpfully keeps track of the numbers it needed to use to
+ * get its solution, so we use that to remove an initial set of numbers
+ * and check we still satsify our requirements (on uniqueness and
+ * non-recursiveness, if applicable; we don't check explicit recursiveness
+ * until the end).
+ *
+ * Then we try to remove all numbers in a random order, and see if we
+ * still satisfy requirements (putting them back if we didn't).
+ *
+ * Removing numbers will always, in general terms, make a puzzle require
+ * more recursion but it may also mean a puzzle becomes non-unique.
+ *
+ * Once we're done, if we wanted a recursive puzzle but the most difficult
+ * puzzle we could come up with was non-recursive, we give up and try a new
+ * grid. */
+
+#define MAX_GRIDGEN_TRIES 20
+
+static char *new_game_desc(const game_params *params_in, random_state *rs,
+                           char **aux, int interactive)
+{
+    game_params params_copy = *params_in; /* structure copy */
+    game_params *params = &params_copy;
+    game_state *news = new_state(params), *copys;
+    int i, j, run, x, y, wh = params->w*params->h, num;
+    char *ret, *p;
+    int *numindices;
+
+    /* Construct a shuffled list of grid positions; we only
+     * do this once, because if it gets used more than once it'll
+     * be on a different grid layout. */
+    numindices = snewn(wh, int);
+    for (j = 0; j < wh; j++) numindices[j] = j;
+    shuffle(numindices, wh, sizeof(*numindices), rs);
+
+    while (1) {
+        for (i = 0; i < MAX_GRIDGEN_TRIES; i++) {
+            set_blacks(news, params, rs); /* also cleans board. */
+
+            /* set up lights and then the numbers, and remove the lights */
+            place_lights(news, rs);
+            debug(("Generating initial grid.\n"));
+            place_numbers(news);
+            if (!puzzle_is_good(news, params->difficulty)) continue;
+
+            /* Take a copy, remove numbers we didn't use and check there's
+             * still a unique solution; if so, use the copy subsequently. */
+            copys = dup_game(news);
+            strip_unused_nums(copys);
+            if (!puzzle_is_good(copys, params->difficulty)) {
+                debug(("Stripped grid is not good, reverting.\n"));
+                free_game(copys);
+            } else {
+                free_game(news);
+                news = copys;
+            }
+
+            /* Go through grid removing numbers at random one-by-one and
+             * trying to solve again; if it ceases to be good put the number back. */
+            for (j = 0; j < wh; j++) {
+                y = numindices[j] / params->w;
+                x = numindices[j] % params->w;
+                if (!(GRID(news, flags, x, y) & F_NUMBERED)) continue;
+                num = GRID(news, lights, x, y);
+                GRID(news, lights, x, y) = 0;
+                GRID(news, flags, x, y) &= ~F_NUMBERED;
+                if (!puzzle_is_good(news, params->difficulty)) {
+                    GRID(news, lights, x, y) = num;
+                    GRID(news, flags, x, y) |= F_NUMBERED;
+                } else
+                    debug(("Removed (%d,%d) still soluble.\n", x, y));
+            }
+            if (params->difficulty > 0) {
+                /* Was the maximally-difficult puzzle difficult enough?
+                 * Check we can't solve it with a more simplistic solver. */
+                if (puzzle_is_good(news, params->difficulty-1)) {
+                    debug(("Maximally-hard puzzle still not hard enough, skipping.\n"));
+                    continue;
+                }
+            }
+
+            goto goodpuzzle;
+        }
+        /* Couldn't generate a good puzzle in however many goes. Ramp up the
+         * %age of black squares (if we didn't already have lots; in which case
+         * why couldn't we generate a puzzle?) and try again. */
+        if (params->blackpc < 90) params->blackpc += 5;
+        debug(("New black layout %d%%.\n", params->blackpc));
+    }
+goodpuzzle:
+    /* Game is encoded as a long string one character per square;
+     * 'S' is a space
+     * 'B' is a black square with no number
+     * '0', '1', '2', '3', '4' is a black square with a number. */
+    ret = snewn((params->w * params->h) + 1, char);
+    p = ret;
+    run = 0;
+    for (y = 0; y < params->h; y++) {
+        for (x = 0; x < params->w; x++) {
+            if (GRID(news,flags,x,y) & F_BLACK) {
+                if (run) {
+                    *p++ = ('a'-1) + run;
+                    run = 0;
+                }
+                if (GRID(news,flags,x,y) & F_NUMBERED)
+                    *p++ = '0' + GRID(news,lights,x,y);
+                else
+                    *p++ = 'B';
+            } else {
+                if (run == 26) {
+                    *p++ = ('a'-1) + run;
+                    run = 0;
+                }
+                run++;
+            }
+        }
+    }
+    if (run) {
+        *p++ = ('a'-1) + run;
+        run = 0;
+    }
+    *p = '\0';
+    assert(p - ret <= params->w * params->h);
+    free_game(news);
+    sfree(numindices);
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int i;
+    for (i = 0; i < params->w*params->h; i++) {
+        if (*desc >= '0' && *desc <= '4')
+            /* OK */;
+        else if (*desc == 'B')
+            /* OK */;
+        else if (*desc >= 'a' && *desc <= 'z')
+            i += *desc - 'a';          /* and the i++ will add another one */
+        else if (!*desc)
+            return "Game description shorter than expected";
+        else
+            return "Game description contained unexpected character";
+        desc++;
+    }
+    if (*desc || i > params->w*params->h)
+        return "Game description longer than expected";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *ret = new_state(params);
+    int x,y;
+    int run = 0;
+
+    for (y = 0; y < params->h; y++) {
+        for (x = 0; x < params->w; x++) {
+            char c = '\0';
+
+            if (run == 0) {
+                c = *desc++;
+                assert(c != 'S');
+                if (c >= 'a' && c <= 'z')
+                    run = c - 'a' + 1;
+            }
+
+            if (run > 0) {
+                c = 'S';
+                run--;
+            }
+
+            switch (c) {
+              case '0': case '1': case '2': case '3': case '4':
+                GRID(ret,flags,x,y) |= F_NUMBERED;
+                GRID(ret,lights,x,y) = (c - '0');
+                /* run-on... */
+
+              case 'B':
+                GRID(ret,flags,x,y) |= F_BLACK;
+                break;
+
+              case 'S':
+                /* empty square */
+                break;
+
+              default:
+                assert(!"Malformed desc.");
+                break;
+            }
+        }
+    }
+    if (*desc) assert(!"Over-long desc.");
+
+    return ret;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    game_state *solved;
+    char *move = NULL, buf[80];
+    int movelen, movesize, x, y, len;
+    unsigned int oldflags, solvedflags, sflags;
+
+    /* We don't care here about non-unique puzzles; if the
+     * user entered one themself then I doubt they care. */
+
+    sflags = F_SOLVE_ALLOWRECURSE | F_SOLVE_DISCOUNTSETS;
+
+    /* Try and solve from where we are now (for non-unique
+     * puzzles this may produce a different answer). */
+    solved = dup_game(currstate);
+    if (dosolve(solved, sflags, NULL) > 0) goto solved;
+    free_game(solved);
+
+    /* That didn't work; try solving from the clean puzzle. */
+    solved = dup_game(state);
+    if (dosolve(solved, sflags, NULL) > 0) goto solved;
+    *error = "Unable to find a solution to this puzzle.";
+    goto done;
+
+solved:
+    movesize = 256;
+    move = snewn(movesize, char);
+    movelen = 0;
+    move[movelen++] = 'S';
+    move[movelen] = '\0';
+    for (x = 0; x < currstate->w; x++) {
+        for (y = 0; y < currstate->h; y++) {
+            len = 0;
+            oldflags = GRID(currstate, flags, x, y);
+            solvedflags = GRID(solved, flags, x, y);
+            if ((oldflags & F_LIGHT) != (solvedflags & F_LIGHT))
+                len = sprintf(buf, ";L%d,%d", x, y);
+            else if ((oldflags & F_IMPOSSIBLE) != (solvedflags & F_IMPOSSIBLE))
+                len = sprintf(buf, ";I%d,%d", x, y);
+            if (len) {
+                if (movelen + len >= movesize) {
+                    movesize = movelen + len + 256;
+                    move = sresize(move, movesize, char);
+                }
+                strcpy(move + movelen, buf);
+                movelen += len;
+            }
+        }
+    }
+
+done:
+    free_game(solved);
+    return move;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+/* 'borrowed' from slant.c, mainly. I could have printed it one
+ * character per cell (like debug_state) but that comes out tiny.
+ * 'L' is used for 'light here' because 'O' looks too much like '0'
+ * (black square with no surrounding lights). */
+static char *game_text_format(const game_state *state)
+{
+    int w = state->w, h = state->h, W = w+1, H = h+1;
+    int x, y, len, lights;
+    unsigned int flags;
+    char *ret, *p;
+
+    len = (h+H) * (w+W+1) + 1;
+    ret = snewn(len, char);
+    p = ret;
+
+    for (y = 0; y < H; y++) {
+        for (x = 0; x < W; x++) {
+            *p++ = '+';
+            if (x < w)
+                *p++ = '-';
+        }
+        *p++ = '\n';
+        if (y < h) {
+            for (x = 0; x < W; x++) {
+                *p++ = '|';
+                if (x < w) {
+                    /* actual interesting bit. */
+                    flags = GRID(state, flags, x, y);
+                    lights = GRID(state, lights, x, y);
+                    if (flags & F_BLACK) {
+                        if (flags & F_NUMBERED)
+                            *p++ = '0' + lights;
+                        else
+                            *p++ = '#';
+                    } else {
+                        if (flags & F_LIGHT)
+                            *p++ = 'L';
+                        else if (flags & F_IMPOSSIBLE)
+                            *p++ = 'x';
+                        else if (lights > 0)
+                            *p++ = '.';
+                        else
+                            *p++ = ' ';
+                    }
+                }
+            }
+            *p++ = '\n';
+        }
+    }
+    *p++ = '\0';
+
+    assert(p - ret == len);
+    return ret;
+}
+
+struct game_ui {
+    int cur_x, cur_y, cur_visible;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->cur_x = ui->cur_y = ui->cur_visible = 0;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    /* nothing to encode. */
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+    /* nothing to decode. */
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    if (newstate->completed)
+        ui->cur_visible = 0;
+}
+
+#define DF_BLACK        1       /* black square */
+#define DF_NUMBERED     2       /* black square with number */
+#define DF_LIT          4       /* display (white) square lit up */
+#define DF_LIGHT        8       /* display light in square */
+#define DF_OVERLAP      16      /* display light as overlapped */
+#define DF_CURSOR       32      /* display cursor */
+#define DF_NUMBERWRONG  64      /* display black numbered square as error. */
+#define DF_FLASH        128     /* background flash is on. */
+#define DF_IMPOSSIBLE   256     /* display non-light little square */
+
+struct game_drawstate {
+    int tilesize, crad;
+    int w, h;
+    unsigned int *flags;         /* width * height */
+    int started;
+};
+
+
+/* Believe it or not, this empty = "" hack is needed to get around a bug in
+ * the prc-tools gcc when optimisation is turned on; before, it produced:
+    lightup-sect.c: In function `interpret_move':
+    lightup-sect.c:1416: internal error--unrecognizable insn:
+    (insn 582 580 583 (set (reg:SI 134)
+            (pc)) -1 (nil)
+        (nil))
+ */
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    enum { NONE, FLIP_LIGHT, FLIP_IMPOSSIBLE } action = NONE;
+    int cx = -1, cy = -1;
+    unsigned int flags;
+    char buf[80], *nullret = NULL, *empty = "", c;
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        if (ui->cur_visible)
+            nullret = empty;
+        ui->cur_visible = 0;
+        cx = FROMCOORD(x);
+        cy = FROMCOORD(y);
+        action = (button == LEFT_BUTTON) ? FLIP_LIGHT : FLIP_IMPOSSIBLE;
+    } else if (IS_CURSOR_SELECT(button) ||
+               button == 'i' || button == 'I' ||
+               button == ' ' || button == '\r' || button == '\n') {
+        if (ui->cur_visible) {
+            /* Only allow cursor-effect operations if the cursor is visible
+             * (otherwise you have no idea which square it might be affecting) */
+            cx = ui->cur_x;
+            cy = ui->cur_y;
+            action = (button == 'i' || button == 'I' || button == CURSOR_SELECT2) ?
+                FLIP_IMPOSSIBLE : FLIP_LIGHT;
+        }
+        ui->cur_visible = 1;
+    } else if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->w, state->h, 0);
+        ui->cur_visible = 1;
+        nullret = empty;
+    } else
+        return NULL;
+
+    switch (action) {
+    case FLIP_LIGHT:
+    case FLIP_IMPOSSIBLE:
+        if (cx < 0 || cy < 0 || cx >= state->w || cy >= state->h)
+            return nullret;
+        flags = GRID(state, flags, cx, cy);
+        if (flags & F_BLACK)
+            return nullret;
+        if (action == FLIP_LIGHT) {
+#ifdef STYLUS_BASED
+            if (flags & F_IMPOSSIBLE || flags & F_LIGHT) c = 'I'; else c = 'L';
+#else
+            if (flags & F_IMPOSSIBLE) return nullret;
+            c = 'L';
+#endif
+        } else {
+#ifdef STYLUS_BASED
+            if (flags & F_IMPOSSIBLE || flags & F_LIGHT) c = 'L'; else c = 'I';
+#else
+            if (flags & F_LIGHT) return nullret;
+            c = 'I';
+#endif
+        }
+        sprintf(buf, "%c%d,%d", (int)c, cx, cy);
+        break;
+
+    case NONE:
+        return nullret;
+
+    default:
+        assert(!"Shouldn't get here!");
+    }
+    return dupstr(buf);
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    game_state *ret = dup_game(state);
+    int x, y, n, flags;
+    char c;
+
+    if (!*move) goto badmove;
+
+    while (*move) {
+        c = *move;
+        if (c == 'S') {
+            ret->used_solve = TRUE;
+            move++;
+        } else if (c == 'L' || c == 'I') {
+            move++;
+            if (sscanf(move, "%d,%d%n", &x, &y, &n) != 2 ||
+                x < 0 || y < 0 || x >= ret->w || y >= ret->h)
+                goto badmove;
+
+            flags = GRID(ret, flags, x, y);
+            if (flags & F_BLACK) goto badmove;
+
+            /* LIGHT and IMPOSSIBLE are mutually exclusive. */
+            if (c == 'L') {
+                GRID(ret, flags, x, y) &= ~F_IMPOSSIBLE;
+                set_light(ret, x, y, (flags & F_LIGHT) ? 0 : 1);
+            } else {
+                set_light(ret, x, y, 0);
+                GRID(ret, flags, x, y) ^= F_IMPOSSIBLE;
+            }
+            move += n;
+        } else goto badmove;
+
+        if (*move == ';')
+            move++;
+        else if (*move) goto badmove;
+    }
+    if (grid_correct(ret)) ret->completed = 1;
+    return ret;
+
+badmove:
+    free_game(ret);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+/* XXX entirely cloned from fifteen.c; separate out? */
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = TILE_SIZE * params->w + 2 * BORDER;
+    *y = TILE_SIZE * params->h + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+    ds->crad = 3*(tilesize-1)/8;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_BLACK * 3 + i] = 0.0F;
+        ret[COL_LIGHT * 3 + i] = 1.0F;
+        ret[COL_CURSOR * 3 + i] = ret[COL_BACKGROUND * 3 + i] / 2.0F;
+        ret[COL_GRID * 3 + i] = ret[COL_BACKGROUND * 3 + i] / 1.5F;
+
+    }
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.25F;
+    ret[COL_ERROR * 3 + 2] = 0.25F;
+
+    ret[COL_LIT * 3 + 0] = 1.0F;
+    ret[COL_LIT * 3 + 1] = 1.0F;
+    ret[COL_LIT * 3 + 2] = 0.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = ds->crad = 0;
+    ds->w = state->w; ds->h = state->h;
+
+    ds->flags = snewn(ds->w*ds->h, unsigned int);
+    for (i = 0; i < ds->w*ds->h; i++)
+        ds->flags[i] = -1;
+
+    ds->started = 0;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->flags);
+    sfree(ds);
+}
+
+/* At some stage we should put these into a real options struct.
+ * Note that tile_redraw has no #ifdeffery; it relies on tile_flags not
+ * to put those flags in. */
+#define HINT_LIGHTS
+#define HINT_OVERLAPS
+#define HINT_NUMBERS
+
+static unsigned int tile_flags(game_drawstate *ds, const game_state *state,
+                               const game_ui *ui, int x, int y, int flashing)
+{
+    unsigned int flags = GRID(state, flags, x, y);
+    int lights = GRID(state, lights, x, y);
+    unsigned int ret = 0;
+
+    if (flashing) ret |= DF_FLASH;
+    if (ui && ui->cur_visible && x == ui->cur_x && y == ui->cur_y)
+        ret |= DF_CURSOR;
+
+    if (flags & F_BLACK) {
+        ret |= DF_BLACK;
+        if (flags & F_NUMBERED) {
+#ifdef HINT_NUMBERS
+            if (number_wrong(state, x, y))
+                ret |= DF_NUMBERWRONG;
+#endif
+            ret |= DF_NUMBERED;
+        }
+    } else {
+#ifdef HINT_LIGHTS
+        if (lights > 0) ret |= DF_LIT;
+#endif
+        if (flags & F_LIGHT) {
+            ret |= DF_LIGHT;
+#ifdef HINT_OVERLAPS
+            if (lights > 1) ret |= DF_OVERLAP;
+#endif
+        }
+        if (flags & F_IMPOSSIBLE) ret |= DF_IMPOSSIBLE;
+    }
+    return ret;
+}
+
+static void tile_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *state, int x, int y)
+{
+    unsigned int ds_flags = GRID(ds, flags, x, y);
+    int dx = COORD(x), dy = COORD(y);
+    int lit = (ds_flags & DF_FLASH) ? COL_GRID : COL_LIT;
+
+    if (ds_flags & DF_BLACK) {
+        draw_rect(dr, dx, dy, TILE_SIZE, TILE_SIZE, COL_BLACK);
+        if (ds_flags & DF_NUMBERED) {
+            int ccol = (ds_flags & DF_NUMBERWRONG) ? COL_ERROR : COL_LIGHT;
+            char str[32];
+
+            /* We know that this won't change over the course of the game
+             * so it's OK to ignore this when calculating whether or not
+             * to redraw the tile. */
+            sprintf(str, "%d", GRID(state, lights, x, y));
+            draw_text(dr, dx + TILE_SIZE/2, dy + TILE_SIZE/2,
+                      FONT_VARIABLE, TILE_SIZE*3/5,
+                      ALIGN_VCENTRE | ALIGN_HCENTRE, ccol, str);
+        }
+    } else {
+        draw_rect(dr, dx, dy, TILE_SIZE, TILE_SIZE,
+                  (ds_flags & DF_LIT) ? lit : COL_BACKGROUND);
+        draw_rect_outline(dr, dx, dy, TILE_SIZE, TILE_SIZE, COL_GRID);
+        if (ds_flags & DF_LIGHT) {
+            int lcol = (ds_flags & DF_OVERLAP) ? COL_ERROR : COL_LIGHT;
+            draw_circle(dr, dx + TILE_SIZE/2, dy + TILE_SIZE/2, TILE_RADIUS,
+                        lcol, COL_BLACK);
+        } else if ((ds_flags & DF_IMPOSSIBLE)) {
+            static int draw_blobs_when_lit = -1;
+            if (draw_blobs_when_lit < 0) {
+                char *env = getenv("LIGHTUP_LIT_BLOBS");
+                draw_blobs_when_lit = (!env || (env[0] == 'y' ||
+                                                env[0] == 'Y'));
+            }
+            if (!(ds_flags & DF_LIT) || draw_blobs_when_lit) {
+                int rlen = TILE_SIZE / 4;
+                draw_rect(dr, dx + TILE_SIZE/2 - rlen/2,
+                          dy + TILE_SIZE/2 - rlen/2,
+                          rlen, rlen, COL_BLACK);
+            }
+        }
+    }
+
+    if (ds_flags & DF_CURSOR) {
+        int coff = TILE_SIZE/8;
+        draw_rect_outline(dr, dx + coff, dy + coff,
+                          TILE_SIZE - coff*2, TILE_SIZE - coff*2, COL_CURSOR);
+    }
+
+    draw_update(dr, dx, dy, TILE_SIZE, TILE_SIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int flashing = FALSE;
+    int x,y;
+
+    if (flashtime) flashing = (int)(flashtime * 3 / FLASH_TIME) != 1;
+
+    if (!ds->started) {
+        draw_rect(dr, 0, 0,
+                  TILE_SIZE * ds->w + 2 * BORDER,
+                  TILE_SIZE * ds->h + 2 * BORDER, COL_BACKGROUND);
+
+        draw_rect_outline(dr, COORD(0)-1, COORD(0)-1,
+                          TILE_SIZE * ds->w + 2,
+                          TILE_SIZE * ds->h + 2,
+                          COL_GRID);
+
+        draw_update(dr, 0, 0,
+                    TILE_SIZE * ds->w + 2 * BORDER,
+                    TILE_SIZE * ds->h + 2 * BORDER);
+        ds->started = 1;
+    }
+
+    for (x = 0; x < ds->w; x++) {
+        for (y = 0; y < ds->h; y++) {
+            unsigned int ds_flags = tile_flags(ds, state, ui, x, y, flashing);
+            if (ds_flags != GRID(ds, flags, x, y)) {
+                GRID(ds, flags, x, y) = ds_flags;
+                tile_redraw(dr, ds, state, x, y);
+            }
+        }
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->used_solve && !newstate->used_solve)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 6mm squares by default.
+     */
+    game_compute_size(params, 600, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->w, h = state->h;
+    int ink = print_mono_colour(dr, 0);
+    int paper = print_mono_colour(dr, 1);
+    int x, y;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    /*
+     * Border.
+     */
+    print_line_width(dr, TILE_SIZE / 16);
+    draw_rect_outline(dr, COORD(0), COORD(0),
+                      TILE_SIZE * w, TILE_SIZE * h, ink);
+
+    /*
+     * Grid.
+     */
+    print_line_width(dr, TILE_SIZE / 24);
+    for (x = 1; x < w; x++)
+        draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h), ink);
+    for (y = 1; y < h; y++)
+        draw_line(dr, COORD(0), COORD(y), COORD(w), COORD(y), ink);
+
+    /*
+     * Grid contents.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            unsigned int ds_flags = tile_flags(ds, state, NULL, x, y, FALSE);
+            int dx = COORD(x), dy = COORD(y);
+            if (ds_flags & DF_BLACK) {
+                draw_rect(dr, dx, dy, TILE_SIZE, TILE_SIZE, ink);
+                if (ds_flags & DF_NUMBERED) {
+                    char str[32];
+                    sprintf(str, "%d", GRID(state, lights, x, y));
+                    draw_text(dr, dx + TILE_SIZE/2, dy + TILE_SIZE/2,
+                              FONT_VARIABLE, TILE_SIZE*3/5,
+                              ALIGN_VCENTRE | ALIGN_HCENTRE, paper, str);
+                }
+            } else if (ds_flags & DF_LIGHT) {
+                draw_circle(dr, dx + TILE_SIZE/2, dy + TILE_SIZE/2,
+                            TILE_RADIUS, -1, ink);
+            }
+        }
+}
+
+#ifdef COMBINED
+#define thegame lightup
+#endif
+
+const struct game thegame = {
+    "Light Up", "games.lightup", "lightup",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err, *result;
+    int nsol, diff, really_verbose = 0;
+    unsigned int sflags;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            really_verbose++;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    /* Run the solvers easiest to hardest until we find one that
+     * can solve our puzzle. If it's soluble we know that the
+     * hardest (recursive) solver will always find the solution. */
+    nsol = sflags = 0;
+    for (diff = 0; diff <= DIFFCOUNT; diff++) {
+        printf("\nSolving with difficulty %d.\n", diff);
+        sflags = flags_from_difficulty(diff);
+        unplace_lights(s);
+        nsol = dosolve(s, sflags, NULL);
+        if (nsol == 1) break;
+    }
+
+    printf("\n");
+    if (nsol == 0) {
+        printf("Puzzle has no solution.\n");
+    } else if (nsol < 0) {
+        printf("Unable to find a unique solution.\n");
+    } else if (nsol > 1) {
+        printf("Puzzle has multiple solutions.\n");
+    } else {
+        verbose = really_verbose;
+        unplace_lights(s);
+        printf("Puzzle has difficulty %d: solving...\n", diff);
+        dosolve(s, sflags, NULL); /* sflags from last successful solve */
+        result = game_text_format(s);
+        printf("%s", result);
+        sfree(result);
+    }
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/list.c b/apps/plugins/puzzles/list.c
new file mode 100644
index 0000000000..ec019c31b2
--- /dev/null
+++ b/apps/plugins/puzzles/list.c
@@ -0,0 +1,55 @@
+/*
+ * list.c: List of pointers to puzzle structures, for monolithic
+ * platforms.
+ *
+ * This file is automatically generated by mkfiles.pl. Do not edit
+ * it directly, or the changes will be lost next time mkfiles.pl runs.
+ * Instead, edit Recipe and/or its *.R subfiles.
+ */
+#include "puzzles.h"
+#define GAMELIST(A) \
+    A(blackbox) \
+    A(bridges) \
+    A(cube) \
+    A(dominosa) \
+    A(fifteen) \
+    A(filling) \
+    A(flip) \
+    A(flood) \
+    A(galaxies) \
+    A(guess) \
+    A(inertia) \
+    A(keen) \
+    A(lightup) \
+    A(loopy) \
+    A(magnets) \
+    A(map) \
+    A(mines) \
+    A(net) \
+    A(netslide) \
+    A(palisade) \
+    A(pattern) \
+    A(pearl) \
+    A(pegs) \
+    A(range) \
+    A(rect) \
+    A(samegame) \
+    A(signpost) \
+    A(singles) \
+    A(sixteen) \
+    A(slant) \
+    A(solo) \
+    A(tents) \
+    A(towers) \
+    A(tracks) \
+    A(twiddle) \
+    A(undead) \
+    A(unequal) \
+    A(unruly) \
+    A(untangle) \
+
+#define DECL(x) extern const game x;
+#define REF(x) &x,
+GAMELIST(DECL)
+const game *gamelist[] = { GAMELIST(REF) };
+const int gamecount = lenof(gamelist);
diff --git a/apps/plugins/puzzles/loopgen.c b/apps/plugins/puzzles/loopgen.c
new file mode 100644
index 0000000000..25b63906fa
--- /dev/null
+++ b/apps/plugins/puzzles/loopgen.c
@@ -0,0 +1,536 @@
+/*
+ * loopgen.c: loop generation functions for grid.[ch].
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+#include "grid.h"
+#include "loopgen.h"
+
+
+/* We're going to store lists of current candidate faces for colouring black
+ * or white.
+ * Each face gets a 'score', which tells us how adding that face right
+ * now would affect the curliness of the solution loop.  We're trying to
+ * maximise that quantity so will bias our random selection of faces to
+ * colour those with high scores */
+struct face_score {
+    int white_score;
+    int black_score;
+    unsigned long random;
+    /* No need to store a grid_face* here.  The 'face_scores' array will
+     * be a list of 'face_score' objects, one for each face of the grid, so
+     * the position (index) within the 'face_scores' array will determine
+     * which face corresponds to a particular face_score.
+     * Having a single 'face_scores' array for all faces simplifies memory
+     * management, and probably improves performance, because we don't have to 
+     * malloc/free each individual face_score, and we don't have to maintain
+     * a mapping from grid_face* pointers to face_score* pointers.
+     */
+};
+
+static int generic_sort_cmpfn(void *v1, void *v2, size_t offset)
+{
+    struct face_score *f1 = v1;
+    struct face_score *f2 = v2;
+    int r;
+
+    r = *(int *)((char *)f2 + offset) - *(int *)((char *)f1 + offset);
+    if (r) {
+        return r;
+    }
+
+    if (f1->random < f2->random)
+        return -1;
+    else if (f1->random > f2->random)
+        return 1;
+
+    /*
+     * It's _just_ possible that two faces might have been given
+     * the same random value. In that situation, fall back to
+     * comparing based on the positions within the face_scores list.
+     * This introduces a tiny directional bias, but not a significant one.
+     */
+    return f1 - f2;
+}
+
+static int white_sort_cmpfn(void *v1, void *v2)
+{
+    return generic_sort_cmpfn(v1, v2, offsetof(struct face_score,white_score));
+}
+
+static int black_sort_cmpfn(void *v1, void *v2)
+{
+    return generic_sort_cmpfn(v1, v2, offsetof(struct face_score,black_score));
+}
+
+/* 'board' is an array of enum face_colour, indicating which faces are
+ * currently black/white/grey.  'colour' is FACE_WHITE or FACE_BLACK.
+ * Returns whether it's legal to colour the given face with this colour. */
+static int can_colour_face(grid *g, char* board, int face_index,
+                           enum face_colour colour)
+{
+    int i, j;
+    grid_face *test_face = g->faces + face_index;
+    grid_face *starting_face, *current_face;
+    grid_dot *starting_dot;
+    int transitions;
+    int current_state, s; /* booleans: equal or not-equal to 'colour' */
+    int found_same_coloured_neighbour = FALSE;
+    assert(board[face_index] != colour);
+
+    /* Can only consider a face for colouring if it's adjacent to a face
+     * with the same colour. */
+    for (i = 0; i < test_face->order; i++) {
+        grid_edge *e = test_face->edges[i];
+        grid_face *f = (e->face1 == test_face) ? e->face2 : e->face1;
+        if (FACE_COLOUR(f) == colour) {
+            found_same_coloured_neighbour = TRUE;
+            break;
+        }
+    }
+    if (!found_same_coloured_neighbour)
+        return FALSE;
+
+    /* Need to avoid creating a loop of faces of this colour around some
+     * differently-coloured faces.
+     * Also need to avoid meeting a same-coloured face at a corner, with
+     * other-coloured faces in between.  Here's a simple test that (I believe)
+     * takes care of both these conditions:
+     *
+     * Take the circular path formed by this face's edges, and inflate it
+     * slightly outwards.  Imagine walking around this path and consider
+     * the faces that you visit in sequence.  This will include all faces
+     * touching the given face, either along an edge or just at a corner.
+     * Count the number of 'colour'/not-'colour' transitions you encounter, as
+     * you walk along the complete loop.  This will obviously turn out to be
+     * an even number.
+     * If 0, we're either in the middle of an "island" of this colour (should
+     * be impossible as we're not supposed to create black or white loops),
+     * or we're about to start a new island - also not allowed.
+     * If 4 or greater, there are too many separate coloured regions touching
+     * this face, and colouring it would create a loop or a corner-violation.
+     * The only allowed case is when the count is exactly 2. */
+
+    /* i points to a dot around the test face.
+     * j points to a face around the i^th dot.
+     * The current face will always be:
+     *     test_face->dots[i]->faces[j]
+     * We assume dots go clockwise around the test face,
+     * and faces go clockwise around dots. */
+
+    /*
+     * The end condition is slightly fiddly. In sufficiently strange
+     * degenerate grids, our test face may be adjacent to the same
+     * other face multiple times (typically if it's the exterior
+     * face). Consider this, in particular:
+     * 
+     *   +--+
+     *   |  |
+     *   +--+--+
+     *   |  |  |
+     *   +--+--+
+     * 
+     * The bottom left face there is adjacent to the exterior face
+     * twice, so we can't just terminate our iteration when we reach
+     * the same _face_ we started at. Furthermore, we can't
+     * condition on having the same (i,j) pair either, because
+     * several (i,j) pairs identify the bottom left contiguity with
+     * the exterior face! We canonicalise the (i,j) pair by taking
+     * one step around before we set the termination tracking.
+     */
+
+    i = j = 0;
+    current_face = test_face->dots[0]->faces[0];
+    if (current_face == test_face) {
+        j = 1;
+        current_face = test_face->dots[0]->faces[1];
+    }
+    transitions = 0;
+    current_state = (FACE_COLOUR(current_face) == colour);
+    starting_dot = NULL;
+    starting_face = NULL;
+    while (TRUE) {
+        /* Advance to next face.
+         * Need to loop here because it might take several goes to
+         * find it. */
+        while (TRUE) {
+            j++;
+            if (j == test_face->dots[i]->order)
+                j = 0;
+
+            if (test_face->dots[i]->faces[j] == test_face) {
+                /* Advance to next dot round test_face, then
+                 * find current_face around new dot
+                 * and advance to the next face clockwise */
+                i++;
+                if (i == test_face->order)
+                    i = 0;
+                for (j = 0; j < test_face->dots[i]->order; j++) {
+                    if (test_face->dots[i]->faces[j] == current_face)
+                        break;
+                }
+                /* Must actually find current_face around new dot,
+                 * or else something's wrong with the grid. */
+                assert(j != test_face->dots[i]->order);
+                /* Found, so advance to next face and try again */
+            } else {
+                break;
+            }
+        }
+        /* (i,j) are now advanced to next face */
+        current_face = test_face->dots[i]->faces[j];
+        s = (FACE_COLOUR(current_face) == colour);
+        if (!starting_dot) {
+            starting_dot = test_face->dots[i];
+            starting_face = current_face;
+            current_state = s;
+        } else {
+            if (s != current_state) {
+                ++transitions;
+                current_state = s;
+                if (transitions > 2)
+                    break;
+            }
+            if (test_face->dots[i] == starting_dot &&
+                current_face == starting_face)
+                break;
+        }
+    }
+
+    return (transitions == 2) ? TRUE : FALSE;
+}
+
+/* Count the number of neighbours of 'face', having colour 'colour' */
+static int face_num_neighbours(grid *g, char *board, grid_face *face,
+                               enum face_colour colour)
+{
+    int colour_count = 0;
+    int i;
+    grid_face *f;
+    grid_edge *e;
+    for (i = 0; i < face->order; i++) {
+        e = face->edges[i];
+        f = (e->face1 == face) ? e->face2 : e->face1;
+        if (FACE_COLOUR(f) == colour)
+            ++colour_count;
+    }
+    return colour_count;
+}
+
+/* The 'score' of a face reflects its current desirability for selection
+ * as the next face to colour white or black.  We want to encourage moving
+ * into grey areas and increasing loopiness, so we give scores according to
+ * how many of the face's neighbours are currently coloured the same as the
+ * proposed colour. */
+static int face_score(grid *g, char *board, grid_face *face,
+                      enum face_colour colour)
+{
+    /* Simple formula: score = 0 - num. same-coloured neighbours,
+     * so a higher score means fewer same-coloured neighbours. */
+    return -face_num_neighbours(g, board, face, colour);
+}
+
+/*
+ * Generate a new complete random closed loop for the given grid.
+ *
+ * The method is to generate a WHITE/BLACK colouring of all the faces,
+ * such that the WHITE faces will define the inside of the path, and the
+ * BLACK faces define the outside.
+ * To do this, we initially colour all faces GREY.  The infinite space outside
+ * the grid is coloured BLACK, and we choose a random face to colour WHITE.
+ * Then we gradually grow the BLACK and the WHITE regions, eliminating GREY
+ * faces, until the grid is filled with BLACK/WHITE.  As we grow the regions,
+ * we avoid creating loops of a single colour, to preserve the topological
+ * shape of the WHITE and BLACK regions.
+ * We also try to make the boundary as loopy and twisty as possible, to avoid
+ * generating paths that are uninteresting.
+ * The algorithm works by choosing a BLACK/WHITE colour, then choosing a GREY
+ * face that can be coloured with that colour (without violating the
+ * topological shape of that region).  It's not obvious, but I think this
+ * algorithm is guaranteed to terminate without leaving any GREY faces behind.
+ * Indeed, if there are any GREY faces at all, both the WHITE and BLACK
+ * regions can be grown.
+ * This is checked using assert()ions, and I haven't seen any failures yet.
+ *
+ * Hand-wavy proof: imagine what can go wrong...
+ *
+ * Could the white faces get completely cut off by the black faces, and still
+ * leave some grey faces remaining?
+ * No, because then the black faces would form a loop around both the white
+ * faces and the grey faces, which is disallowed because we continually
+ * maintain the correct topological shape of the black region.
+ * Similarly, the black faces can never get cut off by the white faces.  That
+ * means both the WHITE and BLACK regions always have some room to grow into
+ * the GREY regions.
+ * Could it be that we can't colour some GREY face, because there are too many
+ * WHITE/BLACK transitions as we walk round the face? (see the
+ * can_colour_face() function for details)
+ * No.  Imagine otherwise, and we see WHITE/BLACK/WHITE/BLACK as we walk
+ * around the face.  The two WHITE faces would be connected by a WHITE path,
+ * and the BLACK faces would be connected by a BLACK path.  These paths would
+ * have to cross, which is impossible.
+ * Another thing that could go wrong: perhaps we can't find any GREY face to
+ * colour WHITE, because it would create a loop-violation or a corner-violation
+ * with the other WHITE faces?
+ * This is a little bit tricky to prove impossible.  Imagine you have such a
+ * GREY face (that is, if you coloured it WHITE, you would create a WHITE loop
+ * or corner violation).
+ * That would cut all the non-white area into two blobs.  One of those blobs
+ * must be free of BLACK faces (because the BLACK stuff is a connected blob).
+ * So we have a connected GREY area, completely surrounded by WHITE
+ * (including the GREY face we've tentatively coloured WHITE).
+ * A well-known result in graph theory says that you can always find a GREY
+ * face whose removal leaves the remaining GREY area connected.  And it says
+ * there are at least two such faces, so we can always choose the one that
+ * isn't the "tentative" GREY face.  Colouring that face WHITE leaves
+ * everything nice and connected, including that "tentative" GREY face which
+ * acts as a gateway to the rest of the non-WHITE grid.
+ */
+void generate_loop(grid *g, char *board, random_state *rs,
+                   loopgen_bias_fn_t bias, void *biasctx)
+{
+    int i, j;
+    int num_faces = g->num_faces;
+    struct face_score *face_scores; /* Array of face_score objects */
+    struct face_score *fs; /* Points somewhere in the above list */
+    struct grid_face *cur_face;
+    tree234 *lightable_faces_sorted;
+    tree234 *darkable_faces_sorted;
+    int *face_list;
+    int do_random_pass;
+
+    /* Make a board */
+    memset(board, FACE_GREY, num_faces);
+    
+    /* Create and initialise the list of face_scores */
+    face_scores = snewn(num_faces, struct face_score);
+    for (i = 0; i < num_faces; i++) {
+        face_scores[i].random = random_bits(rs, 31);
+        face_scores[i].black_score = face_scores[i].white_score = 0;
+    }
+    
+    /* Colour a random, finite face white.  The infinite face is implicitly
+     * coloured black.  Together, they will seed the random growth process
+     * for the black and white areas. */
+    i = random_upto(rs, num_faces);
+    board[i] = FACE_WHITE;
+
+    /* We need a way of favouring faces that will increase our loopiness.
+     * We do this by maintaining a list of all candidate faces sorted by
+     * their score and choose randomly from that with appropriate skew.
+     * In order to avoid consistently biasing towards particular faces, we
+     * need the sort order _within_ each group of scores to be completely
+     * random.  But it would be abusing the hospitality of the tree234 data
+     * structure if our comparison function were nondeterministic :-).  So with
+     * each face we associate a random number that does not change during a
+     * particular run of the generator, and use that as a secondary sort key.
+     * Yes, this means we will be biased towards particular random faces in
+     * any one run but that doesn't actually matter. */
+
+    lightable_faces_sorted = newtree234(white_sort_cmpfn);
+    darkable_faces_sorted = newtree234(black_sort_cmpfn);
+
+    /* Initialise the lists of lightable and darkable faces.  This is
+     * slightly different from the code inside the while-loop, because we need
+     * to check every face of the board (the grid structure does not keep a
+     * list of the infinite face's neighbours). */
+    for (i = 0; i < num_faces; i++) {
+        grid_face *f = g->faces + i;
+        struct face_score *fs = face_scores + i;
+        if (board[i] != FACE_GREY) continue;
+        /* We need the full colourability check here, it's not enough simply
+         * to check neighbourhood.  On some grids, a neighbour of the infinite
+         * face is not necessarily darkable. */
+        if (can_colour_face(g, board, i, FACE_BLACK)) {
+            fs->black_score = face_score(g, board, f, FACE_BLACK);
+            add234(darkable_faces_sorted, fs);
+        }
+        if (can_colour_face(g, board, i, FACE_WHITE)) {
+            fs->white_score = face_score(g, board, f, FACE_WHITE);
+            add234(lightable_faces_sorted, fs);
+        }
+    }
+
+    /* Colour faces one at a time until no more faces are colourable. */
+    while (TRUE)
+    {
+        enum face_colour colour;
+        tree234 *faces_to_pick;
+        int c_lightable = count234(lightable_faces_sorted);
+        int c_darkable = count234(darkable_faces_sorted);
+        if (c_lightable == 0 && c_darkable == 0) {
+            /* No more faces we can use at all. */
+            break;
+        }
+        assert(c_lightable != 0 && c_darkable != 0);
+
+        /* Choose a colour, and colour the best available face
+         * with that colour. */
+        colour = random_upto(rs, 2) ? FACE_WHITE : FACE_BLACK;
+
+        if (colour == FACE_WHITE)
+            faces_to_pick = lightable_faces_sorted;
+        else
+            faces_to_pick = darkable_faces_sorted;
+        if (bias) {
+            /*
+             * Go through all the candidate faces and pick the one the
+             * bias function likes best, breaking ties using the
+             * ordering in our tree234 (which is why we replace only
+             * if score > bestscore, not >=).
+             */
+            int j, k;
+            struct face_score *best = NULL;
+            int score, bestscore = 0;
+
+            for (j = 0;
+                 (fs = (struct face_score *)index234(faces_to_pick, j))!=NULL;
+                 j++) {
+
+                assert(fs);
+                k = fs - face_scores;
+                assert(board[k] == FACE_GREY);
+                board[k] = colour;
+                score = bias(biasctx, board, k);
+                board[k] = FACE_GREY;
+                bias(biasctx, board, k); /* let bias know we put it back */
+
+                if (!best || score > bestscore) {
+                    bestscore = score;
+                    best = fs;
+                }
+            }
+            fs = best;
+        } else {
+            fs = (struct face_score *)index234(faces_to_pick, 0);
+        }
+        assert(fs);
+        i = fs - face_scores;
+        assert(board[i] == FACE_GREY);
+        board[i] = colour;
+        if (bias)
+            bias(biasctx, board, i); /* notify bias function of the change */
+
+        /* Remove this newly-coloured face from the lists.  These lists should
+         * only contain grey faces. */
+        del234(lightable_faces_sorted, fs);
+        del234(darkable_faces_sorted, fs);
+
+        /* Remember which face we've just coloured */
+        cur_face = g->faces + i;
+
+        /* The face we've just coloured potentially affects the colourability
+         * and the scores of any neighbouring faces (touching at a corner or
+         * edge).  So the search needs to be conducted around all faces
+         * touching the one we've just lit.  Iterate over its corners, then
+         * over each corner's faces.  For each such face, we remove it from
+         * the lists, recalculate any scores, then add it back to the lists
+         * (depending on whether it is lightable, darkable or both). */
+        for (i = 0; i < cur_face->order; i++) {
+            grid_dot *d = cur_face->dots[i];
+            for (j = 0; j < d->order; j++) {
+                grid_face *f = d->faces[j];
+                int fi; /* face index of f */
+
+                if (f == NULL)
+                    continue;
+                if (f == cur_face)
+                    continue;
+                
+                /* If the face is already coloured, it won't be on our
+                 * lightable/darkable lists anyway, so we can skip it without 
+                 * bothering with the removal step. */
+                if (FACE_COLOUR(f) != FACE_GREY) continue; 
+
+                /* Find the face index and face_score* corresponding to f */
+                fi = f - g->faces;                
+                fs = face_scores + fi;
+
+                /* Remove from lightable list if it's in there.  We do this,
+                 * even if it is still lightable, because the score might
+                 * be different, and we need to remove-then-add to maintain
+                 * correct sort order. */
+                del234(lightable_faces_sorted, fs);
+                if (can_colour_face(g, board, fi, FACE_WHITE)) {
+                    fs->white_score = face_score(g, board, f, FACE_WHITE);
+                    add234(lightable_faces_sorted, fs);
+                }
+                /* Do the same for darkable list. */
+                del234(darkable_faces_sorted, fs);
+                if (can_colour_face(g, board, fi, FACE_BLACK)) {
+                    fs->black_score = face_score(g, board, f, FACE_BLACK);
+                    add234(darkable_faces_sorted, fs);
+                }
+            }
+        }
+    }
+
+    /* Clean up */
+    freetree234(lightable_faces_sorted);
+    freetree234(darkable_faces_sorted);
+    sfree(face_scores);
+
+    /* The next step requires a shuffled list of all faces */
+    face_list = snewn(num_faces, int);
+    for (i = 0; i < num_faces; ++i) {
+        face_list[i] = i;
+    }
+    shuffle(face_list, num_faces, sizeof(int), rs);
+
+    /* The above loop-generation algorithm can often leave large clumps
+     * of faces of one colour.  In extreme cases, the resulting path can be 
+     * degenerate and not very satisfying to solve.
+     * This next step alleviates this problem:
+     * Go through the shuffled list, and flip the colour of any face we can
+     * legally flip, and which is adjacent to only one face of the opposite
+     * colour - this tends to grow 'tendrils' into any clumps.
+     * Repeat until we can find no more faces to flip.  This will
+     * eventually terminate, because each flip increases the loop's
+     * perimeter, which cannot increase for ever.
+     * The resulting path will have maximal loopiness (in the sense that it
+     * cannot be improved "locally".  Unfortunately, this allows a player to
+     * make some illicit deductions.  To combat this (and make the path more
+     * interesting), we do one final pass making random flips. */
+
+    /* Set to TRUE for final pass */
+    do_random_pass = FALSE;
+
+    while (TRUE) {
+        /* Remember whether a flip occurred during this pass */
+        int flipped = FALSE;
+
+        for (i = 0; i < num_faces; ++i) {
+            int j = face_list[i];
+            enum face_colour opp =
+                (board[j] == FACE_WHITE) ? FACE_BLACK : FACE_WHITE;
+            if (can_colour_face(g, board, j, opp)) {
+                grid_face *face = g->faces +j;
+                if (do_random_pass) {
+                    /* final random pass */
+                    if (!random_upto(rs, 10))
+                        board[j] = opp;
+                } else {
+                    /* normal pass - flip when neighbour count is 1 */
+                    if (face_num_neighbours(g, board, face, opp) == 1) {
+                        board[j] = opp;
+                        flipped = TRUE;
+                    }
+                }
+            }
+        }
+
+        if (do_random_pass) break;
+        if (!flipped) do_random_pass = TRUE;
+    }
+
+    sfree(face_list);
+}
diff --git a/apps/plugins/puzzles/loopgen.h b/apps/plugins/puzzles/loopgen.h
new file mode 100644
index 0000000000..079c87c576
--- /dev/null
+++ b/apps/plugins/puzzles/loopgen.h
@@ -0,0 +1,35 @@
+/*
+ * loopgen.h: interface file for loop generation functions for grid.[ch].
+ */
+
+#ifndef _LOOPGEN_H
+#define _LOOPGEN_H
+
+#include "puzzles.h"
+#include "grid.h"
+
+enum face_colour { FACE_WHITE, FACE_GREY, FACE_BLACK };
+
+/* face should be of type grid_face* here. */
+#define FACE_COLOUR(face) \
+    ( (face) == NULL ? FACE_BLACK : \
+          board[(face) - g->faces] )
+
+typedef int (*loopgen_bias_fn_t)(void *ctx, char *board, int face);
+
+/* 'board' should be a char array whose length is the same as
+ * g->num_faces: this will be filled in with FACE_WHITE or FACE_BLACK
+ * after loop generation.
+ *
+ * If 'bias' is non-null, it should be a user-provided function which
+ * rates a half-finished board (i.e. may include some FACE_GREYs) for
+ * desirability; this will cause the loop generator to bias in favour
+ * of loops with a high return value from that function. The 'face'
+ * parameter to the bias function indicates which face of the grid has
+ * been modified since the last call; it is guaranteed that only one
+ * will have been (so that bias functions can work incrementally
+ * rather than re-scanning the whole grid on every call). */
+extern void generate_loop(grid *g, char *board, random_state *rs,
+                          loopgen_bias_fn_t bias, void *biasctx);
+
+#endif
diff --git a/apps/plugins/puzzles/loopy.R b/apps/plugins/puzzles/loopy.R
new file mode 100644
index 0000000000..f44560095d
--- /dev/null
+++ b/apps/plugins/puzzles/loopy.R
@@ -0,0 +1,31 @@
+# -*- makefile -*-
+
+LOOPY_EXTRA = tree234 dsf grid penrose loopgen
+
+loopy     : [X] GTK COMMON loopy LOOPY_EXTRA loopy-icon|no-icon
+
+loopy     : [G] WINDOWS COMMON loopy LOOPY_EXTRA loopy.res|noicon.res
+
+loopysolver :   [U] loopy[STANDALONE_SOLVER] LOOPY_EXTRA STANDALONE m.lib
+loopysolver :   [C] loopy[STANDALONE_SOLVER] LOOPY_EXTRA STANDALONE
+
+#penrose :    [U] penrose[TEST_PENROSE] STANDALONE m.lib
+#penrose :    [C] penrose[TEST_PENROSE] STANDALONE
+
+#test-basis : [U] penrose[TEST_VECTORS] tree234 STANDALONE m.lib
+#test-basis : [C] penrose[TEST_VECTORS] tree234 STANDALONE
+
+
+ALL += loopy[COMBINED] LOOPY_EXTRA
+
+!begin am gtk
+GAMES += loopy
+!end
+
+!begin >list.c
+    A(loopy) \
+!end
+
+!begin >gamedesc.txt
+loopy:loopy.exe:Loopy:Loop-drawing puzzle:Draw a single closed loop, given clues about number of adjacent edges.
+!end
diff --git a/apps/plugins/puzzles/loopy.c b/apps/plugins/puzzles/loopy.c
new file mode 100644
index 0000000000..a931b31c37
--- /dev/null
+++ b/apps/plugins/puzzles/loopy.c
@@ -0,0 +1,3688 @@
+/*
+ * loopy.c:
+ *
+ * An implementation of the Nikoli game 'Loop the loop'.
+ * (c) Mike Pinna, 2005, 2006
+ * Substantially rewritten to allowing for more general types of grid.
+ * (c) Lambros Lambrou 2008
+ *
+ * vim: set shiftwidth=4 :set textwidth=80:
+ */
+
+/*
+ * Possible future solver enhancements:
+ * 
+ *  - There's an interesting deductive technique which makes use
+ *    of topology rather than just graph theory. Each _face_ in
+ *    the grid is either inside or outside the loop; you can tell
+ *    that two faces are on the same side of the loop if they're
+ *    separated by a LINE_NO (or, more generally, by a path
+ *    crossing no LINE_UNKNOWNs and an even number of LINE_YESes),
+ *    and on the opposite side of the loop if they're separated by
+ *    a LINE_YES (or an odd number of LINE_YESes and no
+ *    LINE_UNKNOWNs). Oh, and any face separated from the outside
+ *    of the grid by a LINE_YES or a LINE_NO is on the inside or
+ *    outside respectively. So if you can track this for all
+ *    faces, you figure out the state of the line between a pair
+ *    once their relative insideness is known.
+ *     + The way I envisage this working is simply to keep an edsf
+ *       of all _faces_, which indicates whether they're on
+ *       opposite sides of the loop from one another. We also
+ *       include a special entry in the edsf for the infinite
+ *       exterior "face".
+ *     + So, the simple way to do this is to just go through the
+ *       edges: every time we see an edge in a state other than
+ *       LINE_UNKNOWN which separates two faces that aren't in the
+ *       same edsf class, we can rectify that by merging the
+ *       classes. Then, conversely, an edge in LINE_UNKNOWN state
+ *       which separates two faces that _are_ in the same edsf
+ *       class can immediately have its state determined.
+ *     + But you can go one better, if you're prepared to loop
+ *       over all _pairs_ of edges. Suppose we have edges A and B,
+ *       which respectively separate faces A1,A2 and B1,B2.
+ *       Suppose that A,B are in the same edge-edsf class and that
+ *       A1,B1 (wlog) are in the same face-edsf class; then we can
+ *       immediately place A2,B2 into the same face-edsf class (as
+ *       each other, not as A1 and A2) one way round or the other.
+ *       And conversely again, if A1,B1 are in the same face-edsf
+ *       class and so are A2,B2, then we can put A,B into the same
+ *       face-edsf class.
+ *        * Of course, this deduction requires a quadratic-time
+ *          loop over all pairs of edges in the grid, so it should
+ *          be reserved until there's nothing easier left to be
+ *          done.
+ * 
+ *  - The generalised grid support has made me (SGT) notice a
+ *    possible extension to the loop-avoidance code. When you have
+ *    a path of connected edges such that no other edges at all
+ *    are incident on any vertex in the middle of the path - or,
+ *    alternatively, such that any such edges are already known to
+ *    be LINE_NO - then you know those edges are either all
+ *    LINE_YES or all LINE_NO. Hence you can mentally merge the
+ *    entire path into a single long curly edge for the purposes
+ *    of loop avoidance, and look directly at whether or not the
+ *    extreme endpoints of the path are connected by some other
+ *    route. I find this coming up fairly often when I play on the
+ *    octagonal grid setting, so it might be worth implementing in
+ *    the solver.
+ *
+ *  - (Just a speed optimisation.)  Consider some todo list queue where every
+ *    time we modify something we mark it for consideration by other bits of
+ *    the solver, to save iteration over things that have already been done.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+#include "grid.h"
+#include "loopgen.h"
+
+/* Debugging options */
+
+/*
+#define DEBUG_CACHES
+#define SHOW_WORKING
+#define DEBUG_DLINES
+*/
+
+/* ----------------------------------------------------------------------
+ * Struct, enum and function declarations
+ */
+
+enum {
+    COL_BACKGROUND,
+    COL_FOREGROUND,
+    COL_LINEUNKNOWN,
+    COL_HIGHLIGHT,
+    COL_MISTAKE,
+    COL_SATISFIED,
+    COL_FAINT,
+    NCOLOURS
+};
+
+struct game_state {
+    grid *game_grid; /* ref-counted (internally) */
+
+    /* Put -1 in a face that doesn't get a clue */
+    signed char *clues;
+
+    /* Array of line states, to store whether each line is
+     * YES, NO or UNKNOWN */
+    char *lines;
+
+    unsigned char *line_errors;
+    int exactly_one_loop;
+
+    int solved;
+    int cheated;
+
+    /* Used in game_text_format(), so that it knows what type of
+     * grid it's trying to render as ASCII text. */
+    int grid_type;
+};
+
+enum solver_status {
+    SOLVER_SOLVED,    /* This is the only solution the solver could find */
+    SOLVER_MISTAKE,   /* This is definitely not a solution */
+    SOLVER_AMBIGUOUS, /* This _might_ be an ambiguous solution */
+    SOLVER_INCOMPLETE /* This may be a partial solution */
+};
+
+/* ------ Solver state ------ */
+typedef struct solver_state {
+    game_state *state;
+    enum solver_status solver_status;
+    /* NB looplen is the number of dots that are joined together at a point, ie a
+     * looplen of 1 means there are no lines to a particular dot */
+    int *looplen;
+
+    /* Difficulty level of solver.  Used by solver functions that want to
+     * vary their behaviour depending on the requested difficulty level. */
+    int diff;
+
+    /* caches */
+    char *dot_yes_count;
+    char *dot_no_count;
+    char *face_yes_count;
+    char *face_no_count;
+    char *dot_solved, *face_solved;
+    int *dotdsf;
+
+    /* Information for Normal level deductions:
+     * For each dline, store a bitmask for whether we know:
+     * (bit 0) at least one is YES
+     * (bit 1) at most one is YES */
+    char *dlines;
+
+    /* Hard level information */
+    int *linedsf;
+} solver_state;
+
+/*
+ * Difficulty levels. I do some macro ickery here to ensure that my
+ * enum and the various forms of my name list always match up.
+ */
+
+#define DIFFLIST(A) \
+    A(EASY,Easy,e) \
+    A(NORMAL,Normal,n) \
+    A(TRICKY,Tricky,t) \
+    A(HARD,Hard,h)
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFF_MAX };
+static char const *const diffnames[] = { DIFFLIST(TITLE) };
+static char const diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+/*
+ * Solver routines, sorted roughly in order of computational cost.
+ * The solver will run the faster deductions first, and slower deductions are
+ * only invoked when the faster deductions are unable to make progress.
+ * Each function is associated with a difficulty level, so that the generated
+ * puzzles are solvable by applying only the functions with the chosen
+ * difficulty level or lower.
+ */
+#define SOLVERLIST(A) \
+    A(trivial_deductions, DIFF_EASY) \
+    A(dline_deductions, DIFF_NORMAL) \
+    A(linedsf_deductions, DIFF_HARD) \
+    A(loop_deductions, DIFF_EASY)
+#define SOLVER_FN_DECL(fn,diff) static int fn(solver_state *);
+#define SOLVER_FN(fn,diff) &fn,
+#define SOLVER_DIFF(fn,diff) diff,
+SOLVERLIST(SOLVER_FN_DECL)
+static int (*(solver_fns[]))(solver_state *) = { SOLVERLIST(SOLVER_FN) };
+static int const solver_diffs[] = { SOLVERLIST(SOLVER_DIFF) };
+static const int NUM_SOLVERS = sizeof(solver_diffs)/sizeof(*solver_diffs);
+
+struct game_params {
+    int w, h;
+    int diff;
+    int type;
+};
+
+/* line_drawstate is the same as line_state, but with the extra ERROR
+ * possibility.  The drawing code copies line_state to line_drawstate,
+ * except in the case that the line is an error. */
+enum line_state { LINE_YES, LINE_UNKNOWN, LINE_NO };
+enum line_drawstate { DS_LINE_YES, DS_LINE_UNKNOWN,
+                      DS_LINE_NO, DS_LINE_ERROR };
+
+#define OPP(line_state) \
+    (2 - line_state)
+
+
+struct game_drawstate {
+    int started;
+    int tilesize;
+    int flashing;
+    int *textx, *texty;
+    char *lines;
+    char *clue_error;
+    char *clue_satisfied;
+};
+
+static char *validate_desc(const game_params *params, const char *desc);
+static int dot_order(const game_state* state, int i, char line_type);
+static int face_order(const game_state* state, int i, char line_type);
+static solver_state *solve_game_rec(const solver_state *sstate);
+
+#ifdef DEBUG_CACHES
+static void check_caches(const solver_state* sstate);
+#else
+#define check_caches(s)
+#endif
+
+/* ------- List of grid generators ------- */
+#define GRIDLIST(A) \
+    A(Squares,GRID_SQUARE,3,3) \
+    A(Triangular,GRID_TRIANGULAR,3,3) \
+    A(Honeycomb,GRID_HONEYCOMB,3,3) \
+    A(Snub-Square,GRID_SNUBSQUARE,3,3) \
+    A(Cairo,GRID_CAIRO,3,4) \
+    A(Great-Hexagonal,GRID_GREATHEXAGONAL,3,3) \
+    A(Octagonal,GRID_OCTAGONAL,3,3) \
+    A(Kites,GRID_KITE,3,3) \
+    A(Floret,GRID_FLORET,1,2) \
+    A(Dodecagonal,GRID_DODECAGONAL,2,2) \
+    A(Great-Dodecagonal,GRID_GREATDODECAGONAL,2,2) \
+    A(Penrose (kite/dart),GRID_PENROSE_P2,3,3) \
+    A(Penrose (rhombs),GRID_PENROSE_P3,3,3)
+
+#define GRID_NAME(title,type,amin,omin) #title,
+#define GRID_CONFIG(title,type,amin,omin) ":" #title
+#define GRID_TYPE(title,type,amin,omin) type,
+#define GRID_SIZES(title,type,amin,omin) \
+    {amin, omin, \
+     "Width and height for this grid type must both be at least " #amin, \
+     "At least one of width and height for this grid type must be at least " #omin,},
+static char const *const gridnames[] = { GRIDLIST(GRID_NAME) };
+#define GRID_CONFIGS GRIDLIST(GRID_CONFIG)
+static grid_type grid_types[] = { GRIDLIST(GRID_TYPE) };
+#define NUM_GRID_TYPES (sizeof(grid_types) / sizeof(grid_types[0]))
+static const struct {
+    int amin, omin;
+    char *aerr, *oerr;
+} grid_size_limits[] = { GRIDLIST(GRID_SIZES) };
+
+/* Generates a (dynamically allocated) new grid, according to the
+ * type and size requested in params.  Does nothing if the grid is already
+ * generated. */
+static grid *loopy_generate_grid(const game_params *params,
+                                 const char *grid_desc)
+{
+    return grid_new(grid_types[params->type], params->w, params->h, grid_desc);
+}
+
+/* ----------------------------------------------------------------------
+ * Preprocessor magic
+ */
+
+/* General constants */
+#define PREFERRED_TILE_SIZE 32
+#define BORDER(tilesize) ((tilesize) / 2)
+#define FLASH_TIME 0.5F
+
+#define BIT_SET(field, bit) ((field) & (1<<(bit)))
+
+#define SET_BIT(field, bit)  (BIT_SET(field, bit) ? FALSE : \
+                              ((field) |= (1<<(bit)), TRUE))
+
+#define CLEAR_BIT(field, bit) (BIT_SET(field, bit) ? \
+                               ((field) &= ~(1<<(bit)), TRUE) : FALSE)
+
+#define CLUE2CHAR(c) \
+    ((c < 0) ? ' ' : c < 10 ? c + '0' : c - 10 + 'A')
+
+/* ----------------------------------------------------------------------
+ * General struct manipulation and other straightforward code
+ */
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->game_grid = state->game_grid;
+    ret->game_grid->refcount++;
+
+    ret->solved = state->solved;
+    ret->cheated = state->cheated;
+
+    ret->clues = snewn(state->game_grid->num_faces, signed char);
+    memcpy(ret->clues, state->clues, state->game_grid->num_faces);
+
+    ret->lines = snewn(state->game_grid->num_edges, char);
+    memcpy(ret->lines, state->lines, state->game_grid->num_edges);
+
+    ret->line_errors = snewn(state->game_grid->num_edges, unsigned char);
+    memcpy(ret->line_errors, state->line_errors, state->game_grid->num_edges);
+    ret->exactly_one_loop = state->exactly_one_loop;
+
+    ret->grid_type = state->grid_type;
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (state) {
+        grid_free(state->game_grid);
+        sfree(state->clues);
+        sfree(state->lines);
+        sfree(state->line_errors);
+        sfree(state);
+    }
+}
+
+static solver_state *new_solver_state(const game_state *state, int diff) {
+    int i;
+    int num_dots = state->game_grid->num_dots;
+    int num_faces = state->game_grid->num_faces;
+    int num_edges = state->game_grid->num_edges;
+    solver_state *ret = snew(solver_state);
+
+    ret->state = dup_game(state);
+
+    ret->solver_status = SOLVER_INCOMPLETE;
+    ret->diff = diff;
+
+    ret->dotdsf = snew_dsf(num_dots);
+    ret->looplen = snewn(num_dots, int);
+
+    for (i = 0; i < num_dots; i++) {
+        ret->looplen[i] = 1;
+    }
+
+    ret->dot_solved = snewn(num_dots, char);
+    ret->face_solved = snewn(num_faces, char);
+    memset(ret->dot_solved, FALSE, num_dots);
+    memset(ret->face_solved, FALSE, num_faces);
+
+    ret->dot_yes_count = snewn(num_dots, char);
+    memset(ret->dot_yes_count, 0, num_dots);
+    ret->dot_no_count = snewn(num_dots, char);
+    memset(ret->dot_no_count, 0, num_dots);
+    ret->face_yes_count = snewn(num_faces, char);
+    memset(ret->face_yes_count, 0, num_faces);
+    ret->face_no_count = snewn(num_faces, char);
+    memset(ret->face_no_count, 0, num_faces);
+
+    if (diff < DIFF_NORMAL) {
+        ret->dlines = NULL;
+    } else {
+        ret->dlines = snewn(2*num_edges, char);
+        memset(ret->dlines, 0, 2*num_edges);
+    }
+
+    if (diff < DIFF_HARD) {
+        ret->linedsf = NULL;
+    } else {
+        ret->linedsf = snew_dsf(state->game_grid->num_edges);
+    }
+
+    return ret;
+}
+
+static void free_solver_state(solver_state *sstate) {
+    if (sstate) {
+        free_game(sstate->state);
+        sfree(sstate->dotdsf);
+        sfree(sstate->looplen);
+        sfree(sstate->dot_solved);
+        sfree(sstate->face_solved);
+        sfree(sstate->dot_yes_count);
+        sfree(sstate->dot_no_count);
+        sfree(sstate->face_yes_count);
+        sfree(sstate->face_no_count);
+
+        /* OK, because sfree(NULL) is a no-op */
+        sfree(sstate->dlines);
+        sfree(sstate->linedsf);
+
+        sfree(sstate);
+    }
+}
+
+static solver_state *dup_solver_state(const solver_state *sstate) {
+    game_state *state = sstate->state;
+    int num_dots = state->game_grid->num_dots;
+    int num_faces = state->game_grid->num_faces;
+    int num_edges = state->game_grid->num_edges;
+    solver_state *ret = snew(solver_state);
+
+    ret->state = state = dup_game(sstate->state);
+
+    ret->solver_status = sstate->solver_status;
+    ret->diff = sstate->diff;
+
+    ret->dotdsf = snewn(num_dots, int);
+    ret->looplen = snewn(num_dots, int);
+    memcpy(ret->dotdsf, sstate->dotdsf,
+           num_dots * sizeof(int));
+    memcpy(ret->looplen, sstate->looplen,
+           num_dots * sizeof(int));
+
+    ret->dot_solved = snewn(num_dots, char);
+    ret->face_solved = snewn(num_faces, char);
+    memcpy(ret->dot_solved, sstate->dot_solved, num_dots);
+    memcpy(ret->face_solved, sstate->face_solved, num_faces);
+
+    ret->dot_yes_count = snewn(num_dots, char);
+    memcpy(ret->dot_yes_count, sstate->dot_yes_count, num_dots);
+    ret->dot_no_count = snewn(num_dots, char);
+    memcpy(ret->dot_no_count, sstate->dot_no_count, num_dots);
+
+    ret->face_yes_count = snewn(num_faces, char);
+    memcpy(ret->face_yes_count, sstate->face_yes_count, num_faces);
+    ret->face_no_count = snewn(num_faces, char);
+    memcpy(ret->face_no_count, sstate->face_no_count, num_faces);
+
+    if (sstate->dlines) {
+        ret->dlines = snewn(2*num_edges, char);
+        memcpy(ret->dlines, sstate->dlines,
+               2*num_edges);
+    } else {
+        ret->dlines = NULL;
+    }
+
+    if (sstate->linedsf) {
+        ret->linedsf = snewn(num_edges, int);
+        memcpy(ret->linedsf, sstate->linedsf,
+               num_edges * sizeof(int));
+    } else {
+        ret->linedsf = NULL;
+    }
+
+    return ret;
+}
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+#ifdef SLOW_SYSTEM
+    ret->h = 7;
+    ret->w = 7;
+#else
+    ret->h = 10;
+    ret->w = 10;
+#endif
+    ret->diff = DIFF_EASY;
+    ret->type = 0;
+
+    return ret;
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+
+    *ret = *params;                       /* structure copy */
+    return ret;
+}
+
+static const game_params presets[] = {
+#ifdef SMALL_SCREEN
+    {  7,  7, DIFF_EASY, 0 },
+    {  7,  7, DIFF_NORMAL, 0 },
+    {  7,  7, DIFF_HARD, 0 },
+    {  7,  7, DIFF_HARD, 1 },
+    {  7,  7, DIFF_HARD, 2 },
+    {  5,  5, DIFF_HARD, 3 },
+    {  7,  7, DIFF_HARD, 4 },
+    {  5,  4, DIFF_HARD, 5 },
+    {  5,  5, DIFF_HARD, 6 },
+    {  5,  5, DIFF_HARD, 7 },
+    {  3,  3, DIFF_HARD, 8 },
+    {  3,  3, DIFF_HARD, 9 },
+    {  3,  3, DIFF_HARD, 10 },
+    {  6,  6, DIFF_HARD, 11 },
+    {  6,  6, DIFF_HARD, 12 },
+#else
+    {  7,  7, DIFF_EASY, 0 },
+    {  10,  10, DIFF_EASY, 0 },
+    {  7,  7, DIFF_NORMAL, 0 },
+    {  10,  10, DIFF_NORMAL, 0 },
+    {  7,  7, DIFF_HARD, 0 },
+    {  10,  10, DIFF_HARD, 0 },
+    {  10,  10, DIFF_HARD, 1 },
+    {  12,  10, DIFF_HARD, 2 },
+    {  7,  7, DIFF_HARD, 3 },
+    {  9,  9, DIFF_HARD, 4 },
+    {  5,  4, DIFF_HARD, 5 },
+    {  7,  7, DIFF_HARD, 6 },
+    {  5,  5, DIFF_HARD, 7 },
+    {  5,  5, DIFF_HARD, 8 },
+    {  5,  4, DIFF_HARD, 9 },
+    {  5,  4, DIFF_HARD, 10 },
+    {  10, 10, DIFF_HARD, 11 },
+    {  10, 10, DIFF_HARD, 12 }
+#endif
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *tmppar;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(presets))
+        return FALSE;
+
+    tmppar = snew(game_params);
+    *tmppar = presets[i];
+    *params = tmppar;
+    sprintf(buf, "%dx%d %s - %s", tmppar->h, tmppar->w,
+            gridnames[tmppar->type], diffnames[tmppar->diff]);
+    *name = dupstr(buf);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->h = params->w = atoi(string);
+    params->diff = DIFF_EASY;
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        params->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 't') {
+        string++;
+        params->type = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 'd') {
+        int i;
+        string++;
+        for (i = 0; i < DIFF_MAX; i++)
+            if (*string == diffchars[i])
+                params->diff = i;
+        if (*string) string++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char str[80];
+    sprintf(str, "%dx%dt%d", params->w, params->h, params->type);
+    if (full)
+        sprintf(str + strlen(str), "d%c", diffchars[params->diff]);
+    return dupstr(str);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(5, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Grid type";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = GRID_CONFIGS;
+    ret[2].ival = params->type;
+
+    ret[3].name = "Difficulty";
+    ret[3].type = C_CHOICES;
+    ret[3].sval = DIFFCONFIG;
+    ret[3].ival = params->diff;
+
+    ret[4].name = NULL;
+    ret[4].type = C_END;
+    ret[4].sval = NULL;
+    ret[4].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->type = cfg[2].ival;
+    ret->diff = cfg[3].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->type < 0 || params->type >= NUM_GRID_TYPES)
+        return "Illegal grid type";
+    if (params->w < grid_size_limits[params->type].amin ||
+        params->h < grid_size_limits[params->type].amin)
+        return grid_size_limits[params->type].aerr;
+    if (params->w < grid_size_limits[params->type].omin &&
+        params->h < grid_size_limits[params->type].omin)
+        return grid_size_limits[params->type].oerr;
+
+    /*
+     * This shouldn't be able to happen at all, since decode_params
+     * and custom_params will never generate anything that isn't
+     * within range.
+     */
+    assert(params->diff < DIFF_MAX);
+
+    return NULL;
+}
+
+/* Returns a newly allocated string describing the current puzzle */
+static char *state_to_text(const game_state *state)
+{
+    grid *g = state->game_grid;
+    char *retval;
+    int num_faces = g->num_faces;
+    char *description = snewn(num_faces + 1, char);
+    char *dp = description;
+    int empty_count = 0;
+    int i;
+
+    for (i = 0; i < num_faces; i++) {
+        if (state->clues[i] < 0) {
+            if (empty_count > 25) {
+                dp += sprintf(dp, "%c", (int)(empty_count + 'a' - 1));
+                empty_count = 0;
+            }
+            empty_count++;
+        } else {
+            if (empty_count) {
+                dp += sprintf(dp, "%c", (int)(empty_count + 'a' - 1));
+                empty_count = 0;
+            }
+            dp += sprintf(dp, "%c", (int)CLUE2CHAR(state->clues[i]));
+        }
+    }
+
+    if (empty_count)
+        dp += sprintf(dp, "%c", (int)(empty_count + 'a' - 1));
+
+    retval = dupstr(description);
+    sfree(description);
+
+    return retval;
+}
+
+#define GRID_DESC_SEP '_'
+
+/* Splits up a (optional) grid_desc from the game desc. Returns the
+ * grid_desc (which needs freeing) and updates the desc pointer to
+ * start of real desc, or returns NULL if no desc. */
+static char *extract_grid_desc(const char **desc)
+{
+    char *sep = strchr(*desc, GRID_DESC_SEP), *gd;
+    int gd_len;
+
+    if (!sep) return NULL;
+
+    gd_len = sep - (*desc);
+    gd = snewn(gd_len+1, char);
+    memcpy(gd, *desc, gd_len);
+    gd[gd_len] = '\0';
+
+    *desc = sep+1;
+
+    return gd;
+}
+
+/* We require that the params pass the test in validate_params and that the
+ * description fills the entire game area */
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int count = 0;
+    grid *g;
+    char *grid_desc, *ret;
+
+    /* It's pretty inefficient to do this just for validation. All we need to
+     * know is the precise number of faces. */
+    grid_desc = extract_grid_desc(&desc);
+    ret = grid_validate_desc(grid_types[params->type], params->w, params->h, grid_desc);
+    if (ret) return ret;
+
+    g = loopy_generate_grid(params, grid_desc);
+    if (grid_desc) sfree(grid_desc);
+
+    for (; *desc; ++desc) {
+        if ((*desc >= '0' && *desc <= '9') || (*desc >= 'A' && *desc <= 'Z')) {
+            count++;
+            continue;
+        }
+        if (*desc >= 'a') {
+            count += *desc - 'a' + 1;
+            continue;
+        }
+        return "Unknown character in description";
+    }
+
+    if (count < g->num_faces)
+        return "Description too short for board size";
+    if (count > g->num_faces)
+        return "Description too long for board size";
+
+    grid_free(g);
+
+    return NULL;
+}
+
+/* Sums the lengths of the numbers in range [0,n) */
+/* See equivalent function in solo.c for justification of this. */
+static int len_0_to_n(int n)
+{
+    int len = 1; /* Counting 0 as a bit of a special case */
+    int i;
+
+    for (i = 1; i < n; i *= 10) {
+        len += max(n - i, 0);
+    }
+
+    return len;
+}
+
+static char *encode_solve_move(const game_state *state)
+{
+    int len;
+    char *ret, *p;
+    int i;
+    int num_edges = state->game_grid->num_edges;
+
+    /* This is going to return a string representing the moves needed to set
+     * every line in a grid to be the same as the ones in 'state'.  The exact
+     * length of this string is predictable. */
+
+    len = 1;  /* Count the 'S' prefix */
+    /* Numbers in all lines */
+    len += len_0_to_n(num_edges);
+    /* For each line we also have a letter */
+    len += num_edges;
+
+    ret = snewn(len + 1, char);
+    p = ret;
+
+    p += sprintf(p, "S");
+
+    for (i = 0; i < num_edges; i++) {
+        switch (state->lines[i]) {
+          case LINE_YES:
+            p += sprintf(p, "%dy", i);
+            break;
+          case LINE_NO:
+            p += sprintf(p, "%dn", i);
+            break;
+        }
+    }
+
+    /* No point in doing sums like that if they're going to be wrong */
+    assert(strlen(ret) <= (size_t)len);
+    return ret;
+}
+
+static game_ui *new_ui(const game_state *state)
+{
+    return NULL;
+}
+
+static void free_ui(game_ui *ui)
+{
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    int grid_width, grid_height, rendered_width, rendered_height;
+    int g_tilesize;
+
+    grid_compute_size(grid_types[params->type], params->w, params->h,
+                      &g_tilesize, &grid_width, &grid_height);
+
+    /* multiply first to minimise rounding error on integer division */
+    rendered_width = grid_width * tilesize / g_tilesize;
+    rendered_height = grid_height * tilesize / g_tilesize;
+    *x = rendered_width + 2 * BORDER(tilesize) + 1;
+    *y = rendered_height + 2 * BORDER(tilesize) + 1;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_FOREGROUND * 3 + 0] = 0.0F;
+    ret[COL_FOREGROUND * 3 + 1] = 0.0F;
+    ret[COL_FOREGROUND * 3 + 2] = 0.0F;
+
+    /*
+     * We want COL_LINEUNKNOWN to be a yellow which is a bit darker
+     * than the background. (I previously set it to 0.8,0.8,0, but
+     * found that this went badly with the 0.8,0.8,0.8 favoured as a
+     * background by the Java frontend.)
+     */
+    ret[COL_LINEUNKNOWN * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.9F;
+    ret[COL_LINEUNKNOWN * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 0.9F;
+    ret[COL_LINEUNKNOWN * 3 + 2] = 0.0F;
+
+    ret[COL_HIGHLIGHT * 3 + 0] = 1.0F;
+    ret[COL_HIGHLIGHT * 3 + 1] = 1.0F;
+    ret[COL_HIGHLIGHT * 3 + 2] = 1.0F;
+
+    ret[COL_MISTAKE * 3 + 0] = 1.0F;
+    ret[COL_MISTAKE * 3 + 1] = 0.0F;
+    ret[COL_MISTAKE * 3 + 2] = 0.0F;
+
+    ret[COL_SATISFIED * 3 + 0] = 0.0F;
+    ret[COL_SATISFIED * 3 + 1] = 0.0F;
+    ret[COL_SATISFIED * 3 + 2] = 0.0F;
+
+    /* We want the faint lines to be a bit darker than the background.
+     * Except if the background is pretty dark already; then it ought to be a
+     * bit lighter.  Oy vey.
+     */
+    ret[COL_FAINT * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.9F;
+    ret[COL_FAINT * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 0.9F;
+    ret[COL_FAINT * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 0.9F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int num_faces = state->game_grid->num_faces;
+    int num_edges = state->game_grid->num_edges;
+    int i;
+
+    ds->tilesize = 0;
+    ds->started = 0;
+    ds->lines = snewn(num_edges, char);
+    ds->clue_error = snewn(num_faces, char);
+    ds->clue_satisfied = snewn(num_faces, char);
+    ds->textx = snewn(num_faces, int);
+    ds->texty = snewn(num_faces, int);
+    ds->flashing = 0;
+
+    memset(ds->lines, LINE_UNKNOWN, num_edges);
+    memset(ds->clue_error, 0, num_faces);
+    memset(ds->clue_satisfied, 0, num_faces);
+    for (i = 0; i < num_faces; i++)
+        ds->textx[i] = ds->texty[i] = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->textx);
+    sfree(ds->texty);
+    sfree(ds->clue_error);
+    sfree(ds->clue_satisfied);
+    sfree(ds->lines);
+    sfree(ds);
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    if (params->type != 0)
+        return FALSE;
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w, h, W, H;
+    int x, y, i;
+    int cell_size;
+    char *ret;
+    grid *g = state->game_grid;
+    grid_face *f;
+
+    assert(state->grid_type == 0);
+
+    /* Work out the basic size unit */
+    f = g->faces; /* first face */
+    assert(f->order == 4);
+    /* The dots are ordered clockwise, so the two opposite
+     * corners are guaranteed to span the square */
+    cell_size = abs(f->dots[0]->x - f->dots[2]->x);
+
+    w = (g->highest_x - g->lowest_x) / cell_size;
+    h = (g->highest_y - g->lowest_y) / cell_size;
+
+    /* Create a blank "canvas" to "draw" on */
+    W = 2 * w + 2;
+    H = 2 * h + 1;
+    ret = snewn(W * H + 1, char);
+    for (y = 0; y < H; y++) {
+        for (x = 0; x < W-1; x++) {
+            ret[y*W + x] = ' ';
+        }
+        ret[y*W + W-1] = '\n';
+    }
+    ret[H*W] = '\0';
+
+    /* Fill in edge info */
+    for (i = 0; i < g->num_edges; i++) {
+        grid_edge *e = g->edges + i;
+        /* Cell coordinates, from (0,0) to (w-1,h-1) */
+        int x1 = (e->dot1->x - g->lowest_x) / cell_size;
+        int x2 = (e->dot2->x - g->lowest_x) / cell_size;
+        int y1 = (e->dot1->y - g->lowest_y) / cell_size;
+        int y2 = (e->dot2->y - g->lowest_y) / cell_size;
+        /* Midpoint, in canvas coordinates (canvas coordinates are just twice
+         * cell coordinates) */
+        x = x1 + x2;
+        y = y1 + y2;
+        switch (state->lines[i]) {
+          case LINE_YES:
+            ret[y*W + x] = (y1 == y2) ? '-' : '|';
+            break;
+          case LINE_NO:
+            ret[y*W + x] = 'x';
+            break;
+          case LINE_UNKNOWN:
+            break; /* already a space */
+          default:
+            assert(!"Illegal line state");
+        }
+    }
+
+    /* Fill in clues */
+    for (i = 0; i < g->num_faces; i++) {
+        int x1, x2, y1, y2;
+
+        f = g->faces + i;
+        assert(f->order == 4);
+        /* Cell coordinates, from (0,0) to (w-1,h-1) */
+        x1 = (f->dots[0]->x - g->lowest_x) / cell_size;
+        x2 = (f->dots[2]->x - g->lowest_x) / cell_size;
+        y1 = (f->dots[0]->y - g->lowest_y) / cell_size;
+        y2 = (f->dots[2]->y - g->lowest_y) / cell_size;
+        /* Midpoint, in canvas coordinates */
+        x = x1 + x2;
+        y = y1 + y2;
+        ret[y*W + x] = CLUE2CHAR(state->clues[i]);
+    }
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Debug code
+ */
+
+#ifdef DEBUG_CACHES
+static void check_caches(const solver_state* sstate)
+{
+    int i;
+    const game_state *state = sstate->state;
+    const grid *g = state->game_grid;
+
+    for (i = 0; i < g->num_dots; i++) {
+        assert(dot_order(state, i, LINE_YES) == sstate->dot_yes_count[i]);
+        assert(dot_order(state, i, LINE_NO) == sstate->dot_no_count[i]);
+    }
+
+    for (i = 0; i < g->num_faces; i++) {
+        assert(face_order(state, i, LINE_YES) == sstate->face_yes_count[i]);
+        assert(face_order(state, i, LINE_NO) == sstate->face_no_count[i]);
+    }
+}
+
+#if 0
+#define check_caches(s) \
+    do { \
+        fprintf(stderr, "check_caches at line %d\n", __LINE__); \
+        check_caches(s); \
+    } while (0)
+#endif
+#endif /* DEBUG_CACHES */
+
+/* ----------------------------------------------------------------------
+ * Solver utility functions
+ */
+
+/* Sets the line (with index i) to the new state 'line_new', and updates
+ * the cached counts of any affected faces and dots.
+ * Returns TRUE if this actually changed the line's state. */
+static int solver_set_line(solver_state *sstate, int i,
+                           enum line_state line_new
+#ifdef SHOW_WORKING
+                           , const char *reason
+#endif
+                           )
+{
+    game_state *state = sstate->state;
+    grid *g;
+    grid_edge *e;
+
+    assert(line_new != LINE_UNKNOWN);
+
+    check_caches(sstate);
+
+    if (state->lines[i] == line_new) {
+        return FALSE; /* nothing changed */
+    }
+    state->lines[i] = line_new;
+
+#ifdef SHOW_WORKING
+    fprintf(stderr, "solver: set line [%d] to %s (%s)\n",
+            i, line_new == LINE_YES ? "YES" : "NO",
+            reason);
+#endif
+
+    g = state->game_grid;
+    e = g->edges + i;
+
+    /* Update the cache for both dots and both faces affected by this. */
+    if (line_new == LINE_YES) {
+        sstate->dot_yes_count[e->dot1 - g->dots]++;
+        sstate->dot_yes_count[e->dot2 - g->dots]++;
+        if (e->face1) {
+            sstate->face_yes_count[e->face1 - g->faces]++;
+        }
+        if (e->face2) {
+            sstate->face_yes_count[e->face2 - g->faces]++;
+        }
+    } else {
+        sstate->dot_no_count[e->dot1 - g->dots]++;
+        sstate->dot_no_count[e->dot2 - g->dots]++;
+        if (e->face1) {
+            sstate->face_no_count[e->face1 - g->faces]++;
+        }
+        if (e->face2) {
+            sstate->face_no_count[e->face2 - g->faces]++;
+        }
+    }
+
+    check_caches(sstate);
+    return TRUE;
+}
+
+#ifdef SHOW_WORKING
+#define solver_set_line(a, b, c) \
+    solver_set_line(a, b, c, __FUNCTION__)
+#endif
+
+/*
+ * Merge two dots due to the existence of an edge between them.
+ * Updates the dsf tracking equivalence classes, and keeps track of
+ * the length of path each dot is currently a part of.
+ * Returns TRUE if the dots were already linked, ie if they are part of a
+ * closed loop, and false otherwise.
+ */
+static int merge_dots(solver_state *sstate, int edge_index)
+{
+    int i, j, len;
+    grid *g = sstate->state->game_grid;
+    grid_edge *e = g->edges + edge_index;
+
+    i = e->dot1 - g->dots;
+    j = e->dot2 - g->dots;
+
+    i = dsf_canonify(sstate->dotdsf, i);
+    j = dsf_canonify(sstate->dotdsf, j);
+
+    if (i == j) {
+        return TRUE;
+    } else {
+        len = sstate->looplen[i] + sstate->looplen[j];
+        dsf_merge(sstate->dotdsf, i, j);
+        i = dsf_canonify(sstate->dotdsf, i);
+        sstate->looplen[i] = len;
+        return FALSE;
+    }
+}
+
+/* Merge two lines because the solver has deduced that they must be either
+ * identical or opposite.   Returns TRUE if this is new information, otherwise
+ * FALSE. */
+static int merge_lines(solver_state *sstate, int i, int j, int inverse
+#ifdef SHOW_WORKING
+                       , const char *reason
+#endif
+                       )
+{
+    int inv_tmp;
+
+    assert(i < sstate->state->game_grid->num_edges);
+    assert(j < sstate->state->game_grid->num_edges);
+
+    i = edsf_canonify(sstate->linedsf, i, &inv_tmp);
+    inverse ^= inv_tmp;
+    j = edsf_canonify(sstate->linedsf, j, &inv_tmp);
+    inverse ^= inv_tmp;
+
+    edsf_merge(sstate->linedsf, i, j, inverse);
+
+#ifdef SHOW_WORKING
+    if (i != j) {
+        fprintf(stderr, "%s [%d] [%d] %s(%s)\n",
+                __FUNCTION__, i, j,
+                inverse ? "inverse " : "", reason);
+    }
+#endif
+    return (i != j);
+}
+
+#ifdef SHOW_WORKING
+#define merge_lines(a, b, c, d) \
+    merge_lines(a, b, c, d, __FUNCTION__)
+#endif
+
+/* Count the number of lines of a particular type currently going into the
+ * given dot. */
+static int dot_order(const game_state* state, int dot, char line_type)
+{
+    int n = 0;
+    grid *g = state->game_grid;
+    grid_dot *d = g->dots + dot;
+    int i;
+
+    for (i = 0; i < d->order; i++) {
+        grid_edge *e = d->edges[i];
+        if (state->lines[e - g->edges] == line_type)
+            ++n;
+    }
+    return n;
+}
+
+/* Count the number of lines of a particular type currently surrounding the
+ * given face */
+static int face_order(const game_state* state, int face, char line_type)
+{
+    int n = 0;
+    grid *g = state->game_grid;
+    grid_face *f = g->faces + face;
+    int i;
+
+    for (i = 0; i < f->order; i++) {
+        grid_edge *e = f->edges[i];
+        if (state->lines[e - g->edges] == line_type)
+            ++n;
+    }
+    return n;
+}
+
+/* Set all lines bordering a dot of type old_type to type new_type
+ * Return value tells caller whether this function actually did anything */
+static int dot_setall(solver_state *sstate, int dot,
+                      char old_type, char new_type)
+{
+    int retval = FALSE, r;
+    game_state *state = sstate->state;
+    grid *g;
+    grid_dot *d;
+    int i;
+
+    if (old_type == new_type)
+        return FALSE;
+
+    g = state->game_grid;
+    d = g->dots + dot;
+
+    for (i = 0; i < d->order; i++) {
+        int line_index = d->edges[i] - g->edges;
+        if (state->lines[line_index] == old_type) {
+            r = solver_set_line(sstate, line_index, new_type);
+            assert(r == TRUE);
+            retval = TRUE;
+        }
+    }
+    return retval;
+}
+
+/* Set all lines bordering a face of type old_type to type new_type */
+static int face_setall(solver_state *sstate, int face,
+                       char old_type, char new_type)
+{
+    int retval = FALSE, r;
+    game_state *state = sstate->state;
+    grid *g;
+    grid_face *f;
+    int i;
+
+    if (old_type == new_type)
+        return FALSE;
+
+    g = state->game_grid;
+    f = g->faces + face;
+
+    for (i = 0; i < f->order; i++) {
+        int line_index = f->edges[i] - g->edges;
+        if (state->lines[line_index] == old_type) {
+            r = solver_set_line(sstate, line_index, new_type);
+            assert(r == TRUE);
+            retval = TRUE;
+        }
+    }
+    return retval;
+}
+
+/* ----------------------------------------------------------------------
+ * Loop generation and clue removal
+ */
+
+static void add_full_clues(game_state *state, random_state *rs)
+{
+    signed char *clues = state->clues;
+    grid *g = state->game_grid;
+    char *board = snewn(g->num_faces, char);
+    int i;
+
+    generate_loop(g, board, rs, NULL, NULL);
+
+    /* Fill out all the clues by initialising to 0, then iterating over
+     * all edges and incrementing each clue as we find edges that border
+     * between BLACK/WHITE faces.  While we're at it, we verify that the
+     * algorithm does work, and there aren't any GREY faces still there. */
+    memset(clues, 0, g->num_faces);
+    for (i = 0; i < g->num_edges; i++) {
+        grid_edge *e = g->edges + i;
+        grid_face *f1 = e->face1;
+        grid_face *f2 = e->face2;
+        enum face_colour c1 = FACE_COLOUR(f1);
+        enum face_colour c2 = FACE_COLOUR(f2);
+        assert(c1 != FACE_GREY);
+        assert(c2 != FACE_GREY);
+        if (c1 != c2) {
+            if (f1) clues[f1 - g->faces]++;
+            if (f2) clues[f2 - g->faces]++;
+        }
+    }
+    sfree(board);
+}
+
+
+static int game_has_unique_soln(const game_state *state, int diff)
+{
+    int ret;
+    solver_state *sstate_new;
+    solver_state *sstate = new_solver_state((game_state *)state, diff);
+
+    sstate_new = solve_game_rec(sstate);
+
+    assert(sstate_new->solver_status != SOLVER_MISTAKE);
+    ret = (sstate_new->solver_status == SOLVER_SOLVED);
+
+    free_solver_state(sstate_new);
+    free_solver_state(sstate);
+
+    return ret;
+}
+
+
+/* Remove clues one at a time at random. */
+static game_state *remove_clues(game_state *state, random_state *rs,
+                                int diff)
+{
+    int *face_list;
+    int num_faces = state->game_grid->num_faces;
+    game_state *ret = dup_game(state), *saved_ret;
+    int n;
+
+    /* We need to remove some clues.  We'll do this by forming a list of all
+     * available clues, shuffling it, then going along one at a
+     * time clearing each clue in turn for which doing so doesn't render the
+     * board unsolvable. */
+    face_list = snewn(num_faces, int);
+    for (n = 0; n < num_faces; ++n) {
+        face_list[n] = n;
+    }
+
+    shuffle(face_list, num_faces, sizeof(int), rs);
+
+    for (n = 0; n < num_faces; ++n) {
+        saved_ret = dup_game(ret);
+        ret->clues[face_list[n]] = -1;
+
+        if (game_has_unique_soln(ret, diff)) {
+            free_game(saved_ret);
+        } else {
+            free_game(ret);
+            ret = saved_ret;
+        }
+    }
+    sfree(face_list);
+
+    return ret;
+}
+
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    /* solution and description both use run-length encoding in obvious ways */
+    char *retval, *game_desc, *grid_desc;
+    grid *g;
+    game_state *state = snew(game_state);
+    game_state *state_new;
+
+    grid_desc = grid_new_desc(grid_types[params->type], params->w, params->h, rs);
+    state->game_grid = g = loopy_generate_grid(params, grid_desc);
+
+    state->clues = snewn(g->num_faces, signed char);
+    state->lines = snewn(g->num_edges, char);
+    state->line_errors = snewn(g->num_edges, unsigned char);
+    state->exactly_one_loop = FALSE;
+
+    state->grid_type = params->type;
+
+    newboard_please:
+
+    memset(state->lines, LINE_UNKNOWN, g->num_edges);
+    memset(state->line_errors, 0, g->num_edges);
+
+    state->solved = state->cheated = FALSE;
+
+    /* Get a new random solvable board with all its clues filled in.  Yes, this
+     * can loop for ever if the params are suitably unfavourable, but
+     * preventing games smaller than 4x4 seems to stop this happening */
+    do {
+        add_full_clues(state, rs);
+    } while (!game_has_unique_soln(state, params->diff));
+
+    state_new = remove_clues(state, rs, params->diff);
+    free_game(state);
+    state = state_new;
+
+
+    if (params->diff > 0 && game_has_unique_soln(state, params->diff-1)) {
+#ifdef SHOW_WORKING
+        fprintf(stderr, "Rejecting board, it is too easy\n");
+#endif
+        goto newboard_please;
+    }
+
+    game_desc = state_to_text(state);
+
+    free_game(state);
+
+    if (grid_desc) {
+        retval = snewn(strlen(grid_desc) + 1 + strlen(game_desc) + 1, char);
+        sprintf(retval, "%s%c%s", grid_desc, (int)GRID_DESC_SEP, game_desc);
+        sfree(grid_desc);
+        sfree(game_desc);
+    } else {
+        retval = game_desc;
+    }
+
+    assert(!validate_desc(params, retval));
+
+    return retval;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int i;
+    game_state *state = snew(game_state);
+    int empties_to_make = 0;
+    int n,n2;
+    const char *dp;
+    char *grid_desc;
+    grid *g;
+    int num_faces, num_edges;
+
+    grid_desc = extract_grid_desc(&desc);
+    state->game_grid = g = loopy_generate_grid(params, grid_desc);
+    if (grid_desc) sfree(grid_desc);
+
+    dp = desc;
+
+    num_faces = g->num_faces;
+    num_edges = g->num_edges;
+
+    state->clues = snewn(num_faces, signed char);
+    state->lines = snewn(num_edges, char);
+    state->line_errors = snewn(num_edges, unsigned char);
+    state->exactly_one_loop = FALSE;
+
+    state->solved = state->cheated = FALSE;
+
+    state->grid_type = params->type;
+
+    for (i = 0; i < num_faces; i++) {
+        if (empties_to_make) {
+            empties_to_make--;
+            state->clues[i] = -1;
+            continue;
+        }
+
+        assert(*dp);
+        n = *dp - '0';
+        n2 = *dp - 'A' + 10;
+        if (n >= 0 && n < 10) {
+            state->clues[i] = n;
+        } else if (n2 >= 10 && n2 < 36) {
+            state->clues[i] = n2;
+        } else {
+            n = *dp - 'a' + 1;
+            assert(n > 0);
+            state->clues[i] = -1;
+            empties_to_make = n - 1;
+        }
+        ++dp;
+    }
+
+    memset(state->lines, LINE_UNKNOWN, num_edges);
+    memset(state->line_errors, 0, num_edges);
+    return state;
+}
+
+/* Calculates the line_errors data, and checks if the current state is a
+ * solution */
+static int check_completion(game_state *state)
+{
+    grid *g = state->game_grid;
+    int i, ret;
+    int *dsf, *component_state;
+    int nsilly, nloop, npath, largest_comp, largest_size, total_pathsize;
+    enum { COMP_NONE, COMP_LOOP, COMP_PATH, COMP_SILLY, COMP_EMPTY };
+
+    memset(state->line_errors, 0, g->num_edges);
+
+    /*
+     * Find loops in the grid, and determine whether the puzzle is
+     * solved.
+     *
+     * Loopy is a bit more complicated than most puzzles that care
+     * about loop detection. In most of them, loops are simply
+     * _forbidden_; so the obviously right way to do
+     * error-highlighting during play is to light up a graph edge red
+     * iff it is part of a loop, which is exactly what the centralised
+     * findloop.c makes easy.
+     *
+     * But Loopy is unusual in that you're _supposed_ to be making a
+     * loop - and yet _some_ loops are not the right loop. So we need
+     * to be more discriminating, by identifying loops one by one and
+     * then thinking about which ones to highlight, and so findloop.c
+     * isn't quite the right tool for the job in this case.
+     *
+     * Worse still, consider situations in which the grid contains a
+     * loop and also some non-loop edges: there are some cases like
+     * this in which the user's intuitive expectation would be to
+     * highlight the loop (if you're only about half way through the
+     * puzzle and have accidentally made a little loop in some corner
+     * of the grid), and others in which they'd be more likely to
+     * expect you to highlight the non-loop edges (if you've just
+     * closed off a whole loop that you thought was the entire
+     * solution, but forgot some disconnected edges in a corner
+     * somewhere). So while it's easy enough to check whether the
+     * solution is _right_, highlighting the wrong parts is a tricky
+     * problem for this puzzle!
+     *
+     * I'd quite like, in some situations, to identify the largest
+     * loop among the player's YES edges, and then light up everything
+     * other than that. But finding the longest cycle in a graph is an
+     * NP-complete problem (because, in particular, it must return a
+     * Hamilton cycle if one exists).
+     *
+     * However, I think we can make the problem tractable by
+     * exercising the Puzzles principle that it isn't absolutely
+     * necessary to highlight _all_ errors: the key point is that by
+     * the time the user has filled in the whole grid, they should
+     * either have seen a completion flash, or have _some_ error
+     * highlight showing them why the solution isn't right. So in
+     * principle it would be *just about* good enough to highlight
+     * just one error in the whole grid, if there was really no better
+     * way. But we'd like to highlight as many errors as possible.
+     *
+     * In this case, I think the simple approach is to make use of the
+     * fact that no vertex may have degree > 2, and that's really
+     * simple to detect. So the plan goes like this:
+     *
+     *  - Form the dsf of connected components of the graph vertices.
+     *
+     *  - Highlight an error at any vertex with degree > 2. (It so
+     *    happens that we do this by lighting up all the edges
+     *    incident to that vertex, but that's an output detail.)
+     *
+     *  - Any component that contains such a vertex is now excluded
+     *    from further consideration, because it already has a
+     *    highlight.
+     *
+     *  - The remaining components have no vertex with degree > 2, and
+     *    hence they all consist of either a simple loop, or a simple
+     *    path with two endpoints.
+     *
+     *  - For these purposes, group together all the paths and imagine
+     *    them to be a single component (because in most normal
+     *    situations the player will gradually build up the solution
+     *    _not_ all in one connected segment, but as lots of separate
+     *    little path pieces that gradually connect to each other).
+     *
+     *  - After doing that, if there is exactly one (sensible)
+     *    component - be it a collection of paths or a loop - then
+     *    highlight no further edge errors. (The former case is normal
+     *    during play, and the latter is a potentially solved puzzle.)
+     *
+     *  - Otherwise, find the largest of the sensible components,
+     *    leave that one unhighlighted, and light the rest up in red.
+     */
+
+    dsf = snew_dsf(g->num_dots);
+
+    /* Build the dsf. */
+    for (i = 0; i < g->num_edges; i++) {
+        if (state->lines[i] == LINE_YES) {
+            grid_edge *e = g->edges + i;
+            int d1 = e->dot1 - g->dots, d2 = e->dot2 - g->dots;
+            dsf_merge(dsf, d1, d2);
+        }
+    }
+
+    /* Initialise a state variable for each connected component. */
+    component_state = snewn(g->num_dots, int);
+    for (i = 0; i < g->num_dots; i++) {
+        if (dsf_canonify(dsf, i) == i)
+            component_state[i] = COMP_LOOP;
+        else
+            component_state[i] = COMP_NONE;
+    }
+
+    /* Check for dots with degree > 3. Here we also spot dots of
+     * degree 1 in which the user has marked all the non-edges as
+     * LINE_NO, because those are also clear vertex-level errors, so
+     * we give them the same treatment of excluding their connected
+     * component from the subsequent loop analysis. */
+    for (i = 0; i < g->num_dots; i++) {
+        int comp = dsf_canonify(dsf, i);
+        int yes = dot_order(state, i, LINE_YES);
+        int unknown = dot_order(state, i, LINE_UNKNOWN);
+        if ((yes == 1 && unknown == 0) || (yes >= 3)) {
+            /* violation, so mark all YES edges as errors */
+            grid_dot *d = g->dots + i;
+            int j;
+            for (j = 0; j < d->order; j++) {
+                int e = d->edges[j] - g->edges;
+                if (state->lines[e] == LINE_YES)
+                    state->line_errors[e] = TRUE;
+            }
+            /* And mark this component as not worthy of further
+             * consideration. */
+            component_state[comp] = COMP_SILLY;
+
+        } else if (yes == 0) {
+            /* A completely isolated dot must also be excluded it from
+             * the subsequent loop highlighting pass, but we tag it
+             * with a different enum value to avoid it counting
+             * towards the components that inhibit returning a win
+             * status. */
+            component_state[comp] = COMP_EMPTY;
+        } else if (yes == 1) {
+            /* A dot with degree 1 that didn't fall into the 'clearly
+             * erroneous' case above indicates that this connected
+             * component will be a path rather than a loop - unless
+             * something worse elsewhere in the component has
+             * classified it as silly. */
+            if (component_state[comp] != COMP_SILLY)
+                component_state[comp] = COMP_PATH;
+        }
+    }
+
+    /* Count up the components. Also, find the largest sensible
+     * component. (Tie-breaking condition is derived from the order of
+     * vertices in the grid data structure, which is fairly arbitrary
+     * but at least stays stable throughout the game.) */
+    nsilly = nloop = npath = 0;
+    total_pathsize = 0;
+    largest_comp = largest_size = -1;
+    for (i = 0; i < g->num_dots; i++) {
+        if (component_state[i] == COMP_SILLY) {
+            nsilly++;
+        } else if (component_state[i] == COMP_PATH) {
+            total_pathsize += dsf_size(dsf, i);
+            npath = 1;
+        } else if (component_state[i] == COMP_LOOP) {
+            int this_size;
+
+            nloop++;
+
+            if ((this_size = dsf_size(dsf, i)) > largest_size) {
+                largest_comp = i;
+                largest_size = this_size;
+            }
+        }
+    }
+    if (largest_size < total_pathsize) {
+        largest_comp = -1;             /* means the paths */
+        largest_size = total_pathsize;
+    }
+
+    if (nloop > 0 && nloop + npath > 1) {
+        /*
+         * If there are at least two sensible components including at
+         * least one loop, highlight all edges in every sensible
+         * component that is not the largest one.
+         */
+        for (i = 0; i < g->num_edges; i++) {
+            if (state->lines[i] == LINE_YES) {
+                grid_edge *e = g->edges + i;
+                int d1 = e->dot1 - g->dots; /* either endpoint is good enough */
+                int comp = dsf_canonify(dsf, d1);
+                if ((component_state[comp] == COMP_PATH &&
+                     -1 != largest_comp) ||
+                    (component_state[comp] == COMP_LOOP &&
+                     comp != largest_comp))
+                    state->line_errors[i] = TRUE;
+            }
+        }
+    }
+
+    if (nloop == 1 && npath == 0 && nsilly == 0) {
+        /*
+         * If there is exactly one component and it is a loop, then
+         * the puzzle is potentially complete, so check the clues.
+         */
+        ret = TRUE;
+
+        for (i = 0; i < g->num_faces; i++) {
+            int c = state->clues[i];
+            if (c >= 0 && face_order(state, i, LINE_YES) != c) {
+                ret = FALSE;
+                break;
+            }
+        }
+
+        /*
+         * Also, whether or not the puzzle is actually complete, set
+         * the flag that says this game_state has exactly one loop and
+         * nothing else, which will be used to vary the semantics of
+         * clue highlighting at display time.
+         */
+        state->exactly_one_loop = TRUE;
+    } else {
+        ret = FALSE;
+        state->exactly_one_loop = FALSE;
+    }
+
+    sfree(component_state);
+    sfree(dsf);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver logic
+ *
+ * Our solver modes operate as follows.  Each mode also uses the modes above it.
+ *
+ *   Easy Mode
+ *   Just implement the rules of the game.
+ *
+ *   Normal and Tricky Modes
+ *   For each (adjacent) pair of lines through each dot we store a bit for
+ *   whether at least one of them is on and whether at most one is on.  (If we
+ *   know both or neither is on that's already stored more directly.)
+ *
+ *   Advanced Mode
+ *   Use edsf data structure to make equivalence classes of lines that are
+ *   known identical to or opposite to one another.
+ */
+
+
+/* DLines:
+ * For general grids, we consider "dlines" to be pairs of lines joined
+ * at a dot.  The lines must be adjacent around the dot, so we can think of
+ * a dline as being a dot+face combination.  Or, a dot+edge combination where
+ * the second edge is taken to be the next clockwise edge from the dot.
+ * Original loopy code didn't have this extra restriction of the lines being
+ * adjacent.  From my tests with square grids, this extra restriction seems to
+ * take little, if anything, away from the quality of the puzzles.
+ * A dline can be uniquely identified by an edge/dot combination, given that
+ * a dline-pair always goes clockwise around its common dot.  The edge/dot
+ * combination can be represented by an edge/bool combination - if bool is
+ * TRUE, use edge->dot1 else use edge->dot2.  So the total number of dlines is
+ * exactly twice the number of edges in the grid - although the dlines
+ * spanning the infinite face are not all that useful to the solver.
+ * Note that, by convention, a dline goes clockwise around its common dot,
+ * which means the dline goes anti-clockwise around its common face.
+ */
+
+/* Helper functions for obtaining an index into an array of dlines, given
+ * various information.  We assume the grid layout conventions about how
+ * the various lists are interleaved - see grid_make_consistent() for
+ * details. */
+
+/* i points to the first edge of the dline pair, reading clockwise around
+ * the dot. */
+static int dline_index_from_dot(grid *g, grid_dot *d, int i)
+{
+    grid_edge *e = d->edges[i];
+    int ret;
+#ifdef DEBUG_DLINES
+    grid_edge *e2;
+    int i2 = i+1;
+    if (i2 == d->order) i2 = 0;
+    e2 = d->edges[i2];
+#endif
+    ret = 2 * (e - g->edges) + ((e->dot1 == d) ? 1 : 0);
+#ifdef DEBUG_DLINES
+    printf("dline_index_from_dot: d=%d,i=%d, edges [%d,%d] - %d\n",
+           (int)(d - g->dots), i, (int)(e - g->edges),
+           (int)(e2 - g->edges), ret);
+#endif
+    return ret;
+}
+/* i points to the second edge of the dline pair, reading clockwise around
+ * the face.  That is, the edges of the dline, starting at edge{i}, read
+ * anti-clockwise around the face.  By layout conventions, the common dot
+ * of the dline will be f->dots[i] */
+static int dline_index_from_face(grid *g, grid_face *f, int i)
+{
+    grid_edge *e = f->edges[i];
+    grid_dot *d = f->dots[i];
+    int ret;
+#ifdef DEBUG_DLINES
+    grid_edge *e2;
+    int i2 = i - 1;
+    if (i2 < 0) i2 += f->order;
+    e2 = f->edges[i2];
+#endif
+    ret = 2 * (e - g->edges) + ((e->dot1 == d) ? 1 : 0);
+#ifdef DEBUG_DLINES
+    printf("dline_index_from_face: f=%d,i=%d, edges [%d,%d] - %d\n",
+           (int)(f - g->faces), i, (int)(e - g->edges),
+           (int)(e2 - g->edges), ret);
+#endif
+    return ret;
+}
+static int is_atleastone(const char *dline_array, int index)
+{
+    return BIT_SET(dline_array[index], 0);
+}
+static int set_atleastone(char *dline_array, int index)
+{
+    return SET_BIT(dline_array[index], 0);
+}
+static int is_atmostone(const char *dline_array, int index)
+{
+    return BIT_SET(dline_array[index], 1);
+}
+static int set_atmostone(char *dline_array, int index)
+{
+    return SET_BIT(dline_array[index], 1);
+}
+
+static void array_setall(char *array, char from, char to, int len)
+{
+    char *p = array, *p_old = p;
+    int len_remaining = len;
+
+    while ((p = memchr(p, from, len_remaining))) {
+        *p = to;
+        len_remaining -= p - p_old;
+        p_old = p;
+    }
+}
+
+/* Helper, called when doing dline dot deductions, in the case where we
+ * have 4 UNKNOWNs, and two of them (adjacent) have *exactly* one YES between
+ * them (because of dline atmostone/atleastone).
+ * On entry, edge points to the first of these two UNKNOWNs.  This function
+ * will find the opposite UNKNOWNS (if they are adjacent to one another)
+ * and set their corresponding dline to atleastone.  (Setting atmostone
+ * already happens in earlier dline deductions) */
+static int dline_set_opp_atleastone(solver_state *sstate,
+                                    grid_dot *d, int edge)
+{
+    game_state *state = sstate->state;
+    grid *g = state->game_grid;
+    int N = d->order;
+    int opp, opp2;
+    for (opp = 0; opp < N; opp++) {
+        int opp_dline_index;
+        if (opp == edge || opp == edge+1 || opp == edge-1)
+            continue;
+        if (opp == 0 && edge == N-1)
+            continue;
+        if (opp == N-1 && edge == 0)
+            continue;
+        opp2 = opp + 1;
+        if (opp2 == N) opp2 = 0;
+        /* Check if opp, opp2 point to LINE_UNKNOWNs */
+        if (state->lines[d->edges[opp] - g->edges] != LINE_UNKNOWN)
+            continue;
+        if (state->lines[d->edges[opp2] - g->edges] != LINE_UNKNOWN)
+            continue;
+        /* Found opposite UNKNOWNS and they're next to each other */
+        opp_dline_index = dline_index_from_dot(g, d, opp);
+        return set_atleastone(sstate->dlines, opp_dline_index);
+    }
+    return FALSE;
+}
+
+
+/* Set pairs of lines around this face which are known to be identical, to
+ * the given line_state */
+static int face_setall_identical(solver_state *sstate, int face_index,
+                                 enum line_state line_new)
+{
+    /* can[dir] contains the canonical line associated with the line in
+     * direction dir from the square in question.  Similarly inv[dir] is
+     * whether or not the line in question is inverse to its canonical
+     * element. */
+    int retval = FALSE;
+    game_state *state = sstate->state;
+    grid *g = state->game_grid;
+    grid_face *f = g->faces + face_index;
+    int N = f->order;
+    int i, j;
+    int can1, can2, inv1, inv2;
+
+    for (i = 0; i < N; i++) {
+        int line1_index = f->edges[i] - g->edges;
+        if (state->lines[line1_index] != LINE_UNKNOWN)
+            continue;
+        for (j = i + 1; j < N; j++) {
+            int line2_index = f->edges[j] - g->edges;
+            if (state->lines[line2_index] != LINE_UNKNOWN)
+                continue;
+
+            /* Found two UNKNOWNS */
+            can1 = edsf_canonify(sstate->linedsf, line1_index, &inv1);
+            can2 = edsf_canonify(sstate->linedsf, line2_index, &inv2);
+            if (can1 == can2 && inv1 == inv2) {
+                solver_set_line(sstate, line1_index, line_new);
+                solver_set_line(sstate, line2_index, line_new);
+            }
+        }
+    }
+    return retval;
+}
+
+/* Given a dot or face, and a count of LINE_UNKNOWNs, find them and
+ * return the edge indices into e. */
+static void find_unknowns(game_state *state,
+    grid_edge **edge_list, /* Edge list to search (from a face or a dot) */
+    int expected_count, /* Number of UNKNOWNs (comes from solver's cache) */
+    int *e /* Returned edge indices */)
+{
+    int c = 0;
+    grid *g = state->game_grid;
+    while (c < expected_count) {
+        int line_index = *edge_list - g->edges;
+        if (state->lines[line_index] == LINE_UNKNOWN) {
+            e[c] = line_index;
+            c++;
+        }
+        ++edge_list;
+    }
+}
+
+/* If we have a list of edges, and we know whether the number of YESs should
+ * be odd or even, and there are only a few UNKNOWNs, we can do some simple
+ * linedsf deductions.  This can be used for both face and dot deductions.
+ * Returns the difficulty level of the next solver that should be used,
+ * or DIFF_MAX if no progress was made. */
+static int parity_deductions(solver_state *sstate,
+    grid_edge **edge_list, /* Edge list (from a face or a dot) */
+    int total_parity, /* Expected number of YESs modulo 2 (either 0 or 1) */
+    int unknown_count)
+{
+    game_state *state = sstate->state;
+    int diff = DIFF_MAX;
+    int *linedsf = sstate->linedsf;
+
+    if (unknown_count == 2) {
+        /* Lines are known alike/opposite, depending on inv. */
+        int e[2];
+        find_unknowns(state, edge_list, 2, e);
+        if (merge_lines(sstate, e[0], e[1], total_parity))
+            diff = min(diff, DIFF_HARD);
+    } else if (unknown_count == 3) {
+        int e[3];
+        int can[3]; /* canonical edges */
+        int inv[3]; /* whether can[x] is inverse to e[x] */
+        find_unknowns(state, edge_list, 3, e);
+        can[0] = edsf_canonify(linedsf, e[0], inv);
+        can[1] = edsf_canonify(linedsf, e[1], inv+1);
+        can[2] = edsf_canonify(linedsf, e[2], inv+2);
+        if (can[0] == can[1]) {
+            if (solver_set_line(sstate, e[2], (total_parity^inv[0]^inv[1]) ?
+                                LINE_YES : LINE_NO))
+                diff = min(diff, DIFF_EASY);
+        }
+        if (can[0] == can[2]) {
+            if (solver_set_line(sstate, e[1], (total_parity^inv[0]^inv[2]) ?
+                                LINE_YES : LINE_NO))
+                diff = min(diff, DIFF_EASY);
+        }
+        if (can[1] == can[2]) {
+            if (solver_set_line(sstate, e[0], (total_parity^inv[1]^inv[2]) ?
+                                LINE_YES : LINE_NO))
+                diff = min(diff, DIFF_EASY);
+        }
+    } else if (unknown_count == 4) {
+        int e[4];
+        int can[4]; /* canonical edges */
+        int inv[4]; /* whether can[x] is inverse to e[x] */
+        find_unknowns(state, edge_list, 4, e);
+        can[0] = edsf_canonify(linedsf, e[0], inv);
+        can[1] = edsf_canonify(linedsf, e[1], inv+1);
+        can[2] = edsf_canonify(linedsf, e[2], inv+2);
+        can[3] = edsf_canonify(linedsf, e[3], inv+3);
+        if (can[0] == can[1]) {
+            if (merge_lines(sstate, e[2], e[3], total_parity^inv[0]^inv[1]))
+                diff = min(diff, DIFF_HARD);
+        } else if (can[0] == can[2]) {
+            if (merge_lines(sstate, e[1], e[3], total_parity^inv[0]^inv[2]))
+                diff = min(diff, DIFF_HARD);
+        } else if (can[0] == can[3]) {
+            if (merge_lines(sstate, e[1], e[2], total_parity^inv[0]^inv[3]))
+                diff = min(diff, DIFF_HARD);
+        } else if (can[1] == can[2]) {
+            if (merge_lines(sstate, e[0], e[3], total_parity^inv[1]^inv[2]))
+                diff = min(diff, DIFF_HARD);
+        } else if (can[1] == can[3]) {
+            if (merge_lines(sstate, e[0], e[2], total_parity^inv[1]^inv[3]))
+                diff = min(diff, DIFF_HARD);
+        } else if (can[2] == can[3]) {
+            if (merge_lines(sstate, e[0], e[1], total_parity^inv[2]^inv[3]))
+                diff = min(diff, DIFF_HARD);
+        }
+    }
+    return diff;
+}
+
+
+/*
+ * These are the main solver functions.
+ *
+ * Their return values are diff values corresponding to the lowest mode solver
+ * that would notice the work that they have done.  For example if the normal
+ * mode solver adds actual lines or crosses, it will return DIFF_EASY as the
+ * easy mode solver might be able to make progress using that.  It doesn't make
+ * sense for one of them to return a diff value higher than that of the
+ * function itself.
+ *
+ * Each function returns the lowest value it can, as early as possible, in
+ * order to try and pass as much work as possible back to the lower level
+ * solvers which progress more quickly.
+ */
+
+/* PROPOSED NEW DESIGN:
+ * We have a work queue consisting of 'events' notifying us that something has
+ * happened that a particular solver mode might be interested in.  For example
+ * the hard mode solver might do something that helps the normal mode solver at
+ * dot [x,y] in which case it will enqueue an event recording this fact.  Then
+ * we pull events off the work queue, and hand each in turn to the solver that
+ * is interested in them.  If a solver reports that it failed we pass the same
+ * event on to progressively more advanced solvers and the loop detector.  Once
+ * we've exhausted an event, or it has helped us progress, we drop it and
+ * continue to the next one.  The events are sorted first in order of solver
+ * complexity (easy first) then order of insertion (oldest first).
+ * Once we run out of events we loop over each permitted solver in turn
+ * (easiest first) until either a deduction is made (and an event therefore
+ * emerges) or no further deductions can be made (in which case we've failed).
+ *
+ * QUESTIONS:
+ *    * How do we 'loop over' a solver when both dots and squares are concerned.
+ *      Answer: first all squares then all dots.
+ */
+
+static int trivial_deductions(solver_state *sstate)
+{
+    int i, current_yes, current_no;
+    game_state *state = sstate->state;
+    grid *g = state->game_grid;
+    int diff = DIFF_MAX;
+
+    /* Per-face deductions */
+    for (i = 0; i < g->num_faces; i++) {
+        grid_face *f = g->faces + i;
+
+        if (sstate->face_solved[i])
+            continue;
+
+        current_yes = sstate->face_yes_count[i];
+        current_no  = sstate->face_no_count[i];
+
+        if (current_yes + current_no == f->order)  {
+            sstate->face_solved[i] = TRUE;
+            continue;
+        }
+
+        if (state->clues[i] < 0)
+            continue;
+
+        /*
+         * This code checks whether the numeric clue on a face is so
+         * large as to permit all its remaining LINE_UNKNOWNs to be
+         * filled in as LINE_YES, or alternatively so small as to
+         * permit them all to be filled in as LINE_NO.
+         */
+
+        if (state->clues[i] < current_yes) {
+            sstate->solver_status = SOLVER_MISTAKE;
+            return DIFF_EASY;
+        }
+        if (state->clues[i] == current_yes) {
+            if (face_setall(sstate, i, LINE_UNKNOWN, LINE_NO))
+                diff = min(diff, DIFF_EASY);
+            sstate->face_solved[i] = TRUE;
+            continue;
+        }
+
+        if (f->order - state->clues[i] < current_no) {
+            sstate->solver_status = SOLVER_MISTAKE;
+            return DIFF_EASY;
+        }
+        if (f->order - state->clues[i] == current_no) {
+            if (face_setall(sstate, i, LINE_UNKNOWN, LINE_YES))
+                diff = min(diff, DIFF_EASY);
+            sstate->face_solved[i] = TRUE;
+            continue;
+        }
+
+        if (f->order - state->clues[i] == current_no + 1 &&
+            f->order - current_yes - current_no > 2) {
+            /*
+             * One small refinement to the above: we also look for any
+             * adjacent pair of LINE_UNKNOWNs around the face with
+             * some LINE_YES incident on it from elsewhere. If we find
+             * one, then we know that pair of LINE_UNKNOWNs can't
+             * _both_ be LINE_YES, and hence that pushes us one line
+             * closer to being able to determine all the rest.
+             */
+            int j, k, e1, e2, e, d;
+
+            for (j = 0; j < f->order; j++) {
+                e1 = f->edges[j] - g->edges;
+                e2 = f->edges[j+1 < f->order ? j+1 : 0] - g->edges;
+
+                if (g->edges[e1].dot1 == g->edges[e2].dot1 ||
+                    g->edges[e1].dot1 == g->edges[e2].dot2) {
+                    d = g->edges[e1].dot1 - g->dots;
+                } else {
+                    assert(g->edges[e1].dot2 == g->edges[e2].dot1 ||
+                           g->edges[e1].dot2 == g->edges[e2].dot2);
+                    d = g->edges[e1].dot2 - g->dots;
+                }
+
+                if (state->lines[e1] == LINE_UNKNOWN &&
+                    state->lines[e2] == LINE_UNKNOWN) {
+                    for (k = 0; k < g->dots[d].order; k++) {
+                        int e = g->dots[d].edges[k] - g->edges;
+                        if (state->lines[e] == LINE_YES)
+                            goto found;    /* multi-level break */
+                    }
+                }
+            }
+            continue;
+
+          found:
+            /*
+             * If we get here, we've found such a pair of edges, and
+             * they're e1 and e2.
+             */
+            for (j = 0; j < f->order; j++) {
+                e = f->edges[j] - g->edges;
+                if (state->lines[e] == LINE_UNKNOWN && e != e1 && e != e2) {
+                    int r = solver_set_line(sstate, e, LINE_YES);
+                    assert(r);
+                    diff = min(diff, DIFF_EASY);
+                }
+            }
+        }
+    }
+
+    check_caches(sstate);
+
+    /* Per-dot deductions */
+    for (i = 0; i < g->num_dots; i++) {
+        grid_dot *d = g->dots + i;
+        int yes, no, unknown;
+
+        if (sstate->dot_solved[i])
+            continue;
+
+        yes = sstate->dot_yes_count[i];
+        no = sstate->dot_no_count[i];
+        unknown = d->order - yes - no;
+
+        if (yes == 0) {
+            if (unknown == 0) {
+                sstate->dot_solved[i] = TRUE;
+            } else if (unknown == 1) {
+                dot_setall(sstate, i, LINE_UNKNOWN, LINE_NO);
+                diff = min(diff, DIFF_EASY);
+                sstate->dot_solved[i] = TRUE;
+            }
+        } else if (yes == 1) {
+            if (unknown == 0) {
+                sstate->solver_status = SOLVER_MISTAKE;
+                return DIFF_EASY;
+            } else if (unknown == 1) {
+                dot_setall(sstate, i, LINE_UNKNOWN, LINE_YES);
+                diff = min(diff, DIFF_EASY);
+            }
+        } else if (yes == 2) {
+            if (unknown > 0) {
+                dot_setall(sstate, i, LINE_UNKNOWN, LINE_NO);
+                diff = min(diff, DIFF_EASY);
+            }
+            sstate->dot_solved[i] = TRUE;
+        } else {
+            sstate->solver_status = SOLVER_MISTAKE;
+            return DIFF_EASY;
+        }
+    }
+
+    check_caches(sstate);
+
+    return diff;
+}
+
+static int dline_deductions(solver_state *sstate)
+{
+    game_state *state = sstate->state;
+    grid *g = state->game_grid;
+    char *dlines = sstate->dlines;
+    int i;
+    int diff = DIFF_MAX;
+
+    /* ------ Face deductions ------ */
+
+    /* Given a set of dline atmostone/atleastone constraints, need to figure
+     * out if we can deduce any further info.  For more general faces than
+     * squares, this turns out to be a tricky problem.
+     * The approach taken here is to define (per face) NxN matrices:
+     * "maxs" and "mins".
+     * The entries maxs(j,k) and mins(j,k) define the upper and lower limits
+     * for the possible number of edges that are YES between positions j and k
+     * going clockwise around the face.  Can think of j and k as marking dots
+     * around the face (recall the labelling scheme: edge0 joins dot0 to dot1,
+     * edge1 joins dot1 to dot2 etc).
+     * Trivially, mins(j,j) = maxs(j,j) = 0, and we don't even bother storing
+     * these.  mins(j,j+1) and maxs(j,j+1) are determined by whether edge{j}
+     * is YES, NO or UNKNOWN.  mins(j,j+2) and maxs(j,j+2) are related to
+     * the dline atmostone/atleastone status for edges j and j+1.
+     *
+     * Then we calculate the remaining entries recursively.  We definitely
+     * know that
+     * mins(j,k) >= { mins(j,u) + mins(u,k) } for any u between j and k.
+     * This is because any valid placement of YESs between j and k must give
+     * a valid placement between j and u, and also between u and k.
+     * I believe it's sufficient to use just the two values of u:
+     * j+1 and j+2.  Seems to work well in practice - the bounds we compute
+     * are rigorous, even if they might not be best-possible.
+     *
+     * Once we have maxs and mins calculated, we can make inferences about
+     * each dline{j,j+1} by looking at the possible complementary edge-counts
+     * mins(j+2,j) and maxs(j+2,j) and comparing these with the face clue.
+     * As well as dlines, we can make similar inferences about single edges.
+     * For example, consider a pentagon with clue 3, and we know at most one
+     * of (edge0, edge1) is YES, and at most one of (edge2, edge3) is YES.
+     * We could then deduce edge4 is YES, because maxs(0,4) would be 2, so
+     * that final edge would have to be YES to make the count up to 3.
+     */
+
+    /* Much quicker to allocate arrays on the stack than the heap, so
+     * define the largest possible face size, and base our array allocations
+     * on that.  We check this with an assertion, in case someone decides to
+     * make a grid which has larger faces than this.  Note, this algorithm
+     * could get quite expensive if there are many large faces. */
+#define MAX_FACE_SIZE 12
+
+    for (i = 0; i < g->num_faces; i++) {
+        int maxs[MAX_FACE_SIZE][MAX_FACE_SIZE];
+        int mins[MAX_FACE_SIZE][MAX_FACE_SIZE];
+        grid_face *f = g->faces + i;
+        int N = f->order;
+        int j,m;
+        int clue = state->clues[i];
+        assert(N <= MAX_FACE_SIZE);
+        if (sstate->face_solved[i])
+            continue;
+        if (clue < 0) continue;
+
+        /* Calculate the (j,j+1) entries */
+        for (j = 0; j < N; j++) {
+            int edge_index = f->edges[j] - g->edges;
+            int dline_index;
+            enum line_state line1 = state->lines[edge_index];
+            enum line_state line2;
+            int tmp;
+            int k = j + 1;
+            if (k >= N) k = 0;
+            maxs[j][k] = (line1 == LINE_NO) ? 0 : 1;
+            mins[j][k] = (line1 == LINE_YES) ? 1 : 0;
+            /* Calculate the (j,j+2) entries */
+            dline_index = dline_index_from_face(g, f, k);
+            edge_index = f->edges[k] - g->edges;
+            line2 = state->lines[edge_index];
+            k++;
+            if (k >= N) k = 0;
+
+            /* max */
+            tmp = 2;
+            if (line1 == LINE_NO) tmp--;
+            if (line2 == LINE_NO) tmp--;
+            if (tmp == 2 && is_atmostone(dlines, dline_index))
+                tmp = 1;
+            maxs[j][k] = tmp;
+
+            /* min */
+            tmp = 0;
+            if (line1 == LINE_YES) tmp++;
+            if (line2 == LINE_YES) tmp++;
+            if (tmp == 0 && is_atleastone(dlines, dline_index))
+                tmp = 1;
+            mins[j][k] = tmp;
+        }
+
+        /* Calculate the (j,j+m) entries for m between 3 and N-1 */
+        for (m = 3; m < N; m++) {
+            for (j = 0; j < N; j++) {
+                int k = j + m;
+                int u = j + 1;
+                int v = j + 2;
+                int tmp;
+                if (k >= N) k -= N;
+                if (u >= N) u -= N;
+                if (v >= N) v -= N;
+                maxs[j][k] = maxs[j][u] + maxs[u][k];
+                mins[j][k] = mins[j][u] + mins[u][k];
+                tmp = maxs[j][v] + maxs[v][k];
+                maxs[j][k] = min(maxs[j][k], tmp);
+                tmp = mins[j][v] + mins[v][k];
+                mins[j][k] = max(mins[j][k], tmp);
+            }
+        }
+
+        /* See if we can make any deductions */
+        for (j = 0; j < N; j++) {
+            int k;
+            grid_edge *e = f->edges[j];
+            int line_index = e - g->edges;
+            int dline_index;
+
+            if (state->lines[line_index] != LINE_UNKNOWN)
+                continue;
+            k = j + 1;
+            if (k >= N) k = 0;
+
+            /* minimum YESs in the complement of this edge */
+            if (mins[k][j] > clue) {
+                sstate->solver_status = SOLVER_MISTAKE;
+                return DIFF_EASY;
+            }
+            if (mins[k][j] == clue) {
+                /* setting this edge to YES would make at least
+                 * (clue+1) edges - contradiction */
+                solver_set_line(sstate, line_index, LINE_NO);
+                diff = min(diff, DIFF_EASY);
+            }
+            if (maxs[k][j] < clue - 1) {
+                sstate->solver_status = SOLVER_MISTAKE;
+                return DIFF_EASY;
+            }
+            if (maxs[k][j] == clue - 1) {
+                /* Only way to satisfy the clue is to set edge{j} as YES */
+                solver_set_line(sstate, line_index, LINE_YES);
+                diff = min(diff, DIFF_EASY);
+            }
+
+            /* More advanced deduction that allows propagation along diagonal
+             * chains of faces connected by dots, for example, 3-2-...-2-3
+             * in square grids. */
+            if (sstate->diff >= DIFF_TRICKY) {
+                /* Now see if we can make dline deduction for edges{j,j+1} */
+                e = f->edges[k];
+                if (state->lines[e - g->edges] != LINE_UNKNOWN)
+                    /* Only worth doing this for an UNKNOWN,UNKNOWN pair.
+                     * Dlines where one of the edges is known, are handled in the
+                     * dot-deductions */
+                    continue;
+    
+                dline_index = dline_index_from_face(g, f, k);
+                k++;
+                if (k >= N) k = 0;
+    
+                /* minimum YESs in the complement of this dline */
+                if (mins[k][j] > clue - 2) {
+                    /* Adding 2 YESs would break the clue */
+                    if (set_atmostone(dlines, dline_index))
+                        diff = min(diff, DIFF_NORMAL);
+                }
+                /* maximum YESs in the complement of this dline */
+                if (maxs[k][j] < clue) {
+                    /* Adding 2 NOs would mean not enough YESs */
+                    if (set_atleastone(dlines, dline_index))
+                        diff = min(diff, DIFF_NORMAL);
+                }
+            }
+        }
+    }
+
+    if (diff < DIFF_NORMAL)
+        return diff;
+
+    /* ------ Dot deductions ------ */
+
+    for (i = 0; i < g->num_dots; i++) {
+        grid_dot *d = g->dots + i;
+        int N = d->order;
+        int yes, no, unknown;
+        int j;
+        if (sstate->dot_solved[i])
+            continue;
+        yes = sstate->dot_yes_count[i];
+        no = sstate->dot_no_count[i];
+        unknown = N - yes - no;
+
+        for (j = 0; j < N; j++) {
+            int k;
+            int dline_index;
+            int line1_index, line2_index;
+            enum line_state line1, line2;
+            k = j + 1;
+            if (k >= N) k = 0;
+            dline_index = dline_index_from_dot(g, d, j);
+            line1_index = d->edges[j] - g->edges;
+            line2_index = d->edges[k] - g->edges;
+            line1 = state->lines[line1_index];
+            line2 = state->lines[line2_index];
+
+            /* Infer dline state from line state */
+            if (line1 == LINE_NO || line2 == LINE_NO) {
+                if (set_atmostone(dlines, dline_index))
+                    diff = min(diff, DIFF_NORMAL);
+            }
+            if (line1 == LINE_YES || line2 == LINE_YES) {
+                if (set_atleastone(dlines, dline_index))
+                    diff = min(diff, DIFF_NORMAL);
+            }
+            /* Infer line state from dline state */
+            if (is_atmostone(dlines, dline_index)) {
+                if (line1 == LINE_YES && line2 == LINE_UNKNOWN) {
+                    solver_set_line(sstate, line2_index, LINE_NO);
+                    diff = min(diff, DIFF_EASY);
+                }
+                if (line2 == LINE_YES && line1 == LINE_UNKNOWN) {
+                    solver_set_line(sstate, line1_index, LINE_NO);
+                    diff = min(diff, DIFF_EASY);
+                }
+            }
+            if (is_atleastone(dlines, dline_index)) {
+                if (line1 == LINE_NO && line2 == LINE_UNKNOWN) {
+                    solver_set_line(sstate, line2_index, LINE_YES);
+                    diff = min(diff, DIFF_EASY);
+                }
+                if (line2 == LINE_NO && line1 == LINE_UNKNOWN) {
+                    solver_set_line(sstate, line1_index, LINE_YES);
+                    diff = min(diff, DIFF_EASY);
+                }
+            }
+            /* Deductions that depend on the numbers of lines.
+             * Only bother if both lines are UNKNOWN, otherwise the
+             * easy-mode solver (or deductions above) would have taken
+             * care of it. */
+            if (line1 != LINE_UNKNOWN || line2 != LINE_UNKNOWN)
+                continue;
+
+            if (yes == 0 && unknown == 2) {
+                /* Both these unknowns must be identical.  If we know
+                 * atmostone or atleastone, we can make progress. */
+                if (is_atmostone(dlines, dline_index)) {
+                    solver_set_line(sstate, line1_index, LINE_NO);
+                    solver_set_line(sstate, line2_index, LINE_NO);
+                    diff = min(diff, DIFF_EASY);
+                }
+                if (is_atleastone(dlines, dline_index)) {
+                    solver_set_line(sstate, line1_index, LINE_YES);
+                    solver_set_line(sstate, line2_index, LINE_YES);
+                    diff = min(diff, DIFF_EASY);
+                }
+            }
+            if (yes == 1) {
+                if (set_atmostone(dlines, dline_index))
+                    diff = min(diff, DIFF_NORMAL);
+                if (unknown == 2) {
+                    if (set_atleastone(dlines, dline_index))
+                        diff = min(diff, DIFF_NORMAL);
+                }
+            }
+
+            /* More advanced deduction that allows propagation along diagonal
+             * chains of faces connected by dots, for example: 3-2-...-2-3
+             * in square grids. */
+            if (sstate->diff >= DIFF_TRICKY) {
+                /* If we have atleastone set for this dline, infer
+                 * atmostone for each "opposite" dline (that is, each
+                 * dline without edges in common with this one).
+                 * Again, this test is only worth doing if both these
+                 * lines are UNKNOWN.  For if one of these lines were YES,
+                 * the (yes == 1) test above would kick in instead. */
+                if (is_atleastone(dlines, dline_index)) {
+                    int opp;
+                    for (opp = 0; opp < N; opp++) {
+                        int opp_dline_index;
+                        if (opp == j || opp == j+1 || opp == j-1)
+                            continue;
+                        if (j == 0 && opp == N-1)
+                            continue;
+                        if (j == N-1 && opp == 0)
+                            continue;
+                        opp_dline_index = dline_index_from_dot(g, d, opp);
+                        if (set_atmostone(dlines, opp_dline_index))
+                            diff = min(diff, DIFF_NORMAL);
+                    }
+                    if (yes == 0 && is_atmostone(dlines, dline_index)) {
+                        /* This dline has *exactly* one YES and there are no
+                         * other YESs.  This allows more deductions. */
+                        if (unknown == 3) {
+                            /* Third unknown must be YES */
+                            for (opp = 0; opp < N; opp++) {
+                                int opp_index;
+                                if (opp == j || opp == k)
+                                    continue;
+                                opp_index = d->edges[opp] - g->edges;
+                                if (state->lines[opp_index] == LINE_UNKNOWN) {
+                                    solver_set_line(sstate, opp_index,
+                                                    LINE_YES);
+                                    diff = min(diff, DIFF_EASY);
+                                }
+                            }
+                        } else if (unknown == 4) {
+                            /* Exactly one of opposite UNKNOWNS is YES.  We've
+                             * already set atmostone, so set atleastone as
+                             * well.
+                             */
+                            if (dline_set_opp_atleastone(sstate, d, j))
+                                diff = min(diff, DIFF_NORMAL);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return diff;
+}
+
+static int linedsf_deductions(solver_state *sstate)
+{
+    game_state *state = sstate->state;
+    grid *g = state->game_grid;
+    char *dlines = sstate->dlines;
+    int i;
+    int diff = DIFF_MAX;
+    int diff_tmp;
+
+    /* ------ Face deductions ------ */
+
+    /* A fully-general linedsf deduction seems overly complicated
+     * (I suspect the problem is NP-complete, though in practice it might just
+     * be doable because faces are limited in size).
+     * For simplicity, we only consider *pairs* of LINE_UNKNOWNS that are
+     * known to be identical.  If setting them both to YES (or NO) would break
+     * the clue, set them to NO (or YES). */
+
+    for (i = 0; i < g->num_faces; i++) {
+        int N, yes, no, unknown;
+        int clue;
+
+        if (sstate->face_solved[i])
+            continue;
+        clue = state->clues[i];
+        if (clue < 0)
+            continue;
+
+        N = g->faces[i].order;
+        yes = sstate->face_yes_count[i];
+        if (yes + 1 == clue) {
+            if (face_setall_identical(sstate, i, LINE_NO))
+                diff = min(diff, DIFF_EASY);
+        }
+        no = sstate->face_no_count[i];
+        if (no + 1 == N - clue) {
+            if (face_setall_identical(sstate, i, LINE_YES))
+                diff = min(diff, DIFF_EASY);
+        }
+
+        /* Reload YES count, it might have changed */
+        yes = sstate->face_yes_count[i];
+        unknown = N - no - yes;
+
+        /* Deductions with small number of LINE_UNKNOWNs, based on overall
+         * parity of lines. */
+        diff_tmp = parity_deductions(sstate, g->faces[i].edges,
+                                     (clue - yes) % 2, unknown);
+        diff = min(diff, diff_tmp);
+    }
+
+    /* ------ Dot deductions ------ */
+    for (i = 0; i < g->num_dots; i++) {
+        grid_dot *d = g->dots + i;
+        int N = d->order;
+        int j;
+        int yes, no, unknown;
+        /* Go through dlines, and do any dline<->linedsf deductions wherever
+         * we find two UNKNOWNS. */
+        for (j = 0; j < N; j++) {
+            int dline_index = dline_index_from_dot(g, d, j);
+            int line1_index;
+            int line2_index;
+            int can1, can2, inv1, inv2;
+            int j2;
+            line1_index = d->edges[j] - g->edges;
+            if (state->lines[line1_index] != LINE_UNKNOWN)
+                continue;
+            j2 = j + 1;
+            if (j2 == N) j2 = 0;
+            line2_index = d->edges[j2] - g->edges;
+            if (state->lines[line2_index] != LINE_UNKNOWN)
+                continue;
+            /* Infer dline flags from linedsf */
+            can1 = edsf_canonify(sstate->linedsf, line1_index, &inv1);
+            can2 = edsf_canonify(sstate->linedsf, line2_index, &inv2);
+            if (can1 == can2 && inv1 != inv2) {
+                /* These are opposites, so set dline atmostone/atleastone */
+                if (set_atmostone(dlines, dline_index))
+                    diff = min(diff, DIFF_NORMAL);
+                if (set_atleastone(dlines, dline_index))
+                    diff = min(diff, DIFF_NORMAL);
+                continue;
+            }
+            /* Infer linedsf from dline flags */
+            if (is_atmostone(dlines, dline_index)
+                && is_atleastone(dlines, dline_index)) {
+                if (merge_lines(sstate, line1_index, line2_index, 1))
+                    diff = min(diff, DIFF_HARD);
+            }
+        }
+
+        /* Deductions with small number of LINE_UNKNOWNs, based on overall
+         * parity of lines. */
+        yes = sstate->dot_yes_count[i];
+        no = sstate->dot_no_count[i];
+        unknown = N - yes - no;
+        diff_tmp = parity_deductions(sstate, d->edges,
+                                     yes % 2, unknown);
+        diff = min(diff, diff_tmp);
+    }
+
+    /* ------ Edge dsf deductions ------ */
+
+    /* If the state of a line is known, deduce the state of its canonical line
+     * too, and vice versa. */
+    for (i = 0; i < g->num_edges; i++) {
+        int can, inv;
+        enum line_state s;
+        can = edsf_canonify(sstate->linedsf, i, &inv);
+        if (can == i)
+            continue;
+        s = sstate->state->lines[can];
+        if (s != LINE_UNKNOWN) {
+            if (solver_set_line(sstate, i, inv ? OPP(s) : s))
+                diff = min(diff, DIFF_EASY);
+        } else {
+            s = sstate->state->lines[i];
+            if (s != LINE_UNKNOWN) {
+                if (solver_set_line(sstate, can, inv ? OPP(s) : s))
+                    diff = min(diff, DIFF_EASY);
+            }
+        }
+    }
+
+    return diff;
+}
+
+static int loop_deductions(solver_state *sstate)
+{
+    int edgecount = 0, clues = 0, satclues = 0, sm1clues = 0;
+    game_state *state = sstate->state;
+    grid *g = state->game_grid;
+    int shortest_chainlen = g->num_dots;
+    int loop_found = FALSE;
+    int dots_connected;
+    int progress = FALSE;
+    int i;
+
+    /*
+     * Go through the grid and update for all the new edges.
+     * Since merge_dots() is idempotent, the simplest way to
+     * do this is just to update for _all_ the edges.
+     * Also, while we're here, we count the edges.
+     */
+    for (i = 0; i < g->num_edges; i++) {
+        if (state->lines[i] == LINE_YES) {
+            loop_found |= merge_dots(sstate, i);
+            edgecount++;
+        }
+    }
+
+    /*
+     * Count the clues, count the satisfied clues, and count the
+     * satisfied-minus-one clues.
+     */
+    for (i = 0; i < g->num_faces; i++) {
+        int c = state->clues[i];
+        if (c >= 0) {
+            int o = sstate->face_yes_count[i];
+            if (o == c)
+                satclues++;
+            else if (o == c-1)
+                sm1clues++;
+            clues++;
+        }
+    }
+
+    for (i = 0; i < g->num_dots; ++i) {
+        dots_connected =
+            sstate->looplen[dsf_canonify(sstate->dotdsf, i)];
+        if (dots_connected > 1)
+            shortest_chainlen = min(shortest_chainlen, dots_connected);
+    }
+
+    assert(sstate->solver_status == SOLVER_INCOMPLETE);
+
+    if (satclues == clues && shortest_chainlen == edgecount) {
+        sstate->solver_status = SOLVER_SOLVED;
+        /* This discovery clearly counts as progress, even if we haven't
+         * just added any lines or anything */
+        progress = TRUE;
+        goto finished_loop_deductionsing;
+    }
+
+    /*
+     * Now go through looking for LINE_UNKNOWN edges which
+     * connect two dots that are already in the same
+     * equivalence class. If we find one, test to see if the
+     * loop it would create is a solution.
+     */
+    for (i = 0; i < g->num_edges; i++) {
+        grid_edge *e = g->edges + i;
+        int d1 = e->dot1 - g->dots;
+        int d2 = e->dot2 - g->dots;
+        int eqclass, val;
+        if (state->lines[i] != LINE_UNKNOWN)
+            continue;
+
+        eqclass = dsf_canonify(sstate->dotdsf, d1);
+        if (eqclass != dsf_canonify(sstate->dotdsf, d2))
+            continue;
+
+        val = LINE_NO;  /* loop is bad until proven otherwise */
+
+        /*
+         * This edge would form a loop. Next
+         * question: how long would the loop be?
+         * Would it equal the total number of edges
+         * (plus the one we'd be adding if we added
+         * it)?
+         */
+        if (sstate->looplen[eqclass] == edgecount + 1) {
+            int sm1_nearby;
+
+            /*
+             * This edge would form a loop which
+             * took in all the edges in the entire
+             * grid. So now we need to work out
+             * whether it would be a valid solution
+             * to the puzzle, which means we have to
+             * check if it satisfies all the clues.
+             * This means that every clue must be
+             * either satisfied or satisfied-minus-
+             * 1, and also that the number of
+             * satisfied-minus-1 clues must be at
+             * most two and they must lie on either
+             * side of this edge.
+             */
+            sm1_nearby = 0;
+            if (e->face1) {
+                int f = e->face1 - g->faces;
+                int c = state->clues[f];
+                if (c >= 0 && sstate->face_yes_count[f] == c - 1)
+                    sm1_nearby++;
+            }
+            if (e->face2) {
+                int f = e->face2 - g->faces;
+                int c = state->clues[f];
+                if (c >= 0 && sstate->face_yes_count[f] == c - 1)
+                    sm1_nearby++;
+            }
+            if (sm1clues == sm1_nearby &&
+                sm1clues + satclues == clues) {
+                val = LINE_YES;  /* loop is good! */
+            }
+        }
+
+        /*
+         * Right. Now we know that adding this edge
+         * would form a loop, and we know whether
+         * that loop would be a viable solution or
+         * not.
+         *
+         * If adding this edge produces a solution,
+         * then we know we've found _a_ solution but
+         * we don't know that it's _the_ solution -
+         * if it were provably the solution then
+         * we'd have deduced this edge some time ago
+         * without the need to do loop detection. So
+         * in this state we return SOLVER_AMBIGUOUS,
+         * which has the effect that hitting Solve
+         * on a user-provided puzzle will fill in a
+         * solution but using the solver to
+         * construct new puzzles won't consider this
+         * a reasonable deduction for the user to
+         * make.
+         */
+        progress = solver_set_line(sstate, i, val);
+        assert(progress == TRUE);
+        if (val == LINE_YES) {
+            sstate->solver_status = SOLVER_AMBIGUOUS;
+            goto finished_loop_deductionsing;
+        }
+    }
+
+    finished_loop_deductionsing:
+    return progress ? DIFF_EASY : DIFF_MAX;
+}
+
+/* This will return a dynamically allocated solver_state containing the (more)
+ * solved grid */
+static solver_state *solve_game_rec(const solver_state *sstate_start)
+{
+    solver_state *sstate;
+
+    /* Index of the solver we should call next. */
+    int i = 0;
+    
+    /* As a speed-optimisation, we avoid re-running solvers that we know
+     * won't make any progress.  This happens when a high-difficulty
+     * solver makes a deduction that can only help other high-difficulty
+     * solvers.
+     * For example: if a new 'dline' flag is set by dline_deductions, the
+     * trivial_deductions solver cannot do anything with this information.
+     * If we've already run the trivial_deductions solver (because it's
+     * earlier in the list), there's no point running it again.
+     *
+     * Therefore: if a solver is earlier in the list than "threshold_index",
+     * we don't bother running it if it's difficulty level is less than
+     * "threshold_diff".
+     */
+    int threshold_diff = 0;
+    int threshold_index = 0;
+    
+    sstate = dup_solver_state(sstate_start);
+
+    check_caches(sstate);
+
+    while (i < NUM_SOLVERS) {
+        if (sstate->solver_status == SOLVER_MISTAKE)
+            return sstate;
+        if (sstate->solver_status == SOLVER_SOLVED ||
+            sstate->solver_status == SOLVER_AMBIGUOUS) {
+            /* solver finished */
+            break;
+        }
+
+        if ((solver_diffs[i] >= threshold_diff || i >= threshold_index)
+            && solver_diffs[i] <= sstate->diff) {
+            /* current_solver is eligible, so use it */
+            int next_diff = solver_fns[i](sstate);
+            if (next_diff != DIFF_MAX) {
+                /* solver made progress, so use new thresholds and
+                * start again at top of list. */
+                threshold_diff = next_diff;
+                threshold_index = i;
+                i = 0;
+                continue;
+            }
+        }
+        /* current_solver is ineligible, or failed to make progress, so
+         * go to the next solver in the list */
+        i++;
+    }
+
+    if (sstate->solver_status == SOLVER_SOLVED ||
+        sstate->solver_status == SOLVER_AMBIGUOUS) {
+        /* s/LINE_UNKNOWN/LINE_NO/g */
+        array_setall(sstate->state->lines, LINE_UNKNOWN, LINE_NO,
+                     sstate->state->game_grid->num_edges);
+        return sstate;
+    }
+
+    return sstate;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    char *soln = NULL;
+    solver_state *sstate, *new_sstate;
+
+    sstate = new_solver_state(state, DIFF_MAX);
+    new_sstate = solve_game_rec(sstate);
+
+    if (new_sstate->solver_status == SOLVER_SOLVED) {
+        soln = encode_solve_move(new_sstate->state);
+    } else if (new_sstate->solver_status == SOLVER_AMBIGUOUS) {
+        soln = encode_solve_move(new_sstate->state);
+        /**error = "Solver found ambiguous solutions"; */
+    } else {
+        soln = encode_solve_move(new_sstate->state);
+        /**error = "Solver failed"; */
+    }
+
+    free_solver_state(new_sstate);
+    free_solver_state(sstate);
+
+    return soln;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing and mouse-handling
+ */
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    grid *g = state->game_grid;
+    grid_edge *e;
+    int i;
+    char *ret, buf[80];
+    char button_char = ' ';
+    enum line_state old_state;
+
+    button &= ~MOD_MASK;
+
+    /* Convert mouse-click (x,y) to grid coordinates */
+    x -= BORDER(ds->tilesize);
+    y -= BORDER(ds->tilesize);
+    x = x * g->tilesize / ds->tilesize;
+    y = y * g->tilesize / ds->tilesize;
+    x += g->lowest_x;
+    y += g->lowest_y;
+
+    e = grid_nearest_edge(g, x, y);
+    if (e == NULL)
+        return NULL;
+
+    i = e - g->edges;
+
+    /* I think it's only possible to play this game with mouse clicks, sorry */
+    /* Maybe will add mouse drag support some time */
+    old_state = state->lines[i];
+
+    switch (button) {
+      case LEFT_BUTTON:
+        switch (old_state) {
+          case LINE_UNKNOWN:
+            button_char = 'y';
+            break;
+          case LINE_YES:
+#ifdef STYLUS_BASED
+            button_char = 'n';
+            break;
+#endif
+          case LINE_NO:
+            button_char = 'u';
+            break;
+        }
+        break;
+      case MIDDLE_BUTTON:
+        button_char = 'u';
+        break;
+      case RIGHT_BUTTON:
+        switch (old_state) {
+          case LINE_UNKNOWN:
+            button_char = 'n';
+            break;
+          case LINE_NO:
+#ifdef STYLUS_BASED
+            button_char = 'y';
+            break;
+#endif
+          case LINE_YES:
+            button_char = 'u';
+            break;
+        }
+        break;
+      default:
+        return NULL;
+    }
+
+
+    sprintf(buf, "%d%c", i, (int)button_char);
+    ret = dupstr(buf);
+
+    return ret;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int i;
+    game_state *newstate = dup_game(state);
+
+    if (move[0] == 'S') {
+        move++;
+        newstate->cheated = TRUE;
+    }
+
+    while (*move) {
+        i = atoi(move);
+        if (i < 0 || i >= newstate->game_grid->num_edges)
+            goto fail;
+        move += strspn(move, "1234567890");
+        switch (*(move++)) {
+          case 'y':
+            newstate->lines[i] = LINE_YES;
+            break;
+          case 'n':
+            newstate->lines[i] = LINE_NO;
+            break;
+          case 'u':
+            newstate->lines[i] = LINE_UNKNOWN;
+            break;
+          default:
+            goto fail;
+        }
+    }
+
+    /*
+     * Check for completion.
+     */
+    if (check_completion(newstate))
+        newstate->solved = TRUE;
+
+    return newstate;
+
+    fail:
+    free_game(newstate);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+/* Convert from grid coordinates to screen coordinates */
+static void grid_to_screen(const game_drawstate *ds, const grid *g,
+                           int grid_x, int grid_y, int *x, int *y)
+{
+    *x = grid_x - g->lowest_x;
+    *y = grid_y - g->lowest_y;
+    *x = *x * ds->tilesize / g->tilesize;
+    *y = *y * ds->tilesize / g->tilesize;
+    *x += BORDER(ds->tilesize);
+    *y += BORDER(ds->tilesize);
+}
+
+/* Returns (into x,y) position of centre of face for rendering the text clue.
+ */
+static void face_text_pos(const game_drawstate *ds, const grid *g,
+                          grid_face *f, int *xret, int *yret)
+{
+    int faceindex = f - g->faces;
+
+    /*
+     * Return the cached position for this face, if we've already
+     * worked it out.
+     */
+    if (ds->textx[faceindex] >= 0) {
+        *xret = ds->textx[faceindex];
+        *yret = ds->texty[faceindex];
+        return;
+    }
+
+    /*
+     * Otherwise, use the incentre computed by grid.c and convert it
+     * to screen coordinates.
+     */
+    grid_find_incentre(f);
+    grid_to_screen(ds, g, f->ix, f->iy,
+                   &ds->textx[faceindex], &ds->texty[faceindex]);
+
+    *xret = ds->textx[faceindex];
+    *yret = ds->texty[faceindex];
+}
+
+static void face_text_bbox(game_drawstate *ds, grid *g, grid_face *f,
+                           int *x, int *y, int *w, int *h)
+{
+    int xx, yy;
+    face_text_pos(ds, g, f, &xx, &yy);
+
+    /* There seems to be a certain amount of trial-and-error involved
+     * in working out the correct bounding-box for the text. */
+
+    *x = xx - ds->tilesize/4 - 1;
+    *y = yy - ds->tilesize/4 - 3;
+    *w = ds->tilesize/2 + 2;
+    *h = ds->tilesize/2 + 5;
+}
+
+static void game_redraw_clue(drawing *dr, game_drawstate *ds,
+                             const game_state *state, int i)
+{
+    grid *g = state->game_grid;
+    grid_face *f = g->faces + i;
+    int x, y;
+    char c[20];
+
+    sprintf(c, "%d", state->clues[i]);
+
+    face_text_pos(ds, g, f, &x, &y);
+    draw_text(dr, x, y,
+              FONT_VARIABLE, ds->tilesize/2,
+              ALIGN_VCENTRE | ALIGN_HCENTRE,
+              ds->clue_error[i] ? COL_MISTAKE :
+              ds->clue_satisfied[i] ? COL_SATISFIED : COL_FOREGROUND, c);
+}
+
+static void edge_bbox(game_drawstate *ds, grid *g, grid_edge *e,
+                      int *x, int *y, int *w, int *h)
+{
+    int x1 = e->dot1->x;
+    int y1 = e->dot1->y;
+    int x2 = e->dot2->x;
+    int y2 = e->dot2->y;
+    int xmin, xmax, ymin, ymax;
+
+    grid_to_screen(ds, g, x1, y1, &x1, &y1);
+    grid_to_screen(ds, g, x2, y2, &x2, &y2);
+    /* Allow extra margin for dots, and thickness of lines */
+    xmin = min(x1, x2) - 2;
+    xmax = max(x1, x2) + 2;
+    ymin = min(y1, y2) - 2;
+    ymax = max(y1, y2) + 2;
+
+    *x = xmin;
+    *y = ymin;
+    *w = xmax - xmin + 1;
+    *h = ymax - ymin + 1;
+}
+
+static void dot_bbox(game_drawstate *ds, grid *g, grid_dot *d,
+                     int *x, int *y, int *w, int *h)
+{
+    int x1, y1;
+
+    grid_to_screen(ds, g, d->x, d->y, &x1, &y1);
+
+    *x = x1 - 2;
+    *y = y1 - 2;
+    *w = 5;
+    *h = 5;
+}
+
+static const int loopy_line_redraw_phases[] = {
+    COL_FAINT, COL_LINEUNKNOWN, COL_FOREGROUND, COL_HIGHLIGHT, COL_MISTAKE
+};
+#define NPHASES lenof(loopy_line_redraw_phases)
+
+static void game_redraw_line(drawing *dr, game_drawstate *ds,
+                             const game_state *state, int i, int phase)
+{
+    grid *g = state->game_grid;
+    grid_edge *e = g->edges + i;
+    int x1, x2, y1, y2;
+    int line_colour;
+
+    if (state->line_errors[i])
+        line_colour = COL_MISTAKE;
+    else if (state->lines[i] == LINE_UNKNOWN)
+        line_colour = COL_LINEUNKNOWN;
+    else if (state->lines[i] == LINE_NO)
+        line_colour = COL_FAINT;
+    else if (ds->flashing)
+        line_colour = COL_HIGHLIGHT;
+    else
+        line_colour = COL_FOREGROUND;
+    if (line_colour != loopy_line_redraw_phases[phase])
+        return;
+
+    /* Convert from grid to screen coordinates */
+    grid_to_screen(ds, g, e->dot1->x, e->dot1->y, &x1, &y1);
+    grid_to_screen(ds, g, e->dot2->x, e->dot2->y, &x2, &y2);
+
+    if (line_colour == COL_FAINT) {
+        static int draw_faint_lines = -1;
+        if (draw_faint_lines < 0) {
+            char *env = getenv("LOOPY_FAINT_LINES");
+            draw_faint_lines = (!env || (env[0] == 'y' ||
+                                         env[0] == 'Y'));
+        }
+        if (draw_faint_lines)
+            draw_line(dr, x1, y1, x2, y2, line_colour);
+    } else {
+        draw_thick_line(dr, 3.0,
+                        x1 + 0.5, y1 + 0.5,
+                        x2 + 0.5, y2 + 0.5,
+                        line_colour);
+    }
+}
+
+static void game_redraw_dot(drawing *dr, game_drawstate *ds,
+                            const game_state *state, int i)
+{
+    grid *g = state->game_grid;
+    grid_dot *d = g->dots + i;
+    int x, y;
+
+    grid_to_screen(ds, g, d->x, d->y, &x, &y);
+    draw_circle(dr, x, y, 2, COL_FOREGROUND, COL_FOREGROUND);
+}
+
+static int boxes_intersect(int x0, int y0, int w0, int h0,
+                           int x1, int y1, int w1, int h1)
+{
+    /*
+     * Two intervals intersect iff neither is wholly on one side of
+     * the other. Two boxes intersect iff their horizontal and
+     * vertical intervals both intersect.
+     */
+    return (x0 < x1+w1 && x1 < x0+w0 && y0 < y1+h1 && y1 < y0+h0);
+}
+
+static void game_redraw_in_rect(drawing *dr, game_drawstate *ds,
+                                const game_state *state,
+                                int x, int y, int w, int h)
+{
+    grid *g = state->game_grid;
+    int i, phase;
+    int bx, by, bw, bh;
+
+    clip(dr, x, y, w, h);
+    draw_rect(dr, x, y, w, h, COL_BACKGROUND);
+
+    for (i = 0; i < g->num_faces; i++) {
+        if (state->clues[i] >= 0) {
+            face_text_bbox(ds, g, &g->faces[i], &bx, &by, &bw, &bh);
+            if (boxes_intersect(x, y, w, h, bx, by, bw, bh))
+                game_redraw_clue(dr, ds, state, i);
+        }
+    }
+    for (phase = 0; phase < NPHASES; phase++) {
+        for (i = 0; i < g->num_edges; i++) {
+            edge_bbox(ds, g, &g->edges[i], &bx, &by, &bw, &bh);
+            if (boxes_intersect(x, y, w, h, bx, by, bw, bh))
+                game_redraw_line(dr, ds, state, i, phase);
+        }
+    }
+    for (i = 0; i < g->num_dots; i++) {
+        dot_bbox(ds, g, &g->dots[i], &bx, &by, &bw, &bh);
+        if (boxes_intersect(x, y, w, h, bx, by, bw, bh))
+            game_redraw_dot(dr, ds, state, i);
+    }
+
+    unclip(dr);
+    draw_update(dr, x, y, w, h);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+#define REDRAW_OBJECTS_LIMIT 16         /* Somewhat arbitrary tradeoff */
+
+    grid *g = state->game_grid;
+    int border = BORDER(ds->tilesize);
+    int i;
+    int flash_changed;
+    int redraw_everything = FALSE;
+
+    int edges[REDRAW_OBJECTS_LIMIT], nedges = 0;
+    int faces[REDRAW_OBJECTS_LIMIT], nfaces = 0;
+
+    /* Redrawing is somewhat involved.
+     *
+     * An update can theoretically affect an arbitrary number of edges
+     * (consider, for example, completing or breaking a cycle which doesn't
+     * satisfy all the clues -- we'll switch many edges between error and
+     * normal states).  On the other hand, redrawing the whole grid takes a
+     * while, making the game feel sluggish, and many updates are actually
+     * quite well localized.
+     *
+     * This redraw algorithm attempts to cope with both situations gracefully
+     * and correctly.  For localized changes, we set a clip rectangle, fill
+     * it with background, and then redraw (a plausible but conservative
+     * guess at) the objects which intersect the rectangle; if several
+     * objects need redrawing, we'll do them individually.  However, if lots
+     * of objects are affected, we'll just redraw everything.
+     *
+     * The reason for all of this is that it's just not safe to do the redraw
+     * piecemeal.  If you try to draw an antialiased diagonal line over
+     * itself, you get a slightly thicker antialiased diagonal line, which
+     * looks rather ugly after a while.
+     *
+     * So, we take two passes over the grid.  The first attempts to work out
+     * what needs doing, and the second actually does it.
+     */
+
+    if (!ds->started) {
+        redraw_everything = TRUE;
+        /*
+         * But we must still go through the upcoming loops, so that we
+         * set up stuff in ds correctly for the initial redraw.
+         */
+    }
+
+    /* First, trundle through the faces. */
+    for (i = 0; i < g->num_faces; i++) {
+        grid_face *f = g->faces + i;
+        int sides = f->order;
+        int yes_order, no_order;
+        int clue_mistake;
+        int clue_satisfied;
+        int n = state->clues[i];
+        if (n < 0)
+            continue;
+
+        yes_order = face_order(state, i, LINE_YES);
+        if (state->exactly_one_loop) {
+            /*
+             * Special case: if the set of LINE_YES edges in the grid
+             * consists of exactly one loop and nothing else, then we
+             * switch to treating LINE_UNKNOWN the same as LINE_NO for
+             * purposes of clue checking.
+             *
+             * This is because some people like to play Loopy without
+             * using the right-click, i.e. never setting anything to
+             * LINE_NO. Without this special case, if a person playing
+             * in that style fills in what they think is a correct
+             * solution loop but in fact it has an underfilled clue,
+             * then we will display no victory flash and also no error
+             * highlight explaining why not. With this special case,
+             * we light up underfilled clues at the instant the loop
+             * is closed. (Of course, *overfilled* clues are fine
+             * either way.)
+             *
+             * (It might still be considered unfortunate that we can't
+             * warn this style of player any earlier, if they make a
+             * mistake very near the beginning which doesn't show up
+             * until they close the last edge of the loop. One other
+             * thing we _could_ do here is to treat any LINE_UNKNOWN
+             * as LINE_NO if either of its endpoints has yes-degree 2,
+             * reflecting the fact that setting that line to YES would
+             * be an obvious error. But I don't think even that could
+             * catch _all_ clue errors in a timely manner; I think
+             * there are some that won't be displayed until the loop
+             * is filled in, even so, and there's no way to avoid that
+             * with complete reliability except to switch to being a
+             * player who sets things to LINE_NO.)
+             */
+            no_order = sides - yes_order;
+        } else {
+            no_order = face_order(state, i, LINE_NO);
+        }
+
+        clue_mistake = (yes_order > n || no_order > (sides-n));
+        clue_satisfied = (yes_order == n && no_order == (sides-n));
+
+        if (clue_mistake != ds->clue_error[i] ||
+            clue_satisfied != ds->clue_satisfied[i]) {
+            ds->clue_error[i] = clue_mistake;
+            ds->clue_satisfied[i] = clue_satisfied;
+            if (nfaces == REDRAW_OBJECTS_LIMIT)
+                redraw_everything = TRUE;
+            else
+                faces[nfaces++] = i;
+        }
+    }
+
+    /* Work out what the flash state needs to be. */
+    if (flashtime > 0 &&
+        (flashtime <= FLASH_TIME/3 ||
+         flashtime >= FLASH_TIME*2/3)) {
+        flash_changed = !ds->flashing;
+        ds->flashing = TRUE;
+    } else {
+        flash_changed = ds->flashing;
+        ds->flashing = FALSE;
+    }
+
+    /* Now, trundle through the edges. */
+    for (i = 0; i < g->num_edges; i++) {
+        char new_ds =
+            state->line_errors[i] ? DS_LINE_ERROR : state->lines[i];
+        if (new_ds != ds->lines[i] ||
+            (flash_changed && state->lines[i] == LINE_YES)) {
+            ds->lines[i] = new_ds;
+            if (nedges == REDRAW_OBJECTS_LIMIT)
+                redraw_everything = TRUE;
+            else
+                edges[nedges++] = i;
+        }
+    }
+
+    /* Pass one is now done.  Now we do the actual drawing. */
+    if (redraw_everything) {
+        int grid_width = g->highest_x - g->lowest_x;
+        int grid_height = g->highest_y - g->lowest_y;
+        int w = grid_width * ds->tilesize / g->tilesize;
+        int h = grid_height * ds->tilesize / g->tilesize;
+
+        game_redraw_in_rect(dr, ds, state,
+                            0, 0, w + 2*border + 1, h + 2*border + 1);
+    } else {
+
+        /* Right.  Now we roll up our sleeves. */
+
+        for (i = 0; i < nfaces; i++) {
+            grid_face *f = g->faces + faces[i];
+            int x, y, w, h;
+
+            face_text_bbox(ds, g, f, &x, &y, &w, &h);
+            game_redraw_in_rect(dr, ds, state, x, y, w, h);
+        }
+
+        for (i = 0; i < nedges; i++) {
+            grid_edge *e = g->edges + edges[i];
+            int x, y, w, h;
+
+            edge_bbox(ds, g, e, &x, &y, &w, &h);
+            game_redraw_in_rect(dr, ds, state, x, y, w, h);
+        }
+    }
+
+    ds->started = TRUE;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->solved  &&  newstate->solved &&
+        !oldstate->cheated && !newstate->cheated) {
+        return FLASH_TIME;
+    }
+
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->solved ? +1 : 0;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 7mm "squares" by default.
+     */
+    game_compute_size(params, 700, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int ink = print_mono_colour(dr, 0);
+    int i;
+    game_drawstate ads, *ds = &ads;
+    grid *g = state->game_grid;
+
+    ds->tilesize = tilesize;
+    ds->textx = snewn(g->num_faces, int);
+    ds->texty = snewn(g->num_faces, int);
+    for (i = 0; i < g->num_faces; i++)
+        ds->textx[i] = ds->texty[i] = -1;
+
+    for (i = 0; i < g->num_dots; i++) {
+        int x, y;
+        grid_to_screen(ds, g, g->dots[i].x, g->dots[i].y, &x, &y);
+        draw_circle(dr, x, y, ds->tilesize / 15, ink, ink);
+    }
+
+    /*
+     * Clues.
+     */
+    for (i = 0; i < g->num_faces; i++) {
+        grid_face *f = g->faces + i;
+        int clue = state->clues[i];
+        if (clue >= 0) {
+            char c[20];
+            int x, y;
+            sprintf(c, "%d", state->clues[i]);
+            face_text_pos(ds, g, f, &x, &y);
+            draw_text(dr, x, y,
+                      FONT_VARIABLE, ds->tilesize / 2,
+                      ALIGN_VCENTRE | ALIGN_HCENTRE, ink, c);
+        }
+    }
+
+    /*
+     * Lines.
+     */
+    for (i = 0; i < g->num_edges; i++) {
+        int thickness = (state->lines[i] == LINE_YES) ? 30 : 150;
+        grid_edge *e = g->edges + i;
+        int x1, y1, x2, y2;
+        grid_to_screen(ds, g, e->dot1->x, e->dot1->y, &x1, &y1);
+        grid_to_screen(ds, g, e->dot2->x, e->dot2->y, &x2, &y2);
+        if (state->lines[i] == LINE_YES)
+        {
+            /* (dx, dy) points from (x1, y1) to (x2, y2).
+             * The line is then "fattened" in a perpendicular
+             * direction to create a thin rectangle. */
+            double d = sqrt(SQ((double)x1 - x2) + SQ((double)y1 - y2));
+            double dx = (x2 - x1) / d;
+            double dy = (y2 - y1) / d;
+            int points[8];
+
+            dx = (dx * ds->tilesize) / thickness;
+            dy = (dy * ds->tilesize) / thickness;
+            points[0] = x1 + (int)dy;
+            points[1] = y1 - (int)dx;
+            points[2] = x1 - (int)dy;
+            points[3] = y1 + (int)dx;
+            points[4] = x2 - (int)dy;
+            points[5] = y2 + (int)dx;
+            points[6] = x2 + (int)dy;
+            points[7] = y2 - (int)dx;
+            draw_polygon(dr, points, 4, ink, ink);
+        }
+        else
+        {
+            /* Draw a dotted line */
+            int divisions = 6;
+            int j;
+            for (j = 1; j < divisions; j++) {
+                /* Weighted average */
+                int x = (x1 * (divisions -j) + x2 * j) / divisions;
+                int y = (y1 * (divisions -j) + y2 * j) / divisions;
+                draw_circle(dr, x, y, ds->tilesize / thickness, ink, ink);
+            }
+        }
+    }
+
+    sfree(ds->textx);
+    sfree(ds->texty);
+}
+
+#ifdef COMBINED
+#define thegame loopy
+#endif
+
+const struct game thegame = {
+    "Loopy", "games.loopy", "loopy",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    1, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE /* wants_statusbar */,
+    FALSE, game_timing_state,
+    0,                                       /* mouse_priorities */
+};
+
+#ifdef STANDALONE_SOLVER
+
+/*
+ * Half-hearted standalone solver. It can't output the solution to
+ * anything but a square puzzle, and it can't log the deductions
+ * it makes either. But it can solve square puzzles, and more
+ * importantly it can use its solver to grade the difficulty of
+ * any puzzle you give it.
+ */
+
+#include <stdarg.h>
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err;
+    int grade = FALSE;
+    int ret, diff;
+#if 0 /* verbose solver not supported here (yet) */
+    int really_verbose = FALSE;
+#endif
+
+    while (--argc > 0) {
+        char *p = *++argv;
+#if 0 /* verbose solver not supported here (yet) */
+        if (!strcmp(p, "-v")) {
+            really_verbose = TRUE;
+        } else
+#endif
+        if (!strcmp(p, "-g")) {
+            grade = TRUE;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-g | -v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    /*
+     * When solving an Easy puzzle, we don't want to bother the
+     * user with Hard-level deductions. For this reason, we grade
+     * the puzzle internally before doing anything else.
+     */
+    ret = -1;                          /* placate optimiser */
+    for (diff = 0; diff < DIFF_MAX; diff++) {
+        solver_state *sstate_new;
+        solver_state *sstate = new_solver_state((game_state *)s, diff);
+
+        sstate_new = solve_game_rec(sstate);
+
+        if (sstate_new->solver_status == SOLVER_MISTAKE)
+            ret = 0;
+        else if (sstate_new->solver_status == SOLVER_SOLVED)
+            ret = 1;
+        else
+            ret = 2;
+
+        free_solver_state(sstate_new);
+        free_solver_state(sstate);
+
+        if (ret < 2)
+            break;
+    }
+
+    if (diff == DIFF_MAX) {
+        if (grade)
+            printf("Difficulty rating: harder than Hard, or ambiguous\n");
+        else
+            printf("Unable to find a unique solution\n");
+    } else {
+        if (grade) {
+            if (ret == 0)
+                printf("Difficulty rating: impossible (no solution exists)\n");
+            else if (ret == 1)
+                printf("Difficulty rating: %s\n", diffnames[diff]);
+        } else {
+            solver_state *sstate_new;
+            solver_state *sstate = new_solver_state((game_state *)s, diff);
+
+            /* If we supported a verbose solver, we'd set verbosity here */
+
+            sstate_new = solve_game_rec(sstate);
+
+            if (sstate_new->solver_status == SOLVER_MISTAKE)
+                printf("Puzzle is inconsistent\n");
+            else {
+                assert(sstate_new->solver_status == SOLVER_SOLVED);
+                if (s->grid_type == 0) {
+                    fputs(game_text_format(sstate_new->state), stdout);
+                } else {
+                    printf("Unable to output non-square grids\n");
+                }
+            }
+
+            free_solver_state(sstate_new);
+            free_solver_state(sstate);
+        }
+    }
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/magnets.R b/apps/plugins/puzzles/magnets.R
new file mode 100644
index 0000000000..e55e4746ee
--- /dev/null
+++ b/apps/plugins/puzzles/magnets.R
@@ -0,0 +1,24 @@
+# -*- makefile -*-
+
+MAGNETS_EXTRA = laydomino
+
+magnets      : [X] GTK COMMON magnets MAGNETS_EXTRA magnets-icon|no-icon
+
+magnets      : [G] WINDOWS COMMON magnets MAGNETS_EXTRA magnets.res|noicon.res
+
+magnetssolver :     [U] magnets[STANDALONE_SOLVER] MAGNETS_EXTRA STANDALONE m.lib
+magnetssolver :     [C] magnets[STANDALONE_SOLVER] MAGNETS_EXTRA STANDALONE
+
+ALL += magnets[COMBINED] MAGNETS_EXTRA
+
+!begin am gtk
+GAMES += magnets
+!end
+
+!begin >list.c
+    A(magnets) \
+!end
+
+!begin >gamedesc.txt
+magnets:magnets.exe:Magnets:Magnet-placing puzzle:Place magnets to satisfy the clues and avoid like poles touching.
+!end
diff --git a/apps/plugins/puzzles/magnets.c b/apps/plugins/puzzles/magnets.c
new file mode 100644
index 0000000000..e51ae103c5
--- /dev/null
+++ b/apps/plugins/puzzles/magnets.c
@@ -0,0 +1,2641 @@
+/*
+ * magnets.c: implementation of janko.at 'magnets puzzle' game.
+ *
+ * http://64.233.179.104/translate_c?hl=en&u=http://www.janko.at/Raetsel/Magnete/Beispiel.htm
+ *
+ * Puzzle definition is just the size, and then the list of + (across then
+ * down) and - (across then down) present, then domino edges.
+ *
+ * An example:
+ *
+ *  + 2 0 1
+ *   +-----+
+ *  1|+ -| |1
+ *   |-+-+ |
+ *  0|-|#| |1
+ *   | +-+-|
+ *  2|+|- +|1
+ *   +-----+
+ *    1 2 0 -
+ *
+ * 3x3:201,102,120,111,LRTT*BBLR
+ *
+ * 'Zotmeister' examples:
+ * 5x5:.2..1,3..1.,.2..2,2..2.,LRLRTTLRTBBT*BTTBLRBBLRLR
+ * 9x9:3.51...33,.2..23.13,..33.33.2,12...5.3.,**TLRTLR*,*TBLRBTLR,TBLRLRBTT,BLRTLRTBB,LRTB*TBLR,LRBLRBLRT,TTTLRLRTB,BBBTLRTB*,*LRBLRB**
+ *
+ * Janko 6x6 with solution:
+ * 6x6:322223,323132,232223,232223,LRTLRTTTBLRBBBTTLRLRBBLRTTLRTTBBLRBB
+ *
+ * janko 8x8:
+ * 8x8:34131323,23131334,43122323,21332243,LRTLRLRT,LRBTTTTB,LRTBBBBT,TTBTLRTB,BBTBTTBT,TTBTBBTB,BBTBLRBT,LRBLRLRB
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#ifdef STANDALONE_SOLVER
+int verbose = 0;
+#endif
+
+enum {
+    COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT,
+    COL_TEXT, COL_ERROR, COL_CURSOR, COL_DONE,
+    COL_NEUTRAL, COL_NEGATIVE, COL_POSITIVE, COL_NOT,
+    NCOLOURS
+};
+
+/* Cell states. */
+enum { EMPTY = 0, NEUTRAL = EMPTY, POSITIVE = 1, NEGATIVE = 2 };
+
+#if defined DEBUGGING || defined STANDALONE_SOLVER
+static const char *cellnames[3] = { "neutral", "positive", "negative" };
+#define NAME(w) ( ((w) < 0 || (w) > 2) ? "(out of range)" : cellnames[(w)] )
+#endif
+
+#define GRID2CHAR(g) ( ((g) >= 0 && (g) <= 2) ? ".+-"[(g)] : '?' )
+#define CHAR2GRID(c) ( (c) == '+' ? POSITIVE : (c) == '-' ? NEGATIVE : NEUTRAL )
+
+#define INGRID(s,x,y) ((x) >= 0 && (x) < (s)->w && (y) >= 0 && (y) < (s)->h)
+
+#define OPPOSITE(x) ( ((x)*2) % 3 ) /* 0 --> 0,
+                                       1 --> 2,
+                                       2 --> 4 --> 1 */
+
+#define FLASH_TIME 0.7F
+
+/* Macro ickery copied from slant.c */
+#define DIFFLIST(A) \
+    A(EASY,Easy,e) \
+    A(TRICKY,Tricky,t)
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const magnets_diffnames[] = { DIFFLIST(TITLE) "(count)" };
+static char const magnets_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+
+/* --------------------------------------------------------------- */
+/* Game parameter functions. */
+
+struct game_params {
+    int w, h, diff, stripclues;
+};
+
+#define DEFAULT_PRESET 2
+
+static const struct game_params magnets_presets[] = {
+    {6, 5, DIFF_EASY, 0},
+    {6, 5, DIFF_TRICKY, 0},
+    {6, 5, DIFF_TRICKY, 1},
+    {8, 7, DIFF_EASY, 0},
+    {8, 7, DIFF_TRICKY, 0},
+    {8, 7, DIFF_TRICKY, 1},
+    {10, 9, DIFF_TRICKY, 0},
+    {10, 9, DIFF_TRICKY, 1}
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    *ret = magnets_presets[DEFAULT_PRESET];
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[64];
+
+    if (i < 0 || i >= lenof(magnets_presets)) return FALSE;
+
+    ret = default_params();
+    *ret = magnets_presets[i]; /* struct copy */
+    *params = ret;
+
+    sprintf(buf, "%dx%d %s%s",
+            magnets_presets[i].w, magnets_presets[i].h,
+            magnets_diffnames[magnets_presets[i].diff],
+            magnets_presets[i].stripclues ? ", strip clues" : "");
+    *name = dupstr(buf);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;       /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    while (*string && isdigit((unsigned char) *string)) ++string;
+    if (*string == 'x') {
+        string++;
+        ret->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+
+    ret->diff = DIFF_EASY;
+    if (*string == 'd') {
+        int i;
+        string++;
+        for (i = 0; i < DIFFCOUNT; i++)
+            if (*string == magnets_diffchars[i])
+                ret->diff = i;
+        if (*string) string++;
+    }
+
+    ret->stripclues = 0;
+    if (*string == 'S') {
+        string++;
+        ret->stripclues = 1;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[256];
+    sprintf(buf, "%dx%d", params->w, params->h);
+    if (full)
+        sprintf(buf + strlen(buf), "d%c%s",
+                magnets_diffchars[params->diff],
+                params->stripclues ? "S" : "");
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[64];
+
+    ret = snewn(5, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Difficulty";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = DIFFCONFIG;
+    ret[2].ival = params->diff;
+
+    ret[3].name = "Strip clues";
+    ret[3].type = C_BOOLEAN;
+    ret[3].sval = NULL;
+    ret[3].ival = params->stripclues;
+
+    ret[4].name = NULL;
+    ret[4].type = C_END;
+    ret[4].sval = NULL;
+    ret[4].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->diff = cfg[2].ival;
+    ret->stripclues = cfg[3].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 2) return "Width must be at least one";
+    if (params->h < 2) return "Height must be at least one";
+    if (params->diff < 0 || params->diff >= DIFFCOUNT)
+        return "Unknown difficulty level";
+
+    return NULL;
+}
+
+/* --------------------------------------------------------------- */
+/* Game state allocation, deallocation. */
+
+struct game_common {
+    int *dominoes;      /* size w*h, dominoes[i] points to other end of domino. */
+    int *rowcount;      /* size 3*h, array of [plus, minus, neutral] counts */
+    int *colcount;      /* size 3*w, ditto */
+    int refcount;
+};
+
+#define GS_ERROR        1
+#define GS_SET          2
+#define GS_NOTPOSITIVE  4
+#define GS_NOTNEGATIVE  8
+#define GS_NOTNEUTRAL  16
+#define GS_MARK        32
+
+#define GS_NOTMASK (GS_NOTPOSITIVE|GS_NOTNEGATIVE|GS_NOTNEUTRAL)
+
+#define NOTFLAG(w) ( (w) == NEUTRAL ? GS_NOTNEUTRAL : \
+                     (w) == POSITIVE ? GS_NOTPOSITIVE : \
+                     (w) == NEGATIVE ? GS_NOTNEGATIVE : \
+                     0 )
+
+#define POSSIBLE(f,w) (!(state->flags[(f)] & NOTFLAG(w)))
+
+struct game_state {
+    int w, h, wh;
+    int *grid;                  /* size w*h, for cell state (pos/neg) */
+    unsigned int *flags;        /* size w*h */
+    int solved, completed, numbered;
+    unsigned char *counts_done;
+
+    struct game_common *common; /* domino layout never changes. */
+};
+
+static void clear_state(game_state *ret)
+{
+    int i;
+
+    ret->solved = ret->completed = ret->numbered = 0;
+
+    memset(ret->common->rowcount, 0, ret->h*3*sizeof(int));
+    memset(ret->common->colcount, 0, ret->w*3*sizeof(int));
+    memset(ret->counts_done, 0, (ret->h + ret->w) * 2 * sizeof(unsigned char));
+
+    for (i = 0; i < ret->wh; i++) {
+        ret->grid[i] = EMPTY;
+        ret->flags[i] = 0;
+        ret->common->dominoes[i] = i;
+    }
+}
+
+static game_state *new_state(int w, int h)
+{
+    game_state *ret = snew(game_state);
+
+    memset(ret, 0, sizeof(game_state));
+    ret->w = w;
+    ret->h = h;
+    ret->wh = w*h;
+
+    ret->grid = snewn(ret->wh, int);
+    ret->flags = snewn(ret->wh, unsigned int);
+    ret->counts_done = snewn((ret->h + ret->w) * 2, unsigned char);
+
+    ret->common = snew(struct game_common);
+    ret->common->refcount = 1;
+
+    ret->common->dominoes = snewn(ret->wh, int);
+    ret->common->rowcount = snewn(ret->h*3, int);
+    ret->common->colcount = snewn(ret->w*3, int);
+
+    clear_state(ret);
+
+    return ret;
+}
+
+static game_state *dup_game(const game_state *src)
+{
+    game_state *dest = snew(game_state);
+
+    dest->w = src->w;
+    dest->h = src->h;
+    dest->wh = src->wh;
+
+    dest->solved = src->solved;
+    dest->completed = src->completed;
+    dest->numbered = src->numbered;
+
+    dest->common = src->common;
+    dest->common->refcount++;
+
+    dest->grid = snewn(dest->wh, int);
+    memcpy(dest->grid, src->grid, dest->wh*sizeof(int));
+
+    dest->counts_done = snewn((dest->h + dest->w) * 2, unsigned char);
+    memcpy(dest->counts_done, src->counts_done,
+           (dest->h + dest->w) * 2 * sizeof(unsigned char));
+
+    dest->flags = snewn(dest->wh, unsigned int);
+    memcpy(dest->flags, src->flags, dest->wh*sizeof(unsigned int));
+
+    return dest;
+}
+
+static void free_game(game_state *state)
+{
+    state->common->refcount--;
+    if (state->common->refcount == 0) {
+        sfree(state->common->dominoes);
+        sfree(state->common->rowcount);
+        sfree(state->common->colcount);
+        sfree(state->common);
+    }
+    sfree(state->counts_done);
+    sfree(state->flags);
+    sfree(state->grid);
+    sfree(state);
+}
+
+/* --------------------------------------------------------------- */
+/* Game generation and reading. */
+
+/* For a game of size w*h the game description is:
+ * w-sized string of column + numbers (L-R), or '.' for none
+ * semicolon
+ * h-sized string of row + numbers (T-B), or '.'
+ * semicolon
+ * w-sized string of column - numbers (L-R), or '.'
+ * semicolon
+ * h-sized string of row - numbers (T-B), or '.'
+ * semicolon
+ * w*h-sized string of 'L', 'R', 'U', 'D' for domino associations,
+ *   or '*' for a black singleton square.
+ *
+ * for a total length of 2w + 2h + wh + 4.
+ */
+
+static char n2c(int num) { /* XXX cloned from singles.c */
+    if (num == -1)
+        return '.';
+    if (num < 10)
+        return '0' + num;
+    else if (num < 10+26)
+        return 'a' + num - 10;
+    else
+        return 'A' + num - 10 - 26;
+    return '?';
+}
+
+static int c2n(char c) { /* XXX cloned from singles.c */
+    if (isdigit((unsigned char)c))
+        return (int)(c - '0');
+    else if (c >= 'a' && c <= 'z')
+        return (int)(c - 'a' + 10);
+    else if (c >= 'A' && c <= 'Z')
+        return (int)(c - 'A' + 10 + 26);
+    return -1;
+}
+
+static const char *readrow(const char *desc, int n, int *array, int off,
+                           const char **prob)
+{
+    int i, num;
+    char c;
+
+    for (i = 0; i < n; i++) {
+        c = *desc++;
+        if (c == 0) goto badchar;
+        if (c == '.')
+            num = -1;
+        else {
+            num = c2n(c);
+            if (num < 0) goto badchar;
+        }
+        array[i*3+off] = num;
+    }
+    c = *desc++;
+    if (c != ',') goto badchar;
+    return desc;
+
+badchar:
+    *prob = (c == 0) ?
+                "Game description too short" :
+                "Game description contained unexpected characters";
+    return NULL;
+}
+
+static game_state *new_game_int(const game_params *params, const char *desc,
+                                const char **prob)
+{
+    game_state *state = new_state(params->w, params->h);
+    int x, y, idx, *count;
+    char c;
+
+    *prob = NULL;
+
+    /* top row, left-to-right */
+    desc = readrow(desc, state->w, state->common->colcount, POSITIVE, prob);
+    if (*prob) goto done;
+
+    /* left column, top-to-bottom */
+    desc = readrow(desc, state->h, state->common->rowcount, POSITIVE, prob);
+    if (*prob) goto done;
+
+    /* bottom row, left-to-right */
+    desc = readrow(desc, state->w, state->common->colcount, NEGATIVE, prob);
+    if (*prob) goto done;
+
+    /* right column, top-to-bottom */
+    desc = readrow(desc, state->h, state->common->rowcount, NEGATIVE, prob);
+    if (*prob) goto done;
+
+    /* Add neutral counts (== size - pos - neg) to columns and rows.
+     * Any singleton cells will just be treated as permanently neutral. */
+    count = state->common->colcount;
+    for (x = 0; x < state->w; x++) {
+        if (count[x*3+POSITIVE] < 0 || count[x*3+NEGATIVE] < 0)
+            count[x*3+NEUTRAL] = -1;
+        else {
+            count[x*3+NEUTRAL] =
+                state->h - count[x*3+POSITIVE] - count[x*3+NEGATIVE];
+            if (count[x*3+NEUTRAL] < 0) {
+                *prob = "Column counts inconsistent";
+                goto done;
+            }
+        }
+    }
+    count = state->common->rowcount;
+    for (y = 0; y < state->h; y++) {
+        if (count[y*3+POSITIVE] < 0 || count[y*3+NEGATIVE] < 0)
+            count[y*3+NEUTRAL] = -1;
+        else {
+            count[y*3+NEUTRAL] =
+                state->w - count[y*3+POSITIVE] - count[y*3+NEGATIVE];
+            if (count[y*3+NEUTRAL] < 0) {
+                *prob = "Row counts inconsistent";
+                goto done;
+            }
+        }
+    }
+
+
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            idx = y*state->w + x;
+nextchar:
+            c = *desc++;
+
+            if (c == 'L') /* this square is LHS of a domino */
+                state->common->dominoes[idx] = idx+1;
+            else if (c == 'R') /* ... RHS of a domino */
+                state->common->dominoes[idx] = idx-1;
+            else if (c == 'T') /* ... top of a domino */
+                state->common->dominoes[idx] = idx+state->w;
+            else if (c == 'B') /* ... bottom of a domino */
+                state->common->dominoes[idx] = idx-state->w;
+            else if (c == '*') /* singleton */
+                state->common->dominoes[idx] = idx;
+            else if (c == ',') /* spacer, ignore */
+                goto nextchar;
+            else goto badchar;
+        }
+    }
+
+    /* Check dominoes as input are sensibly consistent
+     * (i.e. each end points to the other) */
+    for (idx = 0; idx < state->wh; idx++) {
+        if (state->common->dominoes[idx] < 0 ||
+            state->common->dominoes[idx] > state->wh ||
+            state->common->dominoes[state->common->dominoes[idx]] != idx) {
+            *prob = "Domino descriptions inconsistent";
+            goto done;
+        }
+        if (state->common->dominoes[idx] == idx) {
+            state->grid[idx] = NEUTRAL;
+            state->flags[idx] |= GS_SET;
+        }
+    }
+    /* Success. */
+    state->numbered = 1;
+    goto done;
+
+badchar:
+    *prob = (c == 0) ?
+                "Game description too short" :
+                "Game description contained unexpected characters";
+
+done:
+    if (*prob) {
+        free_game(state);
+        return NULL;
+    }
+    return state;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    const char *prob;
+    game_state *st = new_game_int(params, desc, &prob);
+    if (!st) return (char*)prob;
+    free_game(st);
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    const char *prob;
+    game_state *st = new_game_int(params, desc, &prob);
+    assert(st);
+    return st;
+}
+
+static char *generate_desc(game_state *new)
+{
+    int x, y, idx, other, w = new->w, h = new->h;
+    char *desc = snewn(new->wh + 2*(w + h) + 5, char), *p = desc;
+
+    for (x = 0; x < w; x++) *p++ = n2c(new->common->colcount[x*3+POSITIVE]);
+    *p++ = ',';
+    for (y = 0; y < h; y++) *p++ = n2c(new->common->rowcount[y*3+POSITIVE]);
+    *p++ = ',';
+
+    for (x = 0; x < w; x++) *p++ = n2c(new->common->colcount[x*3+NEGATIVE]);
+    *p++ = ',';
+    for (y = 0; y < h; y++) *p++ = n2c(new->common->rowcount[y*3+NEGATIVE]);
+    *p++ = ',';
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            idx = y*w + x;
+            other = new->common->dominoes[idx];
+
+            if (other == idx) *p++ = '*';
+            else if (other == idx+1) *p++ = 'L';
+            else if (other == idx-1) *p++ = 'R';
+            else if (other == idx+w) *p++ = 'T';
+            else if (other == idx-w) *p++ = 'B';
+            else assert(!"mad domino orientation");
+        }
+    }
+    *p = '\0';
+
+    return desc;
+}
+
+static void game_text_hborder(const game_state *state, char **p_r)
+{
+    char *p = *p_r;
+    int x;
+
+    *p++ = ' ';
+    *p++ = '+';
+    for (x = 0; x < state->w*2-1; x++) *p++ = '-';
+    *p++ = '+';
+    *p++ = '\n';
+
+    *p_r = p;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int len, x, y, i;
+    char *ret, *p;
+
+    len = ((state->w*2)+4) * ((state->h*2)+4) + 2;
+    p = ret = snewn(len, char);
+
+    /* top row: '+' then column totals for plus. */
+    *p++ = '+';
+    for (x = 0; x < state->w; x++) {
+        *p++ = ' ';
+        *p++ = n2c(state->common->colcount[x*3+POSITIVE]);
+    }
+    *p++ = '\n';
+
+    /* top border. */
+    game_text_hborder(state, &p);
+
+    for (y = 0; y < state->h; y++) {
+        *p++ = n2c(state->common->rowcount[y*3+POSITIVE]);
+        *p++ = '|';
+        for (x = 0; x < state->w; x++) {
+            i = y*state->w+x;
+            *p++ = state->common->dominoes[i] == i ? '#' :
+                state->grid[i] == POSITIVE ? '+' :
+                state->grid[i] == NEGATIVE ? '-' :
+                state->flags[i] & GS_SET ? '*' : ' ';
+            if (x < (state->w-1))
+                *p++ = state->common->dominoes[i] == i+1 ? ' ' : '|';
+        }
+        *p++ = '|';
+        *p++ = n2c(state->common->rowcount[y*3+NEGATIVE]);
+        *p++ = '\n';
+
+        if (y < (state->h-1)) {
+            *p++ = ' ';
+            *p++ = '|';
+            for (x = 0; x < state->w; x++) {
+                i = y*state->w+x;
+                *p++ = state->common->dominoes[i] == i+state->w ? ' ' : '-';
+                if (x < (state->w-1))
+                    *p++ = '+';
+            }
+            *p++ = '|';
+            *p++ = '\n';
+        }
+    }
+
+    /* bottom border. */
+    game_text_hborder(state, &p);
+
+    /* bottom row: column totals for minus then '-'. */
+    *p++ = ' ';
+    for (x = 0; x < state->w; x++) {
+        *p++ = ' ';
+        *p++ = n2c(state->common->colcount[x*3+NEGATIVE]);
+    }
+    *p++ = ' ';
+    *p++ = '-';
+    *p++ = '\n';
+    *p++ = '\0';
+
+    return ret;
+}
+
+static void game_debug(game_state *state, const char *desc)
+{
+    char *fmt = game_text_format(state);
+    debug(("%s:\n%s\n", desc, fmt));
+    sfree(fmt);
+}
+
+enum { ROW, COLUMN };
+
+typedef struct rowcol {
+    int i, di, n, roworcol, num;
+    int *targets;
+    const char *name;
+} rowcol;
+
+static rowcol mkrowcol(const game_state *state, int num, int roworcol)
+{
+    rowcol rc;
+
+    rc.roworcol = roworcol;
+    rc.num = num;
+
+    if (roworcol == ROW) {
+        rc.i = num * state->w;
+        rc.di = 1;
+        rc.n = state->w;
+        rc.targets = &(state->common->rowcount[num*3]);
+        rc.name = "row";
+    } else if (roworcol == COLUMN) {
+        rc.i = num;
+        rc.di = state->w;
+        rc.n = state->h;
+        rc.targets = &(state->common->colcount[num*3]);
+        rc.name = "column";
+    } else {
+        assert(!"unknown roworcol");
+    }
+    return rc;
+}
+
+static int count_rowcol(const game_state *state, int num, int roworcol,
+                        int which)
+{
+    int i, count = 0;
+    rowcol rc = mkrowcol(state, num, roworcol);
+
+    for (i = 0; i < rc.n; i++, rc.i += rc.di) {
+        if (which < 0) {
+            if (state->grid[rc.i] == EMPTY &&
+                !(state->flags[rc.i] & GS_SET))
+                count++;
+        } else if (state->grid[rc.i] == which)
+            count++;
+    }
+    return count;
+}
+
+static void check_rowcol(game_state *state, int num, int roworcol, int which,
+                        int *wrong, int *incomplete)
+{
+    int count, target = mkrowcol(state, num, roworcol).targets[which];
+
+    if (target == -1) return; /* no number to check against. */
+
+    count = count_rowcol(state, num, roworcol, which);
+    if (count < target) *incomplete = 1;
+    if (count > target) *wrong = 1;
+}
+
+static int check_completion(game_state *state)
+{
+    int i, j, x, y, idx, w = state->w, h = state->h;
+    int which = POSITIVE, wrong = 0, incomplete = 0;
+
+    /* Check row and column counts for magnets. */
+    for (which = POSITIVE, j = 0; j < 2; which = OPPOSITE(which), j++) {
+        for (i = 0; i < w; i++)
+            check_rowcol(state, i, COLUMN, which, &wrong, &incomplete);
+
+        for (i = 0; i < h; i++)
+            check_rowcol(state, i, ROW, which, &wrong, &incomplete);
+    }
+    /* Check each domino has been filled, and that we don't have
+     * touching identical terminals. */
+    for (i = 0; i < state->wh; i++) state->flags[i] &= ~GS_ERROR;
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            idx = y*w + x;
+            if (state->common->dominoes[idx] == idx)
+                continue; /* no domino here */
+
+            if (!(state->flags[idx] & GS_SET))
+                incomplete = 1;
+
+            which = state->grid[idx];
+            if (which != NEUTRAL) {
+#define CHECK(xx,yy) do { \
+    if (INGRID(state,xx,yy) && \
+        (state->grid[(yy)*w+(xx)] == which)) { \
+        wrong = 1; \
+        state->flags[(yy)*w+(xx)] |= GS_ERROR; \
+        state->flags[y*w+x] |= GS_ERROR; \
+    } \
+} while(0)
+                CHECK(x,y-1);
+                CHECK(x,y+1);
+                CHECK(x-1,y);
+                CHECK(x+1,y);
+#undef CHECK
+            }
+        }
+    }
+    return wrong ? -1 : incomplete ? 0 : 1;
+}
+
+static const int dx[4] = {-1, 1, 0, 0};
+static const int dy[4] = {0, 0, -1, 1};
+
+static void solve_clearflags(game_state *state)
+{
+    int i;
+
+    for (i = 0; i < state->wh; i++) {
+        state->flags[i] &= ~GS_NOTMASK;
+        if (state->common->dominoes[i] != i)
+            state->flags[i] &= ~GS_SET;
+    }
+}
+
+/* Knowing a given cell cannot be a certain colour also tells us
+ * something about the other cell in that domino. */
+static int solve_unflag(game_state *state, int i, int which,
+                        const char *why, rowcol *rc)
+{
+    int ii, ret = 0;
+#if defined DEBUGGING || defined STANDALONE_SOLVER
+    int w = state->w;
+#endif
+
+    assert(i >= 0 && i < state->wh);
+    ii = state->common->dominoes[i];
+    if (ii == i) return 0;
+
+    if (rc)
+        debug(("solve_unflag: (%d,%d) for %s %d", i%w, i/w, rc->name, rc->num));
+
+    if ((state->flags[i] & GS_SET) && (state->grid[i] == which)) {
+        debug(("solve_unflag: (%d,%d) already %s, cannot unflag (for %s).",
+               i%w, i/w, NAME(which), why));
+        return -1;
+    }
+    if ((state->flags[ii] & GS_SET) && (state->grid[ii] == OPPOSITE(which))) {
+        debug(("solve_unflag: (%d,%d) opposite already %s, cannot unflag (for %s).",
+               ii%w, ii/w, NAME(OPPOSITE(which)), why));
+        return -1;
+    }
+    if (POSSIBLE(i, which)) {
+        state->flags[i] |= NOTFLAG(which);
+        ret++;
+        debug(("solve_unflag: (%d,%d) CANNOT be %s (%s)",
+               i%w, i/w, NAME(which), why));
+    }
+    if (POSSIBLE(ii, OPPOSITE(which))) {
+        state->flags[ii] |= NOTFLAG(OPPOSITE(which));
+        ret++;
+        debug(("solve_unflag: (%d,%d) CANNOT be %s (%s, other half)",
+               ii%w, ii/w, NAME(OPPOSITE(which)), why));
+    }
+#ifdef STANDALONE_SOLVER
+    if (verbose && ret) {
+        printf("(%d,%d)", i%w, i/w);
+        if (rc) printf(" in %s %d", rc->name, rc->num);
+        printf(" cannot be %s (%s); opposite (%d,%d) not %s.\n",
+               NAME(which), why, ii%w, ii/w, NAME(OPPOSITE(which)));
+    }
+#endif
+    return ret;
+}
+
+static int solve_unflag_surrounds(game_state *state, int i, int which)
+{
+    int x = i%state->w, y = i/state->w, xx, yy, j, ii;
+
+    assert(INGRID(state, x, y));
+
+    for (j = 0; j < 4; j++) {
+        xx = x+dx[j]; yy = y+dy[j];
+        if (!INGRID(state, xx, yy)) continue;
+
+        ii = yy*state->w+xx;
+        if (solve_unflag(state, ii, which, "adjacent to set cell", NULL) < 0)
+            return -1;
+    }
+    return 0;
+}
+
+/* Sets a cell to a particular colour, and also perform other
+ * housekeeping around that. */
+static int solve_set(game_state *state, int i, int which,
+                     const char *why, rowcol *rc)
+{
+    int ii;
+#if defined DEBUGGING || defined STANDALONE_SOLVER
+    int w = state->w;
+#endif
+
+    ii = state->common->dominoes[i];
+
+    if (state->flags[i] & GS_SET) {
+        if (state->grid[i] == which) {
+            return 0; /* was already set and held, do nothing. */
+        } else {
+            debug(("solve_set: (%d,%d) is held and %s, cannot set to %s",
+                   i%w, i/w, NAME(state->grid[i]), NAME(which)));
+            return -1;
+        }
+    }
+    if ((state->flags[ii] & GS_SET) && state->grid[ii] != OPPOSITE(which)) {
+        debug(("solve_set: (%d,%d) opposite is held and %s, cannot set to %s",
+                ii%w, ii/w, NAME(state->grid[ii]), NAME(OPPOSITE(which))));
+        return -1;
+    }
+    if (!POSSIBLE(i, which)) {
+        debug(("solve_set: (%d,%d) NOT %s, cannot set.", i%w, i/w, NAME(which)));
+        return -1;
+    }
+    if (!POSSIBLE(ii, OPPOSITE(which))) {
+        debug(("solve_set: (%d,%d) NOT %s, cannot set (%d,%d).",
+               ii%w, ii/w, NAME(OPPOSITE(which)), i%w, i/w));
+        return -1;
+    }
+
+#ifdef STANDALONE_SOLVER
+    if (verbose) {
+        printf("(%d,%d)", i%w, i/w);
+        if (rc) printf(" in %s %d", rc->name, rc->num);
+        printf(" set to %s (%s), opposite (%d,%d) set to %s.\n",
+               NAME(which), why, ii%w, ii/w, NAME(OPPOSITE(which)));
+    }
+#endif
+    if (rc)
+        debug(("solve_set: (%d,%d) for %s %d", i%w, i/w, rc->name, rc->num));
+    debug(("solve_set: (%d,%d) setting to %s (%s), surrounds first:",
+           i%w, i/w, NAME(which), why));
+
+    if (which != NEUTRAL) {
+        if (solve_unflag_surrounds(state, i, which) < 0)
+            return -1;
+        if (solve_unflag_surrounds(state, ii, OPPOSITE(which)) < 0)
+            return -1;
+    }
+
+    state->grid[i] = which;
+    state->grid[ii] = OPPOSITE(which);
+
+    state->flags[i] |= GS_SET;
+    state->flags[ii] |= GS_SET;
+
+    debug(("solve_set: (%d,%d) set to %s (%s)", i%w, i/w, NAME(which), why));
+
+    return 1;
+}
+
+/* counts should be int[4]. */
+static void solve_counts(game_state *state, rowcol rc, int *counts, int *unset)
+{
+    int i, j, which;
+
+    assert(counts);
+    for (i = 0; i < 4; i++) {
+        counts[i] = 0;
+        if (unset) unset[i] = 0;
+    }
+
+    for (i = rc.i, j = 0; j < rc.n; i += rc.di, j++) {
+        if (state->flags[i] & GS_SET) {
+            assert(state->grid[i] < 3);
+            counts[state->grid[i]]++;
+        } else if (unset) {
+            for (which = 0; which <= 2; which++) {
+                if (POSSIBLE(i, which))
+                    unset[which]++;
+            }
+        }
+    }
+}
+
+static int solve_checkfull(game_state *state, rowcol rc, int *counts)
+{
+    int starti = rc.i, j, which, didsth = 0, target;
+    int unset[4];
+
+    assert(state->numbered); /* only useful (should only be called) if numbered. */
+
+    solve_counts(state, rc, counts, unset);
+
+    for (which = 0; which <= 2; which++) {
+        target = rc.targets[which];
+        if (target == -1) continue;
+
+        /*debug(("%s %d for %s: target %d, count %d, unset %d",
+               rc.name, rc.num, NAME(which),
+               target, counts[which], unset[which]));*/
+
+        if (target < counts[which]) {
+            debug(("%s %d has too many (%d) %s squares (target %d), impossible!",
+                   rc.name, rc.num, counts[which], NAME(which), target));
+            return -1;
+        }
+        if (target == counts[which]) {
+            /* We have the correct no. of the colour in this row/column
+             * already; unflag all the rest. */
+            for (rc.i = starti, j = 0; j < rc.n; rc.i += rc.di, j++) {
+                if (state->flags[rc.i] & GS_SET) continue;
+                if (!POSSIBLE(rc.i, which)) continue;
+
+                if (solve_unflag(state, rc.i, which, "row/col full", &rc) < 0)
+                    return -1;
+                didsth = 1;
+            }
+        } else if ((target - counts[which]) == unset[which]) {
+            /* We need all the remaining unset squares for this colour;
+             * set them all. */
+            for (rc.i = starti, j = 0; j < rc.n; rc.i += rc.di, j++) {
+                if (state->flags[rc.i] & GS_SET) continue;
+                if (!POSSIBLE(rc.i, which)) continue;
+
+                if (solve_set(state, rc.i, which, "row/col needs all unset", &rc) < 0)
+                    return -1;
+                didsth = 1;
+            }
+        }
+    }
+    return didsth;
+}
+
+static int solve_startflags(game_state *state)
+{
+    int x, y, i;
+
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            i = y*state->w+x;
+            if (state->common->dominoes[i] == i) continue;
+            if (state->grid[i] != NEUTRAL ||
+                state->flags[i] & GS_SET) {
+                if (solve_set(state, i, state->grid[i], "initial set-and-hold", NULL) < 0)
+                    return -1;
+            }
+        }
+    }
+    return 0;
+}
+
+typedef int (*rowcolfn)(game_state *state, rowcol rc, int *counts);
+
+static int solve_rowcols(game_state *state, rowcolfn fn)
+{
+    int x, y, didsth = 0, ret;
+    rowcol rc;
+    int counts[4];
+
+    for (x = 0; x < state->w; x++) {
+        rc = mkrowcol(state, x, COLUMN);
+        solve_counts(state, rc, counts, NULL);
+
+        ret = fn(state, rc, counts);
+        if (ret < 0) return ret;
+        didsth += ret;
+    }
+    for (y = 0; y < state->h; y++) {
+        rc = mkrowcol(state, y, ROW);
+        solve_counts(state, rc, counts, NULL);
+
+        ret = fn(state, rc, counts);
+        if (ret < 0) return ret;
+        didsth += ret;
+    }
+    return didsth;
+}
+
+static int solve_force(game_state *state)
+{
+    int i, which, didsth = 0;
+    unsigned long f;
+
+    for (i = 0; i < state->wh; i++) {
+        if (state->flags[i] & GS_SET) continue;
+        if (state->common->dominoes[i] == i) continue;
+
+        f = state->flags[i] & GS_NOTMASK;
+        which = -1;
+        if (f == (GS_NOTPOSITIVE|GS_NOTNEGATIVE))
+            which = NEUTRAL;
+        if (f == (GS_NOTPOSITIVE|GS_NOTNEUTRAL))
+            which = NEGATIVE;
+        if (f == (GS_NOTNEGATIVE|GS_NOTNEUTRAL))
+            which = POSITIVE;
+        if (which != -1) {
+            if (solve_set(state, i, which, "forced by flags", NULL) < 0)
+                return -1;
+            didsth = 1;
+        }
+    }
+    return didsth;
+}
+
+static int solve_neither(game_state *state)
+{
+    int i, j, didsth = 0;
+
+    for (i = 0; i < state->wh; i++) {
+        if (state->flags[i] & GS_SET) continue;
+        j = state->common->dominoes[i];
+        if (i == j) continue;
+
+        if (((state->flags[i] & GS_NOTPOSITIVE) &&
+             (state->flags[j] & GS_NOTPOSITIVE)) ||
+            ((state->flags[i] & GS_NOTNEGATIVE) &&
+             (state->flags[j] & GS_NOTNEGATIVE))) {
+            if (solve_set(state, i, NEUTRAL, "neither tile magnet", NULL) < 0)
+                return -1;
+            didsth = 1;
+        }
+    }
+    return didsth;
+}
+
+static int solve_advancedfull(game_state *state, rowcol rc, int *counts)
+{
+    int i, j, nfound = 0, clearpos = 0, clearneg = 0, ret = 0;
+
+    /* For this row/col, look for a domino entirely within the row where
+     * both ends can only be + or - (but isn't held).
+     * The +/- counts can thus be decremented by 1 each, and the 'unset'
+     * count by 2.
+     *
+     * Once that's done for all such dominoes (and they're marked), try
+     * and made usual deductions about rest of the row based on new totals. */
+
+    if (rc.targets[POSITIVE] == -1 && rc.targets[NEGATIVE] == -1)
+        return 0; /* don't have a target for either colour, nothing to do. */
+    if ((rc.targets[POSITIVE] >= 0 && counts[POSITIVE] == rc.targets[POSITIVE]) &&
+        (rc.targets[NEGATIVE] >= 0 && counts[NEGATIVE] == rc.targets[NEGATIVE]))
+        return 0; /* both colours are full up already, nothing to do. */
+
+    for (i = rc.i, j = 0; j < rc.n; i += rc.di, j++)
+        state->flags[i] &= ~GS_MARK;
+
+    for (i = rc.i, j = 0; j < rc.n; i += rc.di, j++) {
+        if (state->flags[i] & GS_SET) continue;
+
+        /* We're looking for a domino in our row/col, thus if
+         * dominoes[i] -> i+di we've found one. */
+        if (state->common->dominoes[i] != i+rc.di) continue;
+
+        /* We need both squares of this domino to be either + or -
+         * (i.e. both NOTNEUTRAL only). */
+        if (((state->flags[i] & GS_NOTMASK) != GS_NOTNEUTRAL) ||
+            ((state->flags[i+rc.di] & GS_NOTMASK) != GS_NOTNEUTRAL))
+            continue;
+
+        debug(("Domino in %s %d at (%d,%d) must be polarised.",
+               rc.name, rc.num, i%state->w, i/state->w));
+        state->flags[i] |= GS_MARK;
+        state->flags[i+rc.di] |= GS_MARK;
+        nfound++;
+    }
+    if (nfound == 0) return 0;
+
+    /* nfound is #dominoes we matched, which will all be marked. */
+    counts[POSITIVE] += nfound;
+    counts[NEGATIVE] += nfound;
+
+    if (rc.targets[POSITIVE] >= 0 && counts[POSITIVE] == rc.targets[POSITIVE]) {
+        debug(("%s %d has now filled POSITIVE:", rc.name, rc.num));
+        clearpos = 1;
+    }
+    if (rc.targets[NEGATIVE] >= 0 && counts[NEGATIVE] == rc.targets[NEGATIVE]) {
+        debug(("%s %d has now filled NEGATIVE:", rc.name, rc.num));
+        clearneg = 1;
+    }
+
+    if (!clearpos && !clearneg) return 0;
+
+    for (i = rc.i, j = 0; j < rc.n; i += rc.di, j++) {
+        if (state->flags[i] & GS_SET) continue;
+        if (state->flags[i] & GS_MARK) continue;
+
+        if (clearpos && !(state->flags[i] & GS_NOTPOSITIVE)) {
+            if (solve_unflag(state, i, POSITIVE, "row/col full (+ve) [tricky]", &rc) < 0)
+                return -1;
+            ret++;
+        }
+        if (clearneg && !(state->flags[i] & GS_NOTNEGATIVE)) {
+            if (solve_unflag(state, i, NEGATIVE, "row/col full (-ve) [tricky]", &rc) < 0)
+                return -1;
+            ret++;
+        }
+    }
+
+    return ret;
+}
+
+/* If we only have one neutral still to place on a row/column then no
+   dominoes entirely in that row/column can be neutral. */
+static int solve_nonneutral(game_state *state, rowcol rc, int *counts)
+{
+    int i, j, ret = 0;
+
+    if (rc.targets[NEUTRAL] != counts[NEUTRAL]+1)
+        return 0;
+
+    for (i = rc.i, j = 0; j < rc.n; i += rc.di, j++) {
+        if (state->flags[i] & GS_SET) continue;
+        if (state->common->dominoes[i] != i+rc.di) continue;
+
+        if (!(state->flags[i] & GS_NOTNEUTRAL)) {
+            if (solve_unflag(state, i, NEUTRAL, "single neutral in row/col [tricky]", &rc) < 0)
+                return -1;
+            ret++;
+        }
+    }
+    return ret;
+}
+
+/* If we need to fill all unfilled cells with +-, and we need 1 more of
+ * one than the other, and we have a single odd-numbered region of unfilled
+ * cells, that odd-numbered region must start and end with the extra number. */
+static int solve_oddlength(game_state *state, rowcol rc, int *counts)
+{
+    int i, j, ret = 0, extra, tpos, tneg;
+    int start = -1, length = 0, inempty = 0, startodd = -1;
+
+    /* need zero neutral cells still to find... */
+    if (rc.targets[NEUTRAL] != counts[NEUTRAL])
+        return 0;
+
+    /* ...and #positive and #negative to differ by one. */
+    tpos = rc.targets[POSITIVE] - counts[POSITIVE];
+    tneg = rc.targets[NEGATIVE] - counts[NEGATIVE];
+    if (tpos == tneg+1)
+        extra = POSITIVE;
+    else if (tneg == tpos+1)
+        extra = NEGATIVE;
+    else return 0;
+
+    for (i = rc.i, j = 0; j < rc.n; i += rc.di, j++) {
+        if (state->flags[i] & GS_SET) {
+            if (inempty) {
+                if (length % 2) {
+                    /* we've just finished an odd-length section. */
+                    if (startodd != -1) goto twoodd;
+                    startodd = start;
+                }
+                inempty = 0;
+            }
+        } else {
+            if (inempty)
+                length++;
+            else {
+                start = i;
+                length = 1;
+                inempty = 1;
+            }
+        }
+    }
+    if (inempty && (length % 2)) {
+        if (startodd != -1) goto twoodd;
+        startodd = start;
+    }
+    if (startodd != -1)
+        ret = solve_set(state, startodd, extra, "odd-length section start", &rc);
+
+    return ret;
+
+twoodd:
+    debug(("%s %d has >1 odd-length sections, starting at %d,%d and %d,%d.",
+           rc.name, rc.num,
+           startodd%state->w, startodd/state->w,
+           start%state->w, start/state->w));
+    return 0;
+}
+
+/* Count the number of remaining empty dominoes in any row/col.
+ * If that number is equal to the #remaining positive,
+ * or to the #remaining negative, no empty cells can be neutral. */
+static int solve_countdominoes_neutral(game_state *state, rowcol rc, int *counts)
+{
+    int i, j, ndom = 0, nonn = 0, ret = 0;
+
+    if ((rc.targets[POSITIVE] == -1) && (rc.targets[NEGATIVE] == -1))
+        return 0; /* need at least one target to compare. */
+
+    for (i = rc.i, j = 0; j < rc.n; i += rc.di, j++) {
+        if (state->flags[i] & GS_SET) continue;
+        assert(state->grid[i] == EMPTY);
+
+        /* Skip solo cells, or second cell in domino. */
+        if ((state->common->dominoes[i] == i) ||
+            (state->common->dominoes[i] == i-rc.di))
+            continue;
+
+        ndom++;
+    }
+
+    if ((rc.targets[POSITIVE] != -1) &&
+        (rc.targets[POSITIVE]-counts[POSITIVE] == ndom))
+        nonn = 1;
+    if ((rc.targets[NEGATIVE] != -1) &&
+        (rc.targets[NEGATIVE]-counts[NEGATIVE] == ndom))
+        nonn = 1;
+
+    if (!nonn) return 0;
+
+    for (i = rc.i, j = 0; j < rc.n; i += rc.di, j++) {
+        if (state->flags[i] & GS_SET) continue;
+
+        if (!(state->flags[i] & GS_NOTNEUTRAL)) {
+            if (solve_unflag(state, i, NEUTRAL, "all dominoes +/- [tricky]", &rc) < 0)
+                return -1;
+            ret++;
+        }
+    }
+    return ret;
+}
+
+static int solve_domino_count(game_state *state, rowcol rc, int i, int which)
+{
+    int nposs = 0;
+
+    /* Skip solo cells or 2nd in domino. */
+    if ((state->common->dominoes[i] == i) ||
+        (state->common->dominoes[i] == i-rc.di))
+        return 0;
+
+    if (state->flags[i] & GS_SET)
+        return 0;
+
+    if (POSSIBLE(i, which))
+        nposs++;
+
+    if (state->common->dominoes[i] == i+rc.di) {
+        /* second cell of domino is on our row: test that too. */
+        if (POSSIBLE(i+rc.di, which))
+            nposs++;
+    }
+    return nposs;
+}
+
+/* Count number of dominoes we could put each of + and - into. If it is equal
+ * to the #left, any domino we can only put + or - in one cell of must have it. */
+static int solve_countdominoes_nonneutral(game_state *state, rowcol rc, int *counts)
+{
+    int which, w, i, j, ndom = 0, didsth = 0, toset;
+
+    for (which = POSITIVE, w = 0; w < 2; which = OPPOSITE(which), w++) {
+        if (rc.targets[which] == -1) continue;
+
+        for (i = rc.i, j = 0; j < rc.n; i += rc.di, j++) {
+            if (solve_domino_count(state, rc, i, which) > 0)
+                ndom++;
+        }
+
+        if ((rc.targets[which] - counts[which]) != ndom)
+            continue;
+
+        for (i = rc.i, j = 0; j < rc.n; i += rc.di, j++) {
+            if (solve_domino_count(state, rc, i, which) == 1) {
+                if (POSSIBLE(i, which))
+                    toset = i;
+                else {
+                    /* paranoia, should have been checked by solve_domino_count. */
+                    assert(state->common->dominoes[i] == i+rc.di);
+                    assert(POSSIBLE(i+rc.di, which));
+                    toset = i+rc.di;
+                }
+                if (solve_set(state, toset, which, "all empty dominoes need +/- [tricky]", &rc) < 0)
+                    return -1;
+                didsth++;
+            }
+        }
+    }
+    return didsth;
+}
+
+/* danger, evil macro. can't use the do { ... } while(0) trick because
+ * the continue breaks. */
+#define SOLVE_FOR_ROWCOLS(fn) \
+    ret = solve_rowcols(state, fn); \
+    if (ret < 0) { debug(("%s said impossible, cannot solve", #fn)); return -1; } \
+    if (ret > 0) continue
+
+static int solve_state(game_state *state, int diff)
+{
+    int ret;
+
+    debug(("solve_state, difficulty %s", magnets_diffnames[diff]));
+
+    solve_clearflags(state);
+    if (solve_startflags(state) < 0) return -1;
+
+    while (1) {
+        ret = solve_force(state);
+        if (ret > 0) continue;
+        if (ret < 0) return -1;
+
+        ret = solve_neither(state);
+        if (ret > 0) continue;
+        if (ret < 0) return -1;
+
+        SOLVE_FOR_ROWCOLS(solve_checkfull);
+        SOLVE_FOR_ROWCOLS(solve_oddlength);
+
+        if (diff < DIFF_TRICKY) break;
+
+        SOLVE_FOR_ROWCOLS(solve_advancedfull);
+        SOLVE_FOR_ROWCOLS(solve_nonneutral);
+        SOLVE_FOR_ROWCOLS(solve_countdominoes_neutral);
+        SOLVE_FOR_ROWCOLS(solve_countdominoes_nonneutral);
+
+        /* more ... */
+
+        break;
+    }
+    return check_completion(state);
+}
+
+
+static char *game_state_diff(const game_state *src, const game_state *dst,
+                             int issolve)
+{
+    char *ret = NULL, buf[80], c;
+    int retlen = 0, x, y, i, k;
+
+    assert(src->w == dst->w && src->h == dst->h);
+
+    if (issolve) {
+        ret = sresize(ret, 3, char);
+        ret[0] = 'S'; ret[1] = ';'; ret[2] = '\0';
+        retlen += 2;
+    }
+    for (x = 0; x < dst->w; x++) {
+        for (y = 0; y < dst->h; y++) {
+            i = y*dst->w+x;
+
+            if (src->common->dominoes[i] == i) continue;
+
+#define APPEND do { \
+    ret = sresize(ret, retlen + k + 1, char); \
+    strcpy(ret + retlen, buf); \
+    retlen += k; \
+} while(0)
+
+            if ((src->grid[i] != dst->grid[i]) ||
+                ((src->flags[i] & GS_SET) != (dst->flags[i] & GS_SET))) {
+                if (dst->grid[i] == EMPTY && !(dst->flags[i] & GS_SET))
+                    c = ' ';
+                else
+                    c = GRID2CHAR(dst->grid[i]);
+                k = sprintf(buf, "%c%d,%d;", (int)c, x, y);
+                APPEND;
+            }
+        }
+    }
+    debug(("game_state_diff returns %s", ret));
+    return ret;
+}
+
+static void solve_from_aux(const game_state *state, const char *aux)
+{
+    int i;
+    assert(strlen(aux) == state->wh);
+    for (i = 0; i < state->wh; i++) {
+        state->grid[i] = CHAR2GRID(aux[i]);
+        state->flags[i] |= GS_SET;
+    }
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    game_state *solved = dup_game(currstate);
+    char *move = NULL;
+    int ret;
+
+    if (aux && strlen(aux) == state->wh) {
+        solve_from_aux(solved, aux);
+        goto solved;
+    }
+
+    if (solve_state(solved, DIFFCOUNT) > 0) goto solved;
+    free_game(solved);
+
+    solved = dup_game(state);
+    ret = solve_state(solved, DIFFCOUNT);
+    if (ret > 0) goto solved;
+    free_game(solved);
+
+    *error = (ret < 0) ? "Puzzle is impossible." : "Unable to solve puzzle.";
+    return NULL;
+
+solved:
+    move = game_state_diff(currstate, solved, 1);
+    free_game(solved);
+    return move;
+}
+
+static int solve_unnumbered(game_state *state)
+{
+    int i, ret;
+    while (1) {
+        ret = solve_force(state);
+        if (ret > 0) continue;
+        if (ret < 0) return -1;
+
+        ret = solve_neither(state);
+        if (ret > 0) continue;
+        if (ret < 0) return -1;
+
+        break;
+    }
+    for (i = 0; i < state->wh; i++) {
+        if (!(state->flags[i] & GS_SET)) return 0;
+    }
+    return 1;
+}
+
+static int lay_dominoes(game_state *state, random_state *rs, int *scratch)
+{
+    int n, i, ret = 0, nlaid = 0, n_initial_neutral;
+
+    for (i = 0; i < state->wh; i++) {
+        scratch[i] = i;
+        state->grid[i] = EMPTY;
+        state->flags[i] = (state->common->dominoes[i] == i) ? GS_SET : 0;
+    }
+    shuffle(scratch, state->wh, sizeof(int), rs);
+
+    n_initial_neutral = (state->wh > 100) ? 5 : (state->wh / 10);
+
+    for (n = 0; n < state->wh; n++) {
+        /* Find a space ... */
+
+        i = scratch[n];
+        if (state->flags[i] & GS_SET) continue; /* already laid here. */
+
+        /* ...and lay a domino if we can. */
+
+        debug(("Laying domino at i:%d, (%d,%d)\n", i, i%state->w, i/state->w));
+
+        /* The choice of which type of domino to lay here leads to subtle differences
+         * in the sorts of boards that get produced. Too much bias towards magnets
+         * leads to games that are too easy.
+         *
+         * Currently, it lays a small set of dominoes at random as neutral, and
+         * then lays the rest preferring to be magnets -- however, if the
+         * current layout is such that a magnet won't go there, then it lays
+         * another neutral.
+         *
+         * The number of initially neutral dominoes is limited as grids get bigger:
+         * too many neutral dominoes invariably ends up with insoluble puzzle at
+         * this size, and the positioning process means it'll always end up laying
+         * more than the initial 5 anyway.
+         */
+
+        /* We should always be able to lay a neutral anywhere. */
+        assert(!(state->flags[i] & GS_NOTNEUTRAL));
+
+        if (n < n_initial_neutral) {
+            debug(("  ...laying neutral\n"));
+            ret = solve_set(state, i, NEUTRAL, "layout initial neutral", NULL);
+        } else {
+            debug(("  ... preferring magnet\n"));
+            if (!(state->flags[i] & GS_NOTPOSITIVE))
+                ret = solve_set(state, i, POSITIVE, "layout", NULL);
+            else if (!(state->flags[i] & GS_NOTNEGATIVE))
+                ret = solve_set(state, i, NEGATIVE, "layout", NULL);
+            else
+                ret = solve_set(state, i, NEUTRAL, "layout", NULL);
+        }
+        if (!ret) {
+            debug(("Unable to lay anything at (%d,%d), giving up.",
+                   i%state->w, i/state->w));
+            ret = -1;
+            break;
+        }
+
+        nlaid++;
+        ret = solve_unnumbered(state);
+        if (ret == -1)
+            debug(("solve_unnumbered decided impossible.\n"));
+        if (ret != 0)
+            break;
+    }
+
+    debug(("Laid %d dominoes, total %d dominoes.\n", nlaid, state->wh/2));
+    game_debug(state, "Final layout");
+    return ret;
+}
+
+static void gen_game(game_state *new, random_state *rs)
+{
+    int ret, x, y, val;
+    int *scratch = snewn(new->wh, int);
+
+#ifdef STANDALONE_SOLVER
+    if (verbose) printf("Generating new game...\n");
+#endif
+
+    clear_state(new);
+    sfree(new->common->dominoes); /* bit grotty. */
+    new->common->dominoes = domino_layout(new->w, new->h, rs);
+
+    do {
+        ret = lay_dominoes(new, rs, scratch);
+    } while(ret == -1);
+
+    /* for each cell, update colcount/rowcount as appropriate. */
+    memset(new->common->colcount, 0, new->w*3*sizeof(int));
+    memset(new->common->rowcount, 0, new->h*3*sizeof(int));
+    for (x = 0; x < new->w; x++) {
+        for (y = 0; y < new->h; y++) {
+            val = new->grid[y*new->w+x];
+            new->common->colcount[x*3+val]++;
+            new->common->rowcount[y*3+val]++;
+        }
+    }
+    new->numbered = 1;
+
+    sfree(scratch);
+}
+
+static void generate_aux(game_state *new, char *aux)
+{
+    int i;
+    for (i = 0; i < new->wh; i++)
+        aux[i] = GRID2CHAR(new->grid[i]);
+    aux[new->wh] = '\0';
+}
+
+static int check_difficulty(const game_params *params, game_state *new,
+                            random_state *rs)
+{
+    int *scratch, *grid_correct, slen, i;
+
+    memset(new->grid, EMPTY, new->wh*sizeof(int));
+
+    if (params->diff > DIFF_EASY) {
+        /* If this is too easy, return. */
+        if (solve_state(new, params->diff-1) > 0) {
+            debug(("Puzzle is too easy."));
+            return -1;
+        }
+    }
+    if (solve_state(new, params->diff) <= 0) {
+        debug(("Puzzle is not soluble at requested difficulty."));
+        return -1;
+    }
+    if (!params->stripclues) return 0;
+
+    /* Copy the correct grid away. */
+    grid_correct = snewn(new->wh, int);
+    memcpy(grid_correct, new->grid, new->wh*sizeof(int));
+
+    /* Create shuffled array of side-clue locations. */
+    slen = new->w*2 + new->h*2;
+    scratch = snewn(slen, int);
+    for (i = 0; i < slen; i++) scratch[i] = i;
+    shuffle(scratch, slen, sizeof(int), rs);
+
+    /* For each clue, check whether removing it makes the puzzle unsoluble;
+     * put it back if so. */
+    for (i = 0; i < slen; i++) {
+        int num = scratch[i], which, roworcol, target, targetn, ret;
+        rowcol rc;
+
+        /* work out which clue we meant. */
+        if (num < new->w+new->h) { which = POSITIVE; }
+        else { which = NEGATIVE; num -= new->w+new->h; }
+
+        if (num < new->w) { roworcol = COLUMN; }
+        else { roworcol = ROW; num -= new->w; }
+
+        /* num is now the row/column index in question. */
+        rc = mkrowcol(new, num, roworcol);
+
+        /* Remove clue, storing original... */
+        target = rc.targets[which];
+        targetn = rc.targets[NEUTRAL];
+        rc.targets[which] = -1;
+        rc.targets[NEUTRAL] = -1;
+
+        /* ...and see if we can still solve it. */
+        game_debug(new, "removed clue, new board:");
+        memset(new->grid, EMPTY, new->wh * sizeof(int));
+        ret = solve_state(new, params->diff);
+        assert(ret != -1);
+
+        if (ret == 0 ||
+            memcmp(new->grid, grid_correct, new->wh*sizeof(int)) != 0) {
+            /* We made it ambiguous: put clue back. */
+            debug(("...now impossible/different, put clue back."));
+            rc.targets[which] = target;
+            rc.targets[NEUTRAL] = targetn;
+        }
+    }
+    sfree(scratch);
+    sfree(grid_correct);
+
+    return 0;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux_r, int interactive)
+{
+    game_state *new = new_state(params->w, params->h);
+    char *desc, *aux = snewn(new->wh+1, char);
+
+    do {
+        gen_game(new, rs);
+        generate_aux(new, aux);
+    } while (check_difficulty(params, new, rs) < 0);
+
+    /* now we're complete, generate the description string
+     * and an aux_info for the completed game. */
+    desc = generate_desc(new);
+
+    free_game(new);
+
+    *aux_r = aux;
+    return desc;
+}
+
+struct game_ui {
+    int cur_x, cur_y, cur_visible;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->cur_x = ui->cur_y = 0;
+    ui->cur_visible = 0;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    if (!oldstate->completed && newstate->completed)
+        ui->cur_visible = 0;
+}
+
+struct game_drawstate {
+    int tilesize, started, solved;
+    int w, h;
+    unsigned long *what;                /* size w*h */
+    unsigned long *colwhat, *rowwhat;   /* size 3*w, 3*h */
+};
+
+#define DS_WHICH_MASK 0xf
+
+#define DS_ERROR    0x10
+#define DS_CURSOR   0x20
+#define DS_SET      0x40
+#define DS_NOTPOS   0x80
+#define DS_NOTNEG   0x100
+#define DS_NOTNEU   0x200
+#define DS_FLASH    0x400
+
+#define PREFERRED_TILE_SIZE 32
+#define TILE_SIZE (ds->tilesize)
+#define BORDER    (TILE_SIZE / 8)
+
+#define COORD(x) ( (x+1) * TILE_SIZE + BORDER )
+#define FROMCOORD(x) ( (x - BORDER) / TILE_SIZE - 1 )
+
+static int is_clue(const game_state *state, int x, int y)
+{
+    int h = state->h, w = state->w;
+
+    if (((x == -1 || x == w) && y >= 0 && y < h) ||
+        ((y == -1 || y == h) && x >= 0 && x < w))
+        return TRUE;
+
+    return FALSE;
+}
+
+static int clue_index(const game_state *state, int x, int y)
+{
+    int h = state->h, w = state->w;
+
+    if (y == -1)
+        return x;
+    else if (x == w)
+        return w + y;
+    else if (y == h)
+        return 2 * w + h - x - 1;
+    else if (x == -1)
+        return 2 * (w + h) - y - 1;
+
+    return -1;
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int gx = FROMCOORD(x), gy = FROMCOORD(y), idx, curr;
+    char *nullret = NULL, buf[80], movech;
+    enum { CYCLE_MAGNET, CYCLE_NEUTRAL } action;
+
+    if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->w, state->h, 0);
+        ui->cur_visible = 1;
+        return "";
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+        action = (button == CURSOR_SELECT) ? CYCLE_MAGNET : CYCLE_NEUTRAL;
+        gx = ui->cur_x;
+        gy = ui->cur_y;
+    } else if (INGRID(state, gx, gy) &&
+               (button == LEFT_BUTTON || button == RIGHT_BUTTON)) {
+        if (ui->cur_visible) {
+            ui->cur_visible = 0;
+            nullret = "";
+        }
+        action = (button == LEFT_BUTTON) ? CYCLE_MAGNET : CYCLE_NEUTRAL;
+    } else if (button == LEFT_BUTTON && is_clue(state, gx, gy)) {
+        sprintf(buf, "D%d,%d", gx, gy);
+        return dupstr(buf);
+    } else
+        return NULL;
+
+    idx = gy * state->w + gx;
+    if (state->common->dominoes[idx] == idx) return nullret;
+    curr = state->grid[idx];
+
+    if (action == CYCLE_MAGNET) {
+        /* ... empty --> positive --> negative --> empty ... */
+
+        if (state->grid[idx] == NEUTRAL && state->flags[idx] & GS_SET)
+            return nullret; /* can't cycle a magnet from a neutral. */
+        movech = (curr == EMPTY) ? '+' : (curr == POSITIVE) ? '-' : ' ';
+    } else if (action == CYCLE_NEUTRAL) {
+        /* ... empty -> neutral -> !neutral --> empty ... */
+
+        if (state->grid[idx] != NEUTRAL)
+            return nullret; /* can't cycle through neutral from a magnet. */
+
+        /* All of these are grid == EMPTY == NEUTRAL; it twiddles
+         * combinations of flags. */
+        if (state->flags[idx] & GS_SET) /* neutral */
+            movech = '?';
+        else if (state->flags[idx] & GS_NOTNEUTRAL) /* !neutral */
+            movech = ' ';
+        else
+            movech = '.';
+    } else {
+        assert(!"unknown action");
+        movech = 0;                    /* placate optimiser */
+    }
+
+    sprintf(buf, "%c%d,%d", movech, gx, gy);
+
+    return dupstr(buf);
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    game_state *ret = dup_game(state);
+    int x, y, n, idx, idx2;
+    char c;
+
+    if (!*move) goto badmove;
+    while (*move) {
+        c = *move++;
+        if (c == 'S') {
+            ret->solved = TRUE;
+            n = 0;
+        } else if (c == '+' || c == '-' ||
+                   c == '.' || c == ' ' || c == '?') {
+            if ((sscanf(move, "%d,%d%n", &x, &y, &n) != 2) ||
+                !INGRID(state, x, y)) goto badmove;
+
+            idx = y*state->w + x;
+            idx2 = state->common->dominoes[idx];
+            if (idx == idx2) goto badmove;
+
+            ret->flags[idx] &= ~GS_NOTMASK;
+            ret->flags[idx2] &= ~GS_NOTMASK;
+
+            if (c == ' ' || c == '?') {
+                ret->grid[idx] = EMPTY;
+                ret->grid[idx2] = EMPTY;
+                ret->flags[idx] &= ~GS_SET;
+                ret->flags[idx2] &= ~GS_SET;
+                if (c == '?') {
+                    ret->flags[idx] |= GS_NOTNEUTRAL;
+                    ret->flags[idx2] |= GS_NOTNEUTRAL;
+                }
+            } else {
+                ret->grid[idx] = CHAR2GRID(c);
+                ret->grid[idx2] = OPPOSITE(CHAR2GRID(c));
+                ret->flags[idx] |= GS_SET;
+                ret->flags[idx2] |= GS_SET;
+            }
+        } else if (c == 'D' && sscanf(move, "%d,%d%n", &x, &y, &n) == 2 &&
+                   is_clue(ret, x, y)) {
+            ret->counts_done[clue_index(ret, x, y)] ^= 1;
+        } else
+            goto badmove;
+
+        move += n;
+        if (*move == ';') move++;
+        else if (*move) goto badmove;
+    }
+    if (check_completion(ret) == 1)
+        ret->completed = 1;
+
+    return ret;
+
+badmove:
+    free_game(ret);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = TILE_SIZE * (params->w+2) + 2 * BORDER;
+    *y = TILE_SIZE * (params->h+2) + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_TEXT * 3 + i] = 0.0F;
+        ret[COL_NEGATIVE * 3 + i] = 0.0F;
+        ret[COL_CURSOR * 3 + i] = 0.9F;
+        ret[COL_DONE * 3 + i] = ret[COL_BACKGROUND * 3 + i] / 1.5F;
+    }
+
+    ret[COL_POSITIVE * 3 + 0] = 0.8F;
+    ret[COL_POSITIVE * 3 + 1] = 0.0F;
+    ret[COL_POSITIVE * 3 + 2] = 0.0F;
+
+    ret[COL_NEUTRAL * 3 + 0] = 0.10F;
+    ret[COL_NEUTRAL * 3 + 1] = 0.60F;
+    ret[COL_NEUTRAL * 3 + 2] = 0.10F;
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_NOT * 3 + 0] = 0.2F;
+    ret[COL_NOT * 3 + 1] = 0.2F;
+    ret[COL_NOT * 3 + 2] = 1.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->tilesize = ds->started = ds->solved = 0;
+    ds->w = state->w;
+    ds->h = state->h;
+
+    ds->what = snewn(state->wh, unsigned long);
+    memset(ds->what, 0, state->wh*sizeof(unsigned long));
+
+    ds->colwhat = snewn(state->w*3, unsigned long);
+    memset(ds->colwhat, 0, state->w*3*sizeof(unsigned long));
+    ds->rowwhat = snewn(state->h*3, unsigned long);
+    memset(ds->rowwhat, 0, state->h*3*sizeof(unsigned long));
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->colwhat);
+    sfree(ds->rowwhat);
+    sfree(ds->what);
+    sfree(ds);
+}
+
+static void draw_num(drawing *dr, game_drawstate *ds, int rowcol, int which,
+                         int idx, int colbg, int col, int num)
+{
+    char buf[32];
+    int cx, cy, tsz;
+
+    if (num < 0) return;
+
+    sprintf(buf, "%d", num);
+    tsz = (strlen(buf) == 1) ? (7*TILE_SIZE/10) : (9*TILE_SIZE/10)/strlen(buf);
+
+    if (rowcol == ROW) {
+        cx = BORDER;
+        if (which == NEGATIVE) cx += TILE_SIZE * (ds->w+1);
+        cy = BORDER + TILE_SIZE * (idx+1);
+    } else {
+        cx = BORDER + TILE_SIZE * (idx+1);
+        cy = BORDER;
+        if (which == NEGATIVE) cy += TILE_SIZE * (ds->h+1);
+    }
+
+    draw_rect(dr, cx, cy, TILE_SIZE, TILE_SIZE, colbg);
+    draw_text(dr, cx + TILE_SIZE/2, cy + TILE_SIZE/2, FONT_VARIABLE, tsz,
+              ALIGN_VCENTRE | ALIGN_HCENTRE, col, buf);
+
+    draw_update(dr, cx, cy, TILE_SIZE, TILE_SIZE);
+}
+
+static void draw_sym(drawing *dr, game_drawstate *ds, int x, int y, int which, int col)
+{
+    int cx = COORD(x), cy = COORD(y);
+    int ccx = cx + TILE_SIZE/2, ccy = cy + TILE_SIZE/2;
+    int roff = TILE_SIZE/4, rsz = 2*roff+1;
+    int soff = TILE_SIZE/16, ssz = 2*soff+1;
+
+    if (which == POSITIVE || which == NEGATIVE) {
+        draw_rect(dr, ccx - roff, ccy - soff, rsz, ssz, col);
+        if (which == POSITIVE)
+            draw_rect(dr, ccx - soff, ccy - roff, ssz, rsz, col);
+    } else if (col == COL_NOT) {
+        /* not-a-neutral is a blue question mark. */
+        char qu[2] = { '?', 0 };
+        draw_text(dr, ccx, ccy, FONT_VARIABLE, 7*TILE_SIZE/10,
+                  ALIGN_VCENTRE | ALIGN_HCENTRE, col, qu);
+    } else {
+        draw_line(dr, ccx - roff, ccy - roff, ccx + roff, ccy + roff, col);
+        draw_line(dr, ccx + roff, ccy - roff, ccx - roff, ccy + roff, col);
+    }
+}
+
+enum {
+    TYPE_L,
+    TYPE_R,
+    TYPE_T,
+    TYPE_B,
+    TYPE_BLANK
+};
+
+/* NOT responsible for redrawing background or updating. */
+static void draw_tile_col(drawing *dr, game_drawstate *ds, int *dominoes,
+                          int x, int y, int which, int bg, int fg, int perc)
+{
+    int cx = COORD(x), cy = COORD(y), i, other, type = TYPE_BLANK;
+    int gutter, radius, coffset;
+
+    /* gutter is TSZ/16 for 100%, 8*TSZ/16 (TSZ/2) for 0% */
+    gutter = (TILE_SIZE / 16) + ((100 - perc) * (7*TILE_SIZE / 16))/100;
+    radius = (perc * (TILE_SIZE / 8)) / 100;
+    coffset = gutter + radius;
+
+    i = y*ds->w + x;
+    other = dominoes[i];
+
+    if (other == i) return;
+    else if (other == i+1) type = TYPE_L;
+    else if (other == i-1) type = TYPE_R;
+    else if (other == i+ds->w) type = TYPE_T;
+    else if (other == i-ds->w) type = TYPE_B;
+    else assert(!"mad domino orientation");
+
+    /* domino drawing shamelessly stolen from dominosa.c. */
+    if (type == TYPE_L || type == TYPE_T)
+        draw_circle(dr, cx+coffset, cy+coffset,
+                    radius, bg, bg);
+    if (type == TYPE_R || type == TYPE_T)
+        draw_circle(dr, cx+TILE_SIZE-1-coffset, cy+coffset,
+                    radius, bg, bg);
+    if (type == TYPE_L || type == TYPE_B)
+        draw_circle(dr, cx+coffset, cy+TILE_SIZE-1-coffset,
+                    radius, bg, bg);
+    if (type == TYPE_R || type == TYPE_B)
+        draw_circle(dr, cx+TILE_SIZE-1-coffset,
+                    cy+TILE_SIZE-1-coffset,
+                    radius, bg, bg);
+
+    for (i = 0; i < 2; i++) {
+        int x1, y1, x2, y2;
+
+        x1 = cx + (i ? gutter : coffset);
+        y1 = cy + (i ? coffset : gutter);
+        x2 = cx + TILE_SIZE-1 - (i ? gutter : coffset);
+        y2 = cy + TILE_SIZE-1 - (i ? coffset : gutter);
+        if (type == TYPE_L)
+            x2 = cx + TILE_SIZE;
+        else if (type == TYPE_R)
+            x1 = cx;
+        else if (type == TYPE_T)
+            y2 = cy + TILE_SIZE ;
+        else if (type == TYPE_B)
+            y1 = cy;
+
+        draw_rect(dr, x1, y1, x2-x1+1, y2-y1+1, bg);
+    }
+
+    if (fg != -1) draw_sym(dr, ds, x, y, which, fg);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds, int *dominoes,
+                      int x, int y, unsigned long flags)
+{
+    int cx = COORD(x), cy = COORD(y), bg, fg, perc = 100;
+    int which = flags & DS_WHICH_MASK;
+
+    flags &= ~DS_WHICH_MASK;
+
+    draw_rect(dr, cx, cy, TILE_SIZE, TILE_SIZE, COL_BACKGROUND);
+
+    if (flags & DS_CURSOR)
+        bg = COL_CURSOR;        /* off-white white for cursor */
+    else if (which == POSITIVE)
+        bg = COL_POSITIVE;
+    else if (which == NEGATIVE)
+        bg = COL_NEGATIVE;
+    else if (flags & DS_SET)
+        bg = COL_NEUTRAL;       /* green inner for neutral cells */
+    else
+        bg = COL_LOWLIGHT;      /* light grey for empty cells. */
+
+    if (which == EMPTY && !(flags & DS_SET)) {
+        int notwhich = -1;
+        fg = -1; /* don't draw cross unless actually set as neutral. */
+
+        if (flags & DS_NOTPOS) notwhich = POSITIVE;
+        if (flags & DS_NOTNEG) notwhich = NEGATIVE;
+        if (flags & DS_NOTNEU) notwhich = NEUTRAL;
+        if (notwhich != -1) {
+            which = notwhich;
+            fg = COL_NOT;
+        }
+    } else
+        fg = (flags & DS_ERROR) ? COL_ERROR :
+             (flags & DS_CURSOR) ? COL_TEXT : COL_BACKGROUND;
+
+    draw_rect(dr, cx, cy, TILE_SIZE, TILE_SIZE, COL_BACKGROUND);
+
+    if (flags & DS_FLASH) {
+        int bordercol = COL_HIGHLIGHT;
+        draw_tile_col(dr, ds, dominoes, x, y, which, bordercol, -1, perc);
+        perc = 3*perc/4;
+    }
+    draw_tile_col(dr, ds, dominoes, x, y, which, bg, fg, perc);
+
+    draw_update(dr, cx, cy, TILE_SIZE, TILE_SIZE);
+}
+
+static int get_count_color(const game_state *state, int rowcol, int which,
+                           int index, int target)
+{
+    int idx;
+    int count = count_rowcol(state, index, rowcol, which);
+
+    if ((count > target) ||
+        (count < target && !count_rowcol(state, index, rowcol, -1))) {
+        return COL_ERROR;
+    } else if (rowcol == COLUMN) {
+        idx = clue_index(state, index, which == POSITIVE ? -1 : state->h);
+    } else {
+        idx = clue_index(state, which == POSITIVE ? -1 : state->w, index);
+    }
+
+    if (state->counts_done[idx]) {
+        return COL_DONE;
+    }
+
+    return COL_TEXT;
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int x, y, w = state->w, h = state->h, which, i, j, flash;
+
+    flash = (int)(flashtime * 5 / FLASH_TIME) % 2;
+
+    if (!ds->started) {
+        /* draw background, corner +-. */
+        draw_rect(dr, 0, 0,
+                  TILE_SIZE * (w+2) + 2 * BORDER,
+                  TILE_SIZE * (h+2) + 2 * BORDER,
+                  COL_BACKGROUND);
+
+        draw_sym(dr, ds, -1, -1, POSITIVE, COL_TEXT);
+        draw_sym(dr, ds, state->w, state->h, NEGATIVE, COL_TEXT);
+
+        draw_update(dr, 0, 0,
+                    TILE_SIZE * (ds->w+2) + 2 * BORDER,
+                    TILE_SIZE * (ds->h+2) + 2 * BORDER);
+    }
+
+    /* Draw grid */
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            int idx = y*w+x;
+            unsigned long c = state->grid[idx];
+
+            if (state->flags[idx] & GS_ERROR)
+                c |= DS_ERROR;
+            if (state->flags[idx] & GS_SET)
+                c |= DS_SET;
+
+            if (x == ui->cur_x && y == ui->cur_y && ui->cur_visible)
+                c |= DS_CURSOR;
+
+            if (flash)
+                c |= DS_FLASH;
+
+            if (state->flags[idx] & GS_NOTPOSITIVE)
+                c |= DS_NOTPOS;
+            if (state->flags[idx] & GS_NOTNEGATIVE)
+                c |= DS_NOTNEG;
+            if (state->flags[idx] & GS_NOTNEUTRAL)
+                c |= DS_NOTNEU;
+
+            if (ds->what[idx] != c || !ds->started) {
+                draw_tile(dr, ds, state->common->dominoes, x, y, c);
+                ds->what[idx] = c;
+            }
+        }
+    }
+    /* Draw counts around side */
+    for (which = POSITIVE, j = 0; j < 2; which = OPPOSITE(which), j++) {
+        for (i = 0; i < w; i++) {
+            int index = i * 3 + which;
+            int target = state->common->colcount[index];
+            int color = get_count_color(state, COLUMN, which, i, target);
+
+            if (color != ds->colwhat[index] || !ds->started) {
+                draw_num(dr, ds, COLUMN, which, i, COL_BACKGROUND, color, target);
+                ds->colwhat[index] = color;
+            }
+        }
+        for (i = 0; i < h; i++) {
+            int index = i * 3 + which;
+            int target = state->common->rowcount[index];
+            int color = get_count_color(state, ROW, which, i, target);
+
+            if (color != ds->rowwhat[index] || !ds->started) {
+                draw_num(dr, ds, ROW, which, i, COL_BACKGROUND, color, target);
+                ds->rowwhat[index] = color;
+            }
+        }
+    }
+
+    ds->started = 1;
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->solved && !newstate->solved)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 6mm squares by default.
+     */
+    game_compute_size(params, 600, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->w, h = state->h;
+    int ink = print_mono_colour(dr, 0);
+    int paper = print_mono_colour(dr, 1);
+    int x, y, which, i, j;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+    ds->w = w; ds->h = h;
+
+    /* Border. */
+    print_line_width(dr, TILE_SIZE/12);
+
+    /* Numbers and +/- for corners. */
+    draw_sym(dr, ds, -1, -1, POSITIVE, ink);
+    draw_sym(dr, ds, state->w, state->h, NEGATIVE, ink);
+    for (which = POSITIVE, j = 0; j < 2; which = OPPOSITE(which), j++) {
+        for (i = 0; i < w; i++) {
+            draw_num(dr, ds, COLUMN, which, i, paper, ink,
+                         state->common->colcount[i*3+which]);
+        }
+        for (i = 0; i < h; i++) {
+            draw_num(dr, ds, ROW, which, i, paper, ink,
+                         state->common->rowcount[i*3+which]);
+        }
+    }
+
+    /* Dominoes. */
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            i = y*state->w + x;
+            if (state->common->dominoes[i] == i+1 ||
+                state->common->dominoes[i] == i+w) {
+                int dx = state->common->dominoes[i] == i+1 ? 2 : 1;
+                int dy = 3 - dx;
+                int xx, yy;
+                int cx = COORD(x), cy = COORD(y);
+
+                print_line_width(dr, 0);
+
+                /* Ink the domino */
+                for (yy = 0; yy < 2; yy++)
+                    for (xx = 0; xx < 2; xx++)
+                        draw_circle(dr,
+                                    cx+xx*dx*TILE_SIZE+(1-2*xx)*3*TILE_SIZE/16,
+                                    cy+yy*dy*TILE_SIZE+(1-2*yy)*3*TILE_SIZE/16,
+                                    TILE_SIZE/8, ink, ink);
+                draw_rect(dr, cx + TILE_SIZE/16, cy + 3*TILE_SIZE/16,
+                          dx*TILE_SIZE - 2*(TILE_SIZE/16),
+                          dy*TILE_SIZE - 6*(TILE_SIZE/16), ink);
+                draw_rect(dr, cx + 3*TILE_SIZE/16, cy + TILE_SIZE/16,
+                          dx*TILE_SIZE - 6*(TILE_SIZE/16),
+                          dy*TILE_SIZE - 2*(TILE_SIZE/16), ink);
+
+                /* Un-ink the domino interior */
+                for (yy = 0; yy < 2; yy++)
+                    for (xx = 0; xx < 2; xx++)
+                        draw_circle(dr,
+                                    cx+xx*dx*TILE_SIZE+(1-2*xx)*3*TILE_SIZE/16,
+                                    cy+yy*dy*TILE_SIZE+(1-2*yy)*3*TILE_SIZE/16,
+                                    3*TILE_SIZE/32, paper, paper);
+                draw_rect(dr, cx + 3*TILE_SIZE/32, cy + 3*TILE_SIZE/16,
+                          dx*TILE_SIZE - 2*(3*TILE_SIZE/32),
+                          dy*TILE_SIZE - 6*(TILE_SIZE/16), paper);
+                draw_rect(dr, cx + 3*TILE_SIZE/16, cy + 3*TILE_SIZE/32,
+                          dx*TILE_SIZE - 6*(TILE_SIZE/16),
+                          dy*TILE_SIZE - 2*(3*TILE_SIZE/32), paper);
+            }
+        }
+    }
+
+    /* Grid symbols (solution). */
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            i = y*state->w + x;
+            if ((state->grid[i] != NEUTRAL) || (state->flags[i] & GS_SET))
+                draw_sym(dr, ds, x, y, state->grid[i], ink);
+        }
+    }
+}
+
+#ifdef COMBINED
+#define thegame magnets
+#endif
+
+const struct game thegame = {
+    "Magnets", "games.magnets", "magnets",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON,                   /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+#include <time.h>
+#include <stdarg.h>
+
+const char *quis = NULL;
+int csv = 0;
+
+void usage(FILE *out) {
+    fprintf(out, "usage: %s [-v] [--print] <params>|<game id>\n", quis);
+}
+
+void doprint(game_state *state)
+{
+    char *fmt = game_text_format(state);
+    printf("%s", fmt);
+    sfree(fmt);
+}
+
+static void pnum(int n, int ntot, const char *desc)
+{
+    printf("%2.1f%% (%d) %s", (double)n*100.0 / (double)ntot, n, desc);
+}
+
+static void start_soak(game_params *p, random_state *rs)
+{
+    time_t tt_start, tt_now, tt_last;
+    char *aux;
+    game_state *s, *s2;
+    int n = 0, nsolved = 0, nimpossible = 0, ntricky = 0, ret, i;
+    long nn, nn_total = 0, nn_solved = 0, nn_tricky = 0;
+
+    tt_start = tt_now = time(NULL);
+
+    if (csv)
+        printf("time, w, h,  #generated, #solved, #tricky, #impossible,  "
+               "#neutral, #neutral/solved, #neutral/tricky\n");
+    else
+        printf("Soak-testing a %dx%d grid.\n", p->w, p->h);
+
+    s = new_state(p->w, p->h);
+    aux = snewn(s->wh+1, char);
+
+    while (1) {
+        gen_game(s, rs);
+
+        nn = 0;
+        for (i = 0; i < s->wh; i++) {
+            if (s->grid[i] == NEUTRAL) nn++;
+        }
+
+        generate_aux(s, aux);
+        memset(s->grid, EMPTY, s->wh * sizeof(int));
+        s2 = dup_game(s);
+
+        ret = solve_state(s, DIFFCOUNT);
+
+        n++;
+        nn_total += nn;
+        if (ret > 0) {
+            nsolved++;
+            nn_solved += nn;
+            if (solve_state(s2, DIFF_EASY) <= 0) {
+                ntricky++;
+                nn_tricky += nn;
+            }
+        } else if (ret < 0) {
+            char *desc = generate_desc(s);
+            solve_from_aux(s, aux);
+            printf("Game considered impossible:\n  %dx%d:%s\n",
+                    p->w, p->h, desc);
+            sfree(desc);
+            doprint(s);
+            nimpossible++;
+        }
+
+        free_game(s2);
+
+        tt_last = time(NULL);
+        if (tt_last > tt_now) {
+            tt_now = tt_last;
+            if (csv) {
+                printf("%d,%d,%d, %d,%d,%d,%d, %ld,%ld,%ld\n",
+                       (int)(tt_now - tt_start), p->w, p->h,
+                       n, nsolved, ntricky, nimpossible,
+                       nn_total, nn_solved, nn_tricky);
+            } else {
+                printf("%d total, %3.1f/s, ",
+                       n, (double)n / ((double)tt_now - tt_start));
+                pnum(nsolved, n, "solved"); printf(", ");
+                pnum(ntricky, n, "tricky");
+                if (nimpossible > 0)
+                    pnum(nimpossible, n, "impossible");
+                printf("\n");
+
+                printf("  overall %3.1f%% neutral (%3.1f%% for solved, %3.1f%% for tricky)\n",
+                       (double)(nn_total * 100) / (double)(p->w * p->h * n),
+                       (double)(nn_solved * 100) / (double)(p->w * p->h * nsolved),
+                       (double)(nn_tricky * 100) / (double)(p->w * p->h * ntricky));
+            }
+        }
+    }
+    free_game(s);
+    sfree(aux);
+}
+
+int main(int argc, const char *argv[])
+{
+    int print = 0, soak = 0, solved = 0, ret;
+    char *id = NULL, *desc, *desc_gen = NULL, *err, *aux = NULL;
+    game_state *s = NULL;
+    game_params *p = NULL;
+    random_state *rs = NULL;
+    time_t seed = time(NULL);
+
+    setvbuf(stdout, NULL, _IONBF, 0);
+
+    quis = argv[0];
+    while (--argc > 0) {
+        char *p = (char*)(*++argv);
+        if (!strcmp(p, "-v") || !strcmp(p, "--verbose")) {
+            verbose = 1;
+        } else if (!strcmp(p, "--csv")) {
+            csv = 1;
+        } else if (!strcmp(p, "-e") || !strcmp(p, "--seed")) {
+            seed = atoi(*++argv);
+            argc--;
+        } else if (!strcmp(p, "-p") || !strcmp(p, "--print")) {
+            print = 1;
+        } else if (!strcmp(p, "-s") || !strcmp(p, "--soak")) {
+            soak = 1;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            usage(stderr);
+            exit(1);
+        } else {
+            id = p;
+        }
+    }
+
+    rs = random_new((void*)&seed, sizeof(time_t));
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-v] [--soak] <params> | <game_id>\n", argv[0]);
+        goto done;
+    }
+    desc = strchr(id, ':');
+    if (desc) *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_params(p, 1);
+    if (err) {
+        fprintf(stderr, "%s: %s", argv[0], err);
+        goto done;
+    }
+
+    if (soak) {
+        if (desc) {
+            fprintf(stderr, "%s: --soak needs parameters, not description.\n", quis);
+            goto done;
+        }
+        start_soak(p, rs);
+        goto done;
+    }
+
+    if (!desc)
+        desc = desc_gen = new_game_desc(p, rs, &aux, 0);
+
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\nDescription: %s\n", quis, err, desc);
+        goto done;
+    }
+    s = new_game(NULL, p, desc);
+    printf("%s:%s (seed %ld)\n", id, desc, (long)seed);
+    if (aux) {
+        /* We just generated this ourself. */
+        if (verbose || print) {
+            doprint(s);
+            solve_from_aux(s, aux);
+            solved = 1;
+        }
+    } else {
+        doprint(s);
+        verbose = 1;
+        ret = solve_state(s, DIFFCOUNT);
+        if (ret < 0) printf("Puzzle is impossible.\n");
+        else if (ret == 0) printf("Puzzle is ambiguous.\n");
+        else printf("Puzzle was solved.\n");
+        verbose = 0;
+        solved = 1;
+    }
+    if (solved) doprint(s);
+
+done:
+    if (desc_gen) sfree(desc_gen);
+    if (p) free_params(p);
+    if (s) free_game(s);
+    if (rs) random_free(rs);
+    if (aux) sfree(aux);
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/makedist.sh b/apps/plugins/puzzles/makedist.sh
new file mode 100755
index 0000000000..22b4f5d0ae
--- /dev/null
+++ b/apps/plugins/puzzles/makedist.sh
@@ -0,0 +1,47 @@
+#!/bin/sh 
+
+# Build a Unix source distribution from the Puzzles SVN area.
+#
+# Pass a version number argument to have the archive tagged with that
+# version number. Otherwise, the script will not version-tag the
+# archive at all.
+
+version="$1"
+
+if test "x$version" != "x"; then
+  arcsuffix="-$version"
+  ver="-DVER=$version"
+else
+  arcsuffix=
+  ver=
+fi
+
+perl mkfiles.pl
+./mkauto.sh
+
+mkdir tmp.$$
+mkdir tmp.$$/puzzles$arcsuffix
+mkdir tmp.$$/puzzles$arcsuffix/icons
+
+# Build Windows Help and text versions of the manual for convenience.
+halibut --winhelp=puzzles.hlp --text=puzzles.txt puzzles.but
+
+# Build a text version of the HACKING document.
+halibut --text=HACKING devel.but
+
+for i in *.c *.m *.h *.R *.rc *.but *.plist *.icns LICENCE README Recipe \
+  *.rc2 mkfiles.pl Makefile Makefile.* \
+  HACKING puzzles.txt puzzles.hlp puzzles.cnt puzzles.chm \
+  icons/Makefile icons/*.sav icons/*.pl icons/*.sh icons/win16pal.xpm \
+  icons/*.png icons/*.ico icons/*.rc icons/*.c \
+  configure.ac mkauto.sh aclocal.m4 \
+  configure depcomp install-sh missing compile; do
+  case $i in
+    */*) ln -s ../../../$i tmp.$$/puzzles$arcsuffix/$i;;
+    *)   ln -s ../../$i tmp.$$/puzzles$arcsuffix/$i;;
+  esac
+done
+
+tar -C tmp.$$ -chzf - puzzles$arcsuffix > ../puzzles$arcsuffix.tar.gz
+
+rm -rf tmp.$$
diff --git a/apps/plugins/puzzles/malloc.c b/apps/plugins/puzzles/malloc.c
new file mode 100644
index 0000000000..d9943c6b40
--- /dev/null
+++ b/apps/plugins/puzzles/malloc.c
@@ -0,0 +1,61 @@
+/*
+ * malloc.c: safe wrappers around malloc, realloc, free, strdup
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include "puzzles.h"
+
+/*
+ * smalloc should guarantee to return a useful pointer - Halibut
+ * can do nothing except die when it's out of memory anyway.
+ */
+
+int allocs = 0;
+int frees = 0;
+
+void *smalloc(size_t size) {
+    void *p;
+    p = malloc(size);
+    LOGF("allocs: %d", ++allocs);
+    if (!p)
+        fatal("out of memory");
+    return p;
+}
+
+/*
+ * sfree should guaranteeably deal gracefully with freeing NULL
+ */
+void sfree(void *p) {
+    if (p) {
+        ++frees;
+        LOGF("frees: %d, total outstanding: %d", frees, allocs - frees);
+        free(p);
+    }
+}
+
+/*
+ * srealloc should guaranteeably be able to realloc NULL
+ */
+void *srealloc(void *p, size_t size) {
+    void *q;
+    if (p) {
+        q = realloc(p, size);
+    } else {
+        LOGF("allocs: %d", ++allocs);
+        q = malloc(size);
+    }
+    if (!q)
+        fatal("out of memory");
+    return q;
+}
+
+/*
+ * dupstr is like strdup, but with the never-return-NULL property
+ * of smalloc (and also reliably defined in all environments :-)
+ */
+char *dupstr(const char *s) {
+    char *r = smalloc(1+strlen(s));
+    strcpy(r,s);
+    return r;
+}
diff --git a/apps/plugins/puzzles/map.R b/apps/plugins/puzzles/map.R
new file mode 100644
index 0000000000..1e702aa19d
--- /dev/null
+++ b/apps/plugins/puzzles/map.R
@@ -0,0 +1,24 @@
+# -*- makefile -*-
+
+MAP_EXTRA = dsf
+
+map      : [X] GTK COMMON map MAP_EXTRA map-icon|no-icon
+
+map      : [G] WINDOWS COMMON map MAP_EXTRA map.res|noicon.res
+
+mapsolver :     [U] map[STANDALONE_SOLVER] MAP_EXTRA STANDALONE m.lib
+mapsolver :     [C] map[STANDALONE_SOLVER] MAP_EXTRA STANDALONE
+
+ALL += map[COMBINED] MAP_EXTRA
+
+!begin am gtk
+GAMES += map
+!end
+
+!begin >list.c
+    A(map) \
+!end
+
+!begin >gamedesc.txt
+map:map.exe:Map:Map-colouring puzzle:Colour the map so that adjacent regions are never the same colour.
+!end
diff --git a/apps/plugins/puzzles/map.c b/apps/plugins/puzzles/map.c
new file mode 100644
index 0000000000..6e9c12523a
--- /dev/null
+++ b/apps/plugins/puzzles/map.c
@@ -0,0 +1,3340 @@
+/*
+ * map.c: Game involving four-colouring a map.
+ */
+
+/*
+ * TODO:
+ * 
+ *  - clue marking
+ *  - better four-colouring algorithm?
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+/*
+ * In standalone solver mode, `verbose' is a variable which can be
+ * set by command-line option; in debugging mode it's simply always
+ * true.
+ */
+#if defined STANDALONE_SOLVER
+#define SOLVER_DIAGNOSTICS
+int verbose = FALSE;
+#elif defined SOLVER_DIAGNOSTICS
+#define verbose TRUE
+#endif
+
+/*
+ * I don't seriously anticipate wanting to change the number of
+ * colours used in this game, but it doesn't cost much to use a
+ * #define just in case :-)
+ */
+#define FOUR 4
+#define THREE (FOUR-1)
+#define FIVE (FOUR+1)
+#define SIX (FOUR+2)
+
+/*
+ * Ghastly run-time configuration option, just for Gareth (again).
+ */
+static int flash_type = -1;
+static float flash_length;
+
+/*
+ * Difficulty levels. I do some macro ickery here to ensure that my
+ * enum and the various forms of my name list always match up.
+ */
+#define DIFFLIST(A) \
+    A(EASY,Easy,e) \
+    A(NORMAL,Normal,n) \
+    A(HARD,Hard,h) \
+    A(RECURSE,Unreasonable,u)
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const map_diffnames[] = { DIFFLIST(TITLE) };
+static char const map_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+enum { TE, BE, LE, RE };               /* top/bottom/left/right edges */
+
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_0, COL_1, COL_2, COL_3,
+    COL_ERROR, COL_ERRTEXT,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h, n, diff;
+};
+
+struct map {
+    int refcount;
+    int *map;
+    int *graph;
+    int n;
+    int ngraph;
+    int *immutable;
+    int *edgex, *edgey;                /* position of a point on each edge */
+    int *regionx, *regiony;            /* position of a point in each region */
+};
+
+struct game_state {
+    game_params p;
+    struct map *map;
+    int *colouring, *pencil;
+    int completed, cheated;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+#ifdef PORTRAIT_SCREEN
+    ret->w = 16;
+    ret->h = 18;
+#else
+    ret->w = 20;
+    ret->h = 15;
+#endif
+    ret->n = 30;
+    ret->diff = DIFF_NORMAL;
+
+    return ret;
+}
+
+static const struct game_params map_presets[] = {
+#ifdef PORTRAIT_SCREEN
+    {16, 18, 30, DIFF_EASY},
+    {16, 18, 30, DIFF_NORMAL},
+    {16, 18, 30, DIFF_HARD},
+    {16, 18, 30, DIFF_RECURSE},
+    {25, 30, 75, DIFF_NORMAL},
+    {25, 30, 75, DIFF_HARD},
+#else
+    {20, 15, 30, DIFF_EASY},
+    {20, 15, 30, DIFF_NORMAL},
+    {20, 15, 30, DIFF_HARD},
+    {20, 15, 30, DIFF_RECURSE},
+    {30, 25, 75, DIFF_NORMAL},
+    {30, 25, 75, DIFF_HARD},
+#endif
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(map_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = map_presets[i];
+
+    sprintf(str, "%dx%d, %d regions, %s", ret->w, ret->h, ret->n,
+            map_diffnames[ret->diff]);
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    char const *p = string;
+
+    params->w = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+    if (*p == 'x') {
+        p++;
+        params->h = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+    } else {
+        params->h = params->w;
+    }
+    if (*p == 'n') {
+        p++;
+        params->n = atoi(p);
+        while (*p && (*p == '.' || isdigit((unsigned char)*p))) p++;
+    } else {
+        params->n = params->w * params->h / 8;
+    }
+    if (*p == 'd') {
+        int i;
+        p++;
+        for (i = 0; i < DIFFCOUNT; i++)
+            if (*p == map_diffchars[i])
+                params->diff = i;
+        if (*p) p++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char ret[400];
+
+    sprintf(ret, "%dx%dn%d", params->w, params->h, params->n);
+    if (full)
+        sprintf(ret + strlen(ret), "d%c", map_diffchars[params->diff]);
+
+    return dupstr(ret);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(5, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Regions";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->n);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = "Difficulty";
+    ret[3].type = C_CHOICES;
+    ret[3].sval = DIFFCONFIG;
+    ret[3].ival = params->diff;
+
+    ret[4].name = NULL;
+    ret[4].type = C_END;
+    ret[4].sval = NULL;
+    ret[4].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->n = atoi(cfg[2].sval);
+    ret->diff = cfg[3].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 2 || params->h < 2)
+        return "Width and height must be at least two";
+    if (params->n < 5)
+        return "Must have at least five regions";
+    if (params->n > params->w * params->h)
+        return "Too many regions to fit in grid";
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Cumulative frequency table functions.
+ */
+
+/*
+ * Initialise a cumulative frequency table. (Hardly worth writing
+ * this function; all it does is to initialise everything in the
+ * array to zero.)
+ */
+static void cf_init(int *table, int n)
+{
+    int i;
+
+    for (i = 0; i < n; i++)
+        table[i] = 0;
+}
+
+/*
+ * Increment the count of symbol `sym' by `count'.
+ */
+static void cf_add(int *table, int n, int sym, int count)
+{
+    int bit;
+
+    bit = 1;
+    while (sym != 0) {
+        if (sym & bit) {
+            table[sym] += count;
+            sym &= ~bit;
+        }
+        bit <<= 1;
+    }
+
+    table[0] += count;
+}
+
+/*
+ * Cumulative frequency lookup: return the total count of symbols
+ * with value less than `sym'.
+ */
+static int cf_clookup(int *table, int n, int sym)
+{
+    int bit, index, limit, count;
+
+    if (sym == 0)
+        return 0;
+
+    assert(0 < sym && sym <= n);
+
+    count = table[0];                  /* start with the whole table size */
+
+    bit = 1;
+    while (bit < n)
+        bit <<= 1;
+
+    limit = n;
+
+    while (bit > 0) {
+        /*
+         * Find the least number with its lowest set bit in this
+         * position which is greater than or equal to sym.
+         */
+        index = ((sym + bit - 1) &~ (bit * 2 - 1)) + bit;
+
+        if (index < limit) {
+            count -= table[index];
+            limit = index;
+        }
+
+        bit >>= 1;
+    }
+
+    return count;
+}
+
+/*
+ * Single frequency lookup: return the count of symbol `sym'.
+ */
+static int cf_slookup(int *table, int n, int sym)
+{
+    int count, bit;
+
+    assert(0 <= sym && sym < n);
+
+    count = table[sym];
+
+    for (bit = 1; sym+bit < n && !(sym & bit); bit <<= 1)
+        count -= table[sym+bit];
+
+    return count;
+}
+
+/*
+ * Return the largest symbol index such that the cumulative
+ * frequency up to that symbol is less than _or equal to_ count.
+ */
+static int cf_whichsym(int *table, int n, int count) {
+    int bit, sym, top;
+
+    assert(count >= 0 && count < table[0]);
+
+    bit = 1;
+    while (bit < n)
+        bit <<= 1;
+
+    sym = 0;
+    top = table[0];
+
+    while (bit > 0) {
+        if (sym+bit < n) {
+            if (count >= top - table[sym+bit])
+                sym += bit;
+            else
+                top -= table[sym+bit];
+        }
+
+        bit >>= 1;
+    }
+
+    return sym;
+}
+
+/* ----------------------------------------------------------------------
+ * Map generation.
+ * 
+ * FIXME: this isn't entirely optimal at present, because it
+ * inherently prioritises growing the largest region since there
+ * are more squares adjacent to it. This acts as a destabilising
+ * influence leading to a few large regions and mostly small ones.
+ * It might be better to do it some other way.
+ */
+
+#define WEIGHT_INCREASED 2             /* for increased perimeter */
+#define WEIGHT_DECREASED 4             /* for decreased perimeter */
+#define WEIGHT_UNCHANGED 3             /* for unchanged perimeter */
+
+/*
+ * Look at a square and decide which colours can be extended into
+ * it.
+ * 
+ * If called with index < 0, it adds together one of
+ * WEIGHT_INCREASED, WEIGHT_DECREASED or WEIGHT_UNCHANGED for each
+ * colour that has a valid extension (according to the effect that
+ * it would have on the perimeter of the region being extended) and
+ * returns the overall total.
+ * 
+ * If called with index >= 0, it returns one of the possible
+ * colours depending on the value of index, in such a way that the
+ * number of possible inputs which would give rise to a given
+ * return value correspond to the weight of that value.
+ */
+static int extend_options(int w, int h, int n, int *map,
+                          int x, int y, int index)
+{
+    int c, i, dx, dy;
+    int col[8];
+    int total = 0;
+
+    if (map[y*w+x] >= 0) {
+        assert(index < 0);
+        return 0;                      /* can't do this square at all */
+    }
+
+    /*
+     * Fetch the eight neighbours of this square, in order around
+     * the square.
+     */
+    for (dy = -1; dy <= +1; dy++)
+        for (dx = -1; dx <= +1; dx++) {
+            int index = (dy < 0 ? 6-dx : dy > 0 ? 2+dx : 2*(1+dx));
+            if (x+dx >= 0 && x+dx < w && y+dy >= 0 && y+dy < h)
+                col[index] = map[(y+dy)*w+(x+dx)];
+            else
+                col[index] = -1;
+        }
+
+    /*
+     * Iterate over each colour that might be feasible.
+     * 
+     * FIXME: this routine currently has O(n) running time. We
+     * could turn it into O(FOUR) by only bothering to iterate over
+     * the colours mentioned in the four neighbouring squares.
+     */
+
+    for (c = 0; c < n; c++) {
+        int count, neighbours, runs;
+
+        /*
+         * One of the even indices of col (representing the
+         * orthogonal neighbours of this square) must be equal to
+         * c, or else this square is not adjacent to region c and
+         * obviously cannot become an extension of it at this time.
+         */
+        neighbours = 0;
+        for (i = 0; i < 8; i += 2)
+            if (col[i] == c)
+                neighbours++;
+        if (!neighbours)
+            continue;
+
+        /*
+         * Now we know this square is adjacent to region c. The
+         * next question is, would extending it cause the region to
+         * become non-simply-connected? If so, we mustn't do it.
+         * 
+         * We determine this by looking around col to see if we can
+         * find more than one separate run of colour c.
+         */
+        runs = 0;
+        for (i = 0; i < 8; i++)
+            if (col[i] == c && col[(i+1) & 7] != c)
+                runs++;
+        if (runs > 1)
+            continue;
+
+        assert(runs == 1);
+
+        /*
+         * This square is a possibility. Determine its effect on
+         * the region's perimeter (computed from the number of
+         * orthogonal neighbours - 1 means a perimeter increase, 3
+         * a decrease, 2 no change; 4 is impossible because the
+         * region would already not be simply connected) and we're
+         * done.
+         */
+        assert(neighbours > 0 && neighbours < 4);
+        count = (neighbours == 1 ? WEIGHT_INCREASED :
+                 neighbours == 2 ? WEIGHT_UNCHANGED : WEIGHT_DECREASED);
+
+        total += count;
+        if (index >= 0 && index < count)
+            return c;
+        else
+            index -= count;
+    }
+
+    assert(index < 0);
+
+    return total;
+}
+
+static void genmap(int w, int h, int n, int *map, random_state *rs)
+{
+    int wh = w*h;
+    int x, y, i, k;
+    int *tmp;
+
+    assert(n <= wh);
+    tmp = snewn(wh, int);
+
+    /*
+     * Clear the map, and set up `tmp' as a list of grid indices.
+     */
+    for (i = 0; i < wh; i++) {
+        map[i] = -1;
+        tmp[i] = i;
+    }
+
+    /*
+     * Place the region seeds by selecting n members from `tmp'.
+     */
+    k = wh;
+    for (i = 0; i < n; i++) {
+        int j = random_upto(rs, k);
+        map[tmp[j]] = i;
+        tmp[j] = tmp[--k];
+    }
+
+    /*
+     * Re-initialise `tmp' as a cumulative frequency table. This
+     * will store the number of possible region colours we can
+     * extend into each square.
+     */
+    cf_init(tmp, wh);
+
+    /*
+     * Go through the grid and set up the initial cumulative
+     * frequencies.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            cf_add(tmp, wh, y*w+x,
+                   extend_options(w, h, n, map, x, y, -1));
+
+    /*
+     * Now repeatedly choose a square we can extend a region into,
+     * and do so.
+     */
+    while (tmp[0] > 0) {
+        int k = random_upto(rs, tmp[0]);
+        int sq;
+        int colour;
+        int xx, yy;
+
+        sq = cf_whichsym(tmp, wh, k);
+        k -= cf_clookup(tmp, wh, sq);
+        x = sq % w;
+        y = sq / w;
+        colour = extend_options(w, h, n, map, x, y, k);
+
+        map[sq] = colour;
+
+        /*
+         * Re-scan the nine cells around the one we've just
+         * modified.
+         */
+        for (yy = max(y-1, 0); yy < min(y+2, h); yy++)
+            for (xx = max(x-1, 0); xx < min(x+2, w); xx++) {
+                cf_add(tmp, wh, yy*w+xx,
+                       -cf_slookup(tmp, wh, yy*w+xx) +
+                       extend_options(w, h, n, map, xx, yy, -1));
+            }
+    }
+
+    /*
+     * Finally, go through and normalise the region labels into
+     * order, meaning that indistinguishable maps are actually
+     * identical.
+     */
+    for (i = 0; i < n; i++)
+        tmp[i] = -1;
+    k = 0;
+    for (i = 0; i < wh; i++) {
+        assert(map[i] >= 0);
+        if (tmp[map[i]] < 0)
+            tmp[map[i]] = k++;
+        map[i] = tmp[map[i]];
+    }
+
+    sfree(tmp);
+}
+
+/* ----------------------------------------------------------------------
+ * Functions to handle graphs.
+ */
+
+/*
+ * Having got a map in a square grid, convert it into a graph
+ * representation.
+ */
+static int gengraph(int w, int h, int n, int *map, int *graph)
+{
+    int i, j, x, y;
+
+    /*
+     * Start by setting the graph up as an adjacency matrix. We'll
+     * turn it into a list later.
+     */
+    for (i = 0; i < n*n; i++)
+        graph[i] = 0;
+
+    /*
+     * Iterate over the map looking for all adjacencies.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int v, vx, vy;
+            v = map[y*w+x];
+            if (x+1 < w && (vx = map[y*w+(x+1)]) != v)
+                graph[v*n+vx] = graph[vx*n+v] = 1;
+            if (y+1 < h && (vy = map[(y+1)*w+x]) != v)
+                graph[v*n+vy] = graph[vy*n+v] = 1;
+        }
+
+    /*
+     * Turn the matrix into a list.
+     */
+    for (i = j = 0; i < n*n; i++)
+        if (graph[i])
+            graph[j++] = i;
+
+    return j;
+}
+
+static int graph_edge_index(int *graph, int n, int ngraph, int i, int j)
+{
+    int v = i*n+j;
+    int top, bot, mid;
+
+    bot = -1;
+    top = ngraph;
+    while (top - bot > 1) {
+        mid = (top + bot) / 2;
+        if (graph[mid] == v)
+            return mid;
+        else if (graph[mid] < v)
+            bot = mid;
+        else
+            top = mid;
+    }
+    return -1;
+}
+
+#define graph_adjacent(graph, n, ngraph, i, j) \
+    (graph_edge_index((graph), (n), (ngraph), (i), (j)) >= 0)
+
+static int graph_vertex_start(int *graph, int n, int ngraph, int i)
+{
+    int v = i*n;
+    int top, bot, mid;
+
+    bot = -1;
+    top = ngraph;
+    while (top - bot > 1) {
+        mid = (top + bot) / 2;
+        if (graph[mid] < v)
+            bot = mid;
+        else
+            top = mid;
+    }
+    return top;
+}
+
+/* ----------------------------------------------------------------------
+ * Generate a four-colouring of a graph.
+ *
+ * FIXME: it would be nice if we could convert this recursion into
+ * pseudo-recursion using some sort of explicit stack array, for
+ * the sake of the Palm port and its limited stack.
+ */
+
+static int fourcolour_recurse(int *graph, int n, int ngraph,
+                              int *colouring, int *scratch, random_state *rs)
+{
+    int nfree, nvert, start, i, j, k, c, ci;
+    int cs[FOUR];
+
+    /*
+     * Find the smallest number of free colours in any uncoloured
+     * vertex, and count the number of such vertices.
+     */
+
+    nfree = FIVE;                      /* start off bigger than FOUR! */
+    nvert = 0;
+    for (i = 0; i < n; i++)
+        if (colouring[i] < 0 && scratch[i*FIVE+FOUR] <= nfree) {
+            if (nfree > scratch[i*FIVE+FOUR]) {
+                nfree = scratch[i*FIVE+FOUR];
+                nvert = 0;
+            }
+            nvert++;
+        }
+
+    /*
+     * If there aren't any uncoloured vertices at all, we're done.
+     */
+    if (nvert == 0)
+        return TRUE;                   /* we've got a colouring! */
+
+    /*
+     * Pick a random vertex in that set.
+     */
+    j = random_upto(rs, nvert);
+    for (i = 0; i < n; i++)
+        if (colouring[i] < 0 && scratch[i*FIVE+FOUR] == nfree)
+            if (j-- == 0)
+                break;
+    assert(i < n);
+    start = graph_vertex_start(graph, n, ngraph, i);
+
+    /*
+     * Loop over the possible colours for i, and recurse for each
+     * one.
+     */
+    ci = 0;
+    for (c = 0; c < FOUR; c++)
+        if (scratch[i*FIVE+c] == 0)
+            cs[ci++] = c;
+    shuffle(cs, ci, sizeof(*cs), rs);
+
+    while (ci-- > 0) {
+        c = cs[ci];
+
+        /*
+         * Fill in this colour.
+         */
+        colouring[i] = c;
+
+        /*
+         * Update the scratch space to reflect a new neighbour
+         * of this colour for each neighbour of vertex i.
+         */
+        for (j = start; j < ngraph && graph[j] < n*(i+1); j++) {
+            k = graph[j] - i*n;
+            if (scratch[k*FIVE+c] == 0)
+                scratch[k*FIVE+FOUR]--;
+            scratch[k*FIVE+c]++;
+        }
+
+        /*
+         * Recurse.
+         */
+        if (fourcolour_recurse(graph, n, ngraph, colouring, scratch, rs))
+            return TRUE;               /* got one! */
+
+        /*
+         * If that didn't work, clean up and try again with a
+         * different colour.
+         */
+        for (j = start; j < ngraph && graph[j] < n*(i+1); j++) {
+            k = graph[j] - i*n;
+            scratch[k*FIVE+c]--;
+            if (scratch[k*FIVE+c] == 0)
+                scratch[k*FIVE+FOUR]++;
+        }
+        colouring[i] = -1;
+    }
+
+    /*
+     * If we reach here, we were unable to find a colouring at all.
+     * (This doesn't necessarily mean the Four Colour Theorem is
+     * violated; it might just mean we've gone down a dead end and
+     * need to back up and look somewhere else. It's only an FCT
+     * violation if we get all the way back up to the top level and
+     * still fail.)
+     */
+    return FALSE;
+}
+
+static void fourcolour(int *graph, int n, int ngraph, int *colouring,
+                       random_state *rs)
+{
+    int *scratch;
+    int i;
+
+    /*
+     * For each vertex and each colour, we store the number of
+     * neighbours that have that colour. Also, we store the number
+     * of free colours for the vertex.
+     */
+    scratch = snewn(n * FIVE, int);
+    for (i = 0; i < n * FIVE; i++)
+        scratch[i] = (i % FIVE == FOUR ? FOUR : 0);
+
+    /*
+     * Clear the colouring to start with.
+     */
+    for (i = 0; i < n; i++)
+        colouring[i] = -1;
+
+    i = fourcolour_recurse(graph, n, ngraph, colouring, scratch, rs);
+    assert(i);                         /* by the Four Colour Theorem :-) */
+
+    sfree(scratch);
+}
+
+/* ----------------------------------------------------------------------
+ * Non-recursive solver.
+ */
+
+struct solver_scratch {
+    unsigned char *possible;           /* bitmap of colours for each region */
+
+    int *graph;
+    int n;
+    int ngraph;
+
+    int *bfsqueue;
+    int *bfscolour;
+#ifdef SOLVER_DIAGNOSTICS
+    int *bfsprev;
+#endif
+
+    int depth;
+};
+
+static struct solver_scratch *new_scratch(int *graph, int n, int ngraph)
+{
+    struct solver_scratch *sc;
+
+    sc = snew(struct solver_scratch);
+    sc->graph = graph;
+    sc->n = n;
+    sc->ngraph = ngraph;
+    sc->possible = snewn(n, unsigned char);
+    sc->depth = 0;
+    sc->bfsqueue = snewn(n, int);
+    sc->bfscolour = snewn(n, int);
+#ifdef SOLVER_DIAGNOSTICS
+    sc->bfsprev = snewn(n, int);
+#endif
+
+    return sc;
+}
+
+static void free_scratch(struct solver_scratch *sc)
+{
+    sfree(sc->possible);
+    sfree(sc->bfsqueue);
+    sfree(sc->bfscolour);
+#ifdef SOLVER_DIAGNOSTICS
+    sfree(sc->bfsprev);
+#endif
+    sfree(sc);
+}
+
+/*
+ * Count the bits in a word. Only needs to cope with FOUR bits.
+ */
+static int bitcount(int word)
+{
+    assert(FOUR <= 4);                 /* or this needs changing */
+    word = ((word & 0xA) >> 1) + (word & 0x5);
+    word = ((word & 0xC) >> 2) + (word & 0x3);
+    return word;
+}
+
+#ifdef SOLVER_DIAGNOSTICS
+static const char colnames[FOUR] = { 'R', 'Y', 'G', 'B' };
+#endif
+
+static int place_colour(struct solver_scratch *sc,
+                        int *colouring, int index, int colour
+#ifdef SOLVER_DIAGNOSTICS
+                        , char *verb
+#endif
+                        )
+{
+    int *graph = sc->graph, n = sc->n, ngraph = sc->ngraph;
+    int j, k;
+
+    if (!(sc->possible[index] & (1 << colour))) {
+#ifdef SOLVER_DIAGNOSTICS
+        if (verbose)
+            printf("%*scannot place %c in region %d\n", 2*sc->depth, "",
+                   colnames[colour], index);
+#endif
+        return FALSE;                  /* can't do it */
+    }
+
+    sc->possible[index] = 1 << colour;
+    colouring[index] = colour;
+
+#ifdef SOLVER_DIAGNOSTICS
+    if (verbose)
+        printf("%*s%s %c in region %d\n", 2*sc->depth, "",
+               verb, colnames[colour], index);
+#endif
+
+    /*
+     * Rule out this colour from all the region's neighbours.
+     */
+    for (j = graph_vertex_start(graph, n, ngraph, index);
+         j < ngraph && graph[j] < n*(index+1); j++) {
+        k = graph[j] - index*n;
+#ifdef SOLVER_DIAGNOSTICS
+        if (verbose && (sc->possible[k] & (1 << colour)))
+            printf("%*s  ruling out %c in region %d\n", 2*sc->depth, "",
+                   colnames[colour], k);
+#endif
+        sc->possible[k] &= ~(1 << colour);
+    }
+
+    return TRUE;
+}
+
+#ifdef SOLVER_DIAGNOSTICS
+static char *colourset(char *buf, int set)
+{
+    int i;
+    char *p = buf;
+    char *sep = "";
+
+    for (i = 0; i < FOUR; i++)
+        if (set & (1 << i)) {
+            p += sprintf(p, "%s%c", sep, colnames[i]);
+            sep = ",";
+        }
+
+    return buf;
+}
+#endif
+
+/*
+ * Returns 0 for impossible, 1 for success, 2 for failure to
+ * converge (i.e. puzzle is either ambiguous or just too
+ * difficult).
+ */
+static int map_solver(struct solver_scratch *sc,
+                      int *graph, int n, int ngraph, int *colouring,
+                      int difficulty)
+{
+    int i;
+
+    if (sc->depth == 0) {
+        /*
+         * Initialise scratch space.
+         */
+        for (i = 0; i < n; i++)
+            sc->possible[i] = (1 << FOUR) - 1;
+
+        /*
+         * Place clues.
+         */
+        for (i = 0; i < n; i++)
+            if (colouring[i] >= 0) {
+                if (!place_colour(sc, colouring, i, colouring[i]
+#ifdef SOLVER_DIAGNOSTICS
+                                  , "initial clue:"
+#endif
+                                  )) {
+#ifdef SOLVER_DIAGNOSTICS
+                    if (verbose)
+                        printf("%*sinitial clue set is inconsistent\n",
+                               2*sc->depth, "");
+#endif
+                    return 0;          /* the clues aren't even consistent! */
+                }
+            }
+    }
+
+    /*
+     * Now repeatedly loop until we find nothing further to do.
+     */
+    while (1) {
+        int done_something = FALSE;
+
+        if (difficulty < DIFF_EASY)
+            break;                     /* can't do anything at all! */
+
+        /*
+         * Simplest possible deduction: find a region with only one
+         * possible colour.
+         */
+        for (i = 0; i < n; i++) if (colouring[i] < 0) {
+            int p = sc->possible[i];
+
+            if (p == 0) {
+#ifdef SOLVER_DIAGNOSTICS
+                if (verbose)
+                    printf("%*sregion %d has no possible colours left\n",
+                           2*sc->depth, "", i);
+#endif
+                return 0;              /* puzzle is inconsistent */
+            }
+
+            if ((p & (p-1)) == 0) {    /* p is a power of two */
+                int c, ret;
+                for (c = 0; c < FOUR; c++)
+                    if (p == (1 << c))
+                        break;
+                assert(c < FOUR);
+                ret = place_colour(sc, colouring, i, c
+#ifdef SOLVER_DIAGNOSTICS
+                                   , "placing"
+#endif
+                                   );
+                /*
+                 * place_colour() can only fail if colour c was not
+                 * even a _possibility_ for region i, and we're
+                 * pretty sure it was because we checked before
+                 * calling place_colour(). So we can safely assert
+                 * here rather than having to return a nice
+                 * friendly error code.
+                 */
+                assert(ret);
+                done_something = TRUE;
+            }
+        }
+
+        if (done_something)
+            continue;
+
+        if (difficulty < DIFF_NORMAL)
+            break;                     /* can't do anything harder */
+
+        /*
+         * Failing that, go up one level. Look for pairs of regions
+         * which (a) both have the same pair of possible colours,
+         * (b) are adjacent to one another, (c) are adjacent to the
+         * same region, and (d) that region still thinks it has one
+         * or both of those possible colours.
+         * 
+         * Simplest way to do this is by going through the graph
+         * edge by edge, so that we start with property (b) and
+         * then look for (a) and finally (c) and (d).
+         */
+        for (i = 0; i < ngraph; i++) {
+            int j1 = graph[i] / n, j2 = graph[i] % n;
+            int j, k, v, v2;
+#ifdef SOLVER_DIAGNOSTICS
+            int started = FALSE;
+#endif
+
+            if (j1 > j2)
+                continue;              /* done it already, other way round */
+
+            if (colouring[j1] >= 0 || colouring[j2] >= 0)
+                continue;              /* they're not undecided */
+
+            if (sc->possible[j1] != sc->possible[j2])
+                continue;              /* they don't have the same possibles */
+
+            v = sc->possible[j1];
+            /*
+             * See if v contains exactly two set bits.
+             */
+            v2 = v & -v;           /* find lowest set bit */
+            v2 = v & ~v2;          /* clear it */
+            if (v2 == 0 || (v2 & (v2-1)) != 0)   /* not power of 2 */
+                continue;
+
+            /*
+             * We've found regions j1 and j2 satisfying properties
+             * (a) and (b): they have two possible colours between
+             * them, and since they're adjacent to one another they
+             * must use _both_ those colours between them.
+             * Therefore, if they are both adjacent to any other
+             * region then that region cannot be either colour.
+             * 
+             * Go through the neighbours of j1 and see if any are
+             * shared with j2.
+             */
+            for (j = graph_vertex_start(graph, n, ngraph, j1);
+                 j < ngraph && graph[j] < n*(j1+1); j++) {
+                k = graph[j] - j1*n;
+                if (graph_adjacent(graph, n, ngraph, k, j2) &&
+                    (sc->possible[k] & v)) {
+#ifdef SOLVER_DIAGNOSTICS
+                    if (verbose) {
+                        char buf[80];
+                        if (!started)
+                            printf("%*sadjacent regions %d,%d share colours"
+                                   " %s\n", 2*sc->depth, "", j1, j2,
+                                   colourset(buf, v));
+                        started = TRUE;
+                        printf("%*s  ruling out %s in region %d\n",2*sc->depth,
+                               "", colourset(buf, sc->possible[k] & v), k);
+                    }
+#endif
+                    sc->possible[k] &= ~v;
+                    done_something = TRUE;
+                }
+            }
+        }
+
+        if (done_something)
+            continue;
+
+        if (difficulty < DIFF_HARD)
+            break;                     /* can't do anything harder */
+
+        /*
+         * Right; now we get creative. Now we're going to look for
+         * `forcing chains'. A forcing chain is a path through the
+         * graph with the following properties:
+         * 
+         *  (a) Each vertex on the path has precisely two possible
+         *      colours.
+         * 
+         *  (b) Each pair of vertices which are adjacent on the
+         *      path share at least one possible colour in common.
+         * 
+         *  (c) Each vertex in the middle of the path shares _both_
+         *      of its colours with at least one of its neighbours
+         *      (not the same one with both neighbours).
+         * 
+         * These together imply that at least one of the possible
+         * colour choices at one end of the path forces _all_ the
+         * rest of the colours along the path. In order to make
+         * real use of this, we need further properties:
+         * 
+         *  (c) Ruling out some colour C from the vertex at one end
+         *      of the path forces the vertex at the other end to
+         *      take colour C.
+         * 
+         *  (d) The two end vertices are mutually adjacent to some
+         *      third vertex.
+         * 
+         *  (e) That third vertex currently has C as a possibility.
+         * 
+         * If we can find all of that lot, we can deduce that at
+         * least one of the two ends of the forcing chain has
+         * colour C, and that therefore the mutually adjacent third
+         * vertex does not.
+         * 
+         * To find forcing chains, we're going to start a bfs at
+         * each suitable vertex of the graph, once for each of its
+         * two possible colours.
+         */
+        for (i = 0; i < n; i++) {
+            int c;
+
+            if (colouring[i] >= 0 || bitcount(sc->possible[i]) != 2)
+                continue;
+
+            for (c = 0; c < FOUR; c++)
+                if (sc->possible[i] & (1 << c)) {
+                    int j, k, gi, origc, currc, head, tail;
+                    /*
+                     * Try a bfs from this vertex, ruling out
+                     * colour c.
+                     * 
+                     * Within this loop, we work in colour bitmaps
+                     * rather than actual colours, because
+                     * converting back and forth is a needless
+                     * computational expense.
+                     */
+
+                    origc = 1 << c;
+
+                    for (j = 0; j < n; j++) {
+                        sc->bfscolour[j] = -1;
+#ifdef SOLVER_DIAGNOSTICS
+                        sc->bfsprev[j] = -1;
+#endif
+                    }
+                    head = tail = 0;
+                    sc->bfsqueue[tail++] = i;
+                    sc->bfscolour[i] = sc->possible[i] &~ origc;
+
+                    while (head < tail) {
+                        j = sc->bfsqueue[head++];
+                        currc = sc->bfscolour[j];
+
+                        /*
+                         * Try neighbours of j.
+                         */
+                        for (gi = graph_vertex_start(graph, n, ngraph, j);
+                             gi < ngraph && graph[gi] < n*(j+1); gi++) {
+                            k = graph[gi] - j*n;
+
+                            /*
+                             * To continue with the bfs in vertex
+                             * k, we need k to be
+                             *  (a) not already visited
+                             *  (b) have two possible colours
+                             *  (c) those colours include currc.
+                             */
+
+                            if (sc->bfscolour[k] < 0 &&
+                                colouring[k] < 0 &&
+                                bitcount(sc->possible[k]) == 2 &&
+                                (sc->possible[k] & currc)) {
+                                sc->bfsqueue[tail++] = k;
+                                sc->bfscolour[k] =
+                                    sc->possible[k] &~ currc;
+#ifdef SOLVER_DIAGNOSTICS
+                                sc->bfsprev[k] = j;
+#endif
+                            }
+
+                            /*
+                             * One other possibility is that k
+                             * might be the region in which we can
+                             * make a real deduction: if it's
+                             * adjacent to i, contains currc as a
+                             * possibility, and currc is equal to
+                             * the original colour we ruled out.
+                             */
+                            if (currc == origc &&
+                                graph_adjacent(graph, n, ngraph, k, i) &&
+                                (sc->possible[k] & currc)) {
+#ifdef SOLVER_DIAGNOSTICS
+                                if (verbose) {
+                                    char buf[80], *sep = "";
+                                    int r;
+
+                                    printf("%*sforcing chain, colour %s, ",
+                                           2*sc->depth, "",
+                                           colourset(buf, origc));
+                                    for (r = j; r != -1; r = sc->bfsprev[r]) {
+                                        printf("%s%d", sep, r);
+                                        sep = "-";
+                                    }
+                                    printf("\n%*s  ruling out %s in region"
+                                           " %d\n", 2*sc->depth, "",
+                                           colourset(buf, origc), k);
+                                }
+#endif
+                                sc->possible[k] &= ~origc;
+                                done_something = TRUE;
+                            }
+                        }
+                    }
+
+                    assert(tail <= n);
+                }
+        }
+
+        if (!done_something)
+            break;
+    }
+
+    /*
+     * See if we've got a complete solution, and return if so.
+     */
+    for (i = 0; i < n; i++)
+        if (colouring[i] < 0)
+            break;
+    if (i == n) {
+#ifdef SOLVER_DIAGNOSTICS
+        if (verbose)
+            printf("%*sone solution found\n", 2*sc->depth, "");
+#endif
+        return 1;                      /* success! */
+    }
+
+    /*
+     * If recursion is not permissible, we now give up.
+     */
+    if (difficulty < DIFF_RECURSE) {
+#ifdef SOLVER_DIAGNOSTICS
+        if (verbose)
+            printf("%*sunable to proceed further without recursion\n",
+                   2*sc->depth, "");
+#endif
+        return 2;                      /* unable to complete */
+    }
+
+    /*
+     * Now we've got to do something recursive. So first hunt for a
+     * currently-most-constrained region.
+     */
+    {
+        int best, bestc;
+        struct solver_scratch *rsc;
+        int *subcolouring, *origcolouring;
+        int ret, subret;
+        int we_already_got_one;
+
+        best = -1;
+        bestc = FIVE;
+
+        for (i = 0; i < n; i++) if (colouring[i] < 0) {
+            int p = sc->possible[i];
+            enum { compile_time_assertion = 1 / (FOUR <= 4) };
+            int c;
+
+            /* Count the set bits. */
+            c = (p & 5) + ((p >> 1) & 5);
+            c = (c & 3) + ((c >> 2) & 3);
+            assert(c > 1);             /* or colouring[i] would be >= 0 */
+
+            if (c < bestc) {
+                best = i;
+                bestc = c;
+            }
+        }
+
+        assert(best >= 0);             /* or we'd be solved already */
+
+#ifdef SOLVER_DIAGNOSTICS
+        if (verbose)
+            printf("%*srecursing on region %d\n", 2*sc->depth, "", best);
+#endif
+
+        /*
+         * Now iterate over the possible colours for this region.
+         */
+        rsc = new_scratch(graph, n, ngraph);
+        rsc->depth = sc->depth + 1;
+        origcolouring = snewn(n, int);
+        memcpy(origcolouring, colouring, n * sizeof(int));
+        subcolouring = snewn(n, int);
+        we_already_got_one = FALSE;
+        ret = 0;
+
+        for (i = 0; i < FOUR; i++) {
+            if (!(sc->possible[best] & (1 << i)))
+                continue;
+
+            memcpy(rsc->possible, sc->possible, n);
+            memcpy(subcolouring, origcolouring, n * sizeof(int));
+
+            place_colour(rsc, subcolouring, best, i
+#ifdef SOLVER_DIAGNOSTICS
+                         , "trying"
+#endif
+                         );
+
+            subret = map_solver(rsc, graph, n, ngraph,
+                                subcolouring, difficulty);
+
+#ifdef SOLVER_DIAGNOSTICS
+            if (verbose) {
+                printf("%*sretracting %c in region %d; found %s\n",
+                       2*sc->depth, "", colnames[i], best,
+                       subret == 0 ? "no solutions" :
+                       subret == 1 ? "one solution" : "multiple solutions");
+            }
+#endif
+
+            /*
+             * If this possibility turned up more than one valid
+             * solution, or if it turned up one and we already had
+             * one, we're definitely ambiguous.
+             */
+            if (subret == 2 || (subret == 1 && we_already_got_one)) {
+                ret = 2;
+                break;
+            }
+
+            /*
+             * If this possibility turned up one valid solution and
+             * it's the first we've seen, copy it into the output.
+             */
+            if (subret == 1) {
+                memcpy(colouring, subcolouring, n * sizeof(int));
+                we_already_got_one = TRUE;
+                ret = 1;
+            }
+
+            /*
+             * Otherwise, this guess led to a contradiction, so we
+             * do nothing.
+             */
+        }
+
+        sfree(origcolouring);
+        sfree(subcolouring);
+        free_scratch(rsc);
+
+#ifdef SOLVER_DIAGNOSTICS
+        if (verbose && sc->depth == 0) {
+            printf("%*s%s found\n",
+                   2*sc->depth, "",
+                   ret == 0 ? "no solutions" :
+                   ret == 1 ? "one solution" : "multiple solutions");
+        }
+#endif
+        return ret;
+    }
+}
+
+/* ----------------------------------------------------------------------
+ * Game generation main function.
+ */
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    struct solver_scratch *sc = NULL;
+    int *map, *graph, ngraph, *colouring, *colouring2, *regions;
+    int i, j, w, h, n, solveret, cfreq[FOUR];
+    int wh;
+    int mindiff, tries;
+#ifdef GENERATION_DIAGNOSTICS
+    int x, y;
+#endif
+    char *ret, buf[80];
+    int retlen, retsize;
+
+    w = params->w;
+    h = params->h;
+    n = params->n;
+    wh = w*h;
+
+    *aux = NULL;
+
+    map = snewn(wh, int);
+    graph = snewn(n*n, int);
+    colouring = snewn(n, int);
+    colouring2 = snewn(n, int);
+    regions = snewn(n, int);
+
+    /*
+     * This is the minimum difficulty below which we'll completely
+     * reject a map design. Normally we set this to one below the
+     * requested difficulty, ensuring that we have the right
+     * result. However, for particularly dense maps or maps with
+     * particularly few regions it might not be possible to get the
+     * desired difficulty, so we will eventually drop this down to
+     * -1 to indicate that any old map will do.
+     */
+    mindiff = params->diff;
+    tries = 50;
+
+    while (1) {
+
+        /*
+         * Create the map.
+         */
+        genmap(w, h, n, map, rs);
+
+#ifdef GENERATION_DIAGNOSTICS
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                int v = map[y*w+x];
+                if (v >= 62)
+                    putchar('!');
+                else if (v >= 36)
+                    putchar('a' + v-36);
+                else if (v >= 10)
+                    putchar('A' + v-10);
+                else
+                    putchar('0' + v);
+            }
+            putchar('\n');
+        }
+#endif
+
+        /*
+         * Convert the map into a graph.
+         */
+        ngraph = gengraph(w, h, n, map, graph);
+
+#ifdef GENERATION_DIAGNOSTICS
+        for (i = 0; i < ngraph; i++)
+            printf("%d-%d\n", graph[i]/n, graph[i]%n);
+#endif
+
+        /*
+         * Colour the map.
+         */
+        fourcolour(graph, n, ngraph, colouring, rs);
+
+#ifdef GENERATION_DIAGNOSTICS
+        for (i = 0; i < n; i++)
+            printf("%d: %d\n", i, colouring[i]);
+
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                int v = colouring[map[y*w+x]];
+                if (v >= 36)
+                    putchar('a' + v-36);
+                else if (v >= 10)
+                    putchar('A' + v-10);
+                else
+                    putchar('0' + v);
+            }
+            putchar('\n');
+        }
+#endif
+
+        /*
+         * Encode the solution as an aux string.
+         */
+        if (*aux)                      /* in case we've come round again */
+            sfree(*aux);
+        retlen = retsize = 0;
+        ret = NULL;
+        for (i = 0; i < n; i++) {
+            int len;
+
+            if (colouring[i] < 0)
+                continue;
+
+            len = sprintf(buf, "%s%d:%d", i ? ";" : "S;", colouring[i], i);
+            if (retlen + len >= retsize) {
+                retsize = retlen + len + 256;
+                ret = sresize(ret, retsize, char);
+            }
+            strcpy(ret + retlen, buf);
+            retlen += len;
+        }
+        *aux = ret;
+
+        /*
+         * Remove the region colours one by one, keeping
+         * solubility. Also ensure that there always remains at
+         * least one region of every colour, so that the user can
+         * drag from somewhere.
+         */
+        for (i = 0; i < FOUR; i++)
+            cfreq[i] = 0;
+        for (i = 0; i < n; i++) {
+            regions[i] = i;
+            cfreq[colouring[i]]++;
+        }
+        for (i = 0; i < FOUR; i++)
+            if (cfreq[i] == 0)
+                continue;
+
+        shuffle(regions, n, sizeof(*regions), rs);
+
+        if (sc) free_scratch(sc);
+        sc = new_scratch(graph, n, ngraph);
+
+        for (i = 0; i < n; i++) {
+            j = regions[i];
+
+            if (cfreq[colouring[j]] == 1)
+                continue;              /* can't remove last region of colour */
+
+            memcpy(colouring2, colouring, n*sizeof(int));
+            colouring2[j] = -1;
+            solveret = map_solver(sc, graph, n, ngraph, colouring2,
+                                  params->diff);
+            assert(solveret >= 0);             /* mustn't be impossible! */
+            if (solveret == 1) {
+                cfreq[colouring[j]]--;
+                colouring[j] = -1;
+            }
+        }
+
+#ifdef GENERATION_DIAGNOSTICS
+        for (i = 0; i < n; i++)
+            if (colouring[i] >= 0) {
+                if (i >= 62)
+                    putchar('!');
+                else if (i >= 36)
+                    putchar('a' + i-36);
+                else if (i >= 10)
+                    putchar('A' + i-10);
+                else
+                    putchar('0' + i);
+                printf(": %d\n", colouring[i]);
+            }
+#endif
+
+        /*
+         * Finally, check that the puzzle is _at least_ as hard as
+         * required, and indeed that it isn't already solved.
+         * (Calling map_solver with negative difficulty ensures the
+         * latter - if a solver which _does nothing_ can solve it,
+         * it's too easy!)
+         */
+        memcpy(colouring2, colouring, n*sizeof(int));
+        if (map_solver(sc, graph, n, ngraph, colouring2,
+                       mindiff - 1) == 1) {
+            /*
+             * Drop minimum difficulty if necessary.
+             */
+            if (mindiff > 0 && (n < 9 || n > 2*wh/3)) {
+                if (tries-- <= 0)
+                    mindiff = 0;       /* give up and go for Easy */
+            }
+            continue;
+        }
+
+        break;
+    }
+
+    /*
+     * Encode as a game ID. We do this by:
+     * 
+     *  - first going along the horizontal edges row by row, and
+     *    then the vertical edges column by column
+     *  - encoding the lengths of runs of edges and runs of
+     *    non-edges
+     *  - the decoder will reconstitute the region boundaries from
+     *    this and automatically number them the same way we did
+     *  - then we encode the initial region colours in a Slant-like
+     *    fashion (digits 0-3 interspersed with letters giving
+     *    lengths of runs of empty spaces).
+     */
+    retlen = retsize = 0;
+    ret = NULL;
+
+    {
+        int run, pv;
+
+        /*
+         * Start with a notional non-edge, so that there'll be an
+         * explicit `a' to distinguish the case where we start with
+         * an edge.
+         */
+        run = 1;
+        pv = 0;
+
+        for (i = 0; i < w*(h-1) + (w-1)*h; i++) {
+            int x, y, dx, dy, v;
+
+            if (i < w*(h-1)) {
+                /* Horizontal edge. */
+                y = i / w;
+                x = i % w;
+                dx = 0;
+                dy = 1;
+            } else {
+                /* Vertical edge. */
+                x = (i - w*(h-1)) / h;
+                y = (i - w*(h-1)) % h;
+                dx = 1;
+                dy = 0;
+            }
+
+            if (retlen + 10 >= retsize) {
+                retsize = retlen + 256;
+                ret = sresize(ret, retsize, char);
+            }
+
+            v = (map[y*w+x] != map[(y+dy)*w+(x+dx)]);
+
+            if (pv != v) {
+                ret[retlen++] = 'a'-1 + run;
+                run = 1;
+                pv = v;
+            } else {
+                /*
+                 * 'z' is a special case in this encoding. Rather
+                 * than meaning a run of 26 and a state switch, it
+                 * means a run of 25 and _no_ state switch, because
+                 * otherwise there'd be no way to encode runs of
+                 * more than 26.
+                 */
+                if (run == 25) {
+                    ret[retlen++] = 'z';
+                    run = 0;
+                }
+                run++;
+            }
+        }
+
+        ret[retlen++] = 'a'-1 + run;
+        ret[retlen++] = ',';
+
+        run = 0;
+        for (i = 0; i < n; i++) {
+            if (retlen + 10 >= retsize) {
+                retsize = retlen + 256;
+                ret = sresize(ret, retsize, char);
+            }
+
+            if (colouring[i] < 0) {
+                /*
+                 * In _this_ encoding, 'z' is a run of 26, since
+                 * there's no implicit state switch after each run.
+                 * Confusingly different, but more compact.
+                 */
+                if (run == 26) {
+                    ret[retlen++] = 'z';
+                    run = 0;
+                }
+                run++;
+            } else {
+                if (run > 0)
+                    ret[retlen++] = 'a'-1 + run;
+                ret[retlen++] = '0' + colouring[i];
+                run = 0;
+            }
+        }
+        if (run > 0)
+            ret[retlen++] = 'a'-1 + run;
+        ret[retlen] = '\0';
+
+        assert(retlen < retsize);
+    }
+
+    free_scratch(sc);
+    sfree(regions);
+    sfree(colouring2);
+    sfree(colouring);
+    sfree(graph);
+    sfree(map);
+
+    return ret;
+}
+
+static char *parse_edge_list(const game_params *params, const char **desc,
+                             int *map)
+{
+    int w = params->w, h = params->h, wh = w*h, n = params->n;
+    int i, k, pos, state;
+    const char *p = *desc;
+
+    dsf_init(map+wh, wh);
+
+    pos = -1;
+    state = 0;
+
+    /*
+     * Parse the game description to get the list of edges, and
+     * build up a disjoint set forest as we go (by identifying
+     * pairs of squares whenever the edge list shows a non-edge).
+     */
+    while (*p && *p != ',') {
+        if (*p < 'a' || *p > 'z')
+            return "Unexpected character in edge list";
+        if (*p == 'z')
+            k = 25;
+        else
+            k = *p - 'a' + 1;
+        while (k-- > 0) {
+            int x, y, dx, dy;
+
+            if (pos < 0) {
+                pos++;
+                continue;
+            } else if (pos < w*(h-1)) {
+                /* Horizontal edge. */
+                y = pos / w;
+                x = pos % w;
+                dx = 0;
+                dy = 1;
+            } else if (pos < 2*wh-w-h) {
+                /* Vertical edge. */
+                x = (pos - w*(h-1)) / h;
+                y = (pos - w*(h-1)) % h;
+                dx = 1;
+                dy = 0;
+            } else
+                return "Too much data in edge list";
+            if (!state)
+                dsf_merge(map+wh, y*w+x, (y+dy)*w+(x+dx));
+
+            pos++;
+        }
+        if (*p != 'z')
+            state = !state;
+        p++;
+    }
+    assert(pos <= 2*wh-w-h);
+    if (pos < 2*wh-w-h)
+        return "Too little data in edge list";
+
+    /*
+     * Now go through again and allocate region numbers.
+     */
+    pos = 0;
+    for (i = 0; i < wh; i++)
+        map[i] = -1;
+    for (i = 0; i < wh; i++) {
+        k = dsf_canonify(map+wh, i);
+        if (map[k] < 0)
+            map[k] = pos++;
+        map[i] = map[k];
+    }
+    if (pos != n)
+        return "Edge list defines the wrong number of regions";
+
+    *desc = p;
+
+    return NULL;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, h = params->h, wh = w*h, n = params->n;
+    int area;
+    int *map;
+    char *ret;
+
+    map = snewn(2*wh, int);
+    ret = parse_edge_list(params, &desc, map);
+    sfree(map);
+    if (ret)
+        return ret;
+
+    if (*desc != ',')
+        return "Expected comma before clue list";
+    desc++;                            /* eat comma */
+
+    area = 0;
+    while (*desc) {
+        if (*desc >= '0' && *desc < '0'+FOUR)
+            area++;
+        else if (*desc >= 'a' && *desc <= 'z')
+            area += *desc - 'a' + 1;
+        else
+            return "Unexpected character in clue list";
+        desc++;
+    }
+    if (area < n)
+        return "Too little data in clue list";
+    else if (area > n)
+        return "Too much data in clue list";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, h = params->h, wh = w*h, n = params->n;
+    int i, pos;
+    const char *p;
+    game_state *state = snew(game_state);
+
+    state->p = *params;
+    state->colouring = snewn(n, int);
+    for (i = 0; i < n; i++)
+        state->colouring[i] = -1;
+    state->pencil = snewn(n, int);
+    for (i = 0; i < n; i++)
+        state->pencil[i] = 0;
+
+    state->completed = state->cheated = FALSE;
+
+    state->map = snew(struct map);
+    state->map->refcount = 1;
+    state->map->map = snewn(wh*4, int);
+    state->map->graph = snewn(n*n, int);
+    state->map->n = n;
+    state->map->immutable = snewn(n, int);
+    for (i = 0; i < n; i++)
+        state->map->immutable[i] = FALSE;
+
+    p = desc;
+
+    {
+        char *ret;
+        ret = parse_edge_list(params, &p, state->map->map);
+        assert(!ret);
+    }
+
+    /*
+     * Set up the other three quadrants in `map'.
+     */
+    for (i = wh; i < 4*wh; i++)
+        state->map->map[i] = state->map->map[i % wh];
+
+    assert(*p == ',');
+    p++;
+
+    /*
+     * Now process the clue list.
+     */
+    pos = 0;
+    while (*p) {
+        if (*p >= '0' && *p < '0'+FOUR) {
+            state->colouring[pos] = *p - '0';
+            state->map->immutable[pos] = TRUE;
+            pos++;
+        } else {
+            assert(*p >= 'a' && *p <= 'z');
+            pos += *p - 'a' + 1;
+        }
+        p++;
+    }
+    assert(pos == n);
+
+    state->map->ngraph = gengraph(w, h, n, state->map->map, state->map->graph);
+
+    /*
+     * Attempt to smooth out some of the more jagged region
+     * outlines by the judicious use of diagonally divided squares.
+     */
+    {
+        random_state *rs = random_new(desc, strlen(desc));
+        int *squares = snewn(wh, int);
+        int done_something;
+
+        for (i = 0; i < wh; i++)
+            squares[i] = i;
+        shuffle(squares, wh, sizeof(*squares), rs);
+
+        do {
+            done_something = FALSE;
+            for (i = 0; i < wh; i++) {
+                int y = squares[i] / w, x = squares[i] % w;
+                int c = state->map->map[y*w+x];
+                int tc, bc, lc, rc;
+
+                if (x == 0 || x == w-1 || y == 0 || y == h-1)
+                    continue;
+
+                if (state->map->map[TE * wh + y*w+x] !=
+                    state->map->map[BE * wh + y*w+x])
+                    continue;
+
+                tc = state->map->map[BE * wh + (y-1)*w+x];
+                bc = state->map->map[TE * wh + (y+1)*w+x];
+                lc = state->map->map[RE * wh + y*w+(x-1)];
+                rc = state->map->map[LE * wh + y*w+(x+1)];
+
+                /*
+                 * If this square is adjacent on two sides to one
+                 * region and on the other two sides to the other
+                 * region, and is itself one of the two regions, we can
+                 * adjust it so that it's a diagonal.
+                 */
+                if (tc != bc && (tc == c || bc == c)) {
+                    if ((lc == tc && rc == bc) ||
+                        (lc == bc && rc == tc)) {
+                        state->map->map[TE * wh + y*w+x] = tc;
+                        state->map->map[BE * wh + y*w+x] = bc;
+                        state->map->map[LE * wh + y*w+x] = lc;
+                        state->map->map[RE * wh + y*w+x] = rc;
+                        done_something = TRUE;
+                    }
+                }
+            }
+        } while (done_something);
+        sfree(squares);
+        random_free(rs);
+    }
+
+    /*
+     * Analyse the map to find a canonical line segment
+     * corresponding to each edge, and a canonical point
+     * corresponding to each region. The former are where we'll
+     * eventually put error markers; the latter are where we'll put
+     * per-region flags such as numbers (when in diagnostic mode).
+     */
+    {
+        int *bestx, *besty, *an, pass;
+        float *ax, *ay, *best;
+
+        ax = snewn(state->map->ngraph + n, float);
+        ay = snewn(state->map->ngraph + n, float);
+        an = snewn(state->map->ngraph + n, int);
+        bestx = snewn(state->map->ngraph + n, int);
+        besty = snewn(state->map->ngraph + n, int);
+        best = snewn(state->map->ngraph + n, float);
+
+        for (i = 0; i < state->map->ngraph + n; i++) {
+            bestx[i] = besty[i] = -1;
+            best[i] = (float)(2*(w+h)+1);
+            ax[i] = ay[i] = 0.0F;
+            an[i] = 0;
+        }
+
+        /*
+         * We make two passes over the map, finding all the line
+         * segments separating regions and all the suitable points
+         * within regions. In the first pass, we compute the
+         * _average_ x and y coordinate of all the points in a
+         * given class; in the second pass, for each such average
+         * point, we find the candidate closest to it and call that
+         * canonical.
+         * 
+         * Line segments are considered to have coordinates in
+         * their centre. Thus, at least one coordinate for any line
+         * segment is always something-and-a-half; so we store our
+         * coordinates as twice their normal value.
+         */
+        for (pass = 0; pass < 2; pass++) {
+            int x, y;
+
+            for (y = 0; y < h; y++)
+                for (x = 0; x < w; x++) {
+                    int ex[4], ey[4], ea[4], eb[4], en = 0;
+
+                    /*
+                     * Look for an edge to the right of this
+                     * square, an edge below it, and an edge in the
+                     * middle of it. Also look to see if the point
+                     * at the bottom right of this square is on an
+                     * edge (and isn't a place where more than two
+                     * regions meet).
+                     */
+                    if (x+1 < w) {
+                        /* right edge */
+                        ea[en] = state->map->map[RE * wh + y*w+x];
+                        eb[en] = state->map->map[LE * wh + y*w+(x+1)];
+                        ex[en] = (x+1)*2;
+                        ey[en] = y*2+1;
+                        en++;
+                    }
+                    if (y+1 < h) {
+                        /* bottom edge */
+                        ea[en] = state->map->map[BE * wh + y*w+x];
+                        eb[en] = state->map->map[TE * wh + (y+1)*w+x];
+                        ex[en] = x*2+1;
+                        ey[en] = (y+1)*2;
+                        en++;
+                    }
+                    /* diagonal edge */
+                    ea[en] = state->map->map[TE * wh + y*w+x];
+                    eb[en] = state->map->map[BE * wh + y*w+x];
+                    ex[en] = x*2+1;
+                    ey[en] = y*2+1;
+                    en++;
+
+                    if (x+1 < w && y+1 < h) {
+                        /* bottom right corner */
+                        int oct[8], othercol, nchanges;
+                        oct[0] = state->map->map[RE * wh + y*w+x];
+                        oct[1] = state->map->map[LE * wh + y*w+(x+1)];
+                        oct[2] = state->map->map[BE * wh + y*w+(x+1)];
+                        oct[3] = state->map->map[TE * wh + (y+1)*w+(x+1)];
+                        oct[4] = state->map->map[LE * wh + (y+1)*w+(x+1)];
+                        oct[5] = state->map->map[RE * wh + (y+1)*w+x];
+                        oct[6] = state->map->map[TE * wh + (y+1)*w+x];
+                        oct[7] = state->map->map[BE * wh + y*w+x];
+
+                        othercol = -1;
+                        nchanges = 0;
+                        for (i = 0; i < 8; i++) {
+                            if (oct[i] != oct[0]) {
+                                if (othercol < 0)
+                                    othercol = oct[i];
+                                else if (othercol != oct[i])
+                                    break;   /* three colours at this point */
+                            }
+                            if (oct[i] != oct[(i+1) & 7])
+                                nchanges++;
+                        }
+
+                        /*
+                         * Now if there are exactly two regions at
+                         * this point (not one, and not three or
+                         * more), and only two changes around the
+                         * loop, then this is a valid place to put
+                         * an error marker.
+                         */
+                        if (i == 8 && othercol >= 0 && nchanges == 2) {
+                            ea[en] = oct[0];
+                            eb[en] = othercol;
+                            ex[en] = (x+1)*2;
+                            ey[en] = (y+1)*2;
+                            en++;
+                        }
+
+                        /*
+                         * If there's exactly _one_ region at this
+                         * point, on the other hand, it's a valid
+                         * place to put a region centre.
+                         */
+                        if (othercol < 0) {
+                            ea[en] = eb[en] = oct[0];
+                            ex[en] = (x+1)*2;
+                            ey[en] = (y+1)*2;
+                            en++;
+                        }
+                    }
+
+                    /*
+                     * Now process the points we've found, one by
+                     * one.
+                     */
+                    for (i = 0; i < en; i++) {
+                        int emin = min(ea[i], eb[i]);
+                        int emax = max(ea[i], eb[i]);
+                        int gindex;
+
+                        if (emin != emax) {
+                            /* Graph edge */
+                            gindex =
+                                graph_edge_index(state->map->graph, n,
+                                                 state->map->ngraph, emin,
+                                                 emax);
+                        } else {
+                            /* Region number */
+                            gindex = state->map->ngraph + emin;
+                        }
+
+                        assert(gindex >= 0);
+
+                        if (pass == 0) {
+                            /*
+                             * In pass 0, accumulate the values
+                             * we'll use to compute the average
+                             * positions.
+                             */
+                            ax[gindex] += ex[i];
+                            ay[gindex] += ey[i];
+                            an[gindex] += 1;
+                        } else {
+                            /*
+                             * In pass 1, work out whether this
+                             * point is closer to the average than
+                             * the last one we've seen.
+                             */
+                            float dx, dy, d;
+
+                            assert(an[gindex] > 0);
+                            dx = ex[i] - ax[gindex];
+                            dy = ey[i] - ay[gindex];
+                            d = (float)sqrt(dx*dx + dy*dy);
+                            if (d < best[gindex]) {
+                                best[gindex] = d;
+                                bestx[gindex] = ex[i];
+                                besty[gindex] = ey[i];
+                            }
+                        }
+                    }
+                }
+
+            if (pass == 0) {
+                for (i = 0; i < state->map->ngraph + n; i++)
+                    if (an[i] > 0) {
+                        ax[i] /= an[i];
+                        ay[i] /= an[i];
+                    }
+            }
+        }
+
+        state->map->edgex = snewn(state->map->ngraph, int);
+        state->map->edgey = snewn(state->map->ngraph, int);
+        memcpy(state->map->edgex, bestx, state->map->ngraph * sizeof(int));
+        memcpy(state->map->edgey, besty, state->map->ngraph * sizeof(int));
+
+        state->map->regionx = snewn(n, int);
+        state->map->regiony = snewn(n, int);
+        memcpy(state->map->regionx, bestx + state->map->ngraph, n*sizeof(int));
+        memcpy(state->map->regiony, besty + state->map->ngraph, n*sizeof(int));
+
+        for (i = 0; i < state->map->ngraph; i++)
+            if (state->map->edgex[i] < 0) {
+                /* Find the other representation of this edge. */
+                int e = state->map->graph[i];
+                int iprime = graph_edge_index(state->map->graph, n,
+                                              state->map->ngraph, e%n, e/n);
+                assert(state->map->edgex[iprime] >= 0);
+                state->map->edgex[i] = state->map->edgex[iprime];
+                state->map->edgey[i] = state->map->edgey[iprime];
+            }
+
+        sfree(ax);
+        sfree(ay);
+        sfree(an);
+        sfree(best);
+        sfree(bestx);
+        sfree(besty);
+    }
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->p = state->p;
+    ret->colouring = snewn(state->p.n, int);
+    memcpy(ret->colouring, state->colouring, state->p.n * sizeof(int));
+    ret->pencil = snewn(state->p.n, int);
+    memcpy(ret->pencil, state->pencil, state->p.n * sizeof(int));
+    ret->map = state->map;
+    ret->map->refcount++;
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (--state->map->refcount <= 0) {
+        sfree(state->map->map);
+        sfree(state->map->graph);
+        sfree(state->map->immutable);
+        sfree(state->map->edgex);
+        sfree(state->map->edgey);
+        sfree(state->map->regionx);
+        sfree(state->map->regiony);
+        sfree(state->map);
+    }
+    sfree(state->pencil);
+    sfree(state->colouring);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    if (!aux) {
+        /*
+         * Use the solver.
+         */
+        int *colouring;
+        struct solver_scratch *sc;
+        int sret;
+        int i;
+        char *ret, buf[80];
+        int retlen, retsize;
+
+        colouring = snewn(state->map->n, int);
+        memcpy(colouring, state->colouring, state->map->n * sizeof(int));
+
+        sc = new_scratch(state->map->graph, state->map->n, state->map->ngraph);
+        sret = map_solver(sc, state->map->graph, state->map->n,
+                         state->map->ngraph, colouring, DIFFCOUNT-1);
+        free_scratch(sc);
+
+        if (sret != 1) {
+            sfree(colouring);
+            if (sret == 0)
+                *error = "Puzzle is inconsistent";
+            else
+                *error = "Unable to find a unique solution for this puzzle";
+            return NULL;
+        }
+
+        retsize = 64;
+        ret = snewn(retsize, char);
+        strcpy(ret, "S");
+        retlen = 1;
+
+        for (i = 0; i < state->map->n; i++) {
+            int len;
+
+            assert(colouring[i] >= 0);
+            if (colouring[i] == currstate->colouring[i])
+                continue;
+            assert(!state->map->immutable[i]);
+
+            len = sprintf(buf, ";%d:%d", colouring[i], i);
+            if (retlen + len >= retsize) {
+                retsize = retlen + len + 256;
+                ret = sresize(ret, retsize, char);
+            }
+            strcpy(ret + retlen, buf);
+            retlen += len;
+        }
+
+        sfree(colouring);
+
+        return ret;
+    }
+    return dupstr(aux);
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+struct game_ui {
+    /*
+     * drag_colour:
+     * 
+     *  - -2 means no drag currently active.
+     *  - >=0 means we're dragging a solid colour.
+     *  - -1 means we're dragging a blank space, and drag_pencil
+     *    might or might not add some pencil-mark stipples to that.
+     */
+    int drag_colour;
+    int drag_pencil;
+    int dragx, dragy;
+    int show_numbers;
+
+    int cur_x, cur_y, cur_visible, cur_moved, cur_lastmove;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->dragx = ui->dragy = -1;
+    ui->drag_colour = -2;
+    ui->drag_pencil = 0;
+    ui->show_numbers = FALSE;
+    ui->cur_x = ui->cur_y = ui->cur_visible = ui->cur_moved = 0;
+    ui->cur_lastmove = 0;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int tilesize;
+    unsigned long *drawn, *todraw;
+    int started;
+    int dragx, dragy, drag_visible;
+    blitter *bl;
+};
+
+/* Flags in `drawn'. */
+#define ERR_BASE      0x00800000L
+#define ERR_MASK      0xFF800000L
+#define PENCIL_T_BASE 0x00080000L
+#define PENCIL_T_MASK 0x00780000L
+#define PENCIL_B_BASE 0x00008000L
+#define PENCIL_B_MASK 0x00078000L
+#define PENCIL_MASK   0x007F8000L
+#define SHOW_NUMBERS  0x00004000L
+
+#define TILESIZE (ds->tilesize)
+#define BORDER (TILESIZE)
+#define COORD(x)  ( (x) * TILESIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILESIZE) / TILESIZE - 1 )
+
+ /*
+  * EPSILON_FOO are epsilons added to absolute cursor position by
+  * cursor movement, such that in pathological cases (e.g. a very
+  * small diamond-shaped area) it's relatively easy to select the
+  * region you wanted.
+  */
+
+#define EPSILON_X(button) (((button) == CURSOR_RIGHT) ? +1 : \
+                           ((button) == CURSOR_LEFT)  ? -1 : 0)
+#define EPSILON_Y(button) (((button) == CURSOR_DOWN)  ? +1 : \
+                           ((button) == CURSOR_UP)    ? -1 : 0)
+
+
+static int region_from_coords(const game_state *state,
+                              const game_drawstate *ds, int x, int y)
+{
+    int w = state->p.w, h = state->p.h, wh = w*h /*, n = state->p.n */;
+    int tx = FROMCOORD(x), ty = FROMCOORD(y);
+    int dx = x - COORD(tx), dy = y - COORD(ty);
+    int quadrant;
+
+    if (tx < 0 || tx >= w || ty < 0 || ty >= h)
+        return -1;                     /* border */
+
+    quadrant = 2 * (dx > dy) + (TILESIZE - dx > dy);
+    quadrant = (quadrant == 0 ? BE :
+                quadrant == 1 ? LE :
+                quadrant == 2 ? RE : TE);
+
+    return state->map->map[quadrant * wh + ty*w+tx];
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    char *bufp, buf[256];
+    int alt_button;
+
+    /*
+     * Enable or disable numeric labels on regions.
+     */
+    if (button == 'l' || button == 'L') {
+        ui->show_numbers = !ui->show_numbers;
+        return "";
+    }
+
+    if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->p.w, state->p.h, 0);
+        ui->cur_visible = 1;
+        ui->cur_moved = 1;
+        ui->cur_lastmove = button;
+        ui->dragx = COORD(ui->cur_x) + TILESIZE/2 + EPSILON_X(button);
+        ui->dragy = COORD(ui->cur_y) + TILESIZE/2 + EPSILON_Y(button);
+        return "";
+    }
+    if (IS_CURSOR_SELECT(button)) {
+        if (!ui->cur_visible) {
+            ui->dragx = COORD(ui->cur_x) + TILESIZE/2 + EPSILON_X(ui->cur_lastmove);
+            ui->dragy = COORD(ui->cur_y) + TILESIZE/2 + EPSILON_Y(ui->cur_lastmove);
+            ui->cur_visible = 1;
+            return "";
+        }
+        if (ui->drag_colour == -2) { /* not currently cursor-dragging, start. */
+            int r = region_from_coords(state, ds, ui->dragx, ui->dragy);
+            if (r >= 0) {
+                ui->drag_colour = state->colouring[r];
+                ui->drag_pencil = (ui->drag_colour >= 0) ? 0 : state->pencil[r];
+            } else {
+                ui->drag_colour = -1;
+                ui->drag_pencil = 0;
+            }
+            ui->cur_moved = 0;
+            return "";
+        } else { /* currently cursor-dragging; drop the colour in the new region. */
+            x = COORD(ui->cur_x) + TILESIZE/2 + EPSILON_X(ui->cur_lastmove);
+            y = COORD(ui->cur_y) + TILESIZE/2 + EPSILON_Y(ui->cur_lastmove);
+            alt_button = (button == CURSOR_SELECT2) ? 1 : 0;
+            /* Double-select removes current colour. */
+            if (!ui->cur_moved) ui->drag_colour = -1;
+            goto drag_dropped;
+        }
+    }
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        int r = region_from_coords(state, ds, x, y);
+
+        if (r >= 0) {
+            ui->drag_colour = state->colouring[r];
+            ui->drag_pencil = state->pencil[r];
+            if (ui->drag_colour >= 0)
+                ui->drag_pencil = 0;  /* should be already, but double-check */
+        } else {
+            ui->drag_colour = -1;
+            ui->drag_pencil = 0;
+        }
+        ui->dragx = x;
+        ui->dragy = y;
+        ui->cur_visible = 0;
+        return "";
+    }
+
+    if ((button == LEFT_DRAG || button == RIGHT_DRAG) &&
+        ui->drag_colour > -2) {
+        ui->dragx = x;
+        ui->dragy = y;
+        return "";
+    }
+
+    if ((button == LEFT_RELEASE || button == RIGHT_RELEASE) &&
+        ui->drag_colour > -2) {
+        alt_button = (button == RIGHT_RELEASE) ? 1 : 0;
+        goto drag_dropped;
+    }
+
+    return NULL;
+
+drag_dropped:
+    {
+        int r = region_from_coords(state, ds, x, y);
+        int c = ui->drag_colour;
+        int p = ui->drag_pencil;
+        int oldp;
+
+        /*
+         * Cancel the drag, whatever happens.
+         */
+        ui->drag_colour = -2;
+
+        if (r < 0)
+            return "";                 /* drag into border; do nothing else */
+
+        if (state->map->immutable[r])
+            return "";                 /* can't change this region */
+
+        if (state->colouring[r] == c && state->pencil[r] == p)
+            return "";                 /* don't _need_ to change this region */
+
+        if (alt_button) {
+            if (state->colouring[r] >= 0) {
+                /* Can't pencil on a coloured region */
+                return "";
+            } else if (c >= 0) {
+                /* Right-dragging from colour to blank toggles one pencil */
+                p = state->pencil[r] ^ (1 << c);
+                c = -1;
+            }
+            /* Otherwise, right-dragging from blank to blank is equivalent
+             * to left-dragging. */
+        }
+
+        bufp = buf;
+        oldp = state->pencil[r];
+        if (c != state->colouring[r]) {
+            bufp += sprintf(bufp, ";%c:%d", (int)(c < 0 ? 'C' : '0' + c), r);
+            if (c >= 0)
+                oldp = 0;
+        }
+        if (p != oldp) {
+            int i;
+            for (i = 0; i < FOUR; i++)
+                if ((oldp ^ p) & (1 << i))
+                    bufp += sprintf(bufp, ";p%c:%d", (int)('0' + i), r);
+        }
+
+        return dupstr(buf+1);          /* ignore first semicolon */
+    }
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int n = state->p.n;
+    game_state *ret = dup_game(state);
+    int c, k, adv, i;
+
+    while (*move) {
+        int pencil = FALSE;
+
+        c = *move;
+        if (c == 'p') {
+            pencil = TRUE;
+            c = *++move;
+        }
+        if ((c == 'C' || (c >= '0' && c < '0'+FOUR)) &&
+            sscanf(move+1, ":%d%n", &k, &adv) == 1 &&
+            k >= 0 && k < state->p.n) {
+            move += 1 + adv;
+            if (pencil) {
+                if (ret->colouring[k] >= 0) {
+                    free_game(ret);
+                    return NULL;
+                }
+                if (c == 'C')
+                    ret->pencil[k] = 0;
+                else
+                    ret->pencil[k] ^= 1 << (c - '0');
+            } else {
+                ret->colouring[k] = (c == 'C' ? -1 : c - '0');
+                ret->pencil[k] = 0;
+            }
+        } else if (*move == 'S') {
+            move++;
+            ret->cheated = TRUE;
+        } else {
+            free_game(ret);
+            return NULL;
+        }
+
+        if (*move && *move != ';') {
+            free_game(ret);
+            return NULL;
+        }
+        if (*move)
+            move++;
+    }
+
+    /*
+     * Check for completion.
+     */
+    if (!ret->completed) {
+        int ok = TRUE;
+
+        for (i = 0; i < n; i++)
+            if (ret->colouring[i] < 0) {
+                ok = FALSE;
+                break;
+            }
+
+        if (ok) {
+            for (i = 0; i < ret->map->ngraph; i++) {
+                int j = ret->map->graph[i] / n;
+                int k = ret->map->graph[i] % n;
+                if (ret->colouring[j] == ret->colouring[k]) {
+                    ok = FALSE;
+                    break;
+                }
+            }
+        }
+
+        if (ok)
+            ret->completed = TRUE;
+    }
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = params->w * TILESIZE + 2 * BORDER + 1;
+    *y = params->h * TILESIZE + 2 * BORDER + 1;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+
+    assert(!ds->bl);                   /* set_size is never called twice */
+    ds->bl = blitter_new(dr, TILESIZE+3, TILESIZE+3);
+}
+
+const float map_colours[FOUR][3] = {
+#ifdef VIVID_COLOURS
+    /* Use more vivid colours (e.g. on the Pocket PC) */
+    {0.75F, 0.25F, 0.25F},
+    {0.3F,  0.7F,  0.3F},
+    {0.3F,  0.3F,  0.7F},
+    {0.85F, 0.85F, 0.1F},
+#else
+    {0.7F, 0.5F, 0.4F},
+    {0.8F, 0.7F, 0.4F},
+    {0.5F, 0.6F, 0.4F},
+    {0.55F, 0.45F, 0.35F},
+#endif
+};
+const int map_hatching[FOUR] = {
+    HATCH_VERT, HATCH_SLASH, HATCH_HORIZ, HATCH_BACKSLASH
+};
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_GRID * 3 + 0] = 0.0F;
+    ret[COL_GRID * 3 + 1] = 0.0F;
+    ret[COL_GRID * 3 + 2] = 0.0F;
+
+    memcpy(ret + COL_0 * 3, map_colours[0], 3 * sizeof(float));
+    memcpy(ret + COL_1 * 3, map_colours[1], 3 * sizeof(float));
+    memcpy(ret + COL_2 * 3, map_colours[2], 3 * sizeof(float));
+    memcpy(ret + COL_3 * 3, map_colours[3], 3 * sizeof(float));
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_ERRTEXT * 3 + 0] = 1.0F;
+    ret[COL_ERRTEXT * 3 + 1] = 1.0F;
+    ret[COL_ERRTEXT * 3 + 2] = 1.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = 0;
+    ds->drawn = snewn(state->p.w * state->p.h, unsigned long);
+    for (i = 0; i < state->p.w * state->p.h; i++)
+        ds->drawn[i] = 0xFFFFL;
+    ds->todraw = snewn(state->p.w * state->p.h, unsigned long);
+    ds->started = FALSE;
+    ds->bl = NULL;
+    ds->drag_visible = FALSE;
+    ds->dragx = ds->dragy = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->drawn);
+    sfree(ds->todraw);
+    if (ds->bl)
+        blitter_free(dr, ds->bl);
+    sfree(ds);
+}
+
+static void draw_error(drawing *dr, game_drawstate *ds, int x, int y)
+{
+    int coords[8];
+    int yext, xext;
+
+    /*
+     * Draw a diamond.
+     */
+    coords[0] = x - TILESIZE*2/5;
+    coords[1] = y;
+    coords[2] = x;
+    coords[3] = y - TILESIZE*2/5;
+    coords[4] = x + TILESIZE*2/5;
+    coords[5] = y;
+    coords[6] = x;
+    coords[7] = y + TILESIZE*2/5;
+    draw_polygon(dr, coords, 4, COL_ERROR, COL_GRID);
+
+    /*
+     * Draw an exclamation mark in the diamond. This turns out to
+     * look unpleasantly off-centre if done via draw_text, so I do
+     * it by hand on the basis that exclamation marks aren't that
+     * difficult to draw...
+     */
+    xext = TILESIZE/16;
+    yext = TILESIZE*2/5 - (xext*2+2);
+    draw_rect(dr, x-xext, y-yext, xext*2+1, yext*2+1 - (xext*3),
+              COL_ERRTEXT);
+    draw_rect(dr, x-xext, y+yext-xext*2+1, xext*2+1, xext*2, COL_ERRTEXT);
+}
+
+static void draw_square(drawing *dr, game_drawstate *ds,
+                        const game_params *params, struct map *map,
+                        int x, int y, unsigned long v)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    int tv, bv, xo, yo, i, j, oldj;
+    unsigned long errs, pencil, show_numbers;
+
+    errs = v & ERR_MASK;
+    v &= ~ERR_MASK;
+    pencil = v & PENCIL_MASK;
+    v &= ~PENCIL_MASK;
+    show_numbers = v & SHOW_NUMBERS;
+    v &= ~SHOW_NUMBERS;
+    tv = v / FIVE;
+    bv = v % FIVE;
+
+    clip(dr, COORD(x), COORD(y), TILESIZE, TILESIZE);
+
+    /*
+     * Draw the region colour.
+     */
+    draw_rect(dr, COORD(x), COORD(y), TILESIZE, TILESIZE,
+              (tv == FOUR ? COL_BACKGROUND : COL_0 + tv));
+    /*
+     * Draw the second region colour, if this is a diagonally
+     * divided square.
+     */
+    if (map->map[TE * wh + y*w+x] != map->map[BE * wh + y*w+x]) {
+        int coords[6];
+        coords[0] = COORD(x)-1;
+        coords[1] = COORD(y+1)+1;
+        if (map->map[LE * wh + y*w+x] == map->map[TE * wh + y*w+x])
+            coords[2] = COORD(x+1)+1;
+        else
+            coords[2] = COORD(x)-1;
+        coords[3] = COORD(y)-1;
+        coords[4] = COORD(x+1)+1;
+        coords[5] = COORD(y+1)+1;
+        draw_polygon(dr, coords, 3,
+                     (bv == FOUR ? COL_BACKGROUND : COL_0 + bv), COL_GRID);
+    }
+
+    /*
+     * Draw `pencil marks'. Currently we arrange these in a square
+     * formation, which means we may be in trouble if the value of
+     * FOUR changes later...
+     */
+    assert(FOUR == 4);
+    for (yo = 0; yo < 4; yo++)
+        for (xo = 0; xo < 4; xo++) {
+            int te = map->map[TE * wh + y*w+x];
+            int e, ee, c;
+
+            e = (yo < xo && yo < 3-xo ? TE :
+                 yo > xo && yo > 3-xo ? BE :
+                 xo < 2 ? LE : RE);
+            ee = map->map[e * wh + y*w+x];
+
+            if (xo != (yo * 2 + 1) % 5)
+                continue;
+            c = yo;
+
+            if (!(pencil & ((ee == te ? PENCIL_T_BASE : PENCIL_B_BASE) << c)))
+                continue;
+
+            if (yo == xo &&
+                (map->map[TE * wh + y*w+x] != map->map[LE * wh + y*w+x]))
+                continue;              /* avoid TL-BR diagonal line */
+            if (yo == 3-xo &&
+                (map->map[TE * wh + y*w+x] != map->map[RE * wh + y*w+x]))
+                continue;              /* avoid BL-TR diagonal line */
+
+            draw_circle(dr, COORD(x) + (xo+1)*TILESIZE/5,
+                        COORD(y) + (yo+1)*TILESIZE/5,
+                        TILESIZE/7, COL_0 + c, COL_0 + c);
+        }
+
+    /*
+     * Draw the grid lines, if required.
+     */
+    if (x <= 0 || map->map[RE*wh+y*w+(x-1)] != map->map[LE*wh+y*w+x])
+        draw_rect(dr, COORD(x), COORD(y), 1, TILESIZE, COL_GRID);
+    if (y <= 0 || map->map[BE*wh+(y-1)*w+x] != map->map[TE*wh+y*w+x])
+        draw_rect(dr, COORD(x), COORD(y), TILESIZE, 1, COL_GRID);
+    if (x <= 0 || y <= 0 ||
+        map->map[RE*wh+(y-1)*w+(x-1)] != map->map[TE*wh+y*w+x] ||
+        map->map[BE*wh+(y-1)*w+(x-1)] != map->map[LE*wh+y*w+x])
+        draw_rect(dr, COORD(x), COORD(y), 1, 1, COL_GRID);
+
+    /*
+     * Draw error markers.
+     */
+    for (yo = 0; yo < 3; yo++)
+        for (xo = 0; xo < 3; xo++)
+            if (errs & (ERR_BASE << (yo*3+xo)))
+                draw_error(dr, ds,
+                           (COORD(x)*2+TILESIZE*xo)/2,
+                           (COORD(y)*2+TILESIZE*yo)/2);
+
+    /*
+     * Draw region numbers, if desired.
+     */
+    if (show_numbers) {
+        oldj = -1;
+        for (i = 0; i < 2; i++) {
+            j = map->map[(i?BE:TE)*wh+y*w+x];
+            if (oldj == j)
+                continue;
+            oldj = j;
+
+            xo = map->regionx[j] - 2*x;
+            yo = map->regiony[j] - 2*y;
+            if (xo >= 0 && xo <= 2 && yo >= 0 && yo <= 2) {
+                char buf[80];
+                sprintf(buf, "%d", j);
+                draw_text(dr, (COORD(x)*2+TILESIZE*xo)/2,
+                          (COORD(y)*2+TILESIZE*yo)/2,
+                          FONT_VARIABLE, 3*TILESIZE/5,
+                          ALIGN_HCENTRE|ALIGN_VCENTRE,
+                          COL_GRID, buf);
+            }
+        }
+    }
+
+    unclip(dr);
+
+    draw_update(dr, COORD(x), COORD(y), TILESIZE, TILESIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->p.w, h = state->p.h, wh = w*h, n = state->p.n;
+    int x, y, i;
+    int flash;
+
+    if (ds->drag_visible) {
+        blitter_load(dr, ds->bl, ds->dragx, ds->dragy);
+        draw_update(dr, ds->dragx, ds->dragy, TILESIZE + 3, TILESIZE + 3);
+        ds->drag_visible = FALSE;
+    }
+
+    /*
+     * The initial contents of the window are not guaranteed and
+     * can vary with front ends. To be on the safe side, all games
+     * should start by drawing a big background-colour rectangle
+     * covering the whole window.
+     */
+    if (!ds->started) {
+        int ww, wh;
+
+        game_compute_size(&state->p, TILESIZE, &ww, &wh);
+        draw_rect(dr, 0, 0, ww, wh, COL_BACKGROUND);
+        draw_rect(dr, COORD(0), COORD(0), w*TILESIZE+1, h*TILESIZE+1,
+                  COL_GRID);
+
+        draw_update(dr, 0, 0, ww, wh);
+        ds->started = TRUE;
+    }
+
+    if (flashtime) {
+        if (flash_type == 1)
+            flash = (int)(flashtime * FOUR / flash_length);
+        else
+            flash = 1 + (int)(flashtime * THREE / flash_length);
+    } else
+        flash = -1;
+
+    /*
+     * Set up the `todraw' array.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int tv = state->colouring[state->map->map[TE * wh + y*w+x]];
+            int bv = state->colouring[state->map->map[BE * wh + y*w+x]];
+            unsigned long v;
+
+            if (tv < 0)
+                tv = FOUR;
+            if (bv < 0)
+                bv = FOUR;
+
+            if (flash >= 0) {
+                if (flash_type == 1) {
+                    if (tv == flash)
+                        tv = FOUR;
+                    if (bv == flash)
+                        bv = FOUR;
+                } else if (flash_type == 2) {
+                    if (flash % 2)
+                        tv = bv = FOUR;
+                } else {
+                    if (tv != FOUR)
+                        tv = (tv + flash) % FOUR;
+                    if (bv != FOUR)
+                        bv = (bv + flash) % FOUR;
+                }
+            }
+
+            v = tv * FIVE + bv;
+
+            /*
+             * Add pencil marks.
+             */
+            for (i = 0; i < FOUR; i++) {
+                if (state->colouring[state->map->map[TE * wh + y*w+x]] < 0 &&
+                    (state->pencil[state->map->map[TE * wh + y*w+x]] & (1<<i)))
+                    v |= PENCIL_T_BASE << i;
+                if (state->colouring[state->map->map[BE * wh + y*w+x]] < 0 &&
+                    (state->pencil[state->map->map[BE * wh + y*w+x]] & (1<<i)))
+                    v |= PENCIL_B_BASE << i;
+            }
+
+            if (ui->show_numbers)
+                v |= SHOW_NUMBERS;
+
+            ds->todraw[y*w+x] = v;
+        }
+
+    /*
+     * Add error markers to the `todraw' array.
+     */
+    for (i = 0; i < state->map->ngraph; i++) {
+        int v1 = state->map->graph[i] / n;
+        int v2 = state->map->graph[i] % n;
+        int xo, yo;
+
+        if (state->colouring[v1] < 0 || state->colouring[v2] < 0)
+            continue;
+        if (state->colouring[v1] != state->colouring[v2])
+            continue;
+
+        x = state->map->edgex[i];
+        y = state->map->edgey[i];
+
+        xo = x % 2; x /= 2;
+        yo = y % 2; y /= 2;
+
+        ds->todraw[y*w+x] |= ERR_BASE << (yo*3+xo);
+        if (xo == 0) {
+            assert(x > 0);
+            ds->todraw[y*w+(x-1)] |= ERR_BASE << (yo*3+2);
+        }
+        if (yo == 0) {
+            assert(y > 0);
+            ds->todraw[(y-1)*w+x] |= ERR_BASE << (2*3+xo);
+        }
+        if (xo == 0 && yo == 0) {
+            assert(x > 0 && y > 0);
+            ds->todraw[(y-1)*w+(x-1)] |= ERR_BASE << (2*3+2);
+        }
+    }
+
+    /*
+     * Now actually draw everything.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            unsigned long v = ds->todraw[y*w+x];
+            if (ds->drawn[y*w+x] != v) {
+                draw_square(dr, ds, &state->p, state->map, x, y, v);
+                ds->drawn[y*w+x] = v;
+            }
+        }
+
+    /*
+     * Draw the dragged colour blob if any.
+     */
+    if ((ui->drag_colour > -2) || ui->cur_visible) {
+        int bg, iscur = 0;
+        if (ui->drag_colour >= 0)
+            bg = COL_0 + ui->drag_colour;
+        else if (ui->drag_colour == -1) {
+            bg = COL_BACKGROUND;
+        } else {
+            int r = region_from_coords(state, ds, ui->dragx, ui->dragy);
+            int c = (r < 0) ? -1 : state->colouring[r];
+            assert(ui->cur_visible);
+            /*bg = COL_GRID;*/
+            bg = (c < 0) ? COL_BACKGROUND : COL_0 + c;
+            iscur = 1;
+        }
+
+        ds->dragx = ui->dragx - TILESIZE/2 - 2;
+        ds->dragy = ui->dragy - TILESIZE/2 - 2;
+        blitter_save(dr, ds->bl, ds->dragx, ds->dragy);
+        draw_circle(dr, ui->dragx, ui->dragy,
+                    iscur ? TILESIZE/4 : TILESIZE/2, bg, COL_GRID);
+        for (i = 0; i < FOUR; i++)
+            if (ui->drag_pencil & (1 << i))
+                draw_circle(dr, ui->dragx + ((i*4+2)%10-3) * TILESIZE/10,
+                            ui->dragy + (i*2-3) * TILESIZE/10,
+                            TILESIZE/8, COL_0 + i, COL_0 + i);
+        draw_update(dr, ds->dragx, ds->dragy, TILESIZE + 3, TILESIZE + 3);
+        ds->drag_visible = TRUE;
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated) {
+        if (flash_type < 0) {
+            char *env = getenv("MAP_ALTERNATIVE_FLASH");
+            if (env)
+                flash_type = atoi(env);
+            else
+                flash_type = 0;
+            flash_length = (flash_type == 1 ? 0.50F : 0.30F);
+        }
+        return flash_length;
+    } else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 4mm squares by default, I think. Simplest way to
+     * compute this size is to compute the pixel puzzle size at a
+     * given tile size and then scale.
+     */
+    game_compute_size(params, 400, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->p.w, h = state->p.h, wh = w*h, n = state->p.n;
+    int ink, c[FOUR], i;
+    int x, y, r;
+    int *coords, ncoords, coordsize;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    /* We can't call game_set_size() here because we don't want a blitter */
+    ads.tilesize = tilesize;
+
+    ink = print_mono_colour(dr, 0);
+    for (i = 0; i < FOUR; i++)
+        c[i] = print_rgb_hatched_colour(dr, map_colours[i][0],
+                                        map_colours[i][1], map_colours[i][2],
+                                        map_hatching[i]);
+
+    coordsize = 0;
+    coords = NULL;
+
+    print_line_width(dr, TILESIZE / 16);
+
+    /*
+     * Draw a single filled polygon around each region.
+     */
+    for (r = 0; r < n; r++) {
+        int octants[8], lastdir, d1, d2, ox, oy;
+
+        /*
+         * Start by finding a point on the region boundary. Any
+         * point will do. To do this, we'll search for a square
+         * containing the region and then decide which corner of it
+         * to use.
+         */
+        x = w;
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                if (state->map->map[wh*0+y*w+x] == r ||
+                    state->map->map[wh*1+y*w+x] == r ||
+                    state->map->map[wh*2+y*w+x] == r ||
+                    state->map->map[wh*3+y*w+x] == r)
+                    break;
+            }
+            if (x < w)
+                break;
+        }
+        assert(y < h && x < w);        /* we must have found one somewhere */
+        /*
+         * This is the first square in lexicographic order which
+         * contains part of this region. Therefore, one of the top
+         * two corners of the square must be what we're after. The
+         * only case in which it isn't the top left one is if the
+         * square is diagonally divided and the region is in the
+         * bottom right half.
+         */
+        if (state->map->map[wh*TE+y*w+x] != r &&
+            state->map->map[wh*LE+y*w+x] != r)
+            x++;                       /* could just as well have done y++ */
+
+        /*
+         * Now we have a point on the region boundary. Trace around
+         * the region until we come back to this point,
+         * accumulating coordinates for a polygon draw operation as
+         * we go.
+         */
+        lastdir = -1;
+        ox = x;
+        oy = y;
+        ncoords = 0;
+
+        do {
+            /*
+             * There are eight possible directions we could head in
+             * from here. We identify them by octant numbers, and
+             * we also use octant numbers to identify the spaces
+             * between them:
+             * 
+             *   6   7   0
+             *    \ 7|0 /
+             *     \ | /
+             *    6 \|/ 1
+             * 5-----+-----1
+             *    5 /|\ 2
+             *     / | \
+             *    / 4|3 \
+             *   4   3   2
+             */
+            octants[0] = x<w && y>0 ? state->map->map[wh*LE+(y-1)*w+x] : -1;
+            octants[1] = x<w && y>0 ? state->map->map[wh*BE+(y-1)*w+x] : -1;
+            octants[2] = x<w && y<h ? state->map->map[wh*TE+y*w+x] : -1;
+            octants[3] = x<w && y<h ? state->map->map[wh*LE+y*w+x] : -1;
+            octants[4] = x>0 && y<h ? state->map->map[wh*RE+y*w+(x-1)] : -1;
+            octants[5] = x>0 && y<h ? state->map->map[wh*TE+y*w+(x-1)] : -1;
+            octants[6] = x>0 && y>0 ? state->map->map[wh*BE+(y-1)*w+(x-1)] :-1;
+            octants[7] = x>0 && y>0 ? state->map->map[wh*RE+(y-1)*w+(x-1)] :-1;
+
+            d1 = d2 = -1;
+            for (i = 0; i < 8; i++)
+                if ((octants[i] == r) ^ (octants[(i+1)%8] == r)) {
+                    assert(d2 == -1);
+                    if (d1 == -1)
+                        d1 = i;
+                    else
+                        d2 = i;
+                }
+
+            assert(d1 != -1 && d2 != -1);
+            if (d1 == lastdir)
+                d1 = d2;
+
+            /*
+             * Now we're heading in direction d1. Save the current
+             * coordinates.
+             */
+            if (ncoords + 2 > coordsize) {
+                coordsize += 128;
+                coords = sresize(coords, coordsize, int);
+            }
+            coords[ncoords++] = COORD(x);
+            coords[ncoords++] = COORD(y);
+
+            /*
+             * Compute the new coordinates.
+             */
+            x += (d1 % 4 == 3 ? 0 : d1 < 4 ? +1 : -1);
+            y += (d1 % 4 == 1 ? 0 : d1 > 1 && d1 < 5 ? +1 : -1);
+            assert(x >= 0 && x <= w && y >= 0 && y <= h);
+
+            lastdir = d1 ^ 4;
+        } while (x != ox || y != oy);
+
+        draw_polygon(dr, coords, ncoords/2,
+                     state->colouring[r] >= 0 ?
+                     c[state->colouring[r]] : -1, ink);
+    }
+    sfree(coords);
+}
+
+#ifdef COMBINED
+#define thegame map
+#endif
+
+const struct game thegame = {
+    "Map", "games.map", "map",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    20, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, TRUE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err;
+    int grade = FALSE;
+    int ret, diff, really_verbose = FALSE;
+    struct solver_scratch *sc;
+    int i;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            really_verbose = TRUE;
+        } else if (!strcmp(p, "-g")) {
+            grade = TRUE;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-g | -v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    sc = new_scratch(s->map->graph, s->map->n, s->map->ngraph);
+
+    /*
+     * When solving an Easy puzzle, we don't want to bother the
+     * user with Hard-level deductions. For this reason, we grade
+     * the puzzle internally before doing anything else.
+     */
+    ret = -1;                          /* placate optimiser */
+    for (diff = 0; diff < DIFFCOUNT; diff++) {
+        for (i = 0; i < s->map->n; i++)
+            if (!s->map->immutable[i])
+                s->colouring[i] = -1;
+        ret = map_solver(sc, s->map->graph, s->map->n, s->map->ngraph,
+                         s->colouring, diff);
+        if (ret < 2)
+            break;
+    }
+
+    if (diff == DIFFCOUNT) {
+        if (grade)
+            printf("Difficulty rating: harder than Hard, or ambiguous\n");
+        else
+            printf("Unable to find a unique solution\n");
+    } else {
+        if (grade) {
+            if (ret == 0)
+                printf("Difficulty rating: impossible (no solution exists)\n");
+            else if (ret == 1)
+                printf("Difficulty rating: %s\n", map_diffnames[diff]);
+        } else {
+            verbose = really_verbose;
+            for (i = 0; i < s->map->n; i++)
+                if (!s->map->immutable[i])
+                    s->colouring[i] = -1;
+            ret = map_solver(sc, s->map->graph, s->map->n, s->map->ngraph,
+                             s->colouring, diff);
+            if (ret == 0)
+                printf("Puzzle is inconsistent\n");
+            else {
+                int col = 0;
+
+                for (i = 0; i < s->map->n; i++) {
+                    printf("%5d <- %c%c", i, colnames[s->colouring[i]],
+                           (col < 6 && i+1 < s->map->n ? ' ' : '\n'));
+                    if (++col == 7)
+                        col = 0;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/maxflow.c b/apps/plugins/puzzles/maxflow.c
new file mode 100644
index 0000000000..3a25654ff0
--- /dev/null
+++ b/apps/plugins/puzzles/maxflow.c
@@ -0,0 +1,461 @@
+/*
+ * Edmonds-Karp algorithm for finding a maximum flow and minimum
+ * cut in a network. Almost identical to the Ford-Fulkerson
+ * algorithm, but apparently using breadth-first search to find the
+ * _shortest_ augmenting path is a good way to guarantee
+ * termination and ensure the time complexity is not dependent on
+ * the actual value of the maximum flow. I don't understand why
+ * that should be, but it's claimed on the Internet that it's been
+ * proved, and that's good enough for me. I prefer BFS to DFS
+ * anyway :-)
+ */
+
+#include "rbassert.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "maxflow.h"
+
+#include "puzzles.h"                   /* for snewn/sfree */
+
+int maxflow_with_scratch(void *scratch, int nv, int source, int sink,
+                         int ne, const int *edges, const int *backedges,
+                         const int *capacity, int *flow, int *cut)
+{
+    int *todo = (int *)scratch;
+    int *prev = todo + nv;
+    int *firstedge = todo + 2*nv;
+    int *firstbackedge = todo + 3*nv;
+    int i, j, head, tail, from, to;
+    int totalflow;
+
+    /*
+     * Scan the edges array to find the index of the first edge
+     * from each node.
+     */
+    j = 0;
+    for (i = 0; i < ne; i++)
+        while (j <= edges[2*i])
+            firstedge[j++] = i;
+    while (j < nv)
+        firstedge[j++] = ne;
+    assert(j == nv);
+
+    /*
+     * Scan the backedges array to find the index of the first edge
+     * _to_ each node.
+     */
+    j = 0;
+    for (i = 0; i < ne; i++)
+        while (j <= edges[2*backedges[i]+1])
+            firstbackedge[j++] = i;
+    while (j < nv)
+        firstbackedge[j++] = ne;
+    assert(j == nv);
+
+    /*
+     * Start the flow off at zero on every edge.
+     */
+    for (i = 0; i < ne; i++)
+        flow[i] = 0;
+    totalflow = 0;
+
+    /*
+     * Repeatedly look for an augmenting path, and follow it.
+     */
+    while (1) {
+
+        /*
+         * Set up the prev array.
+         */
+        for (i = 0; i < nv; i++)
+            prev[i] = -1;
+
+        /*
+         * Initialise the to-do list for BFS.
+         */
+        head = tail = 0;
+        todo[tail++] = source;
+
+        /*
+         * Now do the BFS loop.
+         */
+        while (head < tail && prev[sink] <= 0) {
+            from = todo[head++];
+
+            /*
+             * Try all the forward edges out of node `from'. For a
+             * forward edge to be valid, it must have flow
+             * currently less than its capacity.
+             */
+            for (i = firstedge[from]; i < ne && edges[2*i] == from; i++) {
+                to = edges[2*i+1];
+                if (to == source || prev[to] >= 0)
+                    continue;
+                if (capacity[i] >= 0 && flow[i] >= capacity[i])
+                    continue;
+                /*
+                 * This is a valid augmenting edge. Visit node `to'.
+                 */
+                prev[to] = 2*i;
+                todo[tail++] = to;
+            }
+
+            /*
+             * Try all the backward edges into node `from'. For a
+             * backward edge to be valid, it must have flow
+             * currently greater than zero.
+             */
+            for (i = firstbackedge[from];
+                 j = backedges[i], i < ne && edges[2*j+1]==from; i++) {
+                to = edges[2*j];
+                if (to == source || prev[to] >= 0)
+                    continue;
+                if (flow[j] <= 0)
+                    continue;
+                /*
+                 * This is a valid augmenting edge. Visit node `to'.
+                 */
+                prev[to] = 2*j+1;
+                todo[tail++] = to;
+            }
+        }
+
+        /*
+         * If prev[sink] is non-null, we have found an augmenting
+         * path.
+         */
+        if (prev[sink] >= 0) {
+            int max;
+
+            /*
+             * Work backwards along the path figuring out the
+             * maximum flow we can add.
+             */
+            to = sink;
+            max = -1;
+            while (to != source) {
+                int spare;
+
+                /*
+                 * Find the edge we're currently moving along.
+                 */
+                i = prev[to];
+                from = edges[i];
+                assert(from != to);
+
+                /*
+                 * Determine the spare capacity of this edge.
+                 */
+                if (i & 1)
+                    spare = flow[i / 2];   /* backward edge */
+                else if (capacity[i / 2] >= 0)
+                    spare = capacity[i / 2] - flow[i / 2];   /* forward edge */
+                else
+                    spare = -1;        /* unlimited forward edge */
+
+                assert(spare != 0);
+
+                if (max < 0 || (spare >= 0 && spare < max))
+                    max = spare;
+
+                to = from;
+            }
+            /*
+             * Fail an assertion if max is still < 0, i.e. there is
+             * an entirely unlimited path from source to sink. Also
+             * max should not _be_ zero, because by construction
+             * this _should_ be an augmenting path.
+             */
+            assert(max > 0);
+
+            /*
+             * Now work backwards along the path again, this time
+             * actually adjusting the flow.
+             */
+            to = sink;
+            while (to != source) {
+                /*
+                 * Find the edge we're currently moving along.
+                 */
+                i = prev[to];
+                from = edges[i];
+                assert(from != to);
+
+                /*
+                 * Adjust the edge.
+                 */
+                if (i & 1)
+                    flow[i / 2] -= max;  /* backward edge */
+                else
+                    flow[i / 2] += max;  /* forward edge */
+
+                to = from;
+            }
+
+            /*
+             * And adjust the overall flow counter.
+             */
+            totalflow += max;
+
+            continue;
+        }
+
+        /*
+         * If we reach here, we have failed to find an augmenting
+         * path, which means we're done. Output the `cut' array if
+         * required, and leave.
+         */
+        if (cut) {
+            for (i = 0; i < nv; i++) {
+                if (i == source || prev[i] >= 0)
+                    cut[i] = 0;
+                else
+                    cut[i] = 1;
+            }
+        }
+        return totalflow;
+    }
+}
+
+int maxflow_scratch_size(int nv)
+{
+    return (nv * 4) * sizeof(int);
+}
+
+void maxflow_setup_backedges(int ne, const int *edges, int *backedges)
+{
+    int i, n;
+
+    for (i = 0; i < ne; i++)
+        backedges[i] = i;
+
+    /*
+     * We actually can't use the C qsort() function, because we'd
+     * need to pass `edges' as a context parameter to its
+     * comparator function. So instead I'm forced to implement my
+     * own sorting algorithm internally, which is a pest. I'll use
+     * heapsort, because I like it.
+     */
+
+#define LESS(i,j) ( (edges[2*(i)+1] < edges[2*(j)+1]) || \
+                    (edges[2*(i)+1] == edges[2*(j)+1] && \
+                     edges[2*(i)] < edges[2*(j)]) )
+#define PARENT(n) ( ((n)-1)/2 )
+#define LCHILD(n) ( 2*(n)+1 )
+#define RCHILD(n) ( 2*(n)+2 )
+#define SWAP(i,j) do { int swaptmp = (i); (i) = (j); (j) = swaptmp; } while (0)
+
+    /*
+     * Phase 1: build the heap. We want the _largest_ element at
+     * the top.
+     */
+    n = 0;
+    while (n < ne) {
+        n++;
+
+        /*
+         * Swap element n with its parent repeatedly to preserve
+         * the heap property.
+         */
+        i = n-1;
+
+        while (i > 0) {
+            int p = PARENT(i);
+
+            if (LESS(backedges[p], backedges[i])) {
+                SWAP(backedges[p], backedges[i]);
+                i = p;
+            } else
+                break;
+        }
+    }
+
+    /*
+     * Phase 2: repeatedly remove the largest element and stick it
+     * at the top of the array.
+     */
+    while (n > 0) {
+        /*
+         * The largest element is at position 0. Put it at the top,
+         * and swap the arbitrary element from that position into
+         * position 0.
+         */
+        n--;
+        SWAP(backedges[0], backedges[n]);
+
+        /*
+         * Now repeatedly move that arbitrary element down the heap
+         * by swapping it with the more suitable of its children.
+         */
+        i = 0;
+        while (1) {
+            int lc, rc;
+
+            lc = LCHILD(i);
+            rc = RCHILD(i);
+
+            if (lc >= n)
+                break;                 /* we've hit bottom */
+
+            if (rc >= n) {
+                /*
+                 * Special case: there is only one child to check.
+                 */
+                if (LESS(backedges[i], backedges[lc]))
+                    SWAP(backedges[i], backedges[lc]);
+
+                /* _Now_ we've hit bottom. */
+                break;
+            } else {
+                /*
+                 * The common case: there are two children and we
+                 * must check them both.
+                 */
+                if (LESS(backedges[i], backedges[lc]) ||
+                    LESS(backedges[i], backedges[rc])) {
+                    /*
+                     * Pick the more appropriate child to swap with
+                     * (i.e. the one which would want to be the
+                     * parent if one were above the other - as one
+                     * is about to be).
+                     */
+                    if (LESS(backedges[lc], backedges[rc])) {
+                        SWAP(backedges[i], backedges[rc]);
+                        i = rc;
+                    } else {
+                        SWAP(backedges[i], backedges[lc]);
+                        i = lc;
+                    }
+                } else {
+                    /* This element is in the right place; we're done. */
+                    break;
+                }
+            }
+        }
+    }
+
+#undef LESS
+#undef PARENT
+#undef LCHILD
+#undef RCHILD
+#undef SWAP
+
+}
+
+int maxflow(int nv, int source, int sink,
+            int ne, const int *edges, const int *capacity,
+            int *flow, int *cut)
+{
+    void *scratch;
+    int *backedges;
+    int size;
+    int ret;
+
+    /*
+     * Allocate the space.
+     */
+    size = ne * sizeof(int) + maxflow_scratch_size(nv);
+    backedges = smalloc(size);
+    if (!backedges)
+        return -1;
+    scratch = backedges + ne;
+
+    /*
+     * Set up the backedges array.
+     */
+    maxflow_setup_backedges(ne, edges, backedges);
+
+    /*
+     * Call the main function.
+     */
+    ret = maxflow_with_scratch(scratch, nv, source, sink, ne, edges,
+                               backedges, capacity, flow, cut);
+
+    /*
+     * Free the scratch space.
+     */
+    sfree(backedges);
+
+    /*
+     * And we're done.
+     */
+    return ret;
+}
+
+#ifdef TESTMODE
+
+#define MAXEDGES 256
+#define MAXVERTICES 128
+#define ADDEDGE(i,j) do{edges[ne*2] = (i); edges[ne*2+1] = (j); ne++;}while(0)
+
+int compare_edge(const void *av, const void *bv)
+{
+    const int *a = (const int *)av;
+    const int *b = (const int *)bv;
+
+    if (a[0] < b[0])
+        return -1;
+    else if (a[0] > b[0])
+        return +1;
+    else if (a[1] < b[1])
+        return -1;
+    else if (a[1] > b[1])
+        return +1;
+    else
+        return 0;
+}
+
+int main(void)
+{
+    int edges[MAXEDGES*2], ne, nv;
+    int capacity[MAXEDGES], flow[MAXEDGES], cut[MAXVERTICES];
+    int source, sink, p, q, i, j, ret;
+
+    /*
+     * Use this algorithm to find a maximal complete matching in a
+     * bipartite graph.
+     */
+    ne = 0;
+    nv = 0;
+    source = nv++;
+    p = nv;
+    nv += 5;
+    q = nv;
+    nv += 5;
+    sink = nv++;
+    for (i = 0; i < 5; i++) {
+        capacity[ne] = 1;
+        ADDEDGE(source, p+i);
+    }
+    for (i = 0; i < 5; i++) {
+        capacity[ne] = 1;
+        ADDEDGE(q+i, sink);
+    }
+    j = ne;
+    capacity[ne] = 1; ADDEDGE(p+0,q+0);
+    capacity[ne] = 1; ADDEDGE(p+1,q+0);
+    capacity[ne] = 1; ADDEDGE(p+1,q+1);
+    capacity[ne] = 1; ADDEDGE(p+2,q+1);
+    capacity[ne] = 1; ADDEDGE(p+2,q+2);
+    capacity[ne] = 1; ADDEDGE(p+3,q+2);
+    capacity[ne] = 1; ADDEDGE(p+3,q+3);
+    capacity[ne] = 1; ADDEDGE(p+4,q+3);
+    /* capacity[ne] = 1; ADDEDGE(p+2,q+4); */
+    qsort(edges, ne, 2*sizeof(int), compare_edge);
+
+    ret = maxflow(nv, source, sink, ne, edges, capacity, flow, cut);
+
+    printf("ret = %d\n", ret);
+
+    for (i = 0; i < ne; i++)
+        printf("flow %d: %d -> %d\n", flow[i], edges[2*i], edges[2*i+1]);
+
+    for (i = 0; i < nv; i++)
+        if (cut[i] == 0)
+            printf("difficult set includes %d\n", i);
+
+    return 0;
+}
+
+#endif
diff --git a/apps/plugins/puzzles/maxflow.h b/apps/plugins/puzzles/maxflow.h
new file mode 100644
index 0000000000..d490f45421
--- /dev/null
+++ b/apps/plugins/puzzles/maxflow.h
@@ -0,0 +1,95 @@
+/*
+ * Edmonds-Karp algorithm for finding a maximum flow and minimum
+ * cut in a network. Almost identical to the Ford-Fulkerson
+ * algorithm, but apparently using breadth-first search to find the
+ * _shortest_ augmenting path is a good way to guarantee
+ * termination and ensure the time complexity is not dependent on
+ * the actual value of the maximum flow. I don't understand why
+ * that should be, but it's claimed on the Internet that it's been
+ * proved, and that's good enough for me. I prefer BFS to DFS
+ * anyway :-)
+ */
+
+#ifndef MAXFLOW_MAXFLOW_H
+#define MAXFLOW_MAXFLOW_H
+
+/*
+ * The actual algorithm.
+ * 
+ * Inputs:
+ * 
+ *  - `scratch' is previously allocated scratch space of a size
+ *    previously determined by calling `maxflow_scratch_size'.
+ * 
+ *  - `nv' is the number of vertices. Vertices are assumed to be
+ *    numbered from 0 to nv-1.
+ * 
+ *  - `source' and `sink' are the distinguished source and sink
+ *    vertices.
+ * 
+ *  - `ne' is the number of edges in the graph.
+ * 
+ *  - `edges' is an array of 2*ne integers, giving a (source, dest)
+ *    pair for each network edge. Edge pairs are expected to be
+ *    sorted in lexicographic order.
+ * 
+ *  - `backedges' is an array of `ne' integers, each a distinct
+ *    index into `edges'. The edges in `edges', if permuted as
+ *    specified by this array, should end up sorted in the _other_
+ *    lexicographic order, i.e. dest taking priority over source.
+ * 
+ *  - `capacity' is an array of `ne' integers, giving a maximum
+ *    flow capacity for each edge. A negative value is taken to
+ *    indicate unlimited capacity on that edge, but note that there
+ *    may not be any unlimited-capacity _path_ from source to sink
+ *    or an assertion will be failed.
+ * 
+ * Output:
+ * 
+ *  - `flow' must be non-NULL. It is an array of `ne' integers,
+ *    each giving the final flow along each edge.
+ * 
+ *  - `cut' may be NULL. If non-NULL, it is an array of `nv'
+ *    integers, which will be set to zero or one on output, in such
+ *    a way that:
+ *     + the set of zero vertices includes the source
+ *     + the set of one vertices includes the sink
+ *     + the maximum flow capacity between the zero and one vertex
+ *       sets is achieved (i.e. all edges from a zero vertex to a
+ *       one vertex are at full capacity, while all edges from a
+ *       one vertex to a zero vertex have no flow at all).
+ * 
+ *  - the returned value from the function is the total flow
+ *    achieved.
+ */
+int maxflow_with_scratch(void *scratch, int nv, int source, int sink,
+                         int ne, const int *edges, const int *backedges,
+                         const int *capacity, int *flow, int *cut);
+
+/*
+ * The above function expects its `scratch' and `backedges'
+ * parameters to have already been set up. This allows you to set
+ * them up once and use them in multiple invocates of the
+ * algorithm. Now I provide functions to actually do the setting
+ * up.
+ */
+int maxflow_scratch_size(int nv);
+void maxflow_setup_backedges(int ne, const int *edges, int *backedges);
+
+/*
+ * Simplified version of the above function. All parameters are the
+ * same, except that `scratch' and `backedges' are constructed
+ * internally. This is the simplest way to call the algorithm as a
+ * one-off; however, if you need to call it multiple times on the
+ * same network, it is probably better to call the above version
+ * directly so that you only construct `scratch' and `backedges'
+ * once.
+ * 
+ * Additional return value is now -1, meaning that scratch space
+ * could not be allocated.
+ */
+int maxflow(int nv, int source, int sink,
+            int ne, const int *edges, const int *capacity,
+            int *flow, int *cut);
+
+#endif /* MAXFLOW_MAXFLOW_H */
diff --git a/apps/plugins/puzzles/midend.c b/apps/plugins/puzzles/midend.c
new file mode 100644
index 0000000000..e2938a45bc
--- /dev/null
+++ b/apps/plugins/puzzles/midend.c
@@ -0,0 +1,2136 @@
+/*
+ * midend.c: general middle fragment sitting between the
+ * platform-specific front end and game-specific back end.
+ * Maintains a move list, takes care of Undo and Redo commands, and
+ * processes standard keystrokes for undo/redo/new/quit.
+ */
+#include "puzzles.h"
+
+#include "rbcompat.h"
+#include "rbassert.h"
+
+enum { DEF_PARAMS, DEF_SEED, DEF_DESC };   /* for midend_game_id_int */
+
+enum { NEWGAME, MOVE, SOLVE, RESTART };/* for midend_state_entry.movetype */
+
+#define special(type) ( (type) != MOVE )
+
+struct midend_state_entry {
+    game_state *state;
+    char *movestr;
+    int movetype;
+};
+
+struct midend {
+    frontend *frontend;
+    random_state *random;
+    const game *ourgame;
+
+    game_params **presets;
+    char **preset_names, **preset_encodings;
+    int npresets, presetsize;
+
+    /*
+     * `desc' and `privdesc' deserve a comment.
+     * 
+     * `desc' is the game description as presented to the user when
+     * they ask for Game -> Specific. `privdesc', if non-NULL, is a
+     * different game description used to reconstruct the initial
+     * game_state when de-serialising. If privdesc is NULL, `desc'
+     * is used for both.
+     * 
+     * For almost all games, `privdesc' is NULL and never used. The
+     * exception (as usual) is Mines: the initial game state has no
+     * squares open at all, but after the first click `desc' is
+     * rewritten to describe a game state with an initial click and
+     * thus a bunch of squares open. If we used that desc to
+     * serialise and deserialise, then the initial game state after
+     * deserialisation would look unlike the initial game state
+     * beforehand, and worse still execute_move() might fail on the
+     * attempted first click. So `privdesc' is also used in this
+     * case, to provide a game description describing the same
+     * fixed mine layout _but_ no initial click. (These game IDs
+     * may also be typed directly into Mines if you like.)
+     */
+    char *desc, *privdesc, *seedstr;
+    char *aux_info;
+    enum { GOT_SEED, GOT_DESC, GOT_NOTHING } genmode;
+
+    int nstates, statesize, statepos;
+    struct midend_state_entry *states;
+
+    game_params *params, *curparams;
+    game_drawstate *drawstate;
+    game_ui *ui;
+
+    game_state *oldstate;
+    float anim_time, anim_pos;
+    float flash_time, flash_pos;
+    int dir;
+
+    int timing;
+    float elapsed;
+    char *laststatus;
+
+    drawing *drawing;
+
+    int pressed_mouse_button;
+
+    int preferred_tilesize, tilesize, winwidth, winheight;
+
+    void (*game_id_change_notify_function)(void *);
+    void *game_id_change_notify_ctx;
+};
+
+#define ensure(me) do { \
+    if ((me)->nstates >= (me)->statesize) { \
+        (me)->statesize = (me)->nstates + 128; \
+        (me)->states = sresize((me)->states, (me)->statesize, \
+                               struct midend_state_entry); \
+    } \
+} while (0)
+
+void midend_reset_tilesize(midend *me)
+{
+    me->preferred_tilesize = me->ourgame->preferred_tilesize;
+    {
+        /*
+         * Allow an environment-based override for the default tile
+         * size by defining a variable along the lines of
+         * `NET_TILESIZE=15'.
+         */
+
+        char buf[80], *e;
+        int j, k, ts;
+
+        sprintf(buf, "%s_TILESIZE", me->ourgame->name);
+        for (j = k = 0; buf[j]; j++)
+            if (!isspace((unsigned char)buf[j]))
+                buf[k++] = toupper((unsigned char)buf[j]);
+        buf[k] = '\0';
+        if ((e = getenv(buf)) != NULL && sscanf(e, "%d", &ts) == 1 && ts > 0)
+            me->preferred_tilesize = ts;
+    }
+}
+
+midend *midend_new(frontend *fe, const game *ourgame,
+                   const drawing_api *drapi, void *drhandle)
+{
+    midend *me = snew(midend);
+    void *randseed;
+    int randseedsize;
+
+    get_random_seed(&randseed, &randseedsize);
+
+    me->frontend = fe;
+    me->ourgame = ourgame;
+    me->random = random_new(randseed, randseedsize);
+    me->nstates = me->statesize = me->statepos = 0;
+    me->states = NULL;
+    me->params = ourgame->default_params();
+    me->game_id_change_notify_function = NULL;
+    me->game_id_change_notify_ctx = NULL;
+
+    /*
+     * Allow environment-based changing of the default settings by
+     * defining a variable along the lines of `NET_DEFAULT=25x25w'
+     * in which the value is an encoded parameter string.
+     */
+    {
+        char buf[80], *e;
+        int j, k;
+        sprintf(buf, "%s_DEFAULT", me->ourgame->name);
+        for (j = k = 0; buf[j]; j++)
+            if (!isspace((unsigned char)buf[j]))
+                buf[k++] = toupper((unsigned char)buf[j]);
+        buf[k] = '\0';
+        if ((e = getenv(buf)) != NULL)
+            me->ourgame->decode_params(me->params, e);
+    }
+    me->curparams = NULL;
+    me->desc = me->privdesc = NULL;
+    me->seedstr = NULL;
+    me->aux_info = NULL;
+    me->genmode = GOT_NOTHING;
+    me->drawstate = NULL;
+    me->oldstate = NULL;
+    me->presets = NULL;
+    me->preset_names = NULL;
+    me->preset_encodings = NULL;
+    me->npresets = me->presetsize = 0;
+    me->anim_time = me->anim_pos = 0.0F;
+    me->flash_time = me->flash_pos = 0.0F;
+    me->dir = 0;
+    me->ui = NULL;
+    me->pressed_mouse_button = 0;
+    me->laststatus = NULL;
+    me->timing = FALSE;
+    me->elapsed = 0.0F;
+    me->tilesize = me->winwidth = me->winheight = 0;
+    if (drapi)
+        me->drawing = drawing_new(drapi, me, drhandle);
+    else
+        me->drawing = NULL;
+
+    midend_reset_tilesize(me);
+
+    sfree(randseed);
+
+    return me;
+}
+
+const game *midend_which_game(midend *me)
+{
+    return me->ourgame;
+}
+
+static void midend_purge_states(midend *me)
+{
+    while (me->nstates > me->statepos) {
+        me->ourgame->free_game(me->states[--me->nstates].state);
+        if (me->states[me->nstates].movestr)
+            sfree(me->states[me->nstates].movestr);
+    }
+}
+
+static void midend_free_game(midend *me)
+{
+    while (me->nstates > 0) {
+        me->nstates--;
+        me->ourgame->free_game(me->states[me->nstates].state);
+        sfree(me->states[me->nstates].movestr);
+    }
+
+    if (me->drawstate)
+        me->ourgame->free_drawstate(me->drawing, me->drawstate);
+}
+
+void midend_free(midend *me)
+{
+    int i;
+
+    midend_free_game(me);
+
+    if (me->drawing)
+        drawing_free(me->drawing);
+    random_free(me->random);
+    sfree(me->states);
+    sfree(me->desc);
+    sfree(me->privdesc);
+    sfree(me->seedstr);
+    sfree(me->aux_info);
+    me->ourgame->free_params(me->params);
+    if (me->npresets) {
+        for (i = 0; i < me->npresets; i++) {
+            sfree(me->presets[i]);
+            sfree(me->preset_names[i]);
+            sfree(me->preset_encodings[i]);
+        }
+        sfree(me->presets);
+        sfree(me->preset_names);
+        sfree(me->preset_encodings);
+    }
+    if (me->ui)
+        me->ourgame->free_ui(me->ui);
+    if (me->curparams)
+        me->ourgame->free_params(me->curparams);
+    sfree(me->laststatus);
+    sfree(me);
+}
+
+static void midend_size_new_drawstate(midend *me)
+{
+    /*
+     * Don't even bother, if we haven't worked out our tile size
+     * anyway yet.
+     */
+    if (me->tilesize > 0) {
+        me->ourgame->compute_size(me->params, me->tilesize,
+                                  &me->winwidth, &me->winheight);
+        me->ourgame->set_size(me->drawing, me->drawstate,
+                              me->params, me->tilesize);
+    }
+}
+
+void midend_size(midend *me, int *x, int *y, int user_size)
+{
+    int min, max;
+    int rx, ry;
+
+    /*
+     * We can't set the size on the same drawstate twice. So if
+     * we've already sized one drawstate, we must throw it away and
+     * create a new one.
+     */
+    if (me->drawstate && me->tilesize > 0) {
+        me->ourgame->free_drawstate(me->drawing, me->drawstate);
+        me->drawstate = me->ourgame->new_drawstate(me->drawing,
+                                                   me->states[0].state);
+    }
+
+    /*
+     * Find the tile size that best fits within the given space. If
+     * `user_size' is TRUE, we must actually find the _largest_ such
+     * tile size, in order to get as close to the user's explicit
+     * request as possible; otherwise, we bound above at the game's
+     * preferred tile size, so that the game gets what it wants
+     * provided that this doesn't break the constraint from the
+     * front-end (which is likely to be a screen size or similar).
+     */
+    if (user_size) {
+        max = 1;
+        do {
+            max *= 2;
+            me->ourgame->compute_size(me->params, max, &rx, &ry);
+        } while (rx <= *x && ry <= *y);
+    } else
+        max = me->preferred_tilesize + 1;
+    min = 1;
+
+    /*
+     * Now binary-search between min and max. We're looking for a
+     * boundary rather than a value: the point at which tile sizes
+     * stop fitting within the given dimensions. Thus, we stop when
+     * max and min differ by exactly 1.
+     */
+    while (max - min > 1) {
+        int mid = (max + min) / 2;
+        me->ourgame->compute_size(me->params, mid, &rx, &ry);
+        if (rx <= *x && ry <= *y)
+            min = mid;
+        else
+            max = mid;
+    }
+
+    /*
+     * Now `min' is a valid size, and `max' isn't. So use `min'.
+     */
+
+    me->tilesize = min;
+    if (user_size)
+        /* If the user requested a change in size, make it permanent. */
+        me->preferred_tilesize = me->tilesize;
+    midend_size_new_drawstate(me);
+    *x = me->winwidth;
+    *y = me->winheight;
+}
+
+int midend_tilesize(midend *me) { return me->tilesize; }
+
+void midend_set_params(midend *me, game_params *params)
+{
+    me->ourgame->free_params(me->params);
+    me->params = me->ourgame->dup_params(params);
+}
+
+game_params *midend_get_params(midend *me)
+{
+    return me->ourgame->dup_params(me->params);
+}
+
+static void midend_set_timer(midend *me)
+{
+    me->timing = (me->ourgame->is_timed &&
+                  me->ourgame->timing_state(me->states[me->statepos-1].state,
+                                            me->ui));
+    if (me->timing || me->flash_time || me->anim_time)
+        activate_timer(me->frontend);
+    else
+        deactivate_timer(me->frontend);
+}
+
+void midend_force_redraw(midend *me)
+{
+    if (me->drawstate)
+        me->ourgame->free_drawstate(me->drawing, me->drawstate);
+    me->drawstate = me->ourgame->new_drawstate(me->drawing,
+                                               me->states[0].state);
+    midend_size_new_drawstate(me);
+    midend_redraw(me);
+}
+
+void midend_new_game(midend *me)
+{
+    midend_stop_anim(me);
+    midend_free_game(me);
+
+    assert(me->nstates == 0);
+
+    if (me->genmode == GOT_DESC) {
+        me->genmode = GOT_NOTHING;
+    } else {
+        random_state *rs;
+
+        if (me->genmode == GOT_SEED) {
+            me->genmode = GOT_NOTHING;
+        } else {
+            /*
+             * Generate a new random seed. 15 digits comes to about
+             * 48 bits, which should be more than enough.
+             * 
+             * I'll avoid putting a leading zero on the number,
+             * just in case it confuses anybody who thinks it's
+             * processed as an integer rather than a string.
+             */
+            char newseed[16];
+            int i;
+            newseed[15] = '\0';
+            newseed[0] = '1' + (char)random_upto(me->random, 9);
+            for (i = 1; i < 15; i++)
+                newseed[i] = '0' + (char)random_upto(me->random, 10);
+            sfree(me->seedstr);
+            me->seedstr = dupstr(newseed);
+
+            if (me->curparams)
+                me->ourgame->free_params(me->curparams);
+            me->curparams = me->ourgame->dup_params(me->params);
+        }
+
+        sfree(me->desc);
+        sfree(me->privdesc);
+        sfree(me->aux_info);
+        me->aux_info = NULL;
+
+        rs = random_new(me->seedstr, strlen(me->seedstr));
+        /*
+         * If this midend has been instantiated without providing a
+         * drawing API, it is non-interactive. This means that it's
+         * being used for bulk game generation, and hence we should
+         * pass the non-interactive flag to new_desc.
+         */
+        me->desc = me->ourgame->new_desc(me->curparams, rs,
+                                         &me->aux_info, (me->drawing != NULL));
+        me->privdesc = NULL;
+        random_free(rs);
+    }
+
+    ensure(me);
+
+    /*
+     * It might seem a bit odd that we're using me->params to
+     * create the initial game state, rather than me->curparams
+     * which is better tailored to this specific game and which we
+     * always know.
+     * 
+     * It's supposed to be an invariant in the midend that
+     * me->params and me->curparams differ in no aspect that is
+     * important after generation (i.e. after new_desc()). By
+     * deliberately passing the _less_ specific of these two
+     * parameter sets, we provoke play-time misbehaviour in the
+     * case where a game has failed to encode a play-time parameter
+     * in the non-full version of encode_params().
+     */
+    me->states[me->nstates].state =
+        me->ourgame->new_game(me, me->params, me->desc);
+
+    /*
+     * As part of our commitment to self-testing, test the aux
+     * string to make sure nothing ghastly went wrong.
+     */
+    if (me->ourgame->can_solve && me->aux_info) {
+        game_state *s;
+        char *msg, *movestr;
+
+        msg = NULL;
+        movestr = me->ourgame->solve(me->states[0].state,
+                                     me->states[0].state,
+                                     me->aux_info, &msg);
+        assert(movestr && !msg);
+        s = me->ourgame->execute_move(me->states[0].state, movestr);
+        assert(s);
+        me->ourgame->free_game(s);
+        sfree(movestr);
+    }
+
+    me->states[me->nstates].movestr = NULL;
+    me->states[me->nstates].movetype = NEWGAME;
+    me->nstates++;
+    me->statepos = 1;
+    me->drawstate = me->ourgame->new_drawstate(me->drawing,
+                                               me->states[0].state);
+    midend_size_new_drawstate(me);
+    me->elapsed = 0.0F;
+    me->flash_pos = me->flash_time = 0.0F;
+    me->anim_pos = me->anim_time = 0.0F;
+    if (me->ui)
+        me->ourgame->free_ui(me->ui);
+    me->ui = me->ourgame->new_ui(me->states[0].state);
+    midend_set_timer(me);
+    me->pressed_mouse_button = 0;
+
+    if (me->game_id_change_notify_function)
+        me->game_id_change_notify_function(me->game_id_change_notify_ctx);
+}
+
+int midend_can_undo(midend *me)
+{
+    return (me->statepos > 1);
+}
+
+int midend_can_redo(midend *me)
+{
+    return (me->statepos < me->nstates);
+}
+
+static int midend_undo(midend *me)
+{
+    if (me->statepos > 1) {
+        if (me->ui)
+            me->ourgame->changed_state(me->ui,
+                                       me->states[me->statepos-1].state,
+                                       me->states[me->statepos-2].state);
+        me->statepos--;
+        me->dir = -1;
+        return 1;
+    } else
+        return 0;
+}
+
+static int midend_redo(midend *me)
+{
+    if (me->statepos < me->nstates) {
+        if (me->ui)
+            me->ourgame->changed_state(me->ui,
+                                       me->states[me->statepos-1].state,
+                                       me->states[me->statepos].state);
+        me->statepos++;
+        me->dir = +1;
+        return 1;
+    } else
+        return 0;
+}
+
+static void midend_finish_move(midend *me)
+{
+    float flashtime;
+
+    /*
+     * We do not flash if the later of the two states is special.
+     * This covers both forward Solve moves and backward (undone)
+     * Restart moves.
+     */
+    if ((me->oldstate || me->statepos > 1) &&
+        ((me->dir > 0 && !special(me->states[me->statepos-1].movetype)) ||
+         (me->dir < 0 && me->statepos < me->nstates &&
+          !special(me->states[me->statepos].movetype)))) {
+        flashtime = me->ourgame->flash_length(me->oldstate ? me->oldstate :
+                                              me->states[me->statepos-2].state,
+                                              me->states[me->statepos-1].state,
+                                              me->oldstate ? me->dir : +1,
+                                              me->ui);
+        if (flashtime > 0) {
+            me->flash_pos = 0.0F;
+            me->flash_time = flashtime;
+        }
+    }
+
+    if (me->oldstate)
+        me->ourgame->free_game(me->oldstate);
+    me->oldstate = NULL;
+    me->anim_pos = me->anim_time = 0;
+    me->dir = 0;
+
+    midend_set_timer(me);
+}
+
+void midend_stop_anim(midend *me)
+{
+    if (me->oldstate || me->anim_time != 0) {
+        midend_finish_move(me);
+        midend_redraw(me);
+    }
+}
+
+void midend_restart_game(midend *me)
+{
+    game_state *s;
+
+    assert(me->statepos >= 1);
+    if (me->statepos == 1)
+        return;                        /* no point doing anything at all! */
+
+    /*
+     * During restart, we reconstruct the game from the (public)
+     * game description rather than from states[0], because that
+     * way Mines gets slightly more sensible behaviour (restart
+     * goes to _after_ the first click so you don't have to
+     * remember where you clicked).
+     */
+    s = me->ourgame->new_game(me, me->params, me->desc);
+
+    /*
+     * Now enter the restarted state as the next move.
+     */
+    midend_stop_anim(me);
+    midend_purge_states(me);
+    ensure(me);
+    me->states[me->nstates].state = s;
+    me->states[me->nstates].movestr = dupstr(me->desc);
+    me->states[me->nstates].movetype = RESTART;
+    me->statepos = ++me->nstates;
+    if (me->ui)
+        me->ourgame->changed_state(me->ui,
+                                   me->states[me->statepos-2].state,
+                                   me->states[me->statepos-1].state);
+    me->flash_pos = me->flash_time = 0.0F;
+    midend_finish_move(me);
+    midend_redraw(me);
+    midend_set_timer(me);
+}
+
+static int midend_really_process_key(midend *me, int x, int y, int button)
+{
+    game_state *oldstate =
+        me->ourgame->dup_game(me->states[me->statepos - 1].state);
+    int type = MOVE, gottype = FALSE, ret = 1;
+    float anim_time;
+    game_state *s;
+    char *movestr;
+        
+    movestr =
+        me->ourgame->interpret_move(me->states[me->statepos-1].state,
+                                    me->ui, me->drawstate, x, y, button);
+
+    if (!movestr) {
+        if (button == 'n' || button == 'N' || button == '\x0E') {
+            midend_new_game(me);
+            midend_redraw(me);
+            goto done;                 /* never animate */
+        } else if (button == 'u' || button == 'U' ||
+                   button == '\x1A' || button == '\x1F') {
+            midend_stop_anim(me);
+            type = me->states[me->statepos-1].movetype;
+            gottype = TRUE;
+            if (!midend_undo(me))
+                goto done;
+        } else if (button == 'r' || button == 'R' ||
+                   button == '\x12' || button == '\x19') {
+            midend_stop_anim(me);
+            if (!midend_redo(me))
+                goto done;
+        } else if (button == '\x13' && me->ourgame->can_solve) {
+            if (midend_solve(me))
+                goto done;
+        } else if (button == 'q' || button == 'Q' || button == '\x11') {
+            ret = 0;
+            goto done;
+        } else
+            goto done;
+    } else {
+        if (!*movestr)
+            s = me->states[me->statepos-1].state;
+        else {
+            s = me->ourgame->execute_move(me->states[me->statepos-1].state,
+                                          movestr);
+            assert(s != NULL);
+        }
+
+        if (s == me->states[me->statepos-1].state) {
+            /*
+             * make_move() is allowed to return its input state to
+             * indicate that although no move has been made, the UI
+             * state has been updated and a redraw is called for.
+             */
+            midend_redraw(me);
+            midend_set_timer(me);
+            goto done;
+        } else if (s) {
+            midend_stop_anim(me);
+            midend_purge_states(me);
+            ensure(me);
+            assert(movestr != NULL);
+            me->states[me->nstates].state = s;
+            me->states[me->nstates].movestr = movestr;
+            me->states[me->nstates].movetype = MOVE;
+            me->statepos = ++me->nstates;
+            me->dir = +1;
+            if (me->ui)
+                me->ourgame->changed_state(me->ui,
+                                           me->states[me->statepos-2].state,
+                                           me->states[me->statepos-1].state);
+        } else {
+            goto done;
+        }
+    }
+
+    if (!gottype)
+        type = me->states[me->statepos-1].movetype;
+
+    /*
+     * See if this move requires an animation.
+     */
+    if (special(type) && !(type == SOLVE &&
+                           (me->ourgame->flags & SOLVE_ANIMATES))) {
+        anim_time = 0;
+    } else {
+        anim_time = me->ourgame->anim_length(oldstate,
+                                             me->states[me->statepos-1].state,
+                                             me->dir, me->ui);
+    }
+
+    me->oldstate = oldstate; oldstate = NULL;
+    if (anim_time > 0) {
+        me->anim_time = anim_time;
+    } else {
+        me->anim_time = 0.0;
+        midend_finish_move(me);
+    }
+    me->anim_pos = 0.0;
+
+    midend_redraw(me);
+
+    midend_set_timer(me);
+
+    done:
+    if (oldstate) me->ourgame->free_game(oldstate);
+    return ret;
+}
+
+int midend_process_key(midend *me, int x, int y, int button)
+{
+    int ret = 1;
+
+    /*
+     * Harmonise mouse drag and release messages.
+     * 
+     * Some front ends might accidentally switch from sending, say,
+     * RIGHT_DRAG messages to sending LEFT_DRAG, half way through a
+     * drag. (This can happen on the Mac, for example, since
+     * RIGHT_DRAG is usually done using Command+drag, and if the
+     * user accidentally releases Command half way through the drag
+     * then there will be trouble.)
+     * 
+     * It would be an O(number of front ends) annoyance to fix this
+     * in the front ends, but an O(number of back ends) annoyance
+     * to have each game capable of dealing with it. Therefore, we
+     * fix it _here_ in the common midend code so that it only has
+     * to be done once.
+     * 
+     * The possible ways in which things can go screwy in the front
+     * end are:
+     * 
+     *  - in a system containing multiple physical buttons button
+     *    presses can inadvertently overlap. We can see ABab (caps
+     *    meaning button-down and lowercase meaning button-up) when
+     *    the user had semantically intended AaBb.
+     * 
+     *  - in a system where one button is simulated by means of a
+     *    modifier key and another button, buttons can mutate
+     *    between press and release (possibly during drag). So we
+     *    can see Ab instead of Aa.
+     * 
+     * Definite requirements are:
+     * 
+     *  - button _presses_ must never be invented or destroyed. If
+     *    the user presses two buttons in succession, the button
+     *    presses must be transferred to the backend unchanged. So
+     *    if we see AaBb , that's fine; if we see ABab (the button
+     *    presses inadvertently overlapped) we must somehow
+     *    `correct' it to AaBb.
+     * 
+     *  - every mouse action must end up looking like a press, zero
+     *    or more drags, then a release. This allows back ends to
+     *    make the _assumption_ that incoming mouse data will be
+     *    sane in this regard, and not worry about the details.
+     * 
+     * So my policy will be:
+     * 
+     *  - treat any button-up as a button-up for the currently
+     *    pressed button, or ignore it if there is no currently
+     *    pressed button.
+     * 
+     *  - treat any drag as a drag for the currently pressed
+     *    button, or ignore it if there is no currently pressed
+     *    button.
+     * 
+     *  - if we see a button-down while another button is currently
+     *    pressed, invent a button-up for the first one and then
+     *    pass the button-down through as before.
+     * 
+     * 2005-05-31: An addendum to the above. Some games might want
+     * a `priority order' among buttons, such that if one button is
+     * pressed while another is down then a fixed one of the
+     * buttons takes priority no matter what order they're pressed
+     * in. Mines, in particular, wants to treat a left+right click
+     * like a left click for the benefit of users of other
+     * implementations. So the last of the above points is modified
+     * in the presence of an (optional) button priority order.
+     *
+     * A further addition: we translate certain keyboard presses to
+     * cursor key 'select' buttons, so that a) frontends don't have
+     * to translate these themselves (like they do for CURSOR_UP etc),
+     * and b) individual games don't have to hard-code button presses
+     * of '\n' etc for keyboard-based cursors. The choice of buttons
+     * here could eventually be controlled by a runtime configuration
+     * option.
+     */
+    if (IS_MOUSE_DRAG(button) || IS_MOUSE_RELEASE(button)) {
+        if (me->pressed_mouse_button) {
+            if (IS_MOUSE_DRAG(button)) {
+                button = me->pressed_mouse_button +
+                    (LEFT_DRAG - LEFT_BUTTON);
+            } else {
+                button = me->pressed_mouse_button +
+                    (LEFT_RELEASE - LEFT_BUTTON);
+            }
+        } else
+            return ret;                /* ignore it */
+    } else if (IS_MOUSE_DOWN(button) && me->pressed_mouse_button) {
+        /*
+         * If the new button has lower priority than the old one,
+         * don't bother doing this.
+         */
+        if (me->ourgame->flags &
+            BUTTON_BEATS(me->pressed_mouse_button, button))
+            return ret;                /* just ignore it */
+
+        /*
+         * Fabricate a button-up for the previously pressed button.
+         */
+        ret = ret && midend_really_process_key
+            (me, x, y, (me->pressed_mouse_button +
+                        (LEFT_RELEASE - LEFT_BUTTON)));
+    }
+
+    /*
+     * Translate keyboard presses to cursor selection.
+     */
+    if (button == '\n' || button == '\r')
+      button = CURSOR_SELECT;
+    if (button == ' ')
+      button = CURSOR_SELECT2;
+
+    /*
+     * Normalise both backspace characters (8 and 127) to \b. Easier
+     * to do this once, here, than to require all front ends to
+     * carefully generate the same one - now each front end can
+     * generate whichever is easiest.
+     */
+    if (button == '\177')
+        button = '\b';
+
+    /*
+     * Now send on the event we originally received.
+     */
+    ret = ret && midend_really_process_key(me, x, y, button);
+
+    /*
+     * And update the currently pressed button.
+     */
+    if (IS_MOUSE_RELEASE(button))
+        me->pressed_mouse_button = 0;
+    else if (IS_MOUSE_DOWN(button))
+        me->pressed_mouse_button = button;
+
+    return ret;
+}
+
+void midend_redraw(midend *me)
+{
+    assert(me->drawing);
+
+    if (me->statepos > 0 && me->drawstate) {
+        start_draw(me->drawing);
+        if (me->oldstate && me->anim_time > 0 &&
+            me->anim_pos < me->anim_time) {
+            assert(me->dir != 0);
+            me->ourgame->redraw(me->drawing, me->drawstate, me->oldstate,
+                                me->states[me->statepos-1].state, me->dir,
+                                me->ui, me->anim_pos, me->flash_pos);
+        } else {
+            me->ourgame->redraw(me->drawing, me->drawstate, NULL,
+                                me->states[me->statepos-1].state, +1 /*shrug*/,
+                                me->ui, 0.0, me->flash_pos);
+        }
+        end_draw(me->drawing);
+    }
+}
+
+/*
+ * Nasty hacky function used to implement the --redo option in
+ * gtk.c. Only used for generating the puzzles' icons.
+ */
+void midend_freeze_timer(midend *me, float tprop)
+{
+    me->anim_pos = me->anim_time * tprop;
+    midend_redraw(me);
+    deactivate_timer(me->frontend);
+}
+
+void midend_timer(midend *me, float tplus)
+{
+    int need_redraw = (me->anim_time > 0 || me->flash_time > 0);
+
+    me->anim_pos += tplus;
+    if (me->anim_pos >= me->anim_time ||
+        me->anim_time == 0 || !me->oldstate) {
+        if (me->anim_time > 0)
+            midend_finish_move(me);
+    }
+
+    me->flash_pos += tplus;
+    if (me->flash_pos >= me->flash_time || me->flash_time == 0) {
+        me->flash_pos = me->flash_time = 0;
+    }
+
+    if (need_redraw)
+        midend_redraw(me);
+
+    if (me->timing) {
+        float oldelapsed = me->elapsed;
+        me->elapsed += tplus;
+        if ((int)oldelapsed != (int)me->elapsed)
+            status_bar(me->drawing, me->laststatus ? me->laststatus : "");
+    }
+
+    midend_set_timer(me);
+}
+
+float *midend_colours(midend *me, int *ncolours)
+{
+    float *ret;
+
+    ret = me->ourgame->colours(me->frontend, ncolours);
+
+    {
+        int i;
+
+        /*
+         * Allow environment-based overrides for the standard
+         * colours by defining variables along the lines of
+         * `NET_COLOUR_4=6000c0'.
+         */
+
+        for (i = 0; i < *ncolours; i++) {
+            char buf[80], *e;
+            unsigned int r, g, b;
+            int j, k;
+
+            sprintf(buf, "%s_COLOUR_%d", me->ourgame->name, i);
+            for (j = k = 0; buf[j]; j++)
+                if (!isspace((unsigned char)buf[j]))
+                    buf[k++] = toupper((unsigned char)buf[j]);
+            buf[k] = '\0';
+            if ((e = getenv(buf)) != NULL &&
+                sscanf(e, "%2x%2x%2x", &r, &g, &b) == 3) {
+                ret[i*3 + 0] = r / 255.0F;
+                ret[i*3 + 1] = g / 255.0F;
+                ret[i*3 + 2] = b / 255.0F;
+            }
+        }
+    }
+
+    return ret;
+}
+
+int midend_num_presets(midend *me)
+{
+    if (!me->npresets) {
+        char *name;
+        game_params *preset;
+
+        while (me->ourgame->fetch_preset(me->npresets, &name, &preset)) {
+            if (me->presetsize <= me->npresets) {
+                me->presetsize = me->npresets + 10;
+                me->presets = sresize(me->presets, me->presetsize,
+                                      game_params *);
+                me->preset_names = sresize(me->preset_names, me->presetsize,
+                                           char *);
+                me->preset_encodings = sresize(me->preset_encodings,
+                                               me->presetsize, char *);
+            }
+
+            me->presets[me->npresets] = preset;
+            me->preset_names[me->npresets] = name;
+            me->preset_encodings[me->npresets] =
+                me->ourgame->encode_params(preset, TRUE);;
+            me->npresets++;
+        }
+    }
+
+    {
+        /*
+         * Allow environment-based extensions to the preset list by
+         * defining a variable along the lines of `SOLO_PRESETS=2x3
+         * Advanced:2x3da'. Colon-separated list of items,
+         * alternating between textual titles in the menu and
+         * encoded parameter strings.
+         */
+        char buf[80], *e, *p;
+        int j, k;
+
+        sprintf(buf, "%s_PRESETS", me->ourgame->name);
+        for (j = k = 0; buf[j]; j++)
+            if (!isspace((unsigned char)buf[j]))
+                buf[k++] = toupper((unsigned char)buf[j]);
+        buf[k] = '\0';
+
+        if ((e = getenv(buf)) != NULL) {
+            p = e = dupstr(e);
+
+            while (*p) {
+                char *name, *val;
+                game_params *preset;
+
+                name = p;
+                while (*p && *p != ':') p++;
+                if (*p) *p++ = '\0';
+                val = p;
+                while (*p && *p != ':') p++;
+                if (*p) *p++ = '\0';
+
+                preset = me->ourgame->default_params();
+                me->ourgame->decode_params(preset, val);
+
+                if (me->ourgame->validate_params(preset, TRUE)) {
+                    /* Drop this one from the list. */
+                    me->ourgame->free_params(preset);
+                    continue;
+                }
+
+                if (me->presetsize <= me->npresets) {
+                    me->presetsize = me->npresets + 10;
+                    me->presets = sresize(me->presets, me->presetsize,
+                                          game_params *);
+                    me->preset_names = sresize(me->preset_names,
+                                               me->presetsize, char *);
+                    me->preset_encodings = sresize(me->preset_encodings,
+                                                   me->presetsize, char *);
+                }
+
+                me->presets[me->npresets] = preset;
+                me->preset_names[me->npresets] = dupstr(name);
+                me->preset_encodings[me->npresets] =
+                    me->ourgame->encode_params(preset, TRUE);
+                me->npresets++;
+            }
+            sfree(e);
+        }
+    }
+
+    return me->npresets;
+}
+
+void midend_fetch_preset(midend *me, int n,
+                         char **name, game_params **params)
+{
+    assert(n >= 0 && n < me->npresets);
+    *name = me->preset_names[n];
+    *params = me->presets[n];
+}
+
+int midend_which_preset(midend *me)
+{
+    char *encoding = me->ourgame->encode_params(me->params, TRUE);
+    int i, ret;
+
+    ret = -1;
+    for (i = 0; i < me->npresets; i++)
+        if (!strcmp(encoding, me->preset_encodings[i])) {
+            ret = i;
+            break;
+        }
+
+    sfree(encoding);
+    return ret;
+}
+
+int midend_wants_statusbar(midend *me)
+{
+    return me->ourgame->wants_statusbar;
+}
+
+void midend_request_id_changes(midend *me, void (*notify)(void *), void *ctx)
+{
+    me->game_id_change_notify_function = notify;
+    me->game_id_change_notify_ctx = ctx;
+}
+
+void midend_supersede_game_desc(midend *me, char *desc, char *privdesc)
+{
+    sfree(me->desc);
+    sfree(me->privdesc);
+    me->desc = dupstr(desc);
+    me->privdesc = privdesc ? dupstr(privdesc) : NULL;
+    if (me->game_id_change_notify_function)
+        me->game_id_change_notify_function(me->game_id_change_notify_ctx);
+}
+
+config_item *midend_get_config(midend *me, int which, char **wintitle)
+{
+    char *titlebuf, *parstr, *rest;
+    config_item *ret;
+    char sep;
+
+    assert(wintitle);
+    titlebuf = snewn(40 + strlen(me->ourgame->name), char);
+
+    switch (which) {
+      case CFG_SETTINGS:
+        sprintf(titlebuf, "%s configuration", me->ourgame->name);
+        *wintitle = titlebuf;
+        return me->ourgame->configure(me->params);
+      case CFG_SEED:
+      case CFG_DESC:
+        if (!me->curparams) {
+          sfree(titlebuf);
+          return NULL;
+        }
+        sprintf(titlebuf, "%s %s selection", me->ourgame->name,
+                which == CFG_SEED ? "random" : "game");
+        *wintitle = titlebuf;
+
+        ret = snewn(2, config_item);
+
+        ret[0].type = C_STRING;
+        if (which == CFG_SEED)
+            ret[0].name = "Game random seed";
+        else
+            ret[0].name = "Game ID";
+        ret[0].ival = 0;
+        /*
+         * For CFG_DESC the text going in here will be a string
+         * encoding of the restricted parameters, plus a colon,
+         * plus the game description. For CFG_SEED it will be the
+         * full parameters, plus a hash, plus the random seed data.
+         * Either of these is a valid full game ID (although only
+         * the former is likely to persist across many code
+         * changes).
+         */
+        parstr = me->ourgame->encode_params(me->curparams, which == CFG_SEED);
+        assert(parstr);
+        if (which == CFG_DESC) {
+            rest = me->desc ? me->desc : "";
+            sep = ':';
+        } else {
+            rest = me->seedstr ? me->seedstr : "";
+            sep = '#';
+        }
+        ret[0].sval = snewn(strlen(parstr) + strlen(rest) + 2, char);
+        sprintf(ret[0].sval, "%s%c%s", parstr, sep, rest);
+        sfree(parstr);
+
+        ret[1].type = C_END;
+        ret[1].name = ret[1].sval = NULL;
+        ret[1].ival = 0;
+
+        return ret;
+    }
+
+    assert(!"We shouldn't be here");
+    return NULL;
+}
+
+static char *midend_game_id_int(midend *me, char *id, int defmode)
+{
+    char *error, *par, *desc, *seed;
+    game_params *newcurparams, *newparams, *oldparams1, *oldparams2;
+    int free_params;
+
+    seed = strchr(id, '#');
+    desc = strchr(id, ':');
+
+    if (desc && (!seed || desc < seed)) {
+        /*
+         * We have a colon separating parameters from game
+         * description. So `par' now points to the parameters
+         * string, and `desc' to the description string.
+         */
+        *desc++ = '\0';
+        par = id;
+        seed = NULL;
+    } else if (seed && (!desc || seed < desc)) {
+        /*
+         * We have a hash separating parameters from random seed.
+         * So `par' now points to the parameters string, and `seed'
+         * to the seed string.
+         */
+        *seed++ = '\0';
+        par = id;
+        desc = NULL;
+    } else {
+        /*
+         * We only have one string. Depending on `defmode', we take
+         * it to be either parameters, seed or description.
+         */
+        if (defmode == DEF_SEED) {
+            seed = id;
+            par = desc = NULL;
+        } else if (defmode == DEF_DESC) {
+            desc = id;
+            par = seed = NULL;
+        } else {
+            par = id;
+            seed = desc = NULL;
+        }
+    }
+
+    /*
+     * We must be reasonably careful here not to modify anything in
+     * `me' until we have finished validating things. This function
+     * must either return an error and do nothing to the midend, or
+     * return success and do everything; nothing in between is
+     * acceptable.
+     */
+    newcurparams = newparams = oldparams1 = oldparams2 = NULL;
+
+    if (par) {
+        /*
+         * The params string may underspecify the game parameters, so
+         * we must first initialise newcurparams with a full set of
+         * params from somewhere else before we decode_params the
+         * input string over the top.
+         *
+         * But which set? It depends on what other data we have.
+         *
+         * If we've been given a _descriptive_ game id, then that may
+         * well underspecify by design, e.g. Solo game descriptions
+         * often start just '3x3:' without specifying one of Solo's
+         * difficulty settings, because it isn't necessary once a game
+         * has been generated (and you might not even know it, if
+         * you're manually transcribing a game description). In that
+         * situation, I've always felt that the best thing to set the
+         * difficulty to (for use if the user hits 'New Game' after
+         * pasting in that game id) is whatever it was previously set
+         * to. That is, we use whatever is already in me->params as
+         * the basis for our decoding of this input string.
+         *
+         * A random-seed based game id, however, should use the real,
+         * built-in default params, and not even check the
+         * <game>_DEFAULT environment setting, because when people
+         * paste each other random seeds - whether it's two users
+         * arranging to generate the same game at the same time to
+         * race solving them, or a user sending a bug report upstream
+         * - the whole point is for the random game id to always be
+         * interpreted the same way, even if it does underspecify.
+         *
+         * A parameter string typed in on its own, with no seed _or_
+         * description, gets treated the same way as a random seed,
+         * because again I think the most likely reason for doing that
+         * is to have a portable representation of a set of params.
+         */
+        if (desc) {
+            newcurparams = me->ourgame->dup_params(me->params);
+        } else {
+            newcurparams = me->ourgame->default_params();
+        }
+        me->ourgame->decode_params(newcurparams, par);
+        error = me->ourgame->validate_params(newcurparams, desc == NULL);
+        if (error) {
+            me->ourgame->free_params(newcurparams);
+            return error;
+        }
+        oldparams1 = me->curparams;
+
+        /*
+         * Now filter only the persistent parts of this state into
+         * the long-term params structure, unless we've _only_
+         * received a params string in which case the whole lot is
+         * persistent.
+         */
+        oldparams2 = me->params;
+        if (seed || desc) {
+            char *tmpstr;
+
+            newparams = me->ourgame->dup_params(me->params);
+
+            tmpstr = me->ourgame->encode_params(newcurparams, FALSE);
+            me->ourgame->decode_params(newparams, tmpstr);
+
+            sfree(tmpstr);
+        } else {
+            newparams = me->ourgame->dup_params(newcurparams);
+        }
+        free_params = TRUE;
+    } else {
+        newcurparams = me->curparams;
+        newparams = me->params;
+        free_params = FALSE;
+    }
+
+    if (desc) {
+        error = me->ourgame->validate_desc(newparams, desc);
+        if (error) {
+            if (free_params) {
+                if (newcurparams)
+                    me->ourgame->free_params(newcurparams);
+                if (newparams)
+                    me->ourgame->free_params(newparams);
+            }
+            return error;
+        }
+    }
+
+    /*
+     * Now we've got past all possible error points. Update the
+     * midend itself.
+     */
+    me->params = newparams;
+    me->curparams = newcurparams;
+    if (oldparams1)
+        me->ourgame->free_params(oldparams1);
+    if (oldparams2)
+        me->ourgame->free_params(oldparams2);
+
+    sfree(me->desc);
+    sfree(me->privdesc);
+    me->desc = me->privdesc = NULL;
+    sfree(me->seedstr);
+    me->seedstr = NULL;
+
+    if (desc) {
+        me->desc = dupstr(desc);
+        me->genmode = GOT_DESC;
+        sfree(me->aux_info);
+        me->aux_info = NULL;
+    }
+
+    if (seed) {
+        me->seedstr = dupstr(seed);
+        me->genmode = GOT_SEED;
+    }
+
+    return NULL;
+}
+
+char *midend_game_id(midend *me, char *id)
+{
+    return midend_game_id_int(me, id, DEF_PARAMS);
+}
+
+char *midend_get_game_id(midend *me)
+{
+    char *parstr, *ret;
+
+    parstr = me->ourgame->encode_params(me->curparams, FALSE);
+    assert(parstr);
+    assert(me->desc);
+    ret = snewn(strlen(parstr) + strlen(me->desc) + 2, char);
+    sprintf(ret, "%s:%s", parstr, me->desc);
+    sfree(parstr);
+    return ret;
+}
+
+char *midend_get_random_seed(midend *me)
+{
+    char *parstr, *ret;
+
+    if (!me->seedstr)
+        return NULL;
+
+    parstr = me->ourgame->encode_params(me->curparams, TRUE);
+    assert(parstr);
+    ret = snewn(strlen(parstr) + strlen(me->seedstr) + 2, char);
+    sprintf(ret, "%s#%s", parstr, me->seedstr);
+    sfree(parstr);
+    return ret;
+}
+
+char *midend_set_config(midend *me, int which, config_item *cfg)
+{
+    char *error;
+    game_params *params;
+
+    switch (which) {
+      case CFG_SETTINGS:
+        params = me->ourgame->custom_params(cfg);
+        error = me->ourgame->validate_params(params, TRUE);
+
+        if (error) {
+            me->ourgame->free_params(params);
+            return error;
+        }
+
+        me->ourgame->free_params(me->params);
+        me->params = params;
+        break;
+
+      case CFG_SEED:
+      case CFG_DESC:
+        error = midend_game_id_int(me, cfg[0].sval,
+                                   (which == CFG_SEED ? DEF_SEED : DEF_DESC));
+        if (error)
+            return error;
+        break;
+    }
+
+    return NULL;
+}
+
+int midend_can_format_as_text_now(midend *me)
+{
+    if (me->ourgame->can_format_as_text_ever)
+        return me->ourgame->can_format_as_text_now(me->params);
+    else
+        return FALSE;
+}
+
+char *midend_text_format(midend *me)
+{
+    if (me->ourgame->can_format_as_text_ever && me->statepos > 0 &&
+        me->ourgame->can_format_as_text_now(me->params))
+        return me->ourgame->text_format(me->states[me->statepos-1].state);
+    else
+        return NULL;
+}
+
+char *midend_solve(midend *me)
+{
+    game_state *s;
+    char *msg, *movestr;
+
+    if (!me->ourgame->can_solve)
+        return "This game does not support the Solve operation";
+
+    if (me->statepos < 1)
+        return "No game set up to solve";   /* _shouldn't_ happen! */
+
+    msg = NULL;
+    movestr = me->ourgame->solve(me->states[0].state,
+                                 me->states[me->statepos-1].state,
+                                 me->aux_info, &msg);
+    if (!movestr) {
+        if (!msg)
+            msg = "Solve operation failed";   /* _shouldn't_ happen, but can */
+        return msg;
+    }
+    s = me->ourgame->execute_move(me->states[me->statepos-1].state, movestr);
+    assert(s);
+
+    /*
+     * Now enter the solved state as the next move.
+     */
+    midend_stop_anim(me);
+    midend_purge_states(me);
+    ensure(me);
+    me->states[me->nstates].state = s;
+    me->states[me->nstates].movestr = movestr;
+    me->states[me->nstates].movetype = SOLVE;
+    me->statepos = ++me->nstates;
+    if (me->ui)
+        me->ourgame->changed_state(me->ui,
+                                   me->states[me->statepos-2].state,
+                                   me->states[me->statepos-1].state);
+    me->dir = +1;
+    if (me->ourgame->flags & SOLVE_ANIMATES) {
+        me->oldstate = me->ourgame->dup_game(me->states[me->statepos-2].state);
+        me->anim_time =
+            me->ourgame->anim_length(me->states[me->statepos-2].state,
+                                     me->states[me->statepos-1].state,
+                                     +1, me->ui);
+        me->anim_pos = 0.0;
+    } else {
+        me->anim_time = 0.0;
+        midend_finish_move(me);
+    }
+    if (me->drawing)
+        midend_redraw(me);
+    midend_set_timer(me);
+    return NULL;
+}
+
+int midend_status(midend *me)
+{
+    /*
+     * We should probably never be called when the state stack has no
+     * states on it at all - ideally, midends should never be left in
+     * that state for long enough to get put down and forgotten about.
+     * But if we are, I think we return _true_ - pedantically speaking
+     * a midend in that state is 'vacuously solved', and more
+     * practically, a user whose midend has been left in that state
+     * probably _does_ want the 'new game' option to be prominent.
+     */
+    if (me->statepos == 0)
+        return +1;
+
+    return me->ourgame->status(me->states[me->statepos-1].state);
+}
+
+char *midend_rewrite_statusbar(midend *me, char *text)
+{
+    /*
+     * An important special case is that we are occasionally called
+     * with our own laststatus, to update the timer.
+     */
+    if (me->laststatus != text) {
+        sfree(me->laststatus);
+        me->laststatus = dupstr(text);
+    }
+
+    if (me->ourgame->is_timed) {
+        char timebuf[100], *ret;
+        int min, sec;
+
+        sec = (int)me->elapsed;
+        min = sec / 60;
+        sec %= 60;
+        sprintf(timebuf, "[%d:%02d] ", min, sec);
+
+        ret = snewn(strlen(timebuf) + strlen(text) + 1, char);
+        strcpy(ret, timebuf);
+        strcat(ret, text);
+        return ret;
+
+    } else {
+        return dupstr(text);
+    }
+}
+
+#define SERIALISE_MAGIC "Simon Tatham's Portable Puzzle Collection"
+#define SERIALISE_VERSION "1"
+
+/* rockbox kludge */
+static void copy_left_justified(char *buf, size_t sz, const char *str)
+{
+    memset(buf, ' ', sz - 1);
+    int len = strlen(str);
+    if(len <= sz - 1)
+        memcpy(buf, str, len);
+    else
+        fatal("overrun");
+    buf[sz - 1] = 0;
+}
+
+void midend_serialise(midend *me,
+                      void (*write)(void *ctx, void *buf, int len),
+                      void *wctx)
+{
+    int i;
+
+    /*
+     * Each line of the save file contains three components. First
+     * exactly 8 characters of header word indicating what type of
+     * data is contained on the line; then a colon followed by a
+     * decimal integer giving the length of the main string on the
+     * line; then a colon followed by the string itself (exactly as
+     * many bytes as previously specified, no matter what they
+     * contain). Then a newline (of reasonably flexible form).
+     */
+#define wr(h,s) do { \
+    char hbuf[80]; \
+    char *str = (s); \
+    char lbuf[9]; \
+    copy_left_justified(lbuf, sizeof(lbuf), h); \
+    sprintf(hbuf, "%s:%d:", lbuf, (int)strlen(str)); \
+    write(wctx, hbuf, strlen(hbuf)); \
+    write(wctx, str, strlen(str)); \
+    write(wctx, "\n", 1); \
+} while (0)
+
+    /*
+     * Magic string identifying the file, and version number of the
+     * file format.
+     */
+    wr("SAVEFILE", SERIALISE_MAGIC);
+    wr("VERSION", SERIALISE_VERSION);
+
+    /*
+     * The game name. (Copied locally to avoid const annoyance.)
+     */
+    {
+        char *s = dupstr(me->ourgame->name);
+        wr("GAME", s);
+        sfree(s);
+    }
+
+    /*
+     * The current long-term parameters structure, in full.
+     */
+    if (me->params) {
+        char *s = me->ourgame->encode_params(me->params, TRUE);
+        wr("PARAMS", s);
+        sfree(s);
+    }
+
+    /*
+     * The current short-term parameters structure, in full.
+     */
+    if (me->curparams) {
+        char *s = me->ourgame->encode_params(me->curparams, TRUE);
+        wr("CPARAMS", s);
+        sfree(s);
+    }
+
+    /*
+     * The current game description, the privdesc, and the random seed.
+     */
+    if (me->seedstr)
+        wr("SEED", me->seedstr);
+    if (me->desc)
+        wr("DESC", me->desc);
+    if (me->privdesc)
+        wr("PRIVDESC", me->privdesc);
+
+    /*
+     * The game's aux_info. We obfuscate this to prevent spoilers
+     * (people are likely to run `head' or similar on a saved game
+     * file simply to find out what it is, and don't necessarily
+     * want to be told the answer to the puzzle!)
+     */
+    if (me->aux_info) {
+        unsigned char *s1;
+        char *s2;
+        int len;
+
+        len = strlen(me->aux_info);
+        s1 = snewn(len, unsigned char);
+        memcpy(s1, me->aux_info, len);
+        obfuscate_bitmap(s1, len*8, FALSE);
+        s2 = bin2hex(s1, len);
+
+        wr("AUXINFO", s2);
+
+        sfree(s2);
+        sfree(s1);
+    }
+
+    /*
+     * Any required serialisation of the game_ui.
+     */
+    if (me->ui) {
+        char *s = me->ourgame->encode_ui(me->ui);
+        if (s) {
+            wr("UI", s);
+            sfree(s);
+        }
+    }
+
+    /*
+     * The game time, if it's a timed game.
+     */
+    if (me->ourgame->is_timed) {
+        char buf[80];
+        sprintf(buf, "%g", me->elapsed);
+        wr("TIME", buf);
+    }
+
+    /*
+     * The length of, and position in, the states list.
+     */
+    {
+        char buf[80];
+        sprintf(buf, "%d", me->nstates);
+        wr("NSTATES", buf);
+        sprintf(buf, "%d", me->statepos);
+        wr("STATEPOS", buf);
+    }
+
+    /*
+     * For each state after the initial one (which we know is
+     * constructed from either privdesc or desc), enough
+     * information for execute_move() to reconstruct it from the
+     * previous one.
+     */
+    for (i = 1; i < me->nstates; i++) {
+        assert(me->states[i].movetype != NEWGAME);   /* only state 0 */
+        switch (me->states[i].movetype) {
+          case MOVE:
+            wr("MOVE", me->states[i].movestr);
+            break;
+          case SOLVE:
+            wr("SOLVE", me->states[i].movestr);
+            break;
+          case RESTART:
+            wr("RESTART", me->states[i].movestr);
+            break;
+        }
+    }
+
+#undef wr
+}
+
+/*
+ * This function returns NULL on success, or an error message.
+ */
+char *midend_deserialise(midend *me,
+                         int (*read)(void *ctx, void *buf, int len),
+                         void *rctx)
+{
+    int nstates = 0, statepos = -1, gotstates = 0;
+    int started = FALSE;
+    int i;
+
+    char *val = NULL;
+    /* Initially all errors give the same report */
+    char *ret = "Data does not appear to be a saved game file";
+
+    /*
+     * We construct all the new state in local variables while we
+     * check its sanity. Only once we have finished reading the
+     * serialised data and detected no errors at all do we start
+     * modifying stuff in the midend passed in.
+     */
+    char *seed = NULL, *parstr = NULL, *desc = NULL, *privdesc = NULL;
+    char *auxinfo = NULL, *uistr = NULL, *cparstr = NULL;
+    float elapsed = 0.0F;
+    game_params *params = NULL, *cparams = NULL;
+    game_ui *ui = NULL;
+    struct midend_state_entry *states = NULL;
+
+    /*
+     * Loop round and round reading one key/value pair at a time
+     * from the serialised stream, until we have enough game states
+     * to finish.
+     */
+    while (nstates <= 0 || statepos < 0 || gotstates < nstates-1) {
+        char key[9], c;
+        int len;
+
+        do {
+            if (!read(rctx, key, 1)) {
+                /* unexpected EOF */
+                goto cleanup;
+            }
+        } while (key[0] == '\r' || key[0] == '\n');
+
+        if (!read(rctx, key+1, 8)) {
+            /* unexpected EOF */
+            goto cleanup;
+        }
+
+        if (key[8] != ':') {
+            if (started)
+                ret = "Data was incorrectly formatted for a saved game file";
+            goto cleanup;
+        }
+        len = strcspn(key, ": ");
+        assert(len <= 8);
+        key[len] = '\0';
+
+        len = 0;
+        while (1) {
+            if (!read(rctx, &c, 1)) {
+                /* unexpected EOF */
+                goto cleanup;
+            }
+
+            if (c == ':') {
+                break;
+            } else if (c >= '0' && c <= '9') {
+                len = (len * 10) + (c - '0');
+            } else {
+                if (started)
+                    ret = "Data was incorrectly formatted for a"
+                    " saved game file";
+                goto cleanup;
+            }
+        }
+
+        val = snewn(len+1, char);
+        if (!read(rctx, val, len)) {
+            if (started)
+            goto cleanup;
+        }
+        val[len] = '\0';
+
+        if (!started) {
+            if (strcmp(key, "SAVEFILE") || strcmp(val, SERIALISE_MAGIC)) {
+                /* ret already has the right message in it */
+                goto cleanup;
+            }
+            /* Now most errors are this one, unless otherwise specified */
+            ret = "Saved data ended unexpectedly";
+            started = TRUE;
+        } else {
+            if (!strcmp(key, "VERSION")) {
+                if (strcmp(val, SERIALISE_VERSION)) {
+                    ret = "Cannot handle this version of the saved game"
+                        " file format";
+                    goto cleanup;
+                }
+            } else if (!strcmp(key, "GAME")) {
+                if (strcmp(val, me->ourgame->name)) {
+                    ret = "Save file is from a different game";
+                    goto cleanup;
+                }
+            } else if (!strcmp(key, "PARAMS")) {
+                sfree(parstr);
+                parstr = val;
+                val = NULL;
+            } else if (!strcmp(key, "CPARAMS")) {
+                sfree(cparstr);
+                cparstr = val;
+                val = NULL;
+            } else if (!strcmp(key, "SEED")) {
+                sfree(seed);
+                seed = val;
+                val = NULL;
+            } else if (!strcmp(key, "DESC")) {
+                sfree(desc);
+                desc = val;
+                val = NULL;
+            } else if (!strcmp(key, "PRIVDESC")) {
+                sfree(privdesc);
+                privdesc = val;
+                val = NULL;
+            } else if (!strcmp(key, "AUXINFO")) {
+                unsigned char *tmp;
+                int len = strlen(val) / 2;   /* length in bytes */
+                tmp = hex2bin(val, len);
+                obfuscate_bitmap(tmp, len*8, TRUE);
+
+                sfree(auxinfo);
+                auxinfo = snewn(len + 1, char);
+                memcpy(auxinfo, tmp, len);
+                auxinfo[len] = '\0';
+                sfree(tmp);
+            } else if (!strcmp(key, "UI")) {
+                sfree(uistr);
+                uistr = val;
+                val = NULL;
+            } else if (!strcmp(key, "TIME")) {
+                elapsed = (float)atof(val);
+            } else if (!strcmp(key, "NSTATES")) {
+                nstates = atoi(val);
+                if (nstates <= 0) {
+                    ret = "Number of states in save file was negative";
+                    goto cleanup;
+                }
+                if (states) {
+                    ret = "Two state counts provided in save file";
+                    goto cleanup;
+                }
+                states = snewn(nstates, struct midend_state_entry);
+                for (i = 0; i < nstates; i++) {
+                    states[i].state = NULL;
+                    states[i].movestr = NULL;
+                    states[i].movetype = NEWGAME;
+                }
+            } else if (!strcmp(key, "STATEPOS")) {
+                statepos = atoi(val);
+            } else if (!strcmp(key, "MOVE")) {
+                gotstates++;
+                states[gotstates].movetype = MOVE;
+                states[gotstates].movestr = val;
+                val = NULL;
+            } else if (!strcmp(key, "SOLVE")) {
+                gotstates++;
+                states[gotstates].movetype = SOLVE;
+                states[gotstates].movestr = val;
+                val = NULL;
+            } else if (!strcmp(key, "RESTART")) {
+                gotstates++;
+                states[gotstates].movetype = RESTART;
+                states[gotstates].movestr = val;
+                val = NULL;
+            }
+        }
+
+        sfree(val);
+        val = NULL;
+    }
+
+    params = me->ourgame->default_params();
+    me->ourgame->decode_params(params, parstr);
+    if (me->ourgame->validate_params(params, TRUE)) {
+        ret = "Long-term parameters in save file are invalid";
+        goto cleanup;
+    }
+    cparams = me->ourgame->default_params();
+    me->ourgame->decode_params(cparams, cparstr);
+    if (me->ourgame->validate_params(cparams, FALSE)) {
+        ret = "Short-term parameters in save file are invalid";
+        goto cleanup;
+    }
+    if (seed && me->ourgame->validate_params(cparams, TRUE)) {
+        /*
+         * The seed's no use with this version, but we can perfectly
+         * well use the rest of the data.
+         */
+        sfree(seed);
+        seed = NULL;
+    }
+    if (!desc) {
+        ret = "Game description in save file is missing";
+        goto cleanup;
+    } else if (me->ourgame->validate_desc(params, desc)) {
+        ret = "Game description in save file is invalid";
+        goto cleanup;
+    }
+    if (privdesc && me->ourgame->validate_desc(params, privdesc)) {
+        ret = "Game private description in save file is invalid";
+        goto cleanup;
+    }
+    if (statepos < 0 || statepos >= nstates) {
+        ret = "Game position in save file is out of range";
+    }
+
+    states[0].state = me->ourgame->new_game(me, params,
+                                            privdesc ? privdesc : desc);
+    for (i = 1; i < nstates; i++) {
+        assert(states[i].movetype != NEWGAME);
+        switch (states[i].movetype) {
+          case MOVE:
+          case SOLVE:
+            states[i].state = me->ourgame->execute_move(states[i-1].state,
+                                                        states[i].movestr);
+            if (states[i].state == NULL) {
+                ret = "Save file contained an invalid move";
+                goto cleanup;
+            }
+            break;
+          case RESTART:
+            if (me->ourgame->validate_desc(params, states[i].movestr)) {
+                ret = "Save file contained an invalid restart move";
+                goto cleanup;
+            }
+            states[i].state = me->ourgame->new_game(me, params,
+                                                    states[i].movestr);
+            break;
+        }
+    }
+
+    ui = me->ourgame->new_ui(states[0].state);
+    me->ourgame->decode_ui(ui, uistr);
+
+    /*
+     * Now we've run out of possible error conditions, so we're
+     * ready to start overwriting the real data in the current
+     * midend. We'll do this by swapping things with the local
+     * variables, so that the same cleanup code will free the old
+     * stuff.
+     */
+    {
+        char *tmp;
+
+        tmp = me->desc;
+        me->desc = desc;
+        desc = tmp;
+
+        tmp = me->privdesc;
+        me->privdesc = privdesc;
+        privdesc = tmp;
+
+        tmp = me->seedstr;
+        me->seedstr = seed;
+        seed = tmp;
+
+        tmp = me->aux_info;
+        me->aux_info = auxinfo;
+        auxinfo = tmp;
+    }
+
+    me->genmode = GOT_NOTHING;
+
+    me->statesize = nstates;
+    nstates = me->nstates;
+    me->nstates = me->statesize;
+    {
+        struct midend_state_entry *tmp;
+        tmp = me->states;
+        me->states = states;
+        states = tmp;
+    }
+    me->statepos = statepos;
+
+    {
+        game_params *tmp;
+
+        tmp = me->params;
+        me->params = params;
+        params = tmp;
+
+        tmp = me->curparams;
+        me->curparams = cparams;
+        cparams = tmp;
+    }
+
+    me->oldstate = NULL;
+    me->anim_time = me->anim_pos = me->flash_time = me->flash_pos = 0.0F;
+    me->dir = 0;
+
+    {
+        game_ui *tmp;
+
+        tmp = me->ui;
+        me->ui = ui;
+        ui = tmp;
+    }
+
+    me->elapsed = elapsed;
+    me->pressed_mouse_button = 0;
+
+    midend_set_timer(me);
+
+    if (me->drawstate)
+        me->ourgame->free_drawstate(me->drawing, me->drawstate);
+    me->drawstate =
+        me->ourgame->new_drawstate(me->drawing,
+                                   me->states[me->statepos-1].state);
+    midend_size_new_drawstate(me);
+
+    ret = NULL;                        /* success! */
+
+    cleanup:
+    sfree(val);
+    sfree(seed);
+    sfree(parstr);
+    sfree(cparstr);
+    sfree(desc);
+    sfree(privdesc);
+    sfree(auxinfo);
+    sfree(uistr);
+    if (params)
+        me->ourgame->free_params(params);
+    if (cparams)
+        me->ourgame->free_params(cparams);
+    if (ui)
+        me->ourgame->free_ui(ui);
+    if (states) {
+        int i;
+
+        for (i = 0; i < nstates; i++) {
+            if (states[i].state)
+                me->ourgame->free_game(states[i].state);
+            sfree(states[i].movestr);
+        }
+        sfree(states);
+    }
+
+    return ret;
+}
+
+/*
+ * This function examines a saved game file just far enough to
+ * determine which game type it contains. It returns NULL on success
+ * and the game name string in 'name' (which will be dynamically
+ * allocated and should be caller-freed), or an error message on
+ * failure.
+ */
+char *identify_game(char **name, int (*read)(void *ctx, void *buf, int len),
+                    void *rctx)
+{
+    int nstates = 0, statepos = -1, gotstates = 0;
+    int started = FALSE;
+
+    char *val = NULL;
+    /* Initially all errors give the same report */
+    char *ret = "Data does not appear to be a saved game file";
+
+    *name = NULL;
+
+    /*
+     * Loop round and round reading one key/value pair at a time from
+     * the serialised stream, until we've found the game name.
+     */
+    while (nstates <= 0 || statepos < 0 || gotstates < nstates-1) {
+        char key[9], c;
+        int len;
+
+        do {
+            if (!read(rctx, key, 1)) {
+                /* unexpected EOF */
+                goto cleanup;
+            }
+        } while (key[0] == '\r' || key[0] == '\n');
+
+        if (!read(rctx, key+1, 8)) {
+            /* unexpected EOF */
+            goto cleanup;
+        }
+
+        if (key[8] != ':') {
+            if (started)
+                ret = "Data was incorrectly formatted for a saved game file";
+            goto cleanup;
+        }
+        len = strcspn(key, ": ");
+        assert(len <= 8);
+        key[len] = '\0';
+
+        len = 0;
+        while (1) {
+            if (!read(rctx, &c, 1)) {
+                /* unexpected EOF */
+                goto cleanup;
+            }
+
+            if (c == ':') {
+                break;
+            } else if (c >= '0' && c <= '9') {
+                len = (len * 10) + (c - '0');
+            } else {
+                if (started)
+                    ret = "Data was incorrectly formatted for a"
+                    " saved game file";
+                goto cleanup;
+            }
+        }
+
+        val = snewn(len+1, char);
+        if (!read(rctx, val, len)) {
+            if (started)
+            goto cleanup;
+        }
+        val[len] = '\0';
+
+        if (!started) {
+            if (strcmp(key, "SAVEFILE") || strcmp(val, SERIALISE_MAGIC)) {
+                /* ret already has the right message in it */
+                goto cleanup;
+            }
+            /* Now most errors are this one, unless otherwise specified */
+            ret = "Saved data ended unexpectedly";
+            started = TRUE;
+        } else {
+            if (!strcmp(key, "VERSION")) {
+                if (strcmp(val, SERIALISE_VERSION)) {
+                    ret = "Cannot handle this version of the saved game"
+                        " file format";
+                    goto cleanup;
+                }
+            } else if (!strcmp(key, "GAME")) {
+                *name = dupstr(val);
+                ret = NULL;
+                goto cleanup;
+            }
+        }
+
+        sfree(val);
+        val = NULL;
+    }
+
+    cleanup:
+    sfree(val);
+    return ret;
+}
+
+char *midend_print_puzzle(midend *me, document *doc, int with_soln)
+{
+    game_state *soln = NULL;
+
+    if (me->statepos < 1)
+        return "No game set up to print";/* _shouldn't_ happen! */
+
+    if (with_soln) {
+        char *msg, *movestr;
+
+        if (!me->ourgame->can_solve)
+            return "This game does not support the Solve operation";
+
+        msg = "Solve operation failed";/* game _should_ overwrite on error */
+        movestr = me->ourgame->solve(me->states[0].state,
+                                     me->states[me->statepos-1].state,
+                                     me->aux_info, &msg);
+        if (!movestr)
+            return msg;
+        soln = me->ourgame->execute_move(me->states[me->statepos-1].state,
+                                         movestr);
+        assert(soln);
+
+        sfree(movestr);
+    } else
+        soln = NULL;
+
+    /*
+     * This call passes over ownership of the two game_states and
+     * the game_params. Hence we duplicate the ones we want to
+     * keep, and we don't have to bother freeing soln if it was
+     * non-NULL.
+     */
+    document_add_puzzle(doc, me->ourgame,
+                        me->ourgame->dup_params(me->curparams),
+                        me->ourgame->dup_game(me->states[0].state), soln);
+
+    return NULL;
+}
diff --git a/apps/plugins/puzzles/mines.R b/apps/plugins/puzzles/mines.R
new file mode 100644
index 0000000000..275c76c7ad
--- /dev/null
+++ b/apps/plugins/puzzles/mines.R
@@ -0,0 +1,24 @@
+# -*- makefile -*-
+
+MINES_EXTRA = tree234
+
+mines    : [X] GTK COMMON mines MINES_EXTRA mines-icon|no-icon
+
+mines    : [G] WINDOWS COMMON mines MINES_EXTRA mines.res|noicon.res
+
+mineobfusc :    [U] mines[STANDALONE_OBFUSCATOR] MINES_EXTRA STANDALONE
+mineobfusc :    [C] mines[STANDALONE_OBFUSCATOR] MINES_EXTRA STANDALONE
+
+ALL += mines[COMBINED] MINES_EXTRA
+
+!begin am gtk
+GAMES += mines
+!end
+
+!begin >list.c
+    A(mines) \
+!end
+
+!begin >gamedesc.txt
+mines:mines.exe:Mines:Mine-finding puzzle:Find all the mines without treading on any of them.
+!end
diff --git a/apps/plugins/puzzles/mines.c b/apps/plugins/puzzles/mines.c
new file mode 100644
index 0000000000..deb71aed6b
--- /dev/null
+++ b/apps/plugins/puzzles/mines.c
@@ -0,0 +1,3250 @@
+/*
+ * mines.c: Minesweeper clone with sophisticated grid generation.
+ * 
+ * Still TODO:
+ *
+ *  - think about configurably supporting question marks. Once,
+ *    that is, we've thought about configurability in general!
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "tree234.h"
+#include "puzzles.h"
+
+enum {
+    COL_BACKGROUND, COL_BACKGROUND2,
+    COL_1, COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8,
+    COL_MINE, COL_BANG, COL_CROSS, COL_FLAG, COL_FLAGBASE, COL_QUERY,
+    COL_HIGHLIGHT, COL_LOWLIGHT,
+    COL_WRONGNUMBER,
+    COL_CURSOR,
+    NCOLOURS
+};
+
+#define PREFERRED_TILE_SIZE 20
+#define TILE_SIZE (ds->tilesize)
+#ifdef SMALL_SCREEN
+#define BORDER 8
+#else
+#define BORDER (TILE_SIZE * 3 / 2)
+#endif
+#define HIGHLIGHT_WIDTH (TILE_SIZE / 10)
+#define OUTER_HIGHLIGHT_WIDTH (BORDER / 10)
+#define COORD(x)  ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
+
+#define FLASH_FRAME 0.13F
+
+struct game_params {
+    int w, h, n;
+    int unique;
+};
+
+struct mine_layout {
+    /*
+     * This structure is shared between all the game_states for a
+     * given instance of the puzzle, so we reference-count it.
+     */
+    int refcount;
+    char *mines;
+    /*
+     * If we haven't yet actually generated the mine layout, here's
+     * all the data we will need to do so.
+     */
+    int n, unique;
+    random_state *rs;
+    midend *me;                /* to give back the new game desc */
+};
+
+struct game_state {
+    int w, h, n, dead, won;
+    int used_solve;
+    struct mine_layout *layout;        /* real mine positions */
+    signed char *grid;                         /* player knowledge */
+    /*
+     * Each item in the `grid' array is one of the following values:
+     * 
+     *  - 0 to 8 mean the square is open and has a surrounding mine
+     *    count.
+     * 
+     *  - -1 means the square is marked as a mine.
+     * 
+     *  - -2 means the square is unknown.
+     * 
+     *  - -3 means the square is marked with a question mark
+     *    (FIXME: do we even want to bother with this?).
+     * 
+     *  - 64 means the square has had a mine revealed when the game
+     *    was lost.
+     * 
+     *  - 65 means the square had a mine revealed and this was the
+     *    one the player hits.
+     * 
+     *  - 66 means the square has a crossed-out mine because the
+     *    player had incorrectly marked it.
+     */
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 9;
+    ret->n = 10;
+    ret->unique = TRUE;
+
+    return ret;
+}
+
+static const struct game_params mines_presets[] = {
+  {9, 9, 10, TRUE},
+  {9, 9, 35, TRUE},
+  {16, 16, 40, TRUE},
+  {16, 16, 99, TRUE},
+#ifndef SMALL_SCREEN
+  {30, 16, 99, TRUE},
+  {30, 16, 170, TRUE},
+#endif
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(mines_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = mines_presets[i];
+
+    sprintf(str, "%dx%d, %d mines", ret->w, ret->h, ret->n);
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    char const *p = string;
+
+    params->w = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+    if (*p == 'x') {
+        p++;
+        params->h = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+    } else {
+        params->h = params->w;
+    }
+    if (*p == 'n') {
+        p++;
+        params->n = atoi(p);
+        while (*p && (*p == '.' || isdigit((unsigned char)*p))) p++;
+    } else {
+        params->n = params->w * params->h / 10;
+    }
+
+    while (*p) {
+        if (*p == 'a') {
+            p++;
+            params->unique = FALSE;
+        } else
+            p++;                       /* skip any other gunk */
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char ret[400];
+    int len;
+
+    len = sprintf(ret, "%dx%d", params->w, params->h);
+    /*
+     * Mine count is a generation-time parameter, since it can be
+     * deduced from the mine bitmap!
+     */
+    if (full)
+        len += sprintf(ret+len, "n%d", params->n);
+    if (full && !params->unique)
+        ret[len++] = 'a';
+    assert(len < lenof(ret));
+    ret[len] = '\0';
+
+    return dupstr(ret);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(5, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Mines";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->n);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = "Ensure solubility";
+    ret[3].type = C_BOOLEAN;
+    ret[3].sval = NULL;
+    ret[3].ival = params->unique;
+
+    ret[4].name = NULL;
+    ret[4].type = C_END;
+    ret[4].sval = NULL;
+    ret[4].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->n = atoi(cfg[2].sval);
+    if (strchr(cfg[2].sval, '%'))
+        ret->n = ret->n * (ret->w * ret->h) / 100;
+    ret->unique = cfg[3].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    /*
+     * Lower limit on grid size: each dimension must be at least 3.
+     * 1 is theoretically workable if rather boring, but 2 is a
+     * real problem: there is often _no_ way to generate a uniquely
+     * solvable 2xn Mines grid. You either run into two mines
+     * blocking the way and no idea what's behind them, or one mine
+     * and no way to know which of the two rows it's in. If the
+     * mine count is even you can create a soluble grid by packing
+     * all the mines at one end (so what when you hit a two-mine
+     * wall there are only as many covered squares left as there
+     * are mines); but if it's odd, you are doomed, because you
+     * _have_ to have a gap somewhere which you can't determine the
+     * position of.
+     */
+    if (full && params->unique && (params->w <= 2 || params->h <= 2))
+        return "Width and height must both be greater than two";
+    if (params->n > params->w * params->h - 9)
+        return "Too many mines for grid size";
+
+    /*
+     * FIXME: Need more constraints here. Not sure what the
+     * sensible limits for Minesweeper actually are. The limits
+     * probably ought to change, however, depending on uniqueness.
+     */
+
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Minesweeper solver, used to ensure the generated grids are
+ * solvable without having to take risks.
+ */
+
+/*
+ * Count the bits in a word. Only needs to cope with 16 bits.
+ */
+static int bitcount16(int inword)
+{
+    unsigned int word = inword;
+
+    word = ((word & 0xAAAA) >> 1) + (word & 0x5555);
+    word = ((word & 0xCCCC) >> 2) + (word & 0x3333);
+    word = ((word & 0xF0F0) >> 4) + (word & 0x0F0F);
+    word = ((word & 0xFF00) >> 8) + (word & 0x00FF);
+
+    return (int)word;
+}
+
+/*
+ * We use a tree234 to store a large number of small localised
+ * sets, each with a mine count. We also keep some of those sets
+ * linked together into a to-do list.
+ */
+struct set {
+    short x, y, mask, mines;
+    int todo;
+    struct set *prev, *next;
+};
+
+static int setcmp(void *av, void *bv)
+{
+    struct set *a = (struct set *)av;
+    struct set *b = (struct set *)bv;
+
+    if (a->y < b->y)
+        return -1;
+    else if (a->y > b->y)
+        return +1;
+    else if (a->x < b->x)
+        return -1;
+    else if (a->x > b->x)
+        return +1;
+    else if (a->mask < b->mask)
+        return -1;
+    else if (a->mask > b->mask)
+        return +1;
+    else
+        return 0;
+}
+
+struct setstore {
+    tree234 *sets;
+    struct set *todo_head, *todo_tail;
+};
+
+static struct setstore *ss_new(void)
+{
+    struct setstore *ss = snew(struct setstore);
+    ss->sets = newtree234(setcmp);
+    ss->todo_head = ss->todo_tail = NULL;
+    return ss;
+}
+
+/*
+ * Take two input sets, in the form (x,y,mask). Munge the first by
+ * taking either its intersection with the second or its difference
+ * with the second. Return the new mask part of the first set.
+ */
+static int setmunge(int x1, int y1, int mask1, int x2, int y2, int mask2,
+                    int diff)
+{
+    /*
+     * Adjust the second set so that it has the same x,y
+     * coordinates as the first.
+     */
+    if (abs(x2-x1) >= 3 || abs(y2-y1) >= 3) {
+        mask2 = 0;
+    } else {
+        while (x2 > x1) {
+            mask2 &= ~(4|32|256);
+            mask2 <<= 1;
+            x2--;
+        }
+        while (x2 < x1) {
+            mask2 &= ~(1|8|64);
+            mask2 >>= 1;
+            x2++;
+        }
+        while (y2 > y1) {
+            mask2 &= ~(64|128|256);
+            mask2 <<= 3;
+            y2--;
+        }
+        while (y2 < y1) {
+            mask2 &= ~(1|2|4);
+            mask2 >>= 3;
+            y2++;
+        }
+    }
+
+    /*
+     * Invert the second set if `diff' is set (we're after A &~ B
+     * rather than A & B).
+     */
+    if (diff)
+        mask2 ^= 511;
+
+    /*
+     * Now all that's left is a logical AND.
+     */
+    return mask1 & mask2;
+}
+
+static void ss_add_todo(struct setstore *ss, struct set *s)
+{
+    if (s->todo)
+        return;                        /* already on it */
+
+#ifdef SOLVER_DIAGNOSTICS
+    printf("adding set on todo list: %d,%d %03x %d\n",
+           s->x, s->y, s->mask, s->mines);
+#endif
+
+    s->prev = ss->todo_tail;
+    if (s->prev)
+        s->prev->next = s;
+    else
+        ss->todo_head = s;
+    ss->todo_tail = s;
+    s->next = NULL;
+    s->todo = TRUE;
+}
+
+static void ss_add(struct setstore *ss, int x, int y, int mask, int mines)
+{
+    struct set *s;
+
+    assert(mask != 0);
+
+    /*
+     * Normalise so that x and y are genuinely the bounding
+     * rectangle.
+     */
+    while (!(mask & (1|8|64)))
+        mask >>= 1, x++;
+    while (!(mask & (1|2|4)))
+        mask >>= 3, y++;
+
+    /*
+     * Create a set structure and add it to the tree.
+     */
+    s = snew(struct set);
+    s->x = x;
+    s->y = y;
+    s->mask = mask;
+    s->mines = mines;
+    s->todo = FALSE;
+    if (add234(ss->sets, s) != s) {
+        /*
+         * This set already existed! Free it and return.
+         */
+        sfree(s);
+        return;
+    }
+
+    /*
+     * We've added a new set to the tree, so put it on the todo
+     * list.
+     */
+    ss_add_todo(ss, s);
+}
+
+static void ss_remove(struct setstore *ss, struct set *s)
+{
+    struct set *next = s->next, *prev = s->prev;
+
+#ifdef SOLVER_DIAGNOSTICS
+    printf("removing set %d,%d %03x\n", s->x, s->y, s->mask);
+#endif
+    /*
+     * Remove s from the todo list.
+     */
+    if (prev)
+        prev->next = next;
+    else if (s == ss->todo_head)
+        ss->todo_head = next;
+
+    if (next)
+        next->prev = prev;
+    else if (s == ss->todo_tail)
+        ss->todo_tail = prev;
+
+    s->todo = FALSE;
+
+    /*
+     * Remove s from the tree.
+     */
+    del234(ss->sets, s);
+
+    /*
+     * Destroy the actual set structure.
+     */
+    sfree(s);
+}
+
+/*
+ * Return a dynamically allocated list of all the sets which
+ * overlap a provided input set.
+ */
+static struct set **ss_overlap(struct setstore *ss, int x, int y, int mask)
+{
+    struct set **ret = NULL;
+    int nret = 0, retsize = 0;
+    int xx, yy;
+
+    for (xx = x-3; xx < x+3; xx++)
+        for (yy = y-3; yy < y+3; yy++) {
+            struct set stmp, *s;
+            int pos;
+
+            /*
+             * Find the first set with these top left coordinates.
+             */
+            stmp.x = xx;
+            stmp.y = yy;
+            stmp.mask = 0;
+
+            if (findrelpos234(ss->sets, &stmp, NULL, REL234_GE, &pos)) {
+                while ((s = index234(ss->sets, pos)) != NULL &&
+                       s->x == xx && s->y == yy) {
+                    /*
+                     * This set potentially overlaps the input one.
+                     * Compute the intersection to see if they
+                     * really overlap, and add it to the list if
+                     * so.
+                     */
+                    if (setmunge(x, y, mask, s->x, s->y, s->mask, FALSE)) {
+                        /*
+                         * There's an overlap.
+                         */
+                        if (nret >= retsize) {
+                            retsize = nret + 32;
+                            ret = sresize(ret, retsize, struct set *);
+                        }
+                        ret[nret++] = s;
+                    }
+
+                    pos++;
+                }
+            }
+        }
+
+    ret = sresize(ret, nret+1, struct set *);
+    ret[nret] = NULL;
+
+    return ret;
+}
+
+/*
+ * Get an element from the head of the set todo list.
+ */
+static struct set *ss_todo(struct setstore *ss)
+{
+    if (ss->todo_head) {
+        struct set *ret = ss->todo_head;
+        ss->todo_head = ret->next;
+        if (ss->todo_head)
+            ss->todo_head->prev = NULL;
+        else
+            ss->todo_tail = NULL;
+        ret->next = ret->prev = NULL;
+        ret->todo = FALSE;
+        return ret;
+    } else {
+        return NULL;
+    }
+}
+
+struct squaretodo {
+    int *next;
+    int head, tail;
+};
+
+static void std_add(struct squaretodo *std, int i)
+{
+    if (std->tail >= 0)
+        std->next[std->tail] = i;
+    else
+        std->head = i;
+    std->tail = i;
+    std->next[i] = -1;
+}
+
+typedef int (*open_cb)(void *, int, int);
+
+static void known_squares(int w, int h, struct squaretodo *std,
+                          signed char *grid,
+                          open_cb open, void *openctx,
+                          int x, int y, int mask, int mine)
+{
+    int xx, yy, bit;
+
+    bit = 1;
+
+    for (yy = 0; yy < 3; yy++)
+        for (xx = 0; xx < 3; xx++) {
+            if (mask & bit) {
+                int i = (y + yy) * w + (x + xx);
+
+                /*
+                 * It's possible that this square is _already_
+                 * known, in which case we don't try to add it to
+                 * the list twice.
+                 */
+                if (grid[i] == -2) {
+
+                    if (mine) {
+                        grid[i] = -1;   /* and don't open it! */
+                    } else {
+                        grid[i] = open(openctx, x + xx, y + yy);
+                        assert(grid[i] != -1);   /* *bang* */
+                    }
+                    std_add(std, i);
+
+                }
+            }
+            bit <<= 1;
+        }
+}
+
+/*
+ * This is data returned from the `perturb' function. It details
+ * which squares have become mines and which have become clear. The
+ * solver is (of course) expected to honourably not use that
+ * knowledge directly, but to efficently adjust its internal data
+ * structures and proceed based on only the information it
+ * legitimately has.
+ */
+struct perturbation {
+    int x, y;
+    int delta;                         /* +1 == become a mine; -1 == cleared */
+};
+struct perturbations {
+    int n;
+    struct perturbation *changes;
+};
+
+/*
+ * Main solver entry point. You give it a grid of existing
+ * knowledge (-1 for a square known to be a mine, 0-8 for empty
+ * squares with a given number of neighbours, -2 for completely
+ * unknown), plus a function which you can call to open new squares
+ * once you're confident of them. It fills in as much more of the
+ * grid as it can.
+ * 
+ * Return value is:
+ * 
+ *  - -1 means deduction stalled and nothing could be done
+ *  - 0 means deduction succeeded fully
+ *  - >0 means deduction succeeded but some number of perturbation
+ *    steps were required; the exact return value is the number of
+ *    perturb calls.
+ */
+
+typedef struct perturbations *(*perturb_cb) (void *, signed char *, int, int, int);
+
+static int minesolve(int w, int h, int n, signed char *grid,
+                     open_cb open,
+                     perturb_cb perturb,
+                     void *ctx, random_state *rs)
+{
+    struct setstore *ss = ss_new();
+    struct set **list;
+    struct squaretodo astd, *std = &astd;
+    int x, y, i, j;
+    int nperturbs = 0;
+
+    /*
+     * Set up a linked list of squares with known contents, so that
+     * we can process them one by one.
+     */
+    std->next = snewn(w*h, int);
+    std->head = std->tail = -1;
+
+    /*
+     * Initialise that list with all known squares in the input
+     * grid.
+     */
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            i = y*w+x;
+            if (grid[i] != -2)
+                std_add(std, i);
+        }
+    }
+
+    /*
+     * Main deductive loop.
+     */
+    while (1) {
+        int done_something = FALSE;
+        struct set *s;
+
+        /*
+         * If there are any known squares on the todo list, process
+         * them and construct a set for each.
+         */
+        while (std->head != -1) {
+            i = std->head;
+#ifdef SOLVER_DIAGNOSTICS
+            printf("known square at %d,%d [%d]\n", i%w, i/w, grid[i]);
+#endif
+            std->head = std->next[i];
+            if (std->head == -1)
+                std->tail = -1;
+
+            x = i % w;
+            y = i / w;
+
+            if (grid[i] >= 0) {
+                int dx, dy, mines, bit, val;
+#ifdef SOLVER_DIAGNOSTICS
+                printf("creating set around this square\n");
+#endif
+                /*
+                 * Empty square. Construct the set of non-known squares
+                 * around this one, and determine its mine count.
+                 */
+                mines = grid[i];
+                bit = 1;
+                val = 0;
+                for (dy = -1; dy <= +1; dy++) {
+                    for (dx = -1; dx <= +1; dx++) {
+#ifdef SOLVER_DIAGNOSTICS
+                        printf("grid %d,%d = %d\n", x+dx, y+dy, grid[i+dy*w+dx]);
+#endif
+                        if (x+dx < 0 || x+dx >= w || y+dy < 0 || y+dy >= h)
+                            /* ignore this one */;
+                        else if (grid[i+dy*w+dx] == -1)
+                            mines--;
+                        else if (grid[i+dy*w+dx] == -2)
+                            val |= bit;
+                        bit <<= 1;
+                    }
+                }
+                if (val)
+                    ss_add(ss, x-1, y-1, val, mines);
+            }
+
+            /*
+             * Now, whether the square is empty or full, we must
+             * find any set which contains it and replace it with
+             * one which does not.
+             */
+            {
+#ifdef SOLVER_DIAGNOSTICS
+                printf("finding sets containing known square %d,%d\n", x, y);
+#endif
+                list = ss_overlap(ss, x, y, 1);
+
+                for (j = 0; list[j]; j++) {
+                    int newmask, newmines;
+
+                    s = list[j];
+
+                    /*
+                     * Compute the mask for this set minus the
+                     * newly known square.
+                     */
+                    newmask = setmunge(s->x, s->y, s->mask, x, y, 1, TRUE);
+
+                    /*
+                     * Compute the new mine count.
+                     */
+                    newmines = s->mines - (grid[i] == -1);
+
+                    /*
+                     * Insert the new set into the collection,
+                     * unless it's been whittled right down to
+                     * nothing.
+                     */
+                    if (newmask)
+                        ss_add(ss, s->x, s->y, newmask, newmines);
+
+                    /*
+                     * Destroy the old one; it is actually obsolete.
+                     */
+                    ss_remove(ss, s);
+                }
+
+                sfree(list);
+            }
+
+            /*
+             * Marking a fresh square as known certainly counts as
+             * doing something.
+             */
+            done_something = TRUE;
+        }
+
+        /*
+         * Now pick a set off the to-do list and attempt deductions
+         * based on it.
+         */
+        if ((s = ss_todo(ss)) != NULL) {
+
+#ifdef SOLVER_DIAGNOSTICS
+            printf("set to do: %d,%d %03x %d\n", s->x, s->y, s->mask, s->mines);
+#endif
+            /*
+             * Firstly, see if this set has a mine count of zero or
+             * of its own cardinality.
+             */
+            if (s->mines == 0 || s->mines == bitcount16(s->mask)) {
+                /*
+                 * If so, we can immediately mark all the squares
+                 * in the set as known.
+                 */
+#ifdef SOLVER_DIAGNOSTICS
+                printf("easy\n");
+#endif
+                known_squares(w, h, std, grid, open, ctx,
+                              s->x, s->y, s->mask, (s->mines != 0));
+
+                /*
+                 * Having done that, we need do nothing further
+                 * with this set; marking all the squares in it as
+                 * known will eventually eliminate it, and will
+                 * also permit further deductions about anything
+                 * that overlaps it.
+                 */
+                continue;
+            }
+
+            /*
+             * Failing that, we now search through all the sets
+             * which overlap this one.
+             */
+            list = ss_overlap(ss, s->x, s->y, s->mask);
+
+            for (j = 0; list[j]; j++) {
+                struct set *s2 = list[j];
+                int swing, s2wing, swc, s2wc;
+
+                /*
+                 * Find the non-overlapping parts s2-s and s-s2,
+                 * and their cardinalities.
+                 * 
+                 * I'm going to refer to these parts as `wings'
+                 * surrounding the central part common to both
+                 * sets. The `s wing' is s-s2; the `s2 wing' is
+                 * s2-s.
+                 */
+                swing = setmunge(s->x, s->y, s->mask, s2->x, s2->y, s2->mask,
+                                 TRUE);
+                s2wing = setmunge(s2->x, s2->y, s2->mask, s->x, s->y, s->mask,
+                                 TRUE);
+                swc = bitcount16(swing);
+                s2wc = bitcount16(s2wing);
+
+                /*
+                 * If one set has more mines than the other, and
+                 * the number of extra mines is equal to the
+                 * cardinality of that set's wing, then we can mark
+                 * every square in the wing as a known mine, and
+                 * every square in the other wing as known clear.
+                 */
+                if (swc == s->mines - s2->mines ||
+                    s2wc == s2->mines - s->mines) {
+                    known_squares(w, h, std, grid, open, ctx,
+                                  s->x, s->y, swing,
+                                  (swc == s->mines - s2->mines));
+                    known_squares(w, h, std, grid, open, ctx,
+                                  s2->x, s2->y, s2wing,
+                                  (s2wc == s2->mines - s->mines));
+                    continue;
+                }
+
+                /*
+                 * Failing that, see if one set is a subset of the
+                 * other. If so, we can divide up the mine count of
+                 * the larger set between the smaller set and its
+                 * complement, even if neither smaller set ends up
+                 * being immediately clearable.
+                 */
+                if (swc == 0 && s2wc != 0) {
+                    /* s is a subset of s2. */
+                    assert(s2->mines > s->mines);
+                    ss_add(ss, s2->x, s2->y, s2wing, s2->mines - s->mines);
+                } else if (s2wc == 0 && swc != 0) {
+                    /* s2 is a subset of s. */
+                    assert(s->mines > s2->mines);
+                    ss_add(ss, s->x, s->y, swing, s->mines - s2->mines);
+                }
+            }
+
+            sfree(list);
+
+            /*
+             * In this situation we have definitely done
+             * _something_, even if it's only reducing the size of
+             * our to-do list.
+             */
+            done_something = TRUE;
+        } else if (n >= 0) {
+            /*
+             * We have nothing left on our todo list, which means
+             * all localised deductions have failed. Our next step
+             * is to resort to global deduction based on the total
+             * mine count. This is computationally expensive
+             * compared to any of the above deductions, which is
+             * why we only ever do it when all else fails, so that
+             * hopefully it won't have to happen too often.
+             * 
+             * If you pass n<0 into this solver, that informs it
+             * that you do not know the total mine count, so it
+             * won't even attempt these deductions.
+             */
+
+            int minesleft, squaresleft;
+            int nsets, setused[10], cursor;
+
+            /*
+             * Start by scanning the current grid state to work out
+             * how many unknown squares we still have, and how many
+             * mines are to be placed in them.
+             */
+            squaresleft = 0;
+            minesleft = n;
+            for (i = 0; i < w*h; i++) {
+                if (grid[i] == -1)
+                    minesleft--;
+                else if (grid[i] == -2)
+                    squaresleft++;
+            }
+
+#ifdef SOLVER_DIAGNOSTICS
+            printf("global deduction time: squaresleft=%d minesleft=%d\n",
+                   squaresleft, minesleft);
+            for (y = 0; y < h; y++) {
+                for (x = 0; x < w; x++) {
+                    int v = grid[y*w+x];
+                    if (v == -1)
+                        putchar('*');
+                    else if (v == -2)
+                        putchar('?');
+                    else if (v == 0)
+                        putchar('-');
+                    else
+                        putchar('0' + v);
+                }
+                putchar('\n');
+            }
+#endif
+
+            /*
+             * If there _are_ no unknown squares, we have actually
+             * finished.
+             */
+            if (squaresleft == 0) {
+                assert(minesleft == 0);
+                break;
+            }
+
+            /*
+             * First really simple case: if there are no more mines
+             * left, or if there are exactly as many mines left as
+             * squares to play them in, then it's all easy.
+             */
+            if (minesleft == 0 || minesleft == squaresleft) {
+                for (i = 0; i < w*h; i++)
+                    if (grid[i] == -2)
+                        known_squares(w, h, std, grid, open, ctx,
+                                      i % w, i / w, 1, minesleft != 0);
+                continue;              /* now go back to main deductive loop */
+            }
+
+            /*
+             * Failing that, we have to do some _real_ work.
+             * Ideally what we do here is to try every single
+             * combination of the currently available sets, in an
+             * attempt to find a disjoint union (i.e. a set of
+             * squares with a known mine count between them) such
+             * that the remaining unknown squares _not_ contained
+             * in that union either contain no mines or are all
+             * mines.
+             * 
+             * Actually enumerating all 2^n possibilities will get
+             * a bit slow for large n, so I artificially cap this
+             * recursion at n=10 to avoid too much pain.
+             */
+            nsets = count234(ss->sets);
+            if (nsets <= lenof(setused)) {
+                /*
+                 * Doing this with actual recursive function calls
+                 * would get fiddly because a load of local
+                 * variables from this function would have to be
+                 * passed down through the recursion. So instead
+                 * I'm going to use a virtual recursion within this
+                 * function. The way this works is:
+                 * 
+                 *  - we have an array `setused', such that
+                 *    setused[n] is 0 or 1 depending on whether set
+                 *    n is currently in the union we are
+                 *    considering.
+                 * 
+                 *  - we have a value `cursor' which indicates how
+                 *    much of `setused' we have so far filled in.
+                 *    It's conceptually the recursion depth.
+                 * 
+                 * We begin by setting `cursor' to zero. Then:
+                 * 
+                 *  - if cursor can advance, we advance it by one.
+                 *    We set the value in `setused' that it went
+                 *    past to 1 if that set is disjoint from
+                 *    anything else currently in `setused', or to 0
+                 *    otherwise.
+                 * 
+                 *  - If cursor cannot advance because it has
+                 *    reached the end of the setused list, then we
+                 *    have a maximal disjoint union. Check to see
+                 *    whether its mine count has any useful
+                 *    properties. If so, mark all the squares not
+                 *    in the union as known and terminate.
+                 * 
+                 *  - If cursor has reached the end of setused and
+                 *    the algorithm _hasn't_ terminated, back
+                 *    cursor up to the nearest 1, turn it into a 0
+                 *    and advance cursor just past it.
+                 * 
+                 *  - If we attempt to back up to the nearest 1 and
+                 *    there isn't one at all, then we have gone
+                 *    through all disjoint unions of sets in the
+                 *    list and none of them has been helpful, so we
+                 *    give up.
+                 */
+                struct set *sets[lenof(setused)];
+                for (i = 0; i < nsets; i++)
+                    sets[i] = index234(ss->sets, i);
+
+                cursor = 0;
+                while (1) {
+
+                    if (cursor < nsets) {
+                        int ok = TRUE;
+
+                        /* See if any existing set overlaps this one. */
+                        for (i = 0; i < cursor; i++)
+                            if (setused[i] &&
+                                setmunge(sets[cursor]->x,
+                                         sets[cursor]->y,
+                                         sets[cursor]->mask,
+                                         sets[i]->x, sets[i]->y, sets[i]->mask,
+                                         FALSE)) {
+                                ok = FALSE;
+                                break;
+                            }
+
+                        if (ok) {
+                            /*
+                             * We're adding this set to our union,
+                             * so adjust minesleft and squaresleft
+                             * appropriately.
+                             */
+                            minesleft -= sets[cursor]->mines;
+                            squaresleft -= bitcount16(sets[cursor]->mask);
+                        }
+
+                        setused[cursor++] = ok;
+                    } else {
+#ifdef SOLVER_DIAGNOSTICS
+                        printf("trying a set combination with %d %d\n",
+                               squaresleft, minesleft);
+#endif /* SOLVER_DIAGNOSTICS */
+
+                        /*
+                         * We've reached the end. See if we've got
+                         * anything interesting.
+                         */
+                        if (squaresleft > 0 &&
+                            (minesleft == 0 || minesleft == squaresleft)) {
+                            /*
+                             * We have! There is at least one
+                             * square not contained within the set
+                             * union we've just found, and we can
+                             * deduce that either all such squares
+                             * are mines or all are not (depending
+                             * on whether minesleft==0). So now all
+                             * we have to do is actually go through
+                             * the grid, find those squares, and
+                             * mark them.
+                             */
+                            for (i = 0; i < w*h; i++)
+                                if (grid[i] == -2) {
+                                    int outside = TRUE;
+                                    y = i / w;
+                                    x = i % w;
+                                    for (j = 0; j < nsets; j++)
+                                        if (setused[j] &&
+                                            setmunge(sets[j]->x, sets[j]->y,
+                                                     sets[j]->mask, x, y, 1,
+                                                     FALSE)) {
+                                            outside = FALSE;
+                                            break;
+                                        }
+                                    if (outside)
+                                        known_squares(w, h, std, grid,
+                                                      open, ctx,
+                                                      x, y, 1, minesleft != 0);
+                                }
+
+                            done_something = TRUE;
+                            break;     /* return to main deductive loop */
+                        }
+
+                        /*
+                         * If we reach here, then this union hasn't
+                         * done us any good, so move on to the
+                         * next. Backtrack cursor to the nearest 1,
+                         * change it to a 0 and continue.
+                         */
+                        while (--cursor >= 0 && !setused[cursor]);
+                        if (cursor >= 0) {
+                            assert(setused[cursor]);
+
+                            /*
+                             * We're removing this set from our
+                             * union, so re-increment minesleft and
+                             * squaresleft.
+                             */
+                            minesleft += sets[cursor]->mines;
+                            squaresleft += bitcount16(sets[cursor]->mask);
+
+                            setused[cursor++] = 0;
+                        } else {
+                            /*
+                             * We've backtracked all the way to the
+                             * start without finding a single 1,
+                             * which means that our virtual
+                             * recursion is complete and nothing
+                             * helped.
+                             */
+                            break;
+                        }
+                    }
+
+                }
+
+            }
+        }
+
+        if (done_something)
+            continue;
+
+#ifdef SOLVER_DIAGNOSTICS
+        /*
+         * Dump the current known state of the grid.
+         */
+        printf("solver ran out of steam, ret=%d, grid:\n", nperturbs);
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                int v = grid[y*w+x];
+                if (v == -1)
+                    putchar('*');
+                else if (v == -2)
+                    putchar('?');
+                else if (v == 0)
+                    putchar('-');
+                else
+                    putchar('0' + v);
+            }
+            putchar('\n');
+        }
+
+        {
+            struct set *s;
+
+            for (i = 0; (s = index234(ss->sets, i)) != NULL; i++)
+                printf("remaining set: %d,%d %03x %d\n", s->x, s->y, s->mask, s->mines);
+        }
+#endif
+
+        /*
+         * Now we really are at our wits' end as far as solving
+         * this grid goes. Our only remaining option is to call
+         * a perturb function and ask it to modify the grid to
+         * make it easier.
+         */
+        if (perturb) {
+            struct perturbations *ret;
+            struct set *s;
+
+            nperturbs++;
+
+            /*
+             * Choose a set at random from the current selection,
+             * and ask the perturb function to either fill or empty
+             * it.
+             * 
+             * If we have no sets at all, we must give up.
+             */
+            if (count234(ss->sets) == 0) {
+#ifdef SOLVER_DIAGNOSTICS
+                printf("perturbing on entire unknown set\n");
+#endif
+                ret = perturb(ctx, grid, 0, 0, 0);
+            } else {
+                s = index234(ss->sets, random_upto(rs, count234(ss->sets)));
+#ifdef SOLVER_DIAGNOSTICS
+                printf("perturbing on set %d,%d %03x\n", s->x, s->y, s->mask);
+#endif
+                ret = perturb(ctx, grid, s->x, s->y, s->mask);
+            }
+
+            if (ret) {
+                assert(ret->n > 0);    /* otherwise should have been NULL */
+
+                /*
+                 * A number of squares have been fiddled with, and
+                 * the returned structure tells us which. Adjust
+                 * the mine count in any set which overlaps one of
+                 * those squares, and put them back on the to-do
+                 * list. Also, if the square itself is marked as a
+                 * known non-mine, put it back on the squares-to-do
+                 * list.
+                 */
+                for (i = 0; i < ret->n; i++) {
+#ifdef SOLVER_DIAGNOSTICS
+                    printf("perturbation %s mine at %d,%d\n",
+                           ret->changes[i].delta > 0 ? "added" : "removed",
+                           ret->changes[i].x, ret->changes[i].y);
+#endif
+
+                    if (ret->changes[i].delta < 0 &&
+                        grid[ret->changes[i].y*w+ret->changes[i].x] != -2) {
+                        std_add(std, ret->changes[i].y*w+ret->changes[i].x);
+                    }
+
+                    list = ss_overlap(ss,
+                                      ret->changes[i].x, ret->changes[i].y, 1);
+
+                    for (j = 0; list[j]; j++) {
+                        list[j]->mines += ret->changes[i].delta;
+                        ss_add_todo(ss, list[j]);
+                    }
+
+                    sfree(list);
+                }
+
+                /*
+                 * Now free the returned data.
+                 */
+                sfree(ret->changes);
+                sfree(ret);
+
+#ifdef SOLVER_DIAGNOSTICS
+                /*
+                 * Dump the current known state of the grid.
+                 */
+                printf("state after perturbation:\n");
+                for (y = 0; y < h; y++) {
+                    for (x = 0; x < w; x++) {
+                        int v = grid[y*w+x];
+                        if (v == -1)
+                            putchar('*');
+                        else if (v == -2)
+                            putchar('?');
+                        else if (v == 0)
+                            putchar('-');
+                        else
+                            putchar('0' + v);
+                    }
+                    putchar('\n');
+                }
+
+                {
+                    struct set *s;
+
+                    for (i = 0; (s = index234(ss->sets, i)) != NULL; i++)
+                        printf("remaining set: %d,%d %03x %d\n", s->x, s->y, s->mask, s->mines);
+                }
+#endif
+
+                /*
+                 * And now we can go back round the deductive loop.
+                 */
+                continue;
+            }
+        }
+
+        /*
+         * If we get here, even that didn't work (either we didn't
+         * have a perturb function or it returned failure), so we
+         * give up entirely.
+         */
+        break;
+    }
+
+    /*
+     * See if we've got any unknown squares left.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            if (grid[y*w+x] == -2) {
+                nperturbs = -1;        /* failed to complete */
+                break;
+            }
+
+    /*
+     * Free the set list and square-todo list.
+     */
+    {
+        struct set *s;
+        while ((s = delpos234(ss->sets, 0)) != NULL)
+            sfree(s);
+        freetree234(ss->sets);
+        sfree(ss);
+        sfree(std->next);
+    }
+
+    return nperturbs;
+}
+
+/* ----------------------------------------------------------------------
+ * Grid generator which uses the above solver.
+ */
+
+struct minectx {
+    char *grid;
+    int w, h;
+    int sx, sy;
+    int allow_big_perturbs;
+    random_state *rs;
+};
+
+static int mineopen(void *vctx, int x, int y)
+{
+    struct minectx *ctx = (struct minectx *)vctx;
+    int i, j, n;
+
+    assert(x >= 0 && x < ctx->w && y >= 0 && y < ctx->h);
+    if (ctx->grid[y * ctx->w + x])
+        return -1;                     /* *bang* */
+
+    n = 0;
+    for (i = -1; i <= +1; i++) {
+        if (x + i < 0 || x + i >= ctx->w)
+            continue;
+        for (j = -1; j <= +1; j++) {
+            if (y + j < 0 || y + j >= ctx->h)
+                continue;
+            if (i == 0 && j == 0)
+                continue;
+            if (ctx->grid[(y+j) * ctx->w + (x+i)])
+                n++;
+        }
+    }
+
+    return n;
+}
+
+/* Structure used internally to mineperturb(). */
+struct square {
+    int x, y, type, random;
+};
+static int squarecmp(const void *av, const void *bv)
+{
+    const struct square *a = (const struct square *)av;
+    const struct square *b = (const struct square *)bv;
+    if (a->type < b->type)
+        return -1;
+    else if (a->type > b->type)
+        return +1;
+    else if (a->random < b->random)
+        return -1;
+    else if (a->random > b->random)
+        return +1;
+    else if (a->y < b->y)
+        return -1;
+    else if (a->y > b->y)
+        return +1;
+    else if (a->x < b->x)
+        return -1;
+    else if (a->x > b->x)
+        return +1;
+    return 0;
+}
+
+/*
+ * Normally this function is passed an (x,y,mask) set description.
+ * On occasions, though, there is no _localised_ set being used,
+ * and the set being perturbed is supposed to be the entirety of
+ * the unreachable area. This is signified by the special case
+ * mask==0: in this case, anything labelled -2 in the grid is part
+ * of the set.
+ * 
+ * Allowing perturbation in this special case appears to make it
+ * guaranteeably possible to generate a workable grid for any mine
+ * density, but they tend to be a bit boring, with mines packed
+ * densely into far corners of the grid and the remainder being
+ * less dense than one might like. Therefore, to improve overall
+ * grid quality I disable this feature for the first few attempts,
+ * and fall back to it after no useful grid has been generated.
+ */
+static struct perturbations *mineperturb(void *vctx, signed char *grid,
+                                         int setx, int sety, int mask)
+{
+    struct minectx *ctx = (struct minectx *)vctx;
+    struct square *sqlist;
+    int x, y, dx, dy, i, n, nfull, nempty;
+    struct square **tofill, **toempty, **todo;
+    int ntofill, ntoempty, ntodo, dtodo, dset;
+    struct perturbations *ret;
+    int *setlist;
+
+    if (!mask && !ctx->allow_big_perturbs)
+        return NULL;
+
+    /*
+     * Make a list of all the squares in the grid which we can
+     * possibly use. This list should be in preference order, which
+     * means
+     * 
+     *  - first, unknown squares on the boundary of known space
+     *  - next, unknown squares beyond that boundary
+     *  - as a very last resort, known squares, but not within one
+     *    square of the starting position.
+     * 
+     * Each of these sections needs to be shuffled independently.
+     * We do this by preparing list of all squares and then sorting
+     * it with a random secondary key.
+     */
+    sqlist = snewn(ctx->w * ctx->h, struct square);
+    n = 0;
+    for (y = 0; y < ctx->h; y++)
+        for (x = 0; x < ctx->w; x++) {
+            /*
+             * If this square is too near the starting position,
+             * don't put it on the list at all.
+             */
+            if (abs(y - ctx->sy) <= 1 && abs(x - ctx->sx) <= 1)
+                continue;
+
+            /*
+             * If this square is in the input set, also don't put
+             * it on the list!
+             */
+            if ((mask == 0 && grid[y*ctx->w+x] == -2) ||
+                (x >= setx && x < setx + 3 &&
+                 y >= sety && y < sety + 3 &&
+                 mask & (1 << ((y-sety)*3+(x-setx)))))
+                continue;
+
+            sqlist[n].x = x;
+            sqlist[n].y = y;
+
+            if (grid[y*ctx->w+x] != -2) {
+                sqlist[n].type = 3;    /* known square */
+            } else {
+                /*
+                 * Unknown square. Examine everything around it and
+                 * see if it borders on any known squares. If it
+                 * does, it's class 1, otherwise it's 2.
+                 */
+
+                sqlist[n].type = 2;
+
+                for (dy = -1; dy <= +1; dy++)
+                    for (dx = -1; dx <= +1; dx++)
+                        if (x+dx >= 0 && x+dx < ctx->w &&
+                            y+dy >= 0 && y+dy < ctx->h &&
+                            grid[(y+dy)*ctx->w+(x+dx)] != -2) {
+                            sqlist[n].type = 1;
+                            break;
+                        }
+            }
+
+            /*
+             * Finally, a random number to cause qsort to
+             * shuffle within each group.
+             */
+            sqlist[n].random = random_bits(ctx->rs, 31);
+
+            n++;
+        }
+
+    qsort(sqlist, n, sizeof(struct square), squarecmp);
+
+    /*
+     * Now count up the number of full and empty squares in the set
+     * we've been provided.
+     */
+    nfull = nempty = 0;
+    if (mask) {
+        for (dy = 0; dy < 3; dy++)
+            for (dx = 0; dx < 3; dx++)
+                if (mask & (1 << (dy*3+dx))) {
+                    assert(setx+dx <= ctx->w);
+                    assert(sety+dy <= ctx->h);
+                    if (ctx->grid[(sety+dy)*ctx->w+(setx+dx)])
+                        nfull++;
+                    else
+                        nempty++;
+                }
+    } else {
+        for (y = 0; y < ctx->h; y++)
+            for (x = 0; x < ctx->w; x++)
+                if (grid[y*ctx->w+x] == -2) {
+                    if (ctx->grid[y*ctx->w+x])
+                        nfull++;
+                    else
+                        nempty++;
+                }
+    }
+
+    /*
+     * Now go through our sorted list until we find either `nfull'
+     * empty squares, or `nempty' full squares; these will be
+     * swapped with the appropriate squares in the set to either
+     * fill or empty the set while keeping the same number of mines
+     * overall.
+     */
+    ntofill = ntoempty = 0;
+    if (mask) {
+        tofill = snewn(9, struct square *);
+        toempty = snewn(9, struct square *);
+    } else {
+        tofill = snewn(ctx->w * ctx->h, struct square *);
+        toempty = snewn(ctx->w * ctx->h, struct square *);
+    }
+    for (i = 0; i < n; i++) {
+        struct square *sq = &sqlist[i];
+        if (ctx->grid[sq->y * ctx->w + sq->x])
+            toempty[ntoempty++] = sq;
+        else
+            tofill[ntofill++] = sq;
+        if (ntofill == nfull || ntoempty == nempty)
+            break;
+    }
+
+    /*
+     * If we haven't found enough empty squares outside the set to
+     * empty it into _or_ enough full squares outside it to fill it
+     * up with, we'll have to settle for doing only a partial job.
+     * In this case we choose to always _fill_ the set (because
+     * this case will tend to crop up when we're working with very
+     * high mine densities and the only way to get a solvable grid
+     * is going to be to pack most of the mines solidly around the
+     * edges). So now our job is to make a list of the empty
+     * squares in the set, and shuffle that list so that we fill a
+     * random selection of them.
+     */
+    if (ntofill != nfull && ntoempty != nempty) {
+        int k;
+
+        assert(ntoempty != 0);
+
+        setlist = snewn(ctx->w * ctx->h, int);
+        i = 0;
+        if (mask) {
+            for (dy = 0; dy < 3; dy++)
+                for (dx = 0; dx < 3; dx++)
+                    if (mask & (1 << (dy*3+dx))) {
+                        assert(setx+dx <= ctx->w);
+                        assert(sety+dy <= ctx->h);
+                        if (!ctx->grid[(sety+dy)*ctx->w+(setx+dx)])
+                            setlist[i++] = (sety+dy)*ctx->w+(setx+dx);
+                    }
+        } else {
+            for (y = 0; y < ctx->h; y++)
+                for (x = 0; x < ctx->w; x++)
+                    if (grid[y*ctx->w+x] == -2) {
+                        if (!ctx->grid[y*ctx->w+x])
+                            setlist[i++] = y*ctx->w+x;
+                    }
+        }
+        assert(i > ntoempty);
+        /*
+         * Now pick `ntoempty' items at random from the list.
+         */
+        for (k = 0; k < ntoempty; k++) {
+            int index = k + random_upto(ctx->rs, i - k);
+            int tmp;
+
+            tmp = setlist[k];
+            setlist[k] = setlist[index];
+            setlist[index] = tmp;
+        }
+    } else
+        setlist = NULL;
+
+    /*
+     * Now we're pretty much there. We need to either
+     *  (a) put a mine in each of the empty squares in the set, and
+     *      take one out of each square in `toempty'
+     *  (b) take a mine out of each of the full squares in the set,
+     *      and put one in each square in `tofill'
+     * depending on which one we've found enough squares to do.
+     * 
+     * So we start by constructing our list of changes to return to
+     * the solver, so that it can update its data structures
+     * efficiently rather than having to rescan the whole grid.
+     */
+    ret = snew(struct perturbations);
+    if (ntofill == nfull) {
+        todo = tofill;
+        ntodo = ntofill;
+        dtodo = +1;
+        dset = -1;
+        sfree(toempty);
+    } else {
+        /*
+         * (We also fall into this case if we've constructed a
+         * setlist.)
+         */
+        todo = toempty;
+        ntodo = ntoempty;
+        dtodo = -1;
+        dset = +1;
+        sfree(tofill);
+    }
+    ret->n = 2 * ntodo;
+    ret->changes = snewn(ret->n, struct perturbation);
+    for (i = 0; i < ntodo; i++) {
+        ret->changes[i].x = todo[i]->x;
+        ret->changes[i].y = todo[i]->y;
+        ret->changes[i].delta = dtodo;
+    }
+    /* now i == ntodo */
+    if (setlist) {
+        int j;
+        assert(todo == toempty);
+        for (j = 0; j < ntoempty; j++) {
+            ret->changes[i].x = setlist[j] % ctx->w;
+            ret->changes[i].y = setlist[j] / ctx->w;
+            ret->changes[i].delta = dset;
+            i++;
+        }
+        sfree(setlist);
+    } else if (mask) {
+        for (dy = 0; dy < 3; dy++)
+            for (dx = 0; dx < 3; dx++)
+                if (mask & (1 << (dy*3+dx))) {
+                    int currval = (ctx->grid[(sety+dy)*ctx->w+(setx+dx)] ? +1 : -1);
+                    if (dset == -currval) {
+                        ret->changes[i].x = setx + dx;
+                        ret->changes[i].y = sety + dy;
+                        ret->changes[i].delta = dset;
+                        i++;
+                    }
+                }
+    } else {
+        for (y = 0; y < ctx->h; y++)
+            for (x = 0; x < ctx->w; x++)
+                if (grid[y*ctx->w+x] == -2) {
+                    int currval = (ctx->grid[y*ctx->w+x] ? +1 : -1);
+                    if (dset == -currval) {
+                        ret->changes[i].x = x;
+                        ret->changes[i].y = y;
+                        ret->changes[i].delta = dset;
+                        i++;
+                    }
+                }
+    }
+    assert(i == ret->n);
+
+    sfree(sqlist);
+    sfree(todo);
+
+    /*
+     * Having set up the precise list of changes we're going to
+     * make, we now simply make them and return.
+     */
+    for (i = 0; i < ret->n; i++) {
+        int delta;
+
+        x = ret->changes[i].x;
+        y = ret->changes[i].y;
+        delta = ret->changes[i].delta;
+
+        /*
+         * Check we're not trying to add an existing mine or remove
+         * an absent one.
+         */
+        assert((delta < 0) ^ (ctx->grid[y*ctx->w+x] == 0));
+
+        /*
+         * Actually make the change.
+         */
+        ctx->grid[y*ctx->w+x] = (delta > 0);
+
+        /*
+         * Update any numbers already present in the grid.
+         */
+        for (dy = -1; dy <= +1; dy++)
+            for (dx = -1; dx <= +1; dx++)
+                if (x+dx >= 0 && x+dx < ctx->w &&
+                    y+dy >= 0 && y+dy < ctx->h &&
+                    grid[(y+dy)*ctx->w+(x+dx)] != -2) {
+                    if (dx == 0 && dy == 0) {
+                        /*
+                         * The square itself is marked as known in
+                         * the grid. Mark it as a mine if it's a
+                         * mine, or else work out its number.
+                         */
+                        if (delta > 0) {
+                            grid[y*ctx->w+x] = -1;
+                        } else {
+                            int dx2, dy2, minecount = 0;
+                            for (dy2 = -1; dy2 <= +1; dy2++)
+                                for (dx2 = -1; dx2 <= +1; dx2++)
+                                    if (x+dx2 >= 0 && x+dx2 < ctx->w &&
+                                        y+dy2 >= 0 && y+dy2 < ctx->h &&
+                                        ctx->grid[(y+dy2)*ctx->w+(x+dx2)])
+                                        minecount++;
+                            grid[y*ctx->w+x] = minecount;
+                        }
+                    } else {
+                        if (grid[(y+dy)*ctx->w+(x+dx)] >= 0)
+                            grid[(y+dy)*ctx->w+(x+dx)] += delta;
+                    }
+                }
+    }
+
+#ifdef GENERATION_DIAGNOSTICS
+    {
+        int yy, xx;
+        printf("grid after perturbing:\n");
+        for (yy = 0; yy < ctx->h; yy++) {
+            for (xx = 0; xx < ctx->w; xx++) {
+                int v = ctx->grid[yy*ctx->w+xx];
+                if (yy == ctx->sy && xx == ctx->sx) {
+                    assert(!v);
+                    putchar('S');
+                } else if (v) {
+                    putchar('*');
+                } else {
+                    putchar('-');
+                }
+            }
+            putchar('\n');
+        }
+        printf("\n");
+    }
+#endif
+
+    return ret;
+}
+
+static char *minegen(int w, int h, int n, int x, int y, int unique,
+                     random_state *rs)
+{
+    char *ret = snewn(w*h, char);
+    int success;
+    int ntries = 0;
+
+    do {
+        success = FALSE;
+        ntries++;
+
+        memset(ret, 0, w*h);
+
+        /*
+         * Start by placing n mines, none of which is at x,y or within
+         * one square of it.
+         */
+        {
+            int *tmp = snewn(w*h, int);
+            int i, j, k, nn;
+
+            /*
+             * Write down the list of possible mine locations.
+             */
+            k = 0;
+            for (i = 0; i < h; i++)
+                for (j = 0; j < w; j++)
+                    if (abs(i - y) > 1 || abs(j - x) > 1)
+                        tmp[k++] = i*w+j;
+
+            /*
+             * Now pick n off the list at random.
+             */
+            nn = n;
+            while (nn-- > 0) {
+                i = random_upto(rs, k);
+                ret[tmp[i]] = 1;
+                tmp[i] = tmp[--k];
+            }
+
+            sfree(tmp);
+        }
+
+#ifdef GENERATION_DIAGNOSTICS
+        {
+            int yy, xx;
+            printf("grid after initial generation:\n");
+            for (yy = 0; yy < h; yy++) {
+                for (xx = 0; xx < w; xx++) {
+                    int v = ret[yy*w+xx];
+                    if (yy == y && xx == x) {
+                        assert(!v);
+                        putchar('S');
+                    } else if (v) {
+                        putchar('*');
+                    } else {
+                        putchar('-');
+                    }
+                }
+                putchar('\n');
+            }
+            printf("\n");
+        }
+#endif
+
+        /*
+         * Now set up a results grid to run the solver in, and a
+         * context for the solver to open squares. Then run the solver
+         * repeatedly; if the number of perturb steps ever goes up or
+         * it ever returns -1, give up completely.
+         *
+         * We bypass this bit if we're not after a unique grid.
+         */
+        if (unique) {
+            signed char *solvegrid = snewn(w*h, signed char);
+            struct minectx actx, *ctx = &actx;
+            int solveret, prevret = -2;
+
+            ctx->grid = ret;
+            ctx->w = w;
+            ctx->h = h;
+            ctx->sx = x;
+            ctx->sy = y;
+            ctx->rs = rs;
+            ctx->allow_big_perturbs = (ntries > 100);
+
+            while (1) {
+                memset(solvegrid, -2, w*h);
+                solvegrid[y*w+x] = mineopen(ctx, x, y);
+                assert(solvegrid[y*w+x] == 0); /* by deliberate arrangement */
+
+                solveret =
+                    minesolve(w, h, n, solvegrid, mineopen, mineperturb, ctx, rs);
+                if (solveret < 0 || (prevret >= 0 && solveret >= prevret)) {
+                    success = FALSE;
+                    break;
+                } else if (solveret == 0) {
+                    success = TRUE;
+                    break;
+                }
+            }
+
+            sfree(solvegrid);
+        } else {
+            success = TRUE;
+        }
+
+    } while (!success);
+
+    return ret;
+}
+
+static char *describe_layout(char *grid, int area, int x, int y,
+                             int obfuscate)
+{
+    char *ret, *p;
+    unsigned char *bmp;
+    int i;
+
+    /*
+     * Set up the mine bitmap and obfuscate it.
+     */
+    bmp = snewn((area + 7) / 8, unsigned char);
+    memset(bmp, 0, (area + 7) / 8);
+    for (i = 0; i < area; i++) {
+        if (grid[i])
+            bmp[i / 8] |= 0x80 >> (i % 8);
+    }
+    if (obfuscate)
+        obfuscate_bitmap(bmp, area, FALSE);
+
+    /*
+     * Now encode the resulting bitmap in hex. We can work to
+     * nibble rather than byte granularity, since the obfuscation
+     * function guarantees to return a bit string of the same
+     * length as its input.
+     */
+    ret = snewn((area+3)/4 + 100, char);
+    p = ret + sprintf(ret, "%d,%d,%s", x, y,
+                      obfuscate ? "m" : "u");   /* 'm' == masked */
+    for (i = 0; i < (area+3)/4; i++) {
+        int v = bmp[i/2];
+        if (i % 2 == 0)
+            v >>= 4;
+        *p++ = "0123456789abcdef"[v & 0xF];
+    }
+    *p = '\0';
+
+    sfree(bmp);
+
+    return ret;
+}
+
+static char *new_mine_layout(int w, int h, int n, int x, int y, int unique,
+                             random_state *rs, char **game_desc)
+{
+    char *grid;
+
+#ifdef TEST_OBFUSCATION
+    static int tested_obfuscation = FALSE;
+    if (!tested_obfuscation) {
+        /*
+         * A few simple test vectors for the obfuscator.
+         * 
+         * First test: the 28-bit stream 1234567. This divides up
+         * into 1234 and 567[0]. The SHA of 56 70 30 (appending
+         * "0") is 15ce8ab946640340bbb99f3f48fd2c45d1a31d30. Thus,
+         * we XOR the 16-bit string 15CE into the input 1234 to get
+         * 07FA. Next, we SHA that with "0": the SHA of 07 FA 30 is
+         * 3370135c5e3da4fed937adc004a79533962b6391. So we XOR the
+         * 12-bit string 337 into the input 567 to get 650. Thus
+         * our output is 07FA650.
+         */
+        {
+            unsigned char bmp1[] = "\x12\x34\x56\x70";
+            obfuscate_bitmap(bmp1, 28, FALSE);
+            printf("test 1 encode: %s\n",
+                   memcmp(bmp1, "\x07\xfa\x65\x00", 4) ? "failed" : "passed");
+            obfuscate_bitmap(bmp1, 28, TRUE);
+            printf("test 1 decode: %s\n",
+                   memcmp(bmp1, "\x12\x34\x56\x70", 4) ? "failed" : "passed");
+        }
+        /*
+         * Second test: a long string to make sure we switch from
+         * one SHA to the next correctly. My input string this time
+         * is simply fifty bytes of zeroes.
+         */
+        {
+            unsigned char bmp2[50];
+            unsigned char bmp2a[50];
+            memset(bmp2, 0, 50);
+            memset(bmp2a, 0, 50);
+            obfuscate_bitmap(bmp2, 50 * 8, FALSE);
+            /*
+             * SHA of twenty-five zero bytes plus "0" is
+             * b202c07b990c01f6ff2d544707f60e506019b671. SHA of
+             * twenty-five zero bytes plus "1" is
+             * fcb1d8b5a2f6b592fe6780b36aa9d65dd7aa6db9. Thus our
+             * first half becomes
+             * b202c07b990c01f6ff2d544707f60e506019b671fcb1d8b5a2.
+             * 
+             * SHA of that lot plus "0" is
+             * 10b0af913db85d37ca27f52a9f78bba3a80030db. SHA of the
+             * same string plus "1" is
+             * 3d01d8df78e76d382b8106f480135a1bc751d725. So the
+             * second half becomes
+             * 10b0af913db85d37ca27f52a9f78bba3a80030db3d01d8df78.
+             */
+            printf("test 2 encode: %s\n",
+                   memcmp(bmp2, "\xb2\x02\xc0\x7b\x99\x0c\x01\xf6\xff\x2d\x54"
+                          "\x47\x07\xf6\x0e\x50\x60\x19\xb6\x71\xfc\xb1\xd8"
+                          "\xb5\xa2\x10\xb0\xaf\x91\x3d\xb8\x5d\x37\xca\x27"
+                          "\xf5\x2a\x9f\x78\xbb\xa3\xa8\x00\x30\xdb\x3d\x01"
+                          "\xd8\xdf\x78", 50) ? "failed" : "passed");
+            obfuscate_bitmap(bmp2, 50 * 8, TRUE);
+            printf("test 2 decode: %s\n",
+                   memcmp(bmp2, bmp2a, 50) ? "failed" : "passed");
+        }
+    }
+#endif
+
+    grid = minegen(w, h, n, x, y, unique, rs);
+
+    if (game_desc)
+        *game_desc = describe_layout(grid, w * h, x, y, TRUE);
+
+    return grid;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    /*
+     * We generate the coordinates of an initial click even if they
+     * aren't actually used. This has the effect of harmonising the
+     * random number usage between interactive and batch use: if
+     * you use `mines --generate' with an explicit random seed, you
+     * should get exactly the same results as if you type the same
+     * random seed into the interactive game and click in the same
+     * initial location. (Of course you won't get the same grid if
+     * you click in a _different_ initial location, but there's
+     * nothing to be done about that.)
+     */
+    int x = random_upto(rs, params->w);
+    int y = random_upto(rs, params->h);
+
+    if (!interactive) {
+        /*
+         * For batch-generated grids, pre-open one square.
+         */
+        char *grid;
+        char *desc;
+
+        grid = new_mine_layout(params->w, params->h, params->n,
+                               x, y, params->unique, rs, &desc);
+        sfree(grid);
+        return desc;
+    } else {
+        char *rsdesc, *desc;
+
+        rsdesc = random_state_encode(rs);
+        desc = snewn(strlen(rsdesc) + 100, char);
+        sprintf(desc, "r%d,%c,%s", params->n, (char)(params->unique ? 'u' : 'a'), rsdesc);
+        sfree(rsdesc);
+        return desc;
+    }
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int wh = params->w * params->h;
+    int x, y;
+
+    if (*desc == 'r') {
+        desc++;
+        if (!*desc || !isdigit((unsigned char)*desc))
+            return "No initial mine count in game description";
+        while (*desc && isdigit((unsigned char)*desc))
+            desc++;                    /* skip over mine count */
+        if (*desc != ',')
+            return "No ',' after initial x-coordinate in game description";
+        desc++;
+        if (*desc != 'u' && *desc != 'a')
+            return "No uniqueness specifier in game description";
+        desc++;
+        if (*desc != ',')
+            return "No ',' after uniqueness specifier in game description";
+        /* now ignore the rest */
+    } else {
+        if (*desc && isdigit((unsigned char)*desc)) {
+            x = atoi(desc);
+            if (x < 0 || x >= params->w)
+                return "Initial x-coordinate was out of range";
+            while (*desc && isdigit((unsigned char)*desc))
+                desc++;                /* skip over x coordinate */
+            if (*desc != ',')
+                return "No ',' after initial x-coordinate in game description";
+            desc++;                    /* eat comma */
+            if (!*desc || !isdigit((unsigned char)*desc))
+                return "No initial y-coordinate in game description";
+            y = atoi(desc);
+            if (y < 0 || y >= params->h)
+                return "Initial y-coordinate was out of range";
+            while (*desc && isdigit((unsigned char)*desc))
+                desc++;                /* skip over y coordinate */
+            if (*desc != ',')
+                return "No ',' after initial y-coordinate in game description";
+            desc++;                    /* eat comma */
+        }
+        /* eat `m' for `masked' or `u' for `unmasked', if present */
+        if (*desc == 'm' || *desc == 'u')
+            desc++;
+        /* now just check length of remainder */
+        if (strlen(desc) != (wh+3)/4)
+            return "Game description is wrong length";
+    }
+
+    return NULL;
+}
+
+static int open_square(game_state *state, int x, int y)
+{
+    int w = state->w, h = state->h;
+    int xx, yy, nmines, ncovered;
+
+    if (!state->layout->mines) {
+        /*
+         * We have a preliminary game in which the mine layout
+         * hasn't been generated yet. Generate it based on the
+         * initial click location.
+         */
+        char *desc, *privdesc;
+        state->layout->mines = new_mine_layout(w, h, state->layout->n,
+                                               x, y, state->layout->unique,
+                                               state->layout->rs,
+                                               &desc);
+        /*
+         * Find the trailing substring of the game description
+         * corresponding to just the mine layout; we will use this
+         * as our second `private' game ID for serialisation.
+         */
+        privdesc = desc;
+        while (*privdesc && isdigit((unsigned char)*privdesc)) privdesc++;
+        if (*privdesc == ',') privdesc++;
+        while (*privdesc && isdigit((unsigned char)*privdesc)) privdesc++;
+        if (*privdesc == ',') privdesc++;
+        assert(*privdesc == 'm');
+        midend_supersede_game_desc(state->layout->me, desc, privdesc);
+        sfree(desc);
+        random_free(state->layout->rs);
+        state->layout->rs = NULL;
+    }
+
+    if (state->layout->mines[y*w+x]) {
+        /*
+         * The player has landed on a mine. Bad luck. Expose the
+         * mine that killed them, but not the rest (in case they
+         * want to Undo and carry on playing).
+         */
+        state->dead = TRUE;
+        state->grid[y*w+x] = 65;
+        return -1;
+    }
+
+    /*
+     * Otherwise, the player has opened a safe square. Mark it to-do.
+     */
+    state->grid[y*w+x] = -10;          /* `todo' value internal to this func */
+
+    /*
+     * Now go through the grid finding all `todo' values and
+     * opening them. Every time one of them turns out to have no
+     * neighbouring mines, we add all its unopened neighbours to
+     * the list as well.
+     * 
+     * FIXME: We really ought to be able to do this better than
+     * using repeated N^2 scans of the grid.
+     */
+    while (1) {
+        int done_something = FALSE;
+
+        for (yy = 0; yy < h; yy++)
+            for (xx = 0; xx < w; xx++)
+                if (state->grid[yy*w+xx] == -10) {
+                    int dx, dy, v;
+
+                    assert(!state->layout->mines[yy*w+xx]);
+
+                    v = 0;
+
+                    for (dx = -1; dx <= +1; dx++)
+                        for (dy = -1; dy <= +1; dy++)
+                            if (xx+dx >= 0 && xx+dx < state->w &&
+                                yy+dy >= 0 && yy+dy < state->h &&
+                                state->layout->mines[(yy+dy)*w+(xx+dx)])
+                                v++;
+
+                    state->grid[yy*w+xx] = v;
+
+                    if (v == 0) {
+                        for (dx = -1; dx <= +1; dx++)
+                            for (dy = -1; dy <= +1; dy++)
+                                if (xx+dx >= 0 && xx+dx < state->w &&
+                                    yy+dy >= 0 && yy+dy < state->h &&
+                                    state->grid[(yy+dy)*w+(xx+dx)] == -2)
+                                    state->grid[(yy+dy)*w+(xx+dx)] = -10;
+                    }
+
+                    done_something = TRUE;
+                }
+
+        if (!done_something)
+            break;
+    }
+
+    /*
+     * Finally, scan the grid and see if exactly as many squares
+     * are still covered as there are mines. If so, set the `won'
+     * flag and fill in mine markers on all covered squares.
+     */
+    nmines = ncovered = 0;
+    for (yy = 0; yy < h; yy++)
+        for (xx = 0; xx < w; xx++) {
+            if (state->grid[yy*w+xx] < 0)
+                ncovered++;
+            if (state->layout->mines[yy*w+xx])
+                nmines++;
+        }
+    assert(ncovered >= nmines);
+    if (ncovered == nmines) {
+        for (yy = 0; yy < h; yy++)
+            for (xx = 0; xx < w; xx++) {
+                if (state->grid[yy*w+xx] < 0)
+                    state->grid[yy*w+xx] = -1;
+        }
+        state->won = TRUE;
+    }
+
+    return 0;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    int i, wh, x, y, masked;
+    unsigned char *bmp;
+
+    state->w = params->w;
+    state->h = params->h;
+    state->n = params->n;
+    state->dead = state->won = FALSE;
+    state->used_solve = FALSE;
+
+    wh = state->w * state->h;
+
+    state->layout = snew(struct mine_layout);
+    memset(state->layout, 0, sizeof(struct mine_layout));
+    state->layout->refcount = 1;
+
+    state->grid = snewn(wh, signed char);
+    memset(state->grid, -2, wh);
+
+    if (*desc == 'r') {
+        desc++;
+        state->layout->n = atoi(desc);
+        while (*desc && isdigit((unsigned char)*desc))
+            desc++;                    /* skip over mine count */
+        if (*desc) desc++;             /* eat comma */
+        if (*desc == 'a')
+            state->layout->unique = FALSE;
+        else
+            state->layout->unique = TRUE;
+        desc++;
+        if (*desc) desc++;             /* eat comma */
+
+        state->layout->mines = NULL;
+        state->layout->rs = random_state_decode(desc);
+        state->layout->me = me;
+
+    } else {
+        state->layout->rs = NULL;
+        state->layout->me = NULL;
+        state->layout->mines = snewn(wh, char);
+
+        if (*desc && isdigit((unsigned char)*desc)) {
+            x = atoi(desc);
+            while (*desc && isdigit((unsigned char)*desc))
+                desc++;                /* skip over x coordinate */
+            if (*desc) desc++;         /* eat comma */
+            y = atoi(desc);
+            while (*desc && isdigit((unsigned char)*desc))
+                desc++;                /* skip over y coordinate */
+            if (*desc) desc++;         /* eat comma */
+        } else {
+            x = y = -1;
+        }
+
+        if (*desc == 'm') {
+            masked = TRUE;
+            desc++;
+        } else {
+            if (*desc == 'u')
+                desc++;
+            /*
+             * We permit game IDs to be entered by hand without the
+             * masking transformation.
+             */
+            masked = FALSE;
+        }
+
+        bmp = snewn((wh + 7) / 8, unsigned char);
+        memset(bmp, 0, (wh + 7) / 8);
+        for (i = 0; i < (wh+3)/4; i++) {
+            int c = desc[i];
+            int v;
+
+            assert(c != 0);            /* validate_desc should have caught */
+            if (c >= '0' && c <= '9')
+                v = c - '0';
+            else if (c >= 'a' && c <= 'f')
+                v = c - 'a' + 10;
+            else if (c >= 'A' && c <= 'F')
+                v = c - 'A' + 10;
+            else
+                v = 0;
+
+            bmp[i / 2] |= v << (4 * (1 - (i % 2)));
+        }
+
+        if (masked)
+            obfuscate_bitmap(bmp, wh, TRUE);
+
+        memset(state->layout->mines, 0, wh);
+        for (i = 0; i < wh; i++) {
+            if (bmp[i / 8] & (0x80 >> (i % 8)))
+                state->layout->mines[i] = 1;
+        }
+
+        if (x >= 0 && y >= 0)
+            open_square(state, x, y);
+        sfree(bmp);
+    }
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->n = state->n;
+    ret->dead = state->dead;
+    ret->won = state->won;
+    ret->used_solve = state->used_solve;
+    ret->layout = state->layout;
+    ret->layout->refcount++;
+    ret->grid = snewn(ret->w * ret->h, signed char);
+    memcpy(ret->grid, state->grid, ret->w * ret->h);
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (--state->layout->refcount <= 0) {
+        sfree(state->layout->mines);
+        if (state->layout->rs)
+            random_free(state->layout->rs);
+        sfree(state->layout);
+    }
+    sfree(state->grid);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    if (!state->layout->mines) {
+        *error = "Game has not been started yet";
+        return NULL;
+    }
+
+    return dupstr("S");
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    char *ret;
+    int x, y;
+
+    ret = snewn((state->w + 1) * state->h + 1, char);
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            int v = state->grid[y*state->w+x];
+            if (v == 0)
+                v = '-';
+            else if (v >= 1 && v <= 8)
+                v = '0' + v;
+            else if (v == -1)
+                v = '*';
+            else if (v == -2 || v == -3)
+                v = '?';
+            else if (v >= 64)
+                v = '!';
+            ret[y * (state->w+1) + x] = v;
+        }
+        ret[y * (state->w+1) + state->w] = '\n';
+    }
+    ret[(state->w + 1) * state->h] = '\0';
+
+    return ret;
+}
+
+struct game_ui {
+    int hx, hy, hradius;               /* for mouse-down highlights */
+    int validradius;
+    int flash_is_death;
+    int deaths, completed;
+    int cur_x, cur_y, cur_visible;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->hx = ui->hy = -1;
+    ui->hradius = ui->validradius = 0;
+    ui->deaths = 0;
+    ui->completed = FALSE;
+    ui->flash_is_death = FALSE;        /* *shrug* */
+    ui->cur_x = ui->cur_y = ui->cur_visible = 0;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    char buf[80];
+    /*
+     * The deaths counter and completion status need preserving
+     * across a serialisation.
+     */
+    sprintf(buf, "D%d", ui->deaths);
+    if (ui->completed)
+        strcat(buf, "C");
+    return dupstr(buf);
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+    int p= 0;
+    sscanf(encoding, "D%d%n", &ui->deaths, &p);
+    if (encoding[p] == 'C')
+        ui->completed = TRUE;
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    if (newstate->won)
+        ui->completed = TRUE;
+}
+
+struct game_drawstate {
+    int w, h, started, tilesize, bg;
+    signed char *grid;
+    /*
+     * Items in this `grid' array have all the same values as in
+     * the game_state grid, and in addition:
+     * 
+     *  - -10 means the tile was drawn `specially' as a result of a
+     *    flash, so it will always need redrawing.
+     * 
+     *  - -22 and -23 mean the tile is highlighted for a possible
+     *    click.
+     */
+    int cur_x, cur_y; /* -1, -1 for no cursor displayed. */
+};
+
+static char *interpret_move(const game_state *from, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int cx, cy;
+    char buf[256];
+
+    if (from->dead || from->won)
+        return NULL;                   /* no further moves permitted */
+
+    cx = FROMCOORD(x);
+    cy = FROMCOORD(y);
+
+    if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->cur_x, &ui->cur_y, from->w, from->h, 0);
+        ui->cur_visible = 1;
+        return "";
+    }
+    if (IS_CURSOR_SELECT(button)) {
+        int v = from->grid[ui->cur_y * from->w + ui->cur_x];
+
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+        if (button == CURSOR_SELECT2) {
+            /* As for RIGHT_BUTTON; only works on covered square. */
+            if (v != -2 && v != -1)
+                return NULL;
+            sprintf(buf, "F%d,%d", ui->cur_x, ui->cur_y);
+            return dupstr(buf);
+        }
+        /* Otherwise, treat as LEFT_BUTTON, for a single square. */
+        if (v == -2 || v == -3) {
+            if (from->layout->mines &&
+                from->layout->mines[ui->cur_y * from->w + ui->cur_x])
+                ui->deaths++;
+
+            sprintf(buf, "O%d,%d", ui->cur_x, ui->cur_y);
+            return dupstr(buf);
+        }
+        cx = ui->cur_x; cy = ui->cur_y;
+        ui->validradius = 1;
+        goto uncover;
+    }
+
+    if (button == LEFT_BUTTON || button == LEFT_DRAG ||
+        button == MIDDLE_BUTTON || button == MIDDLE_DRAG) {
+        if (cx < 0 || cx >= from->w || cy < 0 || cy >= from->h)
+            return NULL;
+
+        /*
+         * Mouse-downs and mouse-drags just cause highlighting
+         * updates.
+         */
+        ui->hx = cx;
+        ui->hy = cy;
+        ui->hradius = (from->grid[cy*from->w+cx] >= 0 ? 1 : 0);
+        if (button == LEFT_BUTTON)
+            ui->validradius = ui->hradius;
+        else if (button == MIDDLE_BUTTON)
+            ui->validradius = 1;
+        ui->cur_visible = 0;
+        return "";
+    }
+
+    if (button == RIGHT_BUTTON) {
+        if (cx < 0 || cx >= from->w || cy < 0 || cy >= from->h)
+            return NULL;
+
+        /*
+         * Right-clicking only works on a covered square, and it
+         * toggles between -1 (marked as mine) and -2 (not marked
+         * as mine).
+         *
+         * FIXME: question marks.
+         */
+        if (from->grid[cy * from->w + cx] != -2 &&
+            from->grid[cy * from->w + cx] != -1)
+            return NULL;
+
+        sprintf(buf, "F%d,%d", cx, cy);
+        return dupstr(buf);
+    }
+
+    if (button == LEFT_RELEASE || button == MIDDLE_RELEASE) {
+        ui->hx = ui->hy = -1;
+        ui->hradius = 0;
+
+        /*
+         * At this stage we must never return NULL: we have adjusted
+         * the ui, so at worst we return "".
+         */
+        if (cx < 0 || cx >= from->w || cy < 0 || cy >= from->h)
+            return "";
+
+        /*
+         * Left-clicking on a covered square opens a tile. Not
+         * permitted if the tile is marked as a mine, for safety.
+         * (Unmark it and _then_ open it.)
+         */
+        if (button == LEFT_RELEASE &&
+            (from->grid[cy * from->w + cx] == -2 ||
+             from->grid[cy * from->w + cx] == -3) &&
+            ui->validradius == 0) {
+            /* Check if you've killed yourself. */
+            if (from->layout->mines && from->layout->mines[cy * from->w + cx])
+                ui->deaths++;
+
+            sprintf(buf, "O%d,%d", cx, cy);
+            return dupstr(buf);
+        }
+        goto uncover;
+    }
+    return NULL;
+
+uncover:
+    {
+        /*
+         * Left-clicking or middle-clicking on an uncovered tile:
+         * first we check to see if the number of mine markers
+         * surrounding the tile is equal to its mine count, and if
+         * so then we open all other surrounding squares.
+         */
+        if (from->grid[cy * from->w + cx] > 0 && ui->validradius == 1) {
+            int dy, dx, n;
+
+            /* Count mine markers. */
+            n = 0;
+            for (dy = -1; dy <= +1; dy++)
+                for (dx = -1; dx <= +1; dx++)
+                    if (cx+dx >= 0 && cx+dx < from->w &&
+                        cy+dy >= 0 && cy+dy < from->h) {
+                        if (from->grid[(cy+dy)*from->w+(cx+dx)] == -1)
+                            n++;
+                    }
+
+            if (n == from->grid[cy * from->w + cx]) {
+
+                /*
+                 * Now see if any of the squares we're clearing
+                 * contains a mine (which will happen iff you've
+                 * incorrectly marked the mines around the clicked
+                 * square). If so, we open _just_ those squares, to
+                 * reveal as little additional information as we
+                 * can.
+                 */
+                char *p = buf;
+                char *sep = "";
+
+                for (dy = -1; dy <= +1; dy++)
+                    for (dx = -1; dx <= +1; dx++)
+                        if (cx+dx >= 0 && cx+dx < from->w &&
+                            cy+dy >= 0 && cy+dy < from->h) {
+                            if (from->grid[(cy+dy)*from->w+(cx+dx)] != -1 &&
+                                from->layout->mines &&
+                                from->layout->mines[(cy+dy)*from->w+(cx+dx)]) {
+                                p += sprintf(p, "%sO%d,%d", sep, cx+dx, cy+dy);
+                                sep = ";";
+                            }
+                        }
+
+                if (p > buf) {
+                    ui->deaths++;
+                } else {
+                    sprintf(buf, "C%d,%d", cx, cy);
+                }
+
+                return dupstr(buf);
+            }
+        }
+
+        return "";
+    }
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    int cy, cx;
+    game_state *ret;
+
+    if (!strcmp(move, "S")) {
+        int yy, xx;
+
+        ret = dup_game(from);
+        if (!ret->dead) {
+            /*
+             * If the player is still alive at the moment of pressing
+             * Solve, expose the entire grid as if it were a completed
+             * solution.
+             */
+            for (yy = 0; yy < ret->h; yy++)
+                for (xx = 0; xx < ret->w; xx++) {
+
+                    if (ret->layout->mines[yy*ret->w+xx]) {
+                        ret->grid[yy*ret->w+xx] = -1;
+                    } else {
+                        int dx, dy, v;
+
+                        v = 0;
+
+                        for (dx = -1; dx <= +1; dx++)
+                            for (dy = -1; dy <= +1; dy++)
+                                if (xx+dx >= 0 && xx+dx < ret->w &&
+                                    yy+dy >= 0 && yy+dy < ret->h &&
+                                    ret->layout->mines[(yy+dy)*ret->w+(xx+dx)])
+                                    v++;
+
+                        ret->grid[yy*ret->w+xx] = v;
+                    }
+                }
+        } else {
+            /*
+             * If the player pressed Solve _after dying_, show a full
+             * corrections grid in the style of standard Minesweeper.
+             * Players who don't like Mines's behaviour on death of
+             * only showing the mine that killed you (so that in case
+             * of a typo you can undo and carry on without the rest of
+             * the grid being spoiled) can use this to get the display
+             * that ordinary Minesweeper would have given them.
+             */
+            for (yy = 0; yy < ret->h; yy++)
+                for (xx = 0; xx < ret->w; xx++) {
+                    int pos = yy*ret->w+xx;
+                    if ((ret->grid[pos] == -2 || ret->grid[pos] == -3) &&
+                        ret->layout->mines[pos]) {
+                        ret->grid[pos] = 64;
+                    } else if (ret->grid[pos] == -1 &&
+                               !ret->layout->mines[pos]) {
+                        ret->grid[pos] = 66;
+                    }
+                }
+        }
+        ret->used_solve = TRUE;
+
+        return ret;
+    } else {
+        ret = dup_game(from);
+
+        while (*move) {
+            if (move[0] == 'F' &&
+                sscanf(move+1, "%d,%d", &cx, &cy) == 2 &&
+                cx >= 0 && cx < from->w && cy >= 0 && cy < from->h) {
+                ret->grid[cy * from->w + cx] ^= (-2 ^ -1);
+            } else if (move[0] == 'O' &&
+                       sscanf(move+1, "%d,%d", &cx, &cy) == 2 &&
+                       cx >= 0 && cx < from->w && cy >= 0 && cy < from->h) {
+                open_square(ret, cx, cy);
+            } else if (move[0] == 'C' &&
+                       sscanf(move+1, "%d,%d", &cx, &cy) == 2 &&
+                       cx >= 0 && cx < from->w && cy >= 0 && cy < from->h) {
+                int dx, dy;
+
+                for (dy = -1; dy <= +1; dy++)
+                    for (dx = -1; dx <= +1; dx++)
+                        if (cx+dx >= 0 && cx+dx < ret->w &&
+                            cy+dy >= 0 && cy+dy < ret->h &&
+                            (ret->grid[(cy+dy)*ret->w+(cx+dx)] == -2 ||
+                             ret->grid[(cy+dy)*ret->w+(cx+dx)] == -3))
+                            open_square(ret, cx+dx, cy+dy);
+            } else {
+                free_game(ret);
+                return NULL;
+            }
+
+            while (*move && *move != ';') move++;
+            if (*move) move++;
+        }
+
+        return ret;
+    }
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = BORDER * 2 + TILE_SIZE * params->w;
+    *y = BORDER * 2 + TILE_SIZE * params->h;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_BACKGROUND2 * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 19.0F / 20.0F;
+    ret[COL_BACKGROUND2 * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 19.0F / 20.0F;
+    ret[COL_BACKGROUND2 * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 19.0F / 20.0F;
+
+    ret[COL_1 * 3 + 0] = 0.0F;
+    ret[COL_1 * 3 + 1] = 0.0F;
+    ret[COL_1 * 3 + 2] = 1.0F;
+
+    ret[COL_2 * 3 + 0] = 0.0F;
+    ret[COL_2 * 3 + 1] = 0.5F;
+    ret[COL_2 * 3 + 2] = 0.0F;
+
+    ret[COL_3 * 3 + 0] = 1.0F;
+    ret[COL_3 * 3 + 1] = 0.0F;
+    ret[COL_3 * 3 + 2] = 0.0F;
+
+    ret[COL_4 * 3 + 0] = 0.0F;
+    ret[COL_4 * 3 + 1] = 0.0F;
+    ret[COL_4 * 3 + 2] = 0.5F;
+
+    ret[COL_5 * 3 + 0] = 0.5F;
+    ret[COL_5 * 3 + 1] = 0.0F;
+    ret[COL_5 * 3 + 2] = 0.0F;
+
+    ret[COL_6 * 3 + 0] = 0.0F;
+    ret[COL_6 * 3 + 1] = 0.5F;
+    ret[COL_6 * 3 + 2] = 0.5F;
+
+    ret[COL_7 * 3 + 0] = 0.0F;
+    ret[COL_7 * 3 + 1] = 0.0F;
+    ret[COL_7 * 3 + 2] = 0.0F;
+
+    ret[COL_8 * 3 + 0] = 0.5F;
+    ret[COL_8 * 3 + 1] = 0.5F;
+    ret[COL_8 * 3 + 2] = 0.5F;
+
+    ret[COL_MINE * 3 + 0] = 0.0F;
+    ret[COL_MINE * 3 + 1] = 0.0F;
+    ret[COL_MINE * 3 + 2] = 0.0F;
+
+    ret[COL_BANG * 3 + 0] = 1.0F;
+    ret[COL_BANG * 3 + 1] = 0.0F;
+    ret[COL_BANG * 3 + 2] = 0.0F;
+
+    ret[COL_CROSS * 3 + 0] = 1.0F;
+    ret[COL_CROSS * 3 + 1] = 0.0F;
+    ret[COL_CROSS * 3 + 2] = 0.0F;
+
+    ret[COL_FLAG * 3 + 0] = 1.0F;
+    ret[COL_FLAG * 3 + 1] = 0.0F;
+    ret[COL_FLAG * 3 + 2] = 0.0F;
+
+    ret[COL_FLAGBASE * 3 + 0] = 0.0F;
+    ret[COL_FLAGBASE * 3 + 1] = 0.0F;
+    ret[COL_FLAGBASE * 3 + 2] = 0.0F;
+
+    ret[COL_QUERY * 3 + 0] = 0.0F;
+    ret[COL_QUERY * 3 + 1] = 0.0F;
+    ret[COL_QUERY * 3 + 2] = 0.0F;
+
+    ret[COL_HIGHLIGHT * 3 + 0] = 1.0F;
+    ret[COL_HIGHLIGHT * 3 + 1] = 1.0F;
+    ret[COL_HIGHLIGHT * 3 + 2] = 1.0F;
+
+    ret[COL_LOWLIGHT * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 2.0F / 3.0F;
+    ret[COL_LOWLIGHT * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 2.0F / 3.0F;
+    ret[COL_LOWLIGHT * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 2.0F / 3.0F;
+
+    ret[COL_WRONGNUMBER * 3 + 0] = 1.0F;
+    ret[COL_WRONGNUMBER * 3 + 1] = 0.6F;
+    ret[COL_WRONGNUMBER * 3 + 2] = 0.6F;
+
+    /* Red tinge to a light colour, for the cursor. */
+    ret[COL_CURSOR * 3 + 0] = ret[COL_HIGHLIGHT * 3 + 0];
+    ret[COL_CURSOR * 3 + 1] = ret[COL_HIGHLIGHT * 3 + 0] / 2.0F;
+    ret[COL_CURSOR * 3 + 2] = ret[COL_HIGHLIGHT * 3 + 0] / 2.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->w = state->w;
+    ds->h = state->h;
+    ds->started = FALSE;
+    ds->tilesize = 0;                  /* not decided yet */
+    ds->grid = snewn(ds->w * ds->h, signed char);
+    ds->bg = -1;
+    ds->cur_x = ds->cur_y = -1;
+
+    memset(ds->grid, -99, ds->w * ds->h);
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds,
+                      int x, int y, int v, int bg)
+{
+    if (v < 0) {
+        int coords[12];
+        int hl = 0;
+
+        if (v == -22 || v == -23) {
+            v += 20;
+
+            /*
+             * Omit the highlights in this case.
+             */
+            draw_rect(dr, x, y, TILE_SIZE, TILE_SIZE,
+                      bg == COL_BACKGROUND ? COL_BACKGROUND2 : bg);
+            draw_line(dr, x, y, x + TILE_SIZE - 1, y, COL_LOWLIGHT);
+            draw_line(dr, x, y, x, y + TILE_SIZE - 1, COL_LOWLIGHT);
+        } else {
+            /*
+             * Draw highlights to indicate the square is covered.
+             */
+            coords[0] = x + TILE_SIZE - 1;
+            coords[1] = y + TILE_SIZE - 1;
+            coords[2] = x + TILE_SIZE - 1;
+            coords[3] = y;
+            coords[4] = x;
+            coords[5] = y + TILE_SIZE - 1;
+            draw_polygon(dr, coords, 3, COL_LOWLIGHT ^ hl, COL_LOWLIGHT ^ hl);
+
+            coords[0] = x;
+            coords[1] = y;
+            draw_polygon(dr, coords, 3, COL_HIGHLIGHT ^ hl,
+                         COL_HIGHLIGHT ^ hl);
+
+            draw_rect(dr, x + HIGHLIGHT_WIDTH, y + HIGHLIGHT_WIDTH,
+                      TILE_SIZE - 2*HIGHLIGHT_WIDTH, TILE_SIZE - 2*HIGHLIGHT_WIDTH,
+                      bg);
+        }
+
+        if (v == -1) {
+            /*
+             * Draw a flag.
+             */
+#define SETCOORD(n, dx, dy) do { \
+    coords[(n)*2+0] = x + (int)(TILE_SIZE * (dx)); \
+    coords[(n)*2+1] = y + (int)(TILE_SIZE * (dy)); \
+} while (0)
+            SETCOORD(0, 0.6F,  0.35F);
+            SETCOORD(1, 0.6F,  0.7F);
+            SETCOORD(2, 0.8F,  0.8F);
+            SETCOORD(3, 0.25F, 0.8F);
+            SETCOORD(4, 0.55F, 0.7F);
+            SETCOORD(5, 0.55F, 0.35F);
+            draw_polygon(dr, coords, 6, COL_FLAGBASE, COL_FLAGBASE);
+
+            SETCOORD(0, 0.6F, 0.2F);
+            SETCOORD(1, 0.6F, 0.5F);
+            SETCOORD(2, 0.2F, 0.35F);
+            draw_polygon(dr, coords, 3, COL_FLAG, COL_FLAG);
+#undef SETCOORD
+
+        } else if (v == -3) {
+            /*
+             * Draw a question mark.
+             */
+            draw_text(dr, x + TILE_SIZE / 2, y + TILE_SIZE / 2,
+                      FONT_VARIABLE, TILE_SIZE * 6 / 8,
+                      ALIGN_VCENTRE | ALIGN_HCENTRE,
+                      COL_QUERY, "?");
+        }
+    } else {
+        /*
+         * Clear the square to the background colour, and draw thin
+         * grid lines along the top and left.
+         * 
+         * Exception is that for value 65 (mine we've just trodden
+         * on), we clear the square to COL_BANG.
+         */
+        if (v & 32) {
+            bg = COL_WRONGNUMBER;
+            v &= ~32;
+        }
+        draw_rect(dr, x, y, TILE_SIZE, TILE_SIZE,
+                  (v == 65 ? COL_BANG :
+                   bg == COL_BACKGROUND ? COL_BACKGROUND2 : bg));
+        draw_line(dr, x, y, x + TILE_SIZE - 1, y, COL_LOWLIGHT);
+        draw_line(dr, x, y, x, y + TILE_SIZE - 1, COL_LOWLIGHT);
+
+        if (v > 0 && v <= 8) {
+            /*
+             * Mark a number.
+             */
+            char str[2];
+            str[0] = v + '0';
+            str[1] = '\0';
+            draw_text(dr, x + TILE_SIZE / 2, y + TILE_SIZE / 2,
+                      FONT_VARIABLE, TILE_SIZE * 7 / 8,
+                      ALIGN_VCENTRE | ALIGN_HCENTRE,
+                      (COL_1 - 1) + v, str);
+
+        } else if (v >= 64) {
+            /*
+             * Mark a mine.
+             */
+            {
+                int cx = x + TILE_SIZE / 2;
+                int cy = y + TILE_SIZE / 2;
+                int r = TILE_SIZE / 2 - 3;
+
+                draw_circle(dr, cx, cy, 5*r/6, COL_MINE, COL_MINE);
+                draw_rect(dr, cx - r/6, cy - r, 2*(r/6)+1, 2*r+1, COL_MINE);
+                draw_rect(dr, cx - r, cy - r/6, 2*r+1, 2*(r/6)+1, COL_MINE);
+                draw_rect(dr, cx-r/3, cy-r/3, r/3, r/4, COL_HIGHLIGHT);
+            }
+
+            if (v == 66) {
+                /*
+                 * Cross through the mine.
+                 */
+                int dx;
+                for (dx = -1; dx <= +1; dx++) {
+                    draw_line(dr, x + 3 + dx, y + 2,
+                              x + TILE_SIZE - 3 + dx,
+                              y + TILE_SIZE - 2, COL_CROSS);
+                    draw_line(dr, x + TILE_SIZE - 3 + dx, y + 2,
+                              x + 3 + dx, y + TILE_SIZE - 2,
+                              COL_CROSS);
+                }
+            }
+        }
+    }
+
+    draw_update(dr, x, y, TILE_SIZE, TILE_SIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int x, y;
+    int mines, markers, bg;
+    int cx = -1, cy = -1, cmoved;
+
+    if (flashtime) {
+        int frame = (int)(flashtime / FLASH_FRAME);
+        if (frame % 2)
+            bg = (ui->flash_is_death ? COL_BACKGROUND : COL_LOWLIGHT);
+        else
+            bg = (ui->flash_is_death ? COL_BANG : COL_HIGHLIGHT);
+    } else
+        bg = COL_BACKGROUND;
+
+    if (!ds->started) {
+        int coords[10];
+
+        draw_rect(dr, 0, 0,
+                  TILE_SIZE * state->w + 2 * BORDER,
+                  TILE_SIZE * state->h + 2 * BORDER, COL_BACKGROUND);
+        draw_update(dr, 0, 0,
+                    TILE_SIZE * state->w + 2 * BORDER,
+                    TILE_SIZE * state->h + 2 * BORDER);
+
+        /*
+         * Recessed area containing the whole puzzle.
+         */
+        coords[0] = COORD(state->w) + OUTER_HIGHLIGHT_WIDTH - 1;
+        coords[1] = COORD(state->h) + OUTER_HIGHLIGHT_WIDTH - 1;
+        coords[2] = COORD(state->w) + OUTER_HIGHLIGHT_WIDTH - 1;
+        coords[3] = COORD(0) - OUTER_HIGHLIGHT_WIDTH;
+        coords[4] = coords[2] - TILE_SIZE;
+        coords[5] = coords[3] + TILE_SIZE;
+        coords[8] = COORD(0) - OUTER_HIGHLIGHT_WIDTH;
+        coords[9] = COORD(state->h) + OUTER_HIGHLIGHT_WIDTH - 1;
+        coords[6] = coords[8] + TILE_SIZE;
+        coords[7] = coords[9] - TILE_SIZE;
+        draw_polygon(dr, coords, 5, COL_HIGHLIGHT, COL_HIGHLIGHT);
+
+        coords[1] = COORD(0) - OUTER_HIGHLIGHT_WIDTH;
+        coords[0] = COORD(0) - OUTER_HIGHLIGHT_WIDTH;
+        draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
+
+        ds->started = TRUE;
+    }
+
+    if (ui->cur_visible) cx = ui->cur_x;
+    if (ui->cur_visible) cy = ui->cur_y;
+    cmoved = (cx != ds->cur_x || cy != ds->cur_y);
+
+    /*
+     * Now draw the tiles. Also in this loop, count up the number
+     * of mines and mine markers.
+     */
+    mines = markers = 0;
+    for (y = 0; y < ds->h; y++)
+        for (x = 0; x < ds->w; x++) {
+            int v = state->grid[y*ds->w+x], cc = 0;
+
+            if (v == -1)
+                markers++;
+            if (state->layout->mines && state->layout->mines[y*ds->w+x])
+                mines++;
+
+            if (v >= 0 && v <= 8) {
+                /*
+                 * Count up the flags around this tile, and if
+                 * there are too _many_, highlight the tile.
+                 */
+                int dx, dy, flags = 0;
+
+                for (dy = -1; dy <= +1; dy++)
+                    for (dx = -1; dx <= +1; dx++) {
+                        int nx = x+dx, ny = y+dy;
+                        if (nx >= 0 && nx < ds->w &&
+                            ny >= 0 && ny < ds->h &&
+                            state->grid[ny*ds->w+nx] == -1)
+                            flags++;
+                    }
+
+                if (flags > v)
+                    v |= 32;
+            }
+
+            if ((v == -2 || v == -3) &&
+                (abs(x-ui->hx) <= ui->hradius && abs(y-ui->hy) <= ui->hradius))
+                v -= 20;
+
+            if (cmoved && /* if cursor has moved, force redraw of curr and prev pos */
+                ((x == cx && y == cy) || (x == ds->cur_x && y == ds->cur_y)))
+              cc = 1;
+
+            if (ds->grid[y*ds->w+x] != v || bg != ds->bg || cc) {
+                draw_tile(dr, ds, COORD(x), COORD(y), v,
+                          (x == cx && y == cy) ? COL_CURSOR : bg);
+                ds->grid[y*ds->w+x] = v;
+            }
+        }
+    ds->bg = bg;
+    ds->cur_x = cx; ds->cur_y = cy;
+
+    if (!state->layout->mines)
+        mines = state->layout->n;
+
+    /*
+     * Update the status bar.
+     */
+    {
+        char statusbar[512];
+        if (state->dead) {
+            sprintf(statusbar, "DEAD!");
+        } else if (state->won) {
+            if (state->used_solve)
+                sprintf(statusbar, "Auto-solved.");
+            else
+                sprintf(statusbar, "COMPLETED!");
+        } else {
+            sprintf(statusbar, "Marked: %d / %d", markers, mines);
+        }
+        if (ui->deaths)
+            sprintf(statusbar + strlen(statusbar),
+                    "  Deaths: %d", ui->deaths);
+        status_bar(dr, statusbar);
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (oldstate->used_solve || newstate->used_solve)
+        return 0.0F;
+
+    if (dir > 0 && !oldstate->dead && !oldstate->won) {
+        if (newstate->dead) {
+            ui->flash_is_death = TRUE;
+            return 3 * FLASH_FRAME;
+        }
+        if (newstate->won) {
+            ui->flash_is_death = FALSE;
+            return 2 * FLASH_FRAME;
+        }
+    }
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    /*
+     * We report the game as lost only if the player has used the
+     * Solve function to reveal all the mines. Otherwise, we assume
+     * they'll undo and continue play.
+     */
+    return state->won ? (state->used_solve ? -1 : +1) : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    if (state->dead || state->won || ui->completed || !state->layout->mines)
+        return FALSE;
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame mines
+#endif
+
+const struct game thegame = {
+    "Mines", "games.mines", "mines",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    TRUE, game_timing_state,
+    BUTTON_BEATS(LEFT_BUTTON, RIGHT_BUTTON) | REQUIRE_RBUTTON,
+};
+
+#ifdef STANDALONE_OBFUSCATOR
+
+/*
+ * Vaguely useful stand-alone program which translates between
+ * obfuscated and clear Mines game descriptions. Pass in a game
+ * description on the command line, and if it's clear it will be
+ * obfuscated and vice versa. The output text should also be a
+ * valid game ID describing the same game. Like this:
+ *
+ * $ ./mineobfusc 9x9:4,4,mb071b49fbd1cb6a0d5868
+ * 9x9:4,4,004000007c00010022080
+ * $ ./mineobfusc 9x9:4,4,004000007c00010022080
+ * 9x9:4,4,mb071b49fbd1cb6a0d5868
+ */
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err;
+    int y, x;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    x = atoi(desc);
+    while (*desc && *desc != ',') desc++;
+    if (*desc) desc++;
+    y = atoi(desc);
+    while (*desc && *desc != ',') desc++;
+    if (*desc) desc++;
+
+    printf("%s:%s\n", id, describe_layout(s->layout->mines,
+                                          p->w * p->h,
+                                          x, y,
+                                          (*desc != 'm')));
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/misc.c b/apps/plugins/puzzles/misc.c
new file mode 100644
index 0000000000..caf52cd520
--- /dev/null
+++ b/apps/plugins/puzzles/misc.c
@@ -0,0 +1,363 @@
+/*
+ * misc.c: Miscellaneous helpful functions.
+ */
+
+#include "rbassert.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "puzzles.h"
+
+void free_cfg(config_item *cfg)
+{
+    config_item *i;
+
+    for (i = cfg; i->type != C_END; i++)
+        if (i->type == C_STRING)
+            sfree(i->sval);
+    sfree(cfg);
+}
+
+/*
+ * The Mines (among others) game descriptions contain the location of every
+ * mine, and can therefore be used to cheat.
+ *
+ * It would be pointless to attempt to _prevent_ this form of
+ * cheating by encrypting the description, since Mines is
+ * open-source so anyone can find out the encryption key. However,
+ * I think it is worth doing a bit of gentle obfuscation to prevent
+ * _accidental_ spoilers: if you happened to note that the game ID
+ * starts with an F, for example, you might be unable to put the
+ * knowledge of those mines out of your mind while playing. So,
+ * just as discussions of film endings are rot13ed to avoid
+ * spoiling it for people who don't want to be told, we apply a
+ * keyless, reversible, but visually completely obfuscatory masking
+ * function to the mine bitmap.
+ */
+void obfuscate_bitmap(unsigned char *bmp, int bits, int decode)
+{
+    int bytes, firsthalf, secondhalf;
+    struct step {
+        unsigned char *seedstart;
+        int seedlen;
+        unsigned char *targetstart;
+        int targetlen;
+    } steps[2];
+    int i, j;
+
+    /*
+     * My obfuscation algorithm is similar in concept to the OAEP
+     * encoding used in some forms of RSA. Here's a specification
+     * of it:
+     * 
+     *  + We have a `masking function' which constructs a stream of
+     *    pseudorandom bytes from a seed of some number of input
+     *    bytes.
+     * 
+     *  + We pad out our input bit stream to a whole number of
+     *    bytes by adding up to 7 zero bits on the end. (In fact
+     *    the bitmap passed as input to this function will already
+     *    have had this done in practice.)
+     * 
+     *  + We divide the _byte_ stream exactly in half, rounding the
+     *    half-way position _down_. So an 81-bit input string, for
+     *    example, rounds up to 88 bits or 11 bytes, and then
+     *    dividing by two gives 5 bytes in the first half and 6 in
+     *    the second half.
+     * 
+     *  + We generate a mask from the second half of the bytes, and
+     *    XOR it over the first half.
+     * 
+     *  + We generate a mask from the (encoded) first half of the
+     *    bytes, and XOR it over the second half. Any null bits at
+     *    the end which were added as padding are cleared back to
+     *    zero even if this operation would have made them nonzero.
+     * 
+     * To de-obfuscate, the steps are precisely the same except
+     * that the final two are reversed.
+     * 
+     * Finally, our masking function. Given an input seed string of
+     * bytes, the output mask consists of concatenating the SHA-1
+     * hashes of the seed string and successive decimal integers,
+     * starting from 0.
+     */
+
+    bytes = (bits + 7) / 8;
+    firsthalf = bytes / 2;
+    secondhalf = bytes - firsthalf;
+
+    steps[decode ? 1 : 0].seedstart = bmp + firsthalf;
+    steps[decode ? 1 : 0].seedlen = secondhalf;
+    steps[decode ? 1 : 0].targetstart = bmp;
+    steps[decode ? 1 : 0].targetlen = firsthalf;
+
+    steps[decode ? 0 : 1].seedstart = bmp;
+    steps[decode ? 0 : 1].seedlen = firsthalf;
+    steps[decode ? 0 : 1].targetstart = bmp + firsthalf;
+    steps[decode ? 0 : 1].targetlen = secondhalf;
+
+    for (i = 0; i < 2; i++) {
+        SHA_State base, final;
+        unsigned char digest[20];
+        char numberbuf[80];
+        int digestpos = 20, counter = 0;
+
+        SHA_Init(&base);
+        SHA_Bytes(&base, steps[i].seedstart, steps[i].seedlen);
+
+        for (j = 0; j < steps[i].targetlen; j++) {
+            if (digestpos >= 20) {
+                sprintf(numberbuf, "%d", counter++);
+                final = base;
+                SHA_Bytes(&final, numberbuf, strlen(numberbuf));
+                SHA_Final(&final, digest);
+                digestpos = 0;
+            }
+            steps[i].targetstart[j] ^= digest[digestpos++];
+        }
+
+        /*
+         * Mask off the pad bits in the final byte after both steps.
+         */
+        if (bits % 8)
+            bmp[bits / 8] &= 0xFF & (0xFF00 >> (bits % 8));
+    }
+}
+
+/* err, yeah, these two pretty much rely on unsigned char being 8 bits.
+ * Platforms where this is not the case probably have bigger problems
+ * than just making these two work, though... */
+char *bin2hex(const unsigned char *in, int inlen)
+{
+    char *ret = snewn(inlen*2 + 1, char), *p = ret;
+    int i;
+
+    for (i = 0; i < inlen*2; i++) {
+        int v = in[i/2];
+        if (i % 2 == 0) v >>= 4;
+        *p++ = "0123456789abcdef"[v & 0xF];
+    }
+    *p = '\0';
+    return ret;
+}
+
+unsigned char *hex2bin(const char *in, int outlen)
+{
+    unsigned char *ret = snewn(outlen, unsigned char);
+    int i;
+
+    memset(ret, 0, outlen*sizeof(unsigned char));
+    for (i = 0; i < outlen*2; i++) {
+        int c = in[i];
+        int v;
+
+        assert(c != 0);
+        if (c >= '0' && c <= '9')
+            v = c - '0';
+        else if (c >= 'a' && c <= 'f')
+            v = c - 'a' + 10;
+        else if (c >= 'A' && c <= 'F')
+            v = c - 'A' + 10;
+        else
+            v = 0;
+
+        ret[i / 2] |= v << (4 * (1 - (i % 2)));
+    }
+    return ret;
+}
+
+void game_mkhighlight_specific(frontend *fe, float *ret,
+                               int background, int highlight, int lowlight)
+{
+    float max;
+    int i;
+
+    /*
+     * Drop the background colour so that the highlight is
+     * noticeably brighter than it while still being under 1.
+     */
+    max = ret[background*3];
+    for (i = 1; i < 3; i++)
+        if (ret[background*3+i] > max)
+            max = ret[background*3+i];
+    if (max * 1.2F > 1.0F) {
+        for (i = 0; i < 3; i++)
+            ret[background*3+i] /= (max * 1.2F);
+    }
+
+    for (i = 0; i < 3; i++) {
+        if (highlight >= 0)
+            ret[highlight * 3 + i] = ret[background * 3 + i] * 1.2F;
+        if (lowlight >= 0)
+            ret[lowlight * 3 + i] = ret[background * 3 + i] * 0.8F;
+    }
+}
+
+void game_mkhighlight(frontend *fe, float *ret,
+                      int background, int highlight, int lowlight)
+{
+    frontend_default_colour(fe, &ret[background * 3]);
+    game_mkhighlight_specific(fe, ret, background, highlight, lowlight);
+}
+
+static void memswap(void *av, void *bv, int size)
+{
+    char tmpbuf[512];
+    char *a = av, *b = bv;
+
+    while (size > 0) {
+        int thislen = min(size, sizeof(tmpbuf));
+        memcpy(tmpbuf, a, thislen);
+        memcpy(a, b, thislen);
+        memcpy(b, tmpbuf, thislen);
+        a += thislen;
+        b += thislen;
+        size -= thislen;
+    }
+}
+
+void shuffle(void *array, int nelts, int eltsize, random_state *rs)
+{
+    char *carray = (char *)array;
+    int i;
+
+    for (i = nelts; i-- > 1 ;) {
+        int j = random_upto(rs, i+1);
+        if (j != i)
+            memswap(carray + eltsize * i, carray + eltsize * j, eltsize);
+    }
+}
+
+void draw_rect_outline(drawing *dr, int x, int y, int w, int h, int colour)
+{
+    int x0 = x, x1 = x+w-1, y0 = y, y1 = y+h-1;
+    int coords[8];
+
+    coords[0] = x0;
+    coords[1] = y0;
+    coords[2] = x0;
+    coords[3] = y1;
+    coords[4] = x1;
+    coords[5] = y1;
+    coords[6] = x1;
+    coords[7] = y0;
+
+    draw_polygon(dr, coords, 4, -1, colour);
+}
+
+void draw_rect_corners(drawing *dr, int cx, int cy, int r, int col)
+{
+    draw_line(dr, cx - r, cy - r, cx - r, cy - r/2, col);
+    draw_line(dr, cx - r, cy - r, cx - r/2, cy - r, col);
+    draw_line(dr, cx - r, cy + r, cx - r, cy + r/2, col);
+    draw_line(dr, cx - r, cy + r, cx - r/2, cy + r, col);
+    draw_line(dr, cx + r, cy - r, cx + r, cy - r/2, col);
+    draw_line(dr, cx + r, cy - r, cx + r/2, cy - r, col);
+    draw_line(dr, cx + r, cy + r, cx + r, cy + r/2, col);
+    draw_line(dr, cx + r, cy + r, cx + r/2, cy + r, col);
+}
+
+void move_cursor(int button, int *x, int *y, int maxw, int maxh, int wrap)
+{
+    int dx = 0, dy = 0;
+    switch (button) {
+    case CURSOR_UP:         dy = -1; break;
+    case CURSOR_DOWN:       dy = 1; break;
+    case CURSOR_RIGHT:      dx = 1; break;
+    case CURSOR_LEFT:       dx = -1; break;
+    default: return;
+    }
+    if (wrap) {
+        *x = (*x + dx + maxw) % maxw;
+        *y = (*y + dy + maxh) % maxh;
+    } else {
+        *x = min(max(*x+dx, 0), maxw - 1);
+        *y = min(max(*y+dy, 0), maxh - 1);
+    }
+}
+
+/* Used in netslide.c and sixteen.c for cursor movement around edge. */
+
+int c2pos(int w, int h, int cx, int cy)
+{
+    if (cy == -1)
+        return cx;                      /* top row, 0 .. w-1 (->) */
+    else if (cx == w)
+        return w + cy;                  /* R col, w .. w+h -1 (v) */
+    else if (cy == h)
+        return w + h + (w-cx-1);        /* bottom row, w+h .. w+h+w-1 (<-) */
+    else if (cx == -1)
+        return w + h + w + (h-cy-1);    /* L col, w+h+w .. w+h+w+h-1 (^) */
+
+    assert(!"invalid cursor pos!");
+    return -1; /* not reached */
+}
+
+int c2diff(int w, int h, int cx, int cy, int button)
+{
+    int diff = 0;
+
+    assert(IS_CURSOR_MOVE(button));
+
+    /* Obvious moves around edge. */
+    if (cy == -1)
+        diff = (button == CURSOR_RIGHT) ? +1 : (button == CURSOR_LEFT) ? -1 : diff;
+    if (cy == h)
+        diff = (button == CURSOR_RIGHT) ? -1 : (button == CURSOR_LEFT) ? +1 : diff;
+    if (cx == -1)
+        diff = (button == CURSOR_UP) ? +1 : (button == CURSOR_DOWN) ? -1 : diff;
+    if (cx == w)
+        diff = (button == CURSOR_UP) ? -1 : (button == CURSOR_DOWN) ? +1 : diff;
+
+    if (button == CURSOR_LEFT && cx == w && (cy == 0 || cy == h-1))
+        diff = (cy == 0) ? -1 : +1;
+    if (button == CURSOR_RIGHT && cx == -1 && (cy == 0 || cy == h-1))
+        diff = (cy == 0) ? +1 : -1;
+    if (button == CURSOR_DOWN && cy == -1 && (cx == 0 || cx == w-1))
+        diff = (cx == 0) ? -1 : +1;
+    if (button == CURSOR_UP && cy == h && (cx == 0 || cx == w-1))
+        diff = (cx == 0) ? +1 : -1;
+
+    debug(("cx,cy = %d,%d; w%d h%d, diff = %d", cx, cy, w, h, diff));
+    return diff;
+}
+
+void pos2c(int w, int h, int pos, int *cx, int *cy)
+{
+    int max = w+h+w+h;
+
+    pos = (pos + max) % max;
+
+    if (pos < w) {
+        *cx = pos; *cy = -1; return;
+    }
+    pos -= w;
+    if (pos < h) {
+        *cx = w; *cy = pos; return;
+    }
+    pos -= h;
+    if (pos < w) {
+        *cx = w-pos-1; *cy = h; return;
+    }
+    pos -= w;
+    if (pos < h) {
+      *cx = -1; *cy = h-pos-1; return;
+    }
+    assert(!"invalid pos, huh?"); /* limited by % above! */
+}
+
+void draw_text_outline(drawing *dr, int x, int y, int fonttype,
+                       int fontsize, int align,
+                       int text_colour, int outline_colour, char *text)
+{
+    if (outline_colour > -1) {
+        draw_text(dr, x-1, y, fonttype, fontsize, align, outline_colour, text);
+        draw_text(dr, x+1, y, fonttype, fontsize, align, outline_colour, text);
+        draw_text(dr, x, y-1, fonttype, fontsize, align, outline_colour, text);
+        draw_text(dr, x, y+1, fonttype, fontsize, align, outline_colour, text);
+    }
+    draw_text(dr, x, y, fonttype, fontsize, align, text_colour, text);
+}
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/mkauto.sh b/apps/plugins/puzzles/mkauto.sh
new file mode 100755
index 0000000000..297212ad4d
--- /dev/null
+++ b/apps/plugins/puzzles/mkauto.sh
@@ -0,0 +1,2 @@
+#! /bin/sh
+autoreconf -i && rm -rf autom4te.cache
diff --git a/apps/plugins/puzzles/mkfiles.pl b/apps/plugins/puzzles/mkfiles.pl
new file mode 100755
index 0000000000..c1623dfd12
--- /dev/null
+++ b/apps/plugins/puzzles/mkfiles.pl
@@ -0,0 +1,1807 @@
+#!/usr/bin/env perl
+#
+# Cross-platform Makefile generator.
+#
+# Reads the file `Recipe' to determine the list of generated
+# executables and their component objects. Then reads the source
+# files to compute #include dependencies. Finally, writes out the
+# various target Makefiles.
+
+# PuTTY specifics which could still do with removing:
+#  - Mac makefile is not portabilised at all. Include directories
+#    are hardwired, and also the libraries are fixed. This is
+#    mainly because I was too scared to go anywhere near it.
+#  - sbcsgen.pl is still run at startup.
+
+# Other things undone:
+#  - special-define objects (foo.o[PREPROCSYMBOL]) are not
+#    supported in the mac or vcproj makefiles.
+
+use warnings;
+use IO::Handle;
+use Cwd;
+use File::Basename;
+
+while ($#ARGV >= 0) {
+    if ($ARGV[0] eq "-U") {
+        # Convenience for Unix users: -U means that after we finish what
+        # we're doing here, we also run mkauto.sh and then 'configure'. So
+        # it's a one-stop shop for regenerating the actual end-product
+        # Unix makefile.
+        #
+        # Arguments supplied after -U go to configure.
+        $do_unix = 1;
+        shift @ARGV;
+        @confargs = @ARGV;
+        @ARGV = ();
+    } else {
+        die "unrecognised command-line argument '$ARGV[0]'\n";
+    }
+}
+
+@filestack = ();
+$in = new IO::Handle;
+open $in, "Recipe" or do {
+    # We want to deal correctly with being run from one of the
+    # subdirs in the source tree. So if we can't find Recipe here,
+    # try one level up.
+    chdir "..";
+    open $in, "Recipe" or die "unable to open Recipe file\n";
+};
+push @filestack, $in;
+
+# HACK: One of the source files in `charset' is auto-generated by
+# sbcsgen.pl. We need to generate that _now_, before attempting
+# dependency analysis.
+eval 'chdir "charset"; require "sbcsgen.pl"; chdir ".."';
+
+@srcdirs = ("./");
+
+$divert = undef; # ref to array of refs of scalars in which text is
+                 # currently being put
+$help = ""; # list of newline-free lines of help text
+$project_name = "project"; # this is a good enough default
+%makefiles = (); # maps makefile types to output makefile pathnames
+%makefile_extra = (); # maps makefile types to extra Makefile text
+%programs = (); # maps prog name + type letter to listref of objects/resources
+%groups = (); # maps group name to listref of objects/resources
+
+@allobjs = (); # all object file names
+
+readinput: while (1) {
+  $in = $filestack[$#filestack];
+  while (not defined ($_ = <$in>)) {
+    close $filestack[$#filestack];
+    pop @filestack;
+    last readinput if 0 == scalar @filestack;
+    $in = $filestack[$#filestack];
+  }
+  chomp;
+  @_ = split;
+
+  # If we're gathering help text, keep doing so.
+  if (defined $divert) {
+      if ((defined $_[0]) && $_[0] eq "!end") {
+          $divert = undef;
+      } else {
+          for my $ref (@$divert) {
+              ${$ref} .= "$_\n";
+          }
+      }
+      next;
+  }
+  # Skip comments and blank lines.
+  next if /^\s*#/ or scalar @_ == 0;
+
+  if ($_[0] eq "!begin" and $_[1] eq "help") { $divert = [\$help]; next; }
+  if ($_[0] eq "!name") { $project_name = $_[1]; next; }
+  if ($_[0] eq "!srcdir") { push @srcdirs, $_[1]; next; }
+  if ($_[0] eq "!makefile" and &mfval($_[1])) { $makefiles{$_[1]}=$_[2]; next;}
+  if ($_[0] eq "!specialobj" and &mfval($_[1])) { $specialobj{$_[1]}->{$_[2]} = 1; next;}
+  if ($_[0] eq "!cflags" and &mfval($_[1])) {
+      ($rest = $_) =~ s/^\s*\S+\s+\S+\s+\S+\s*//; # find rest of input line
+      $rest = 1 if $rest eq "";
+      $cflags{$_[1]}->{$_[2]} = $rest;
+      next;
+  }
+  if ($_[0] eq "!begin") {
+      my @args = @_;
+      shift @args;
+      $divert = [];
+      for my $component (@args) {
+          if ($component =~ /^>(.*)/) {
+              push @$divert, \$auxfiles{$1};
+          } elsif ($component =~ /^([^_]*)(_.*)?$/ and &mfval($1)) {
+              push @$divert, \$makefile_extra{$component};
+          }
+      }
+      next;
+  }
+  if ($_[0] eq "!include") {
+      @newfiles = ();
+      for ($i = 1; $i <= $#_; $i++) {
+          push @newfiles, (sort glob $_[$i]);
+      }
+      for ($i = $#newfiles; $i >= 0; $i--) {
+          $file = $newfiles[$i];
+          $f = new IO::Handle;
+          open $f, "<$file" or die "unable to open include file '$file'\n";
+          push @filestack, $f;
+      }
+      next;
+  }
+
+  # Now we have an ordinary line. See if it's an = line, a : line
+  # or a + line.
+  @objs = @_;
+
+  if ($_[0] eq "+") {
+    $listref = $lastlistref;
+    $prog = undef;
+    die "$.: unexpected + line\n" if !defined $lastlistref;
+  } elsif ($_[1] eq "=") {
+    $groups{$_[0]} = [];
+    $listref = $groups{$_[0]};
+    $prog = undef;
+    shift @objs; # eat the group name
+  } elsif ($_[1] eq "+=") {
+    $groups{$_[0]} = [] if !defined $groups{$_[0]};
+    $listref = $groups{$_[0]};
+    $prog = undef;
+    shift @objs; # eat the group name
+  } elsif ($_[1] eq ":") {
+    $listref = [];
+    $prog = $_[0];
+    shift @objs; # eat the program name
+  } else {
+    die "$.: unrecognised line type: '$_'\n";
+  }
+  shift @objs; # eat the +, the = or the :
+
+  while (scalar @objs > 0) {
+    $i = shift @objs;
+    if ($groups{$i}) {
+      foreach $j (@{$groups{$i}}) { unshift @objs, $j; }
+    } elsif (($i eq "[G]" or $i eq "[C]" or $i eq "[M]" or
+              $i eq "[X]" or $i eq "[U]" or $i eq "[MX]") and defined $prog) {
+      $type = substr($i,1,(length $i)-2);
+    } else {
+      if ($i =~ /\?$/) {
+        # Object files with a trailing question mark are optional:
+        # the build can proceed fine without them, so we only use
+        # them if their primary source files are present.
+        $i =~ s/\?$//;
+        $i = undef unless defined &finddep($i);
+      } elsif ($i =~ /\|/) {
+        # Object file descriptions containing a vertical bar are
+        # lists of choices: we use the _first_ one whose primary
+        # source file is present.
+        @options = split /\|/, $i;
+        $j = undef;
+        foreach $k (@options) {
+          $j=$k, last if defined &finddep($k);
+        }
+        die "no alternative found for $i\n" unless defined $j;
+        $i = $j;
+      }
+      if (defined $i) {
+        push @$listref, $i;
+        push @allobjs, $i;
+      }
+    }
+  }
+  if ($prog and $type) {
+    die "multiple program entries for $prog [$type]\n"
+        if defined $programs{$prog . "," . $type};
+    $programs{$prog . "," . $type} = $listref;
+  }
+  $lastlistref = $listref;
+}
+
+foreach $aux (sort keys %auxfiles) {
+    open AUX, ">$aux";
+    print AUX $auxfiles{$aux};
+    close AUX;
+}
+
+# Find object file names with predefines (in square brackets after
+# the module name), and decide on actual object names for them.
+foreach $i (@allobjs) {
+  if ($i !~ /\[/) {
+    $objname{$i} = $i;
+    $srcname{$i} = $i;
+    $usedobjname{$i} = 1;
+  }
+}
+foreach $i (@allobjs) {
+  if ($i =~ /^(.*)\[([^\]]*)/) {
+    $defs{$i} = [ split ",",$2 ];
+    $srcname{$i} = $s = $1;
+    $index = 1;
+    while (1) {
+      $maxlen = length $s;
+      $maxlen = 8 if $maxlen < 8;
+      $chop = $maxlen - length $index;
+      $chop = length $s if $chop > length $s;
+      $chop = 0 if $chop < 0;
+      $name = substr($s, 0, $chop) . $index;
+      $index++, next if $usedobjname{$name};
+      $objname{$i} = $name;
+      $usedobjname{$name} = 1;
+      last;
+    }
+  }
+}
+
+# Now retrieve the complete list of objects and resource files, and
+# construct dependency data for them. While we're here, expand the
+# object list for each program, and complain if its type isn't set.
+@prognames = sort keys %programs;
+%depends = ();
+@scanlist = ();
+foreach $i (@prognames) {
+  ($prog, $type) = split ",", $i;
+  # Strip duplicate object names.
+  $prev = '';
+  @list = grep { $status = ($prev ne $_); $prev=$_; $status }
+          sort @{$programs{$i}};
+  $programs{$i} = [@list];
+  foreach $jj (@list) {
+    $j = $srcname{$jj};
+    $file = &finddep($j);
+    if (defined $file) {
+      $depends{$jj} = [$file];
+      push @scanlist, $file;
+    }
+  }
+}
+
+# Scan each file on @scanlist and find further inclusions.
+# Inclusions are given by lines of the form `#include "otherfile"'
+# (system headers are automatically ignored by this because they'll
+# be given in angle brackets). Files included by this method are
+# added back on to @scanlist to be scanned in turn (if not already
+# done).
+#
+# Resource scripts (.rc) can also include a file by means of a line
+# ending `ICON "filename"'. Files included by this method are not
+# added to @scanlist because they can never include further files.
+#
+# In this pass we write out a hash %further which maps a source
+# file name into a listref containing further source file names.
+
+%further = ();
+while (scalar @scanlist > 0) {
+  $file = shift @scanlist;
+  next if defined $further{$file}; # skip if we've already done it
+  $further{$file} = [];
+  $dirfile = &findfile($file);
+  open IN, "$dirfile" or die "unable to open source file $file\n";
+  while (<IN>) {
+    chomp;
+    /^\s*#include\s+\"([^\"]+)\"/ and do {
+      push @{$further{$file}}, $1;
+      push @scanlist, $1;
+      next;
+    };
+    /ICON\s+\"([^\"]+)\"\s*$/ and do {
+      push @{$further{$file}}, $1;
+      next;
+    }
+  }
+  close IN;
+}
+
+# Now we're ready to generate the final dependencies section. For
+# each key in %depends, we must expand the dependencies list by
+# iteratively adding entries from %further.
+foreach $i (keys %depends) {
+  %dep = ();
+  @scanlist = @{$depends{$i}};
+  foreach $i (@scanlist) { $dep{$i} = 1; }
+  while (scalar @scanlist > 0) {
+    $file = shift @scanlist;
+    foreach $j (@{$further{$file}}) {
+      if (!$dep{$j}) {
+        $dep{$j} = 1;
+        push @{$depends{$i}}, $j;
+        push @scanlist, $j;
+      }
+    }
+  }
+#  printf "%s: %s\n", $i, join ' ',@{$depends{$i}};
+}
+
+# Validation of input.
+
+sub mfval($) {
+    my ($type) = @_;
+    # Returns true if the argument is a known makefile type. Otherwise,
+    # prints a warning and returns false;
+    if (grep { $type eq $_ }
+        ("vc","vcproj","cygwin","borland","lcc","gtk","am","mpw","nestedvm","osx","wce","gnustep","emcc")) {
+            return 1;
+        }
+    warn "$.:unknown makefile type '$type'\n";
+    return 0;
+}
+
+# Utility routines while writing out the Makefiles.
+
+sub dirpfx {
+    my ($path) = shift @_;
+    my ($sep) = shift @_;
+    my $ret = "";
+    my $i;
+    while (($i = index $path, $sep) >= 0) {
+        $path = substr $path, ($i + length $sep);
+        $ret .= "..$sep";
+    }
+    return $ret;
+}
+
+sub findfile {
+  my ($name) = @_;
+  my $dir;
+  my $i;
+  my $outdir = undef;
+  unless (defined $findfilecache{$name}) {
+    $i = 0;
+    foreach $dir (@srcdirs) {
+      $outdir = $dir, $i++ if -f "$dir$name";
+    }
+    die "multiple instances of source file $name\n" if $i > 1;
+    $findfilecache{$name} = (defined $outdir ? $outdir . $name : undef);
+  }
+  return $findfilecache{$name};
+}
+
+sub finddep {
+  my $j = shift @_;
+  my $file;
+  # Find the first dependency of an object.
+
+  # Dependencies for "x" start with "x.c" or "x.m" (depending on
+  # which one exists).
+  # Dependencies for "x.res" start with "x.rc".
+  # Dependencies for "x.rsrc" start with "x.r".
+  # Both types of file are pushed on the list of files to scan.
+  # Libraries (.lib) don't have dependencies at all.
+  if ($j =~ /^(.*)\.res$/) {
+    $file = "$1.rc";
+  } elsif ($j =~ /^(.*)\.rsrc$/) {
+    $file = "$1.r";
+  } elsif ($j !~ /\./) {
+    $file = "$j.c";
+    $file = "$j.m" unless &findfile($file);
+  } else {
+    # For everything else, we assume it's its own dependency.
+    $file = $j;
+  }
+  $file = undef unless &findfile($file);
+  return $file;
+}
+
+sub objects {
+  my ($prog, $otmpl, $rtmpl, $ltmpl, $prefix, $dirsep) = @_;
+  my @ret;
+  my ($i, $x, $y);
+  ($otmpl, $rtmpl, $ltmpl) = map { defined $_ ? $_ : "" } ($otmpl, $rtmpl, $ltmpl);
+  @ret = ();
+  foreach $ii (@{$programs{$prog}}) {
+    $i = $objname{$ii};
+    $x = "";
+    if ($i =~ /^(.*)\.(res|rsrc)/) {
+      $y = $1;
+      ($x = $rtmpl) =~ s/X/$y/;
+    } elsif ($i =~ /^(.*)\.lib/) {
+      $y = $1;
+      ($x = $ltmpl) =~ s/X/$y/;
+    } elsif ($i !~ /\./) {
+      ($x = $otmpl) =~ s/X/$i/;
+    }
+    push @ret, $x if $x ne "";
+  }
+  return join " ", @ret;
+}
+
+sub special {
+  my ($prog, $suffix) = @_;
+  my @ret;
+  my ($i, $x, $y);
+  @ret = ();
+  foreach $ii (@{$programs{$prog}}) {
+    $i = $objname{$ii};
+    if (substr($i, (length $i) - (length $suffix)) eq $suffix) {
+      push @ret, $i;
+    }
+  }
+  return join " ", @ret;
+}
+
+sub splitline {
+  my ($line, $width, $splitchar) = @_;
+  my $result = "";
+  my $len;
+  $len = (defined $width ? $width : 76);
+  $splitchar = (defined $splitchar ? $splitchar : '\\');
+  while (length $line > $len) {
+    $line =~ /^(.{0,$len})\s(.*)$/ or $line =~ /^(.{$len,}?\s(.*)$/;
+    $result .= $1;
+    $result .= " ${splitchar}\n\t\t" if $2 ne '';
+    $line = $2;
+    $len = 60;
+  }
+  return $result . $line;
+}
+
+sub deps {
+  my ($otmpl, $rtmpl, $prefix, $dirsep, $depchar, $splitchar) = @_;
+  my ($i, $x, $y);
+  my @deps;
+  my @ret;
+  @ret = ();
+  $depchar ||= ':';
+  foreach $ii (sort keys %depends) {
+    $i = $objname{$ii};
+    next if $specialobj{$mftyp}->{$i};
+    if ($i =~ /^(.*)\.(res|rsrc)/) {
+      next if !defined $rtmpl;
+      $y = $1;
+      ($x = $rtmpl) =~ s/X/$y/;
+    } else {
+      ($x = $otmpl) =~ s/X/$i/;
+    }
+    @deps = @{$depends{$ii}};
+    # Skip things which are their own dependency.
+    next if grep { $_ eq $i } @deps;
+    @deps = map {
+      $_ = &findfile($_);
+      s/\//$dirsep/g;
+      $_ = $prefix . $_;
+    } @deps;
+    push @ret, {obj => $x, deps => [@deps], defs => $defs{$ii}};
+  }
+  return @ret;
+}
+
+sub prognames {
+  my ($types) = @_;
+  my ($n, $prog, $type);
+  my @ret;
+  @ret = ();
+  foreach $n (@prognames) {
+    ($prog, $type) = split ",", $n;
+    push @ret, $n if index(":$types:", ":$type:") >= 0;
+  }
+  return @ret;
+}
+
+sub progrealnames {
+  my ($types) = @_;
+  my ($n, $prog, $type);
+  my @ret;
+  @ret = ();
+  foreach $n (@prognames) {
+    ($prog, $type) = split ",", $n;
+    push @ret, $prog if index(":$types:", ":$type:") >= 0;
+  }
+  return @ret;
+}
+
+sub manpages {
+  my ($types,$suffix) = @_;
+
+  # assume that all UNIX programs have a man page
+  if($suffix eq "1" && $types =~ /:X:/) {
+    return map("$_.1", &progrealnames($types));
+  }
+  return ();
+}
+
+$orig_dir = cwd;
+
+# Now we're ready to output the actual Makefiles.
+
+if (defined $makefiles{'cygwin'}) {
+    $mftyp = 'cygwin';
+    $dirpfx = &dirpfx($makefiles{'cygwin'}, "/");
+
+    ##-- CygWin makefile
+    open OUT, ">$makefiles{'cygwin'}"; select OUT;
+    print
+    "# Makefile for $project_name under cygwin.\n".
+    "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+    "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    # gcc command line option is -D not /D
+    ($_ = $help) =~ s/=\/D/=-D/gs;
+    print $_;
+    print
+    "\n".
+    "# You can define this path to point at your tools if you need to\n".
+    "# TOOLPATH = c:\\cygwin\\bin\\ # or similar, if you're running Windows\n".
+    "# TOOLPATH = /pkg/mingw32msvc/i386-mingw32msvc/bin/\n".
+    "CC = \$(TOOLPATH)gcc\n".
+    "RC = \$(TOOLPATH)windres\n".
+    "# Uncomment the following two lines to compile under Winelib\n".
+    "# CC = winegcc\n".
+    "# RC = wrc\n".
+    "# You may also need to tell windres where to find include files:\n".
+    "# RCINC = --include-dir c:\\cygwin\\include\\\n".
+    "\n".
+    &splitline("CFLAGS = -mno-cygwin -Wall -O2 -D_WINDOWS -DDEBUG -DWIN32S_COMPAT".
+      " -D_NO_OLDNAMES -DNO_MULTIMON -DNO_HTMLHELP " .
+               (join " ", map {"-I$dirpfx$_"} @srcdirs)) .
+               "\n".
+    "LDFLAGS = -mno-cygwin -s\n".
+    &splitline("RCFLAGS = \$(RCINC) --define WIN32=1 --define _WIN32=1".
+      " --define WINVER=0x0400 --define MINGW32_FIX=1 " .
+        (join " ", map {"--include $dirpfx$_"} @srcdirs) )."\n".
+    "\n";
+    print &splitline("all:" . join "", map { " $_.exe" } &progrealnames("G:C"));
+    print "\n\n";
+    foreach $p (&prognames("G:C")) {
+      ($prog, $type) = split ",", $p;
+      $objstr = &objects($p, "X.o", "X.res.o", undef);
+      print &splitline($prog . ".exe: " . $objstr), "\n";
+      my $mw = $type eq "G" ? " -mwindows" : "";
+      $libstr = &objects($p, undef, undef, "-lX");
+      print &splitline("\t\$(CC)" . $mw . " \$(LDFLAGS) -o \$@ " .
+                       "-Wl,-Map,$prog.map " .
+                       $objstr . " $libstr", 69), "\n\n";
+    }
+    foreach $d (&deps("X.o", "X.res.o", $dirpfx, "/")) {
+      print &splitline(sprintf("%s: %s", $d->{obj}, join " ", @{$d->{deps}})),
+        "\n";
+      if ($d->{obj} =~ /\.res\.o$/) {
+        print "\t\$(RC) \$(FWHACK) \$(RCFL) \$(RCFLAGS) \$< \$\@\n";
+      } else {
+        $deflist = join "", map { " -D$_" } @{$d->{defs}};
+        print "\t\$(CC) \$(COMPAT) \$(FWHACK) \$(CFLAGS)" .
+            " \$(XFLAGS)$deflist -c \$< -o \$\@\n";
+      }
+    }
+    print "\n";
+    print $makefile_extra{'cygwin'} || "";
+    print "\nclean:\n".
+    "\trm -f *.o *.exe *.res.o *.map\n".
+    "\n";
+    select STDOUT; close OUT;
+
+}
+
+##-- Borland makefile
+if (defined $makefiles{'borland'}) {
+    $mftyp = 'borland';
+    $dirpfx = &dirpfx($makefiles{'borland'}, "\\");
+
+    %stdlibs = (  # Borland provides many Win32 API libraries intrinsically
+      "advapi32" => 1,
+      "comctl32" => 1,
+      "comdlg32" => 1,
+      "gdi32" => 1,
+      "imm32" => 1,
+      "shell32" => 1,
+      "user32" => 1,
+      "winmm" => 1,
+      "winspool" => 1,
+      "wsock32" => 1,
+    );
+    open OUT, ">$makefiles{'borland'}"; select OUT;
+    print
+    "# Makefile for $project_name under Borland C.\n".
+    "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+    "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    # bcc32 command line option is -D not /D
+    ($_ = $help) =~ s/=\/D/=-D/gs;
+    print $_;
+    print
+    "\n".
+    "# If you rename this file to `Makefile', you should change this line,\n".
+    "# so that the .rsp files still depend on the correct makefile.\n".
+    "MAKEFILE = Makefile.bor\n".
+    "\n".
+    "# C compilation flags\n".
+    "CFLAGS = -D_WINDOWS -DWINVER=0x0401\n".
+    "\n".
+    "# Get include directory for resource compiler\n".
+    "!if !\$d(BCB)\n".
+    "BCB = \$(MAKEDIR)\\..\n".
+    "!endif\n".
+    "\n";
+    print &splitline("all:" . join "", map { " $_.exe" } &progrealnames("G:C"));
+    print "\n\n";
+    foreach $p (&prognames("G:C")) {
+      ($prog, $type) = split ",", $p;
+      $objstr =  &objects($p, "X.obj", "X.res", undef);
+      print &splitline("$prog.exe: " . $objstr . " $prog.rsp"), "\n";
+      my $ap = ($type eq "G") ? "-aa" : "-ap";
+      print "\tilink32 $ap -Gn -L\$(BCB)\\lib \@$prog.rsp\n\n";
+    }
+    foreach $p (&prognames("G:C")) {
+      ($prog, $type) = split ",", $p;
+      print $prog, ".rsp: \$(MAKEFILE)\n";
+      $objstr = &objects($p, "X.obj", undef, undef);
+      @objlist = split " ", $objstr;
+      @objlines = ("");
+      foreach $i (@objlist) {
+        if (length($objlines[$#objlines] . " $i") > 50) {
+          push @objlines, "";
+        }
+        $objlines[$#objlines] .= " $i";
+      }
+      $c0w = ($type eq "G") ? "c0w32" : "c0x32";
+      print "\techo $c0w + > $prog.rsp\n";
+      for ($i=0; $i<=$#objlines; $i++) {
+        $plus = ($i < $#objlines ? " +" : "");
+        print "\techo$objlines[$i]$plus >> $prog.rsp\n";
+      }
+      print "\techo $prog.exe >> $prog.rsp\n";
+      $objstr = &objects($p, "X.obj", "X.res", undef);
+      @libs = split " ", &objects($p, undef, undef, "X");
+      @libs = grep { !$stdlibs{$_} } @libs;
+      unshift @libs, "cw32", "import32";
+      $libstr = join ' ', @libs;
+      print "\techo nul,$libstr, >> $prog.rsp\n";
+      print "\techo " . &objects($p, undef, "X.res", undef) . " >> $prog.rsp\n";
+      print "\n";
+    }
+    foreach $d (&deps("X.obj", "X.res", $dirpfx, "\\")) {
+      print &splitline(sprintf("%s: %s", $d->{obj}, join " ", @{$d->{deps}})),
+        "\n";
+      if ($d->{obj} =~ /\.res$/) {
+        print &splitline("\tbrcc32 \$(FWHACK) \$(RCFL) " .
+                         "-i \$(BCB)\\include -r -DNO_WINRESRC_H -DWIN32".
+                         " -D_WIN32 -DWINVER=0x0401 \$*.rc",69)."\n";
+      } else {
+        $deflist = join "", map { " -D$_" } @{$d->{defs}};
+        print &splitline("\tbcc32 -w-aus -w-ccc -w-par -w-pia \$(COMPAT)" .
+                         " \$(FWHACK) \$(CFLAGS) \$(XFLAGS)$deflist ".
+                         (join " ", map {"-I$dirpfx$_"} @srcdirs) .
+                         " /o$d->{obj} /c ".$d->{deps}->[0],69)."\n";
+      }
+    }
+    print "\n";
+    print $makefile_extra{'borland'} || "";
+    print "\nclean:\n".
+    "\t-del *.obj\n".
+    "\t-del *.exe\n".
+    "\t-del *.res\n".
+    "\t-del *.pch\n".
+    "\t-del *.aps\n".
+    "\t-del *.il*\n".
+    "\t-del *.pdb\n".
+    "\t-del *.rsp\n".
+    "\t-del *.tds\n".
+    "\t-del *.\$\$\$\$\$\$\n";
+    select STDOUT; close OUT;
+}
+
+if (defined $makefiles{'vc'}) {
+    $mftyp = 'vc';
+    $dirpfx = &dirpfx($makefiles{'vc'}, "\\");
+
+    ##-- Visual C++ makefile
+    open OUT, ">$makefiles{'vc'}"; select OUT;
+    print
+      "# Makefile for $project_name under Visual C.\n".
+      "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+      "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    print $help;
+    print
+      "\n".
+      "# If you rename this file to `Makefile', you should change this line,\n".
+      "# so that the .rsp files still depend on the correct makefile.\n".
+      "MAKEFILE = Makefile.vc\n".
+      "\n".
+      "# C compilation flags\n".
+      "CFLAGS = /nologo /W3 /O1 /D_WINDOWS /D_WIN32_WINDOWS=0x401 /DWINVER=0x401 /I.\n".
+      "LFLAGS = /incremental:no /fixed\n".
+      "\n";
+    print &splitline("all:" . join "", map { " $_.exe" } &progrealnames("G:C"));
+    print "\n\n";
+    foreach $p (&prognames("G:C")) {
+        ($prog, $type) = split ",", $p;
+        $objstr = &objects($p, "X.obj", "X.res", undef);
+        print &splitline("$prog.exe: " . $objstr . " $prog.rsp"), "\n";
+        print "\tlink \$(LFLAGS) -out:$prog.exe -map:$prog.map \@$prog.rsp\n\n";
+    }
+    foreach $p (&prognames("G:C")) {
+        ($prog, $type) = split ",", $p;
+        print $prog, ".rsp: \$(MAKEFILE)\n";
+        $objstr = &objects($p, "X.obj", "X.res", "X.lib");
+        @objlist = split " ", $objstr;
+        @objlines = ("");
+        foreach $i (@objlist) {
+            if (length($objlines[$#objlines] . " $i") > 50) {
+                push @objlines, "";
+            }
+            $objlines[$#objlines] .= " $i";
+        }
+        $subsys = ($type eq "G") ? "windows" : "console";
+        print "\techo /nologo /subsystem:$subsys > $prog.rsp\n";
+        for ($i=0; $i<=$#objlines; $i++) {
+            print "\techo$objlines[$i] >> $prog.rsp\n";
+        }
+        print "\n";
+    }
+    foreach $d (&deps("X.obj", "X.res", $dirpfx, "\\")) {
+        print &splitline(sprintf("%s: %s", $d->{obj}, join " ", @{$d->{deps}})),
+          "\n";
+        if ($d->{obj} =~ /\.res$/) {
+            print "\trc \$(FWHACK) \$(RCFL) -r -DWIN32 -D_WIN32 ".
+              "-DWINVER=0x0400 -fo".$d->{obj}." ".$d->{deps}->[0]."\n";
+        } else {
+            $deflist = join "", map { " /D$_" } @{$d->{defs}};
+            print "\tcl \$(COMPAT) \$(FWHACK) \$(CFLAGS) \$(XFLAGS)$deflist".
+              " /c ".$d->{deps}->[0]." /Fo$d->{obj}\n";
+        }
+    }
+    print "\n";
+    print $makefile_extra{'vc'} || "";
+    print "\nclean: tidy\n".
+      "\t-del *.exe\n\n".
+      "tidy:\n".
+      "\t-del *.obj\n".
+      "\t-del *.res\n".
+      "\t-del *.pch\n".
+      "\t-del *.aps\n".
+      "\t-del *.ilk\n".
+      "\t-del *.pdb\n".
+      "\t-del *.rsp\n".
+      "\t-del *.dsp\n".
+      "\t-del *.dsw\n".
+      "\t-del *.ncb\n".
+      "\t-del *.opt\n".
+      "\t-del *.plg\n".
+      "\t-del *.map\n".
+      "\t-del *.idb\n".
+      "\t-del debug.log\n";
+    select STDOUT; close OUT;
+}
+
+if (defined $makefiles{'wce'}) {
+    $mftyp = 'wce';
+    $dirpfx = &dirpfx($makefiles{'wce'}, "\\");
+
+    ##-- eMbedded Visual C PocketPC makefile
+    open OUT, ">$makefiles{'wce'}"; select OUT;
+    print
+      "# Makefile for $project_name on PocketPC using eMbedded Visual C.\n".
+      "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+      "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    print $help;
+    print
+      "\n".
+      "# If you rename this file to `Makefile', you should change this line,\n".
+      "# so that the .rsp files still depend on the correct makefile.\n".
+      "MAKEFILE = Makefile.wce\n".
+      "\n".
+      "# This makefile expects the environment to have been set up by one\n".
+      "# of the PocketPC batch files wcearmv4.bat and wceemulator.bat. No\n".
+      "# other build targets are currently supported, because they would\n".
+      "# need a section in this if statement.\n".
+      "!if \"\$(TARGETCPU)\" == \"emulator\"\n".
+      "PLATFORM_DEFS=/D \"_i386_\" /D \"i_386_\" /D \"_X86_\" /D \"x86\"\n".
+      "CC=cl\n".
+      "BASELIBS=commctrl.lib coredll.lib corelibc.lib aygshell.lib\n".
+      "MACHINE=IX86\n".
+      "!else\n".
+      "PLATFORM_DEFS=/D \"ARM\" /D \"_ARM_\" /D \"ARMV4\"\n".
+      "CC=clarm\n".
+      "BASELIBS=commctrl.lib coredll.lib aygshell.lib\n".
+      "MACHINE=ARM\n".
+      "!endif\n".
+      "\n".
+      "# C compilation flags\n".
+      "CFLAGS = /nologo /W3 /O1 /MC /D _WIN32_WCE=420 /D \"WIN32_PLATFORM_PSPC=400\" /D UNDER_CE=420 \\\n".
+      "         \$(PLATFORM_DEFS) \\\n".
+      "         /D \"UNICODE\" /D \"_UNICODE\" /D \"NDEBUG\" /D \"NO_HTMLHELP\"\n".
+      "\n".
+      "LFLAGS = /nologo /incremental:no \\\n".
+      "         /base:0x00010000 /stack:0x10000,0x1000 /entry:WinMainCRTStartup \\\n".
+      "         /nodefaultlib:libc.lib /nodefaultlib:libcmt.lib /nodefaultlib:msvcrt.lib /nodefaultlib:OLDNAMES.lib \\\n".
+      "         /subsystem:windowsce,4.20 /align:4096 /MACHINE:\$(MACHINE)\n".
+      "\n".
+      "RCFL = /d UNDER_CE=420 /d _WIN32_WCE=420 /d \"WIN32_PLATFORM_PSPC=400\" \\\n".
+      "       \$(PLATFORM_DEFS) \\\n".
+      "       /d \"NDEBUG\" /d \"UNICODE\" /d \"_UNICODE\"\n".
+      "\n";
+    print &splitline("all:" . join "", map { " $_.exe" } &progrealnames("G"));
+    print "\n\n";
+    foreach $p (&prognames("G")) {
+        ($prog, $type) = split ",", $p;
+        $objstr = &objects($p, "X.obj", "X.res", undef);
+        print &splitline("$prog.exe: " . $objstr . " $prog.rsp"), "\n";
+        print "\tlink \$(LFLAGS) -out:$prog.exe -map:$prog.map \@$prog.rsp\n\n";
+    }
+    foreach $p (&prognames("G")) {
+        ($prog, $type) = split ",", $p;
+        print $prog, ".rsp: \$(MAKEFILE)\n";
+        $objstr = &objects($p, "X.obj", "X.res", undef);
+        @objlist = split " ", $objstr;
+        @objlines = ("");
+        foreach $i (@objlist) {
+            if (length($objlines[$#objlines] . " $i") > 50) {
+                push @objlines, "";
+            }
+            $objlines[$#objlines] .= " $i";
+        }
+        print "\techo \$(BASELIBS) > $prog.rsp\n";
+        for ($i=0; $i<=$#objlines; $i++) {
+            print "\techo$objlines[$i] >> $prog.rsp\n";
+        }
+        print "\n";
+    }
+    foreach $d (&deps("X.obj", "X.res", $dirpfx, "\\")) {
+        print &splitline(sprintf("%s: %s", $d->{obj}, join " ", @{$d->{deps}})),
+          "\n";
+        if ($d->{obj} =~ /\.res$/) {
+            print "\trc \$(FWHACK) \$(RCFL) -r -fo".
+              $d->{obj}." ".$d->{deps}->[0]."\n";
+        } else {
+            $deflist = join "", map { " /D$_" } @{$d->{defs}};
+            print "\t\$(CC) \$(COMPAT) \$(FWHACK) \$(CFLAGS) \$(XFLAGS)$deflist".
+              " /c ".$d->{deps}->[0]." /Fo$d->{obj}\n";
+        }
+    }
+    print "\n";
+    print $makefile_extra{'wce'} || "";
+    print "\nclean: tidy\n".
+      "\t-del *.exe\n\n".
+      "tidy:\n".
+      "\t-del *.obj\n".
+      "\t-del *.res\n".
+      "\t-del *.pch\n".
+      "\t-del *.aps\n".
+      "\t-del *.ilk\n".
+      "\t-del *.pdb\n".
+      "\t-del *.rsp\n".
+      "\t-del *.dsp\n".
+      "\t-del *.dsw\n".
+      "\t-del *.ncb\n".
+      "\t-del *.opt\n".
+      "\t-del *.plg\n".
+      "\t-del *.map\n".
+      "\t-del *.idb\n".
+      "\t-del debug.log\n";
+    select STDOUT; close OUT;
+}
+
+if (defined $makefiles{'vcproj'}) {
+    $mftyp = 'vcproj';
+
+    ##-- MSVC 6 Workspace and projects
+    #
+    # Note: All files created in this section are written in binary
+    # mode, because although MSVC's command-line make can deal with
+    # LF-only line endings, MSVC project files really _need_ to be
+    # CRLF. Hence, in order for mkfiles.pl to generate usable project
+    # files even when run from Unix, I make sure all files are binary
+    # and explicitly write the CRLFs.
+    #
+    # Create directories if necessary
+    mkdir $makefiles{'vcproj'}
+        if(! -d $makefiles{'vcproj'});
+    chdir $makefiles{'vcproj'};
+    @deps = &deps("X.obj", "X.res", "", "\\");
+    %all_object_deps = map {$_->{obj} => $_->{deps}} @deps;
+    # Create the project files
+    # Get names of all Windows projects (GUI and console)
+    my @prognames = &prognames("G:C");
+    foreach $progname (@prognames) {
+        create_project(\%all_object_deps, $progname);
+    }
+    # Create the workspace file
+    open OUT, ">$project_name.dsw"; binmode OUT; select OUT;
+    print
+    "Microsoft Developer Studio Workspace File, Format Version 6.00\r\n".
+    "# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!\r\n".
+    "\r\n".
+    "###############################################################################\r\n".
+    "\r\n";
+    # List projects
+    foreach $progname (@prognames) {
+      ($windows_project, $type) = split ",", $progname;
+        print "Project: \"$windows_project\"=\".\\$windows_project\\$windows_project.dsp\" - Package Owner=<4>\r\n";
+    }
+    print
+    "\r\n".
+    "Package=<5>\r\n".
+    "{{{\r\n".
+    "}}}\r\n".
+    "\r\n".
+    "Package=<4>\r\n".
+    "{{{\r\n".
+    "}}}\r\n".
+    "\r\n".
+    "###############################################################################\r\n".
+    "\r\n".
+    "Global:\r\n".
+    "\r\n".
+    "Package=<5>\r\n".
+    "{{{\r\n".
+    "}}}\r\n".
+    "\r\n".
+    "Package=<3>\r\n".
+    "{{{\r\n".
+    "}}}\r\n".
+    "\r\n".
+    "###############################################################################\r\n".
+    "\r\n";
+    select STDOUT; close OUT;
+    chdir $orig_dir;
+
+    sub create_project {
+        my ($all_object_deps, $progname) = @_;
+        # Construct program's dependency info
+        %seen_objects = ();
+        %lib_files = ();
+        %source_files = ();
+        %header_files = ();
+        %resource_files = ();
+        @object_files = split " ", &objects($progname, "X.obj", "X.res", "X.lib");
+        foreach $object_file (@object_files) {
+            next if defined $seen_objects{$object_file};
+            $seen_objects{$object_file} = 1;
+            if($object_file =~ /\.lib$/io) {
+                $lib_files{$object_file} = 1;
+                next;
+            }
+            $object_deps = $all_object_deps{$object_file};
+            foreach $object_dep (@$object_deps) {
+                if($object_dep =~ /\.c$/io) {
+                    $source_files{$object_dep} = 1;
+                    next;
+                }
+                if($object_dep =~ /\.h$/io) {
+                    $header_files{$object_dep} = 1;
+                    next;
+                }
+                if($object_dep =~ /\.(rc|ico)$/io) {
+                    $resource_files{$object_dep} = 1;
+                    next;
+                }
+            }
+        }
+        $libs = join " ", sort keys %lib_files;
+        @source_files = sort keys %source_files;
+        @header_files = sort keys %header_files;
+        @resources = sort keys %resource_files;
+        ($windows_project, $type) = split ",", $progname;
+        mkdir $windows_project
+            if(! -d $windows_project);
+        chdir $windows_project;
+        $subsys = ($type eq "G") ? "windows" : "console";
+        open OUT, ">$windows_project.dsp"; binmode OUT; select OUT;
+        print
+        "# Microsoft Developer Studio Project File - Name=\"$windows_project\" - Package Owner=<4>\r\n".
+        "# Microsoft Developer Studio Generated Build File, Format Version 6.00\r\n".
+        "# ** DO NOT EDIT **\r\n".
+        "\r\n".
+        "# TARGTYPE \"Win32 (x86) Application\" 0x0101\r\n".
+        "\r\n".
+        "CFG=$windows_project - Win32 Debug\r\n".
+        "!MESSAGE This is not a valid makefile. To build this project using NMAKE,\r\n".
+        "!MESSAGE use the Export Makefile command and run\r\n".
+        "!MESSAGE \r\n".
+        "!MESSAGE NMAKE /f \"$windows_project.mak\".\r\n".
+        "!MESSAGE \r\n".
+        "!MESSAGE You can specify a configuration when running NMAKE\r\n".
+        "!MESSAGE by defining the macro CFG on the command line. For example:\r\n".
+        "!MESSAGE \r\n".
+        "!MESSAGE NMAKE /f \"$windows_project.mak\" CFG=\"$windows_project - Win32 Debug\"\r\n".
+        "!MESSAGE \r\n".
+        "!MESSAGE Possible choices for configuration are:\r\n".
+        "!MESSAGE \r\n".
+        "!MESSAGE \"$windows_project - Win32 Release\" (based on \"Win32 (x86) Application\")\r\n".
+        "!MESSAGE \"$windows_project - Win32 Debug\" (based on \"Win32 (x86) Application\")\r\n".
+        "!MESSAGE \r\n".
+        "\r\n".
+        "# Begin Project\r\n".
+        "# PROP AllowPerConfigDependencies 0\r\n".
+        "# PROP Scc_ProjName \"\"\r\n".
+        "# PROP Scc_LocalPath \"\"\r\n".
+        "CPP=cl.exe\r\n".
+        "MTL=midl.exe\r\n".
+        "RSC=rc.exe\r\n".
+        "\r\n".
+        "!IF  \"\$(CFG)\" == \"$windows_project - Win32 Release\"\r\n".
+        "\r\n".
+        "# PROP BASE Use_MFC 0\r\n".
+        "# PROP BASE Use_Debug_Libraries 0\r\n".
+        "# PROP BASE Output_Dir \"Release\"\r\n".
+        "# PROP BASE Intermediate_Dir \"Release\"\r\n".
+        "# PROP BASE Target_Dir \"\"\r\n".
+        "# PROP Use_MFC 0\r\n".
+        "# PROP Use_Debug_Libraries 0\r\n".
+        "# PROP Output_Dir \"Release\"\r\n".
+        "# PROP Intermediate_Dir \"Release\"\r\n".
+        "# PROP Ignore_Export_Lib 0\r\n".
+        "# PROP Target_Dir \"\"\r\n".
+        "# ADD BASE CPP /nologo /W3 /GX /O2 /D \"WIN32\" /D \"NDEBUG\" /D \"_WINDOWS\" /D \"_MBCS\" /YX /FD /c\r\n".
+        "# ADD CPP /nologo /W3 /GX /O2 /D \"WIN32\" /D \"NDEBUG\" /D \"_WINDOWS\" /D \"_MBCS\" /YX /FD /c\r\n".
+        "# ADD BASE MTL /nologo /D \"NDEBUG\" /mktyplib203 /win32\r\n".
+        "# ADD MTL /nologo /D \"NDEBUG\" /mktyplib203 /win32\r\n".
+        "# ADD BASE RSC /l 0x809 /d \"NDEBUG\"\r\n".
+        "# ADD RSC /l 0x809 /d \"NDEBUG\"\r\n".
+        "BSC32=bscmake.exe\r\n".
+        "# ADD BASE BSC32 /nologo\r\n".
+        "# ADD BSC32 /nologo\r\n".
+        "LINK32=link.exe\r\n".
+        "# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:$subsys /machine:I386\r\n".
+        "# ADD LINK32 $libs /nologo /subsystem:$subsys /machine:I386\r\n".
+        "# SUBTRACT LINK32 /pdb:none\r\n".
+        "\r\n".
+        "!ELSEIF  \"\$(CFG)\" == \"$windows_project - Win32 Debug\"\r\n".
+        "\r\n".
+        "# PROP BASE Use_MFC 0\r\n".
+        "# PROP BASE Use_Debug_Libraries 1\r\n".
+        "# PROP BASE Output_Dir \"Debug\"\r\n".
+        "# PROP BASE Intermediate_Dir \"Debug\"\r\n".
+        "# PROP BASE Target_Dir \"\"\r\n".
+        "# PROP Use_MFC 0\r\n".
+        "# PROP Use_Debug_Libraries 1\r\n".
+        "# PROP Output_Dir \"Debug\"\r\n".
+        "# PROP Intermediate_Dir \"Debug\"\r\n".
+        "# PROP Ignore_Export_Lib 0\r\n".
+        "# PROP Target_Dir \"\"\r\n".
+        "# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D \"WIN32\" /D \"_DEBUG\" /D \"_WINDOWS\" /D \"_MBCS\" /YX /FD /GZ /c\r\n".
+        "# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D \"WIN32\" /D \"_DEBUG\" /D \"_WINDOWS\" /D \"_MBCS\" /YX /FD /GZ /c\r\n".
+        "# ADD BASE MTL /nologo /D \"_DEBUG\" /mktyplib203 /win32\r\n".
+        "# ADD MTL /nologo /D \"_DEBUG\" /mktyplib203 /win32\r\n".
+        "# ADD BASE RSC /l 0x809 /d \"_DEBUG\"\r\n".
+        "# ADD RSC /l 0x809 /d \"_DEBUG\"\r\n".
+        "BSC32=bscmake.exe\r\n".
+        "# ADD BASE BSC32 /nologo\r\n".
+        "# ADD BSC32 /nologo\r\n".
+        "LINK32=link.exe\r\n".
+        "# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:$subsys /debug /machine:I386 /pdbtype:sept\r\n".
+        "# ADD LINK32 $libs /nologo /subsystem:$subsys /debug /machine:I386 /pdbtype:sept\r\n".
+        "# SUBTRACT LINK32 /pdb:none\r\n".
+        "\r\n".
+        "!ENDIF \r\n".
+        "\r\n".
+        "# Begin Target\r\n".
+        "\r\n".
+        "# Name \"$windows_project - Win32 Release\"\r\n".
+        "# Name \"$windows_project - Win32 Debug\"\r\n".
+        "# Begin Group \"Source Files\"\r\n".
+        "\r\n".
+        "# PROP Default_Filter \"cpp;c;cxx;rc;def;r;odl;idl;hpj;bat\"\r\n";
+        foreach $source_file (@source_files) {
+            print
+              "# Begin Source File\r\n".
+              "\r\n".
+              "SOURCE=..\\..\\$source_file\r\n";
+            if($source_file =~ /ssh\.c/io) {
+                # Disable 'Edit and continue' as Visual Studio can't handle the macros
+                print
+                  "\r\n".
+                  "!IF  \"\$(CFG)\" == \"$windows_project - Win32 Release\"\r\n".
+                  "\r\n".
+                  "!ELSEIF  \"\$(CFG)\" == \"$windows_project - Win32 Debug\"\r\n".
+                  "\r\n".
+                  "# ADD CPP /Zi\r\n".
+                  "\r\n".
+                  "!ENDIF \r\n".
+                  "\r\n";
+            }
+            print "# End Source File\r\n";
+        }
+        print
+        "# End Group\r\n".
+        "# Begin Group \"Header Files\"\r\n".
+        "\r\n".
+        "# PROP Default_Filter \"h;hpp;hxx;hm;inl\"\r\n";
+        foreach $header_file (@header_files) {
+            print
+              "# Begin Source File\r\n".
+              "\r\n".
+              "SOURCE=..\\..\\$header_file\r\n".
+              "# End Source File\r\n";
+        }
+        print
+        "# End Group\r\n".
+        "# Begin Group \"Resource Files\"\r\n".
+        "\r\n".
+        "# PROP Default_Filter \"ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe\"\r\n";
+        foreach $resource_file (@resources) {
+            print
+              "# Begin Source File\r\n".
+              "\r\n".
+              "SOURCE=..\\..\\$resource_file\r\n".
+              "# End Source File\r\n";
+        }
+        print
+        "# End Group\r\n".
+        "# End Target\r\n".
+        "# End Project\r\n";
+        select STDOUT; close OUT;
+        chdir "..";
+    }
+}
+
+if (defined $makefiles{'gtk'}) {
+    $mftyp = 'gtk';
+    $dirpfx = &dirpfx($makefiles{'gtk'}, "/");
+
+    ##-- X/GTK/Unix makefile
+    open OUT, ">$makefiles{'gtk'}"; select OUT;
+    print
+    "# Makefile for $project_name under X/GTK and Unix.\n".
+    "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+    "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    # gcc command line option is -D not /D
+    ($_ = $help) =~ s/=\/D/=-D/gs;
+    print $_;
+    print
+    "\n".
+    "# You can define this path to point at your tools if you need to\n".
+    "# TOOLPATH = /opt/gcc/bin\n".
+    "CC := \$(TOOLPATH)\$(CC)\n".
+    "# You can manually set this to `gtk-config' or `pkg-config gtk+-1.2'\n".
+    "# (depending on what works on your system) if you want to enforce\n".
+    "# building with GTK 1.2, or you can set it to `pkg-config gtk+-2.0'\n".
+    "# if you want to enforce 2.0. The default is to try 2.0 and fall back\n".
+    "# to 1.2 if it isn't found.\n".
+    "GTK_CONFIG = sh -c 'pkg-config gtk+-2.0 \$\$0 2>/dev/null || gtk-config \$\$0'\n".
+    "\n".
+    &splitline("CFLAGS := -O2 -Wall -Werror -ansi -pedantic -g " .
+               (join " ", map {"-I$dirpfx$_"} @srcdirs) .
+               " `\$(GTK_CONFIG) --cflags` \$(CFLAGS)")."\n".
+    "XLIBS = `\$(GTK_CONFIG) --libs` -lm\n".
+    "ULIBS = -lm#\n".
+    "INSTALL=install\n",
+    "INSTALL_PROGRAM=\$(INSTALL)\n",
+    "INSTALL_DATA=\$(INSTALL)\n",
+    "prefix=/usr/local\n",
+    "exec_prefix=\$(prefix)\n",
+    "bindir=\$(exec_prefix)/bin\n",
+    "gamesdir=\$(exec_prefix)/games\n",
+    "mandir=\$(prefix)/man\n",
+    "man1dir=\$(mandir)/man1\n",
+    "\n";
+    print &splitline("all:" . join "", map { " \$(BINPREFIX)$_" }
+                     &progrealnames("X:U"));
+    print "\n\n";
+    foreach $p (&prognames("X:U")) {
+      ($prog, $type) = split ",", $p;
+      $objstr = &objects($p, "X.o", undef, undef);
+      print &splitline("\$(BINPREFIX)" . $prog . ": " . $objstr), "\n";
+      $libstr = &objects($p, undef, undef, "-lX");
+      print &splitline("\t\$(CC) -o \$@ $objstr $libstr \$(XLFLAGS) \$(${type}LIBS)", 69),
+          "\n\n";
+    }
+    foreach $d (&deps("X.o", undef, $dirpfx, "/")) {
+      print &splitline(sprintf("%s: %s", $d->{obj}, join " ", @{$d->{deps}})),
+          "\n";
+      $deflist = join "", map { " -D$_" } @{$d->{defs}};
+      print "\t\$(CC) \$(COMPAT) \$(FWHACK) \$(CFLAGS) \$(XFLAGS)$deflist" .
+          " -c \$< -o \$\@\n";
+    }
+    print "\n";
+    print $makefile_extra{'gtk'} || "";
+    print "\nclean:\n".
+    "\trm -f *.o". (join "", map { " \$(BINPREFIX)$_" } &progrealnames("X:U")) . "\n";
+    select STDOUT; close OUT;
+}
+
+if (defined $makefiles{'am'}) {
+    $mftyp = 'am';
+    die "Makefile.am in a subdirectory is not supported\n"
+        if &dirpfx($makefiles{'am'}, "/") ne "";
+
+    ##-- Unix/autoconf Makefile.am
+    open OUT, ">$makefiles{'am'}"; select OUT;
+    print
+    "# Makefile.am for $project_name under Unix with Autoconf/Automake.\n".
+    "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+    "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n\n";
+
+    print $makefile_extra{'am_begin'} || "";
+
+    # All programs go in noinstprogs by default. If you want them
+    # installed anywhere else, you have to also add them to
+    # bin_PROGRAMS using '!begin am'. (Automake doesn't seem to mind
+    # having a program name in _both_ of bin_PROGRAMS and
+    # noinst_PROGRAMS.)
+    @noinstprogs = ();
+    foreach $p (&prognames("X:U")) {
+        ($prog, $type) = split ",", $p;
+        push @noinstprogs, $prog;
+    }
+    print &splitline(join " ", "noinst_PROGRAMS", "=", @noinstprogs), "\n";
+
+    %objtosrc = ();
+    %amspeciallibs = ();
+    %amlibobjname = ();
+    %allsources = ();
+    foreach $d (&deps("X", undef, "", "/", "am")) {
+        my $obj = $d->{obj};
+        my $use_archive = 0;
+        
+        if (defined $d->{defs}) {
+            # This file needs to go in an archive, so that we can
+            # change the preprocess flags to include some -Ds
+            $use_archive = 1;
+            $archivecppflags{$obj} = [map { " -D$_" } @{$d->{defs}}];
+        }
+        if (defined $cflags{'am'} && $cflags{'am'}->{$obj}) {
+            # This file needs to go in an archive, so that we can
+            # change the compile flags as specified in Recipe
+            $use_archive = 1;
+            $archivecflags{$obj} = [$cflags{'am'}->{$obj}];
+        }
+        if ($use_archive) {
+            $amspeciallibs{$obj} = "lib${obj}.a";
+            $amlibobjname{$obj} = "lib${obj}_a-" .
+                basename($d->{deps}->[0], ".c", ".m") .
+                ".\$(OBJEXT)";
+        }
+        $objtosrc{$obj} = $d->{deps};
+        map { $allsources{$_} = 1 } @{$d->{deps}};
+    }
+
+    # 2014-02-22: as of automake-1.14 we begin to get complained at if
+    # we don't use this option
+    print "AUTOMAKE_OPTIONS = subdir-objects\n\n";
+
+    # Complete list of source and header files. Not used by the
+    # auto-generated parts of this makefile, but Recipe might like to
+    # have it available as a variable so that mandatory-rebuild things
+    # (version.o) can conveniently be made to depend on it.
+    print &splitline(join " ", "allsources", "=",
+                     sort {$a cmp $b} keys %allsources), "\n\n";
+
+    @amcppflags = map {"-I\$(srcdir)/$_"} @srcdirs;
+    print &splitline(join " ", "AM_CPPFLAGS", "=", @amcppflags, "\n");
+
+    @amcflags = ("\$(GTK_CFLAGS)", "\$(WARNINGOPTS)");
+    print &splitline(join " ", "AM_CFLAGS", "=", @amcflags), "\n";
+
+    %amlibsused = ();
+    foreach $p (&prognames("X:U")) {
+        ($prog, $type) = split ",", $p;
+        @progsources = ("${prog}_SOURCES", "=");
+        %sourcefiles = ();
+        @ldadd = ();
+        $objstr = &objects($p, "X", undef, undef);
+        foreach $obj (split / /,$objstr) {
+            if ($amspeciallibs{$obj}) {
+                $amlibsused{$obj} = 1;
+                push @ldadd, $amlibobjname{$obj};
+            } else {
+                map { $sourcefiles{$_} = 1 } @{$objtosrc{$obj}};
+            }
+        }
+        push @progsources, sort { $a cmp $b } keys %sourcefiles;
+        print &splitline(join " ", @progsources), "\n";
+        if ($type eq "X") {
+            push @ldadd, "\$(GTK_LIBS)";
+        }
+        push @ldadd, "-lm";
+        print &splitline(join " ", "${prog}_LDADD", "=", @ldadd), "\n";
+        print "\n";
+    }
+
+    foreach $obj (sort { $a cmp $b } keys %amlibsused) {
+        print &splitline(join " ", "lib${obj}_a_SOURCES", "=",
+                         @{$objtosrc{$obj}}), "\n";
+        print &splitline(join " ", "lib${obj}_a_CPPFLAGS", "=",
+                         @amcflags, @{$archivecppflags{$obj}}), "\n"
+                             if $archivecppflags{$obj};
+        print &splitline(join " ", "lib${obj}_a_CFLAGS", "=",
+                         @amcflags, @{$archivecflags{$obj}}), "\n"
+                             if $archivecflags{$obj};
+    }
+    print &splitline(join " ", "noinst_LIBRARIES", "=",
+                     sort { $a cmp $b }
+                      map { $amspeciallibs{$_} }
+                     keys %amlibsused),
+                     "\n\n";
+
+    print $makefile_extra{'am'} || "";
+    select STDOUT; close OUT;
+}
+
+if (defined $makefiles{'mpw'}) {
+    $mftyp = 'mpw';
+    ##-- MPW Makefile
+    open OUT, ">$makefiles{'mpw'}"; select OUT;
+    print
+    "# Makefile for $project_name under MPW.\n#\n".
+    "# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+    "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    # MPW command line option is -d not /D
+    ($_ = $help) =~ s/=\/D/=-d /gs;
+    print $_;
+    print "\n\n".
+    "ROptions     = `Echo \"{VER}\" | StreamEdit -e \"1,\$ replace /=(\xc5)\xa81\xb0/ 'STR=\xb6\xb6\xb6\xb6\xb6\"' \xa81 '\xb6\xb6\xb6\xb6\xb6\"'\"`".
+    "\n".
+    "C_68K = {C}\n".
+    "C_CFM68K = {C}\n".
+    "C_PPC = {PPCC}\n".
+    "C_Carbon = {PPCC}\n".
+    "\n".
+    "# -w 35 disables \"unused parameter\" warnings\n".
+    "COptions     = -i : -i :: -i ::charset -w 35 -w err -proto strict -ansi on \xb6\n".
+    "          -notOnce\n".
+    "COptions_68K = {COptions} -model far -opt time\n".
+    "# Enabling \"-opt space\" for CFM-68K gives me undefined references to\n".
+    "# _\$LDIVT and _\$LMODT.\n".
+    "COptions_CFM68K = {COptions} -model cfmSeg -opt time\n".
+    "COptions_PPC = {COptions} -opt size -traceback\n".
+    "COptions_Carbon = {COptions} -opt size -traceback -d TARGET_API_MAC_CARBON\n".
+    "\n".
+    "Link_68K = ILink\n".
+    "Link_CFM68K = ILink\n".
+    "Link_PPC = PPCLink\n".
+    "Link_Carbon = PPCLink\n".
+    "\n".
+    "LinkOptions = -c 'pTTY'\n".
+    "LinkOptions_68K = {LinkOptions} -br 68k -model far -compact\n".
+    "LinkOptions_CFM68K = {LinkOptions} -br 020 -model cfmseg -compact\n".
+    "LinkOptions_PPC = {LinkOptions}\n".
+    "LinkOptions_Carbon = -m __appstart -w {LinkOptions}\n".
+    "\n".
+    "Libs_68K = \"{CLibraries}StdCLib.far.o\" \xb6\n".
+    "           \"{Libraries}MacRuntime.o\" \xb6\n".
+    "           \"{Libraries}MathLib.far.o\" \xb6\n".
+    "           \"{Libraries}IntEnv.far.o\" \xb6\n".
+    "           \"{Libraries}Interface.o\" \xb6\n".
+    "           \"{Libraries}Navigation.far.o\" \xb6\n".
+    "           \"{Libraries}OpenTransport.o\" \xb6\n".
+    "           \"{Libraries}OpenTransportApp.o\" \xb6\n".
+    "           \"{Libraries}OpenTptInet.o\" \xb6\n".
+    "           \"{Libraries}UnicodeConverterLib.far.o\"\n".
+    "\n".
+    "Libs_CFM = \"{SharedLibraries}InterfaceLib\" \xb6\n".
+    "           \"{SharedLibraries}StdCLib\" \xb6\n".
+    "           \"{SharedLibraries}AppearanceLib\" \xb6\n".
+    "                   -weaklib AppearanceLib \xb6\n".
+    "           \"{SharedLibraries}NavigationLib\" \xb6\n".
+    "                   -weaklib NavigationLib \xb6\n".
+    "           \"{SharedLibraries}TextCommon\" \xb6\n".
+    "                   -weaklib TextCommon \xb6\n".
+    "           \"{SharedLibraries}UnicodeConverter\" \xb6\n".
+    "                   -weaklib UnicodeConverter\n".
+    "\n".
+    "Libs_CFM68K =      {Libs_CFM} \xb6\n".
+    "           \"{CFM68KLibraries}NuMacRuntime.o\"\n".
+    "\n".
+    "Libs_PPC = {Libs_CFM} \xb6\n".
+    "           \"{SharedLibraries}ControlsLib\" \xb6\n".
+    "                   -weaklib ControlsLib \xb6\n".
+    "           \"{SharedLibraries}WindowsLib\" \xb6\n".
+    "                   -weaklib WindowsLib \xb6\n".
+    "           \"{SharedLibraries}OpenTransportLib\" \xb6\n".
+    "                   -weaklib OTClientLib \xb6\n".
+    "                   -weaklib OTClientUtilLib \xb6\n".
+    "           \"{SharedLibraries}OpenTptInternetLib\" \xb6\n".
+    "                   -weaklib OTInetClientLib \xb6\n".
+    "           \"{PPCLibraries}StdCRuntime.o\" \xb6\n".
+    "           \"{PPCLibraries}PPCCRuntime.o\" \xb6\n".
+    "           \"{PPCLibraries}CarbonAccessors.o\" \xb6\n".
+    "           \"{PPCLibraries}OpenTransportAppPPC.o\" \xb6\n".
+    "           \"{PPCLibraries}OpenTptInetPPC.o\"\n".
+    "\n".
+    "Libs_Carbon =      \"{PPCLibraries}CarbonStdCLib.o\" \xb6\n".
+    "           \"{PPCLibraries}StdCRuntime.o\" \xb6\n".
+    "           \"{PPCLibraries}PPCCRuntime.o\" \xb6\n".
+    "           \"{SharedLibraries}CarbonLib\" \xb6\n".
+    "           \"{SharedLibraries}StdCLib\"\n".
+    "\n";
+    print &splitline("all \xc4 " . join(" ", &progrealnames("M")), undef, "\xb6");
+    print "\n\n";
+    foreach $p (&prognames("M")) {
+      ($prog, $type) = split ",", $p;
+
+      print &splitline("$prog \xc4 $prog.68k $prog.ppc $prog.carbon",
+                   undef, "\xb6"), "\n\n";
+
+      $rsrc = &objects($p, "", "X.rsrc", undef);
+
+      foreach $arch (qw(68K CFM68K PPC Carbon)) {
+          $objstr = &objects($p, "X.\L$arch\E.o", "", undef);
+          print &splitline("$prog.\L$arch\E \xc4 $objstr $rsrc", undef, "\xb6");
+          print "\n";
+          print &splitline("\tDuplicate -y $rsrc {Targ}", 69, "\xb6"), "\n";
+          print &splitline("\t{Link_$arch} -o {Targ} -fragname $prog " .
+                       "{LinkOptions_$arch} " .
+                       $objstr . " {Libs_$arch}", 69, "\xb6"), "\n";
+          print &splitline("\tSetFile -a BMi {Targ}", 69, "\xb6"), "\n\n";
+      }
+
+    }
+    foreach $d (&deps("", "X.rsrc", "::", ":")) {
+      next unless $d->{obj};
+      print &splitline(sprintf("%s \xc4 %s", $d->{obj}, join " ", @{$d->{deps}}),
+                   undef, "\xb6"), "\n";
+      print "\tRez ", $d->{deps}->[0], " -o {Targ} {ROptions}\n\n";
+    }
+    foreach $arch (qw(68K CFM68K)) {
+        foreach $d (&deps("X.\L$arch\E.o", "", "::", ":")) {
+         next unless $d->{obj};
+        print &splitline(sprintf("%s \xc4 %s", $d->{obj},
+                                 join " ", @{$d->{deps}}),
+                         undef, "\xb6"), "\n";
+         print "\t{C_$arch} ", $d->{deps}->[0],
+               " -o {Targ} {COptions_$arch}\n\n";
+         }
+    }
+    foreach $arch (qw(PPC Carbon)) {
+        foreach $d (&deps("X.\L$arch\E.o", "", "::", ":")) {
+         next unless $d->{obj};
+        print &splitline(sprintf("%s \xc4 %s", $d->{obj},
+                                 join " ", @{$d->{deps}}),
+                         undef, "\xb6"), "\n";
+         # The odd stuff here seems to stop afpd getting confused.
+         print "\techo -n > {Targ}\n";
+         print "\tsetfile -t XCOF {Targ}\n";
+         print "\t{C_$arch} ", $d->{deps}->[0],
+               " -o {Targ} {COptions_$arch}\n\n";
+         }
+    }
+    select STDOUT; close OUT;
+}
+
+if (defined $makefiles{'lcc'}) {
+    $mftyp = 'lcc';
+    $dirpfx = &dirpfx($makefiles{'lcc'}, "\\");
+
+    ##-- lcc makefile
+    open OUT, ">$makefiles{'lcc'}"; select OUT;
+    print
+    "# Makefile for $project_name under lcc.\n".
+    "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+    "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    # lcc command line option is -D not /D
+    ($_ = $help) =~ s/=\/D/=-D/gs;
+    print $_;
+    print
+    "\n".
+    "# If you rename this file to `Makefile', you should change this line,\n".
+    "# so that the .rsp files still depend on the correct makefile.\n".
+    "MAKEFILE = Makefile.lcc\n".
+    "\n".
+    "# C compilation flags\n".
+    "CFLAGS = -D_WINDOWS " .
+      (join " ", map {"-I$dirpfx$_"} @srcdirs) .
+      "\n".
+    "\n".
+    "# Get include directory for resource compiler\n".
+    "\n";
+    print &splitline("all:" . join "", map { " $_.exe" } &progrealnames("G:C"));
+    print "\n\n";
+    foreach $p (&prognames("G:C")) {
+      ($prog, $type) = split ",", $p;
+      $objstr = &objects($p, "X.obj", "X.res", undef);
+      print &splitline("$prog.exe: " . $objstr ), "\n";
+      $subsystemtype = undef;
+      if ($type eq "G") { $subsystemtype = "-subsystem  windows"; }
+      my $libss = "shell32.lib wsock32.lib ws2_32.lib winspool.lib winmm.lib imm32.lib";
+      print &splitline("\tlcclnk $subsystemtype -o $prog.exe $objstr $libss");
+      print "\n\n";
+    }
+
+    foreach $d (&deps("X.obj", "X.res", $dirpfx, "\\")) {
+      print &splitline(sprintf("%s: %s", $d->{obj}, join " ", @{$d->{deps}})),
+        "\n";
+      if ($d->{obj} =~ /\.res$/) {
+        print &splitline("\tlrc \$(FWHACK) \$(RCFL) -r \$*.rc",69)."\n";
+      } else {
+        $deflist = join "", map { " -D$_" } @{$d->{defs}};
+        print &splitline("\tlcc -O -p6 \$(COMPAT) \$(FWHACK) \$(CFLAGS)".
+                         " \$(XFLAGS)$deflist ".$d->{deps}->[0]." -o \$\@",69)."\n";
+      }
+    }
+    print "\n";
+    print $makefile_extra{'lcc'} || "";
+    print "\nclean:\n".
+    "\t-del *.obj\n".
+    "\t-del *.exe\n".
+    "\t-del *.res\n";
+
+    select STDOUT; close OUT;
+}
+
+if (defined $makefiles{'nestedvm'}) {
+    $mftyp = 'nestedvm';
+    $dirpfx = &dirpfx($makefiles{'nestedvm'}, "/");
+
+    ##-- NestedVM makefile
+    open OUT, ">$makefiles{'nestedvm'}"; select OUT;
+    print
+    "# Makefile for $project_name under NestedVM.\n".
+    "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+    "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    # gcc command line option is -D not /D
+    ($_ = $help) =~ s/=\/D/=-D/gs;
+    print $_;
+    print
+    "\n".
+    "# This path points at the nestedvm root directory\n".
+    "NESTEDVM = /opt/nestedvm\n".
+    "# You can define this path to point at your tools if you need to\n".
+    "TOOLPATH = \$(NESTEDVM)/upstream/install/bin\n".
+    "CC = \$(TOOLPATH)/mips-unknown-elf-gcc\n".
+    "\n".
+    &splitline("CFLAGS = -O2 -Wall -Werror -DSLOW_SYSTEM -g " .
+               (join " ", map {"-I$dirpfx$_"} @srcdirs))."\n".
+    "\n";
+    print &splitline("all:" . join "", map { " $_.jar" } &progrealnames("X"));
+    print "\n\n";
+    foreach $p (&prognames("X")) {
+      ($prog, $type) = split ",", $p;
+      $objstr = &objects($p, "X.o", undef, undef);
+      $objstr =~ s/gtk\.o/nestedvm\.o/g;
+      print &splitline($prog . ".mips: " . $objstr), "\n";
+      $libstr = &objects($p, undef, undef, "-lX");
+      print &splitline("\t\$(CC) \$(${type}LDFLAGS) -o \$@ " .
+                       $objstr . " $libstr -lm", 69), "\n\n";
+    }
+    foreach $d (&deps("X.o", undef, $dirpfx, "/")) {
+      $oobjs = $d->{obj};
+      $ddeps= join " ", @{$d->{deps}};
+      $oobjs =~ s/gtk/nestedvm/g;
+      $ddeps =~ s/gtk/nestedvm/g;
+      print &splitline(sprintf("%s: %s", $oobjs, $ddeps)),
+          "\n";
+      $deflist = join "", map { " -D$_" } @{$d->{defs}};
+      print "\t\$(CC) \$(COMPAT) \$(FWHACK) \$(CFLAGS) \$(XFLAGS)$deflist" .
+          " -c \$< -o \$\@\n";
+    }
+    print "\n";
+    print $makefile_extra{'nestedvm'} || "";
+    print "\nclean:\n".
+    "\trm -rf *.o *.mips *.class *.html *.jar org applet.manifest\n";
+    select STDOUT; close OUT;
+}
+
+if (defined $makefiles{'osx'}) {
+    $mftyp = 'osx';
+    $dirpfx = &dirpfx($makefiles{'osx'}, "/");
+    @osxarchs = ('i386');
+
+    ##-- Mac OS X makefile
+    open OUT, ">$makefiles{'osx'}"; select OUT;
+    print
+    "# Makefile for $project_name under Mac OS X.\n".
+    "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+    "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    # gcc command line option is -D not /D
+    ($_ = $help) =~ s/=\/D/=-D/gs;
+    print $_;
+    print
+    "CC = \$(TOOLPATH)gcc\n".
+    "LIPO = \$(TOOLPATH)lipo\n".
+    "\n".
+    &splitline("CFLAGS = -O2 -Wall -Werror -g " .
+               (join " ", map {"-I$dirpfx$_"} @srcdirs))."\n".
+    "LDFLAGS = -framework Cocoa\n".
+    &splitline("all:" . join "", map { " $_" } &progrealnames("MX:U")) .
+    "\n";
+    print $makefile_extra{'osx'} || "";
+    print "\n".
+    ".SUFFIXES: .o .c .m\n".
+    "\n";
+    print "\n\n";
+    foreach $p (&prognames("MX")) {
+      ($prog, $type) = split ",", $p;
+      $icon = &special($p, ".icns");
+      $infoplist = &special($p, "info.plist");
+      print "${prog}.app:\n\tmkdir -p \$\@\n";
+      print "${prog}.app/Contents: ${prog}.app\n\tmkdir -p \$\@\n";
+      print "${prog}.app/Contents/MacOS: ${prog}.app/Contents\n\tmkdir -p \$\@\n";
+      $targets = "${prog}.app/Contents/MacOS/$prog";
+      if (defined $icon) {
+        print "${prog}.app/Contents/Resources: ${prog}.app/Contents\n\tmkdir -p \$\@\n";
+        print "${prog}.app/Contents/Resources/${prog}.icns: ${prog}.app/Contents/Resources $icon\n\tcp $icon \$\@\n";
+        $targets .= " ${prog}.app/Contents/Resources/${prog}.icns";
+      }
+      if (defined $infoplist) {
+        print "${prog}.app/Contents/Info.plist: ${prog}.app/Contents/Resources $infoplist\n\tcp $infoplist \$\@\n";
+        $targets .= " ${prog}.app/Contents/Info.plist";
+      }
+      $targets .= " \$(${prog}_extra)";
+      print &splitline("${prog}: $targets", 69) . "\n\n";
+      $libstr = &objects($p, undef, undef, "-lX");
+      $archbins = "";
+      foreach $arch (@osxarchs) {
+        $objstr = &objects($p, "X.${arch}.o", undef, undef);
+        print &splitline("${prog}.${arch}.bin: " . $objstr), "\n";
+        print &splitline("\t\$(CC) -arch ${arch} -mmacosx-version-min=10.4 \$(LDFLAGS) -o \$@ " .
+                       $objstr . " $libstr", 69), "\n\n";
+        $archbins .= " ${prog}.${arch}.bin";
+      }
+      print &splitline("${prog}.app/Contents/MacOS/$prog: ".
+                       "${prog}.app/Contents/MacOS" . $archbins), "\n";
+      print &splitline("\t\$(LIPO) -create $archbins -output \$@", 69), "\n\n";
+    }
+    foreach $p (&prognames("U")) {
+      ($prog, $type) = split ",", $p;
+      $libstr = &objects($p, undef, undef, "-lX");
+      $archbins = "";
+      foreach $arch (@osxarchs) {
+        $objstr = &objects($p, "X.${arch}.o", undef, undef);
+        print &splitline("${prog}.${arch}: " . $objstr), "\n";
+        print &splitline("\t\$(CC) -arch ${arch} -mmacosx-version-min=10.4 \$(ULDFLAGS) -o \$@ " .
+                       $objstr . " $libstr", 69), "\n\n";
+        $archbins .= " ${prog}.${arch}";
+      }
+      print &splitline("${prog}:" . $archbins), "\n";
+      print &splitline("\t\$(LIPO) -create $archbins -output \$@", 69), "\n\n";
+    }
+    foreach $arch (@osxarchs) {
+      foreach $d (&deps("X.${arch}.o", undef, $dirpfx, "/")) {
+        print &splitline(sprintf("%s: %s", $d->{obj}, join " ", @{$d->{deps}})),
+            "\n";
+        $deflist = join "", map { " -D$_" } @{$d->{defs}};
+        if ($d->{deps}->[0] =~ /\.m$/) {
+          print "\t\$(CC) -arch $arch -mmacosx-version-min=10.4 -x objective-c \$(COMPAT) \$(FWHACK) \$(CFLAGS)".
+              " \$(XFLAGS)$deflist -c \$< -o \$\@\n";
+        } else {
+          print "\t\$(CC) -arch $arch -mmacosx-version-min=10.4 \$(COMPAT) \$(FWHACK) \$(CFLAGS) \$(XFLAGS)$deflist" .
+              " -c \$< -o \$\@\n";
+        }
+      }
+    }
+    print "\nclean:\n".
+    "\trm -f *.o *.dmg". (join "", map { my $a=$_; (" $a", map { " ${a}.$_" } @osxarchs) } &progrealnames("U")) . "\n".
+    "\trm -rf *.app\n";
+    select STDOUT; close OUT;
+}
+
+if (defined $makefiles{'gnustep'}) {
+    $mftyp = 'gnustep';
+    $dirpfx = &dirpfx($makefiles{'gnustep'}, "/");
+
+    ##-- GNUstep makefile (use with 'gs_make -f Makefile.gnustep')
+
+    # This is a pretty evil way to do things. In an ideal world, I'd
+    # use the approved GNUstep makefile mechanism which just defines a
+    # variable or two saying what source files go into what binary and
+    # then includes application.make. Unfortunately, that has the
+    # automake-ish limitation that it doesn't let you choose different
+    # command lines for each object, so I can't arrange for all those
+    # files with -DTHIS and -DTHAT to Just Work.
+    #
+    # A simple if ugly fix would be to have mkfiles.pl construct a
+    # directory full of stub C files of the form '#define thing',
+    # '#include "real_source_file"', and then reference those in this
+    # makefile. That would also make it easy to build a proper
+    # automake makefile.
+    open OUT, ">$makefiles{'gnustep'}"; select OUT;
+    print
+    "# Makefile for $project_name under GNUstep.\n".
+    "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+    "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    # gcc command line option is -D not /D
+    ($_ = $help) =~ s/=\/D/=-D/gs;
+    print $_;
+    print
+    "NEEDS_GUI=yes\n".
+    "include \$(GNUSTEP_MAKEFILES)/common.make\n".
+    "include \$(GNUSTEP_MAKEFILES)/rules.make\n".
+    "include \$(GNUSTEP_MAKEFILES)/Instance/rules.make\n".
+    "\n".
+    &splitline("all::" . join "", map { " $_" } &progrealnames("MX:U")) .
+    "\n";
+    print $makefile_extra{'gnustep'} || "";
+    print "\n".
+    ".SUFFIXES: .o .c .m\n".
+    "\n";
+    print "\n\n";
+    foreach $p (&prognames("MX")) {
+      ($prog, $type) = split ",", $p;
+      $icon = &special($p, ".icns");
+      $infoplist = &special($p, "info.plist");
+      print "${prog}.app:\n\tmkdir -p \$\@\n";
+      $targets = "${prog}.app ${prog}.app/$prog";
+      if (defined $icon) {
+        print "${prog}.app/Resources: ${prog}.app\n\tmkdir -p \$\@\n";
+        print "${prog}.app/Resources/${prog}.icns: ${prog}.app/Resources $icon\n\tcp $icon \$\@\n";
+        $targets .= " ${prog}.app/Resources/${prog}.icns";
+      }
+      if (defined $infoplist) {
+        print "${prog}.app/Info.plist: ${prog}.app $infoplist\n\tcp $infoplist \$\@\n";
+        $targets .= " ${prog}.app/Info.plist";
+      }
+      $targets .= " \$(${prog}_extra)";
+      print &splitline("${prog}: $targets", 69) . "\n\n";
+      $libstr = &objects($p, undef, undef, "-lX");
+      $objstr = &objects($p, "X.o", undef, undef);
+      print &splitline("${prog}.app/$prog: " . $objstr), "\n";
+      print &splitline("\t\$(CC) \$(ALL_LDFLAGS) -o \$@ " . $objstr . " \$(ALL_LIB_DIRS) $libstr \$(ALL_LIBS)", 69), "\n\n";
+    }
+    foreach $p (&prognames("U")) {
+      ($prog, $type) = split ",", $p;
+      $libstr = &objects($p, undef, undef, "-lX");
+      $objstr = &objects($p, "X.o", undef, undef);
+      print &splitline("${prog}: " . $objstr), "\n";
+      print &splitline("\t\$(CC) \$(ULDFLAGS) -o \$@ " . $objstr . " $libstr", 69), "\n\n";
+    }
+    foreach $d (&deps("X.o", undef, $dirpfx, "/")) {
+      print &splitline(sprintf("%s: %s", $d->{obj}, join " ", @{$d->{deps}})),
+      "\n";
+      $deflist = join "", map { " -D$_" } @{$d->{defs}};
+      if ($d->{deps}->[0] =~ /\.m$/) {
+        print "\t\$(CC) -DGNUSTEP \$(ALL_OBJCFLAGS) \$(COMPAT) \$(FWHACK) \$(OBJCFLAGS)".
+                " \$(XFLAGS)$deflist -c \$< -o \$\@\n";
+      } else {
+        print "\t\$(CC) \$(ALL_CFLAGS) \$(COMPAT) \$(FWHACK) \$(CFLAGS) \$(XFLAGS)$deflist" .
+              " -c \$< -o \$\@\n";
+      }
+    }
+    print "\nclean::\n".
+    "\trm -f *.o ". (join " ", &progrealnames("U")) . "\n".
+    "\trm -rf *.app\n";
+    select STDOUT; close OUT;
+}
+
+if (defined $makefiles{'emcc'}) {
+    $mftyp = 'emcc';
+    $dirpfx = &dirpfx($makefiles{'emcc'}, "/");
+
+    ##-- Makefile for building Javascript puzzles via Emscripten
+
+    open OUT, ">$makefiles{'emcc'}"; select OUT;
+    print
+    "# Makefile for $project_name using Emscripten. Requires GNU make.\n".
+    "#\n# This file was created by `mkfiles.pl' from the `Recipe' file.\n".
+    "# DO NOT EDIT THIS FILE DIRECTLY; edit Recipe or mkfiles.pl instead.\n";
+    # emcc command line option is -D not /D
+    ($_ = $help) =~ s/=\/D/=-D/gs;
+    print $_;
+    print
+    "\n".
+    "# This can be set on the command line to point at the emcc command,\n".
+    "# if it is not on your PATH.\n".
+    "EMCC = emcc\n".
+    "\n".
+    &splitline("CFLAGS = -DSLOW_SYSTEM " .
+               (join " ", map {"-I$dirpfx$_"} @srcdirs))."\n".
+    "\n";
+    $output_js_files = join "", map { " \$(OUTPREFIX)$_.js" } &progrealnames("X");
+    print &splitline("all:" . $output_js_files);
+    print "\n\n";
+    foreach $p (&prognames("X")) {
+      ($prog, $type) = split ",", $p;
+      $objstr = &objects($p, "X.o", undef, undef);
+      $objstr =~ s/gtk\.o/emcc\.o/g;
+      print &splitline("\$(OUTPREFIX)" . $prog . ".js: " . $objstr . " emccpre.js emcclib.js emccx.json"), "\n";
+      print "\t\$(EMCC) -o \$(OUTPREFIX)".$prog.".js ".
+          "-O2 ".
+          "-s ASM_JS=1 ".
+          "--pre-js emccpre.js ".
+          "--js-library emcclib.js ".
+          "-s EXPORTED_FUNCTIONS=\"`sed 's://.*::' emccx.json | tr -d ' \\n'`\" " . $objstr . "\n\n";
+    }
+    foreach $d (&deps("X.o", undef, $dirpfx, "/")) {
+      $oobjs = $d->{obj};
+      $ddeps= join " ", @{$d->{deps}};
+      $oobjs =~ s/gtk/emcc/g;
+      $ddeps =~ s/gtk/emcc/g;
+      print &splitline(sprintf("%s: %s", $oobjs, $ddeps)),
+          "\n";
+      $deflist = join "", map { " -D$_" } @{$d->{defs}};
+      print "\t\$(EMCC) \$(CFLAGS) \$(XFLAGS)$deflist" .
+          " -c \$< -o \$\@\n";
+    }
+    print "\n";
+    print $makefile_extra{'emcc'} || "";
+    print "\nclean:\n".
+    "\trm -rf *.o $output_js_files\n";
+    select STDOUT; close OUT;
+}
+
+# All done, so do the Unix postprocessing if asked to.
+
+if ($do_unix) {
+    chdir $orig_dir;
+    system "./mkauto.sh";
+    die "mkfiles.pl: mkauto.sh returned $?\n" if $? > 0;
+    system "./configure", @confargs;
+    die "mkfiles.pl: configure returned $?\n" if $? > 0;
+}
diff --git a/apps/plugins/puzzles/nestedvm.c b/apps/plugins/puzzles/nestedvm.c
new file mode 100644
index 0000000000..c61afecf6a
--- /dev/null
+++ b/apps/plugins/puzzles/nestedvm.c
@@ -0,0 +1,432 @@
+/*
+ * nestedvm.c: NestedVM front end for my puzzle collection.
+ */
+
+#include <stdio.h>
+#include "rbassert.h"
+#include <stdlib.h>
+#include <time.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/time.h>
+
+#include "puzzles.h"
+
+extern void _pause();
+extern int _call_java(int cmd, int arg1, int arg2, int arg3);
+
+void fatal(char *fmt, ...)
+{
+    va_list ap;
+    fprintf(stderr, "fatal error: ");
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+    fprintf(stderr, "\n");
+    exit(1);
+}
+
+struct frontend {
+    // TODO kill unneeded members!
+    midend *me;
+    int timer_active;
+    struct timeval last_time;
+    config_item *cfg;
+    int cfg_which, cfgret;
+    int ox, oy, w, h;
+};
+
+static frontend *_fe;
+
+void get_random_seed(void **randseed, int *randseedsize)
+{
+    struct timeval *tvp = snew(struct timeval);
+    gettimeofday(tvp, NULL);
+    *randseed = (void *)tvp;
+    *randseedsize = sizeof(struct timeval);
+}
+
+void frontend_default_colour(frontend *fe, float *output)
+{
+    output[0] = output[1]= output[2] = 0.8f;
+}
+
+void nestedvm_status_bar(void *handle, char *text)
+{
+    _call_java(4,0,(int)text,0);
+}
+
+void nestedvm_start_draw(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+    _call_java(5, 0, fe->w, fe->h);
+    _call_java(4, 1, fe->ox, fe->oy);
+}
+
+void nestedvm_clip(void *handle, int x, int y, int w, int h)
+{
+    frontend *fe = (frontend *)handle;
+    _call_java(5, w, h, 0);
+    _call_java(4, 3, x + fe->ox, y + fe->oy);
+}
+
+void nestedvm_unclip(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+    _call_java(4, 4, fe->ox, fe->oy);
+}
+
+void nestedvm_draw_text(void *handle, int x, int y, int fonttype, int fontsize,
+                   int align, int colour, char *text)
+{
+    frontend *fe = (frontend *)handle;
+    _call_java(5, x + fe->ox, y + fe->oy, 
+               (fonttype == FONT_FIXED ? 0x10 : 0x0) | align);
+    _call_java(7, fontsize, colour, (int)text);
+}
+
+void nestedvm_draw_rect(void *handle, int x, int y, int w, int h, int colour)
+{
+    frontend *fe = (frontend *)handle;
+    _call_java(5, w, h, colour);
+    _call_java(4, 5, x + fe->ox, y + fe->oy);
+}
+
+void nestedvm_draw_line(void *handle, int x1, int y1, int x2, int y2, 
+                        int colour)
+{
+    frontend *fe = (frontend *)handle;
+    _call_java(5, x2 + fe->ox, y2 + fe->oy, colour);
+    _call_java(4, 6, x1 + fe->ox, y1 + fe->oy);
+}
+
+void nestedvm_draw_poly(void *handle, int *coords, int npoints,
+                        int fillcolour, int outlinecolour)
+{
+    frontend *fe = (frontend *)handle;
+    int i;
+    _call_java(4, 7, npoints, 0);
+    for (i = 0; i < npoints; i++) {
+        _call_java(6, i, coords[i*2] + fe->ox, coords[i*2+1] + fe->oy);
+    }
+    _call_java(4, 8, outlinecolour, fillcolour);
+}
+
+void nestedvm_draw_circle(void *handle, int cx, int cy, int radius,
+                     int fillcolour, int outlinecolour)
+{
+    frontend *fe = (frontend *)handle;
+    _call_java(5, cx+fe->ox, cy+fe->oy, radius);
+    _call_java(4, 9, outlinecolour, fillcolour);
+}
+
+struct blitter {
+    int handle, w, h, x, y;
+};
+
+blitter *nestedvm_blitter_new(void *handle, int w, int h)
+{
+    blitter *bl = snew(blitter);
+    bl->handle = -1;
+    bl->w = w;
+    bl->h = h;
+    return bl;
+}
+
+void nestedvm_blitter_free(void *handle, blitter *bl)
+{
+    if (bl->handle != -1)
+        _call_java(4, 11, bl->handle, 0);
+    sfree(bl);
+}
+
+void nestedvm_blitter_save(void *handle, blitter *bl, int x, int y)
+{
+    frontend *fe = (frontend *)handle;    
+    if (bl->handle == -1)
+        bl->handle = _call_java(4,10,bl->w, bl->h);
+    bl->x = x;
+    bl->y = y;
+    _call_java(8, bl->handle, x + fe->ox, y + fe->oy);
+}
+
+void nestedvm_blitter_load(void *handle, blitter *bl, int x, int y)
+{
+    frontend *fe = (frontend *)handle;
+    assert(bl->handle != -1);
+    if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) {
+        x = bl->x;
+        y = bl->y;
+    }
+    _call_java(9, bl->handle, x + fe->ox, y + fe->oy);
+}
+
+void nestedvm_end_draw(void *handle)
+{
+    _call_java(4,2,0,0);
+}
+
+char *nestedvm_text_fallback(void *handle, const char *const *strings,
+                             int nstrings)
+{
+    /*
+     * We assume Java can cope with any UTF-8 likely to be emitted
+     * by a puzzle.
+     */
+    return dupstr(strings[0]);
+}
+
+const struct drawing_api nestedvm_drawing = {
+    nestedvm_draw_text,
+    nestedvm_draw_rect,
+    nestedvm_draw_line,
+    nestedvm_draw_poly,
+    nestedvm_draw_circle,
+    NULL, // draw_update,
+    nestedvm_clip,
+    nestedvm_unclip,
+    nestedvm_start_draw,
+    nestedvm_end_draw,
+    nestedvm_status_bar,
+    nestedvm_blitter_new,
+    nestedvm_blitter_free,
+    nestedvm_blitter_save,
+    nestedvm_blitter_load,
+    NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */
+    NULL, NULL,                        /* line_width, line_dotted */
+    nestedvm_text_fallback,
+};
+
+int jcallback_key_event(int x, int y, int keyval)
+{
+    frontend *fe = (frontend *)_fe;
+    if (fe->ox == -1)
+        return 1;
+    if (keyval >= 0 &&
+        !midend_process_key(fe->me, x - fe->ox, y - fe->oy, keyval))
+        return 42;
+    return 1;
+}
+
+int jcallback_resize(int width, int height)
+{
+    frontend *fe = (frontend *)_fe;
+    int x, y;
+    x = width;
+    y = height;
+    midend_size(fe->me, &x, &y, TRUE);
+    fe->ox = (width - x) / 2;
+    fe->oy = (height - y) / 2;
+    fe->w = x;
+    fe->h = y;
+    midend_force_redraw(fe->me);
+    return 0;
+}
+
+int jcallback_timer_func()
+{
+    frontend *fe = (frontend *)_fe;
+    if (fe->timer_active) {
+        struct timeval now;
+        float elapsed;
+        gettimeofday(&now, NULL);
+        elapsed = ((now.tv_usec - fe->last_time.tv_usec) * 0.000001F +
+                   (now.tv_sec - fe->last_time.tv_sec));
+        midend_timer(fe->me, elapsed);  /* may clear timer_active */
+        fe->last_time = now;
+    }
+    return fe->timer_active;
+}
+
+void deactivate_timer(frontend *fe)
+{
+    if (fe->timer_active)
+        _call_java(4, 13, 0, 0);
+    fe->timer_active = FALSE;
+}
+
+void activate_timer(frontend *fe)
+{
+    if (!fe->timer_active) {
+        _call_java(4, 12, 0, 0);
+        gettimeofday(&fe->last_time, NULL);
+    }
+    fe->timer_active = TRUE;
+}
+
+void jcallback_config_ok()
+{
+    frontend *fe = (frontend *)_fe;
+    char *err;
+
+    err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
+
+    if (err)
+        _call_java(2, (int) "Error", (int)err, 1);
+    else {
+        fe->cfgret = TRUE;
+    }
+}
+
+void jcallback_config_set_string(int item_ptr, int char_ptr) {
+    config_item *i = (config_item *)item_ptr;
+    char* newval = (char*) char_ptr;
+    sfree(i->sval);
+    i->sval = dupstr(newval);
+    free(newval);
+}
+
+void jcallback_config_set_boolean(int item_ptr, int selected) {
+    config_item *i = (config_item *)item_ptr;
+    i->ival = selected != 0 ? TRUE : FALSE;
+}
+
+void jcallback_config_set_choice(int item_ptr, int selected) {
+    config_item *i = (config_item *)item_ptr;
+    i->ival = selected;
+}
+
+static int get_config(frontend *fe, int which)
+{
+    char *title;
+    config_item *i;
+    fe->cfg = midend_get_config(fe->me, which, &title);
+    fe->cfg_which = which;
+    fe->cfgret = FALSE;
+    _call_java(10, (int)title, 0, 0);
+    for (i = fe->cfg; i->type != C_END; i++) {
+        _call_java(5, (int)i, i->type, (int)i->name);
+        _call_java(11, (int)i->sval, i->ival, 0);
+    }
+    _call_java(12,0,0,0);
+    free_cfg(fe->cfg);
+    return fe->cfgret;
+}
+
+int jcallback_menu_key_event(int key)
+{
+    frontend *fe = (frontend *)_fe;
+    if (!midend_process_key(fe->me, 0, 0, key))
+        return 42;
+    return 0;
+}
+
+static void resize_fe(frontend *fe)
+{
+    int x, y;
+
+    x = INT_MAX;
+    y = INT_MAX;
+    midend_size(fe->me, &x, &y, FALSE);
+    _call_java(3, x, y, 0);
+}
+
+int jcallback_preset_event(int ptr_game_params)
+{
+    frontend *fe = (frontend *)_fe;
+    game_params *params =
+        (game_params *)ptr_game_params;
+
+    midend_set_params(fe->me, params);
+    midend_new_game(fe->me);
+    resize_fe(fe);
+    _call_java(13, midend_which_preset(fe->me), 0, 0);
+    return 0;
+}
+
+int jcallback_solve_event()
+{
+    frontend *fe = (frontend *)_fe;
+    char *msg;
+
+    msg = midend_solve(fe->me);
+
+    if (msg)
+        _call_java(2, (int) "Error", (int)msg, 1);
+    return 0;
+}
+
+int jcallback_restart_event()
+{
+    frontend *fe = (frontend *)_fe;
+
+    midend_restart_game(fe->me);
+    return 0;
+}
+
+int jcallback_config_event(int which)
+{
+    frontend *fe = (frontend *)_fe;
+    _call_java(13, midend_which_preset(fe->me), 0, 0);
+    if (!get_config(fe, which))
+        return 0;
+    midend_new_game(fe->me);
+    resize_fe(fe);
+    _call_java(13, midend_which_preset(fe->me), 0, 0);
+    return 0;
+}
+
+int jcallback_about_event()
+{
+    char titlebuf[256];
+    char textbuf[1024];
+
+    sprintf(titlebuf, "About %.200s", thegame.name);
+    sprintf(textbuf,
+            "%.200s\n\n"
+            "from Simon Tatham's Portable Puzzle Collection\n\n"
+            "%.500s", thegame.name, ver);
+    _call_java(2, (int)&titlebuf, (int)&textbuf, 0);
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
+    int i, n;
+    float* colours;
+
+    _fe = snew(frontend);
+    _fe->timer_active = FALSE;
+    _fe->me = midend_new(_fe, &thegame, &nestedvm_drawing, _fe);
+    if (argc > 1)
+        midend_game_id(_fe->me, argv[1]);   /* ignore failure */
+    midend_new_game(_fe->me);
+
+    if ((n = midend_num_presets(_fe->me)) > 0) {
+        int i;
+        for (i = 0; i < n; i++) {
+            char *name;
+            game_params *params;
+            midend_fetch_preset(_fe->me, i, &name, &params);
+            _call_java(1, (int)name, (int)params, 0);
+        }
+    }
+
+    colours = midend_colours(_fe->me, &n);
+    _fe->ox = -1;
+
+    _call_java(0, (int)thegame.name,
+               (thegame.can_configure ? 1 : 0) |
+               (midend_wants_statusbar(_fe->me) ? 2 : 0) |
+               (thegame.can_solve ? 4 : 0), n);    
+    for (i = 0; i < n; i++) {
+        _call_java(1024+ i,
+                   (int)(colours[i*3] * 0xFF),
+                   (int)(colours[i*3+1] * 0xFF),
+                   (int)(colours[i*3+2] * 0xFF));
+    }
+    resize_fe(_fe);
+
+    _call_java(13, midend_which_preset(_fe->me), 0, 0);
+
+    // Now pause the vm. The VM will be call()ed when
+    // an input event occurs.
+    _pause();
+
+    // shut down when the VM is resumed.
+    deactivate_timer(_fe);
+    midend_free(_fe->me);
+    return 0;
+}
diff --git a/apps/plugins/puzzles/net.R b/apps/plugins/puzzles/net.R
new file mode 100644
index 0000000000..8e98216e03
--- /dev/null
+++ b/apps/plugins/puzzles/net.R
@@ -0,0 +1,23 @@
+# -*- makefile -*-
+
+NET_EXTRA = tree234 dsf findloop
+
+net      : [X] GTK COMMON net NET_EXTRA net-icon|no-icon
+
+# The Windows Net shouldn't be called `net.exe' since Windows
+# already has a reasonably important utility program by that name!
+netgame  : [G] WINDOWS COMMON net NET_EXTRA net.res|noicon.res
+
+ALL += net[COMBINED] NET_EXTRA
+
+!begin am gtk
+GAMES += net
+!end
+
+!begin >list.c
+    A(net) \
+!end
+
+!begin >gamedesc.txt
+net:netgame.exe:Net:Network jigsaw puzzle:Rotate each tile to reassemble the network.
+!end
diff --git a/apps/plugins/puzzles/net.c b/apps/plugins/puzzles/net.c
new file mode 100644
index 0000000000..18ba7760d5
--- /dev/null
+++ b/apps/plugins/puzzles/net.c
@@ -0,0 +1,3210 @@
+/*
+ * net.c: Net game.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+
+/*
+ * The standard user interface for Net simply has left- and
+ * right-button mouse clicks in a square rotate it one way or the
+ * other. We also provide, by #ifdef, a separate interface based on
+ * rotational dragging motions. I initially developed this for the
+ * Mac on the basis that it might work better than the click
+ * interface with only one mouse button available, but in fact
+ * found it to be quite strange and unintuitive. Apparently it
+ * works better on stylus-driven platforms such as Palm and
+ * PocketPC, though, so we enable it by default there.
+ */
+#ifdef STYLUS_BASED
+#define USE_DRAGGING
+#endif
+
+#define MATMUL(xr,yr,m,x,y) do { \
+    float rx, ry, xx = (x), yy = (y), *mat = (m); \
+    rx = mat[0] * xx + mat[2] * yy; \
+    ry = mat[1] * xx + mat[3] * yy; \
+    (xr) = rx; (yr) = ry; \
+} while (0)
+
+/* Direction and other bitfields */
+#define R 0x01
+#define U 0x02
+#define L 0x04
+#define D 0x08
+#define LOCKED 0x10
+#define ACTIVE 0x20
+#define RLOOP (R << 6)
+#define ULOOP (U << 6)
+#define LLOOP (L << 6)
+#define DLOOP (D << 6)
+#define LOOP(dir) ((dir) << 6)
+
+/* Rotations: Anticlockwise, Clockwise, Flip, general rotate */
+#define A(x) ( (((x) & 0x07) << 1) | (((x) & 0x08) >> 3) )
+#define C(x) ( (((x) & 0x0E) >> 1) | (((x) & 0x01) << 3) )
+#define F(x) ( (((x) & 0x0C) >> 2) | (((x) & 0x03) << 2) )
+#define ROT(x, n) ( ((n)&3) == 0 ? (x) : \
+                    ((n)&3) == 1 ? A(x) : \
+                    ((n)&3) == 2 ? F(x) : C(x) )
+
+/* X and Y displacements */
+#define X(x) ( (x) == R ? +1 : (x) == L ? -1 : 0 )
+#define Y(x) ( (x) == D ? +1 : (x) == U ? -1 : 0 )
+
+/* Bit count */
+#define COUNT(x) ( (((x) & 0x08) >> 3) + (((x) & 0x04) >> 2) + \
+                   (((x) & 0x02) >> 1) + ((x) & 0x01) )
+
+#define PREFERRED_TILE_SIZE 32
+#define TILE_SIZE (ds->tilesize)
+#define TILE_BORDER 1
+#ifdef SMALL_SCREEN
+#define WINDOW_OFFSET 4
+#else
+#define WINDOW_OFFSET 16
+#endif
+
+#define ROTATE_TIME 0.13F
+#define FLASH_FRAME 0.07F
+
+/* Transform physical coords to game coords using game_drawstate ds */
+#define GX(x) (((x) + ds->org_x) % ds->width)
+#define GY(y) (((y) + ds->org_y) % ds->height)
+/* ...and game coords to physical coords */
+#define RX(x) (((x) + ds->width - ds->org_x) % ds->width)
+#define RY(y) (((y) + ds->height - ds->org_y) % ds->height)
+
+enum {
+    COL_BACKGROUND,
+    COL_LOCKED,
+    COL_BORDER,
+    COL_WIRE,
+    COL_ENDPOINT,
+    COL_POWERED,
+    COL_BARRIER,
+    COL_LOOP,
+    NCOLOURS
+};
+
+struct game_params {
+    int width;
+    int height;
+    int wrapping;
+    int unique;
+    float barrier_probability;
+};
+
+struct game_state {
+    int width, height, wrapping, completed;
+    int last_rotate_x, last_rotate_y, last_rotate_dir;
+    int used_solve;
+    unsigned char *tiles;
+    unsigned char *barriers;
+};
+
+#define OFFSETWH(x2,y2,x1,y1,dir,width,height) \
+    ( (x2) = ((x1) + width + X((dir))) % width, \
+      (y2) = ((y1) + height + Y((dir))) % height)
+
+#define OFFSET(x2,y2,x1,y1,dir,state) \
+        OFFSETWH(x2,y2,x1,y1,dir,(state)->width,(state)->height)
+
+#define index(state, a, x, y) ( a[(y) * (state)->width + (x)] )
+#define tile(state, x, y)     index(state, (state)->tiles, x, y)
+#define barrier(state, x, y)  index(state, (state)->barriers, x, y)
+
+struct xyd {
+    int x, y, direction;
+};
+
+static int xyd_cmp(const void *av, const void *bv) {
+    const struct xyd *a = (const struct xyd *)av;
+    const struct xyd *b = (const struct xyd *)bv;
+    if (a->x < b->x)
+        return -1;
+    if (a->x > b->x)
+        return +1;
+    if (a->y < b->y)
+        return -1;
+    if (a->y > b->y)
+        return +1;
+    if (a->direction < b->direction)
+        return -1;
+    if (a->direction > b->direction)
+        return +1;
+    return 0;
+}
+
+static int xyd_cmp_nc(void *av, void *bv) { return xyd_cmp(av, bv); }
+
+static struct xyd *new_xyd(int x, int y, int direction)
+{
+    struct xyd *xyd = snew(struct xyd);
+    xyd->x = x;
+    xyd->y = y;
+    xyd->direction = direction;
+    return xyd;
+}
+
+/* ----------------------------------------------------------------------
+ * Manage game parameters.
+ */
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->width = 5;
+    ret->height = 5;
+    ret->wrapping = FALSE;
+    ret->unique = TRUE;
+    ret->barrier_probability = 0.0;
+
+    return ret;
+}
+
+static const struct game_params net_presets[] = {
+    {5, 5, FALSE, TRUE, 0.0},
+    {7, 7, FALSE, TRUE, 0.0},
+    {9, 9, FALSE, TRUE, 0.0},
+    {11, 11, FALSE, TRUE, 0.0},
+#ifndef SMALL_SCREEN
+    {13, 11, FALSE, TRUE, 0.0},
+#endif
+    {5, 5, TRUE, TRUE, 0.0},
+    {7, 7, TRUE, TRUE, 0.0},
+    {9, 9, TRUE, TRUE, 0.0},
+    {11, 11, TRUE, TRUE, 0.0},
+#ifndef SMALL_SCREEN
+    {13, 11, TRUE, TRUE, 0.0},
+#endif
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(net_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = net_presets[i];
+
+    sprintf(str, "%dx%d%s", ret->width, ret->height,
+            ret->wrapping ? " wrapping" : "");
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    char const *p = string;
+
+    ret->width = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+    if (*p == 'x') {
+        p++;
+        ret->height = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+    } else {
+        ret->height = ret->width;
+    }
+
+    while (*p) {
+        if (*p == 'w') {
+            p++;
+            ret->wrapping = TRUE;
+        } else if (*p == 'b') {
+            p++;
+            ret->barrier_probability = (float)atof(p);
+            while (*p && (*p == '.' || isdigit((unsigned char)*p))) p++;
+        } else if (*p == 'a') {
+            p++;
+            ret->unique = FALSE;
+        } else
+            p++;                       /* skip any other gunk */
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char ret[400];
+    int len;
+
+    len = sprintf(ret, "%dx%d", params->width, params->height);
+    if (params->wrapping)
+        ret[len++] = 'w';
+    if (full && params->barrier_probability)
+        len += sprintf(ret+len, "b%g", params->barrier_probability);
+    if (full && !params->unique)
+        ret[len++] = 'a';
+    assert(len < lenof(ret));
+    ret[len] = '\0';
+
+    return dupstr(ret);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(6, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->width);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->height);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Walls wrap around";
+    ret[2].type = C_BOOLEAN;
+    ret[2].sval = NULL;
+    ret[2].ival = params->wrapping;
+
+    ret[3].name = "Barrier probability";
+    ret[3].type = C_STRING;
+    sprintf(buf, "%g", params->barrier_probability);
+    ret[3].sval = dupstr(buf);
+    ret[3].ival = 0;
+
+    ret[4].name = "Ensure unique solution";
+    ret[4].type = C_BOOLEAN;
+    ret[4].sval = NULL;
+    ret[4].ival = params->unique;
+
+    ret[5].name = NULL;
+    ret[5].type = C_END;
+    ret[5].sval = NULL;
+    ret[5].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->width = atoi(cfg[0].sval);
+    ret->height = atoi(cfg[1].sval);
+    ret->wrapping = cfg[2].ival;
+    ret->barrier_probability = (float)atof(cfg[3].sval);
+    ret->unique = cfg[4].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->width <= 0 || params->height <= 0)
+        return "Width and height must both be greater than zero";
+    if (params->width <= 1 && params->height <= 1)
+        return "At least one of width and height must be greater than one";
+    if (params->barrier_probability < 0)
+        return "Barrier probability may not be negative";
+    if (params->barrier_probability > 1)
+        return "Barrier probability may not be greater than 1";
+
+    /*
+     * Specifying either grid dimension as 2 in a wrapping puzzle
+     * makes it actually impossible to ensure a unique puzzle
+     * solution.
+     * 
+     * Proof:
+     * 
+     * Without loss of generality, let us assume the puzzle _width_
+     * is 2, so we can conveniently discuss rows without having to
+     * say `rows/columns' all the time. (The height may be 2 as
+     * well, but that doesn't matter.)
+     * 
+     * In each row, there are two edges between tiles: the inner
+     * edge (running down the centre of the grid) and the outer
+     * edge (the identified left and right edges of the grid).
+     * 
+     * Lemma: In any valid 2xn puzzle there must be at least one
+     * row in which _exactly one_ of the inner edge and outer edge
+     * is connected.
+     * 
+     *   Proof: No row can have _both_ inner and outer edges
+     *   connected, because this would yield a loop. So the only
+     *   other way to falsify the lemma is for every row to have
+     *   _neither_ the inner nor outer edge connected. But this
+     *   means there is no connection at all between the left and
+     *   right columns of the puzzle, so there are two disjoint
+     *   subgraphs, which is also disallowed. []
+     * 
+     * Given such a row, it is always possible to make the
+     * disconnected edge connected and the connected edge
+     * disconnected without changing the state of any other edge.
+     * (This is easily seen by case analysis on the various tiles:
+     * left-pointing and right-pointing endpoints can be exchanged,
+     * likewise T-pieces, and a corner piece can select its
+     * horizontal connectivity independently of its vertical.) This
+     * yields a distinct valid solution.
+     * 
+     * Thus, for _every_ row in which exactly one of the inner and
+     * outer edge is connected, there are two valid states for that
+     * row, and hence the total number of solutions of the puzzle
+     * is at least 2^(number of such rows), and in particular is at
+     * least 2 since there must be at least one such row. []
+     */
+    if (full && params->unique && params->wrapping &&
+        (params->width == 2 || params->height == 2))
+        return "No wrapping puzzle with a width or height of 2 can have"
+        " a unique solution";
+
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver used to assure solution uniqueness during generation. 
+ */
+
+/*
+ * Test cases I used while debugging all this were
+ * 
+ *   ./net --generate 1 13x11w#12300
+ * which expands under the non-unique grid generation rules to
+ *   13x11w:5eaade1bd222664436d5e2965c12656b1129dd825219e3274d558d5eb2dab5da18898e571d5a2987be79746bd95726c597447d6da96188c513add829da7681da954db113d3cd244
+ * and has two ambiguous areas.
+ * 
+ * An even better one is
+ *   13x11w#507896411361192
+ * which expands to
+ *   13x11w:b7125b1aec598eb31bd58d82572bc11494e5dee4e8db2bdd29b88d41a16bdd996d2996ddec8c83741a1e8674e78328ba71737b8894a9271b1cd1399453d1952e43951d9b712822e
+ * and has an ambiguous area _and_ a situation where loop avoidance
+ * is a necessary deductive technique.
+ * 
+ * Then there's
+ *   48x25w#820543338195187
+ * becoming
+ *   48x25w:255989d14cdd185deaa753a93821a12edc1ab97943ac127e2685d7b8b3c48861b2192416139212b316eddd35de43714ebc7628d753db32e596284d9ec52c5a7dc1b4c811a655117d16dc28921b2b4161352cab1d89d18bc836b8b891d55ea4622a1251861b5bc9a8aa3e5bcd745c95229ca6c3b5e21d5832d397e917325793d7eb442dc351b2db2a52ba8e1651642275842d8871d5534aabc6d5b741aaa2d48ed2a7dbbb3151ddb49d5b9a7ed1ab98ee75d613d656dbba347bc514c84556b43a9bc65a3256ead792488b862a9d2a8a39b4255a4949ed7dbd79443292521265896b4399c95ede89d7c8c797a6a57791a849adea489359a158aa12e5dacce862b8333b7ebea7d344d1a3c53198864b73a9dedde7b663abb1b539e1e8853b1b7edb14a2a17ebaae4dbe63598a2e7e9a2dbdad415bc1d8cb88cbab5a8c82925732cd282e641ea3bd7d2c6e776de9117a26be86deb7c82c89524b122cb9397cd1acd2284e744ea62b9279bae85479ababe315c3ac29c431333395b24e6a1e3c43a2da42d4dce84aadd5b154aea555eaddcbd6e527d228c19388d9b424d94214555a7edbdeebe569d4a56dc51a86bd9963e377bb74752bd5eaa5761ba545e297b62a1bda46ab4aee423ad6c661311783cc18786d4289236563cb4a75ec67d481c14814994464cd1b87396dee63e5ab6e952cc584baa1d4c47cb557ec84dbb63d487c8728118673a166846dd3a4ebc23d6cb9c5827d96b4556e91899db32b517eda815ae271a8911bd745447121dc8d321557bc2a435ebec1bbac35b1a291669451174e6aa2218a4a9c5a6ca31ebc45d84e3a82c121e9ced7d55e9a
+ * which has a spot (far right) where slightly more complex loop
+ * avoidance is required.
+ */
+
+struct todo {
+    unsigned char *marked;
+    int *buffer;
+    int buflen;
+    int head, tail;
+};
+
+static struct todo *todo_new(int maxsize)
+{
+    struct todo *todo = snew(struct todo);
+    todo->marked = snewn(maxsize, unsigned char);
+    memset(todo->marked, 0, maxsize);
+    todo->buflen = maxsize + 1;
+    todo->buffer = snewn(todo->buflen, int);
+    todo->head = todo->tail = 0;
+    return todo;
+}
+
+static void todo_free(struct todo *todo)
+{
+    sfree(todo->marked);
+    sfree(todo->buffer);
+    sfree(todo);
+}
+
+static void todo_add(struct todo *todo, int index)
+{
+    if (todo->marked[index])
+        return;                        /* already on the list */
+    todo->marked[index] = TRUE;
+    todo->buffer[todo->tail++] = index;
+    if (todo->tail == todo->buflen)
+        todo->tail = 0;
+}
+
+static int todo_get(struct todo *todo) {
+    int ret;
+
+    if (todo->head == todo->tail)
+        return -1;                     /* list is empty */
+    ret = todo->buffer[todo->head++];
+    if (todo->head == todo->buflen)
+        todo->head = 0;
+    todo->marked[ret] = FALSE;
+
+    return ret;
+}
+
+static int net_solver(int w, int h, unsigned char *tiles,
+                      unsigned char *barriers, int wrapping)
+{
+    unsigned char *tilestate;
+    unsigned char *edgestate;
+    int *deadends;
+    int *equivalence;
+    struct todo *todo;
+    int i, j, x, y;
+    int area;
+    int done_something;
+
+    /*
+     * Set up the solver's data structures.
+     */
+    
+    /*
+     * tilestate stores the possible orientations of each tile.
+     * There are up to four of these, so we'll index the array in
+     * fours. tilestate[(y * w + x) * 4] and its three successive
+     * members give the possible orientations, clearing to 255 from
+     * the end as things are ruled out.
+     * 
+     * In this loop we also count up the area of the grid (which is
+     * not _necessarily_ equal to w*h, because there might be one
+     * or more blank squares present. This will never happen in a
+     * grid generated _by_ this program, but it's worth keeping the
+     * solver as general as possible.)
+     */
+    tilestate = snewn(w * h * 4, unsigned char);
+    area = 0;
+    for (i = 0; i < w*h; i++) {
+        tilestate[i * 4] = tiles[i] & 0xF;
+        for (j = 1; j < 4; j++) {
+            if (tilestate[i * 4 + j - 1] == 255 ||
+                A(tilestate[i * 4 + j - 1]) == tilestate[i * 4])
+                tilestate[i * 4 + j] = 255;
+            else
+                tilestate[i * 4 + j] = A(tilestate[i * 4 + j - 1]);
+        }
+        if (tiles[i] != 0)
+            area++;
+    }
+
+    /*
+     * edgestate stores the known state of each edge. It is 0 for
+     * unknown, 1 for open (connected) and 2 for closed (not
+     * connected).
+     * 
+     * In principle we need only worry about each edge once each,
+     * but in fact it's easier to track each edge twice so that we
+     * can reference it from either side conveniently. Also I'm
+     * going to allocate _five_ bytes per tile, rather than the
+     * obvious four, so that I can index edgestate[(y*w+x) * 5 + d]
+     * where d is 1,2,4,8 and they never overlap.
+     */
+    edgestate = snewn((w * h - 1) * 5 + 9, unsigned char);
+    memset(edgestate, 0, (w * h - 1) * 5 + 9);
+
+    /*
+     * deadends tracks which edges have dead ends on them. It is
+     * indexed by tile and direction: deadends[(y*w+x) * 5 + d]
+     * tells you whether heading out of tile (x,y) in direction d
+     * can reach a limited amount of the grid. Values are area+1
+     * (no dead end known) or less than that (can reach _at most_
+     * this many other tiles by heading this way out of this tile).
+     */
+    deadends = snewn((w * h - 1) * 5 + 9, int);
+    for (i = 0; i < (w * h - 1) * 5 + 9; i++)
+        deadends[i] = area+1;
+
+    /*
+     * equivalence tracks which sets of tiles are known to be
+     * connected to one another, so we can avoid creating loops by
+     * linking together tiles which are already linked through
+     * another route.
+     * 
+     * This is a disjoint set forest structure: equivalence[i]
+     * contains the index of another member of the equivalence
+     * class containing i, or contains i itself for precisely one
+     * member in each such class. To find a representative member
+     * of the equivalence class containing i, you keep replacing i
+     * with equivalence[i] until it stops changing; then you go
+     * _back_ along the same path and point everything on it
+     * directly at the representative member so as to speed up
+     * future searches. Then you test equivalence between tiles by
+     * finding the representative of each tile and seeing if
+     * they're the same; and you create new equivalence (merge
+     * classes) by finding the representative of each tile and
+     * setting equivalence[one]=the_other.
+     */
+    equivalence = snew_dsf(w * h);
+
+    /*
+     * On a non-wrapping grid, we instantly know that all the edges
+     * round the edge are closed.
+     */
+    if (!wrapping) {
+        for (i = 0; i < w; i++) {
+            edgestate[i * 5 + 2] = edgestate[((h-1) * w + i) * 5 + 8] = 2;
+        }
+        for (i = 0; i < h; i++) {
+            edgestate[(i * w + w-1) * 5 + 1] = edgestate[(i * w) * 5 + 4] = 2;
+        }
+    }
+
+    /*
+     * If we have barriers available, we can mark those edges as
+     * closed too.
+     */
+    if (barriers) {
+        for (y = 0; y < h; y++) for (x = 0; x < w; x++) {
+            int d;
+            for (d = 1; d <= 8; d += d) {
+                if (barriers[y*w+x] & d) {
+                    int x2, y2;
+                    /*
+                     * In principle the barrier list should already
+                     * contain each barrier from each side, but
+                     * let's not take chances with our internal
+                     * consistency.
+                     */
+                    OFFSETWH(x2, y2, x, y, d, w, h);
+                    edgestate[(y*w+x) * 5 + d] = 2;
+                    edgestate[(y2*w+x2) * 5 + F(d)] = 2;
+                }
+            }
+        }
+    }
+
+    /*
+     * Since most deductions made by this solver are local (the
+     * exception is loop avoidance, where joining two tiles
+     * together on one side of the grid can theoretically permit a
+     * fresh deduction on the other), we can address the scaling
+     * problem inherent in iterating repeatedly over the entire
+     * grid by instead working with a to-do list.
+     */
+    todo = todo_new(w * h);
+
+    /*
+     * Main deductive loop.
+     */
+    done_something = TRUE;             /* prevent instant termination! */
+    while (1) {
+        int index;
+
+        /*
+         * Take a tile index off the todo list and process it.
+         */
+        index = todo_get(todo);
+        if (index == -1) {
+            /*
+             * If we have run out of immediate things to do, we
+             * have no choice but to scan the whole grid for
+             * longer-range things we've missed. Hence, I now add
+             * every square on the grid back on to the to-do list.
+             * I also set `done_something' to FALSE at this point;
+             * if we later come back here and find it still FALSE,
+             * we will know we've scanned the entire grid without
+             * finding anything new to do, and we can terminate.
+             */
+            if (!done_something)
+                break;
+            for (i = 0; i < w*h; i++)
+                todo_add(todo, i);
+            done_something = FALSE;
+
+            index = todo_get(todo);
+        }
+
+        y = index / w;
+        x = index % w;
+        {
+            int d, ourclass = dsf_canonify(equivalence, y*w+x);
+            int deadendmax[9];
+
+            deadendmax[1] = deadendmax[2] = deadendmax[4] = deadendmax[8] = 0;
+
+            for (i = j = 0; i < 4 && tilestate[(y*w+x) * 4 + i] != 255; i++) {
+                int valid;
+                int nnondeadends, nondeadends[4], deadendtotal;
+                int nequiv, equiv[5];
+                int val = tilestate[(y*w+x) * 4 + i];
+
+                valid = TRUE;
+                nnondeadends = deadendtotal = 0;
+                equiv[0] = ourclass;
+                nequiv = 1;
+                for (d = 1; d <= 8; d += d) {
+                    /*
+                     * Immediately rule out this orientation if it
+                     * conflicts with any known edge.
+                     */
+                    if ((edgestate[(y*w+x) * 5 + d] == 1 && !(val & d)) ||
+                        (edgestate[(y*w+x) * 5 + d] == 2 && (val & d)))
+                        valid = FALSE;
+
+                    if (val & d) {
+                        /*
+                         * Count up the dead-end statistics.
+                         */
+                        if (deadends[(y*w+x) * 5 + d] <= area) {
+                            deadendtotal += deadends[(y*w+x) * 5 + d];
+                        } else {
+                            nondeadends[nnondeadends++] = d;
+                        }
+
+                        /*
+                         * Ensure we aren't linking to any tiles,
+                         * through edges not already known to be
+                         * open, which create a loop.
+                         */
+                        if (edgestate[(y*w+x) * 5 + d] == 0) {
+                            int c, k, x2, y2;
+                            
+                            OFFSETWH(x2, y2, x, y, d, w, h);
+                            c = dsf_canonify(equivalence, y2*w+x2);
+                            for (k = 0; k < nequiv; k++)
+                                if (c == equiv[k])
+                                    break;
+                            if (k == nequiv)
+                                equiv[nequiv++] = c;
+                            else
+                                valid = FALSE;
+                        }
+                    }
+                }
+
+                if (nnondeadends == 0) {
+                    /*
+                     * If this orientation links together dead-ends
+                     * with a total area of less than the entire
+                     * grid, it is invalid.
+                     *
+                     * (We add 1 to deadendtotal because of the
+                     * tile itself, of course; one tile linking
+                     * dead ends of size 2 and 3 forms a subnetwork
+                     * with a total area of 6, not 5.)
+                     */
+                    if (deadendtotal > 0 && deadendtotal+1 < area)
+                        valid = FALSE;
+                } else if (nnondeadends == 1) {
+                    /*
+                     * If this orientation links together one or
+                     * more dead-ends with precisely one
+                     * non-dead-end, then we may have to mark that
+                     * non-dead-end as a dead end going the other
+                     * way. However, it depends on whether all
+                     * other orientations share the same property.
+                     */
+                    deadendtotal++;
+                    if (deadendmax[nondeadends[0]] < deadendtotal)
+                        deadendmax[nondeadends[0]] = deadendtotal;
+                } else {
+                    /*
+                     * If this orientation links together two or
+                     * more non-dead-ends, then we can rule out the
+                     * possibility of putting in new dead-end
+                     * markings in those directions.
+                     */
+                    int k;
+                    for (k = 0; k < nnondeadends; k++)
+                        deadendmax[nondeadends[k]] = area+1;
+                }
+
+                if (valid)
+                    tilestate[(y*w+x) * 4 + j++] = val;
+#ifdef SOLVER_DIAGNOSTICS
+                else
+                    printf("ruling out orientation %x at %d,%d\n", val, x, y);
+#endif
+            }
+
+            assert(j > 0);             /* we can't lose _all_ possibilities! */
+
+            if (j < i) {
+                done_something = TRUE;
+
+                /*
+                 * We have ruled out at least one tile orientation.
+                 * Make sure the rest are blanked.
+                 */
+                while (j < 4)
+                    tilestate[(y*w+x) * 4 + j++] = 255;
+            }
+
+            /*
+             * Now go through the tile orientations again and see
+             * if we've deduced anything new about any edges.
+             */
+            {
+                int a, o;
+                a = 0xF; o = 0;
+
+                for (i = 0; i < 4 && tilestate[(y*w+x) * 4 + i] != 255; i++) {
+                    a &= tilestate[(y*w+x) * 4 + i];
+                    o |= tilestate[(y*w+x) * 4 + i];
+                }
+                for (d = 1; d <= 8; d += d)
+                    if (edgestate[(y*w+x) * 5 + d] == 0) {
+                        int x2, y2, d2;
+                        OFFSETWH(x2, y2, x, y, d, w, h);
+                        d2 = F(d);
+                        if (a & d) {
+                            /* This edge is open in all orientations. */
+#ifdef SOLVER_DIAGNOSTICS
+                            printf("marking edge %d,%d:%d open\n", x, y, d);
+#endif
+                            edgestate[(y*w+x) * 5 + d] = 1;
+                            edgestate[(y2*w+x2) * 5 + d2] = 1;
+                            dsf_merge(equivalence, y*w+x, y2*w+x2);
+                            done_something = TRUE;
+                            todo_add(todo, y2*w+x2);
+                        } else if (!(o & d)) {
+                            /* This edge is closed in all orientations. */
+#ifdef SOLVER_DIAGNOSTICS
+                            printf("marking edge %d,%d:%d closed\n", x, y, d);
+#endif
+                            edgestate[(y*w+x) * 5 + d] = 2;
+                            edgestate[(y2*w+x2) * 5 + d2] = 2;
+                            done_something = TRUE;
+                            todo_add(todo, y2*w+x2);
+                        }
+                    }
+
+            }
+
+            /*
+             * Now check the dead-end markers and see if any of
+             * them has lowered from the real ones.
+             */
+            for (d = 1; d <= 8; d += d) {
+                int x2, y2, d2;
+                OFFSETWH(x2, y2, x, y, d, w, h);
+                d2 = F(d);
+                if (deadendmax[d] > 0 &&
+                    deadends[(y2*w+x2) * 5 + d2] > deadendmax[d]) {
+#ifdef SOLVER_DIAGNOSTICS
+                    printf("setting dead end value %d,%d:%d to %d\n",
+                           x2, y2, d2, deadendmax[d]);
+#endif
+                    deadends[(y2*w+x2) * 5 + d2] = deadendmax[d];
+                    done_something = TRUE;
+                    todo_add(todo, y2*w+x2);
+                }
+            }
+
+        }
+    }
+
+    /*
+     * Mark all completely determined tiles as locked.
+     */
+    j = TRUE;
+    for (i = 0; i < w*h; i++) {
+        if (tilestate[i * 4 + 1] == 255) {
+            assert(tilestate[i * 4 + 0] != 255);
+            tiles[i] = tilestate[i * 4] | LOCKED;
+        } else {
+            tiles[i] &= ~LOCKED;
+            j = FALSE;
+        }
+    }
+
+    /*
+     * Free up working space.
+     */
+    todo_free(todo);
+    sfree(tilestate);
+    sfree(edgestate);
+    sfree(deadends);
+    sfree(equivalence);
+
+    return j;
+}
+
+/* ----------------------------------------------------------------------
+ * Randomly select a new game description.
+ */
+
+/*
+ * Function to randomly perturb an ambiguous section in a grid, to
+ * attempt to ensure unique solvability.
+ */
+static void perturb(int w, int h, unsigned char *tiles, int wrapping,
+                    random_state *rs, int startx, int starty, int startd)
+{
+    struct xyd *perimeter, *perim2, *loop[2], looppos[2];
+    int nperim, perimsize, nloop[2], loopsize[2];
+    int x, y, d, i;
+
+    /*
+     * We know that the tile at (startx,starty) is part of an
+     * ambiguous section, and we also know that its neighbour in
+     * direction startd is fully specified. We begin by tracing all
+     * the way round the ambiguous area.
+     */
+    nperim = perimsize = 0;
+    perimeter = NULL;
+    x = startx;
+    y = starty;
+    d = startd;
+#ifdef PERTURB_DIAGNOSTICS
+    printf("perturb %d,%d:%d\n", x, y, d);
+#endif
+    do {
+        int x2, y2, d2;
+
+        if (nperim >= perimsize) {
+            perimsize = perimsize * 3 / 2 + 32;
+            perimeter = sresize(perimeter, perimsize, struct xyd);
+        }
+        perimeter[nperim].x = x;
+        perimeter[nperim].y = y;
+        perimeter[nperim].direction = d;
+        nperim++;
+#ifdef PERTURB_DIAGNOSTICS
+        printf("perimeter: %d,%d:%d\n", x, y, d);
+#endif
+
+        /*
+         * First, see if we can simply turn left from where we are
+         * and find another locked square.
+         */
+        d2 = A(d);
+        OFFSETWH(x2, y2, x, y, d2, w, h);
+        if ((!wrapping && (abs(x2-x) > 1 || abs(y2-y) > 1)) ||
+            (tiles[y2*w+x2] & LOCKED)) {
+            d = d2;
+        } else {
+            /*
+             * Failing that, step left into the new square and look
+             * in front of us.
+             */
+            x = x2;
+            y = y2;
+            OFFSETWH(x2, y2, x, y, d, w, h);
+            if ((wrapping || (abs(x2-x) <= 1 && abs(y2-y) <= 1)) &&
+                !(tiles[y2*w+x2] & LOCKED)) {
+                /*
+                 * And failing _that_, we're going to have to step
+                 * forward into _that_ square and look right at the
+                 * same locked square as we started with.
+                 */
+                x = x2;
+                y = y2;
+                d = C(d);
+            }
+        }
+
+    } while (x != startx || y != starty || d != startd);
+
+    /*
+     * Our technique for perturbing this ambiguous area is to
+     * search round its edge for a join we can make: that is, an
+     * edge on the perimeter which is (a) not currently connected,
+     * and (b) connecting it would not yield a full cross on either
+     * side. Then we make that join, search round the network to
+     * find the loop thus constructed, and sever the loop at a
+     * randomly selected other point.
+     */
+    perim2 = snewn(nperim, struct xyd);
+    memcpy(perim2, perimeter, nperim * sizeof(struct xyd));
+    /* Shuffle the perimeter, so as to search it without directional bias. */
+    shuffle(perim2, nperim, sizeof(*perim2), rs);
+    for (i = 0; i < nperim; i++) {
+        int x2, y2;
+
+        x = perim2[i].x;
+        y = perim2[i].y;
+        d = perim2[i].direction;
+
+        OFFSETWH(x2, y2, x, y, d, w, h);
+        if (!wrapping && (abs(x2-x) > 1 || abs(y2-y) > 1))
+            continue;            /* can't link across non-wrapping border */
+        if (tiles[y*w+x] & d)
+            continue;                  /* already linked in this direction! */
+        if (((tiles[y*w+x] | d) & 15) == 15)
+            continue;                  /* can't turn this tile into a cross */
+        if (((tiles[y2*w+x2] | F(d)) & 15) == 15)
+            continue;                  /* can't turn other tile into a cross */
+
+        /*
+         * We've found the point at which we're going to make a new
+         * link.
+         */
+#ifdef PERTURB_DIAGNOSTICS      
+        printf("linking %d,%d:%d\n", x, y, d);
+#endif
+        tiles[y*w+x] |= d;
+        tiles[y2*w+x2] |= F(d);
+
+        break;
+    }
+    sfree(perim2);
+
+    if (i == nperim) {
+        sfree(perimeter);
+        return;                        /* nothing we can do! */
+    }
+
+    /*
+     * Now we've constructed a new link, we need to find the entire
+     * loop of which it is a part.
+     * 
+     * In principle, this involves doing a complete search round
+     * the network. However, I anticipate that in the vast majority
+     * of cases the loop will be quite small, so what I'm going to
+     * do is make _two_ searches round the network in parallel, one
+     * keeping its metaphorical hand on the left-hand wall while
+     * the other keeps its hand on the right. As soon as one of
+     * them gets back to its starting point, I abandon the other.
+     */
+    for (i = 0; i < 2; i++) {
+        loopsize[i] = nloop[i] = 0;
+        loop[i] = NULL;
+        looppos[i].x = x;
+        looppos[i].y = y;
+        looppos[i].direction = d;
+    }
+    while (1) {
+        for (i = 0; i < 2; i++) {
+            int x2, y2, j;
+
+            x = looppos[i].x;
+            y = looppos[i].y;
+            d = looppos[i].direction;
+
+            OFFSETWH(x2, y2, x, y, d, w, h);
+
+            /*
+             * Add this path segment to the loop, unless it exactly
+             * reverses the previous one on the loop in which case
+             * we take it away again.
+             */
+#ifdef PERTURB_DIAGNOSTICS
+            printf("looppos[%d] = %d,%d:%d\n", i, x, y, d);
+#endif
+            if (nloop[i] > 0 &&
+                loop[i][nloop[i]-1].x == x2 &&
+                loop[i][nloop[i]-1].y == y2 &&
+                loop[i][nloop[i]-1].direction == F(d)) {
+#ifdef PERTURB_DIAGNOSTICS
+                printf("removing path segment %d,%d:%d from loop[%d]\n",
+                       x2, y2, F(d), i);
+#endif
+                nloop[i]--;
+            } else {
+                if (nloop[i] >= loopsize[i]) {
+                    loopsize[i] = loopsize[i] * 3 / 2 + 32;
+                    loop[i] = sresize(loop[i], loopsize[i], struct xyd);
+                }
+#ifdef PERTURB_DIAGNOSTICS
+                printf("adding path segment %d,%d:%d to loop[%d]\n",
+                       x, y, d, i);
+#endif
+                loop[i][nloop[i]++] = looppos[i];
+            }
+
+#ifdef PERTURB_DIAGNOSTICS
+            printf("tile at new location is %x\n", tiles[y2*w+x2] & 0xF);
+#endif
+            d = F(d);
+            for (j = 0; j < 4; j++) {
+                if (i == 0)
+                    d = A(d);
+                else
+                    d = C(d);
+#ifdef PERTURB_DIAGNOSTICS
+                printf("trying dir %d\n", d);
+#endif
+                if (tiles[y2*w+x2] & d) {
+                    looppos[i].x = x2;
+                    looppos[i].y = y2;
+                    looppos[i].direction = d;
+                    break;
+                }
+            }
+
+            assert(j < 4);
+            assert(nloop[i] > 0);
+
+            if (looppos[i].x == loop[i][0].x &&
+                looppos[i].y == loop[i][0].y &&
+                looppos[i].direction == loop[i][0].direction) {
+#ifdef PERTURB_DIAGNOSTICS
+                printf("loop %d finished tracking\n", i);
+#endif
+
+                /*
+                 * Having found our loop, we now sever it at a
+                 * randomly chosen point - absolutely any will do -
+                 * which is not the one we joined it at to begin
+                 * with. Conveniently, the one we joined it at is
+                 * loop[i][0], so we just avoid that one.
+                 */
+                j = random_upto(rs, nloop[i]-1) + 1;
+                x = loop[i][j].x;
+                y = loop[i][j].y;
+                d = loop[i][j].direction;
+                OFFSETWH(x2, y2, x, y, d, w, h);
+                tiles[y*w+x] &= ~d;
+                tiles[y2*w+x2] &= ~F(d);
+
+                break;
+            }
+        }
+        if (i < 2)
+            break;
+    }
+    sfree(loop[0]);
+    sfree(loop[1]);
+
+    /*
+     * Finally, we must mark the entire disputed section as locked,
+     * to prevent the perturb function being called on it multiple
+     * times.
+     * 
+     * To do this, we _sort_ the perimeter of the area. The
+     * existing xyd_cmp function will arrange things into columns
+     * for us, in such a way that each column has the edges in
+     * vertical order. Then we can work down each column and fill
+     * in all the squares between an up edge and a down edge.
+     */
+    qsort(perimeter, nperim, sizeof(struct xyd), xyd_cmp);
+    x = y = -1;
+    for (i = 0; i <= nperim; i++) {
+        if (i == nperim || perimeter[i].x > x) {
+            /*
+             * Fill in everything from the last Up edge to the
+             * bottom of the grid, if necessary.
+             */
+            if (x != -1) {
+                while (y < h) {
+#ifdef PERTURB_DIAGNOSTICS
+                    printf("resolved: locking tile %d,%d\n", x, y);
+#endif
+                    tiles[y * w + x] |= LOCKED;
+                    y++;
+                }
+                x = y = -1;
+            }
+
+            if (i == nperim)
+                break;
+
+            x = perimeter[i].x;
+            y = 0;
+        }
+
+        if (perimeter[i].direction == U) {
+            x = perimeter[i].x;
+            y = perimeter[i].y;
+        } else if (perimeter[i].direction == D) {
+            /*
+             * Fill in everything from the last Up edge to here.
+             */
+            assert(x == perimeter[i].x && y <= perimeter[i].y);
+            while (y <= perimeter[i].y) {
+#ifdef PERTURB_DIAGNOSTICS
+                printf("resolved: locking tile %d,%d\n", x, y);
+#endif
+                tiles[y * w + x] |= LOCKED;
+                y++;
+            }
+            x = y = -1;
+        }
+    }
+
+    sfree(perimeter);
+}
+
+static int *compute_loops_inner(int w, int h, int wrapping,
+                                const unsigned char *tiles,
+                                const unsigned char *barriers);
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    tree234 *possibilities, *barriertree;
+    int w, h, x, y, cx, cy, nbarriers;
+    unsigned char *tiles, *barriers;
+    char *desc, *p;
+
+    w = params->width;
+    h = params->height;
+
+    cx = w / 2;
+    cy = h / 2;
+
+    tiles = snewn(w * h, unsigned char);
+    barriers = snewn(w * h, unsigned char);
+
+    begin_generation:
+
+    memset(tiles, 0, w * h);
+    memset(barriers, 0, w * h);
+
+    /*
+     * Construct the unshuffled grid.
+     * 
+     * To do this, we simply start at the centre point, repeatedly
+     * choose a random possibility out of the available ways to
+     * extend a used square into an unused one, and do it. After
+     * extending the third line out of a square, we remove the
+     * fourth from the possibilities list to avoid any full-cross
+     * squares (which would make the game too easy because they
+     * only have one orientation).
+     * 
+     * The slightly worrying thing is the avoidance of full-cross
+     * squares. Can this cause our unsophisticated construction
+     * algorithm to paint itself into a corner, by getting into a
+     * situation where there are some unreached squares and the
+     * only way to reach any of them is to extend a T-piece into a
+     * full cross?
+     * 
+     * Answer: no it can't, and here's a proof.
+     * 
+     * Any contiguous group of such unreachable squares must be
+     * surrounded on _all_ sides by T-pieces pointing away from the
+     * group. (If not, then there is a square which can be extended
+     * into one of the `unreachable' ones, and so it wasn't
+     * unreachable after all.) In particular, this implies that
+     * each contiguous group of unreachable squares must be
+     * rectangular in shape (any deviation from that yields a
+     * non-T-piece next to an `unreachable' square).
+     * 
+     * So we have a rectangle of unreachable squares, with T-pieces
+     * forming a solid border around the rectangle. The corners of
+     * that border must be connected (since every tile connects all
+     * the lines arriving in it), and therefore the border must
+     * form a closed loop around the rectangle.
+     * 
+     * But this can't have happened in the first place, since we
+     * _know_ we've avoided creating closed loops! Hence, no such
+     * situation can ever arise, and the naive grid construction
+     * algorithm will guaranteeably result in a complete grid
+     * containing no unreached squares, no full crosses _and_ no
+     * closed loops. []
+     */
+    possibilities = newtree234(xyd_cmp_nc);
+
+    if (cx+1 < w)
+        add234(possibilities, new_xyd(cx, cy, R));
+    if (cy-1 >= 0)
+        add234(possibilities, new_xyd(cx, cy, U));
+    if (cx-1 >= 0)
+        add234(possibilities, new_xyd(cx, cy, L));
+    if (cy+1 < h)
+        add234(possibilities, new_xyd(cx, cy, D));
+
+    while (count234(possibilities) > 0) {
+        int i;
+        struct xyd *xyd;
+        int x1, y1, d1, x2, y2, d2, d;
+
+        /*
+         * Extract a randomly chosen possibility from the list.
+         */
+        i = random_upto(rs, count234(possibilities));
+        xyd = delpos234(possibilities, i);
+        x1 = xyd->x;
+        y1 = xyd->y;
+        d1 = xyd->direction;
+        sfree(xyd);
+
+        OFFSET(x2, y2, x1, y1, d1, params);
+        d2 = F(d1);
+#ifdef GENERATION_DIAGNOSTICS
+        printf("picked (%d,%d,%c) <-> (%d,%d,%c)\n",
+               x1, y1, "0RU3L567D9abcdef"[d1], x2, y2, "0RU3L567D9abcdef"[d2]);
+#endif
+
+        /*
+         * Make the connection. (We should be moving to an as yet
+         * unused tile.)
+         */
+        index(params, tiles, x1, y1) |= d1;
+        assert(index(params, tiles, x2, y2) == 0);
+        index(params, tiles, x2, y2) |= d2;
+
+        /*
+         * If we have created a T-piece, remove its last
+         * possibility.
+         */
+        if (COUNT(index(params, tiles, x1, y1)) == 3) {
+            struct xyd xyd1, *xydp;
+
+            xyd1.x = x1;
+            xyd1.y = y1;
+            xyd1.direction = 0x0F ^ index(params, tiles, x1, y1);
+
+            xydp = find234(possibilities, &xyd1, NULL);
+
+            if (xydp) {
+#ifdef GENERATION_DIAGNOSTICS
+                printf("T-piece; removing (%d,%d,%c)\n",
+                       xydp->x, xydp->y, "0RU3L567D9abcdef"[xydp->direction]);
+#endif
+                del234(possibilities, xydp);
+                sfree(xydp);
+            }
+        }
+
+        /*
+         * Remove all other possibilities that were pointing at the
+         * tile we've just moved into.
+         */
+        for (d = 1; d < 0x10; d <<= 1) {
+            int x3, y3, d3;
+            struct xyd xyd1, *xydp;
+
+            OFFSET(x3, y3, x2, y2, d, params);
+            d3 = F(d);
+
+            xyd1.x = x3;
+            xyd1.y = y3;
+            xyd1.direction = d3;
+
+            xydp = find234(possibilities, &xyd1, NULL);
+
+            if (xydp) {
+#ifdef GENERATION_DIAGNOSTICS
+                printf("Loop avoidance; removing (%d,%d,%c)\n",
+                       xydp->x, xydp->y, "0RU3L567D9abcdef"[xydp->direction]);
+#endif
+                del234(possibilities, xydp);
+                sfree(xydp);
+            }
+        }
+
+        /*
+         * Add new possibilities to the list for moving _out_ of
+         * the tile we have just moved into.
+         */
+        for (d = 1; d < 0x10; d <<= 1) {
+            int x3, y3;
+
+            if (d == d2)
+                continue;              /* we've got this one already */
+
+            if (!params->wrapping) {
+                if (d == U && y2 == 0)
+                    continue;
+                if (d == D && y2 == h-1)
+                    continue;
+                if (d == L && x2 == 0)
+                    continue;
+                if (d == R && x2 == w-1)
+                    continue;
+            }
+
+            OFFSET(x3, y3, x2, y2, d, params);
+
+            if (index(params, tiles, x3, y3))
+                continue;              /* this would create a loop */
+
+#ifdef GENERATION_DIAGNOSTICS
+            printf("New frontier; adding (%d,%d,%c)\n",
+                   x2, y2, "0RU3L567D9abcdef"[d]);
+#endif
+            add234(possibilities, new_xyd(x2, y2, d));
+        }
+    }
+    /* Having done that, we should have no possibilities remaining. */
+    assert(count234(possibilities) == 0);
+    freetree234(possibilities);
+
+    if (params->unique) {
+        int prevn = -1;
+
+        /*
+         * Run the solver to check unique solubility.
+         */
+        while (!net_solver(w, h, tiles, NULL, params->wrapping)) {
+            int n = 0;
+
+            /*
+             * We expect (in most cases) that most of the grid will
+             * be uniquely specified already, and the remaining
+             * ambiguous sections will be small and separate. So
+             * our strategy is to find each individual such
+             * section, and perform a perturbation on the network
+             * in that area.
+             */
+            for (y = 0; y < h; y++) for (x = 0; x < w; x++) {
+                if (x+1 < w && ((tiles[y*w+x] ^ tiles[y*w+x+1]) & LOCKED)) {
+                    n++;
+                    if (tiles[y*w+x] & LOCKED)
+                        perturb(w, h, tiles, params->wrapping, rs, x+1, y, L);
+                    else
+                        perturb(w, h, tiles, params->wrapping, rs, x, y, R);
+                }
+                if (y+1 < h && ((tiles[y*w+x] ^ tiles[(y+1)*w+x]) & LOCKED)) {
+                    n++;
+                    if (tiles[y*w+x] & LOCKED)
+                        perturb(w, h, tiles, params->wrapping, rs, x, y+1, U);
+                    else
+                        perturb(w, h, tiles, params->wrapping, rs, x, y, D);
+                }
+            }
+
+            /*
+             * Now n counts the number of ambiguous sections we
+             * have fiddled with. If we haven't managed to decrease
+             * it from the last time we ran the solver, give up and
+             * regenerate the entire grid.
+             */
+            if (prevn != -1 && prevn <= n)
+                goto begin_generation; /* (sorry) */
+
+            prevn = n;
+        }
+
+        /*
+         * The solver will have left a lot of LOCKED bits lying
+         * around in the tiles array. Remove them.
+         */
+        for (x = 0; x < w*h; x++)
+            tiles[x] &= ~LOCKED;
+    }
+
+    /*
+     * Now compute a list of the possible barrier locations.
+     */
+    barriertree = newtree234(xyd_cmp_nc);
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+
+            if (!(index(params, tiles, x, y) & R) &&
+                (params->wrapping || x < w-1))
+                add234(barriertree, new_xyd(x, y, R));
+            if (!(index(params, tiles, x, y) & D) &&
+                (params->wrapping || y < h-1))
+                add234(barriertree, new_xyd(x, y, D));
+        }
+    }
+
+    /*
+     * Save the unshuffled grid in aux.
+     */
+    {
+        char *solution;
+        int i;
+
+        solution = snewn(w * h + 1, char);
+        for (i = 0; i < w * h; i++)
+            solution[i] = "0123456789abcdef"[tiles[i] & 0xF];
+        solution[w*h] = '\0';
+
+        *aux = solution;
+    }
+
+    /*
+     * Now shuffle the grid.
+     * 
+     * In order to avoid accidentally generating an already-solved
+     * grid, we will reshuffle as necessary to ensure that at least
+     * one edge has a mismatched connection.
+     *
+     * This can always be done, since validate_params() enforces a
+     * grid area of at least 2 and our generator never creates
+     * either type of rotationally invariant tile (cross and
+     * blank). Hence there must be at least one edge separating
+     * distinct tiles, and it must be possible to find orientations
+     * of those tiles such that one tile is trying to connect
+     * through that edge and the other is not.
+     * 
+     * (We could be more subtle, and allow the shuffle to generate
+     * a grid in which all tiles match up locally and the only
+     * criterion preventing the grid from being already solved is
+     * connectedness. However, that would take more effort, and
+     * it's easier to simply make sure every grid is _obviously_
+     * not solved.)
+     *
+     * We also require that our shuffle produces no loops in the
+     * initial grid state, because it's a bit rude to light up a 'HEY,
+     * YOU DID SOMETHING WRONG!' indicator when the user hasn't even
+     * had a chance to do _anything_ yet. This also is possible just
+     * by retrying the whole shuffle on failure, because it's clear
+     * that at least one non-solved shuffle with no loops must exist.
+     * (Proof: take the _solved_ state of the puzzle, and rotate one
+     * endpoint.)
+     */
+    while (1) {
+        int mismatches, prev_loopsquares, this_loopsquares, i;
+        int *loops;
+
+      shuffle:
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                int orig = index(params, tiles, x, y);
+                int rot = random_upto(rs, 4);
+                index(params, tiles, x, y) = ROT(orig, rot);
+            }
+        }
+
+        /*
+         * Check for loops, and try to fix them by reshuffling just
+         * the squares involved.
+         */
+        prev_loopsquares = w*h+1;
+        while (1) {
+            loops = compute_loops_inner(w, h, params->wrapping, tiles, NULL);
+            this_loopsquares = 0;
+            for (i = 0; i < w*h; i++) {
+                if (loops[i]) {
+                    int orig = tiles[i];
+                    int rot = random_upto(rs, 4);
+                    tiles[i] = ROT(orig, rot);
+                    this_loopsquares++;
+                }
+            }
+            sfree(loops);
+            if (this_loopsquares > prev_loopsquares) {
+                /*
+                 * We're increasing rather than reducing the number of
+                 * loops. Give up and go back to the full shuffle.
+                 */
+                goto shuffle;
+            }
+            if (this_loopsquares == 0)
+                break;
+            prev_loopsquares = this_loopsquares;
+        }
+
+        mismatches = 0;
+        /*
+         * I can't even be bothered to check for mismatches across
+         * a wrapping edge, so I'm just going to enforce that there
+         * must be a mismatch across a non-wrapping edge, which is
+         * still always possible.
+         */
+        for (y = 0; y < h; y++) for (x = 0; x < w; x++) {
+            if (x+1 < w && ((ROT(index(params, tiles, x, y), 2) ^ 
+                             index(params, tiles, x+1, y)) & L))
+                mismatches++;
+            if (y+1 < h && ((ROT(index(params, tiles, x, y), 2) ^ 
+                             index(params, tiles, x, y+1)) & U))
+                mismatches++;
+        }
+
+        if (mismatches == 0)
+            continue;
+
+        /* OK. */
+        break;
+    }
+
+    /*
+     * And now choose barrier locations. (We carefully do this
+     * _after_ shuffling, so that changing the barrier rate in the
+     * params while keeping the random seed the same will give the
+     * same shuffled grid and _only_ change the barrier locations.
+     * Also the way we choose barrier locations, by repeatedly
+     * choosing one possibility from the list until we have enough,
+     * is designed to ensure that raising the barrier rate while
+     * keeping the seed the same will provide a superset of the
+     * previous barrier set - i.e. if you ask for 10 barriers, and
+     * then decide that's still too hard and ask for 20, you'll get
+     * the original 10 plus 10 more, rather than getting 20 new
+     * ones and the chance of remembering your first 10.)
+     */
+    nbarriers = (int)(params->barrier_probability * count234(barriertree));
+    assert(nbarriers >= 0 && nbarriers <= count234(barriertree));
+
+    while (nbarriers > 0) {
+        int i;
+        struct xyd *xyd;
+        int x1, y1, d1, x2, y2, d2;
+
+        /*
+         * Extract a randomly chosen barrier from the list.
+         */
+        i = random_upto(rs, count234(barriertree));
+        xyd = delpos234(barriertree, i);
+
+        assert(xyd != NULL);
+
+        x1 = xyd->x;
+        y1 = xyd->y;
+        d1 = xyd->direction;
+        sfree(xyd);
+
+        OFFSET(x2, y2, x1, y1, d1, params);
+        d2 = F(d1);
+
+        index(params, barriers, x1, y1) |= d1;
+        index(params, barriers, x2, y2) |= d2;
+
+        nbarriers--;
+    }
+
+    /*
+     * Clean up the rest of the barrier list.
+     */
+    {
+        struct xyd *xyd;
+
+        while ( (xyd = delpos234(barriertree, 0)) != NULL)
+            sfree(xyd);
+
+        freetree234(barriertree);
+    }
+
+    /*
+     * Finally, encode the grid into a string game description.
+     * 
+     * My syntax is extremely simple: each square is encoded as a
+     * hex digit in which bit 0 means a connection on the right,
+     * bit 1 means up, bit 2 left and bit 3 down. (i.e. the same
+     * encoding as used internally). Each digit is followed by
+     * optional barrier indicators: `v' means a vertical barrier to
+     * the right of it, and `h' means a horizontal barrier below
+     * it.
+     */
+    desc = snewn(w * h * 3 + 1, char);
+    p = desc;
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            *p++ = "0123456789abcdef"[index(params, tiles, x, y)];
+            if ((params->wrapping || x < w-1) &&
+                (index(params, barriers, x, y) & R))
+                *p++ = 'v';
+            if ((params->wrapping || y < h-1) &&
+                (index(params, barriers, x, y) & D))
+                *p++ = 'h';
+        }
+    }
+    assert(p - desc <= w*h*3);
+    *p = '\0';
+
+    sfree(tiles);
+    sfree(barriers);
+
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->width, h = params->height;
+    int i;
+
+    for (i = 0; i < w*h; i++) {
+        if (*desc >= '0' && *desc <= '9')
+            /* OK */;
+        else if (*desc >= 'a' && *desc <= 'f')
+            /* OK */;
+        else if (*desc >= 'A' && *desc <= 'F')
+            /* OK */;
+        else if (!*desc)
+            return "Game description shorter than expected";
+        else
+            return "Game description contained unexpected character";
+        desc++;
+        while (*desc == 'h' || *desc == 'v')
+            desc++;
+    }
+    if (*desc)
+        return "Game description longer than expected";
+
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Construct an initial game state, given a description and parameters.
+ */
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state;
+    int w, h, x, y;
+
+    assert(params->width > 0 && params->height > 0);
+    assert(params->width > 1 || params->height > 1);
+
+    /*
+     * Create a blank game state.
+     */
+    state = snew(game_state);
+    w = state->width = params->width;
+    h = state->height = params->height;
+    state->wrapping = params->wrapping;
+    state->last_rotate_dir = state->last_rotate_x = state->last_rotate_y = 0;
+    state->completed = state->used_solve = FALSE;
+    state->tiles = snewn(state->width * state->height, unsigned char);
+    memset(state->tiles, 0, state->width * state->height);
+    state->barriers = snewn(state->width * state->height, unsigned char);
+    memset(state->barriers, 0, state->width * state->height);
+
+    /*
+     * Parse the game description into the grid.
+     */
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            if (*desc >= '0' && *desc <= '9')
+                tile(state, x, y) = *desc - '0';
+            else if (*desc >= 'a' && *desc <= 'f')
+                tile(state, x, y) = *desc - 'a' + 10;
+            else if (*desc >= 'A' && *desc <= 'F')
+                tile(state, x, y) = *desc - 'A' + 10;
+            if (*desc)
+                desc++;
+            while (*desc == 'h' || *desc == 'v') {
+                int x2, y2, d1, d2;
+                if (*desc == 'v')
+                    d1 = R;
+                else
+                    d1 = D;
+
+                OFFSET(x2, y2, x, y, d1, state);
+                d2 = F(d1);
+
+                barrier(state, x, y) |= d1;
+                barrier(state, x2, y2) |= d2;
+
+                desc++;
+            }
+        }
+    }
+
+    /*
+     * Set up border barriers if this is a non-wrapping game.
+     */
+    if (!state->wrapping) {
+        for (x = 0; x < state->width; x++) {
+            barrier(state, x, 0) |= U;
+            barrier(state, x, state->height-1) |= D;
+        }
+        for (y = 0; y < state->height; y++) {
+            barrier(state, 0, y) |= L;
+            barrier(state, state->width-1, y) |= R;
+        }
+    } else {
+        /*
+         * We check whether this is de-facto a non-wrapping game
+         * despite the parameters, in case we were passed the
+         * description of a non-wrapping game. This is so that we
+         * can change some aspects of the UI behaviour.
+         */
+        state->wrapping = FALSE;
+        for (x = 0; x < state->width; x++)
+            if (!(barrier(state, x, 0) & U) ||
+                !(barrier(state, x, state->height-1) & D))
+                state->wrapping = TRUE;
+        for (y = 0; y < state->height; y++)
+            if (!(barrier(state, 0, y) & L) ||
+                !(barrier(state, state->width-1, y) & R))
+                state->wrapping = TRUE;
+    }
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret;
+
+    ret = snew(game_state);
+    ret->width = state->width;
+    ret->height = state->height;
+    ret->wrapping = state->wrapping;
+    ret->completed = state->completed;
+    ret->used_solve = state->used_solve;
+    ret->last_rotate_dir = state->last_rotate_dir;
+    ret->last_rotate_x = state->last_rotate_x;
+    ret->last_rotate_y = state->last_rotate_y;
+    ret->tiles = snewn(state->width * state->height, unsigned char);
+    memcpy(ret->tiles, state->tiles, state->width * state->height);
+    ret->barriers = snewn(state->width * state->height, unsigned char);
+    memcpy(ret->barriers, state->barriers, state->width * state->height);
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->tiles);
+    sfree(state->barriers);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    unsigned char *tiles;
+    char *ret;
+    int retlen, retsize;
+    int i;
+
+    tiles = snewn(state->width * state->height, unsigned char);
+
+    if (!aux) {
+        /*
+         * Run the internal solver on the provided grid. This might
+         * not yield a complete solution.
+         */
+        memcpy(tiles, state->tiles, state->width * state->height);
+        net_solver(state->width, state->height, tiles,
+                   state->barriers, state->wrapping);
+    } else {
+        for (i = 0; i < state->width * state->height; i++) {
+            int c = aux[i];
+
+            if (c >= '0' && c <= '9')
+                tiles[i] = c - '0';
+            else if (c >= 'a' && c <= 'f')
+                tiles[i] = c - 'a' + 10;
+            else if (c >= 'A' && c <= 'F')
+                tiles[i] = c - 'A' + 10;
+
+            tiles[i] |= LOCKED;
+        }
+    }
+
+    /*
+     * Now construct a string which can be passed to execute_move()
+     * to transform the current grid into the solved one.
+     */
+    retsize = 256;
+    ret = snewn(retsize, char);
+    retlen = 0;
+    ret[retlen++] = 'S';
+
+    for (i = 0; i < state->width * state->height; i++) {
+        int from = currstate->tiles[i], to = tiles[i];
+        int ft = from & (R|L|U|D), tt = to & (R|L|U|D);
+        int x = i % state->width, y = i / state->width;
+        int chr = '\0';
+        char buf[80], *p = buf;
+
+        if (from == to)
+            continue;                  /* nothing needs doing at all */
+
+        /*
+         * To transform this tile into the desired tile: first
+         * unlock the tile if it's locked, then rotate it if
+         * necessary, then lock it if necessary.
+         */
+        if (from & LOCKED)
+            p += sprintf(p, ";L%d,%d", x, y);
+
+        if (tt == A(ft))
+            chr = 'A';
+        else if (tt == C(ft))
+            chr = 'C';
+        else if (tt == F(ft))
+            chr = 'F';
+        else {
+            assert(tt == ft);
+            chr = '\0';
+        }
+        if (chr)
+            p += sprintf(p, ";%c%d,%d", chr, x, y);
+
+        if (to & LOCKED)
+            p += sprintf(p, ";L%d,%d", x, y);
+
+        if (p > buf) {
+            if (retlen + (p - buf) >= retsize) {
+                retsize = retlen + (p - buf) + 512;
+                ret = sresize(ret, retsize, char);
+            }
+            memcpy(ret+retlen, buf, p - buf);
+            retlen += p - buf;
+        }
+    }
+
+    assert(retlen < retsize);
+    ret[retlen] = '\0';
+    ret = sresize(ret, retlen+1, char);
+
+    sfree(tiles);
+
+    return ret;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Utility routine.
+ */
+
+/*
+ * Compute which squares are reachable from the centre square, as a
+ * quick visual aid to determining how close the game is to
+ * completion. This is also a simple way to tell if the game _is_
+ * completed - just call this function and see whether every square
+ * is marked active.
+ */
+static unsigned char *compute_active(const game_state *state, int cx, int cy)
+{
+    unsigned char *active;
+    tree234 *todo;
+    struct xyd *xyd;
+
+    active = snewn(state->width * state->height, unsigned char);
+    memset(active, 0, state->width * state->height);
+
+    /*
+     * We only store (x,y) pairs in todo, but it's easier to reuse
+     * xyd_cmp and just store direction 0 every time.
+     */
+    todo = newtree234(xyd_cmp_nc);
+    index(state, active, cx, cy) = ACTIVE;
+    add234(todo, new_xyd(cx, cy, 0));
+
+    while ( (xyd = delpos234(todo, 0)) != NULL) {
+        int x1, y1, d1, x2, y2, d2;
+
+        x1 = xyd->x;
+        y1 = xyd->y;
+        sfree(xyd);
+
+        for (d1 = 1; d1 < 0x10; d1 <<= 1) {
+            OFFSET(x2, y2, x1, y1, d1, state);
+            d2 = F(d1);
+
+            /*
+             * If the next tile in this direction is connected to
+             * us, and there isn't a barrier in the way, and it
+             * isn't already marked active, then mark it active and
+             * add it to the to-examine list.
+             */
+            if ((tile(state, x1, y1) & d1) &&
+                (tile(state, x2, y2) & d2) &&
+                !(barrier(state, x1, y1) & d1) &&
+                !index(state, active, x2, y2)) {
+                index(state, active, x2, y2) = ACTIVE;
+                add234(todo, new_xyd(x2, y2, 0));
+            }
+        }
+    }
+    /* Now we expect the todo list to have shrunk to zero size. */
+    assert(count234(todo) == 0);
+    freetree234(todo);
+
+    return active;
+}
+
+struct net_neighbour_ctx {
+    int w, h;
+    const unsigned char *tiles, *barriers;
+    int i, n, neighbours[4];
+};
+static int net_neighbour(int vertex, void *vctx)
+{
+    struct net_neighbour_ctx *ctx = (struct net_neighbour_ctx *)vctx;
+
+    if (vertex >= 0) {
+        int x = vertex % ctx->w, y = vertex / ctx->w;
+        int tile, dir, x1, y1, v1;
+
+        ctx->i = ctx->n = 0;
+
+        tile = ctx->tiles[vertex];
+        if (ctx->barriers)
+            tile &= ~ctx->barriers[vertex];
+
+        for (dir = 1; dir < 0x10; dir <<= 1) {
+            if (!(tile & dir))
+                continue;
+            OFFSETWH(x1, y1, x, y, dir, ctx->w, ctx->h);
+            v1 = y1 * ctx->w + x1;
+            if (ctx->tiles[v1] & F(dir))
+                ctx->neighbours[ctx->n++] = v1;
+        }
+    }
+
+    if (ctx->i < ctx->n)
+        return ctx->neighbours[ctx->i++];
+    else
+        return -1;
+}
+
+static int *compute_loops_inner(int w, int h, int wrapping,
+                                const unsigned char *tiles,
+                                const unsigned char *barriers)
+{
+    struct net_neighbour_ctx ctx;
+    struct findloopstate *fls;
+    int *loops;
+    int x, y;
+
+    fls = findloop_new_state(w*h);
+    ctx.w = w;
+    ctx.h = h;
+    ctx.tiles = tiles;
+    ctx.barriers = barriers;
+    findloop_run(fls, w*h, net_neighbour, &ctx);
+
+    loops = snewn(w*h, int);
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            int x1, y1, dir;
+            int flags = 0;
+
+            for (dir = 1; dir < 0x10; dir <<= 1) {
+                if ((tiles[y*w+x] & dir) &&
+                    !(barriers && (barriers[y*w+x] & dir))) {
+                    OFFSETWH(x1, y1, x, y, dir, w, h);
+                    if ((tiles[y1*w+x1] & F(dir)) &&
+                        findloop_is_loop_edge(fls, y*w+x, y1*w+x1))
+                        flags |= LOOP(dir);
+                }
+            }
+            loops[y*w+x] = flags;
+        }
+    }
+
+    findloop_free_state(fls);
+    return loops;
+}
+
+static int *compute_loops(const game_state *state)
+{
+    return compute_loops_inner(state->width, state->height, state->wrapping,
+                               state->tiles, state->barriers);
+}
+
+struct game_ui {
+    int org_x, org_y; /* origin */
+    int cx, cy;       /* source tile (game coordinates) */
+    int cur_x, cur_y;
+    int cur_visible;
+    random_state *rs; /* used for jumbling */
+#ifdef USE_DRAGGING
+    int dragtilex, dragtiley, dragstartx, dragstarty, dragged;
+#endif
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    void *seed;
+    int seedsize;
+    game_ui *ui = snew(game_ui);
+    ui->org_x = ui->org_y = 0;
+    ui->cur_x = ui->cx = state->width / 2;
+    ui->cur_y = ui->cy = state->height / 2;
+    ui->cur_visible = FALSE;
+    get_random_seed(&seed, &seedsize);
+    ui->rs = random_new(seed, seedsize);
+    sfree(seed);
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    random_free(ui->rs);
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    char buf[120];
+    /*
+     * We preserve the origin and centre-point coordinates over a
+     * serialise.
+     */
+    sprintf(buf, "O%d,%d;C%d,%d", ui->org_x, ui->org_y, ui->cx, ui->cy);
+    return dupstr(buf);
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+    sscanf(encoding, "O%d,%d;C%d,%d",
+           &ui->org_x, &ui->org_y, &ui->cx, &ui->cy);
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int started;
+    int width, height;
+    int org_x, org_y;
+    int tilesize;
+    int *visible;
+};
+
+/* ----------------------------------------------------------------------
+ * Process a move.
+ */
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    char *nullret;
+    int tx = -1, ty = -1, dir = 0;
+    int shift = button & MOD_SHFT, ctrl = button & MOD_CTRL;
+    enum {
+        NONE, ROTATE_LEFT, ROTATE_180, ROTATE_RIGHT, TOGGLE_LOCK, JUMBLE,
+        MOVE_ORIGIN, MOVE_SOURCE, MOVE_ORIGIN_AND_SOURCE, MOVE_CURSOR
+    } action;
+
+    button &= ~MOD_MASK;
+    nullret = NULL;
+    action = NONE;
+
+    if (button == LEFT_BUTTON ||
+        button == MIDDLE_BUTTON ||
+#ifdef USE_DRAGGING
+        button == LEFT_DRAG ||
+        button == LEFT_RELEASE ||
+        button == RIGHT_DRAG ||
+        button == RIGHT_RELEASE ||
+#endif
+        button == RIGHT_BUTTON) {
+
+        if (ui->cur_visible) {
+            ui->cur_visible = FALSE;
+            nullret = "";
+        }
+
+        /*
+         * The button must have been clicked on a valid tile.
+         */
+        x -= WINDOW_OFFSET + TILE_BORDER;
+        y -= WINDOW_OFFSET + TILE_BORDER;
+        if (x < 0 || y < 0)
+            return nullret;
+        tx = x / TILE_SIZE;
+        ty = y / TILE_SIZE;
+        if (tx >= state->width || ty >= state->height)
+            return nullret;
+        /* Transform from physical to game coords */
+        tx = (tx + ui->org_x) % state->width;
+        ty = (ty + ui->org_y) % state->height;
+        if (x % TILE_SIZE >= TILE_SIZE - TILE_BORDER ||
+            y % TILE_SIZE >= TILE_SIZE - TILE_BORDER)
+            return nullret;
+
+#ifdef USE_DRAGGING
+
+        if (button == MIDDLE_BUTTON
+#ifdef STYLUS_BASED
+            || button == RIGHT_BUTTON  /* with a stylus, `right-click' locks */
+#endif
+            ) {
+            /*
+             * Middle button never drags: it only toggles the lock.
+             */
+            action = TOGGLE_LOCK;
+        } else if (button == LEFT_BUTTON
+#ifndef STYLUS_BASED
+                   || button == RIGHT_BUTTON /* (see above) */
+#endif
+                  ) {
+            /*
+             * Otherwise, we note down the start point for a drag.
+             */
+            ui->dragtilex = tx;
+            ui->dragtiley = ty;
+            ui->dragstartx = x % TILE_SIZE;
+            ui->dragstarty = y % TILE_SIZE;
+            ui->dragged = FALSE;
+            return nullret;            /* no actual action */
+        } else if (button == LEFT_DRAG
+#ifndef STYLUS_BASED
+                   || button == RIGHT_DRAG
+#endif
+                  ) {
+            /*
+             * Find the new drag point and see if it necessitates a
+             * rotation.
+             */
+            int x0,y0, xA,yA, xC,yC, xF,yF;
+            int mx, my;
+            int d0, dA, dC, dF, dmin;
+
+            tx = ui->dragtilex;
+            ty = ui->dragtiley;
+
+            mx = x - (ui->dragtilex * TILE_SIZE);
+            my = y - (ui->dragtiley * TILE_SIZE);
+
+            x0 = ui->dragstartx;
+            y0 = ui->dragstarty;
+            xA = ui->dragstarty;
+            yA = TILE_SIZE-1 - ui->dragstartx;
+            xF = TILE_SIZE-1 - ui->dragstartx;
+            yF = TILE_SIZE-1 - ui->dragstarty;
+            xC = TILE_SIZE-1 - ui->dragstarty;
+            yC = ui->dragstartx;
+
+            d0 = (mx-x0)*(mx-x0) + (my-y0)*(my-y0);
+            dA = (mx-xA)*(mx-xA) + (my-yA)*(my-yA);
+            dF = (mx-xF)*(mx-xF) + (my-yF)*(my-yF);
+            dC = (mx-xC)*(mx-xC) + (my-yC)*(my-yC);
+
+            dmin = min(min(d0,dA),min(dF,dC));
+
+            if (d0 == dmin) {
+                return nullret;
+            } else if (dF == dmin) {
+                action = ROTATE_180;
+                ui->dragstartx = xF;
+                ui->dragstarty = yF;
+                ui->dragged = TRUE;
+            } else if (dA == dmin) {
+                action = ROTATE_LEFT;
+                ui->dragstartx = xA;
+                ui->dragstarty = yA;
+                ui->dragged = TRUE;
+            } else /* dC == dmin */ {
+                action = ROTATE_RIGHT;
+                ui->dragstartx = xC;
+                ui->dragstarty = yC;
+                ui->dragged = TRUE;
+            }
+        } else if (button == LEFT_RELEASE
+#ifndef STYLUS_BASED
+                   || button == RIGHT_RELEASE
+#endif
+                  ) {
+            if (!ui->dragged) {
+                /*
+                 * There was a click but no perceptible drag:
+                 * revert to single-click behaviour.
+                 */
+                tx = ui->dragtilex;
+                ty = ui->dragtiley;
+
+                if (button == LEFT_RELEASE)
+                    action = ROTATE_LEFT;
+                else
+                    action = ROTATE_RIGHT;
+            } else
+                return nullret;        /* no action */
+        }
+
+#else /* USE_DRAGGING */
+
+        action = (button == LEFT_BUTTON ? ROTATE_LEFT :
+                  button == RIGHT_BUTTON ? ROTATE_RIGHT : TOGGLE_LOCK);
+
+#endif /* USE_DRAGGING */
+
+    } else if (IS_CURSOR_MOVE(button)) {
+        switch (button) {
+          case CURSOR_UP:       dir = U; break;
+          case CURSOR_DOWN:     dir = D; break;
+          case CURSOR_LEFT:     dir = L; break;
+          case CURSOR_RIGHT:    dir = R; break;
+          default:              return nullret;
+        }
+        if (shift && ctrl) action = MOVE_ORIGIN_AND_SOURCE;
+        else if (shift)    action = MOVE_ORIGIN;
+        else if (ctrl)     action = MOVE_SOURCE;
+        else               action = MOVE_CURSOR;
+    } else if (button == 'a' || button == 's' || button == 'd' ||
+               button == 'A' || button == 'S' || button == 'D' ||
+               button == 'f' || button == 'F' ||
+               IS_CURSOR_SELECT(button)) {
+        tx = ui->cur_x;
+        ty = ui->cur_y;
+        if (button == 'a' || button == 'A' || button == CURSOR_SELECT)
+            action = ROTATE_LEFT;
+        else if (button == 's' || button == 'S' || button == CURSOR_SELECT2)
+            action = TOGGLE_LOCK;
+        else if (button == 'd' || button == 'D')
+            action = ROTATE_RIGHT;
+        else if (button == 'f' || button == 'F')
+            action = ROTATE_180;
+        ui->cur_visible = TRUE;
+    } else if (button == 'j' || button == 'J') {
+        /* XXX should we have some mouse control for this? */
+        action = JUMBLE;
+    } else
+        return nullret;
+
+    /*
+     * The middle button locks or unlocks a tile. (A locked tile
+     * cannot be turned, and is visually marked as being locked.
+     * This is a convenience for the player, so that once they are
+     * sure which way round a tile goes, they can lock it and thus
+     * avoid forgetting later on that they'd already done that one;
+     * and the locking also prevents them turning the tile by
+     * accident. If they change their mind, another middle click
+     * unlocks it.)
+     */
+    if (action == TOGGLE_LOCK) {
+        char buf[80];
+        sprintf(buf, "L%d,%d", tx, ty);
+        return dupstr(buf);
+    } else if (action == ROTATE_LEFT || action == ROTATE_RIGHT ||
+               action == ROTATE_180) {
+        char buf[80];
+
+        /*
+         * The left and right buttons have no effect if clicked on a
+         * locked tile.
+         */
+        if (tile(state, tx, ty) & LOCKED)
+            return nullret;
+
+        /*
+         * Otherwise, turn the tile one way or the other. Left button
+         * turns anticlockwise; right button turns clockwise.
+         */
+        sprintf(buf, "%c%d,%d", (int)(action == ROTATE_LEFT ? 'A' :
+                                      action == ROTATE_RIGHT ? 'C' : 'F'), tx, ty);
+        return dupstr(buf);
+    } else if (action == JUMBLE) {
+        /*
+         * Jumble all unlocked tiles to random orientations.
+         */
+
+        int jx, jy, maxlen;
+        char *ret, *p;
+
+        /*
+         * Maximum string length assumes no int can be converted to
+         * decimal and take more than 11 digits!
+         */
+        maxlen = state->width * state->height * 25 + 3;
+
+        ret = snewn(maxlen, char);
+        p = ret;
+        *p++ = 'J';
+
+        for (jy = 0; jy < state->height; jy++) {
+            for (jx = 0; jx < state->width; jx++) {
+                if (!(tile(state, jx, jy) & LOCKED)) {
+                    int rot = random_upto(ui->rs, 4);
+                    if (rot) {
+                        p += sprintf(p, ";%c%d,%d", "AFC"[rot-1], jx, jy);
+                    }
+                }
+            }
+        }
+        *p++ = '\0';
+        assert(p - ret < maxlen);
+        ret = sresize(ret, p - ret, char);
+
+        return ret;
+    } else if (action == MOVE_ORIGIN || action == MOVE_SOURCE ||
+               action == MOVE_ORIGIN_AND_SOURCE || action == MOVE_CURSOR) {
+        assert(dir != 0);
+        if (action == MOVE_ORIGIN || action == MOVE_ORIGIN_AND_SOURCE) {
+            if (state->wrapping) {
+                 OFFSET(ui->org_x, ui->org_y, ui->org_x, ui->org_y, dir, state);
+            } else return nullret; /* disallowed for non-wrapping grids */
+        }
+        if (action == MOVE_SOURCE || action == MOVE_ORIGIN_AND_SOURCE) {
+            OFFSET(ui->cx, ui->cy, ui->cx, ui->cy, dir, state);
+        }
+        if (action == MOVE_CURSOR) {
+            OFFSET(ui->cur_x, ui->cur_y, ui->cur_x, ui->cur_y, dir, state);
+            ui->cur_visible = TRUE;
+        }
+        return "";
+    } else {
+        return NULL;
+    }
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    game_state *ret;
+    int tx = -1, ty = -1, n, noanim, orig;
+
+    ret = dup_game(from);
+
+    if (move[0] == 'J' || move[0] == 'S') {
+        if (move[0] == 'S')
+            ret->used_solve = TRUE;
+
+        move++;
+        if (*move == ';')
+            move++;
+        noanim = TRUE;
+    } else
+        noanim = FALSE;
+
+    ret->last_rotate_dir = 0;          /* suppress animation */
+    ret->last_rotate_x = ret->last_rotate_y = 0;
+
+    while (*move) {
+        if ((move[0] == 'A' || move[0] == 'C' ||
+             move[0] == 'F' || move[0] == 'L') &&
+            sscanf(move+1, "%d,%d%n", &tx, &ty, &n) >= 2 &&
+            tx >= 0 && tx < from->width && ty >= 0 && ty < from->height) {
+            orig = tile(ret, tx, ty);
+            if (move[0] == 'A') {
+                tile(ret, tx, ty) = A(orig);
+                if (!noanim)
+                    ret->last_rotate_dir = +1;
+            } else if (move[0] == 'F') {
+                tile(ret, tx, ty) = F(orig);
+                if (!noanim)
+                    ret->last_rotate_dir = +2; /* + for sake of argument */
+            } else if (move[0] == 'C') {
+                tile(ret, tx, ty) = C(orig);
+                if (!noanim)
+                    ret->last_rotate_dir = -1;
+            } else {
+                assert(move[0] == 'L');
+                tile(ret, tx, ty) ^= LOCKED;
+            }
+
+            move += 1 + n;
+            if (*move == ';') move++;
+        } else {
+            free_game(ret);
+            return NULL;
+        }
+    }
+    if (!noanim) {
+        if (tx == -1 || ty == -1) { free_game(ret); return NULL; }
+        ret->last_rotate_x = tx;
+        ret->last_rotate_y = ty;
+    }
+
+    /*
+     * Check whether the game has been completed.
+     * 
+     * For this purpose it doesn't matter where the source square
+     * is, because we can start from anywhere and correctly
+     * determine whether the game is completed.
+     */
+    {
+        unsigned char *active = compute_active(ret, 0, 0);
+        int x1, y1;
+        int complete = TRUE;
+
+        for (x1 = 0; x1 < ret->width; x1++)
+            for (y1 = 0; y1 < ret->height; y1++)
+                if ((tile(ret, x1, y1) & 0xF) && !index(ret, active, x1, y1)) {
+                    complete = FALSE;
+                    goto break_label;  /* break out of two loops at once */
+                }
+        break_label:
+
+        sfree(active);
+
+        if (complete)
+            ret->completed = TRUE;
+    }
+
+    return ret;
+}
+
+
+/* ----------------------------------------------------------------------
+ * Routines for drawing the game position on the screen.
+ */
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    game_drawstate *ds = snew(game_drawstate);
+    int i;
+
+    ds->started = FALSE;
+    ds->width = state->width;
+    ds->height = state->height;
+    ds->org_x = ds->org_y = -1;
+    ds->visible = snewn(state->width * state->height, int);
+    ds->tilesize = 0;                  /* undecided yet */
+    for (i = 0; i < state->width * state->height; i++)
+        ds->visible[i] = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->visible);
+    sfree(ds);
+}
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    *x = WINDOW_OFFSET * 2 + tilesize * params->width + TILE_BORDER;
+    *y = WINDOW_OFFSET * 2 + tilesize * params->height + TILE_BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret;
+
+    ret = snewn(NCOLOURS * 3, float);
+    *ncolours = NCOLOURS;
+
+    /*
+     * Basic background colour is whatever the front end thinks is
+     * a sensible default.
+     */
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    /*
+     * Wires are black.
+     */
+    ret[COL_WIRE * 3 + 0] = 0.0F;
+    ret[COL_WIRE * 3 + 1] = 0.0F;
+    ret[COL_WIRE * 3 + 2] = 0.0F;
+
+    /*
+     * Powered wires and powered endpoints are cyan.
+     */
+    ret[COL_POWERED * 3 + 0] = 0.0F;
+    ret[COL_POWERED * 3 + 1] = 1.0F;
+    ret[COL_POWERED * 3 + 2] = 1.0F;
+
+    /*
+     * Barriers are red.
+     */
+    ret[COL_BARRIER * 3 + 0] = 1.0F;
+    ret[COL_BARRIER * 3 + 1] = 0.0F;
+    ret[COL_BARRIER * 3 + 2] = 0.0F;
+
+    /*
+     * Highlighted loops are red as well.
+     */
+    ret[COL_LOOP * 3 + 0] = 1.0F;
+    ret[COL_LOOP * 3 + 1] = 0.0F;
+    ret[COL_LOOP * 3 + 2] = 0.0F;
+
+    /*
+     * Unpowered endpoints are blue.
+     */
+    ret[COL_ENDPOINT * 3 + 0] = 0.0F;
+    ret[COL_ENDPOINT * 3 + 1] = 0.0F;
+    ret[COL_ENDPOINT * 3 + 2] = 1.0F;
+
+    /*
+     * Tile borders are a darker grey than the background.
+     */
+    ret[COL_BORDER * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_BORDER * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_BORDER * 3 + 2] = 0.5F * ret[COL_BACKGROUND * 3 + 2];
+
+    /*
+     * Locked tiles are a grey in between those two.
+     */
+    ret[COL_LOCKED * 3 + 0] = 0.75F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_LOCKED * 3 + 1] = 0.75F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_LOCKED * 3 + 2] = 0.75F * ret[COL_BACKGROUND * 3 + 2];
+
+    return ret;
+}
+
+static void draw_filled_line(drawing *dr, int x1, int y1, int x2, int y2,
+                             int colour)
+{
+    draw_line(dr, x1-1, y1, x2-1, y2, COL_WIRE);
+    draw_line(dr, x1+1, y1, x2+1, y2, COL_WIRE);
+    draw_line(dr, x1, y1-1, x2, y2-1, COL_WIRE);
+    draw_line(dr, x1, y1+1, x2, y2+1, COL_WIRE);
+    draw_line(dr, x1, y1, x2, y2, colour);
+}
+
+static void draw_rect_coords(drawing *dr, int x1, int y1, int x2, int y2,
+                             int colour)
+{
+    int mx = (x1 < x2 ? x1 : x2);
+    int my = (y1 < y2 ? y1 : y2);
+    int dx = (x2 + x1 - 2*mx + 1);
+    int dy = (y2 + y1 - 2*my + 1);
+
+    draw_rect(dr, mx, my, dx, dy, colour);
+}
+
+/*
+ * draw_barrier_corner() and draw_barrier() are passed physical coords
+ */
+static void draw_barrier_corner(drawing *dr, game_drawstate *ds,
+                                int x, int y, int dx, int dy, int phase)
+{
+    int bx = WINDOW_OFFSET + TILE_SIZE * x;
+    int by = WINDOW_OFFSET + TILE_SIZE * y;
+    int x1, y1;
+
+    x1 = (dx > 0 ? TILE_SIZE+TILE_BORDER-1 : 0);
+    y1 = (dy > 0 ? TILE_SIZE+TILE_BORDER-1 : 0);
+
+    if (phase == 0) {
+        draw_rect_coords(dr, bx+x1+dx, by+y1,
+                         bx+x1-TILE_BORDER*dx, by+y1-(TILE_BORDER-1)*dy,
+                         COL_WIRE);
+        draw_rect_coords(dr, bx+x1, by+y1+dy,
+                         bx+x1-(TILE_BORDER-1)*dx, by+y1-TILE_BORDER*dy,
+                         COL_WIRE);
+    } else {
+        draw_rect_coords(dr, bx+x1, by+y1,
+                         bx+x1-(TILE_BORDER-1)*dx, by+y1-(TILE_BORDER-1)*dy,
+                         COL_BARRIER);
+    }
+}
+
+static void draw_barrier(drawing *dr, game_drawstate *ds,
+                         int x, int y, int dir, int phase)
+{
+    int bx = WINDOW_OFFSET + TILE_SIZE * x;
+    int by = WINDOW_OFFSET + TILE_SIZE * y;
+    int x1, y1, w, h;
+
+    x1 = (X(dir) > 0 ? TILE_SIZE : X(dir) == 0 ? TILE_BORDER : 0);
+    y1 = (Y(dir) > 0 ? TILE_SIZE : Y(dir) == 0 ? TILE_BORDER : 0);
+    w = (X(dir) ? TILE_BORDER : TILE_SIZE - TILE_BORDER);
+    h = (Y(dir) ? TILE_BORDER : TILE_SIZE - TILE_BORDER);
+
+    if (phase == 0) {
+        draw_rect(dr, bx+x1-X(dir), by+y1-Y(dir), w, h, COL_WIRE);
+    } else {
+        draw_rect(dr, bx+x1, by+y1, w, h, COL_BARRIER);
+    }
+}
+
+/*
+ * draw_tile() is passed physical coordinates
+ */
+static void draw_tile(drawing *dr, const game_state *state, game_drawstate *ds,
+                      int x, int y, int tile, int src, float angle, int cursor)
+{
+    int bx = WINDOW_OFFSET + TILE_SIZE * x;
+    int by = WINDOW_OFFSET + TILE_SIZE * y;
+    float matrix[4];
+    float cx, cy, ex, ey, tx, ty;
+    int dir, col, phase;
+
+    /*
+     * When we draw a single tile, we must draw everything up to
+     * and including the borders around the tile. This means that
+     * if the neighbouring tiles have connections to those borders,
+     * we must draw those connections on the borders themselves.
+     */
+
+    clip(dr, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER);
+
+    /*
+     * So. First blank the tile out completely: draw a big
+     * rectangle in border colour, and a smaller rectangle in
+     * background colour to fill it in.
+     */
+    draw_rect(dr, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER,
+              COL_BORDER);
+    draw_rect(dr, bx+TILE_BORDER, by+TILE_BORDER,
+              TILE_SIZE-TILE_BORDER, TILE_SIZE-TILE_BORDER,
+              tile & LOCKED ? COL_LOCKED : COL_BACKGROUND);
+
+    /*
+     * Draw an inset outline rectangle as a cursor, in whichever of
+     * COL_LOCKED and COL_BACKGROUND we aren't currently drawing
+     * in.
+     */
+    if (cursor) {
+        draw_line(dr, bx+TILE_SIZE/8, by+TILE_SIZE/8,
+                  bx+TILE_SIZE/8, by+TILE_SIZE-TILE_SIZE/8,
+                  tile & LOCKED ? COL_BACKGROUND : COL_LOCKED);
+        draw_line(dr, bx+TILE_SIZE/8, by+TILE_SIZE/8,
+                  bx+TILE_SIZE-TILE_SIZE/8, by+TILE_SIZE/8,
+                  tile & LOCKED ? COL_BACKGROUND : COL_LOCKED);
+        draw_line(dr, bx+TILE_SIZE-TILE_SIZE/8, by+TILE_SIZE/8,
+                  bx+TILE_SIZE-TILE_SIZE/8, by+TILE_SIZE-TILE_SIZE/8,
+                  tile & LOCKED ? COL_BACKGROUND : COL_LOCKED);
+        draw_line(dr, bx+TILE_SIZE/8, by+TILE_SIZE-TILE_SIZE/8,
+                  bx+TILE_SIZE-TILE_SIZE/8, by+TILE_SIZE-TILE_SIZE/8,
+                  tile & LOCKED ? COL_BACKGROUND : COL_LOCKED);
+    }
+
+    /*
+     * Set up the rotation matrix.
+     */
+    matrix[0] = (float)cos(angle * PI / 180.0);
+    matrix[1] = (float)-sin(angle * PI / 180.0);
+    matrix[2] = (float)sin(angle * PI / 180.0);
+    matrix[3] = (float)cos(angle * PI / 180.0);
+
+    /*
+     * Draw the wires.
+     */
+    cx = cy = TILE_BORDER + (TILE_SIZE-TILE_BORDER) / 2.0F - 0.5F;
+    col = (tile & ACTIVE ? COL_POWERED : COL_WIRE);
+    for (dir = 1; dir < 0x10; dir <<= 1) {
+        if (tile & dir) {
+            ex = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * X(dir);
+            ey = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * Y(dir);
+            MATMUL(tx, ty, matrix, ex, ey);
+            draw_filled_line(dr, bx+(int)cx, by+(int)cy,
+                             bx+(int)(cx+tx), by+(int)(cy+ty),
+                             COL_WIRE);
+        }
+    }
+    for (dir = 1; dir < 0x10; dir <<= 1) {
+        if (tile & dir) {
+            ex = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * X(dir);
+            ey = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * Y(dir);
+            MATMUL(tx, ty, matrix, ex, ey);
+            draw_line(dr, bx+(int)cx, by+(int)cy,
+                      bx+(int)(cx+tx), by+(int)(cy+ty),
+                      (tile & LOOP(dir)) ? COL_LOOP : col);
+        }
+    }
+    /* If we've drawn any loop-highlighted arms, make sure the centre
+     * point is loop-coloured rather than a later arm overwriting it. */
+    if (tile & (RLOOP | ULOOP | LLOOP | DLOOP))
+        draw_rect(dr, bx+(int)cx, by+(int)cy, 1, 1, COL_LOOP);
+
+    /*
+     * Draw the box in the middle. We do this in blue if the tile
+     * is an unpowered endpoint, in cyan if the tile is a powered
+     * endpoint, in black if the tile is the centrepiece, and
+     * otherwise not at all.
+     */
+    col = -1;
+    if (src)
+        col = COL_WIRE;
+    else if (COUNT(tile) == 1) {
+        col = (tile & ACTIVE ? COL_POWERED : COL_ENDPOINT);
+    }
+    if (col >= 0) {
+        int i, points[8];
+
+        points[0] = +1; points[1] = +1;
+        points[2] = +1; points[3] = -1;
+        points[4] = -1; points[5] = -1;
+        points[6] = -1; points[7] = +1;
+
+        for (i = 0; i < 8; i += 2) {
+            ex = (TILE_SIZE * 0.24F) * points[i];
+            ey = (TILE_SIZE * 0.24F) * points[i+1];
+            MATMUL(tx, ty, matrix, ex, ey);
+            points[i] = bx+(int)(cx+tx);
+            points[i+1] = by+(int)(cy+ty);
+        }
+
+        draw_polygon(dr, points, 4, col, COL_WIRE);
+    }
+
+    /*
+     * Draw the points on the border if other tiles are connected
+     * to us.
+     */
+    for (dir = 1; dir < 0x10; dir <<= 1) {
+        int dx, dy, px, py, lx, ly, vx, vy, ox, oy;
+
+        dx = X(dir);
+        dy = Y(dir);
+
+        ox = x + dx;
+        oy = y + dy;
+
+        if (ox < 0 || ox >= state->width || oy < 0 || oy >= state->height)
+            continue;
+
+        if (!(tile(state, GX(ox), GY(oy)) & F(dir)))
+            continue;
+
+        px = bx + (int)(dx>0 ? TILE_SIZE + TILE_BORDER - 1 : dx<0 ? 0 : cx);
+        py = by + (int)(dy>0 ? TILE_SIZE + TILE_BORDER - 1 : dy<0 ? 0 : cy);
+        lx = dx * (TILE_BORDER-1);
+        ly = dy * (TILE_BORDER-1);
+        vx = (dy ? 1 : 0);
+        vy = (dx ? 1 : 0);
+
+        if (angle == 0.0 && (tile & dir)) {
+            /*
+             * If we are fully connected to the other tile, we must
+             * draw right across the tile border. (We can use our
+             * own ACTIVE state to determine what colour to do this
+             * in: if we are fully connected to the other tile then
+             * the two ACTIVE states will be the same.)
+             */
+            draw_rect_coords(dr, px-vx, py-vy, px+lx+vx, py+ly+vy, COL_WIRE);
+            draw_rect_coords(dr, px, py, px+lx, py+ly,
+                             ((tile & LOOP(dir)) ? COL_LOOP :
+                              (tile & ACTIVE) ? COL_POWERED :
+                              COL_WIRE));
+        } else {
+            /*
+             * The other tile extends into our border, but isn't
+             * actually connected to us. Just draw a single black
+             * dot.
+             */
+            draw_rect_coords(dr, px, py, px, py, COL_WIRE);
+        }
+    }
+
+    /*
+     * Draw barrier corners, and then barriers.
+     */
+    for (phase = 0; phase < 2; phase++) {
+        for (dir = 1; dir < 0x10; dir <<= 1) {
+            int x1, y1, corner = FALSE;
+            /*
+             * If at least one barrier terminates at the corner
+             * between dir and A(dir), draw a barrier corner.
+             */
+            if (barrier(state, GX(x), GY(y)) & (dir | A(dir))) {
+                corner = TRUE;
+            } else {
+                /*
+                 * Only count barriers terminating at this corner
+                 * if they're physically next to the corner. (That
+                 * is, if they've wrapped round from the far side
+                 * of the screen, they don't count.)
+                 */
+                x1 = x + X(dir);
+                y1 = y + Y(dir);
+                if (x1 >= 0 && x1 < state->width &&
+                    y1 >= 0 && y1 < state->height &&
+                    (barrier(state, GX(x1), GY(y1)) & A(dir))) {
+                    corner = TRUE;
+                } else {
+                    x1 = x + X(A(dir));
+                    y1 = y + Y(A(dir));
+                    if (x1 >= 0 && x1 < state->width &&
+                        y1 >= 0 && y1 < state->height &&
+                        (barrier(state, GX(x1), GY(y1)) & dir))
+                        corner = TRUE;
+                }
+            }
+
+            if (corner) {
+                /*
+                 * At least one barrier terminates here. Draw a
+                 * corner.
+                 */
+                draw_barrier_corner(dr, ds, x, y,
+                                    X(dir)+X(A(dir)), Y(dir)+Y(A(dir)),
+                                    phase);
+            }
+        }
+
+        for (dir = 1; dir < 0x10; dir <<= 1)
+            if (barrier(state, GX(x), GY(y)) & dir)
+                draw_barrier(dr, ds, x, y, dir, phase);
+    }
+
+    unclip(dr);
+
+    draw_update(dr, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float t, float ft)
+{
+    int x, y, tx, ty, frame, last_rotate_dir, moved_origin = FALSE;
+    unsigned char *active;
+    int *loops;
+    float angle = 0.0;
+
+    /*
+     * Clear the screen, and draw the exterior barrier lines, if
+     * this is our first call or if the origin has changed.
+     */
+    if (!ds->started || ui->org_x != ds->org_x || ui->org_y != ds->org_y) {
+        int phase;
+
+        ds->started = TRUE;
+
+        draw_rect(dr, 0, 0, 
+                  WINDOW_OFFSET * 2 + TILE_SIZE * state->width + TILE_BORDER,
+                  WINDOW_OFFSET * 2 + TILE_SIZE * state->height + TILE_BORDER,
+                  COL_BACKGROUND);
+
+        ds->org_x = ui->org_x;
+        ds->org_y = ui->org_y;
+        moved_origin = TRUE;
+
+        draw_update(dr, 0, 0, 
+                    WINDOW_OFFSET*2 + TILE_SIZE*state->width + TILE_BORDER,
+                    WINDOW_OFFSET*2 + TILE_SIZE*state->height + TILE_BORDER);
+
+        for (phase = 0; phase < 2; phase++) {
+
+            for (x = 0; x < ds->width; x++) {
+                if (x+1 < ds->width) {
+                    if (barrier(state, GX(x), GY(0)) & R)
+                        draw_barrier_corner(dr, ds, x, -1, +1, +1, phase);
+                    if (barrier(state, GX(x), GY(ds->height-1)) & R)
+                        draw_barrier_corner(dr, ds, x, ds->height, +1, -1, phase);
+                }
+                if (barrier(state, GX(x), GY(0)) & U) {
+                    draw_barrier_corner(dr, ds, x, -1, -1, +1, phase);
+                    draw_barrier_corner(dr, ds, x, -1, +1, +1, phase);
+                    draw_barrier(dr, ds, x, -1, D, phase);
+                }
+                if (barrier(state, GX(x), GY(ds->height-1)) & D) {
+                    draw_barrier_corner(dr, ds, x, ds->height, -1, -1, phase);
+                    draw_barrier_corner(dr, ds, x, ds->height, +1, -1, phase);
+                    draw_barrier(dr, ds, x, ds->height, U, phase);
+                }
+            }
+
+            for (y = 0; y < ds->height; y++) {
+                if (y+1 < ds->height) {
+                    if (barrier(state, GX(0), GY(y)) & D)
+                        draw_barrier_corner(dr, ds, -1, y, +1, +1, phase);
+                    if (barrier(state, GX(ds->width-1), GY(y)) & D)
+                        draw_barrier_corner(dr, ds, ds->width, y, -1, +1, phase);
+                }
+                if (barrier(state, GX(0), GY(y)) & L) {
+                    draw_barrier_corner(dr, ds, -1, y, +1, -1, phase);
+                    draw_barrier_corner(dr, ds, -1, y, +1, +1, phase);
+                    draw_barrier(dr, ds, -1, y, R, phase);
+                }
+                if (barrier(state, GX(ds->width-1), GY(y)) & R) {
+                    draw_barrier_corner(dr, ds, ds->width, y, -1, -1, phase);
+                    draw_barrier_corner(dr, ds, ds->width, y, -1, +1, phase);
+                    draw_barrier(dr, ds, ds->width, y, L, phase);
+                }
+            }
+        }
+    }
+
+    tx = ty = -1;
+    last_rotate_dir = dir==-1 ? oldstate->last_rotate_dir :
+                                state->last_rotate_dir;
+    if (oldstate && (t < ROTATE_TIME) && last_rotate_dir) {
+        /*
+         * We're animating a single tile rotation. Find the turning
+         * tile.
+         */
+        tx = (dir==-1 ? oldstate->last_rotate_x : state->last_rotate_x);
+        ty = (dir==-1 ? oldstate->last_rotate_y : state->last_rotate_y);
+        angle = last_rotate_dir * dir * 90.0F * (t / ROTATE_TIME);
+        state = oldstate;
+    }
+
+    frame = -1;
+    if (ft > 0) {
+        /*
+         * We're animating a completion flash. Find which frame
+         * we're at.
+         */
+        frame = (int)(ft / FLASH_FRAME);
+    }
+
+    /*
+     * Draw any tile which differs from the way it was last drawn.
+     */
+    active = compute_active(state, ui->cx, ui->cy);
+    loops = compute_loops(state);
+
+    for (x = 0; x < ds->width; x++)
+        for (y = 0; y < ds->height; y++) {
+            int c = tile(state, GX(x), GY(y)) |
+                index(state, active, GX(x), GY(y)) |
+                index(state, loops, GX(x), GY(y));
+            int is_src = GX(x) == ui->cx && GY(y) == ui->cy;
+            int is_anim = GX(x) == tx && GY(y) == ty;
+            int is_cursor = ui->cur_visible &&
+                            GX(x) == ui->cur_x && GY(y) == ui->cur_y;
+
+            /*
+             * In a completion flash, we adjust the LOCKED bit
+             * depending on our distance from the centre point and
+             * the frame number.
+             */
+            if (frame >= 0) {
+                int rcx = RX(ui->cx), rcy = RY(ui->cy);
+                int xdist, ydist, dist;
+                xdist = (x < rcx ? rcx - x : x - rcx);
+                ydist = (y < rcy ? rcy - y : y - rcy);
+                dist = (xdist > ydist ? xdist : ydist);
+
+                if (frame >= dist && frame < dist+4) {
+                    int lock = (frame - dist) & 1;
+                    lock = lock ? LOCKED : 0;
+                    c = (c &~ LOCKED) | lock;
+                }
+            }
+
+            if (moved_origin ||
+                index(state, ds->visible, x, y) != c ||
+                index(state, ds->visible, x, y) == -1 ||
+                is_src || is_anim || is_cursor) {
+                draw_tile(dr, state, ds, x, y, c,
+                          is_src, (is_anim ? angle : 0.0F), is_cursor);
+                if (is_src || is_anim || is_cursor)
+                    index(state, ds->visible, x, y) = -1;
+                else
+                    index(state, ds->visible, x, y) = c;
+            }
+        }
+
+    /*
+     * Update the status bar.
+     */
+    {
+        char statusbuf[256];
+        int i, n, n2, a;
+
+        n = state->width * state->height;
+        for (i = a = n2 = 0; i < n; i++) {
+            if (active[i])
+                a++;
+            if (state->tiles[i] & 0xF)
+                n2++;
+        }
+
+        sprintf(statusbuf, "%sActive: %d/%d",
+                (state->used_solve ? "Auto-solved. " :
+                 state->completed ? "COMPLETED! " : ""), a, n2);
+
+        status_bar(dr, statusbuf);
+    }
+
+    sfree(active);
+    sfree(loops);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    int last_rotate_dir;
+
+    /*
+     * Don't animate if last_rotate_dir is zero.
+     */
+    last_rotate_dir = dir==-1 ? oldstate->last_rotate_dir :
+                                newstate->last_rotate_dir;
+    if (last_rotate_dir)
+        return ROTATE_TIME;
+
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    /*
+     * If the game has just been completed, we display a completion
+     * flash.
+     */
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->used_solve && !newstate->used_solve) {
+        int size = 0;
+        if (size < newstate->width)
+            size = newstate->width;
+        if (size < newstate->height)
+            size = newstate->height;
+        return FLASH_FRAME * (size+4);
+    }
+
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 8mm squares by default.
+     */
+    game_compute_size(params, 800, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void draw_diagram(drawing *dr, game_drawstate *ds, int x, int y,
+                         int topleft, int v, int drawlines, int ink)
+{
+    int tx, ty, cx, cy, r, br, k, thick;
+
+    tx = WINDOW_OFFSET + TILE_SIZE * x;
+    ty = WINDOW_OFFSET + TILE_SIZE * y;
+
+    /*
+     * Find our centre point.
+     */
+    if (topleft) {
+        cx = tx + (v & L ? TILE_SIZE / 4 : TILE_SIZE / 6);
+        cy = ty + (v & U ? TILE_SIZE / 4 : TILE_SIZE / 6);
+        r = TILE_SIZE / 8;
+        br = TILE_SIZE / 32;
+    } else {
+        cx = tx + TILE_SIZE / 2;
+        cy = ty + TILE_SIZE / 2;
+        r = TILE_SIZE / 2;
+        br = TILE_SIZE / 8;
+    }
+    thick = r / 20;
+
+    /*
+     * Draw the square block if we have an endpoint.
+     */
+    if (v == 1 || v == 2 || v == 4 || v == 8)
+        draw_rect(dr, cx - br, cy - br, br*2, br*2, ink);
+
+    /*
+     * Draw each radial line.
+     */
+    if (drawlines) {
+        for (k = 1; k < 16; k *= 2)
+            if (v & k) {
+                int x1 = min(cx, cx + (r-thick) * X(k));
+                int x2 = max(cx, cx + (r-thick) * X(k));
+                int y1 = min(cy, cy + (r-thick) * Y(k));
+                int y2 = max(cy, cy + (r-thick) * Y(k));
+                draw_rect(dr, x1 - thick, y1 - thick,
+                          (x2 - x1) + 2*thick, (y2 - y1) + 2*thick, ink);
+            }
+    }
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->width, h = state->height;
+    int ink = print_mono_colour(dr, 0);
+    int x, y;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    /*
+     * Border.
+     */
+    print_line_width(dr, TILE_SIZE / (state->wrapping ? 128 : 12));
+    draw_rect_outline(dr, WINDOW_OFFSET, WINDOW_OFFSET,
+                      TILE_SIZE * w, TILE_SIZE * h, ink);
+
+    /*
+     * Grid.
+     */
+    print_line_width(dr, TILE_SIZE / 128);
+    for (x = 1; x < w; x++)
+        draw_line(dr, WINDOW_OFFSET + TILE_SIZE * x, WINDOW_OFFSET,
+                  WINDOW_OFFSET + TILE_SIZE * x, WINDOW_OFFSET + TILE_SIZE * h,
+                  ink);
+    for (y = 1; y < h; y++)
+        draw_line(dr, WINDOW_OFFSET, WINDOW_OFFSET + TILE_SIZE * y,
+                  WINDOW_OFFSET + TILE_SIZE * w, WINDOW_OFFSET + TILE_SIZE * y,
+                  ink);
+
+    /*
+     * Barriers.
+     */
+    for (y = 0; y <= h; y++)
+        for (x = 0; x <= w; x++) {
+            int b = barrier(state, x % w, y % h);
+            if (x < w && (b & U))
+                draw_rect(dr, WINDOW_OFFSET + TILE_SIZE * x - TILE_SIZE/24,
+                          WINDOW_OFFSET + TILE_SIZE * y - TILE_SIZE/24,
+                          TILE_SIZE + TILE_SIZE/24 * 2, TILE_SIZE/24 * 2, ink);
+            if (y < h && (b & L))
+                draw_rect(dr, WINDOW_OFFSET + TILE_SIZE * x - TILE_SIZE/24,
+                          WINDOW_OFFSET + TILE_SIZE * y - TILE_SIZE/24,
+                          TILE_SIZE/24 * 2, TILE_SIZE + TILE_SIZE/24 * 2, ink);
+        }
+
+    /*
+     * Grid contents.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int vx, v = tile(state, x, y);
+            int locked = v & LOCKED;
+
+            v &= 0xF;
+
+            /*
+             * Rotate into a standard orientation for the top left
+             * corner diagram.
+             */
+            vx = v;
+            while (vx != 0 && vx != 15 && vx != 1 && vx != 9 && vx != 13 &&
+                   vx != 5)
+                vx = A(vx);
+
+            /*
+             * Draw the top left corner diagram.
+             */
+            draw_diagram(dr, ds, x, y, TRUE, vx, TRUE, ink);
+
+            /*
+             * Draw the real solution diagram, if we're doing so.
+             */
+            draw_diagram(dr, ds, x, y, FALSE, v, locked, ink);
+        }
+}
+
+#ifdef COMBINED
+#define thegame net
+#endif
+
+const struct game thegame = {
+    "Net", "games.net", "net",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
diff --git a/apps/plugins/puzzles/netslide.R b/apps/plugins/puzzles/netslide.R
new file mode 100644
index 0000000000..ecfe7c3df8
--- /dev/null
+++ b/apps/plugins/puzzles/netslide.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+NETSLIDE_EXTRA = tree234
+
+netslide : [X] GTK COMMON netslide NETSLIDE_EXTRA netslide-icon|no-icon
+
+netslide : [G] WINDOWS COMMON netslide NETSLIDE_EXTRA netslide.res|noicon.res
+
+ALL += netslide[COMBINED] NETSLIDE_EXTRA
+
+!begin am gtk
+GAMES += netslide
+!end
+
+!begin >list.c
+    A(netslide) \
+!end
+
+!begin >gamedesc.txt
+netslide:netslide.exe:Netslide:Toroidal sliding network puzzle:Slide a row at a time to reassemble the network.
+!end
diff --git a/apps/plugins/puzzles/netslide.c b/apps/plugins/puzzles/netslide.c
new file mode 100644
index 0000000000..e299b96eb3
--- /dev/null
+++ b/apps/plugins/puzzles/netslide.c
@@ -0,0 +1,1893 @@
+/*
+ * netslide.c: cross between Net and Sixteen, courtesy of Richard
+ * Boulton.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+
+#define MATMUL(xr,yr,m,x,y) do { \
+    float rx, ry, xx = (x), yy = (y), *mat = (m); \
+    rx = mat[0] * xx + mat[2] * yy; \
+    ry = mat[1] * xx + mat[3] * yy; \
+    (xr) = rx; (yr) = ry; \
+} while (0)
+
+/* Direction and other bitfields */
+#define R 0x01
+#define U 0x02
+#define L 0x04
+#define D 0x08
+#define FLASHING 0x10
+#define ACTIVE 0x20
+/* Corner flags go in the barriers array */
+#define RU 0x10
+#define UL 0x20
+#define LD 0x40
+#define DR 0x80
+
+/* Get tile at given coordinate */
+#define T(state, x, y) ( (y) * (state)->width + (x) )
+
+/* Rotations: Anticlockwise, Clockwise, Flip, general rotate */
+#define A(x) ( (((x) & 0x07) << 1) | (((x) & 0x08) >> 3) )
+#define C(x) ( (((x) & 0x0E) >> 1) | (((x) & 0x01) << 3) )
+#define F(x) ( (((x) & 0x0C) >> 2) | (((x) & 0x03) << 2) )
+#define ROT(x, n) ( ((n)&3) == 0 ? (x) : \
+                    ((n)&3) == 1 ? A(x) : \
+                    ((n)&3) == 2 ? F(x) : C(x) )
+
+/* X and Y displacements */
+#define X(x) ( (x) == R ? +1 : (x) == L ? -1 : 0 )
+#define Y(x) ( (x) == D ? +1 : (x) == U ? -1 : 0 )
+
+/* Bit count */
+#define COUNT(x) ( (((x) & 0x08) >> 3) + (((x) & 0x04) >> 2) + \
+                   (((x) & 0x02) >> 1) + ((x) & 0x01) )
+
+#define PREFERRED_TILE_SIZE 48
+#define TILE_SIZE (ds->tilesize)
+#define BORDER TILE_SIZE
+#define TILE_BORDER 1
+#define WINDOW_OFFSET 0
+
+#define ANIM_TIME 0.13F
+#define FLASH_FRAME 0.07F
+
+enum {
+    COL_BACKGROUND,
+    COL_FLASHING,
+    COL_BORDER,
+    COL_WIRE,
+    COL_ENDPOINT,
+    COL_POWERED,
+    COL_BARRIER,
+    COL_LOWLIGHT,
+    COL_TEXT,
+    NCOLOURS
+};
+
+struct game_params {
+    int width;
+    int height;
+    int wrapping;
+    float barrier_probability;
+    int movetarget;
+};
+
+struct game_state {
+    int width, height, cx, cy, wrapping, completed;
+    int used_solve;
+    int move_count, movetarget;
+
+    /* position (row or col number, starting at 0) of last move. */
+    int last_move_row, last_move_col;
+
+    /* direction of last move: +1 or -1 */
+    int last_move_dir;
+
+    unsigned char *tiles;
+    unsigned char *barriers;
+};
+
+#define OFFSET(x2,y2,x1,y1,dir,state) \
+    ( (x2) = ((x1) + (state)->width + X((dir))) % (state)->width, \
+      (y2) = ((y1) + (state)->height + Y((dir))) % (state)->height)
+
+#define index(state, a, x, y) ( a[(y) * (state)->width + (x)] )
+#define tile(state, x, y)     index(state, (state)->tiles, x, y)
+#define barrier(state, x, y)  index(state, (state)->barriers, x, y)
+
+struct xyd {
+    int x, y, direction;
+};
+
+static int xyd_cmp(void *av, void *bv) {
+    struct xyd *a = (struct xyd *)av;
+    struct xyd *b = (struct xyd *)bv;
+    if (a->x < b->x)
+        return -1;
+    if (a->x > b->x)
+        return +1;
+    if (a->y < b->y)
+        return -1;
+    if (a->y > b->y)
+        return +1;
+    if (a->direction < b->direction)
+        return -1;
+    if (a->direction > b->direction)
+        return +1;
+    return 0;
+}
+
+static struct xyd *new_xyd(int x, int y, int direction)
+{
+    struct xyd *xyd = snew(struct xyd);
+    xyd->x = x;
+    xyd->y = y;
+    xyd->direction = direction;
+    return xyd;
+}
+
+static void slide_col(game_state *state, int dir, int col);
+static void slide_col_int(int w, int h, unsigned char *tiles, int dir, int col);
+static void slide_row(game_state *state, int dir, int row);
+static void slide_row_int(int w, int h, unsigned char *tiles, int dir, int row);
+
+/* ----------------------------------------------------------------------
+ * Manage game parameters.
+ */
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->width = 3;
+    ret->height = 3;
+    ret->wrapping = FALSE;
+    ret->barrier_probability = 1.0;
+    ret->movetarget = 0;
+
+    return ret;
+}
+
+static const struct { int x, y, wrap, bprob; const char* desc; }
+netslide_presets[] = {
+    {3, 3, FALSE, 1, " easy"},
+    {3, 3, FALSE, 0, " medium"},
+    {3, 3, TRUE,  0, " hard"},
+    {4, 4, FALSE, 1, " easy"},
+    {4, 4, FALSE, 0, " medium"},
+    {4, 4, TRUE,  0, " hard"},
+    {5, 5, FALSE, 1, " easy"},
+    {5, 5, FALSE, 0, " medium"},
+    {5, 5, TRUE,  0, " hard"},
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(netslide_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    ret->width = netslide_presets[i].x;
+    ret->height = netslide_presets[i].y;
+    ret->wrapping = netslide_presets[i].wrap;
+    ret->barrier_probability = (float)netslide_presets[i].bprob;
+    ret->movetarget = 0;
+
+    sprintf(str, "%dx%d%s", ret->width, ret->height, netslide_presets[i].desc);
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    char const *p = string;
+
+    ret->wrapping = FALSE;
+    ret->barrier_probability = 0.0;
+    ret->movetarget = 0;
+
+    ret->width = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+    if (*p == 'x') {
+        p++;
+        ret->height = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+        if ( (ret->wrapping = (*p == 'w')) != 0 )
+            p++;
+        if (*p == 'b') {
+            ret->barrier_probability = (float)atof(++p);
+            while (*p && (isdigit((unsigned char)*p) || *p == '.')) p++;
+        }
+        if (*p == 'm') {
+            ret->movetarget = atoi(++p);
+        }
+    } else {
+        ret->height = ret->width;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char ret[400];
+    int len;
+
+    len = sprintf(ret, "%dx%d", params->width, params->height);
+    if (params->wrapping)
+        ret[len++] = 'w';
+    if (full && params->barrier_probability)
+        len += sprintf(ret+len, "b%g", params->barrier_probability);
+    /* Shuffle limit is part of the limited parameters, because we have to
+     * provide the target move count. */
+    if (params->movetarget)
+        len += sprintf(ret+len, "m%d", params->movetarget);
+    assert(len < lenof(ret));
+    ret[len] = '\0';
+
+    return dupstr(ret);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(6, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->width);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->height);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Walls wrap around";
+    ret[2].type = C_BOOLEAN;
+    ret[2].sval = NULL;
+    ret[2].ival = params->wrapping;
+
+    ret[3].name = "Barrier probability";
+    ret[3].type = C_STRING;
+    sprintf(buf, "%g", params->barrier_probability);
+    ret[3].sval = dupstr(buf);
+    ret[3].ival = 0;
+
+    ret[4].name = "Number of shuffling moves";
+    ret[4].type = C_STRING;
+    sprintf(buf, "%d", params->movetarget);
+    ret[4].sval = dupstr(buf);
+    ret[4].ival = 0;
+
+    ret[5].name = NULL;
+    ret[5].type = C_END;
+    ret[5].sval = NULL;
+    ret[5].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->width = atoi(cfg[0].sval);
+    ret->height = atoi(cfg[1].sval);
+    ret->wrapping = cfg[2].ival;
+    ret->barrier_probability = (float)atof(cfg[3].sval);
+    ret->movetarget = atoi(cfg[4].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->width <= 1 || params->height <= 1)
+        return "Width and height must both be greater than one";
+    if (params->barrier_probability < 0)
+        return "Barrier probability may not be negative";
+    if (params->barrier_probability > 1)
+        return "Barrier probability may not be greater than 1";
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Randomly select a new game description.
+ */
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    tree234 *possibilities, *barriertree;
+    int w, h, x, y, cx, cy, nbarriers;
+    unsigned char *tiles, *barriers;
+    char *desc, *p;
+
+    w = params->width;
+    h = params->height;
+
+    tiles = snewn(w * h, unsigned char);
+    memset(tiles, 0, w * h);
+    barriers = snewn(w * h, unsigned char);
+    memset(barriers, 0, w * h);
+
+    cx = w / 2;
+    cy = h / 2;
+
+    /*
+     * Construct the unshuffled grid.
+     * 
+     * To do this, we simply start at the centre point, repeatedly
+     * choose a random possibility out of the available ways to
+     * extend a used square into an unused one, and do it. After
+     * extending the third line out of a square, we remove the
+     * fourth from the possibilities list to avoid any full-cross
+     * squares (which would make the game too easy because they
+     * only have one orientation).
+     * 
+     * The slightly worrying thing is the avoidance of full-cross
+     * squares. Can this cause our unsophisticated construction
+     * algorithm to paint itself into a corner, by getting into a
+     * situation where there are some unreached squares and the
+     * only way to reach any of them is to extend a T-piece into a
+     * full cross?
+     * 
+     * Answer: no it can't, and here's a proof.
+     * 
+     * Any contiguous group of such unreachable squares must be
+     * surrounded on _all_ sides by T-pieces pointing away from the
+     * group. (If not, then there is a square which can be extended
+     * into one of the `unreachable' ones, and so it wasn't
+     * unreachable after all.) In particular, this implies that
+     * each contiguous group of unreachable squares must be
+     * rectangular in shape (any deviation from that yields a
+     * non-T-piece next to an `unreachable' square).
+     * 
+     * So we have a rectangle of unreachable squares, with T-pieces
+     * forming a solid border around the rectangle. The corners of
+     * that border must be connected (since every tile connects all
+     * the lines arriving in it), and therefore the border must
+     * form a closed loop around the rectangle.
+     * 
+     * But this can't have happened in the first place, since we
+     * _know_ we've avoided creating closed loops! Hence, no such
+     * situation can ever arise, and the naive grid construction
+     * algorithm will guaranteeably result in a complete grid
+     * containing no unreached squares, no full crosses _and_ no
+     * closed loops. []
+     */
+    possibilities = newtree234(xyd_cmp);
+
+    if (cx+1 < w)
+        add234(possibilities, new_xyd(cx, cy, R));
+    if (cy-1 >= 0)
+        add234(possibilities, new_xyd(cx, cy, U));
+    if (cx-1 >= 0)
+        add234(possibilities, new_xyd(cx, cy, L));
+    if (cy+1 < h)
+        add234(possibilities, new_xyd(cx, cy, D));
+
+    while (count234(possibilities) > 0) {
+        int i;
+        struct xyd *xyd;
+        int x1, y1, d1, x2, y2, d2, d;
+
+        /*
+         * Extract a randomly chosen possibility from the list.
+         */
+        i = random_upto(rs, count234(possibilities));
+        xyd = delpos234(possibilities, i);
+        x1 = xyd->x;
+        y1 = xyd->y;
+        d1 = xyd->direction;
+        sfree(xyd);
+
+        OFFSET(x2, y2, x1, y1, d1, params);
+        d2 = F(d1);
+#ifdef GENERATION_DIAGNOSTICS
+        printf("picked (%d,%d,%c) <-> (%d,%d,%c)\n",
+               x1, y1, "0RU3L567D9abcdef"[d1], x2, y2, "0RU3L567D9abcdef"[d2]);
+#endif
+
+        /*
+         * Make the connection. (We should be moving to an as yet
+         * unused tile.)
+         */
+        index(params, tiles, x1, y1) |= d1;
+        assert(index(params, tiles, x2, y2) == 0);
+        index(params, tiles, x2, y2) |= d2;
+
+        /*
+         * If we have created a T-piece, remove its last
+         * possibility.
+         */
+        if (COUNT(index(params, tiles, x1, y1)) == 3) {
+            struct xyd xyd1, *xydp;
+
+            xyd1.x = x1;
+            xyd1.y = y1;
+            xyd1.direction = 0x0F ^ index(params, tiles, x1, y1);
+
+            xydp = find234(possibilities, &xyd1, NULL);
+
+            if (xydp) {
+#ifdef GENERATION_DIAGNOSTICS
+                printf("T-piece; removing (%d,%d,%c)\n",
+                       xydp->x, xydp->y, "0RU3L567D9abcdef"[xydp->direction]);
+#endif
+                del234(possibilities, xydp);
+                sfree(xydp);
+            }
+        }
+
+        /*
+         * Remove all other possibilities that were pointing at the
+         * tile we've just moved into.
+         */
+        for (d = 1; d < 0x10; d <<= 1) {
+            int x3, y3, d3;
+            struct xyd xyd1, *xydp;
+
+            OFFSET(x3, y3, x2, y2, d, params);
+            d3 = F(d);
+
+            xyd1.x = x3;
+            xyd1.y = y3;
+            xyd1.direction = d3;
+
+            xydp = find234(possibilities, &xyd1, NULL);
+
+            if (xydp) {
+#ifdef GENERATION_DIAGNOSTICS
+                printf("Loop avoidance; removing (%d,%d,%c)\n",
+                       xydp->x, xydp->y, "0RU3L567D9abcdef"[xydp->direction]);
+#endif
+                del234(possibilities, xydp);
+                sfree(xydp);
+            }
+        }
+
+        /*
+         * Add new possibilities to the list for moving _out_ of
+         * the tile we have just moved into.
+         */
+        for (d = 1; d < 0x10; d <<= 1) {
+            int x3, y3;
+
+            if (d == d2)
+                continue;              /* we've got this one already */
+
+            if (!params->wrapping) {
+                if (d == U && y2 == 0)
+                    continue;
+                if (d == D && y2 == h-1)
+                    continue;
+                if (d == L && x2 == 0)
+                    continue;
+                if (d == R && x2 == w-1)
+                    continue;
+            }
+
+            OFFSET(x3, y3, x2, y2, d, params);
+
+            if (index(params, tiles, x3, y3))
+                continue;              /* this would create a loop */
+
+#ifdef GENERATION_DIAGNOSTICS
+            printf("New frontier; adding (%d,%d,%c)\n",
+                   x2, y2, "0RU3L567D9abcdef"[d]);
+#endif
+            add234(possibilities, new_xyd(x2, y2, d));
+        }
+    }
+    /* Having done that, we should have no possibilities remaining. */
+    assert(count234(possibilities) == 0);
+    freetree234(possibilities);
+
+    /*
+     * Now compute a list of the possible barrier locations.
+     */
+    barriertree = newtree234(xyd_cmp);
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+
+            if (!(index(params, tiles, x, y) & R) &&
+                (params->wrapping || x < w-1))
+                add234(barriertree, new_xyd(x, y, R));
+            if (!(index(params, tiles, x, y) & D) &&
+                (params->wrapping || y < h-1))
+                add234(barriertree, new_xyd(x, y, D));
+        }
+    }
+
+    /*
+     * Save the unshuffled grid in aux.
+     */
+    {
+        char *solution;
+        int i;
+
+        /*
+         * String format is exactly the same as a solve move, so we
+         * can just dupstr this in solve_game().
+         */
+
+        solution = snewn(w * h + 2, char);
+        solution[0] = 'S';
+        for (i = 0; i < w * h; i++)
+            solution[i+1] = "0123456789abcdef"[tiles[i] & 0xF];
+        solution[w*h+1] = '\0';
+
+        *aux = solution;
+    }
+
+    /*
+     * Now shuffle the grid.
+     * FIXME - this simply does a set of random moves to shuffle the pieces,
+     * although we make a token effort to avoid boring cases by avoiding moves
+     * that directly undo the previous one, or that repeat so often as to
+     * turn into fewer moves.
+     *
+     * A better way would be to number all the pieces, generate a placement
+     * for all the numbers as for "sixteen", observing parity constraints if
+     * neccessary, and then place the pieces according to their numbering.
+     * BUT - I'm not sure if this will work, since we disallow movement of
+     * the middle row and column.
+     */
+    {
+        int i;
+        int cols = w - 1;
+        int rows = h - 1;
+        int moves = params->movetarget;
+        int prevdir = -1, prevrowcol = -1, nrepeats = 0;
+        if (!moves) moves = cols * rows * 2;
+        for (i = 0; i < moves; /* incremented conditionally */) {
+            /* Choose a direction: 0,1,2,3 = up, right, down, left. */
+            int dir = random_upto(rs, 4);
+            int rowcol;
+            if (dir % 2 == 0) {
+                int col = random_upto(rs, cols);
+                if (col >= cx) col += 1;    /* avoid centre */
+                if (col == prevrowcol) {
+                    if (dir == 2-prevdir)
+                        continue;   /* undoes last move */
+                    else if (dir == prevdir && (nrepeats+1)*2 > h)
+                        continue;   /* makes fewer moves */
+                }
+                slide_col_int(w, h, tiles, 1 - dir, col);
+                rowcol = col;
+            } else {
+                int row = random_upto(rs, rows);
+                if (row >= cy) row += 1;    /* avoid centre */
+                if (row == prevrowcol) {
+                    if (dir == 4-prevdir)
+                        continue;   /* undoes last move */
+                    else if (dir == prevdir && (nrepeats+1)*2 > w)
+                        continue;   /* makes fewer moves */
+                }
+                slide_row_int(w, h, tiles, 2 - dir, row);
+                rowcol = row;
+            }
+            if (dir == prevdir && rowcol == prevrowcol)
+                nrepeats++;
+            else
+                nrepeats = 1;
+            prevdir = dir;
+            prevrowcol = rowcol;
+            i++;    /* if we got here, the move was accepted */
+        }
+    }
+
+    /*
+     * And now choose barrier locations. (We carefully do this
+     * _after_ shuffling, so that changing the barrier rate in the
+     * params while keeping the random seed the same will give the
+     * same shuffled grid and _only_ change the barrier locations.
+     * Also the way we choose barrier locations, by repeatedly
+     * choosing one possibility from the list until we have enough,
+     * is designed to ensure that raising the barrier rate while
+     * keeping the seed the same will provide a superset of the
+     * previous barrier set - i.e. if you ask for 10 barriers, and
+     * then decide that's still too hard and ask for 20, you'll get
+     * the original 10 plus 10 more, rather than getting 20 new
+     * ones and the chance of remembering your first 10.)
+     */
+    nbarriers = (int)(params->barrier_probability * count234(barriertree));
+    assert(nbarriers >= 0 && nbarriers <= count234(barriertree));
+
+    while (nbarriers > 0) {
+        int i;
+        struct xyd *xyd;
+        int x1, y1, d1, x2, y2, d2;
+
+        /*
+         * Extract a randomly chosen barrier from the list.
+         */
+        i = random_upto(rs, count234(barriertree));
+        xyd = delpos234(barriertree, i);
+
+        assert(xyd != NULL);
+
+        x1 = xyd->x;
+        y1 = xyd->y;
+        d1 = xyd->direction;
+        sfree(xyd);
+
+        OFFSET(x2, y2, x1, y1, d1, params);
+        d2 = F(d1);
+
+        index(params, barriers, x1, y1) |= d1;
+        index(params, barriers, x2, y2) |= d2;
+
+        nbarriers--;
+    }
+
+    /*
+     * Clean up the rest of the barrier list.
+     */
+    {
+        struct xyd *xyd;
+
+        while ( (xyd = delpos234(barriertree, 0)) != NULL)
+            sfree(xyd);
+
+        freetree234(barriertree);
+    }
+
+    /*
+     * Finally, encode the grid into a string game description.
+     * 
+     * My syntax is extremely simple: each square is encoded as a
+     * hex digit in which bit 0 means a connection on the right,
+     * bit 1 means up, bit 2 left and bit 3 down. (i.e. the same
+     * encoding as used internally). Each digit is followed by
+     * optional barrier indicators: `v' means a vertical barrier to
+     * the right of it, and `h' means a horizontal barrier below
+     * it.
+     */
+    desc = snewn(w * h * 3 + 1, char);
+    p = desc;
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            *p++ = "0123456789abcdef"[index(params, tiles, x, y)];
+            if ((params->wrapping || x < w-1) &&
+                (index(params, barriers, x, y) & R))
+                *p++ = 'v';
+            if ((params->wrapping || y < h-1) &&
+                (index(params, barriers, x, y) & D))
+                *p++ = 'h';
+        }
+    }
+    assert(p - desc <= w*h*3);
+    *p = '\0';
+
+    sfree(tiles);
+    sfree(barriers);
+
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->width, h = params->height;
+    int i;
+
+    for (i = 0; i < w*h; i++) {
+        if (*desc >= '0' && *desc <= '9')
+            /* OK */;
+        else if (*desc >= 'a' && *desc <= 'f')
+            /* OK */;
+        else if (*desc >= 'A' && *desc <= 'F')
+            /* OK */;
+        else if (!*desc)
+            return "Game description shorter than expected";
+        else
+            return "Game description contained unexpected character";
+        desc++;
+        while (*desc == 'h' || *desc == 'v')
+            desc++;
+    }
+    if (*desc)
+        return "Game description longer than expected";
+
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Construct an initial game state, given a description and parameters.
+ */
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state;
+    int w, h, x, y;
+
+    assert(params->width > 0 && params->height > 0);
+    assert(params->width > 1 || params->height > 1);
+
+    /*
+     * Create a blank game state.
+     */
+    state = snew(game_state);
+    w = state->width = params->width;
+    h = state->height = params->height;
+    state->cx = state->width / 2;
+    state->cy = state->height / 2;
+    state->wrapping = params->wrapping;
+    state->movetarget = params->movetarget;
+    state->completed = 0;
+    state->used_solve = FALSE;
+    state->move_count = 0;
+    state->last_move_row = -1;
+    state->last_move_col = -1;
+    state->last_move_dir = 0;
+    state->tiles = snewn(state->width * state->height, unsigned char);
+    memset(state->tiles, 0, state->width * state->height);
+    state->barriers = snewn(state->width * state->height, unsigned char);
+    memset(state->barriers, 0, state->width * state->height);
+
+
+    /*
+     * Parse the game description into the grid.
+     */
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            if (*desc >= '0' && *desc <= '9')
+                tile(state, x, y) = *desc - '0';
+            else if (*desc >= 'a' && *desc <= 'f')
+                tile(state, x, y) = *desc - 'a' + 10;
+            else if (*desc >= 'A' && *desc <= 'F')
+                tile(state, x, y) = *desc - 'A' + 10;
+            if (*desc)
+                desc++;
+            while (*desc == 'h' || *desc == 'v') {
+                int x2, y2, d1, d2;
+                if (*desc == 'v')
+                    d1 = R;
+                else
+                    d1 = D;
+
+                OFFSET(x2, y2, x, y, d1, state);
+                d2 = F(d1);
+
+                barrier(state, x, y) |= d1;
+                barrier(state, x2, y2) |= d2;
+
+                desc++;
+            }
+        }
+    }
+
+    /*
+     * Set up border barriers if this is a non-wrapping game.
+     */
+    if (!state->wrapping) {
+        for (x = 0; x < state->width; x++) {
+            barrier(state, x, 0) |= U;
+            barrier(state, x, state->height-1) |= D;
+        }
+        for (y = 0; y < state->height; y++) {
+            barrier(state, 0, y) |= L;
+            barrier(state, state->width-1, y) |= R;
+        }
+    }
+
+    /*
+     * Set up the barrier corner flags, for drawing barriers
+     * prettily when they meet.
+     */
+    for (y = 0; y < state->height; y++) {
+        for (x = 0; x < state->width; x++) {
+            int dir;
+
+            for (dir = 1; dir < 0x10; dir <<= 1) {
+                int dir2 = A(dir);
+                int x1, y1, x2, y2, x3, y3;
+                int corner = FALSE;
+
+                if (!(barrier(state, x, y) & dir))
+                    continue;
+
+                if (barrier(state, x, y) & dir2)
+                    corner = TRUE;
+
+                x1 = x + X(dir), y1 = y + Y(dir);
+                if (x1 >= 0 && x1 < state->width &&
+                    y1 >= 0 && y1 < state->height &&
+                    (barrier(state, x1, y1) & dir2))
+                    corner = TRUE;
+
+                x2 = x + X(dir2), y2 = y + Y(dir2);
+                if (x2 >= 0 && x2 < state->width &&
+                    y2 >= 0 && y2 < state->height &&
+                    (barrier(state, x2, y2) & dir))
+                    corner = TRUE;
+
+                if (corner) {
+                    barrier(state, x, y) |= (dir << 4);
+                    if (x1 >= 0 && x1 < state->width &&
+                        y1 >= 0 && y1 < state->height)
+                        barrier(state, x1, y1) |= (A(dir) << 4);
+                    if (x2 >= 0 && x2 < state->width &&
+                        y2 >= 0 && y2 < state->height)
+                        barrier(state, x2, y2) |= (C(dir) << 4);
+                    x3 = x + X(dir) + X(dir2), y3 = y + Y(dir) + Y(dir2);
+                    if (x3 >= 0 && x3 < state->width &&
+                        y3 >= 0 && y3 < state->height)
+                        barrier(state, x3, y3) |= (F(dir) << 4);
+                }
+            }
+        }
+    }
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret;
+
+    ret = snew(game_state);
+    ret->width = state->width;
+    ret->height = state->height;
+    ret->cx = state->cx;
+    ret->cy = state->cy;
+    ret->wrapping = state->wrapping;
+    ret->movetarget = state->movetarget;
+    ret->completed = state->completed;
+    ret->used_solve = state->used_solve;
+    ret->move_count = state->move_count;
+    ret->last_move_row = state->last_move_row;
+    ret->last_move_col = state->last_move_col;
+    ret->last_move_dir = state->last_move_dir;
+    ret->tiles = snewn(state->width * state->height, unsigned char);
+    memcpy(ret->tiles, state->tiles, state->width * state->height);
+    ret->barriers = snewn(state->width * state->height, unsigned char);
+    memcpy(ret->barriers, state->barriers, state->width * state->height);
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->tiles);
+    sfree(state->barriers);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    if (!aux) {
+        *error = "Solution not known for this puzzle";
+        return NULL;
+    }
+
+    return dupstr(aux);
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Utility routine.
+ */
+
+/*
+ * Compute which squares are reachable from the centre square, as a
+ * quick visual aid to determining how close the game is to
+ * completion. This is also a simple way to tell if the game _is_
+ * completed - just call this function and see whether every square
+ * is marked active.
+ *
+ * squares in the moving_row and moving_col are always inactive - this
+ * is so that "current" doesn't appear to jump across moving lines.
+ */
+static unsigned char *compute_active(const game_state *state,
+                                     int moving_row, int moving_col)
+{
+    unsigned char *active;
+    tree234 *todo;
+    struct xyd *xyd;
+
+    active = snewn(state->width * state->height, unsigned char);
+    memset(active, 0, state->width * state->height);
+
+    /*
+     * We only store (x,y) pairs in todo, but it's easier to reuse
+     * xyd_cmp and just store direction 0 every time.
+     */
+    todo = newtree234(xyd_cmp);
+    index(state, active, state->cx, state->cy) = ACTIVE;
+    add234(todo, new_xyd(state->cx, state->cy, 0));
+
+    while ( (xyd = delpos234(todo, 0)) != NULL) {
+        int x1, y1, d1, x2, y2, d2;
+
+        x1 = xyd->x;
+        y1 = xyd->y;
+        sfree(xyd);
+
+        for (d1 = 1; d1 < 0x10; d1 <<= 1) {
+            OFFSET(x2, y2, x1, y1, d1, state);
+            d2 = F(d1);
+
+            /*
+             * If the next tile in this direction is connected to
+             * us, and there isn't a barrier in the way, and it
+             * isn't already marked active, then mark it active and
+             * add it to the to-examine list.
+             */
+            if ((x2 != moving_col && y2 != moving_row) &&
+                (tile(state, x1, y1) & d1) &&
+                (tile(state, x2, y2) & d2) &&
+                !(barrier(state, x1, y1) & d1) &&
+                !index(state, active, x2, y2)) {
+                index(state, active, x2, y2) = ACTIVE;
+                add234(todo, new_xyd(x2, y2, 0));
+            }
+        }
+    }
+    /* Now we expect the todo list to have shrunk to zero size. */
+    assert(count234(todo) == 0);
+    freetree234(todo);
+
+    return active;
+}
+
+struct game_ui {
+    int cur_x, cur_y;
+    int cur_visible;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->cur_x = 0;
+    ui->cur_y = -1;
+    ui->cur_visible = FALSE;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+/* ----------------------------------------------------------------------
+ * Process a move.
+ */
+
+static void slide_row_int(int w, int h, unsigned char *tiles, int dir, int row)
+{
+    int x = dir > 0 ? -1 : w;
+    int tx = x + dir;
+    int n = w - 1;
+    unsigned char endtile = tiles[row * w + tx];
+    do {
+        x = tx;
+        tx = (x + dir + w) % w;
+        tiles[row * w + x] = tiles[row * w + tx];
+    } while (--n > 0);
+    tiles[row * w + tx] = endtile;
+}
+
+static void slide_col_int(int w, int h, unsigned char *tiles, int dir, int col)
+{
+    int y = dir > 0 ? -1 : h;
+    int ty = y + dir;
+    int n = h - 1;
+    unsigned char endtile = tiles[ty * w + col];
+    do {
+        y = ty;
+        ty = (y + dir + h) % h;
+        tiles[y * w + col] = tiles[ty * w + col];
+    } while (--n > 0);
+    tiles[ty * w + col] = endtile;
+}
+
+static void slide_row(game_state *state, int dir, int row)
+{
+    slide_row_int(state->width, state->height, state->tiles, dir, row);
+}
+
+static void slide_col(game_state *state, int dir, int col)
+{
+    slide_col_int(state->width, state->height, state->tiles, dir, col);
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int started;
+    int width, height;
+    int tilesize;
+    unsigned char *visible;
+    int cur_x, cur_y;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int cx, cy;
+    int dx, dy;
+    char buf[80];
+
+    button &= ~MOD_MASK;
+
+    if (IS_CURSOR_MOVE(button)) {
+        int cpos, diff = 0;
+        cpos = c2pos(state->width, state->height, ui->cur_x, ui->cur_y);
+        diff = c2diff(state->width, state->height, ui->cur_x, ui->cur_y, button);
+
+        if (diff != 0) {
+            do { /* we might have to do this more than once to skip missing arrows */
+                cpos += diff;
+                pos2c(state->width, state->height, cpos, &ui->cur_x, &ui->cur_y);
+            } while (ui->cur_x == state->cx || ui->cur_y == state->cy);
+        }
+
+        ui->cur_visible = 1;
+        return "";
+    }
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        cx = (x - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2;
+        cy = (y - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2;
+        ui->cur_visible = 0;
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (ui->cur_visible) {
+            cx = ui->cur_x;
+            cy = ui->cur_y;
+        } else {
+            /* 'click' when cursor is invisible just makes cursor visible. */
+            ui->cur_visible = 1;
+            return "";
+        }
+    } else
+        return NULL;
+
+    if (cy >= 0 && cy < state->height && cy != state->cy)
+    {
+        if (cx == -1) dx = +1;
+        else if (cx == state->width) dx = -1;
+        else return NULL;
+        dy = 0;
+    }
+    else if (cx >= 0 && cx < state->width && cx != state->cx)
+    {
+        if (cy == -1) dy = +1;
+        else if (cy == state->height) dy = -1;
+        else return NULL;
+        dx = 0;
+    }
+    else
+        return NULL;
+
+    /* reverse direction if right hand button is pressed */
+    if (button == RIGHT_BUTTON)
+    {
+        dx = -dx;
+        dy = -dy;
+    }
+
+    if (dx == 0)
+        sprintf(buf, "C%d,%d", cx, dy);
+    else
+        sprintf(buf, "R%d,%d", cy, dx);
+    return dupstr(buf);
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    game_state *ret;
+    int c, d, col;
+
+    if ((move[0] == 'C' || move[0] == 'R') &&
+        sscanf(move+1, "%d,%d", &c, &d) == 2 &&
+        c >= 0 && c < (move[0] == 'C' ? from->width : from->height)) {
+        col = (move[0] == 'C');
+    } else if (move[0] == 'S' &&
+               strlen(move) == from->width * from->height + 1) {
+        int i;
+        ret = dup_game(from);
+        ret->used_solve = TRUE;
+        ret->completed = ret->move_count = 1;
+
+        for (i = 0; i < from->width * from->height; i++) {
+            c = move[i+1];
+            if (c >= '0' && c <= '9')
+                c -= '0';
+            else if (c >= 'A' && c <= 'F')
+                c -= 'A' - 10;
+            else if (c >= 'a' && c <= 'f')
+                c -= 'a' - 10;
+            else {
+                free_game(ret);
+                return NULL;
+            }
+            ret->tiles[i] = c;
+        }
+        return ret;
+    } else
+        return NULL;                   /* can't parse move string */
+
+    ret = dup_game(from);
+
+    if (col)
+        slide_col(ret, d, c);
+    else
+        slide_row(ret, d, c);
+
+    ret->move_count++;
+    ret->last_move_row = col ? -1 : c;
+    ret->last_move_col = col ? c : -1;
+    ret->last_move_dir = d;
+
+    /*
+     * See if the game has been completed.
+     */
+    if (!ret->completed) {
+        unsigned char *active = compute_active(ret, -1, -1);
+        int x1, y1;
+        int complete = TRUE;
+
+        for (x1 = 0; x1 < ret->width; x1++)
+            for (y1 = 0; y1 < ret->height; y1++)
+                if (!index(ret, active, x1, y1)) {
+                    complete = FALSE;
+                    goto break_label;  /* break out of two loops at once */
+                }
+        break_label:
+
+        sfree(active);
+
+        if (complete)
+            ret->completed = ret->move_count;
+    }
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Routines for drawing the game position on the screen.
+ */
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    game_drawstate *ds = snew(game_drawstate);
+
+    ds->started = FALSE;
+    ds->width = state->width;
+    ds->height = state->height;
+    ds->visible = snewn(state->width * state->height, unsigned char);
+    ds->tilesize = 0;                  /* not decided yet */
+    memset(ds->visible, 0xFF, state->width * state->height);
+    ds->cur_x = ds->cur_y = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->visible);
+    sfree(ds);
+}
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * params->width + TILE_BORDER;
+    *y = BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * params->height + TILE_BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret;
+
+    ret = snewn(NCOLOURS * 3, float);
+    *ncolours = NCOLOURS;
+
+    /*
+     * Basic background colour is whatever the front end thinks is
+     * a sensible default.
+     */
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    /*
+     * Wires are black.
+     */
+    ret[COL_WIRE * 3 + 0] = 0.0F;
+    ret[COL_WIRE * 3 + 1] = 0.0F;
+    ret[COL_WIRE * 3 + 2] = 0.0F;
+
+    /*
+     * Powered wires and powered endpoints are cyan.
+     */
+    ret[COL_POWERED * 3 + 0] = 0.0F;
+    ret[COL_POWERED * 3 + 1] = 1.0F;
+    ret[COL_POWERED * 3 + 2] = 1.0F;
+
+    /*
+     * Barriers are red.
+     */
+    ret[COL_BARRIER * 3 + 0] = 1.0F;
+    ret[COL_BARRIER * 3 + 1] = 0.0F;
+    ret[COL_BARRIER * 3 + 2] = 0.0F;
+
+    /*
+     * Unpowered endpoints are blue.
+     */
+    ret[COL_ENDPOINT * 3 + 0] = 0.0F;
+    ret[COL_ENDPOINT * 3 + 1] = 0.0F;
+    ret[COL_ENDPOINT * 3 + 2] = 1.0F;
+
+    /*
+     * Tile borders are a darker grey than the background.
+     */
+    ret[COL_BORDER * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_BORDER * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_BORDER * 3 + 2] = 0.5F * ret[COL_BACKGROUND * 3 + 2];
+
+    /*
+     * Flashing tiles are a grey in between those two.
+     */
+    ret[COL_FLASHING * 3 + 0] = 0.75F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_FLASHING * 3 + 1] = 0.75F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_FLASHING * 3 + 2] = 0.75F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_LOWLIGHT * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.8F;
+    ret[COL_LOWLIGHT * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 0.8F;
+    ret[COL_LOWLIGHT * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 0.8F;
+    ret[COL_TEXT * 3 + 0] = 0.0;
+    ret[COL_TEXT * 3 + 1] = 0.0;
+    ret[COL_TEXT * 3 + 2] = 0.0;
+
+    return ret;
+}
+
+static void draw_filled_line(drawing *dr, int x1, int y1, int x2, int y2,
+                             int colour)
+{
+    draw_line(dr, x1-1, y1, x2-1, y2, COL_WIRE);
+    draw_line(dr, x1+1, y1, x2+1, y2, COL_WIRE);
+    draw_line(dr, x1, y1-1, x2, y2-1, COL_WIRE);
+    draw_line(dr, x1, y1+1, x2, y2+1, COL_WIRE);
+    draw_line(dr, x1, y1, x2, y2, colour);
+}
+
+static void draw_rect_coords(drawing *dr, int x1, int y1, int x2, int y2,
+                             int colour)
+{
+    int mx = (x1 < x2 ? x1 : x2);
+    int my = (y1 < y2 ? y1 : y2);
+    int dx = (x2 + x1 - 2*mx + 1);
+    int dy = (y2 + y1 - 2*my + 1);
+
+    draw_rect(dr, mx, my, dx, dy, colour);
+}
+
+static void draw_barrier_corner(drawing *dr, game_drawstate *ds,
+                                int x, int y, int dir, int phase)
+{
+    int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x;
+    int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y;
+    int x1, y1, dx, dy, dir2;
+
+    dir >>= 4;
+
+    dir2 = A(dir);
+    dx = X(dir) + X(dir2);
+    dy = Y(dir) + Y(dir2);
+    x1 = (dx > 0 ? TILE_SIZE+TILE_BORDER-1 : 0);
+    y1 = (dy > 0 ? TILE_SIZE+TILE_BORDER-1 : 0);
+
+    if (phase == 0) {
+        draw_rect_coords(dr, bx+x1, by+y1,
+                         bx+x1-TILE_BORDER*dx, by+y1-(TILE_BORDER-1)*dy,
+                         COL_WIRE);
+        draw_rect_coords(dr, bx+x1, by+y1,
+                         bx+x1-(TILE_BORDER-1)*dx, by+y1-TILE_BORDER*dy,
+                         COL_WIRE);
+    } else {
+        draw_rect_coords(dr, bx+x1, by+y1,
+                         bx+x1-(TILE_BORDER-1)*dx, by+y1-(TILE_BORDER-1)*dy,
+                         COL_BARRIER);
+    }
+}
+
+static void draw_barrier(drawing *dr, game_drawstate *ds,
+                         int x, int y, int dir, int phase)
+{
+    int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x;
+    int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y;
+    int x1, y1, w, h;
+
+    x1 = (X(dir) > 0 ? TILE_SIZE : X(dir) == 0 ? TILE_BORDER : 0);
+    y1 = (Y(dir) > 0 ? TILE_SIZE : Y(dir) == 0 ? TILE_BORDER : 0);
+    w = (X(dir) ? TILE_BORDER : TILE_SIZE - TILE_BORDER);
+    h = (Y(dir) ? TILE_BORDER : TILE_SIZE - TILE_BORDER);
+
+    if (phase == 0) {
+        draw_rect(dr, bx+x1-X(dir), by+y1-Y(dir), w, h, COL_WIRE);
+    } else {
+        draw_rect(dr, bx+x1, by+y1, w, h, COL_BARRIER);
+    }
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds, const game_state *state,
+                      int x, int y, int tile, float xshift, float yshift)
+{
+    int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x + (int)(xshift * TILE_SIZE);
+    int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y + (int)(yshift * TILE_SIZE);
+    float cx, cy, ex, ey;
+    int dir, col;
+
+    /*
+     * When we draw a single tile, we must draw everything up to
+     * and including the borders around the tile. This means that
+     * if the neighbouring tiles have connections to those borders,
+     * we must draw those connections on the borders themselves.
+     *
+     * This would be terribly fiddly if we ever had to draw a tile
+     * while its neighbour was in mid-rotate, because we'd have to
+     * arrange to _know_ that the neighbour was being rotated and
+     * hence had an anomalous effect on the redraw of this tile.
+     * Fortunately, the drawing algorithm avoids ever calling us in
+     * this circumstance: we're either drawing lots of straight
+     * tiles at game start or after a move is complete, or we're
+     * repeatedly drawing only the rotating tile. So no problem.
+     */
+
+    /*
+     * So. First blank the tile out completely: draw a big
+     * rectangle in border colour, and a smaller rectangle in
+     * background colour to fill it in.
+     */
+    draw_rect(dr, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER,
+              COL_BORDER);
+    draw_rect(dr, bx+TILE_BORDER, by+TILE_BORDER,
+              TILE_SIZE-TILE_BORDER, TILE_SIZE-TILE_BORDER,
+              tile & FLASHING ? COL_FLASHING : COL_BACKGROUND);
+
+    /*
+     * Draw the wires.
+     */
+    cx = cy = TILE_BORDER + (TILE_SIZE-TILE_BORDER) / 2.0F - 0.5F;
+    col = (tile & ACTIVE ? COL_POWERED : COL_WIRE);
+    for (dir = 1; dir < 0x10; dir <<= 1) {
+        if (tile & dir) {
+            ex = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * X(dir);
+            ey = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * Y(dir);
+            draw_filled_line(dr, bx+(int)cx, by+(int)cy,
+                             bx+(int)(cx+ex), by+(int)(cy+ey),
+                             COL_WIRE);
+        }
+    }
+    for (dir = 1; dir < 0x10; dir <<= 1) {
+        if (tile & dir) {
+            ex = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * X(dir);
+            ey = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * Y(dir);
+            draw_line(dr, bx+(int)cx, by+(int)cy,
+                      bx+(int)(cx+ex), by+(int)(cy+ey), col);
+        }
+    }
+
+    /*
+     * Draw the box in the middle. We do this in blue if the tile
+     * is an unpowered endpoint, in cyan if the tile is a powered
+     * endpoint, in black if the tile is the centrepiece, and
+     * otherwise not at all.
+     */
+    col = -1;
+    if (x == state->cx && y == state->cy)
+        col = COL_WIRE;
+    else if (COUNT(tile) == 1) {
+        col = (tile & ACTIVE ? COL_POWERED : COL_ENDPOINT);
+    }
+    if (col >= 0) {
+        int i, points[8];
+
+        points[0] = +1; points[1] = +1;
+        points[2] = +1; points[3] = -1;
+        points[4] = -1; points[5] = -1;
+        points[6] = -1; points[7] = +1;
+
+        for (i = 0; i < 8; i += 2) {
+            ex = (TILE_SIZE * 0.24F) * points[i];
+            ey = (TILE_SIZE * 0.24F) * points[i+1];
+            points[i] = bx+(int)(cx+ex);
+            points[i+1] = by+(int)(cy+ey);
+        }
+
+        draw_polygon(dr, points, 4, col, COL_WIRE);
+    }
+
+    /*
+     * Draw the points on the border if other tiles are connected
+     * to us.
+     */
+    for (dir = 1; dir < 0x10; dir <<= 1) {
+        int dx, dy, px, py, lx, ly, vx, vy, ox, oy;
+
+        dx = X(dir);
+        dy = Y(dir);
+
+        ox = x + dx;
+        oy = y + dy;
+
+        if (ox < 0 || ox >= state->width || oy < 0 || oy >= state->height)
+            continue;
+
+        if (!(tile(state, ox, oy) & F(dir)))
+            continue;
+
+        px = bx + (int)(dx>0 ? TILE_SIZE + TILE_BORDER - 1 : dx<0 ? 0 : cx);
+        py = by + (int)(dy>0 ? TILE_SIZE + TILE_BORDER - 1 : dy<0 ? 0 : cy);
+        lx = dx * (TILE_BORDER-1);
+        ly = dy * (TILE_BORDER-1);
+        vx = (dy ? 1 : 0);
+        vy = (dx ? 1 : 0);
+
+        if (xshift == 0.0 && yshift == 0.0 && (tile & dir)) {
+            /*
+             * If we are fully connected to the other tile, we must
+             * draw right across the tile border. (We can use our
+             * own ACTIVE state to determine what colour to do this
+             * in: if we are fully connected to the other tile then
+             * the two ACTIVE states will be the same.)
+             */
+            draw_rect_coords(dr, px-vx, py-vy, px+lx+vx, py+ly+vy, COL_WIRE);
+            draw_rect_coords(dr, px, py, px+lx, py+ly,
+                             (tile & ACTIVE) ? COL_POWERED : COL_WIRE);
+        } else {
+            /*
+             * The other tile extends into our border, but isn't
+             * actually connected to us. Just draw a single black
+             * dot.
+             */
+            draw_rect_coords(dr, px, py, px, py, COL_WIRE);
+        }
+    }
+
+    draw_update(dr, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER);
+}
+
+static void draw_tile_barriers(drawing *dr, game_drawstate *ds,
+                               const game_state *state, int x, int y)
+{
+    int phase;
+    int dir;
+    int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x;
+    int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y;
+    /*
+     * Draw barrier corners, and then barriers.
+     */
+    for (phase = 0; phase < 2; phase++) {
+        for (dir = 1; dir < 0x10; dir <<= 1)
+            if (barrier(state, x, y) & (dir << 4))
+                draw_barrier_corner(dr, ds, x, y, dir << 4, phase);
+        for (dir = 1; dir < 0x10; dir <<= 1)
+            if (barrier(state, x, y) & dir)
+                draw_barrier(dr, ds, x, y, dir, phase);
+    }
+
+    draw_update(dr, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER);
+}
+
+static void draw_arrow(drawing *dr, game_drawstate *ds,
+                       int x, int y, int xdx, int xdy, int cur)
+{
+    int coords[14];
+    int ydy = -xdx, ydx = xdy;
+
+    x = x * TILE_SIZE + BORDER + WINDOW_OFFSET;
+    y = y * TILE_SIZE + BORDER + WINDOW_OFFSET;
+
+#define POINT(n, xx, yy) ( \
+    coords[2*(n)+0] = x + (xx)*xdx + (yy)*ydx, \
+    coords[2*(n)+1] = y + (xx)*xdy + (yy)*ydy)
+
+    POINT(0, TILE_SIZE / 2, 3 * TILE_SIZE / 4);   /* top of arrow */
+    POINT(1, 3 * TILE_SIZE / 4, TILE_SIZE / 2);   /* right corner */
+    POINT(2, 5 * TILE_SIZE / 8, TILE_SIZE / 2);   /* right concave */
+    POINT(3, 5 * TILE_SIZE / 8, TILE_SIZE / 4);   /* bottom right */
+    POINT(4, 3 * TILE_SIZE / 8, TILE_SIZE / 4);   /* bottom left */
+    POINT(5, 3 * TILE_SIZE / 8, TILE_SIZE / 2);   /* left concave */
+    POINT(6,     TILE_SIZE / 4, TILE_SIZE / 2);   /* left corner */
+
+    draw_polygon(dr, coords, 7, cur ? COL_POWERED : COL_LOWLIGHT, COL_TEXT);
+}
+
+static void draw_arrow_for_cursor(drawing *dr, game_drawstate *ds,
+                                  int cur_x, int cur_y, int cur)
+{
+    if (cur_x == -1 && cur_y == -1)
+        return; /* 'no cursur here */
+    else if (cur_x == -1) /* LH column. */
+        draw_arrow(dr, ds, 0, cur_y+1, 0, -1, cur);
+    else if (cur_x == ds->width) /* RH column */
+        draw_arrow(dr, ds, ds->width, cur_y, 0, +1, cur);
+    else if (cur_y == -1) /* Top row */
+        draw_arrow(dr, ds, cur_x, 0, +1, 0, cur);
+    else if (cur_y == ds->height) /* Bottom row */
+        draw_arrow(dr, ds, cur_x+1, ds->height, -1, 0, cur);
+    else
+        assert(!"Invalid cursor position");
+
+    draw_update(dr,
+                cur_x * TILE_SIZE + BORDER + WINDOW_OFFSET,
+                cur_y * TILE_SIZE + BORDER + WINDOW_OFFSET,
+                TILE_SIZE, TILE_SIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float t, float ft)
+{
+    int x, y, frame;
+    unsigned char *active;
+    float xshift = 0.0;
+    float yshift = 0.0;
+    int cur_x = -1, cur_y = -1;
+
+    /*
+     * Clear the screen and draw the exterior barrier lines if this
+     * is our first call.
+     */
+    if (!ds->started) {
+        int phase;
+
+        ds->started = TRUE;
+
+        draw_rect(dr, 0, 0, 
+                  BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * state->width + TILE_BORDER,
+                  BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * state->height + TILE_BORDER,
+                  COL_BACKGROUND);
+        draw_update(dr, 0, 0, 
+                    BORDER * 2 + WINDOW_OFFSET*2 + TILE_SIZE*state->width + TILE_BORDER,
+                    BORDER * 2 + WINDOW_OFFSET*2 + TILE_SIZE*state->height + TILE_BORDER);
+
+        for (phase = 0; phase < 2; phase++) {
+
+            for (x = 0; x < ds->width; x++) {
+                if (barrier(state, x, 0) & UL)
+                    draw_barrier_corner(dr, ds, x, -1, LD, phase);
+                if (barrier(state, x, 0) & RU)
+                    draw_barrier_corner(dr, ds, x, -1, DR, phase);
+                if (barrier(state, x, 0) & U)
+                    draw_barrier(dr, ds, x, -1, D, phase);
+                if (barrier(state, x, ds->height-1) & DR)
+                    draw_barrier_corner(dr, ds, x, ds->height, RU, phase);
+                if (barrier(state, x, ds->height-1) & LD)
+                    draw_barrier_corner(dr, ds, x, ds->height, UL, phase);
+                if (barrier(state, x, ds->height-1) & D)
+                    draw_barrier(dr, ds, x, ds->height, U, phase);
+            }
+
+            for (y = 0; y < ds->height; y++) {
+                if (barrier(state, 0, y) & UL)
+                    draw_barrier_corner(dr, ds, -1, y, RU, phase);
+                if (barrier(state, 0, y) & LD)
+                    draw_barrier_corner(dr, ds, -1, y, DR, phase);
+                if (barrier(state, 0, y) & L)
+                    draw_barrier(dr, ds, -1, y, R, phase);
+                if (barrier(state, ds->width-1, y) & RU)
+                    draw_barrier_corner(dr, ds, ds->width, y, UL, phase);
+                if (barrier(state, ds->width-1, y) & DR)
+                    draw_barrier_corner(dr, ds, ds->width, y, LD, phase);
+                if (barrier(state, ds->width-1, y) & R)
+                    draw_barrier(dr, ds, ds->width, y, L, phase);
+            }
+        }
+
+        /*
+         * Arrows for making moves.
+         */
+        for (x = 0; x < ds->width; x++) {
+            if (x == state->cx) continue;
+            draw_arrow(dr, ds, x, 0, +1, 0, 0);
+            draw_arrow(dr, ds, x+1, ds->height, -1, 0, 0);
+        }
+        for (y = 0; y < ds->height; y++) {
+            if (y == state->cy) continue;
+            draw_arrow(dr, ds, ds->width, y, 0, +1, 0);
+            draw_arrow(dr, ds, 0, y+1, 0, -1, 0);
+        }
+    }
+    if (ui->cur_visible) {
+        cur_x = ui->cur_x; cur_y = ui->cur_y;
+    }
+    if (cur_x != ds->cur_x || cur_y != ds->cur_y) {
+        /* Cursor has changed; redraw two (prev and curr) arrows. */
+        assert(cur_x != state->cx && cur_y != state->cy);
+
+        draw_arrow_for_cursor(dr, ds, cur_x, cur_y, 1);
+        draw_arrow_for_cursor(dr, ds, ds->cur_x, ds->cur_y, 0);
+        ds->cur_x = cur_x; ds->cur_y = cur_y;
+    }
+
+    /* Check if this is an undo.  If so, we will need to run any animation
+     * backwards.
+     */
+    if (oldstate && oldstate->move_count > state->move_count) {
+        const game_state * tmpstate = state;
+        state = oldstate;
+        oldstate = tmpstate;
+        t = ANIM_TIME - t;
+    }
+
+    if (oldstate && (t < ANIM_TIME)) {
+        /*
+         * We're animating a slide, of row/column number
+         * state->last_move_pos, in direction
+         * state->last_move_dir
+         */
+        xshift = state->last_move_row == -1 ? 0.0F :
+                (1 - t / ANIM_TIME) * state->last_move_dir;
+        yshift = state->last_move_col == -1 ? 0.0F :
+                (1 - t / ANIM_TIME) * state->last_move_dir;
+    }
+    
+    frame = -1;
+    if (ft > 0) {
+        /*
+         * We're animating a completion flash. Find which frame
+         * we're at.
+         */
+        frame = (int)(ft / FLASH_FRAME);
+    }
+
+    /*
+     * Draw any tile which differs from the way it was last drawn.
+     */
+    if (xshift != 0.0 || yshift != 0.0) {
+        active = compute_active(state,
+                                state->last_move_row, state->last_move_col);
+    } else {
+        active = compute_active(state, -1, -1);
+    }
+
+    clip(dr,
+         BORDER + WINDOW_OFFSET, BORDER + WINDOW_OFFSET,
+         TILE_SIZE * state->width + TILE_BORDER,
+         TILE_SIZE * state->height + TILE_BORDER);
+    
+    for (x = 0; x < ds->width; x++)
+        for (y = 0; y < ds->height; y++) {
+            unsigned char c = tile(state, x, y) | index(state, active, x, y);
+
+            /*
+             * In a completion flash, we adjust the FLASHING bit
+             * depending on our distance from the centre point and
+             * the frame number.
+             */
+            if (frame >= 0) {
+                int xdist, ydist, dist;
+                xdist = (x < state->cx ? state->cx - x : x - state->cx);
+                ydist = (y < state->cy ? state->cy - y : y - state->cy);
+                dist = (xdist > ydist ? xdist : ydist);
+
+                if (frame >= dist && frame < dist+4) {
+                    int flash = (frame - dist) & 1;
+                    flash = flash ? FLASHING : 0;
+                    c = (c &~ FLASHING) | flash;
+                }
+            }
+
+            if (index(state, ds->visible, x, y) != c ||
+                index(state, ds->visible, x, y) == 0xFF ||
+                (x == state->last_move_col || y == state->last_move_row))
+            {
+                float xs = (y == state->last_move_row ? xshift : (float)0.0);
+                float ys = (x == state->last_move_col ? yshift : (float)0.0);
+
+                draw_tile(dr, ds, state, x, y, c, xs, ys);
+                if (xs < 0 && x == 0)
+                    draw_tile(dr, ds, state, state->width, y, c, xs, ys);
+                else if (xs > 0 && x == state->width - 1)
+                    draw_tile(dr, ds, state, -1, y, c, xs, ys);
+                else if (ys < 0 && y == 0)
+                    draw_tile(dr, ds, state, x, state->height, c, xs, ys);
+                else if (ys > 0 && y == state->height - 1)
+                    draw_tile(dr, ds, state, x, -1, c, xs, ys);
+
+                if (x == state->last_move_col || y == state->last_move_row)
+                    index(state, ds->visible, x, y) = 0xFF;
+                else
+                    index(state, ds->visible, x, y) = c;
+            }
+        }
+
+    for (x = 0; x < ds->width; x++)
+        for (y = 0; y < ds->height; y++)
+            draw_tile_barriers(dr, ds, state, x, y);
+
+    unclip(dr);
+
+    /*
+     * Update the status bar.
+     */
+    {
+        char statusbuf[256];
+        int i, n, a;
+
+        n = state->width * state->height;
+        for (i = a = 0; i < n; i++)
+            if (active[i])
+                a++;
+
+        if (state->used_solve)
+            sprintf(statusbuf, "Moves since auto-solve: %d",
+                    state->move_count - state->completed);
+        else
+            sprintf(statusbuf, "%sMoves: %d",
+                    (state->completed ? "COMPLETED! " : ""),
+                    (state->completed ? state->completed : state->move_count));
+
+        if (state->movetarget)
+            sprintf(statusbuf + strlen(statusbuf), " (target %d)",
+                    state->movetarget);
+
+        sprintf(statusbuf + strlen(statusbuf), " Active: %d/%d", a, n);
+
+        status_bar(dr, statusbuf);
+    }
+
+    sfree(active);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return ANIM_TIME;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    /*
+     * If the game has just been completed, we display a completion
+     * flash.
+     */
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->used_solve && !newstate->used_solve) {
+        int size;
+        size = 0;
+        if (size < newstate->cx+1)
+            size = newstate->cx+1;
+        if (size < newstate->cy+1)
+            size = newstate->cy+1;
+        if (size < newstate->width - newstate->cx)
+            size = newstate->width - newstate->cx;
+        if (size < newstate->height - newstate->cy)
+            size = newstate->height - newstate->cy;
+        return FLASH_FRAME * (size+4);
+    }
+
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return FALSE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame netslide
+#endif
+
+const struct game thegame = {
+    "Netslide", "games.netslide", "netslide",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/no-icon.c b/apps/plugins/puzzles/no-icon.c
new file mode 100644
index 0000000000..114b2c57c7
--- /dev/null
+++ b/apps/plugins/puzzles/no-icon.c
@@ -0,0 +1,8 @@
+
+/*
+ * Dummy source file which replaces the files generated in the
+ * `icons' subdirectory, when they're absent.
+ */
+
+const char *const *const xpm_icons[] = { 0 };
+const int n_xpm_icons = 0;
diff --git a/apps/plugins/puzzles/noicon.rc b/apps/plugins/puzzles/noicon.rc
new file mode 100644
index 0000000000..1de605d605
--- /dev/null
+++ b/apps/plugins/puzzles/noicon.rc
@@ -0,0 +1,11 @@
+/* Puzzle resource file without an icon, used in the absence of icons/foo.rc */
+
+#include "puzzles.rc2"
+
+/* XXX this probably isn't the right test, but it'll do. */
+#ifdef MINGW32_FIX
+/* XXX The MinGW toolchain (specifically, windres) doesn't like a resource
+ * file with no resources. Give it a dummy one.
+ * This can go if/when VERSIONINFO resources are added. */
+200 RCDATA { 0 }
+#endif
diff --git a/apps/plugins/puzzles/nullfe.c b/apps/plugins/puzzles/nullfe.c
new file mode 100644
index 0000000000..4c9975b90e
--- /dev/null
+++ b/apps/plugins/puzzles/nullfe.c
@@ -0,0 +1,69 @@
+/*
+ * nullfe.c: Null front-end code containing a bunch of boring stub
+ * functions. Used to ensure successful linking when building the
+ * various stand-alone solver binaries.
+ */
+
+#include <stdarg.h>
+
+#include "puzzles.h"
+
+void frontend_default_colour(frontend *fe, float *output) {}
+void draw_text(drawing *dr, int x, int y, int fonttype, int fontsize,
+               int align, int colour, char *text) {}
+void draw_rect(drawing *dr, int x, int y, int w, int h, int colour) {}
+void draw_line(drawing *dr, int x1, int y1, int x2, int y2, int colour) {}
+void draw_thick_line(drawing *dr, float thickness,
+                     float x1, float y1, float x2, float y2, int colour) {}
+void draw_polygon(drawing *dr, int *coords, int npoints,
+                  int fillcolour, int outlinecolour) {}
+void draw_circle(drawing *dr, int cx, int cy, int radius,
+                 int fillcolour, int outlinecolour) {}
+char *text_fallback(drawing *dr, const char *const *strings, int nstrings)
+{ return dupstr(strings[0]); }
+void clip(drawing *dr, int x, int y, int w, int h) {}
+void unclip(drawing *dr) {}
+void start_draw(drawing *dr) {}
+void draw_update(drawing *dr, int x, int y, int w, int h) {}
+void end_draw(drawing *dr) {}
+blitter *blitter_new(drawing *dr, int w, int h) {return NULL;}
+void blitter_free(drawing *dr, blitter *bl) {}
+void blitter_save(drawing *dr, blitter *bl, int x, int y) {}
+void blitter_load(drawing *dr, blitter *bl, int x, int y) {}
+int print_mono_colour(drawing *dr, int grey) { return 0; }
+int print_grey_colour(drawing *dr, float grey) { return 0; }
+int print_hatched_colour(drawing *dr, int hatch) { return 0; }
+int print_rgb_mono_colour(drawing *dr, float r, float g, float b, int grey)
+{ return 0; }
+int print_rgb_grey_colour(drawing *dr, float r, float g, float b, float grey)
+{ return 0; }
+int print_rgb_hatched_colour(drawing *dr, float r, float g, float b, int hatch)
+{ return 0; }
+void print_line_width(drawing *dr, int width) {}
+void print_line_dotted(drawing *dr, int dotted) {}
+void midend_supersede_game_desc(midend *me, char *desc, char *privdesc) {}
+void status_bar(drawing *dr, char *text) {}
+
+void fatal(char *fmt, ...)
+{
+    va_list ap;
+
+    fprintf(stderr, "fatal error: ");
+
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+
+    fprintf(stderr, "\n");
+    exit(1);
+}
+
+#ifdef DEBUGGING
+void debug_printf(char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    vfprintf(stdout, fmt, ap);
+    va_end(ap);
+}
+#endif
diff --git a/apps/plugins/puzzles/nullgame.R b/apps/plugins/puzzles/nullgame.R
new file mode 100644
index 0000000000..41bdb85d57
--- /dev/null
+++ b/apps/plugins/puzzles/nullgame.R
@@ -0,0 +1,12 @@
+# -*- makefile -*-
+
+# The `nullgame' source file is a largely blank one, which contains
+# all the correct function definitions to compile and link, but
+# which defines the null game in which nothing is ever drawn and
+# there are no valid moves. Its main purpose is to act as a
+# template for writing new game definition source files. I include
+# it in the Makefile because it will be worse than useless if it
+# ever fails to compile, so it's important that it should actually
+# be built on a regular basis.
+nullgame : [X] GTK COMMON nullgame nullgame-icon|no-icon
+nullgame : [G] WINDOWS COMMON nullgame nullgame.res|noicon.res
diff --git a/apps/plugins/puzzles/nullgame.c b/apps/plugins/puzzles/nullgame.c
new file mode 100644
index 0000000000..6e14c3237c
--- /dev/null
+++ b/apps/plugins/puzzles/nullgame.c
@@ -0,0 +1,303 @@
+/*
+ * nullgame.c [FIXME]: Template defining the null game (in which no
+ * moves are permitted and nothing is ever drawn). This file exists
+ * solely as a basis for constructing new game definitions - it
+ * helps to have something which will compile from the word go and
+ * merely doesn't _do_ very much yet.
+ * 
+ * Parts labelled FIXME actually want _removing_ (e.g. the dummy
+ * field in each of the required data structures, and this entire
+ * comment itself) when converting this source file into one
+ * describing a real game.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+enum {
+    COL_BACKGROUND,
+    NCOLOURS
+};
+
+struct game_params {
+    int FIXME;
+};
+
+struct game_state {
+    int FIXME;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->FIXME = 0;
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    return FALSE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    return dupstr("FIXME");
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    return NULL;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    return NULL;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    return NULL;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    return dupstr("FIXME");
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+
+    state->FIXME = 0;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->FIXME = state->FIXME;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return NULL;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+static game_ui *new_ui(const game_state *state)
+{
+    return NULL;
+}
+
+static void free_ui(game_ui *ui)
+{
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int tilesize;
+    int FIXME;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    *x = *y = 10 * tilesize;           /* FIXME */
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->tilesize = 0;
+    ds->FIXME = 0;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    /*
+     * The initial contents of the window are not guaranteed and
+     * can vary with front ends. To be on the safe side, all games
+     * should start by drawing a big background-colour rectangle
+     * covering the whole window.
+     */
+    draw_rect(dr, 0, 0, 10*ds->tilesize, 10*ds->tilesize, COL_BACKGROUND);
+    draw_update(dr, 0, 0, 10*ds->tilesize, 10*ds->tilesize);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame nullgame
+#endif
+
+const struct game thegame = {
+    "Null Game", NULL, NULL,
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    FALSE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    FALSE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    20 /* FIXME */, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
diff --git a/apps/plugins/puzzles/obfusc.c b/apps/plugins/puzzles/obfusc.c
new file mode 100644
index 0000000000..e95fa3f397
--- /dev/null
+++ b/apps/plugins/puzzles/obfusc.c
@@ -0,0 +1,126 @@
+/*
+ * Stand-alone tool to access the Puzzles obfuscation algorithm.
+ * 
+ * To deobfuscate, use "obfusc -d":
+ * 
+ *   obfusc -d                 reads binary data from stdin, writes to stdout
+ *   obfusc -d <hex string>    works on the given hex string instead of stdin
+ *   obfusc -d -h              writes a hex string instead of binary to stdout
+ *
+ * To obfuscate, "obfusc -e":
+ * 
+ *   obfusc -e                 reads binary from stdin, writes hex to stdout
+ *   obfusc -e <hex string>    works on the given hex string instead of stdin
+ *   obfusc -e -b              writes binary instead of text to stdout
+ *
+ * The default output format is hex for -e and binary for -d
+ * because that's the way obfuscation is generally used in
+ * Puzzles. Either of -b and -h can always be specified to set it
+ * explicitly.
+ *
+ * Data read from standard input is assumed always to be binary;
+ * data provided on the command line is taken to be hex.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+
+#include "puzzles.h"
+
+int main(int argc, char **argv)
+{
+    enum { BINARY, DEFAULT, HEX } outputmode = DEFAULT;
+    char *inhex = NULL;
+    unsigned char *data;
+    int datalen;
+    int decode = -1;
+    int doing_opts = TRUE;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+
+        if (doing_opts && *p == '-') {
+            if (!strcmp(p, "--")) {
+                doing_opts = 0;
+                continue;
+            }
+            p++;
+            while (*p) {
+                switch (*p) {
+                  case 'e':
+                    decode = 0;
+                    break;
+                  case 'd':
+                    decode = 1;
+                    break;
+                  case 'b':
+                    outputmode = BINARY;
+                    break;
+                  case 'h':
+                    outputmode = HEX;
+                    break;
+                  default:
+                    return 1;
+                }
+                p++;
+            }
+        } else {
+            if (!inhex) {
+                inhex = p;
+            } else {
+                return 1;
+            }
+        }
+    }
+
+    if (decode < 0) {
+        return 0;
+    }
+
+    if (outputmode == DEFAULT)
+        outputmode = (decode ? BINARY : HEX);
+
+    if (inhex) {
+        datalen = strlen(inhex) / 2;
+        data = hex2bin(inhex, datalen);
+    } else {
+        int datasize = 4096;
+        datalen = 0;
+        data = snewn(datasize, unsigned char);
+        while (1) {
+            int ret = fread(data + datalen, 1, datasize - datalen, stdin);
+            if (ret < 0) {
+                fprintf(stderr, "obfusc: read: %s\n", strerror(errno));
+                return 1;
+            } else if (ret == 0) {
+                break;
+            } else {
+                datalen += ret;
+                if (datasize - datalen < 4096) {
+                    datasize = datalen * 5 / 4 + 4096;
+                    data = sresize(data, datasize, unsigned char);
+                }
+            }
+        }
+    }
+
+    obfuscate_bitmap(data, datalen * 8, decode);
+
+    if (outputmode == BINARY) {
+        int ret = fwrite(data, 1, datalen, stdout);
+        if (ret < 0) {
+            fprintf(stderr, "obfusc: write: %s\n", strerror(errno));
+            return 1;
+        }
+    } else {
+        int i;
+        for (i = 0; i < datalen; i++)
+            printf("%02x", data[i]);
+        printf("\n");
+    }
+
+    return 0;
+}
diff --git a/apps/plugins/puzzles/osx-help.but b/apps/plugins/puzzles/osx-help.but
new file mode 100644
index 0000000000..fa45996aee
--- /dev/null
+++ b/apps/plugins/puzzles/osx-help.but
@@ -0,0 +1,14 @@
+\# Additional Halibut fragment to set up the HTML output
+\# appropriately for MacOS online help.
+
+\cfg{html-head-end}{
+<style type="text/css">
+body \{ font-family: "Lucida Grande", Helvetica, Arial; font-size: 9pt \}
+h1 \{ font-size: 12pt \}
+h2 \{ font-size: 10pt \}
+h3 \{ font-size: 9pt \}
+h4 \{ font-size: 9pt \}
+h5 \{ font-size: 9pt \}
+h6 \{ font-size: 9pt \}
+</style>
+}
diff --git a/apps/plugins/puzzles/osx-info.plist b/apps/plugins/puzzles/osx-info.plist
new file mode 100644
index 0000000000..9f4aef8e53
--- /dev/null
+++ b/apps/plugins/puzzles/osx-info.plist
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+        <key>CFBundleIconFile</key>
+        <string>Puzzles.icns</string>
+        <key>CFBundleHelpBookFolder</key>
+        <string>Help</string>
+        <key>CFBundleHelpBookName</key>
+        <string>Puzzles Help</string>
+        <key>CFBundleName</key>
+        <string>Puzzles</string>
+        <key>CFBundleDisplayName</key>
+        <string>Puzzles</string>
+        <key>CFBundleExecutable</key>
+        <string>Puzzles</string>
+        <key>CFBundleVersion</key>
+        <string>Unidentified build</string>
+        <key>CFBundleShortVersionString</key>
+        <string>Unidentified build</string>
+        <key>CFBundleDevelopmentRegion</key>
+        <string>en</string>
+        <key>CFBundleIdentifier</key>
+        <string>uk.org.greenend.chiark.sgtatham.puzzles</string>
+        <key>CFBundleInfoDictionaryVersion</key>
+        <string>6.0</string>
+        <key>CFBundlePackageType</key>
+        <string>APPL</string>
+        <key>CFBundleSignature</key>
+        <string>????</string>
+        <key>NSHumanReadableCopyright</key>
+        <string>This software is copyright (c) 2004-2014 Simon Tatham</string>
+</dict>
+</plist>
diff --git a/apps/plugins/puzzles/osx.icns b/apps/plugins/puzzles/osx.icns
new file mode 100644
index 0000000000..b4346a0da1
--- /dev/null
+++ b/apps/plugins/puzzles/osx.icns
diff --git a/apps/plugins/puzzles/osx.m b/apps/plugins/puzzles/osx.m
new file mode 100644
index 0000000000..4740124175
--- /dev/null
+++ b/apps/plugins/puzzles/osx.m
@@ -0,0 +1,1724 @@
+/*
+ * Mac OS X / Cocoa front end to puzzles.
+ *
+ * Still to do:
+ * 
+ *  - I'd like to be able to call up context help for a specific
+ *    game at a time.
+ * 
+ * Mac interface issues that possibly could be done better:
+ * 
+ *  - is there a better approach to frontend_default_colour?
+ *
+ *  - do we need any more options in the Window menu?
+ *
+ *  - can / should we be doing anything with the titles of the
+ *    configuration boxes?
+ * 
+ *  - not sure what I should be doing about default window
+ *    placement. Centring new windows is a bit feeble, but what's
+ *    better? Is there a standard way to tell the OS "here's the
+ *    _size_ of window I want, now use your best judgment about the
+ *    initial position"?
+ *     + there's a standard _policy_ on window placement, given in
+ *       the HI guidelines. Have to implement it ourselves though,
+ *       bah.
+ *
+ *  - a brief frob of the Mac numeric keypad suggests that it
+ *    generates numbers no matter what you do. I wonder if I should
+ *    try to figure out a way of detecting keypad codes so I can
+ *    implement UP_LEFT and friends. Alternatively, perhaps I
+ *    should simply assign the number keys to UP_LEFT et al?
+ *    They're not in use for anything else right now.
+ *
+ *  - see if we can do anything to one-button-ise the multi-button
+ *    dependent puzzle UIs:
+ *     - Pattern is a _little_ unwieldy but not too bad (since
+ *       generally you never need the middle button unless you've
+ *       made a mistake, so it's just click versus command-click).
+ *     - Net is utterly vile; having normal click be one rotate and
+ *       command-click be the other introduces a horrid asymmetry,
+ *       and yet requiring a shift key for _each_ click would be
+ *       even worse because rotation feels as if it ought to be the
+ *       default action. I fear this is why the Flash Net had the
+ *       UI it did...
+ *        + I've tried out an alternative dragging interface for
+ *          Net; it might work nicely for stylus-based platforms
+ *          where you have better hand/eye feedback for the thing
+ *          you're clicking on, but it's rather unwieldy on the
+ *          Mac. I fear even shift-clicking is better than that.
+ *
+ *  - Should we _return_ to a game configuration sheet once an
+ *    error is reported by midend_set_config, to allow the user to
+ *    correct the one faulty input and keep the other five OK ones?
+ *    The Apple `one sheet at a time' restriction would require me
+ *    to do this by closing the config sheet, opening the alert
+ *    sheet, and then reopening the config sheet when the alert is
+ *    closed; and the human interface types, who presumably
+ *    invented the one-sheet-at-a-time rule for good reasons, might
+ *    look with disfavour on me trying to get round them to fake a
+ *    nested sheet. On the other hand I think there are good
+ *    practical reasons for wanting it that way. Uncertain.
+ * 
+ *  - User feedback dislikes nothing happening when you start the
+ *    app; they suggest a finder-like window containing an icon for
+ *    each puzzle type, enabling you to start one easily. Needs
+ *    thought.
+ * 
+ * Grotty implementation details that could probably be improved:
+ * 
+ *  - I am _utterly_ unconvinced that NSImageView was the right way
+ *    to go about having a window with a reliable backing store! It
+ *    just doesn't feel right; NSImageView is a _control_. Is there
+ *    a simpler way?
+ * 
+ *  - Resizing is currently very bad; rather than bother to work
+ *    out how to resize the NSImageView, I just splatter and
+ *    recreate it.
+ */
+
+#define COMBINED /* we put all the puzzles in one binary in this port */
+
+#include <ctype.h>
+#include <time.h>
+#include <sys/time.h>
+#import <Cocoa/Cocoa.h>
+#include "puzzles.h"
+
+/* ----------------------------------------------------------------------
+ * Global variables.
+ */
+
+/*
+ * The `Type' menu. We frob this dynamically to allow the user to
+ * choose a preset set of settings from the current game.
+ */
+NSMenu *typemenu;
+
+/*
+ * Forward reference.
+ */
+extern const struct drawing_api osx_drawing;
+
+/*
+ * The NSApplication shared instance, which I'll want to refer to from
+ * a few places here and there.
+ */
+NSApplication *app;
+
+/* ----------------------------------------------------------------------
+ * Miscellaneous support routines that aren't part of any object or
+ * clearly defined subsystem.
+ */
+
+void fatal(char *fmt, ...)
+{
+    va_list ap;
+    char errorbuf[2048];
+    NSAlert *alert;
+
+    va_start(ap, fmt);
+    vsnprintf(errorbuf, lenof(errorbuf), fmt, ap);
+    va_end(ap);
+
+    alert = [NSAlert alloc];
+    /*
+     * We may have come here because we ran out of memory, in which
+     * case it's entirely likely that that alloc will fail, so we
+     * should have a fallback of some sort.
+     */
+    if (!alert) {
+        fprintf(stderr, "fatal error (and NSAlert failed): %s\n", errorbuf);
+    } else {
+        alert = [[alert init] autorelease];
+        [alert addButtonWithTitle:@"Oh dear"];
+        [alert setInformativeText:[NSString stringWithUTF8String:errorbuf]];
+        [alert runModal];
+    }
+    exit(1);
+}
+
+void frontend_default_colour(frontend *fe, float *output)
+{
+    /* FIXME: Is there a system default we can tap into for this? */
+    output[0] = output[1] = output[2] = 0.8F;
+}
+
+void get_random_seed(void **randseed, int *randseedsize)
+{
+    time_t *tp = snew(time_t);
+    time(tp);
+    *randseed = (void *)tp;
+    *randseedsize = sizeof(time_t);
+}
+
+static void savefile_write(void *wctx, void *buf, int len)
+{
+    FILE *fp = (FILE *)wctx;
+    fwrite(buf, 1, len, fp);
+}
+
+static int savefile_read(void *wctx, void *buf, int len)
+{
+    FILE *fp = (FILE *)wctx;
+    int ret;
+
+    ret = fread(buf, 1, len, fp);
+    return (ret == len);
+}
+
+/*
+ * Since this front end does not support printing (yet), we need
+ * this stub to satisfy the reference in midend_print_puzzle().
+ */
+void document_add_puzzle(document *doc, const game *game, game_params *par,
+                         game_state *st, game_state *st2)
+{
+}
+
+/*
+ * setAppleMenu isn't listed in the NSApplication header, but an
+ * NSApp responds to it, so we're adding it here to silence
+ * warnings. (This was removed from the headers in 10.4, so we
+ * only need to include it for 10.4+.)
+ */
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1040
+@interface NSApplication(NSAppleMenu)
+- (void)setAppleMenu:(NSMenu *)menu;
+@end
+#endif
+
+/* ----------------------------------------------------------------------
+ * Tiny extension to NSMenuItem which carries a payload of a `void
+ * *', allowing several menu items to invoke the same message but
+ * pass different data through it.
+ */
+@interface DataMenuItem : NSMenuItem
+{
+    void *payload;
+}
+- (void)setPayload:(void *)d;
+- (void *)getPayload;
+@end
+@implementation DataMenuItem
+- (void)setPayload:(void *)d
+{
+    payload = d;
+}
+- (void *)getPayload
+{
+    return payload;
+}
+@end
+
+/* ----------------------------------------------------------------------
+ * Utility routines for constructing OS X menus.
+ */
+
+NSMenu *newmenu(const char *title)
+{
+    return [[[NSMenu allocWithZone:[NSMenu menuZone]]
+             initWithTitle:[NSString stringWithUTF8String:title]]
+            autorelease];
+}
+
+NSMenu *newsubmenu(NSMenu *parent, const char *title)
+{
+    NSMenuItem *item;
+    NSMenu *child;
+
+    item = [[[NSMenuItem allocWithZone:[NSMenu menuZone]]
+             initWithTitle:[NSString stringWithUTF8String:title]
+             action:NULL
+             keyEquivalent:@""]
+            autorelease];
+    child = newmenu(title);
+    [item setEnabled:YES];
+    [item setSubmenu:child];
+    [parent addItem:item];
+    return child;
+}
+
+id initnewitem(NSMenuItem *item, NSMenu *parent, const char *title,
+               const char *key, id target, SEL action)
+{
+    unsigned mask = NSCommandKeyMask;
+
+    if (key[strcspn(key, "-")]) {
+        while (*key && *key != '-') {
+            int c = tolower((unsigned char)*key);
+            if (c == 's') {
+                mask |= NSShiftKeyMask;
+            } else if (c == 'o' || c == 'a') {
+                mask |= NSAlternateKeyMask;
+            }
+            key++;
+        }
+        if (*key)
+            key++;
+    }
+
+    item = [[item initWithTitle:[NSString stringWithUTF8String:title]
+             action:NULL
+             keyEquivalent:[NSString stringWithUTF8String:key]]
+            autorelease];
+
+    if (*key)
+        [item setKeyEquivalentModifierMask: mask];
+
+    [item setEnabled:YES];
+    [item setTarget:target];
+    [item setAction:action];
+
+    [parent addItem:item];
+
+    return item;
+}
+
+NSMenuItem *newitem(NSMenu *parent, char *title, char *key,
+                    id target, SEL action)
+{
+    return initnewitem([NSMenuItem allocWithZone:[NSMenu menuZone]],
+                       parent, title, key, target, action);
+}
+
+/* ----------------------------------------------------------------------
+ * About box.
+ */
+
+@class AboutBox;
+
+@interface AboutBox : NSWindow
+{
+}
+- (id)init;
+@end
+
+@implementation AboutBox
+- (id)init
+{
+    NSRect totalrect;
+    NSView *views[16];
+    int nviews = 0;
+    NSImageView *iv;
+    NSTextField *tf;
+    NSFont *font1 = [NSFont systemFontOfSize:0];
+    NSFont *font2 = [NSFont boldSystemFontOfSize:[font1 pointSize] * 1.1];
+    const int border = 24;
+    int i;
+    double y;
+
+    /*
+     * Construct the controls that go in the About box.
+     */
+
+    iv = [[NSImageView alloc] initWithFrame:NSMakeRect(0,0,64,64)];
+    [iv setImage:[NSImage imageNamed:@"NSApplicationIcon"]];
+    views[nviews++] = iv;
+
+    tf = [[NSTextField alloc]
+          initWithFrame:NSMakeRect(0,0,400,1)];
+    [tf setEditable:NO];
+    [tf setSelectable:NO];
+    [tf setBordered:NO];
+    [tf setDrawsBackground:NO];
+    [tf setFont:font2];
+    [tf setStringValue:@"Simon Tatham's Portable Puzzle Collection"];
+    [tf sizeToFit];
+    views[nviews++] = tf;
+
+    tf = [[NSTextField alloc]
+          initWithFrame:NSMakeRect(0,0,400,1)];
+    [tf setEditable:NO];
+    [tf setSelectable:NO];
+    [tf setBordered:NO];
+    [tf setDrawsBackground:NO];
+    [tf setFont:font1];
+    [tf setStringValue:[NSString stringWithUTF8String:ver]];
+    [tf sizeToFit];
+    views[nviews++] = tf;
+
+    /*
+     * Lay the controls out.
+     */
+    totalrect = NSMakeRect(0,0,0,0);
+    for (i = 0; i < nviews; i++) {
+        NSRect r = [views[i] frame];
+        if (totalrect.size.width < r.size.width)
+            totalrect.size.width = r.size.width;
+        totalrect.size.height += border + r.size.height;
+    }
+    totalrect.size.width += 2 * border;
+    totalrect.size.height += border;
+    y = totalrect.size.height;
+    for (i = 0; i < nviews; i++) {
+        NSRect r = [views[i] frame];
+        r.origin.x = (totalrect.size.width - r.size.width) / 2;
+        y -= border + r.size.height;
+        r.origin.y = y;
+        [views[i] setFrame:r];
+    }
+
+    self = [super initWithContentRect:totalrect
+            styleMask:(NSTitledWindowMask | NSMiniaturizableWindowMask |
+                       NSClosableWindowMask)
+            backing:NSBackingStoreBuffered
+            defer:YES];
+
+    for (i = 0; i < nviews; i++)
+        [[self contentView] addSubview:views[i]];
+
+    [self center];                     /* :-) */
+
+    return self;
+}
+@end
+
+/* ----------------------------------------------------------------------
+ * The front end presented to midend.c.
+ * 
+ * This is mostly a subclass of NSWindow. The actual `frontend'
+ * structure passed to the midend contains a variety of pointers,
+ * including that window object but also including the image we
+ * draw on, an ImageView to display it in the window, and so on.
+ */
+
+@class GameWindow;
+@class MyImageView;
+
+struct frontend {
+    GameWindow *window;
+    NSImage *image;
+    MyImageView *view;
+    NSColor **colours;
+    int ncolours;
+    int clipped;
+    int w, h;
+};
+
+@interface MyImageView : NSImageView
+{
+    GameWindow *ourwin;
+}
+- (void)setWindow:(GameWindow *)win;
+- (void)mouseEvent:(NSEvent *)ev button:(int)b;
+- (void)mouseDown:(NSEvent *)ev;
+- (void)mouseDragged:(NSEvent *)ev;
+- (void)mouseUp:(NSEvent *)ev;
+- (void)rightMouseDown:(NSEvent *)ev;
+- (void)rightMouseDragged:(NSEvent *)ev;
+- (void)rightMouseUp:(NSEvent *)ev;
+- (void)otherMouseDown:(NSEvent *)ev;
+- (void)otherMouseDragged:(NSEvent *)ev;
+- (void)otherMouseUp:(NSEvent *)ev;
+@end
+
+@interface GameWindow : NSWindow
+{
+    const game *ourgame;
+    midend *me;
+    struct frontend fe;
+    struct timeval last_time;
+    NSTimer *timer;
+    NSWindow *sheet;
+    config_item *cfg;
+    int cfg_which;
+    NSView **cfg_controls;
+    int cfg_ncontrols;
+    NSTextField *status;
+}
+- (id)initWithGame:(const game *)g;
+- (void)dealloc;
+- (void)processButton:(int)b x:(int)x y:(int)y;
+- (void)processKey:(int)b;
+- (void)keyDown:(NSEvent *)ev;
+- (void)activateTimer;
+- (void)deactivateTimer;
+- (void)setStatusLine:(char *)text;
+- (void)resizeForNewGameParams;
+- (void)updateTypeMenuTick;
+@end
+
+@implementation MyImageView
+
+- (void)setWindow:(GameWindow *)win
+{
+    ourwin = win;
+}
+
+- (void)mouseEvent:(NSEvent *)ev button:(int)b
+{
+    NSPoint point = [self convertPoint:[ev locationInWindow] fromView:nil];
+    [ourwin processButton:b x:point.x y:point.y];
+}
+
+- (void)mouseDown:(NSEvent *)ev
+{
+    unsigned mod = [ev modifierFlags];
+    [self mouseEvent:ev button:((mod & NSCommandKeyMask) ? RIGHT_BUTTON :
+                                (mod & NSShiftKeyMask) ? MIDDLE_BUTTON :
+                                LEFT_BUTTON)];
+}
+- (void)mouseDragged:(NSEvent *)ev
+{
+    unsigned mod = [ev modifierFlags];
+    [self mouseEvent:ev button:((mod & NSCommandKeyMask) ? RIGHT_DRAG :
+                                (mod & NSShiftKeyMask) ? MIDDLE_DRAG :
+                                LEFT_DRAG)];
+}
+- (void)mouseUp:(NSEvent *)ev
+{
+    unsigned mod = [ev modifierFlags];
+    [self mouseEvent:ev button:((mod & NSCommandKeyMask) ? RIGHT_RELEASE :
+                                (mod & NSShiftKeyMask) ? MIDDLE_RELEASE :
+                                LEFT_RELEASE)];
+}
+- (void)rightMouseDown:(NSEvent *)ev
+{
+    unsigned mod = [ev modifierFlags];
+    [self mouseEvent:ev button:((mod & NSShiftKeyMask) ? MIDDLE_BUTTON :
+                                RIGHT_BUTTON)];
+}
+- (void)rightMouseDragged:(NSEvent *)ev
+{
+    unsigned mod = [ev modifierFlags];
+    [self mouseEvent:ev button:((mod & NSShiftKeyMask) ? MIDDLE_DRAG :
+                                RIGHT_DRAG)];
+}
+- (void)rightMouseUp:(NSEvent *)ev
+{
+    unsigned mod = [ev modifierFlags];
+    [self mouseEvent:ev button:((mod & NSShiftKeyMask) ? MIDDLE_RELEASE :
+                                RIGHT_RELEASE)];
+}
+- (void)otherMouseDown:(NSEvent *)ev
+{
+    [self mouseEvent:ev button:MIDDLE_BUTTON];
+}
+- (void)otherMouseDragged:(NSEvent *)ev
+{
+    [self mouseEvent:ev button:MIDDLE_DRAG];
+}
+- (void)otherMouseUp:(NSEvent *)ev
+{
+    [self mouseEvent:ev button:MIDDLE_RELEASE];
+}
+@end
+
+@implementation GameWindow
+- (void)setupContentView
+{
+    NSRect frame;
+    int w, h;
+
+    if (status) {
+        frame = [status frame];
+        frame.origin.y = frame.size.height;
+    } else
+        frame.origin.y = 0;
+    frame.origin.x = 0;
+
+    w = h = INT_MAX;
+    midend_size(me, &w, &h, FALSE);
+    frame.size.width = w;
+    frame.size.height = h;
+    fe.w = w;
+    fe.h = h;
+
+    fe.image = [[NSImage alloc] initWithSize:frame.size];
+    fe.view = [[MyImageView alloc] initWithFrame:frame];
+    [fe.view setImage:fe.image];
+    [fe.view setWindow:self];
+
+    midend_redraw(me);
+
+    [[self contentView] addSubview:fe.view];
+}
+- (id)initWithGame:(const game *)g
+{
+    NSRect rect = { {0,0}, {0,0} }, rect2;
+    int w, h;
+
+    ourgame = g;
+
+    fe.window = self;
+
+    me = midend_new(&fe, ourgame, &osx_drawing, &fe);
+    /*
+     * If we ever need to open a fresh window using a provided game
+     * ID, I think the right thing is to move most of this method
+     * into a new initWithGame:gameID: method, and have
+     * initWithGame: simply call that one and pass it NULL.
+     */
+    midend_new_game(me);
+    w = h = INT_MAX;
+    midend_size(me, &w, &h, FALSE);
+    rect.size.width = w;
+    rect.size.height = h;
+    fe.w = w;
+    fe.h = h;
+
+    /*
+     * Create the status bar, which will just be an NSTextField.
+     */
+    if (midend_wants_statusbar(me)) {
+        status = [[NSTextField alloc] initWithFrame:NSMakeRect(0,0,100,50)];
+        [status setEditable:NO];
+        [status setSelectable:NO];
+        [status setBordered:YES];
+        [status setBezeled:YES];
+        [status setBezelStyle:NSTextFieldSquareBezel];
+        [status setDrawsBackground:YES];
+        [[status cell] setTitle:@DEFAULT_STATUSBAR_TEXT];
+        [status sizeToFit];
+        rect2 = [status frame];
+        rect.size.height += rect2.size.height;
+        rect2.size.width = rect.size.width;
+        rect2.origin.x = rect2.origin.y = 0;
+        [status setFrame:rect2];
+    } else
+        status = nil;
+
+    self = [super initWithContentRect:rect
+            styleMask:(NSTitledWindowMask | NSMiniaturizableWindowMask |
+                       NSClosableWindowMask)
+            backing:NSBackingStoreBuffered
+            defer:YES];
+    [self setTitle:[NSString stringWithUTF8String:ourgame->name]];
+
+    {
+        float *colours;
+        int i, ncolours;
+
+        colours = midend_colours(me, &ncolours);
+        fe.ncolours = ncolours;
+        fe.colours = snewn(ncolours, NSColor *);
+
+        for (i = 0; i < ncolours; i++) {
+            fe.colours[i] = [[NSColor colorWithDeviceRed:colours[i*3]
+                              green:colours[i*3+1] blue:colours[i*3+2]
+                              alpha:1.0] retain];
+        }
+    }
+
+    [self setupContentView];
+    if (status)
+        [[self contentView] addSubview:status];
+    [self setIgnoresMouseEvents:NO];
+
+    [self center];                     /* :-) */
+
+    return self;
+}
+
+- (void)dealloc
+{
+    int i;
+    for (i = 0; i < fe.ncolours; i++) {
+        [fe.colours[i] release];
+    }
+    sfree(fe.colours);
+    midend_free(me);
+    [super dealloc];
+}
+
+- (void)processButton:(int)b x:(int)x y:(int)y
+{
+    if (!midend_process_key(me, x, fe.h - 1 - y, b))
+        [self close];
+}
+
+- (void)processKey:(int)b
+{
+    if (!midend_process_key(me, -1, -1, b))
+        [self close];
+}
+
+- (void)keyDown:(NSEvent *)ev
+{
+    NSString *s = [ev characters];
+    int i, n = [s length];
+
+    for (i = 0; i < n; i++) {
+        int c = [s characterAtIndex:i];
+
+        /*
+         * ASCII gets passed straight to midend_process_key.
+         * Anything above that has to be translated to our own
+         * function key codes.
+         */
+        if (c >= 0x80) {
+            int mods = FALSE;
+            switch (c) {
+              case NSUpArrowFunctionKey:
+                c = CURSOR_UP;
+                mods = TRUE;
+                break;
+              case NSDownArrowFunctionKey:
+                c = CURSOR_DOWN;
+                mods = TRUE;
+                break;
+              case NSLeftArrowFunctionKey:
+                c = CURSOR_LEFT;
+                mods = TRUE;
+                break;
+              case NSRightArrowFunctionKey:
+                c = CURSOR_RIGHT;
+                mods = TRUE;
+                break;
+              default:
+                continue;
+            }
+
+            if (mods) {
+                if ([ev modifierFlags] & NSShiftKeyMask)
+                    c |= MOD_SHFT;
+                if ([ev modifierFlags] & NSControlKeyMask)
+                    c |= MOD_CTRL;
+            }
+        }
+
+        if (c >= '0' && c <= '9' && ([ev modifierFlags] & NSNumericPadKeyMask))
+            c |= MOD_NUM_KEYPAD;
+
+        [self processKey:c];
+    }
+}
+
+- (void)activateTimer
+{
+    if (timer != nil)
+        return;
+
+    timer = [NSTimer scheduledTimerWithTimeInterval:0.02
+             target:self selector:@selector(timerTick:)
+             userInfo:nil repeats:YES];
+    gettimeofday(&last_time, NULL);
+}
+
+- (void)deactivateTimer
+{
+    if (timer == nil)
+        return;
+
+    [timer invalidate];
+    timer = nil;
+}
+
+- (void)timerTick:(id)sender
+{
+    struct timeval now;
+    float elapsed;
+    gettimeofday(&now, NULL);
+    elapsed = ((now.tv_usec - last_time.tv_usec) * 0.000001F +
+               (now.tv_sec - last_time.tv_sec));
+    midend_timer(me, elapsed);
+    last_time = now;
+}
+
+- (void)showError:(char *)message
+{
+    NSAlert *alert;
+
+    alert = [[[NSAlert alloc] init] autorelease];
+    [alert addButtonWithTitle:@"Bah"];
+    [alert setInformativeText:[NSString stringWithUTF8String:message]];
+    [alert beginSheetModalForWindow:self modalDelegate:nil
+     didEndSelector:NULL contextInfo:nil];
+}
+
+- (void)newGame:(id)sender
+{
+    [self processKey:'n'];
+}
+- (void)restartGame:(id)sender
+{
+    midend_restart_game(me);
+}
+- (void)saveGame:(id)sender
+{
+    NSSavePanel *sp = [NSSavePanel savePanel];
+
+    if ([sp runModal] == NSFileHandlingPanelOKButton) {
+       const char *name = [[sp filename] UTF8String];
+
+        FILE *fp = fopen(name, "w");
+
+        if (!fp) {
+            [self showError:"Unable to open save file"];
+            return;
+        }
+
+        midend_serialise(me, savefile_write, fp);
+
+        fclose(fp);
+    }
+}
+- (void)loadSavedGame:(id)sender
+{
+    NSOpenPanel *op = [NSOpenPanel openPanel];
+
+    [op setAllowsMultipleSelection:NO];
+
+    if ([op runModalForTypes:nil] == NSOKButton) {
+        /*
+         * This used to be
+         *
+         *    [[[op filenames] objectAtIndex:0] cString]
+         *
+         * but the plain cString method became deprecated and Xcode 7
+         * started complaining about it. Since OS X 10.9 we can
+         * apparently use the more modern API
+         *
+         *    [[[op URLs] objectAtIndex:0] fileSystemRepresentation]
+         *
+         * but the alternative below still compiles with Xcode 7 and
+         * is a bit more backwards compatible, so I'll try it for the
+         * moment.
+         */
+        const char *name = [[[op filenames] objectAtIndex:0]
+                               cStringUsingEncoding:
+                                   [NSString defaultCStringEncoding]];
+        char *err;
+
+        FILE *fp = fopen(name, "r");
+
+        if (!fp) {
+            [self showError:"Unable to open saved game file"];
+            return;
+        }
+
+        err = midend_deserialise(me, savefile_read, fp);
+
+        fclose(fp);
+
+        if (err) {
+            [self showError:err];
+            return;
+        }
+
+        [self resizeForNewGameParams];
+        [self updateTypeMenuTick];
+    }
+}
+- (void)undoMove:(id)sender
+{
+    [self processKey:'u'];
+}
+- (void)redoMove:(id)sender
+{
+    [self processKey:'r'&0x1F];
+}
+
+- (void)copy:(id)sender
+{
+    char *text;
+
+    if ((text = midend_text_format(me)) != NULL) {
+        NSPasteboard *pb = [NSPasteboard generalPasteboard];
+        NSArray *a = [NSArray arrayWithObject:NSStringPboardType];
+        [pb declareTypes:a owner:nil];
+        [pb setString:[NSString stringWithUTF8String:text]
+         forType:NSStringPboardType];
+    } else
+        NSBeep();
+}
+
+- (void)solveGame:(id)sender
+{
+    char *msg;
+
+    msg = midend_solve(me);
+
+    if (msg)
+        [self showError:msg];
+}
+
+- (BOOL)validateMenuItem:(NSMenuItem *)item
+{
+    if ([item action] == @selector(copy:))
+        return (ourgame->can_format_as_text_ever &&
+                midend_can_format_as_text_now(me) ? YES : NO);
+    else if ([item action] == @selector(solveGame:))
+        return (ourgame->can_solve ? YES : NO);
+    else
+        return [super validateMenuItem:item];
+}
+
+- (void)clearTypeMenu
+{
+    while ([typemenu numberOfItems] > 1)
+        [typemenu removeItemAtIndex:0];
+    [[typemenu itemAtIndex:0] setState:NSOffState];
+}
+
+- (void)updateTypeMenuTick
+{
+    int i, total, n;
+
+    total = [typemenu numberOfItems];
+    n = midend_which_preset(me);
+    if (n < 0)
+        n = total - 1;                 /* that's always where "Custom" lives */
+    for (i = 0; i < total; i++)
+        [[typemenu itemAtIndex:i] setState:(i == n ? NSOnState : NSOffState)];
+}
+
+- (void)becomeKeyWindow
+{
+    int n;
+
+    [self clearTypeMenu];
+
+    [super becomeKeyWindow];
+
+    n = midend_num_presets(me);
+
+    if (n > 0) {
+        [typemenu insertItem:[NSMenuItem separatorItem] atIndex:0];
+        while (n--) {
+            char *name;
+            game_params *params;
+            DataMenuItem *item;
+
+            midend_fetch_preset(me, n, &name, &params);
+
+            item = [[[DataMenuItem alloc]
+                     initWithTitle:[NSString stringWithUTF8String:name]
+                     action:NULL keyEquivalent:@""]
+                    autorelease];
+
+            [item setEnabled:YES];
+            [item setTarget:self];
+            [item setAction:@selector(presetGame:)];
+            [item setPayload:params];
+
+            [typemenu insertItem:item atIndex:0];
+        }
+    }
+
+    [self updateTypeMenuTick];
+}
+
+- (void)resignKeyWindow
+{
+    [self clearTypeMenu];
+    [super resignKeyWindow];
+}
+
+- (void)close
+{
+    [self clearTypeMenu];
+    [super close];
+}
+
+- (void)resizeForNewGameParams
+{
+    NSSize size = {0,0};
+    int w, h;
+
+    w = h = INT_MAX;
+    midend_size(me, &w, &h, FALSE);
+    size.width = w;
+    size.height = h;
+    fe.w = w;
+    fe.h = h;
+
+    if (status) {
+        NSRect frame = [status frame];
+        size.height += frame.size.height;
+        frame.size.width = size.width;
+        [status setFrame:frame];
+    }
+
+#ifndef GNUSTEP
+    NSDisableScreenUpdates();
+#endif
+    [self setContentSize:size];
+    [self setupContentView];
+#ifndef GNUSTEP
+    NSEnableScreenUpdates();
+#endif
+}
+
+- (void)presetGame:(id)sender
+{
+    game_params *params = [sender getPayload];
+
+    midend_set_params(me, params);
+    midend_new_game(me);
+
+    [self resizeForNewGameParams];
+    [self updateTypeMenuTick];
+}
+
+- (void)startConfigureSheet:(int)which
+{
+    NSButton *ok, *cancel;
+    int actw, acth, leftw, rightw, totalw, h, thish, y;
+    int k;
+    NSRect rect, tmprect;
+    const int SPACING = 16;
+    char *title;
+    config_item *i;
+    int cfg_controlsize;
+    NSTextField *tf;
+    NSButton *b;
+    NSPopUpButton *pb;
+
+    assert(sheet == NULL);
+
+    /*
+     * Every control we create here is going to have this size
+     * until we tell it to calculate a better one.
+     */
+    tmprect = NSMakeRect(0, 0, 100, 50);
+
+    /*
+     * Set up OK and Cancel buttons. (Actually, MacOS doesn't seem
+     * to be fond of generic OK and Cancel wording, so I'm going to
+     * rename them to something nicer.)
+     */
+    actw = acth = 0;
+
+    cancel = [[NSButton alloc] initWithFrame:tmprect];
+    [cancel setBezelStyle:NSRoundedBezelStyle];
+    [cancel setTitle:@"Abandon"];
+    [cancel setTarget:self];
+    [cancel setKeyEquivalent:@"\033"];
+    [cancel setAction:@selector(sheetCancelButton:)];
+    [cancel sizeToFit];
+    rect = [cancel frame];
+    if (actw < rect.size.width) actw = rect.size.width;
+    if (acth < rect.size.height) acth = rect.size.height;
+
+    ok = [[NSButton alloc] initWithFrame:tmprect];
+    [ok setBezelStyle:NSRoundedBezelStyle];
+    [ok setTitle:@"Accept"];
+    [ok setTarget:self];
+    [ok setKeyEquivalent:@"\r"];
+    [ok setAction:@selector(sheetOKButton:)];
+    [ok sizeToFit];
+    rect = [ok frame];
+    if (actw < rect.size.width) actw = rect.size.width;
+    if (acth < rect.size.height) acth = rect.size.height;
+
+    totalw = SPACING + 2 * actw;
+    h = 2 * SPACING + acth;
+
+    /*
+     * Now fetch the midend config data and go through it creating
+     * controls.
+     */
+    cfg = midend_get_config(me, which, &title);
+    sfree(title);                      /* FIXME: should we use this somehow? */
+    cfg_which = which;
+
+    cfg_ncontrols = cfg_controlsize = 0;
+    cfg_controls = NULL;
+    leftw = rightw = 0;
+    for (i = cfg; i->type != C_END; i++) {
+        if (cfg_controlsize < cfg_ncontrols + 5) {
+            cfg_controlsize = cfg_ncontrols + 32;
+            cfg_controls = sresize(cfg_controls, cfg_controlsize, NSView *);
+        }
+
+        thish = 0;
+
+        switch (i->type) {
+          case C_STRING:
+            /*
+             * Two NSTextFields, one being a label and the other
+             * being an edit box.
+             */
+
+            tf = [[NSTextField alloc] initWithFrame:tmprect];
+            [tf setEditable:NO];
+            [tf setSelectable:NO];
+            [tf setBordered:NO];
+            [tf setDrawsBackground:NO];
+            [[tf cell] setTitle:[NSString stringWithUTF8String:i->name]];
+            [tf sizeToFit];
+            rect = [tf frame];
+            if (thish < rect.size.height + 1) thish = rect.size.height + 1;
+            if (leftw < rect.size.width + 1) leftw = rect.size.width + 1;
+            cfg_controls[cfg_ncontrols++] = tf;
+
+            tf = [[NSTextField alloc] initWithFrame:tmprect];
+            [tf setEditable:YES];
+            [tf setSelectable:YES];
+            [tf setBordered:YES];
+            [[tf cell] setTitle:[NSString stringWithUTF8String:i->sval]];
+            [tf sizeToFit];
+            rect = [tf frame];
+            /*
+             * We impose a minimum and maximum width on editable
+             * NSTextFields. If we allow them to size themselves to
+             * the contents of the text within them, then they will
+             * look very silly if that text is only one or two
+             * characters, and equally silly if it's an absolutely
+             * enormous Rectangles or Pattern game ID!
+             */
+            if (rect.size.width < 75) rect.size.width = 75;
+            if (rect.size.width > 400) rect.size.width = 400;
+
+            if (thish < rect.size.height + 1) thish = rect.size.height + 1;
+            if (rightw < rect.size.width + 1) rightw = rect.size.width + 1;
+            cfg_controls[cfg_ncontrols++] = tf;
+            break;
+
+          case C_BOOLEAN:
+            /*
+             * A checkbox is an NSButton with a type of
+             * NSSwitchButton.
+             */
+            b = [[NSButton alloc] initWithFrame:tmprect];
+            [b setBezelStyle:NSRoundedBezelStyle];
+            [b setButtonType:NSSwitchButton];
+            [b setTitle:[NSString stringWithUTF8String:i->name]];
+            [b sizeToFit];
+            [b setState:(i->ival ? NSOnState : NSOffState)];
+            rect = [b frame];
+            if (totalw < rect.size.width + 1) totalw = rect.size.width + 1;
+            if (thish < rect.size.height + 1) thish = rect.size.height + 1;
+            cfg_controls[cfg_ncontrols++] = b;
+            break;
+
+          case C_CHOICES:
+            /*
+             * A pop-up menu control is an NSPopUpButton, which
+             * takes an embedded NSMenu. We also need an
+             * NSTextField to act as a label.
+             */
+
+            tf = [[NSTextField alloc] initWithFrame:tmprect];
+            [tf setEditable:NO];
+            [tf setSelectable:NO];
+            [tf setBordered:NO];
+            [tf setDrawsBackground:NO];
+            [[tf cell] setTitle:[NSString stringWithUTF8String:i->name]];
+            [tf sizeToFit];
+            rect = [tf frame];
+            if (thish < rect.size.height + 1) thish = rect.size.height + 1;
+            if (leftw < rect.size.width + 1) leftw = rect.size.width + 1;
+            cfg_controls[cfg_ncontrols++] = tf;
+
+            pb = [[NSPopUpButton alloc] initWithFrame:tmprect pullsDown:NO];
+            [pb setBezelStyle:NSRoundedBezelStyle];
+            {
+                char c, *p;
+
+                p = i->sval;
+                c = *p++;
+                while (*p) {
+                    char *q, *copy;
+
+                    q = p;
+                    while (*p && *p != c) p++;
+
+                    copy = snewn((p-q) + 1, char);
+                    memcpy(copy, q, p-q);
+                    copy[p-q] = '\0';
+                    [pb addItemWithTitle:[NSString stringWithUTF8String:copy]];
+                    sfree(copy);
+
+                    if (*p) p++;
+                }
+            }
+            [pb selectItemAtIndex:i->ival];
+            [pb sizeToFit];
+
+            rect = [pb frame];
+            if (rightw < rect.size.width + 1) rightw = rect.size.width + 1;
+            if (thish < rect.size.height + 1) thish = rect.size.height + 1;
+            cfg_controls[cfg_ncontrols++] = pb;
+            break;
+        }
+
+        h += SPACING + thish;
+    }
+
+    if (totalw < leftw + SPACING + rightw)
+        totalw = leftw + SPACING + rightw;
+    if (totalw > leftw + SPACING + rightw) {
+        int excess = totalw - (leftw + SPACING + rightw);
+        int leftexcess = leftw * excess / (leftw + rightw);
+        int rightexcess = excess - leftexcess;
+        leftw += leftexcess;
+        rightw += rightexcess;
+    }
+
+    /*
+     * Now go through the list again, setting the final position
+     * for each control.
+     */
+    k = 0;
+    y = h;
+    for (i = cfg; i->type != C_END; i++) {
+        y -= SPACING;
+        thish = 0;
+        switch (i->type) {
+          case C_STRING:
+          case C_CHOICES:
+            /*
+             * These two are treated identically, since both expect
+             * a control on the left and another on the right.
+             */
+            rect = [cfg_controls[k] frame];
+            if (thish < rect.size.height + 1)
+                thish = rect.size.height + 1;
+            rect = [cfg_controls[k+1] frame];
+            if (thish < rect.size.height + 1)
+                thish = rect.size.height + 1;
+            rect = [cfg_controls[k] frame];
+            rect.origin.y = y - thish/2 - rect.size.height/2;
+            rect.origin.x = SPACING;
+            rect.size.width = leftw;
+            [cfg_controls[k] setFrame:rect];
+            rect = [cfg_controls[k+1] frame];
+            rect.origin.y = y - thish/2 - rect.size.height/2;
+            rect.origin.x = 2 * SPACING + leftw;
+            rect.size.width = rightw;
+            [cfg_controls[k+1] setFrame:rect];
+            k += 2;
+            break;
+
+          case C_BOOLEAN:
+            rect = [cfg_controls[k] frame];
+            if (thish < rect.size.height + 1)
+                thish = rect.size.height + 1;
+            rect.origin.y = y - thish/2 - rect.size.height/2;
+            rect.origin.x = SPACING;
+            rect.size.width = totalw;
+            [cfg_controls[k] setFrame:rect];
+            k++;
+            break;
+        }
+        y -= thish;
+    }
+
+    assert(k == cfg_ncontrols);
+
+    [cancel setFrame:NSMakeRect(SPACING+totalw/4-actw/2, SPACING, actw, acth)];
+    [ok setFrame:NSMakeRect(SPACING+3*totalw/4-actw/2, SPACING, actw, acth)];
+
+    sheet = [[NSWindow alloc]
+             initWithContentRect:NSMakeRect(0,0,totalw + 2*SPACING,h)
+             styleMask:NSTitledWindowMask | NSClosableWindowMask
+             backing:NSBackingStoreBuffered
+             defer:YES];
+
+    [[sheet contentView] addSubview:cancel];
+    [[sheet contentView] addSubview:ok];
+
+    for (k = 0; k < cfg_ncontrols; k++)
+        [[sheet contentView] addSubview:cfg_controls[k]];
+
+    [app beginSheet:sheet modalForWindow:self
+     modalDelegate:nil didEndSelector:NULL contextInfo:nil];
+}
+
+- (void)specificGame:(id)sender
+{
+    [self startConfigureSheet:CFG_DESC];
+}
+
+- (void)specificRandomGame:(id)sender
+{
+    [self startConfigureSheet:CFG_SEED];
+}
+
+- (void)customGameType:(id)sender
+{
+    [self startConfigureSheet:CFG_SETTINGS];
+}
+
+- (void)sheetEndWithStatus:(BOOL)update
+{
+    assert(sheet != NULL);
+    [app endSheet:sheet];
+    [sheet orderOut:self];
+    sheet = NULL;
+    if (update) {
+        int k;
+        config_item *i;
+        char *error;
+
+        k = 0;
+        for (i = cfg; i->type != C_END; i++) {
+            switch (i->type) {
+              case C_STRING:
+                sfree(i->sval);
+                i->sval = dupstr([[[(id)cfg_controls[k+1] cell]
+                                  title] UTF8String]);
+                k += 2;
+                break;
+              case C_BOOLEAN:
+                i->ival = [(id)cfg_controls[k] state] == NSOnState;
+                k++;
+                break;
+              case C_CHOICES:
+                i->ival = [(id)cfg_controls[k+1] indexOfSelectedItem];
+                k += 2;
+                break;
+            }
+        }
+
+        error = midend_set_config(me, cfg_which, cfg);
+        if (error) {
+            NSAlert *alert = [[[NSAlert alloc] init] autorelease];
+            [alert addButtonWithTitle:@"Bah"];
+            [alert setInformativeText:[NSString stringWithUTF8String:error]];
+            [alert beginSheetModalForWindow:self modalDelegate:nil
+             didEndSelector:NULL contextInfo:nil];
+        } else {
+            midend_new_game(me);
+            [self resizeForNewGameParams];
+            [self updateTypeMenuTick];
+        }
+    }
+    sfree(cfg_controls);
+    cfg_controls = NULL;
+}
+- (void)sheetOKButton:(id)sender
+{
+    [self sheetEndWithStatus:YES];
+}
+- (void)sheetCancelButton:(id)sender
+{
+    [self sheetEndWithStatus:NO];
+}
+
+- (void)setStatusLine:(char *)text
+{
+    [[status cell] setTitle:[NSString stringWithUTF8String:text]];
+}
+
+@end
+
+/*
+ * Drawing routines called by the midend.
+ */
+static void osx_draw_polygon(void *handle, int *coords, int npoints,
+                             int fillcolour, int outlinecolour)
+{
+    frontend *fe = (frontend *)handle;
+    NSBezierPath *path = [NSBezierPath bezierPath];
+    int i;
+
+    [[NSGraphicsContext currentContext] setShouldAntialias:YES];
+
+    for (i = 0; i < npoints; i++) {
+        NSPoint p = { coords[i*2] + 0.5, fe->h - coords[i*2+1] - 0.5 };
+        if (i == 0)
+            [path moveToPoint:p];
+        else
+            [path lineToPoint:p];
+    }
+
+    [path closePath];
+
+    if (fillcolour >= 0) {
+        assert(fillcolour >= 0 && fillcolour < fe->ncolours);
+        [fe->colours[fillcolour] set];
+        [path fill];
+    }
+
+    assert(outlinecolour >= 0 && outlinecolour < fe->ncolours);
+    [fe->colours[outlinecolour] set];
+    [path stroke];
+}
+static void osx_draw_circle(void *handle, int cx, int cy, int radius,
+                            int fillcolour, int outlinecolour)
+{
+    frontend *fe = (frontend *)handle;
+    NSBezierPath *path = [NSBezierPath bezierPath];
+
+    [[NSGraphicsContext currentContext] setShouldAntialias:YES];
+
+    [path appendBezierPathWithArcWithCenter:NSMakePoint(cx+0.5, fe->h-cy-0.5)
+        radius:radius startAngle:0.0 endAngle:360.0];
+
+    [path closePath];
+
+    if (fillcolour >= 0) {
+        assert(fillcolour >= 0 && fillcolour < fe->ncolours);
+        [fe->colours[fillcolour] set];
+        [path fill];
+    }
+
+    assert(outlinecolour >= 0 && outlinecolour < fe->ncolours);
+    [fe->colours[outlinecolour] set];
+    [path stroke];
+}
+static void osx_draw_line(void *handle, int x1, int y1, int x2, int y2, int colour)
+{
+    frontend *fe = (frontend *)handle;
+    NSBezierPath *path = [NSBezierPath bezierPath];
+    NSPoint p1 = { x1 + 0.5, fe->h - y1 - 0.5 };
+    NSPoint p2 = { x2 + 0.5, fe->h - y2 - 0.5 };
+
+    [[NSGraphicsContext currentContext] setShouldAntialias:NO];
+
+    assert(colour >= 0 && colour < fe->ncolours);
+    [fe->colours[colour] set];
+
+    [path moveToPoint:p1];
+    [path lineToPoint:p2];
+    [path stroke];
+    NSRectFill(NSMakeRect(x1, fe->h-y1-1, 1, 1));
+    NSRectFill(NSMakeRect(x2, fe->h-y2-1, 1, 1));
+}
+
+static void osx_draw_thick_line(
+    void *handle, float thickness,
+    float x1, float y1,
+    float x2, float y2,
+    int colour)
+{
+    frontend *fe = (frontend *)handle;
+    NSBezierPath *path = [NSBezierPath bezierPath];
+
+    assert(colour >= 0 && colour < fe->ncolours);
+    [fe->colours[colour] set];
+    [[NSGraphicsContext currentContext] setShouldAntialias: YES];
+    [path setLineWidth: thickness];
+    [path setLineCapStyle: NSButtLineCapStyle];
+    [path moveToPoint: NSMakePoint(x1, fe->h-y1)];
+    [path lineToPoint: NSMakePoint(x2, fe->h-y2)];
+    [path stroke];
+}
+
+static void osx_draw_rect(void *handle, int x, int y, int w, int h, int colour)
+{
+    frontend *fe = (frontend *)handle;
+    NSRect r = { {x, fe->h - y - h}, {w,h} };
+    
+    [[NSGraphicsContext currentContext] setShouldAntialias:NO];
+
+    assert(colour >= 0 && colour < fe->ncolours);
+    [fe->colours[colour] set];
+
+    NSRectFill(r);
+}
+static void osx_draw_text(void *handle, int x, int y, int fonttype,
+                          int fontsize, int align, int colour, char *text)
+{
+    frontend *fe = (frontend *)handle;
+    NSString *string = [NSString stringWithUTF8String:text];
+    NSDictionary *attr;
+    NSFont *font;
+    NSSize size;
+    NSPoint point;
+
+    [[NSGraphicsContext currentContext] setShouldAntialias:YES];
+
+    assert(colour >= 0 && colour < fe->ncolours);
+
+    if (fonttype == FONT_FIXED)
+        font = [NSFont userFixedPitchFontOfSize:fontsize];
+    else
+        font = [NSFont userFontOfSize:fontsize];
+
+    attr = [NSDictionary dictionaryWithObjectsAndKeys:
+            fe->colours[colour], NSForegroundColorAttributeName,
+            font, NSFontAttributeName, nil];
+
+    point.x = x;
+    point.y = fe->h - y;
+
+    size = [string sizeWithAttributes:attr];
+    if (align & ALIGN_HRIGHT)
+        point.x -= size.width;
+    else if (align & ALIGN_HCENTRE)
+        point.x -= size.width / 2;
+    if (align & ALIGN_VCENTRE)
+        point.y -= size.height / 2;
+
+    [string drawAtPoint:point withAttributes:attr];
+}
+static char *osx_text_fallback(void *handle, const char *const *strings,
+                               int nstrings)
+{
+    /*
+     * We assume OS X can cope with any UTF-8 likely to be emitted
+     * by a puzzle.
+     */
+    return dupstr(strings[0]);
+}
+struct blitter {
+    int w, h;
+    int x, y;
+    NSImage *img;
+};
+static blitter *osx_blitter_new(void *handle, int w, int h)
+{
+    blitter *bl = snew(blitter);
+    bl->x = bl->y = -1;
+    bl->w = w;
+    bl->h = h;
+    bl->img = [[NSImage alloc] initWithSize:NSMakeSize(w, h)];
+    return bl;
+}
+static void osx_blitter_free(void *handle, blitter *bl)
+{
+    [bl->img release];
+    sfree(bl);
+}
+static void osx_blitter_save(void *handle, blitter *bl, int x, int y)
+{
+    frontend *fe = (frontend *)handle;
+    int sx, sy, sX, sY, dx, dy, dX, dY;
+    [fe->image unlockFocus];
+    [bl->img lockFocus];
+
+    /*
+     * Find the intersection of the source and destination rectangles,
+     * so as to avoid trying to copy from outside the source image,
+     * which GNUstep dislikes.
+     *
+     * Lower-case x,y coordinates are bottom left box corners;
+     * upper-case X,Y are the top right.
+     */
+    sx = x; sy = fe->h - y - bl->h;
+    sX = sx + bl->w; sY = sy + bl->h;
+    dx = dy = 0;
+    dX = bl->w; dY = bl->h;
+    if (sx < 0) {
+        dx += -sx;
+        sx = 0;
+    }
+    if (sy < 0) {
+        dy += -sy;
+        sy = 0;
+    }
+    if (sX > fe->w) {
+        dX -= (sX - fe->w);
+        sX = fe->w;
+    }
+    if (sY > fe->h) {
+        dY -= (sY - fe->h);
+        sY = fe->h;
+    }
+
+    [fe->image drawInRect:NSMakeRect(dx, dy, dX-dx, dY-dy)
+                 fromRect:NSMakeRect(sx, sy, sX-sx, sY-sy)
+                operation:NSCompositeCopy fraction:1.0];
+    [bl->img unlockFocus];
+    [fe->image lockFocus];
+    bl->x = x;
+    bl->y = y;
+}
+static void osx_blitter_load(void *handle, blitter *bl, int x, int y)
+{
+    frontend *fe = (frontend *)handle;
+    if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) {
+        x = bl->x;
+        y = bl->y;
+    }
+    [bl->img drawInRect:NSMakeRect(x, fe->h - y - bl->h, bl->w, bl->h)
+        fromRect:NSMakeRect(0, 0, bl->w, bl->h)
+        operation:NSCompositeCopy fraction:1.0];
+}
+static void osx_draw_update(void *handle, int x, int y, int w, int h)
+{
+    frontend *fe = (frontend *)handle;
+    [fe->view setNeedsDisplayInRect:NSMakeRect(x, fe->h - y - h, w, h)];
+}
+static void osx_clip(void *handle, int x, int y, int w, int h)
+{
+    frontend *fe = (frontend *)handle;
+    NSRect r = { {x, fe->h - y - h}, {w, h} };
+    
+    if (!fe->clipped)
+        [[NSGraphicsContext currentContext] saveGraphicsState];
+    [NSBezierPath clipRect:r];
+    fe->clipped = TRUE;
+}
+static void osx_unclip(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+    if (fe->clipped)
+        [[NSGraphicsContext currentContext] restoreGraphicsState];
+    fe->clipped = FALSE;
+}
+static void osx_start_draw(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+    [fe->image lockFocus];
+    fe->clipped = FALSE;
+}
+static void osx_end_draw(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+    [fe->image unlockFocus];
+}
+static void osx_status_bar(void *handle, char *text)
+{
+    frontend *fe = (frontend *)handle;
+    [fe->window setStatusLine:text];
+}
+
+const struct drawing_api osx_drawing = {
+    osx_draw_text,
+    osx_draw_rect,
+    osx_draw_line,
+    osx_draw_polygon,
+    osx_draw_circle,
+    osx_draw_update,
+    osx_clip,
+    osx_unclip,
+    osx_start_draw,
+    osx_end_draw,
+    osx_status_bar,
+    osx_blitter_new,
+    osx_blitter_free,
+    osx_blitter_save,
+    osx_blitter_load,
+    NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */
+    NULL, NULL,                        /* line_width, line_dotted */
+    osx_text_fallback,
+    osx_draw_thick_line,
+};
+
+void deactivate_timer(frontend *fe)
+{
+    [fe->window deactivateTimer];
+}
+void activate_timer(frontend *fe)
+{
+    [fe->window activateTimer];
+}
+
+/* ----------------------------------------------------------------------
+ * AppController: the object which receives the messages from all
+ * menu selections that aren't standard OS X functions.
+ */
+@interface AppController : NSObject <NSApplicationDelegate>
+{
+}
+- (void)newGameWindow:(id)sender;
+- (void)about:(id)sender;
+@end
+
+@implementation AppController
+
+- (void)newGameWindow:(id)sender
+{
+    const game *g = [sender getPayload];
+    id win;
+
+    win = [[GameWindow alloc] initWithGame:g];
+    [win makeKeyAndOrderFront:self];
+}
+
+- (void)about:(id)sender
+{
+    id win;
+
+    win = [[AboutBox alloc] init];
+    [win makeKeyAndOrderFront:self];    
+}
+
+- (NSMenu *)applicationDockMenu:(NSApplication *)sender
+{
+    NSMenu *menu = newmenu("Dock Menu");
+    {
+        int i;
+
+        for (i = 0; i < gamecount; i++) {
+            id item =
+                initnewitem([DataMenuItem allocWithZone:[NSMenu menuZone]],
+                            menu, gamelist[i]->name, "", self,
+                            @selector(newGameWindow:));
+            [item setPayload:(void *)gamelist[i]];
+        }
+    }
+    return menu;
+}
+
+@end
+
+/* ----------------------------------------------------------------------
+ * Main program. Constructs the menus and runs the application.
+ */
+int main(int argc, char **argv)
+{
+    NSAutoreleasePool *pool;
+    NSMenu *menu;
+    AppController *controller;
+    NSImage *icon;
+
+    pool = [[NSAutoreleasePool alloc] init];
+
+    icon = [NSImage imageNamed:@"NSApplicationIcon"];
+    app = [NSApplication sharedApplication];
+    [app setApplicationIconImage:icon];
+
+    controller = [[[AppController alloc] init] autorelease];
+    [app setDelegate:controller];
+
+    [app setMainMenu: newmenu("Main Menu")];
+
+    menu = newsubmenu([app mainMenu], "Apple Menu");
+    newitem(menu, "About Puzzles", "", NULL, @selector(about:));
+    [menu addItem:[NSMenuItem separatorItem]];
+    [app setServicesMenu:newsubmenu(menu, "Services")];
+    [menu addItem:[NSMenuItem separatorItem]];
+    newitem(menu, "Hide Puzzles", "h", app, @selector(hide:));
+    newitem(menu, "Hide Others", "o-h", app, @selector(hideOtherApplications:));
+    newitem(menu, "Show All", "", app, @selector(unhideAllApplications:));
+    [menu addItem:[NSMenuItem separatorItem]];
+    newitem(menu, "Quit", "q", app, @selector(terminate:));
+    [app setAppleMenu: menu];
+
+    menu = newsubmenu([app mainMenu], "File");
+    newitem(menu, "Open", "o", NULL, @selector(loadSavedGame:));
+    newitem(menu, "Save As", "s", NULL, @selector(saveGame:));
+    newitem(menu, "New Game", "n", NULL, @selector(newGame:));
+    newitem(menu, "Restart Game", "r", NULL, @selector(restartGame:));
+    newitem(menu, "Specific Game", "", NULL, @selector(specificGame:));
+    newitem(menu, "Specific Random Seed", "", NULL,
+                   @selector(specificRandomGame:));
+    [menu addItem:[NSMenuItem separatorItem]];
+    {
+        NSMenu *submenu = newsubmenu(menu, "New Window");
+        int i;
+
+        for (i = 0; i < gamecount; i++) {
+            id item =
+                initnewitem([DataMenuItem allocWithZone:[NSMenu menuZone]],
+                            submenu, gamelist[i]->name, "", controller,
+                            @selector(newGameWindow:));
+            [item setPayload:(void *)gamelist[i]];
+        }
+    }
+    [menu addItem:[NSMenuItem separatorItem]];
+    newitem(menu, "Close", "w", NULL, @selector(performClose:));
+
+    menu = newsubmenu([app mainMenu], "Edit");
+    newitem(menu, "Undo", "z", NULL, @selector(undoMove:));
+    newitem(menu, "Redo", "S-z", NULL, @selector(redoMove:));
+    [menu addItem:[NSMenuItem separatorItem]];
+    newitem(menu, "Cut", "x", NULL, @selector(cut:));
+    newitem(menu, "Copy", "c", NULL, @selector(copy:));
+    newitem(menu, "Paste", "v", NULL, @selector(paste:));
+    [menu addItem:[NSMenuItem separatorItem]];
+    newitem(menu, "Solve", "S-s", NULL, @selector(solveGame:));
+
+    menu = newsubmenu([app mainMenu], "Type");
+    typemenu = menu;
+    newitem(menu, "Custom", "", NULL, @selector(customGameType:));
+
+    menu = newsubmenu([app mainMenu], "Window");
+    [app setWindowsMenu: menu];
+    newitem(menu, "Minimise Window", "m", NULL, @selector(performMiniaturize:));
+
+    menu = newsubmenu([app mainMenu], "Help");
+    newitem(menu, "Puzzles Help", "?", app, @selector(showHelp:));
+
+    [app run];
+    [pool release];
+
+    return 0;
+}
diff --git a/apps/plugins/puzzles/padtoolbar.bmp b/apps/plugins/puzzles/padtoolbar.bmp
new file mode 100644
index 0000000000..46c3e0dcae
--- /dev/null
+++ b/apps/plugins/puzzles/padtoolbar.bmp
diff --git a/apps/plugins/puzzles/palisade.R b/apps/plugins/puzzles/palisade.R
new file mode 100644
index 0000000000..de4bd83126
--- /dev/null
+++ b/apps/plugins/puzzles/palisade.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+PALISADE_EXTRA = divvy dsf
+
+palisade    : [X] GTK COMMON palisade PALISADE_EXTRA palisade-icon|no-icon
+
+palisade    : [G] WINDOWS COMMON palisade PALISADE_EXTRA palisade.res|noicon.res
+
+ALL += palisade[COMBINED] PALISADE_EXTRA
+
+!begin am gtk
+GAMES += palisade
+!end
+
+!begin >list.c
+    A(palisade) \
+!end
+
+!begin >gamedesc.txt
+palisade:palisade.exe:Palisade:Grid-division puzzle:Divide the grid into equal-sized areas in accordance with the clues.
+!end
diff --git a/apps/plugins/puzzles/palisade.c b/apps/plugins/puzzles/palisade.c
new file mode 100644
index 0000000000..c5f1b62022
--- /dev/null
+++ b/apps/plugins/puzzles/palisade.c
@@ -0,0 +1,1383 @@
+/* -*- indent-tabs-mode: nil; tab-width: 1000 -*- */
+
+/*
+ * palisade.c: Nikoli's `Five Cells' puzzle.
+ *
+ * See http://nikoli.co.jp/en/puzzles/five_cells.html
+ */
+
+/* TODO:
+ *
+ * - better solver: implement the sketched-out deductions
+ *
+ * - improve the victory flash?
+ *    - the LINE_NOs look ugly against COL_FLASH.
+ *    - white-blink the edges (instead), a la loopy?
+ */
+
+#include "rbassert.h"
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "puzzles.h"
+
+#define setmem(ptr, byte, len) memset((ptr), (byte), (len) * sizeof (ptr)[0])
+#define scopy(dst, src, len) memcpy((dst), (src), (len) * sizeof (dst)[0])
+#define dupmem(p, n) memcpy(smalloc(n * sizeof (*p)), p, n * sizeof (*p))
+#define snewa(ptr, len) (ptr) = smalloc((len) * sizeof (*ptr))
+#define clone(ptr) (dupmem((ptr), 1))
+
+static char *string(int n, const char *fmt, ...)
+{
+    va_list va;
+    char *ret;
+    int m;
+    va_start(va, fmt);
+    m = vsprintf(snewa(ret, n + 1), fmt, va);
+    va_end(va);
+    if (m > n) fatal("memory corruption");
+    return ret;
+}
+
+struct game_params {
+    int w, h, k;
+};
+
+typedef char clue;
+typedef unsigned char borderflag;
+
+typedef struct shared_state {
+    game_params params;
+    clue *clues;
+    int refcount;
+} shared_state;
+
+struct game_state {
+    shared_state *shared;
+    borderflag *borders; /* length w*h */
+
+    unsigned int completed: 1;
+    unsigned int cheated: 1;
+};
+
+#define DEFAULT_PRESET 0
+static struct game_params presets[] = {
+    {5, 5, 5}, {8, 6, 6}, {10, 8, 8}, {15, 12, 10}
+    /* I definitely want 5x5n5 since that gives "Five Cells" its name.
+     * But how about the others?  By which criteria do I choose? */
+};
+
+static game_params *default_params(void)
+{
+    return clone(&presets[DEFAULT_PRESET]);
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    if (i < 0 || i >= lenof(presets)) return FALSE;
+
+    *params = clone(&presets[i]);
+    *name = string(60, "%d x %d, regions of size %d",
+                   presets[i].w, presets[i].h, presets[i].k);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    return clone(params);
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->w = params->h = params->k = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) ++string;
+    if (*string == 'x') {
+        params->h = atoi(++string);
+        while (*string && isdigit((unsigned char)*string)) ++string;
+    }
+    if (*string == 'n') params->k = atoi(++string);
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    return string(40, "%dx%dn%d", params->w, params->h, params->k);
+}
+
+#define CONFIG(i, nm, ty, iv, sv) \
+    (ret[i].name = nm, ret[i].type = ty, ret[i].ival = iv, ret[i].sval = sv)
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret = snewn(4, config_item);
+
+    CONFIG(0, "Width",       C_STRING, 0, string(20, "%d", params->w));
+    CONFIG(1, "Height",      C_STRING, 0, string(20, "%d", params->h));
+    CONFIG(2, "Region size", C_STRING, 0, string(20, "%d", params->k));
+    CONFIG(3, NULL,          C_END,    0, NULL);
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *params = snew(game_params);
+
+    params->w = atoi(cfg[0].sval);
+    params->h = atoi(cfg[1].sval);
+    params->k = atoi(cfg[2].sval);
+
+    return params;
+}
+
+/* +---+  <<  The one possible domino (up to symmetry).      +---+---+
+ * | 3 |                                                     | 3 | 3 |
+ * |   |   If two dominos are adjacent as depicted here  >>  +---+---+
+ * | 3 |   then it's ambiguous whether the edge between      | 3 | 3 |
+ * +---+   the dominos is horizontal or vertical.            +---+---+
+ */
+
+static char *validate_params(const game_params *params, int full)
+{
+    int w = params->w, h = params->h, k = params->k, wh = w * h;
+
+    if (k < 1) return "Region size must be at least one";
+    if (w < 1) return "Width must be at least one";
+    if (h < 1) return "Height must be at least one";
+    if (wh % k) return "Region size must divide grid area";
+
+    if (!full) return NULL; /* succeed partial validation */
+
+    /* MAYBE FIXME: we (just?) don't have the UI for winning these. */
+    if (k == wh) return "Region size must be less than the grid area";
+    assert (k < wh); /* or wh % k != 0 */
+
+    if (k == 2 && w != 1 && h != 1)
+        return "Region size can't be two unless width or height is one";
+
+    return NULL; /* succeed full validation */
+}
+
+/* --- Solver ------------------------------------------------------- */
+
+/* the solver may write at will to these arrays, but shouldn't free them */
+/* it's up to the client to dup/free as needed */
+typedef struct solver_ctx {
+    const game_params *params;  /* also in shared_state */
+    clue *clues;                /* also in shared_state */
+    borderflag *borders;        /* also in game_state */
+    int *dsf;                   /* particular to the solver */
+} solver_ctx;
+
+/* Deductions:
+ *
+ * - If two adjacent clues do not have a border between them, this
+ *   gives a lower limit on the size of their region (which is also an
+ *   upper limit if both clues are 3).  Rule out any non-border which
+ *   would make its region either too large or too small.
+ *
+ * - If a clue, k, is adjacent to k borders or (4 - k) non-borders,
+ *   the remaining edges incident to the clue are readily decided.
+ *
+ * - If a region has only one other region (e.g. square) to grow into
+ *   and it's not of full size yet, grow it into that one region.
+ *
+ * - If two regions are adjacent and their combined size would be too
+ *   large, put an edge between them.
+ *
+ * - If a border is adjacent to two non-borders, its last vertex-mate
+ *   must also be a border.  If a maybe-border is adjacent to three
+ *   nonborders, the maybe-border is a non-border.
+ *
+ * - If a clue square is adjacent to several squares belonging to the
+ *   same region, and enabling (disabling) those borders would violate
+ *   the clue, those borders must be disabled (enabled).
+ *
+ * - If there's a path crossing only non-borders between two squares,
+ *   the maybe-border between them is a non-border.
+ *   (This is implicitly computed in the dsf representation)
+ */
+
+/* TODO deductions:
+ *
+ * If a vertex is adjacent to a LINE_YES and (4-3)*LINE_NO, at least
+ * one of the last two edges are LINE_YES.  If they're adjacent to a
+ * 1, then the other two edges incident to that 1 are LINE_NO.
+ *
+ * For each square: set all as unknown, then for each k-omino and each
+ * way of placing it on that square, if that way is consistent with
+ * the board, mark its edges and interior as possible LINE_YES and
+ * LINE_NO, respectively.  When all k-ominos are through, see what
+ * isn't possible and remove those impossibilities from the board.
+ * (Sounds pretty nasty for k > 4 or so.)
+ *
+ * A black-bordered subregion must have a size divisible by k.  So,
+ * draw a graph with one node per dsf component and edges between
+ * those dsf components which have adjacent squares.  Identify cut
+ * vertices and edges.  If a cut-vertex-delimited component contains a
+ * number of squares not divisible by k, cut vertex not included, then
+ * the cut vertex must belong to the component.  If it has exactly one
+ * edge _out_ of the component, the line(s) corresponding to that edge
+ * are all LINE_YES (i.e. a BORDER()).
+ * (This sounds complicated, but visually it is rather easy.)
+ *
+ * [Look at loopy and see how the at-least/-most k out of m edges
+ * thing is done.  See how it is propagated across multiple squares.]
+ */
+
+#define EMPTY (~0)
+
+#define BIT(i) (1 << (i))
+#define BORDER(i) BIT(i)
+#define BORDER_U BORDER(0)
+#define BORDER_R BORDER(1)
+#define BORDER_D BORDER(2)
+#define BORDER_L BORDER(3)
+#define FLIP(i) ((i) ^ 2)
+#define BORDER_MASK (BORDER_U|BORDER_R|BORDER_D|BORDER_L)
+#define DISABLED(border) ((border) << 4)
+#define UNDISABLED(border) ((border) >> 4)
+
+static const int dx[4] = { 0, +1,  0, -1};
+static const int dy[4] = {-1,  0, +1,  0};
+static const int bitcount[16] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};
+/* bitcount[x & BORDER_MASK] == number of enabled borders */
+
+#define COMPUTE_J (-1)
+
+static void connect(solver_ctx *ctx, int i, int j)
+{
+    dsf_merge(ctx->dsf, i, j);
+}
+
+static int connected(solver_ctx *ctx, int i, int j, int dir)
+{
+    if (j == COMPUTE_J) j = i + dx[dir] + ctx->params->w*dy[dir];
+    return dsf_canonify(ctx->dsf, i) == dsf_canonify(ctx->dsf, j);
+}
+
+static void disconnect(solver_ctx *ctx, int i, int j, int dir)
+{
+    if (j == COMPUTE_J) j = i + dx[dir] + ctx->params->w*dy[dir];
+    ctx->borders[i] |= BORDER(dir);
+    ctx->borders[j] |= BORDER(FLIP(dir));
+}
+
+static int disconnected(solver_ctx *ctx, int i, int j, int dir)
+{
+    assert (j == COMPUTE_J || j == i + dx[dir] + ctx->params->w*dy[dir]);
+    return ctx->borders[i] & BORDER(dir);
+}
+
+static int maybe(solver_ctx *ctx, int i, int j, int dir)
+{
+    assert (j == COMPUTE_J || j == i + dx[dir] + ctx->params->w*dy[dir]);
+    return !disconnected(ctx, i, j, dir) && !connected(ctx, i, j, dir);
+    /* the ordering is important: disconnected works for invalid
+     * squares (i.e. out of bounds), connected doesn't. */
+}
+
+static void solver_connected_clues_versus_region_size(solver_ctx *ctx)
+{
+    int w = ctx->params->w, h = ctx->params->h, wh = w*h, i, dir;
+
+    /* If i is connected to j and i has borders with p of the
+     * remaining three squares and j with q of the remaining three
+     * squares, then the region has size at least 1+(3-p) + 1+(3-q).
+     * If p = q = 3 then the region has size exactly 2. */
+
+    for (i = 0; i < wh; ++i) {
+        if (ctx->clues[i] == EMPTY) continue;
+        for (dir = 0; dir < 4; ++dir) {
+            int j = i + dx[dir] + w*dy[dir];
+            if (disconnected(ctx, i, j, dir)) continue;
+            if (ctx->clues[j] == EMPTY) continue;
+            if ((8 - ctx->clues[i] - ctx->clues[j] > ctx->params->k) ||
+                (ctx->clues[i] == 3 && ctx->clues[j] == 3 &&
+                 ctx->params->k != 2))
+            {
+                disconnect(ctx, i, j, dir);
+                /* changed = TRUE, but this is a one-shot... */
+            }
+        }
+    }
+}
+
+static int solver_number_exhausted(solver_ctx *ctx)
+{
+    int w = ctx->params->w, h = ctx->params->h, wh = w*h, i, dir, off;
+    int changed = FALSE;
+
+    for (i = 0; i < wh; ++i) {
+        if (ctx->clues[i] == EMPTY) continue;
+
+        if (bitcount[(ctx->borders[i] & BORDER_MASK)] == ctx->clues[i]) {
+            for (dir = 0; dir < 4; ++dir) {
+                int j = i + dx[dir] + w*dy[dir];
+                if (!maybe(ctx, i, j, dir)) continue;
+                connect(ctx, i, j);
+                changed = TRUE;
+            }
+            continue;
+        }
+
+        for (off = dir = 0; dir < 4; ++dir) {
+            int j = i + dx[dir] + w*dy[dir];
+            if (!disconnected(ctx, i, j, dir) && connected(ctx, i, j, dir))
+                ++off; /* ^^^ bounds checking before ^^^^^ */
+        }
+
+        if (ctx->clues[i] == 4 - off)
+            for (dir = 0; dir < 4; ++dir) {
+                int j = i + dx[dir] + w*dy[dir];
+                if (!maybe(ctx, i, j, dir)) continue;
+                disconnect(ctx, i, j, dir);
+                changed = TRUE;
+            }
+    }
+
+    return changed;
+}
+
+static int solver_not_too_big(solver_ctx *ctx)
+{
+    int w = ctx->params->w, h = ctx->params->h, wh = w*h, i, dir;
+    int changed = FALSE;
+
+    for (i = 0; i < wh; ++i) {
+        int size = dsf_size(ctx->dsf, i);
+        for (dir = 0; dir < 4; ++dir) {
+            int j = i + dx[dir] + w*dy[dir];
+            if (!maybe(ctx, i, j, dir)) continue;
+            if (size + dsf_size(ctx->dsf, j) <= ctx->params->k) continue;
+            disconnect(ctx, i, j, dir);
+            changed = TRUE;
+        }
+    }
+
+    return changed;
+}
+
+static int solver_not_too_small(solver_ctx *ctx)
+{
+    int w = ctx->params->w, h = ctx->params->h, wh = w*h, i, dir;
+    int *outs, k = ctx->params->k, ci, changed = FALSE;
+
+    snewa(outs, wh);
+    setmem(outs, -1, wh);
+
+    for (i = 0; i < wh; ++i) {
+        ci = dsf_canonify(ctx->dsf, i);
+        if (dsf_size(ctx->dsf, ci) == k) continue;
+        for (dir = 0; dir < 4; ++dir) {
+            int j = i + dx[dir] + w*dy[dir];
+            if (!maybe(ctx, i, j, dir)) continue;
+            if (outs[ci] == -1) outs[ci] = dsf_canonify(ctx->dsf, j);
+            else if (outs[ci] != dsf_canonify(ctx->dsf, j)) outs[ci] = -2;
+        }
+    }
+
+    for (i = 0; i < wh; ++i) {
+        int j = outs[i];
+        if (i != dsf_canonify(ctx->dsf, i)) continue;
+        if (j < 0) continue;
+        connect(ctx, i, j); /* only one place for i to grow */
+        changed = TRUE;
+    }
+
+    sfree(outs);
+    return changed;
+}
+
+static int solver_no_dangling_edges(solver_ctx *ctx)
+{
+    int w = ctx->params->w, h = ctx->params->h, r, c;
+    int changed = FALSE;
+
+    /* for each vertex */
+    for (r = 1; r < h; ++r)
+        for (c = 1; c < w; ++c) {
+            int i = r * w + c, j = i - w - 1, noline = 0, dir;
+            int squares[4], e = -1, f = -1, de = -1, df = -1;
+
+            /* feels hacky: I align these with BORDER_[U0 R1 D2 L3] */
+            squares[1] = squares[2] = j;
+            squares[0] = squares[3] = i;
+
+            /* for each edge adjacent to the vertex */
+            for (dir = 0; dir < 4; ++dir)
+                if (!connected(ctx, squares[dir], COMPUTE_J, dir)) {
+                    df = dir;
+                    f = squares[df];
+                    if (e != -1) continue;
+                    e = f;
+                    de = df;
+                } else ++noline;
+
+            if (4 - noline == 1) {
+                assert (e != -1);
+                disconnect(ctx, e, COMPUTE_J, de);
+                changed = TRUE;
+                continue;
+            }
+
+            if (4 - noline != 2) continue;
+
+            assert (e != -1);
+            assert (f != -1);
+
+            if (ctx->borders[e] & BORDER(de)) {
+                if (!(ctx->borders[f] & BORDER(df))) {
+                    disconnect(ctx, f, COMPUTE_J, df);
+                    changed = TRUE;
+                }
+            } else if (ctx->borders[f] & BORDER(df)) {
+                disconnect(ctx, e, COMPUTE_J, de);
+                changed = TRUE;
+            }
+        }
+
+    return changed;
+}
+
+static int solver_equivalent_edges(solver_ctx *ctx)
+{
+    int w = ctx->params->w, h = ctx->params->h, wh = w*h, i, dirj;
+    int changed = FALSE;
+
+    /* if a square is adjacent to two connected squares, the two
+     * borders (i,j) and (i,k) are either both on or both off. */
+
+    for (i = 0; i < wh; ++i) {
+        int n_on = 0, n_off = 0;
+        if (ctx->clues[i] < 1 || ctx->clues[i] > 3) continue;
+
+        if (ctx->clues[i] == 2 /* don't need it otherwise */)
+            for (dirj = 0; dirj < 4; ++dirj) {
+                int j = i + dx[dirj] + w*dy[dirj];
+                if (disconnected(ctx, i, j, dirj)) ++n_on;
+                else if (connected(ctx, i, j, dirj)) ++n_off;
+            }
+
+        for (dirj = 0; dirj < 4; ++dirj) {
+            int j = i + dx[dirj] + w*dy[dirj], dirk;
+            if (!maybe(ctx, i, j, dirj)) continue;
+
+            for (dirk = dirj + 1; dirk < 4; ++dirk) {
+                int k = i + dx[dirk] + w*dy[dirk];
+                if (!maybe(ctx, i, k, dirk)) continue;
+                if (!connected(ctx, j, k, -1)) continue;
+
+                if (n_on + 2 > ctx->clues[i]) {
+                    connect(ctx, i, j);
+                    connect(ctx, i, k);
+                    changed = TRUE;
+                } else if (n_off + 2 > 4 - ctx->clues[i]) {
+                    disconnect(ctx, i, j, dirj);
+                    disconnect(ctx, i, k, dirk);
+                    changed = TRUE;
+                }
+            }
+        }
+    }
+
+    return changed;
+}
+
+#define UNVISITED 6
+
+/* build connected components in `dsf', along the lines of `borders'. */
+static void dfs_dsf(int i, int w, borderflag *border, int *dsf, int black)
+{
+    int dir;
+    for (dir = 0; dir < 4; ++dir) {
+        int ii = i + dx[dir] + w*dy[dir], bdir = BORDER(dir);
+        if (black ? (border[i] & bdir) : !(border[i] & DISABLED(bdir)))
+            continue;
+        if (dsf[ii] != UNVISITED) continue;
+        dsf_merge(dsf, i, ii);
+        dfs_dsf(ii, w, border, dsf, black);
+    }
+}
+
+static int is_solved(const game_params *params, clue *clues,
+                     borderflag *border)
+{
+    int w = params->w, h = params->h, wh = w*h, k = params->k;
+    int i, x, y;
+    int *dsf = snew_dsf(wh);
+
+    assert (dsf[0] == UNVISITED); /* check: UNVISITED and dsf.c match up */
+
+    /*
+     * A game is solved if:
+     *
+     *  - the borders drawn on the grid divide it into connected
+     *    components such that every square is in a component of the
+     *    correct size
+     *  - the borders also satisfy the clue set
+     */
+    for (i = 0; i < wh; ++i) {
+        if (dsf[i] == UNVISITED) dfs_dsf(i, params->w, border, dsf, TRUE);
+        if (dsf_size(dsf, i) != k) goto error;
+        if (clues[i] == EMPTY) continue;
+        if (clues[i] != bitcount[border[i] & BORDER_MASK]) goto error;
+    }
+
+    /*
+     * ... and thirdly:
+     *
+     *  - there are no *stray* borders, in that every border is
+     *    actually part of the division between two components.
+     *    Otherwise you could cheat by finding a subdivision which did
+     *    not *exceed* any clue square's counter, and then adding a
+     *    few extra edges.
+     */
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            if (x+1 < w && (border[y*w+x] & BORDER_R) &&
+                dsf_canonify(dsf, y*w+x) == dsf_canonify(dsf, y*w+(x+1)))
+                goto error;
+            if (y+1 < h && (border[y*w+x] & BORDER_D) &&
+                dsf_canonify(dsf, y*w+x) == dsf_canonify(dsf, (y+1)*w+x))
+                goto error;
+        }
+    }
+
+    sfree(dsf);
+    return TRUE;
+
+error:
+    sfree(dsf);
+    return FALSE;
+}
+
+static int solver(const game_params *params, clue *clues, borderflag *borders)
+{
+    int w = params->w, h = params->h, wh = w*h, changed;
+    solver_ctx ctx;
+
+    ctx.params = params;
+    ctx.clues = clues;
+    ctx.borders = borders;
+    ctx.dsf = snew_dsf(wh);
+
+    solver_connected_clues_versus_region_size(&ctx); /* idempotent */
+    do {
+        changed  = FALSE;
+        changed |= solver_number_exhausted(&ctx);
+        changed |= solver_not_too_big(&ctx);
+        changed |= solver_not_too_small(&ctx);
+        changed |= solver_no_dangling_edges(&ctx);
+        changed |= solver_equivalent_edges(&ctx);
+    } while (changed);
+
+    sfree(ctx.dsf);
+
+    return is_solved(params, clues, borders);
+}
+
+/* --- Generator ---------------------------------------------------- */
+
+static void init_borders(int w, int h, borderflag *borders)
+{
+    int r, c;
+    setmem(borders, 0, w*h);
+    for (c = 0; c < w; ++c) {
+        borders[c] |= BORDER_U;
+        borders[w*h-1 - c] |= BORDER_D;
+    }
+    for (r = 0; r < h; ++r) {
+        borders[r*w] |= BORDER_L;
+        borders[w*h-1 - r*w] |= BORDER_R;
+    }
+}
+
+#define OUT_OF_BOUNDS(x, y, w, h) \
+    ((x) < 0 || (x) >= (w) || (y) < 0 || (y) >= (h))
+
+#define xshuffle(ptr, len, rs) shuffle((ptr), (len), sizeof (ptr)[0], (rs))
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, h = params->h, wh = w*h, k = params->k;
+
+    clue *numbers = snewn(wh + 1, clue), *p;
+    borderflag *rim = snewn(wh, borderflag);
+    borderflag *scratch_borders = snewn(wh, borderflag);
+
+    char *soln = snewa(*aux, wh + 2);
+    int *shuf = snewn(wh, int);
+    int *dsf = NULL, i, r, c;
+
+    int attempts = 0;
+
+    for (i = 0; i < wh; ++i) shuf[i] = i;
+    xshuffle(shuf, wh, rs);
+
+    init_borders(w, h, rim);
+
+    assert (!('@' & BORDER_MASK));
+    *soln++ = 'S';
+    soln[wh] = '\0';
+
+    do {
+        ++attempts;
+        setmem(soln, '@', wh);
+
+        sfree(dsf);
+        dsf = divvy_rectangle(w, h, k, rs);
+
+        for (r = 0; r < h; ++r)
+            for (c = 0; c < w; ++c) {
+                int i = r * w + c, dir;
+                numbers[i] = 0;
+                for (dir = 0; dir < 4; ++dir) {
+                    int rr = r + dy[dir], cc = c + dx[dir], ii = rr * w + cc;
+                    if (OUT_OF_BOUNDS(cc, rr, w, h) ||
+                        dsf_canonify(dsf, i) != dsf_canonify(dsf, ii)) {
+                        ++numbers[i];
+                        soln[i] |= BORDER(dir);
+                    }
+                }
+            }
+
+        scopy(scratch_borders, rim, wh);
+    } while (!solver(params, numbers, scratch_borders));
+
+    for (i = 0; i < wh; ++i) {
+        int j = shuf[i];
+        clue copy = numbers[j];
+
+        scopy(scratch_borders, rim, wh);
+        numbers[j] = EMPTY; /* strip away unnecssary clues */
+        if (!solver(params, numbers, scratch_borders))
+            numbers[j] = copy;
+    }
+
+    numbers[wh] = '\0';
+
+    sfree(scratch_borders);
+    sfree(rim);
+    sfree(shuf);
+    sfree(dsf);
+
+    p = numbers;
+    r = 0;
+    for (i = 0; i < wh; ++i) {
+        if (numbers[i] != EMPTY) {
+            while (r) {
+                while (r > 26) {
+                    *p++ = 'z';
+                    r -= 26;
+                }
+                *p++ = 'a'-1 + r;
+                r = 0;
+            }
+            *p++ = '0' + numbers[i];
+        } else ++r;
+    }
+    *p++ = '\0';
+
+    return sresize(numbers, p - numbers, clue);
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+
+    int w = params->w, h = params->h, wh = w*h, squares = 0;
+
+    for (/* nop */; *desc; ++desc) {
+        if (islower((unsigned char)*desc)) {
+            squares += *desc - 'a' + 1;
+        } else if (isdigit((unsigned char)*desc)) {
+            if (*desc > '4') {
+                static char buf[] = "Invalid (too large) number: '5'";
+                assert (isdigit((unsigned char)buf[lenof(buf) - 3]));
+                buf[lenof(buf) - 3] = *desc; /* ... or 6, 7, 8, 9 :-) */
+                return buf;
+            }
+            ++squares;
+        } else if (isprint((unsigned char)*desc)) {
+            static char buf[] = "Invalid character in data: '?'";
+            buf[lenof(buf) - 3] = *desc;
+            return buf;
+        } else return "Invalid (unprintable) character in data";
+    }
+
+    if (squares > wh) return "Data describes too many squares";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, h = params->h, wh = w*h, i;
+    game_state *state = snew(game_state);
+
+    state->shared = snew(shared_state);
+    state->shared->refcount = 1;
+    state->shared->params = *params; /* struct copy */
+    snewa(state->shared->clues, wh);
+
+    setmem(state->shared->clues, EMPTY, wh);
+    for (i = 0; *desc; ++desc) {
+        if (isdigit((unsigned char)*desc)) state->shared->clues[i++] = *desc - '0';
+        else if (isalpha((unsigned char)*desc)) i += *desc - 'a' + 1;
+    }
+
+    snewa(state->borders, wh);
+    init_borders(w, h, state->borders);
+
+    state->completed = (params->k == wh);
+    state->cheated = FALSE;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int wh = state->shared->params.w * state->shared->params.h;
+    game_state *ret = snew(game_state);
+
+    ret->borders = dupmem(state->borders, wh);
+
+    ret->shared = state->shared;
+    ++ret->shared->refcount;
+
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (--state->shared->refcount == 0) {
+        sfree(state->shared->clues);
+        sfree(state->shared);
+    }
+    sfree(state->borders);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int w = state->shared->params.w, h = state->shared->params.h, wh = w*h;
+    borderflag *move;
+
+    if (aux) return dupstr(aux);
+
+    snewa(move, wh + 2);
+
+    move[0] = 'S';
+    init_borders(w, h, move + 1);
+    move[wh + 1] = '\0';
+
+    if (solver(&state->shared->params, state->shared->clues, move + 1)) {
+        int i;
+        for (i = 0; i < wh; i++)
+            move[i+1] |= '@';          /* turn into sensible ASCII */
+        return (char *) move;
+    }
+
+    *error = "Sorry, I can't solve this puzzle";
+    sfree(move);
+    return NULL;
+
+    {
+        /* compile-time-assert (borderflag is-a-kind-of char).
+         *
+         * depends on zero-size arrays being disallowed.  GCC says
+         * ISO C forbids this, pointing to [-Werror=edantic].  Also,
+         * it depends on type-checking of (obviously) dead code. */
+        borderflag b[sizeof (borderflag) == sizeof (char)];
+        char c = b[0]; b[0] = c;
+        /* we could at least in principle put this anywhere, but it
+         * seems silly to not put it where the assumption is used. */
+    }
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->shared->params.w, h = state->shared->params.h, r, c;
+    int cw = 4, ch = 2, gw = cw*w + 2, gh = ch * h + 1, len = gw * gh;
+    char *board;
+
+    setmem(snewa(board, len + 1), ' ', len);
+    for (r = 0; r < h; ++r) {
+        for (c = 0; c < w; ++c) {
+            int cell = r*ch*gw + cw*c, center = cell + gw*ch/2 + cw/2;
+            int i = r * w + c, clue = state->shared->clues[i];
+
+            if (clue != EMPTY) board[center] = '0' + clue;
+
+            board[cell] = '+';
+
+            if (state->borders[i] & BORDER_U)
+                setmem(board + cell + 1, '-', cw - 1);
+            else if (state->borders[i] & DISABLED(BORDER_U))
+                board[cell + cw / 2] = 'x';
+
+            if (state->borders[i] & BORDER_L)
+                board[cell + gw] = '|';
+            else if (state->borders[i] & DISABLED(BORDER_L))
+                board[cell + gw] = 'x';
+        }
+
+        for (c = 0; c < ch; ++c) {
+            board[(r*ch + c)*gw + gw - 2] = c ? '|' : '+';
+            board[(r*ch + c)*gw + gw - 1] = '\n';
+        }
+    }
+
+    scopy(board + len - gw, board, gw);
+    board[len] = '\0';
+
+    return board;
+}
+
+struct game_ui {
+    int x, y;
+    unsigned int show: 1;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->x = ui->y = 0;
+    ui->show = FALSE;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+    assert (encoding == NULL);
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+typedef unsigned short dsflags;
+
+struct game_drawstate {
+    int tilesize;
+    dsflags *grid;
+};
+
+#define TILESIZE (ds->tilesize)
+#define MARGIN (ds->tilesize / 2)
+#define WIDTH (1 + (TILESIZE >= 16) + (TILESIZE >= 32) + (TILESIZE >= 64))
+#define CENTER ((ds->tilesize / 2) + WIDTH/2)
+
+#define FROMCOORD(x) (((x) - MARGIN) / TILESIZE)
+
+enum {MAYBE_LEFT, MAYBE_RIGHT, ON_LEFT, ON_RIGHT, OFF_LEFT, OFF_RIGHT};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds, int x, int y, int button)
+{
+    int w = state->shared->params.w, h = state->shared->params.h;
+    int control = button & MOD_CTRL, shift = button & MOD_SHFT;
+
+    button &= ~MOD_MASK;
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        int gx = FROMCOORD(x), gy = FROMCOORD(y), possible = BORDER_MASK;
+        int px = (x - MARGIN) % TILESIZE, py = (y - MARGIN) % TILESIZE;
+        int hx, hy, dir, i;
+
+        if (OUT_OF_BOUNDS(gx, gy, w, h)) return NULL;
+
+        ui->x = gx;
+        ui->y = gy;
+
+        /* find edge closest to click point */
+        possible &=~ (2*px < TILESIZE ? BORDER_R : BORDER_L);
+        possible &=~ (2*py < TILESIZE ? BORDER_D : BORDER_U);
+        px = min(px, TILESIZE - px);
+        py = min(py, TILESIZE - py);
+        possible &=~ (px < py ? (BORDER_U|BORDER_D) : (BORDER_L|BORDER_R));
+
+        for (dir = 0; dir < 4 && BORDER(dir) != possible; ++dir);
+        if (dir == 4) return NULL; /* there's not exactly one such edge */
+
+        hx = gx + dx[dir];
+        hy = gy + dy[dir];
+
+        if (OUT_OF_BOUNDS(hx, hy, w, h)) return NULL;
+
+        ui->show = FALSE;
+
+        i = gy * w + gx;
+        switch ((button == RIGHT_BUTTON) |
+                ((state->borders[i] & BORDER(dir)) >> dir << 1) |
+                ((state->borders[i] & DISABLED(BORDER(dir))) >> dir >> 2)) {
+
+        case MAYBE_LEFT:
+        case ON_LEFT:
+        case ON_RIGHT:
+            return string(80, "F%d,%d,%dF%d,%d,%d",
+                          gx, gy, BORDER(dir),
+                          hx, hy, BORDER(FLIP(dir)));
+
+        case MAYBE_RIGHT:
+        case OFF_LEFT:
+        case OFF_RIGHT:
+            return string(80, "F%d,%d,%dF%d,%d,%d",
+                          gx, gy, DISABLED(BORDER(dir)),
+                          hx, hy, DISABLED(BORDER(FLIP(dir))));
+        }
+    }
+
+    if (IS_CURSOR_MOVE(button)) {
+        ui->show = TRUE;
+        if (control || shift) {
+            borderflag flag = 0, newflag;
+            int dir, i =  ui->y * w + ui->x;
+            x = ui->x;
+            y = ui->y;
+            move_cursor(button, &x, &y, w, h, FALSE);
+            if (OUT_OF_BOUNDS(x, y, w, h)) return NULL;
+
+            for (dir = 0; dir < 4; ++dir)
+                if (dx[dir] == x - ui->x && dy[dir] == y - ui->y) break;
+            if (dir == 4) return NULL; /* how the ... ?! */
+
+            if (control) flag |= BORDER(dir);
+            if (shift) flag |= DISABLED(BORDER(dir));
+
+            newflag = state->borders[i] ^ flag;
+            if (newflag & BORDER(dir) && newflag & DISABLED(BORDER(dir)))
+                return NULL;
+
+            newflag = 0;
+            if (control) newflag |= BORDER(FLIP(dir));
+            if (shift) newflag |= DISABLED(BORDER(FLIP(dir)));
+            return string(80, "F%d,%d,%dF%d,%d,%d",
+                          ui->x, ui->y, flag, x, y, newflag);
+        } else {
+            move_cursor(button, &ui->x, &ui->y, w, h, FALSE);
+            return "";
+        }
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int w = state->shared->params.w, h = state->shared->params.h, wh = w * h;
+    game_state *ret = dup_game(state);
+    int nchars, x, y, flag;
+
+    if (*move == 'S') {
+        int i;
+        ++move;
+        for (i = 0; i < wh && move[i]; ++i)
+            ret->borders[i] =
+                (move[i] & BORDER_MASK) | DISABLED(~move[i] & BORDER_MASK);
+        if (i < wh || move[i]) return NULL; /* leaks `ret', then we die */
+        ret->cheated = ret->completed = TRUE;
+        return ret;
+    }
+
+    while (sscanf(move, "F%d,%d,%d%n", &x, &y, &flag, &nchars) == 3 &&
+           !OUT_OF_BOUNDS(x, y, w, h)) {
+        move += nchars;
+        ret->borders[y*w + x] ^= flag;
+    }
+
+    if (*move) return NULL; /* leaks `ret', then we die */
+
+    if (!ret->completed)
+        ret->completed = is_solved(&ret->shared->params, ret->shared->clues,
+                                   ret->borders);
+
+    return ret;
+}
+
+/* --- Drawing routines --------------------------------------------- */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    *x = (params->w + 1) * tilesize;
+    *y = (params->h + 1) * tilesize;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+enum {
+    COL_BACKGROUND,
+    COL_FLASH,
+    COL_GRID,
+    COL_CLUE = COL_GRID,
+    COL_LINE_YES = COL_GRID,
+    COL_LINE_MAYBE,
+    COL_LINE_NO,
+    COL_ERROR,
+
+    NCOLOURS
+};
+
+#define COLOUR(i, r, g, b) \
+   ((ret[3*(i)+0] = (r)), (ret[3*(i)+1] = (g)), (ret[3*(i)+2] = (b)))
+#define DARKER 0.9F
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, -1, COL_FLASH);
+
+    COLOUR(COL_GRID,   0.0F, 0.0F, 0.0F); /* black */
+    COLOUR(COL_ERROR,  1.0F, 0.0F, 0.0F); /* red */
+
+    COLOUR(COL_LINE_MAYBE, /* yellow */
+           ret[COL_BACKGROUND*3 + 0] * DARKER,
+           ret[COL_BACKGROUND*3 + 1] * DARKER,
+           0.0F);
+
+    COLOUR(COL_LINE_NO,
+           ret[COL_BACKGROUND*3 + 0] * DARKER,
+           ret[COL_BACKGROUND*3 + 1] * DARKER,
+           ret[COL_BACKGROUND*3 + 2] * DARKER);
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+#undef COLOUR
+
+#define BORDER_ERROR(x) ((x) << 8)
+#define F_ERROR_U BORDER_ERROR(BORDER_U) /* BIT( 8) */
+#define F_ERROR_R BORDER_ERROR(BORDER_R) /* BIT( 9) */
+#define F_ERROR_D BORDER_ERROR(BORDER_D) /* BIT(10) */
+#define F_ERROR_L BORDER_ERROR(BORDER_L) /* BIT(11) */
+#define F_ERROR_CLUE BIT(12)
+#define F_FLASH BIT(13)
+#define F_CURSOR BIT(14)
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->tilesize = 0;
+    ds->grid = NULL;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+#define COLOUR(border)                                                  \
+    (flags & BORDER_ERROR((border)) ? COL_ERROR :                       \
+     flags & (border)               ? COL_LINE_YES :                    \
+     flags & DISABLED((border))     ? COL_LINE_NO :                     \
+                                      COL_LINE_MAYBE)
+
+static void draw_tile(drawing *dr, game_drawstate *ds, int r, int c,
+                      dsflags flags, int clue)
+{
+    int x = MARGIN + TILESIZE * c, y = MARGIN + TILESIZE * r;
+
+    clip(dr, x, y, TILESIZE + WIDTH, TILESIZE + WIDTH); /* { */
+
+    draw_rect(dr, x + WIDTH, y + WIDTH, TILESIZE - WIDTH, TILESIZE - WIDTH,
+              (flags & F_FLASH ? COL_FLASH : COL_BACKGROUND));
+
+    if (flags & F_CURSOR)
+        draw_rect_corners(dr, x + CENTER, y + CENTER, TILESIZE / 3, COL_GRID);
+
+    if (clue != EMPTY) {
+        char buf[2];
+        buf[0] = '0' + clue;
+        buf[1] = '\0';
+        draw_text(dr, x + CENTER, y + CENTER, FONT_VARIABLE,
+                  TILESIZE / 2, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                  (flags & F_ERROR_CLUE ? COL_ERROR : COL_CLUE), buf);
+    }
+
+
+#define ts TILESIZE
+#define w WIDTH
+    draw_rect(dr, x + w,  y,      ts - w, w,      COLOUR(BORDER_U));
+    draw_rect(dr, x + ts, y + w,  w,      ts - w, COLOUR(BORDER_R));
+    draw_rect(dr, x + w,  y + ts, ts - w, w,      COLOUR(BORDER_D));
+    draw_rect(dr, x,      y + w,  w,      ts - w, COLOUR(BORDER_L));
+#undef ts
+#undef w
+
+    unclip(dr); /* } */
+    draw_update(dr, x, y, TILESIZE + WIDTH, TILESIZE + WIDTH);
+}
+
+#define FLASH_TIME 0.7F
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->shared->params.w, h = state->shared->params.h, wh = w*h;
+    int r, c, i, flash = ((int) (flashtime * 5 / FLASH_TIME)) % 2;
+    int *black_border_dsf = snew_dsf(wh), *yellow_border_dsf = snew_dsf(wh);
+    int k = state->shared->params.k;
+
+    if (!ds->grid) {
+        char buf[40];
+        int bgw = (w+1) * ds->tilesize, bgh = (h+1) * ds->tilesize;
+        draw_rect(dr, 0, 0, bgw, bgh, COL_BACKGROUND);
+
+        for (r = 0; r <= h; ++r)
+            for (c = 0; c <= w; ++c)
+                draw_rect(dr, MARGIN + TILESIZE * c, MARGIN + TILESIZE * r,
+                          WIDTH, WIDTH, COL_GRID);
+        draw_update(dr, 0, 0, bgw, bgh);
+
+        snewa(ds->grid, wh);
+        setmem(ds->grid, ~0, wh);
+
+        sprintf(buf, "Region size: %d", state->shared->params.k);
+        status_bar(dr, buf);
+    }
+
+    for (i = 0; i < wh; ++i) {
+        if (black_border_dsf[i] == UNVISITED)
+            dfs_dsf(i, w, state->borders, black_border_dsf, TRUE);
+        if (yellow_border_dsf[i] == UNVISITED)
+            dfs_dsf(i, w, state->borders, yellow_border_dsf, FALSE);
+    }
+
+    for (r = 0; r < h; ++r)
+        for (c = 0; c < w; ++c) {
+            int i = r * w + c, clue = state->shared->clues[i], flags, dir;
+            int on = bitcount[state->borders[i] & BORDER_MASK];
+            int off = bitcount[(state->borders[i] >> 4) & BORDER_MASK];
+
+            flags = state->borders[i];
+
+            if (flash) flags |= F_FLASH;
+
+            if (clue != EMPTY && (on > clue || clue > 4 - off))
+                flags |= F_ERROR_CLUE;
+
+            if (ui->show && ui->x == c && ui->y == r)
+                flags |= F_CURSOR;
+
+            /* border errors */
+            for (dir = 0; dir < 4; ++dir) {
+                int rr = r + dy[dir], cc = c + dx[dir], ii = rr * w + cc;
+
+                if (OUT_OF_BOUNDS(cc, rr, w, h)) continue;
+
+                /* we draw each border twice, except the outermost
+                 * big border, so we have to check for errors on
+                 * both sides of each border.*/
+                if (/* region too large */
+                    ((dsf_size(yellow_border_dsf, i) > k ||
+                      dsf_size(yellow_border_dsf, ii) > k) &&
+                     (dsf_canonify(yellow_border_dsf, i) !=
+                      dsf_canonify(yellow_border_dsf, ii)))
+
+                    ||
+                    /* region too small */
+                    ((dsf_size(black_border_dsf, i) < k ||
+                      dsf_size(black_border_dsf, ii) < k) &&
+                     dsf_canonify(black_border_dsf, i) !=
+                     dsf_canonify(black_border_dsf, ii))
+
+                    ||
+                    /* dangling borders within a single region */
+                    ((state->borders[i] & BORDER(dir)) &&
+                     /* we know it's a single region because there's a
+                      * path crossing no border from i to ii... */
+                     (dsf_canonify(yellow_border_dsf, i) ==
+                      dsf_canonify(yellow_border_dsf, ii) ||
+                      /* or because any such border would be an error */
+                      (dsf_size(black_border_dsf, i) <= k &&
+                       dsf_canonify(black_border_dsf, i) ==
+                       dsf_canonify(black_border_dsf, ii)))))
+
+                    flags |= BORDER_ERROR(BORDER(dir));
+            }
+
+            if (flags == ds->grid[i]) continue;
+            ds->grid[i] = flags;
+            draw_tile(dr, ds, r, c, ds->grid[i], clue);
+        }
+
+    sfree(black_border_dsf);
+    sfree(yellow_border_dsf);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate,
+                              int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate,
+                               int dir, game_ui *ui)
+{
+    if (newstate->completed && !newstate->cheated && !oldstate->completed)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    assert (!"this shouldn't get called");
+    return 0;                          /* placate optimiser */
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    game_compute_size(params, 700, &pw, &ph); /* 7mm, like loopy */
+
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void print_line(drawing *dr, int x1, int y1, int x2, int y2,
+                       int colour, int full)
+{
+    if (!full) {
+        int i, subdivisions = 8;
+        for (i = 1; i < subdivisions; ++i) {
+            int x = (x1 * (subdivisions - i) + x2 * i) / subdivisions;
+            int y = (y1 * (subdivisions - i) + y2 * i) / subdivisions;
+            draw_circle(dr, x, y, 3, colour, colour);
+        }
+    } else draw_line(dr, x1, y1, x2, y2, colour);
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->shared->params.w, h = state->shared->params.h;
+    int ink = print_mono_colour(dr, 0);
+    game_drawstate for_tilesize_macros, *ds = &for_tilesize_macros;
+    int r, c;
+
+    ds->tilesize = tilesize;
+
+    for (r = 0; r < h; ++r)
+        for (c = 0; c < w; ++c) {
+            int x = MARGIN + TILESIZE * c, y = MARGIN + TILESIZE * r;
+            int i = r * w + c, clue = state->shared->clues[i];
+
+            if (clue != EMPTY) {
+                char buf[2];
+                buf[0] = '0' + clue;
+                buf[1] = '\0';
+                draw_text(dr, x + CENTER, y + CENTER, FONT_VARIABLE,
+                          TILESIZE / 2, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                          ink, buf);
+            }
+
+#define ts TILESIZE
+#define FULL(DIR) (state->borders[i] & (BORDER_ ## DIR))
+            print_line(dr, x,      y,      x + ts, y,      ink, FULL(U));
+            print_line(dr, x + ts, y,      x + ts, y + ts, ink, FULL(R));
+            print_line(dr, x,      y + ts, x + ts, y + ts, ink, FULL(D));
+            print_line(dr, x,      y,      x,      y + ts, ink, FULL(L));
+#undef ts
+#undef FULL
+        }
+
+    for (r = 1; r < h; ++r)
+        for (c = 1; c < w; ++c) {
+            int j = r * w + c, i = j - 1 - w;
+            int x = MARGIN + TILESIZE * c, y = MARGIN + TILESIZE * r;
+            if (state->borders[i] & (BORDER_D|BORDER_R)) continue;
+            if (state->borders[j] & (BORDER_U|BORDER_L)) continue;
+            draw_circle(dr, x, y, 3, ink, ink);
+        }
+}
+
+#ifdef COMBINED
+#define thegame palisade
+#endif
+
+const struct game thegame = {
+    "Palisade", "games.palisade", "palisade",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    48, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    TRUE,                                     /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                         /* flags */
+};
diff --git a/apps/plugins/puzzles/pattern.R b/apps/plugins/puzzles/pattern.R
new file mode 100644
index 0000000000..d6695715f9
--- /dev/null
+++ b/apps/plugins/puzzles/pattern.R
@@ -0,0 +1,25 @@
+# -*- makefile -*-
+
+pattern  : [X] GTK COMMON pattern pattern-icon|no-icon
+
+pattern  : [G] WINDOWS COMMON pattern pattern.res|noicon.res
+
+patternsolver : [U] pattern[STANDALONE_SOLVER] STANDALONE
+patternsolver : [C] pattern[STANDALONE_SOLVER] STANDALONE
+
+patternpicture : [U] pattern[STANDALONE_PICTURE_GENERATOR] STANDALONE
+patternpicture : [C] pattern[STANDALONE_PICTURE_GENERATOR] STANDALONE
+
+ALL += pattern[COMBINED]
+
+!begin am gtk
+GAMES += pattern
+!end
+
+!begin >list.c
+    A(pattern) \
+!end
+
+!begin >gamedesc.txt
+pattern:pattern.exe:Pattern:Pattern puzzle:Fill in the pattern in the grid, given only the lengths of runs of black squares.
+!end
diff --git a/apps/plugins/puzzles/pattern.c b/apps/plugins/puzzles/pattern.c
new file mode 100644
index 0000000000..c741a2e3a4
--- /dev/null
+++ b/apps/plugins/puzzles/pattern.c
@@ -0,0 +1,2255 @@
+/*
+ * pattern.c: the pattern-reconstruction game known as `nonograms'.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+enum {
+    COL_BACKGROUND,
+    COL_EMPTY,
+    COL_FULL,
+    COL_TEXT,
+    COL_UNKNOWN,
+    COL_GRID,
+    COL_CURSOR,
+    COL_ERROR,
+    NCOLOURS
+};
+
+#define PREFERRED_TILE_SIZE 24
+#define TILE_SIZE (ds->tilesize)
+#define BORDER (3 * TILE_SIZE / 4)
+#define TLBORDER(d) ( (d) / 5 + 2 )
+#define GUTTER (TILE_SIZE / 2)
+
+#define FROMCOORD(d, x) \
+        ( ((x) - (BORDER + GUTTER + TILE_SIZE * TLBORDER(d))) / TILE_SIZE )
+
+#define SIZE(d) (2*BORDER + GUTTER + TILE_SIZE * (TLBORDER(d) + (d)))
+#define GETTILESIZE(d, w) ((double)w / (2.0 + (double)TLBORDER(d) + (double)(d)))
+
+#define TOCOORD(d, x) (BORDER + GUTTER + TILE_SIZE * (TLBORDER(d) + (x)))
+
+struct game_params {
+    int w, h;
+};
+
+#define GRID_UNKNOWN 2
+#define GRID_FULL 1
+#define GRID_EMPTY 0
+
+typedef struct game_state_common {
+    /* Parts of the game state that don't change during play. */
+    int w, h;
+    int rowsize;
+    int *rowdata, *rowlen;
+    unsigned char *immutable;
+    int refcount;
+} game_state_common;
+
+struct game_state {
+    game_state_common *common;
+    unsigned char *grid;
+    int completed, cheated;
+};
+
+#define FLASH_TIME 0.13F
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 15;
+
+    return ret;
+}
+
+static const struct game_params pattern_presets[] = {
+    {10, 10},
+    {15, 15},
+    {20, 20},
+#ifndef SLOW_SYSTEM
+    {25, 25},
+    {30, 30},
+#endif
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(pattern_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = pattern_presets[i];
+
+    sprintf(str, "%dx%d", ret->w, ret->h);
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    char const *p = string;
+
+    ret->w = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+    if (*p == 'x') {
+        p++;
+        ret->h = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+    } else {
+        ret->h = ret->w;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char ret[400];
+    int len;
+
+    len = sprintf(ret, "%dx%d", params->w, params->h);
+    assert(len < lenof(ret));
+    ret[len] = '\0';
+
+    return dupstr(ret);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(3, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = NULL;
+    ret[2].type = C_END;
+    ret[2].sval = NULL;
+    ret[2].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w <= 0 || params->h <= 0)
+        return "Width and height must both be greater than zero";
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Puzzle generation code.
+ * 
+ * For this particular puzzle, it seemed important to me to ensure
+ * a unique solution. I do this the brute-force way, by having a
+ * solver algorithm alongside the generator, and repeatedly
+ * generating a random grid until I find one whose solution is
+ * unique. It turns out that this isn't too onerous on a modern PC
+ * provided you keep grid size below around 30. Any offers of
+ * better algorithms, however, will be very gratefully received.
+ * 
+ * Another annoyance of this approach is that it limits the
+ * available puzzles to those solvable by the algorithm I've used.
+ * My algorithm only ever considers a single row or column at any
+ * one time, which means it's incapable of solving the following
+ * difficult example (found by Bella Image around 1995/6, when she
+ * and I were both doing maths degrees):
+ * 
+ *        2  1  2  1 
+ *
+ *      +--+--+--+--+
+ * 1 1  |  |  |  |  |
+ *      +--+--+--+--+
+ *   2  |  |  |  |  |
+ *      +--+--+--+--+
+ *   1  |  |  |  |  |
+ *      +--+--+--+--+
+ *   1  |  |  |  |  |
+ *      +--+--+--+--+
+ * 
+ * Obviously this cannot be solved by a one-row-or-column-at-a-time
+ * algorithm (it would require at least one row or column reading
+ * `2 1', `1 2', `3' or `4' to get started). However, it can be
+ * proved to have a unique solution: if the top left square were
+ * empty, then the only option for the top row would be to fill the
+ * two squares in the 1 columns, which would imply the squares
+ * below those were empty, leaving no place for the 2 in the second
+ * row. Contradiction. Hence the top left square is full, and the
+ * unique solution follows easily from that starting point.
+ * 
+ * (The game ID for this puzzle is 4x4:2/1/2/1/1.1/2/1/1 , in case
+ * it's useful to anyone.)
+ */
+
+#ifndef STANDALONE_PICTURE_GENERATOR
+static int float_compare(const void *av, const void *bv)
+{
+    const float *a = (const float *)av;
+    const float *b = (const float *)bv;
+    if (*a < *b)
+        return -1;
+    else if (*a > *b)
+        return +1;
+    else
+        return 0;
+}
+
+static void generate(random_state *rs, int w, int h, unsigned char *retgrid)
+{
+    float *fgrid;
+    float *fgrid2;
+    int step, i, j;
+    float threshold;
+
+    fgrid = snewn(w*h, float);
+
+    for (i = 0; i < h; i++) {
+        for (j = 0; j < w; j++) {
+            fgrid[i*w+j] = random_upto(rs, 100000000UL) / 100000000.F;
+        }
+    }
+
+    /*
+     * The above gives a completely random splattering of black and
+     * white cells. We want to gently bias this in favour of _some_
+     * reasonably thick areas of white and black, while retaining
+     * some randomness and fine detail.
+     * 
+     * So we evolve the starting grid using a cellular automaton.
+     * Currently, I'm doing something very simple indeed, which is
+     * to set each square to the average of the surrounding nine
+     * cells (or the average of fewer, if we're on a corner).
+     */
+    for (step = 0; step < 1; step++) {
+        fgrid2 = snewn(w*h, float);
+
+        for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+                float sx, xbar;
+                int n, p, q;
+
+                /*
+                 * Compute the average of the surrounding cells.
+                 */
+                n = 0;
+                sx = 0.F;
+                for (p = -1; p <= +1; p++) {
+                    for (q = -1; q <= +1; q++) {
+                        if (i+p < 0 || i+p >= h || j+q < 0 || j+q >= w)
+                            continue;
+                        /*
+                         * An additional special case not mentioned
+                         * above: if a grid dimension is 2xn then
+                         * we do not average across that dimension
+                         * at all. Otherwise a 2x2 grid would
+                         * contain four identical squares.
+                         */
+                        if ((h==2 && p!=0) || (w==2 && q!=0))
+                            continue;
+                        n++;
+                        sx += fgrid[(i+p)*w+(j+q)];
+                    }
+                }
+                xbar = sx / n;
+
+                fgrid2[i*w+j] = xbar;
+            }
+        }
+
+        sfree(fgrid);
+        fgrid = fgrid2;
+    }
+
+    fgrid2 = snewn(w*h, float);
+    memcpy(fgrid2, fgrid, w*h*sizeof(float));
+    qsort(fgrid2, w*h, sizeof(float), float_compare);
+    threshold = fgrid2[w*h/2];
+    sfree(fgrid2);
+
+    for (i = 0; i < h; i++) {
+        for (j = 0; j < w; j++) {
+            retgrid[i*w+j] = (fgrid[i*w+j] >= threshold ? GRID_FULL :
+                              GRID_EMPTY);
+        }
+    }
+
+    sfree(fgrid);
+}
+#endif
+
+static int compute_rowdata(int *ret, unsigned char *start, int len, int step)
+{
+    int i, n;
+
+    n = 0;
+
+    for (i = 0; i < len; i++) {
+        if (start[i*step] == GRID_FULL) {
+            int runlen = 1;
+            while (i+runlen < len && start[(i+runlen)*step] == GRID_FULL)
+                runlen++;
+            ret[n++] = runlen;
+            i += runlen;
+        }
+
+        if (i < len && start[i*step] == GRID_UNKNOWN)
+            return -1;
+    }
+
+    return n;
+}
+
+#define UNKNOWN 0
+#define BLOCK 1
+#define DOT 2
+#define STILL_UNKNOWN 3
+
+#ifdef STANDALONE_SOLVER
+int verbose = FALSE;
+#endif
+
+static int do_recurse(unsigned char *known, unsigned char *deduced,
+                       unsigned char *row,
+                       unsigned char *minpos_done, unsigned char *maxpos_done,
+                       unsigned char *minpos_ok, unsigned char *maxpos_ok,
+                       int *data, int len,
+                       int freespace, int ndone, int lowest)
+{
+    int i, j, k;
+
+
+    /* This algorithm basically tries all possible ways the given rows of
+     * black blocks can be laid out in the row/column being examined.
+     * Special care is taken to avoid checking the tail of a row/column
+     * if the same conditions have already been checked during this recursion
+     * The algorithm also takes care to cut its losses as soon as an
+     * invalid (partial) solution is detected.
+     */
+    if (data[ndone]) {
+        if (lowest >= minpos_done[ndone] && lowest <= maxpos_done[ndone]) {
+            if (lowest >= minpos_ok[ndone] && lowest <= maxpos_ok[ndone]) {
+                for (i=0; i<lowest; i++)
+                    deduced[i] |= row[i];
+            }
+            return lowest >= minpos_ok[ndone] && lowest <= maxpos_ok[ndone];
+        } else {
+            if (lowest < minpos_done[ndone]) minpos_done[ndone] = lowest;
+            if (lowest > maxpos_done[ndone]) maxpos_done[ndone] = lowest;
+        }
+        for (i=0; i<=freespace; i++) {
+            j = lowest;
+            for (k=0; k<i; k++) {
+                if (known[j] == BLOCK) goto next_iter;
+                row[j++] = DOT;
+            }
+            for (k=0; k<data[ndone]; k++) {
+                if (known[j] == DOT) goto next_iter;
+                row[j++] = BLOCK;
+            }
+            if (j < len) {
+                if (known[j] == BLOCK) goto next_iter;
+                row[j++] = DOT;
+            }
+            if (do_recurse(known, deduced, row, minpos_done, maxpos_done,
+                           minpos_ok, maxpos_ok, data, len, freespace-i, ndone+1, j)) {
+                if (lowest < minpos_ok[ndone]) minpos_ok[ndone] = lowest;
+                if (lowest + i > maxpos_ok[ndone]) maxpos_ok[ndone] = lowest + i;
+                if (lowest + i > maxpos_done[ndone]) maxpos_done[ndone] = lowest + i;
+            }
+            next_iter:
+            j++;
+        }
+        return lowest >= minpos_ok[ndone] && lowest <= maxpos_ok[ndone];
+    } else {
+        for (i=lowest; i<len; i++) {
+            if (known[i] == BLOCK) return FALSE;
+            row[i] = DOT;
+            }
+        for (i=0; i<len; i++)
+            deduced[i] |= row[i];
+        return TRUE;
+    }
+}
+
+
+static int do_row(unsigned char *known, unsigned char *deduced,
+                  unsigned char *row,
+                  unsigned char *minpos_done, unsigned char *maxpos_done,
+                  unsigned char *minpos_ok, unsigned char *maxpos_ok,
+                  unsigned char *start, int len, int step, int *data,
+                  unsigned int *changed
+#ifdef STANDALONE_SOLVER
+                  , const char *rowcol, int index, int cluewid
+#endif
+                  )
+{
+    int rowlen, i, freespace, done_any;
+
+    freespace = len+1;
+    for (rowlen = 0; data[rowlen]; rowlen++) {
+        minpos_done[rowlen] = minpos_ok[rowlen] = len - 1;
+        maxpos_done[rowlen] = maxpos_ok[rowlen] = 0;
+        freespace -= data[rowlen]+1;
+    }
+
+    for (i = 0; i < len; i++) {
+        known[i] = start[i*step];
+        deduced[i] = 0;
+    }
+    for (i = len - 1; i >= 0 && known[i] == DOT; i--)
+        freespace--;
+
+    if (rowlen == 0) {
+        memset(deduced, DOT, len);
+    } else {
+        do_recurse(known, deduced, row, minpos_done, maxpos_done, minpos_ok,
+                   maxpos_ok, data, len, freespace, 0, 0);
+    }
+
+    done_any = FALSE;
+    for (i=0; i<len; i++)
+        if (deduced[i] && deduced[i] != STILL_UNKNOWN && !known[i]) {
+            start[i*step] = deduced[i];
+            if (changed) changed[i]++;
+            done_any = TRUE;
+        }
+#ifdef STANDALONE_SOLVER
+    if (verbose && done_any) {
+        char buf[80];
+        int thiscluewid;
+        printf("%s %2d: [", rowcol, index);
+        for (thiscluewid = -1, i = 0; data[i]; i++)
+            thiscluewid += sprintf(buf, " %d", data[i]);
+        printf("%*s", cluewid - thiscluewid, "");
+        for (i = 0; data[i]; i++)
+            printf(" %d", data[i]);
+        printf(" ] ");
+        for (i = 0; i < len; i++)
+            putchar(known[i] == BLOCK ? '#' :
+                    known[i] == DOT ? '.' : '?');
+        printf(" -> ");
+        for (i = 0; i < len; i++)
+            putchar(start[i*step] == BLOCK ? '#' :
+                    start[i*step] == DOT ? '.' : '?');
+        putchar('\n');
+    }
+#endif
+    return done_any;
+}
+
+static int solve_puzzle(const game_state *state, unsigned char *grid,
+                        int w, int h,
+                        unsigned char *matrix, unsigned char *workspace,
+                        unsigned int *changed_h, unsigned int *changed_w,
+                        int *rowdata
+#ifdef STANDALONE_SOLVER
+                        , int cluewid
+#else
+                        , int dummy
+#endif
+                        )
+{
+    int i, j, ok, max;
+    int max_h, max_w;
+
+    assert((state!=NULL && state->common->rowdata!=NULL) ^ (grid!=NULL));
+
+    max = max(w, h);
+
+    memset(matrix, 0, w*h);
+    if (state) {
+        for (i=0; i<w*h; i++) {
+            if (state->common->immutable[i])
+                matrix[i] = state->grid[i];
+        }
+    }
+
+    /* For each column, compute how many squares can be deduced
+     * from just the row-data and initial clues.
+     * Later, changed_* will hold how many squares were changed
+     * in every row/column in the previous iteration
+     * Changed_* is used to choose the next rows / cols to re-examine
+     */
+    for (i=0; i<h; i++) {
+        int freespace, rowlen;
+        if (state && state->common->rowdata) {
+            memcpy(rowdata, state->common->rowdata + state->common->rowsize*(w+i), max*sizeof(int));
+            rowlen = state->common->rowlen[w+i];
+        } else {
+            rowlen = compute_rowdata(rowdata, grid+i*w, w, 1);
+        }
+        rowdata[rowlen] = 0;
+        if (rowlen == 0) {
+            changed_h[i] = w;
+        } else {
+            for (j=0, freespace=w+1; rowdata[j]; j++)
+                freespace -= rowdata[j] + 1;
+            for (j=0, changed_h[i]=0; rowdata[j]; j++)
+                if (rowdata[j] > freespace)
+                    changed_h[i] += rowdata[j] - freespace;
+        }
+        for (j = 0; j < w; j++)
+            if (matrix[i*w+j])
+                changed_h[i]++;
+    }
+    for (i=0,max_h=0; i<h; i++)
+        if (changed_h[i] > max_h)
+            max_h = changed_h[i];
+    for (i=0; i<w; i++) {
+        int freespace, rowlen;
+        if (state && state->common->rowdata) {
+            memcpy(rowdata, state->common->rowdata + state->common->rowsize*i, max*sizeof(int));
+            rowlen = state->common->rowlen[i];
+        } else {
+            rowlen = compute_rowdata(rowdata, grid+i, h, w);
+        }
+        rowdata[rowlen] = 0;
+        if (rowlen == 0) {
+            changed_w[i] = h;
+        } else {
+            for (j=0, freespace=h+1; rowdata[j]; j++)
+                freespace -= rowdata[j] + 1;
+            for (j=0, changed_w[i]=0; rowdata[j]; j++)
+                if (rowdata[j] > freespace)
+                    changed_w[i] += rowdata[j] - freespace;
+        }
+        for (j = 0; j < h; j++)
+            if (matrix[j*w+i])
+                changed_w[i]++;
+    }
+    for (i=0,max_w=0; i<w; i++)
+        if (changed_w[i] > max_w)
+            max_w = changed_w[i];
+
+    /* Solve the puzzle.
+     * Process rows/columns individually. Deductions involving more than one
+     * row and/or column at a time are not supported.
+     * Take care to only process rows/columns which have been changed since they
+     * were previously processed.
+     * Also, prioritize rows/columns which have had the most changes since their
+     * previous processing, as they promise the greatest benefit.
+     * Extremely rectangular grids (e.g. 10x20, 15x40, etc.) are not treated specially.
+     */
+    do {
+        for (; max_h && max_h >= max_w; max_h--) {
+            for (i=0; i<h; i++) {
+                if (changed_h[i] >= max_h) {
+                    if (state && state->common->rowdata) {
+                        memcpy(rowdata, state->common->rowdata + state->common->rowsize*(w+i), max*sizeof(int));
+                        rowdata[state->common->rowlen[w+i]] = 0;
+                    } else {
+                        rowdata[compute_rowdata(rowdata, grid+i*w, w, 1)] = 0;
+                    }
+                    do_row(workspace, workspace+max, workspace+2*max,
+                           workspace+3*max, workspace+4*max,
+                           workspace+5*max, workspace+6*max,
+                           matrix+i*w, w, 1, rowdata, changed_w
+#ifdef STANDALONE_SOLVER
+                           , "row", i+1, cluewid
+#endif
+                           );
+                    changed_h[i] = 0;
+                }
+            }
+            for (i=0,max_w=0; i<w; i++)
+                if (changed_w[i] > max_w)
+                    max_w = changed_w[i];
+        }
+        for (; max_w && max_w >= max_h; max_w--) {
+            for (i=0; i<w; i++) {
+                if (changed_w[i] >= max_w) {
+                    if (state && state->common->rowdata) {
+                        memcpy(rowdata, state->common->rowdata + state->common->rowsize*i, max*sizeof(int));
+                        rowdata[state->common->rowlen[i]] = 0;
+                    } else {
+                        rowdata[compute_rowdata(rowdata, grid+i, h, w)] = 0;
+                    }
+                    do_row(workspace, workspace+max, workspace+2*max,
+                           workspace+3*max, workspace+4*max,
+                           workspace+5*max, workspace+6*max,
+                           matrix+i, h, w, rowdata, changed_h
+#ifdef STANDALONE_SOLVER
+                           , "col", i+1, cluewid
+#endif
+                           );
+                    changed_w[i] = 0;
+                }
+            }
+            for (i=0,max_h=0; i<h; i++)
+                if (changed_h[i] > max_h)
+                    max_h = changed_h[i];
+        }
+    } while (max_h>0 || max_w>0);
+
+    ok = TRUE;
+    for (i=0; i<h; i++) {
+        for (j=0; j<w; j++) {
+            if (matrix[i*w+j] == UNKNOWN)
+                ok = FALSE;
+        }
+    }
+
+    return ok;
+}
+
+#ifndef STANDALONE_PICTURE_GENERATOR
+static unsigned char *generate_soluble(random_state *rs, int w, int h)
+{
+    int i, j, ok, ntries, max;
+    unsigned char *grid, *matrix, *workspace;
+    unsigned int *changed_h, *changed_w;
+    int *rowdata;
+
+    max = max(w, h);
+
+    grid = snewn(w*h, unsigned char);
+    /* Allocate this here, to avoid having to reallocate it again for every geneerated grid */
+    matrix = snewn(w*h, unsigned char);
+    workspace = snewn(max*7, unsigned char);
+    changed_h = snewn(max+1, unsigned int);
+    changed_w = snewn(max+1, unsigned int);
+    rowdata = snewn(max+1, int);
+
+    ntries = 0;
+
+    do {
+        ntries++;
+
+        generate(rs, w, h, grid);
+
+        /*
+         * The game is a bit too easy if any row or column is
+         * completely black or completely white. An exception is
+         * made for rows/columns that are under 3 squares,
+         * otherwise nothing will ever be successfully generated.
+         */
+        ok = TRUE;
+        if (w > 2) {
+            for (i = 0; i < h; i++) {
+                int colours = 0;
+                for (j = 0; j < w; j++)
+                    colours |= (grid[i*w+j] == GRID_FULL ? 2 : 1);
+                if (colours != 3)
+                    ok = FALSE;
+            }
+        }
+        if (h > 2) {
+            for (j = 0; j < w; j++) {
+                int colours = 0;
+                for (i = 0; i < h; i++)
+                    colours |= (grid[i*w+j] == GRID_FULL ? 2 : 1);
+                if (colours != 3)
+                    ok = FALSE;
+            }
+        }
+        if (!ok)
+            continue;
+
+        ok = solve_puzzle(NULL, grid, w, h, matrix, workspace,
+                          changed_h, changed_w, rowdata, 0);
+    } while (!ok);
+
+    sfree(matrix);
+    sfree(workspace);
+    sfree(changed_h);
+    sfree(changed_w);
+    sfree(rowdata);
+    return grid;
+}
+#endif
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+unsigned char *picture;
+#endif
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    unsigned char *grid;
+    int i, j, max, rowlen, *rowdata;
+    char intbuf[80], *desc;
+    int desclen, descpos;
+#ifdef STANDALONE_PICTURE_GENERATOR
+    game_state *state;
+    int *index;
+#endif
+
+    max = max(params->w, params->h);
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+    /*
+     * Fixed input picture.
+     */
+    grid = snewn(params->w * params->h, unsigned char);
+    memcpy(grid, picture, params->w * params->h);
+
+    /*
+     * Now winnow the immutable square set as far as possible.
+     */
+    state = snew(game_state);
+    state->grid = grid;
+    state->common = snew(game_state_common);
+    state->common->rowdata = NULL;
+    state->common->immutable = snewn(params->w * params->h, unsigned char);
+    memset(state->common->immutable, 1, params->w * params->h);
+
+    index = snewn(params->w * params->h, int);
+    for (i = 0; i < params->w * params->h; i++)
+        index[i] = i;
+    shuffle(index, params->w * params->h, sizeof(*index), rs);
+
+    {
+        unsigned char *matrix = snewn(params->w*params->h, unsigned char);
+        unsigned char *workspace = snewn(max*7, unsigned char);
+        unsigned int *changed_h = snewn(max+1, unsigned int);
+        unsigned int *changed_w = snewn(max+1, unsigned int);
+        int *rowdata = snewn(max+1, int);
+        for (i = 0; i < params->w * params->h; i++) {
+            state->common->immutable[index[i]] = 0;
+            if (!solve_puzzle(state, grid, params->w, params->h,
+                              matrix, workspace, changed_h, changed_w,
+                              rowdata, 0))
+                state->common->immutable[index[i]] = 1;
+        }
+        sfree(workspace);
+        sfree(changed_h);
+        sfree(changed_w);
+        sfree(rowdata);
+        sfree(matrix);
+    }
+#else
+    grid = generate_soluble(rs, params->w, params->h);
+#endif
+    rowdata = snewn(max, int);
+
+    /*
+     * Save the solved game in aux.
+     */
+    if (aux) {
+        char *ai = snewn(params->w * params->h + 2, char);
+
+        /*
+         * String format is exactly the same as a solve move, so we
+         * can just dupstr this in solve_game().
+         */
+
+        ai[0] = 'S';
+
+        for (i = 0; i < params->w * params->h; i++)
+            ai[i+1] = grid[i] ? '1' : '0';
+
+        ai[params->w * params->h + 1] = '\0';
+
+        *aux = ai;
+    }
+
+    /*
+     * Seed is a slash-separated list of row contents; each row
+     * contents section is a dot-separated list of integers. Row
+     * contents are listed in the order (columns left to right,
+     * then rows top to bottom).
+     * 
+     * Simplest way to handle memory allocation is to make two
+     * passes, first computing the seed size and then writing it
+     * out.
+     */
+    desclen = 0;
+    for (i = 0; i < params->w + params->h; i++) {
+        if (i < params->w)
+            rowlen = compute_rowdata(rowdata, grid+i, params->h, params->w);
+        else
+            rowlen = compute_rowdata(rowdata, grid+(i-params->w)*params->w,
+                                     params->w, 1);
+        if (rowlen > 0) {
+            for (j = 0; j < rowlen; j++) {
+                desclen += 1 + sprintf(intbuf, "%d", rowdata[j]);
+            }
+        } else {
+            desclen++;
+        }
+    }
+    desc = snewn(desclen, char);
+    descpos = 0;
+    for (i = 0; i < params->w + params->h; i++) {
+        if (i < params->w)
+            rowlen = compute_rowdata(rowdata, grid+i, params->h, params->w);
+        else
+            rowlen = compute_rowdata(rowdata, grid+(i-params->w)*params->w,
+                                     params->w, 1);
+        if (rowlen > 0) {
+            for (j = 0; j < rowlen; j++) {
+                int len = sprintf(desc+descpos, "%d", rowdata[j]);
+                if (j+1 < rowlen)
+                    desc[descpos + len] = '.';
+                else
+                    desc[descpos + len] = '/';
+                descpos += len+1;
+            }
+        } else {
+            desc[descpos++] = '/';
+        }
+    }
+    assert(descpos == desclen);
+    assert(desc[desclen-1] == '/');
+    desc[desclen-1] = '\0';
+#ifdef STANDALONE_PICTURE_GENERATOR
+    for (i = 0; i < params->w * params->h; i++)
+        if (state->common->immutable[i])
+            break;
+    if (i < params->w * params->h) {
+        /*
+         * At least one immutable square, so we need a suffix.
+         */
+        int run;
+
+        desc = sresize(desc, desclen + params->w * params->h + 3, char);
+        desc[descpos-1] = ',';
+
+        run = 0;
+        for (i = 0; i < params->w * params->h; i++) {
+            if (!state->common->immutable[i]) {
+                run++;
+                if (run == 25) {
+                    desc[descpos++] = 'z';
+                    run = 0;
+                }
+            } else {
+                desc[descpos++] = run + (grid[i] == GRID_FULL ? 'A' : 'a');
+                run = 0;
+            }
+        }
+        if (run > 0)
+            desc[descpos++] = run + 'a';
+        desc[descpos] = '\0';
+    }
+    sfree(state->common->immutable);
+    sfree(state->common);
+    sfree(state);
+#endif
+    sfree(rowdata);
+    sfree(grid);
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int i, n, rowspace;
+    const char *p;
+
+    for (i = 0; i < params->w + params->h; i++) {
+        if (i < params->w)
+            rowspace = params->h + 1;
+        else
+            rowspace = params->w + 1;
+
+        if (*desc && isdigit((unsigned char)*desc)) {
+            do {
+                p = desc;
+                while (*desc && isdigit((unsigned char)*desc)) desc++;
+                n = atoi(p);
+                rowspace -= n+1;
+
+                if (rowspace < 0) {
+                    if (i < params->w)
+                        return "at least one column contains more numbers than will fit";
+                    else
+                        return "at least one row contains more numbers than will fit";
+                }
+            } while (*desc++ == '.');
+        } else {
+            desc++;                    /* expect a slash immediately */
+        }
+
+        if (desc[-1] == '/') {
+            if (i+1 == params->w + params->h)
+                return "too many row/column specifications";
+        } else if (desc[-1] == '\0' || desc[-1] == ',') {
+            if (i+1 < params->w + params->h)
+                return "too few row/column specifications";
+        } else
+            return "unrecognised character in game specification";
+    }
+
+    if (desc[-1] == ',') {
+        /*
+         * Optional extra piece of game description which fills in
+         * some grid squares as extra clues.
+         */
+        i = 0;
+        while (i < params->w * params->h) {
+            int c = (unsigned char)*desc++;
+            if ((c >= 'a' && c <= 'z') ||
+                (c >= 'A' && c <= 'Z')) {
+                int len = tolower(c) - 'a';
+                i += len;
+                if (len < 25 && i < params->w*params->h)
+                    i++;
+                if (i > params->w * params->h) {
+                    return "too much data in clue-squares section";
+                }
+            } else if (!c) {
+                return "too little data in clue-squares section";
+            } else {
+                return "unrecognised character in clue-squares section";
+            }
+        }
+        if (*desc) {
+            return "too much data in clue-squares section";
+        }
+    }
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int i;
+    const char *p;
+    game_state *state = snew(game_state);
+
+    state->common = snew(game_state_common);
+    state->common->refcount = 1;
+
+    state->common->w = params->w;
+    state->common->h = params->h;
+
+    state->grid = snewn(state->common->w * state->common->h, unsigned char);
+    memset(state->grid, GRID_UNKNOWN, state->common->w * state->common->h);
+
+    state->common->immutable = snewn(state->common->w * state->common->h,
+                                     unsigned char);
+    memset(state->common->immutable, 0, state->common->w * state->common->h);
+
+    state->common->rowsize = max(state->common->w, state->common->h);
+    state->common->rowdata = snewn(state->common->rowsize * (state->common->w + state->common->h), int);
+    state->common->rowlen = snewn(state->common->w + state->common->h, int);
+
+    state->completed = state->cheated = FALSE;
+
+    for (i = 0; i < params->w + params->h; i++) {
+        state->common->rowlen[i] = 0;
+        if (*desc && isdigit((unsigned char)*desc)) {
+            do {
+                p = desc;
+                while (*desc && isdigit((unsigned char)*desc)) desc++;
+                state->common->rowdata[state->common->rowsize * i + state->common->rowlen[i]++] =
+                    atoi(p);
+            } while (*desc++ == '.');
+        } else {
+            desc++;                    /* expect a slash immediately */
+        }
+    }
+
+    if (desc[-1] == ',') {
+        /*
+         * Optional extra piece of game description which fills in
+         * some grid squares as extra clues.
+         */
+        i = 0;
+        while (i < params->w * params->h) {
+            int c = (unsigned char)*desc++;
+            int full = isupper(c), len = tolower(c) - 'a';
+            i += len;
+            if (len < 25 && i < params->w*params->h) {
+                state->grid[i] = full ? GRID_FULL : GRID_EMPTY;
+                state->common->immutable[i] = TRUE;
+                i++;
+            }
+        }
+    }
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->common = state->common;
+    ret->common->refcount++;
+
+    ret->grid = snewn(ret->common->w * ret->common->h, unsigned char);
+    memcpy(ret->grid, state->grid, ret->common->w * ret->common->h);
+
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (--state->common->refcount == 0) {
+        sfree(state->common->rowdata);
+        sfree(state->common->rowlen);
+        sfree(state->common->immutable);
+        sfree(state->common);
+    }
+    sfree(state->grid);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *ai, char **error)
+{
+    unsigned char *matrix;
+    int w = state->common->w, h = state->common->h;
+    int i;
+    char *ret;
+    int max, ok;
+    unsigned char *workspace;
+    unsigned int *changed_h, *changed_w;
+    int *rowdata;
+
+    /*
+     * If we already have the solved state in ai, copy it out.
+     */
+    if (ai)
+        return dupstr(ai);
+
+    max = max(w, h);
+    matrix = snewn(w*h, unsigned char);
+    workspace = snewn(max*7, unsigned char);
+    changed_h = snewn(max+1, unsigned int);
+    changed_w = snewn(max+1, unsigned int);
+    rowdata = snewn(max+1, int);
+
+    ok = solve_puzzle(state, NULL, w, h, matrix, workspace,
+                      changed_h, changed_w, rowdata, 0);
+
+    sfree(workspace);
+    sfree(changed_h);
+    sfree(changed_w);
+    sfree(rowdata);
+
+    if (!ok) {
+        sfree(matrix);
+        *error = "Solving algorithm cannot complete this puzzle";
+        return NULL;
+    }
+
+    ret = snewn(w*h+2, char);
+    ret[0] = 'S';
+    for (i = 0; i < w*h; i++) {
+        assert(matrix[i] == BLOCK || matrix[i] == DOT);
+        ret[i+1] = (matrix[i] == BLOCK ? '1' : '0');
+    }
+    ret[w*h+1] = '\0';
+
+    sfree(matrix);
+
+    return ret;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->common->w, h = state->common->h, i, j;
+    int left_gap = 0, top_gap = 0, ch = 2, cw = 1, limit = 1;
+
+    int len, topleft, lw, lh, gw, gh; /* {line,grid}_{width,height} */
+    char *board, *buf;
+
+    for (i = 0; i < w; ++i) {
+        top_gap = max(top_gap, state->common->rowlen[i]);
+        for (j = 0; j < state->common->rowlen[i]; ++j)
+            while (state->common->rowdata[i*state->common->rowsize + j] >= limit) {
+                ++cw;
+                limit *= 10;
+            }
+    }
+    for (i = 0; i < h; ++i) {
+        int rowlen = 0, predecessors = FALSE;
+        for (j = 0; j < state->common->rowlen[i+w]; ++j) {
+            int copy = state->common->rowdata[(i+w)*state->common->rowsize + j];
+            rowlen += predecessors;
+            predecessors = TRUE;
+            do ++rowlen; while (copy /= 10);
+        }
+        left_gap = max(left_gap, rowlen);
+    }
+
+    cw = max(cw, 3);
+
+    gw = w*cw + 2;
+    gh = h*ch + 1;
+    lw = gw + left_gap;
+    lh = gh + top_gap;
+    len = lw * lh;
+    topleft = lw * top_gap + left_gap;
+
+    board = snewn(len + 1, char);
+    sprintf(board, "%*s\n", len - 2, "");
+
+    for (i = 0; i < lh; ++i) {
+        board[lw - 1 + i*lw] = '\n';
+        if (i < top_gap) continue;
+        board[lw - 2 + i*lw] = ((i - top_gap) % ch ? '|' : '+');
+    }
+
+    for (i = 0; i < w; ++i) {
+        for (j = 0; j < state->common->rowlen[i]; ++j) {
+            int cell = topleft + i*cw + 1 + lw*(j - state->common->rowlen[i]);
+            int nch = sprintf(board + cell, "%*d", cw - 1,
+                              state->common->rowdata[i*state->common->rowsize + j]);
+            board[cell + nch] = ' '; /* de-NUL-ify */
+        }
+    }
+
+    buf = snewn(left_gap, char);
+    for (i = 0; i < h; ++i) {
+        char *p = buf, *start = board + top_gap*lw + left_gap + (i*ch+1)*lw;
+        for (j = 0; j < state->common->rowlen[i+w]; ++j) {
+            if (p > buf) *p++ = ' ';
+            p += sprintf(p, "%d", state->common->rowdata[(i+w)*state->common->rowsize + j]);
+        }
+        memcpy(start - (p - buf), buf, p - buf);
+    }
+
+    for (i = 0; i < w; ++i) {
+        for (j = 0; j < h; ++j) {
+            int cell = topleft + i*cw + j*ch*lw;
+            int center = cell + cw/2 + (ch/2)*lw;
+            int dx, dy;
+            board[cell] = 0 ? center : '+';
+            for (dx = 1; dx < cw; ++dx) board[cell + dx] = '-';
+            for (dy = 1; dy < ch; ++dy) board[cell + dy*lw] = '|';
+            if (state->grid[i*w+j] == GRID_UNKNOWN) continue;
+            for (dx = 1; dx < cw; ++dx)
+                for (dy = 1; dy < ch; ++dy)
+                    board[cell + dx + dy*lw] =
+                        state->grid[i*w+j] == GRID_FULL ? '#' : '.';
+        }
+    }
+
+    memcpy(board + topleft + h*ch*lw, board + topleft, gw - 1);
+
+    sfree(buf);
+
+    return board;
+}
+
+struct game_ui {
+    int dragging;
+    int drag_start_x;
+    int drag_start_y;
+    int drag_end_x;
+    int drag_end_y;
+    int drag, release, state;
+    int cur_x, cur_y, cur_visible;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ret;
+
+    ret = snew(game_ui);
+    ret->dragging = FALSE;
+    ret->cur_x = ret->cur_y = ret->cur_visible = 0;
+
+    return ret;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int started;
+    int w, h;
+    int tilesize;
+    unsigned char *visible, *numcolours;
+    int cur_x, cur_y;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int control = button & MOD_CTRL, shift = button & MOD_SHFT;
+    button &= ~MOD_MASK;
+
+    x = FROMCOORD(state->common->w, x);
+    y = FROMCOORD(state->common->h, y);
+
+    if (x >= 0 && x < state->common->w && y >= 0 && y < state->common->h &&
+        (button == LEFT_BUTTON || button == RIGHT_BUTTON ||
+         button == MIDDLE_BUTTON)) {
+#ifdef STYLUS_BASED
+        int currstate = state->grid[y * state->common->w + x];
+#endif
+
+        ui->dragging = TRUE;
+
+        if (button == LEFT_BUTTON) {
+            ui->drag = LEFT_DRAG;
+            ui->release = LEFT_RELEASE;
+#ifdef STYLUS_BASED
+            ui->state = (currstate + 2) % 3; /* FULL -> EMPTY -> UNKNOWN */
+#else
+            ui->state = GRID_FULL;
+#endif
+        } else if (button == RIGHT_BUTTON) {
+            ui->drag = RIGHT_DRAG;
+            ui->release = RIGHT_RELEASE;
+#ifdef STYLUS_BASED
+            ui->state = (currstate + 1) % 3; /* EMPTY -> FULL -> UNKNOWN */
+#else
+            ui->state = GRID_EMPTY;
+#endif
+        } else /* if (button == MIDDLE_BUTTON) */ {
+            ui->drag = MIDDLE_DRAG;
+            ui->release = MIDDLE_RELEASE;
+            ui->state = GRID_UNKNOWN;
+        }
+
+        ui->drag_start_x = ui->drag_end_x = x;
+        ui->drag_start_y = ui->drag_end_y = y;
+        ui->cur_visible = 0;
+
+        return "";                     /* UI activity occurred */
+    }
+
+    if (ui->dragging && button == ui->drag) {
+        /*
+         * There doesn't seem much point in allowing a rectangle
+         * drag; people will generally only want to drag a single
+         * horizontal or vertical line, so we make that easy by
+         * snapping to it.
+         * 
+         * Exception: if we're _middle_-button dragging to tag
+         * things as UNKNOWN, we may well want to trash an entire
+         * area and start over!
+         */
+        if (ui->state != GRID_UNKNOWN) {
+            if (abs(x - ui->drag_start_x) > abs(y - ui->drag_start_y))
+                y = ui->drag_start_y;
+            else
+                x = ui->drag_start_x;
+        }
+
+        if (x < 0) x = 0;
+        if (y < 0) y = 0;
+        if (x >= state->common->w) x = state->common->w - 1;
+        if (y >= state->common->h) y = state->common->h - 1;
+
+        ui->drag_end_x = x;
+        ui->drag_end_y = y;
+
+        return "";                     /* UI activity occurred */
+    }
+
+    if (ui->dragging && button == ui->release) {
+        int x1, x2, y1, y2, xx, yy;
+        int move_needed = FALSE;
+
+        x1 = min(ui->drag_start_x, ui->drag_end_x);
+        x2 = max(ui->drag_start_x, ui->drag_end_x);
+        y1 = min(ui->drag_start_y, ui->drag_end_y);
+        y2 = max(ui->drag_start_y, ui->drag_end_y);
+
+        for (yy = y1; yy <= y2; yy++)
+            for (xx = x1; xx <= x2; xx++)
+                if (!state->common->immutable[yy * state->common->w + xx] &&
+                    state->grid[yy * state->common->w + xx] != ui->state)
+                    move_needed = TRUE;
+
+        ui->dragging = FALSE;
+
+        if (move_needed) {
+            char buf[80];
+            sprintf(buf, "%c%d,%d,%d,%d",
+                    (char)(ui->state == GRID_FULL ? 'F' :
+                           ui->state == GRID_EMPTY ? 'E' : 'U'),
+                    x1, y1, x2-x1+1, y2-y1+1);
+            return dupstr(buf);
+        } else
+            return "";                 /* UI activity occurred */
+    }
+
+    if (IS_CURSOR_MOVE(button)) {
+        int x = ui->cur_x, y = ui->cur_y, newstate;
+        char buf[80];
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->common->w, state->common->h, 0);
+        ui->cur_visible = 1;
+        if (!control && !shift) return "";
+
+        newstate = control ? shift ? GRID_UNKNOWN : GRID_FULL : GRID_EMPTY;
+        if (state->grid[y * state->common->w + x] == newstate &&
+            state->grid[ui->cur_y * state->common->w + ui->cur_x] == newstate)
+            return "";
+
+        sprintf(buf, "%c%d,%d,%d,%d", control ? shift ? 'U' : 'F' : 'E',
+                min(x, ui->cur_x), min(y, ui->cur_y),
+                abs(x - ui->cur_x) + 1, abs(y - ui->cur_y) + 1);
+        return dupstr(buf);
+    }
+
+    if (IS_CURSOR_SELECT(button)) {
+        int currstate = state->grid[ui->cur_y * state->common->w + ui->cur_x];
+        int newstate;
+        char buf[80];
+
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+
+        if (button == CURSOR_SELECT2)
+            newstate = currstate == GRID_UNKNOWN ? GRID_EMPTY :
+                currstate == GRID_EMPTY ? GRID_FULL : GRID_UNKNOWN;
+        else
+            newstate = currstate == GRID_UNKNOWN ? GRID_FULL :
+                currstate == GRID_FULL ? GRID_EMPTY : GRID_UNKNOWN;
+
+        sprintf(buf, "%c%d,%d,%d,%d",
+                (char)(newstate == GRID_FULL ? 'F' :
+                       newstate == GRID_EMPTY ? 'E' : 'U'),
+                ui->cur_x, ui->cur_y, 1, 1);
+        return dupstr(buf);
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    game_state *ret;
+    int x1, x2, y1, y2, xx, yy;
+    int val;
+
+    if (move[0] == 'S' &&
+        strlen(move) == from->common->w * from->common->h + 1) {
+        int i;
+
+        ret = dup_game(from);
+
+        for (i = 0; i < ret->common->w * ret->common->h; i++)
+            ret->grid[i] = (move[i+1] == '1' ? GRID_FULL : GRID_EMPTY);
+
+        ret->completed = ret->cheated = TRUE;
+
+        return ret;
+    } else if ((move[0] == 'F' || move[0] == 'E' || move[0] == 'U') &&
+        sscanf(move+1, "%d,%d,%d,%d", &x1, &y1, &x2, &y2) == 4 &&
+        x1 >= 0 && x2 >= 0 && x1+x2 <= from->common->w &&
+        y1 >= 0 && y2 >= 0 && y1+y2 <= from->common->h) {
+
+        x2 += x1;
+        y2 += y1;
+        val = (move[0] == 'F' ? GRID_FULL :
+                 move[0] == 'E' ? GRID_EMPTY : GRID_UNKNOWN);
+
+        ret = dup_game(from);
+        for (yy = y1; yy < y2; yy++)
+            for (xx = x1; xx < x2; xx++)
+                if (!ret->common->immutable[yy * ret->common->w + xx])
+                    ret->grid[yy * ret->common->w + xx] = val;
+
+        /*
+         * An actual change, so check to see if we've completed the
+         * game.
+         */
+        if (!ret->completed) {
+            int *rowdata = snewn(ret->common->rowsize, int);
+            int i, len;
+
+            ret->completed = TRUE;
+
+            for (i=0; i<ret->common->w; i++) {
+                len = compute_rowdata(rowdata, ret->grid+i,
+                                      ret->common->h, ret->common->w);
+                if (len != ret->common->rowlen[i] ||
+                    memcmp(ret->common->rowdata+i*ret->common->rowsize,
+                           rowdata, len * sizeof(int))) {
+                    ret->completed = FALSE;
+                    break;
+                }
+            }
+            for (i=0; i<ret->common->h; i++) {
+                len = compute_rowdata(rowdata, ret->grid+i*ret->common->w,
+                                      ret->common->w, 1);
+                if (len != ret->common->rowlen[i+ret->common->w] ||
+                    memcmp(ret->common->rowdata +
+                           (i+ret->common->w)*ret->common->rowsize,
+                           rowdata, len * sizeof(int))) {
+                    ret->completed = FALSE;
+                    break;
+                }
+            }
+
+            sfree(rowdata);
+        }
+
+        return ret;
+    } else
+        return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Error-checking during gameplay.
+ */
+
+/*
+ * The difficulty in error-checking Pattern is to make the error check
+ * _weak_ enough. The most obvious way would be to check each row and
+ * column by calling (a modified form of) do_row() to recursively
+ * analyse the row contents against the clue set and see if the
+ * GRID_UNKNOWNs could be filled in in any way that would end up
+ * correct. However, this turns out to be such a strong error check as
+ * to constitute a spoiler in many situations: you make a typo while
+ * trying to fill in one row, and not only does the row light up to
+ * indicate an error, but several columns crossed by the move also
+ * light up and draw your attention to deductions you hadn't even
+ * noticed you could make.
+ *
+ * So instead I restrict error-checking to 'complete runs' within a
+ * row, by which I mean contiguous sequences of GRID_FULL bounded at
+ * both ends by either GRID_EMPTY or the ends of the row. We identify
+ * all the complete runs in a row, and verify that _those_ are
+ * consistent with the row's clue list. Sequences of complete runs
+ * separated by solid GRID_EMPTY are required to match contiguous
+ * sequences in the clue list, whereas if there's at least one
+ * GRID_UNKNOWN between any two complete runs then those two need not
+ * be contiguous in the clue list.
+ *
+ * To simplify the edge cases, I pretend that the clue list for the
+ * row is extended with a 0 at each end, and I also pretend that the
+ * grid data for the row is extended with a GRID_EMPTY and a
+ * zero-length run at each end. This permits the contiguity checker to
+ * handle the fiddly end effects (e.g. if the first contiguous
+ * sequence of complete runs in the grid matches _something_ in the
+ * clue list but not at the beginning, this is allowable iff there's a
+ * GRID_UNKNOWN before the first one) with minimal faff, since the end
+ * effects just drop out as special cases of the normal inter-run
+ * handling (in this code the above case is not 'at the end of the
+ * clue list' at all, but between the implicit initial zero run and
+ * the first nonzero one).
+ *
+ * We must also be a little careful about how we search for a
+ * contiguous sequence of runs. In the clue list (1 1 2 1 2 3),
+ * suppose we see a GRID_UNKNOWN and then a length-1 run. We search
+ * for 1 in the clue list and find it at the very beginning. But now
+ * suppose we find a length-2 run with no GRID_UNKNOWN before it. We
+ * can't naively look at the next clue from the 1 we found, because
+ * that'll be the second 1 and won't match. Instead, we must backtrack
+ * by observing that the 2 we've just found must be contiguous with
+ * the 1 we've already seen, so we search for the sequence (1 2) and
+ * find it starting at the second 1. Now if we see a 3, we must
+ * rethink again and search for (1 2 3).
+ */
+
+struct errcheck_state {
+    /*
+     * rowdata and rowlen point at the clue data for this row in the
+     * game state.
+     */
+    int *rowdata;
+    int rowlen;
+    /*
+     * rowpos indicates the lowest position where it would be valid to
+     * see our next run length. It might be equal to rowlen,
+     * indicating that the next run would have to be the terminating 0.
+     */
+    int rowpos;
+    /*
+     * ncontig indicates how many runs we've seen in a contiguous
+     * block. This is taken into account when searching for the next
+     * run we find, unless ncontig is zeroed out first by encountering
+     * a GRID_UNKNOWN.
+     */
+    int ncontig;
+};
+
+static int errcheck_found_run(struct errcheck_state *es, int r)
+{
+/* Macro to handle the pretence that rowdata has a 0 at each end */
+#define ROWDATA(k) ((k)<0 || (k)>=es->rowlen ? 0 : es->rowdata[(k)])
+
+    /*
+     * See if we can find this new run length at a position where it
+     * also matches the last 'ncontig' runs we've seen.
+     */
+    int i, newpos;
+    for (newpos = es->rowpos; newpos <= es->rowlen; newpos++) {
+
+        if (ROWDATA(newpos) != r)
+            goto notfound;
+
+        for (i = 1; i <= es->ncontig; i++)
+            if (ROWDATA(newpos - i) != ROWDATA(es->rowpos - i))
+                goto notfound;
+
+        es->rowpos = newpos+1;
+        es->ncontig++;
+        return TRUE;
+
+      notfound:;
+    }
+
+    return FALSE;
+
+#undef ROWDATA
+}
+
+static int check_errors(const game_state *state, int i)
+{
+    int start, step, end, j;
+    int val, runlen;
+    struct errcheck_state aes, *es = &aes;
+
+    es->rowlen = state->common->rowlen[i];
+    es->rowdata = state->common->rowdata + state->common->rowsize * i;
+    /* Pretend that we've already encountered the initial zero run */
+    es->ncontig = 1;
+    es->rowpos = 0;
+
+    if (i < state->common->w) {
+        start = i;
+        step = state->common->w;
+        end = start + step * state->common->h;
+    } else {
+        start = (i - state->common->w) * state->common->w;
+        step = 1;
+        end = start + step * state->common->w;
+    }
+
+    runlen = -1;
+    for (j = start - step; j <= end; j += step) {
+        if (j < start || j == end)
+            val = GRID_EMPTY;
+        else
+            val = state->grid[j];
+
+        if (val == GRID_UNKNOWN) {
+            runlen = -1;
+            es->ncontig = 0;
+        } else if (val == GRID_FULL) {
+            if (runlen >= 0)
+                runlen++;
+        } else if (val == GRID_EMPTY) {
+            if (runlen > 0) {
+                if (!errcheck_found_run(es, runlen))
+                    return TRUE;       /* error! */
+            }
+            runlen = 0;
+        }
+    }
+
+    /* Signal end-of-row by sending errcheck_found_run the terminating
+     * zero run, which will be marked as contiguous with the previous
+     * run if and only if there hasn't been a GRID_UNKNOWN before. */
+    if (!errcheck_found_run(es, 0))
+        return TRUE;                   /* error at the last minute! */
+
+    return FALSE;                      /* no error */
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = SIZE(params->w);
+    *y = SIZE(params->h);
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_GRID    * 3 + i] = 0.3F;
+        ret[COL_UNKNOWN * 3 + i] = 0.5F;
+        ret[COL_TEXT    * 3 + i] = 0.0F;
+        ret[COL_FULL    * 3 + i] = 0.0F;
+        ret[COL_EMPTY   * 3 + i] = 1.0F;
+    }
+    ret[COL_CURSOR * 3 + 0] = 1.0F;
+    ret[COL_CURSOR * 3 + 1] = 0.25F;
+    ret[COL_CURSOR * 3 + 2] = 0.25F;
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->started = FALSE;
+    ds->w = state->common->w;
+    ds->h = state->common->h;
+    ds->visible = snewn(ds->w * ds->h, unsigned char);
+    ds->tilesize = 0;                  /* not decided yet */
+    memset(ds->visible, 255, ds->w * ds->h);
+    ds->numcolours = snewn(ds->w + ds->h, unsigned char);
+    memset(ds->numcolours, 255, ds->w + ds->h);
+    ds->cur_x = ds->cur_y = 0;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->visible);
+    sfree(ds);
+}
+
+static void grid_square(drawing *dr, game_drawstate *ds,
+                        int y, int x, int state, int cur)
+{
+    int xl, xr, yt, yb, dx, dy, dw, dh;
+
+    draw_rect(dr, TOCOORD(ds->w, x), TOCOORD(ds->h, y),
+              TILE_SIZE, TILE_SIZE, COL_GRID);
+
+    xl = (x % 5 == 0 ? 1 : 0);
+    yt = (y % 5 == 0 ? 1 : 0);
+    xr = (x % 5 == 4 || x == ds->w-1 ? 1 : 0);
+    yb = (y % 5 == 4 || y == ds->h-1 ? 1 : 0);
+
+    dx = TOCOORD(ds->w, x) + 1 + xl;
+    dy = TOCOORD(ds->h, y) + 1 + yt;
+    dw = TILE_SIZE - xl - xr - 1;
+    dh = TILE_SIZE - yt - yb - 1;
+
+    draw_rect(dr, dx, dy, dw, dh,
+              (state == GRID_FULL ? COL_FULL :
+               state == GRID_EMPTY ? COL_EMPTY : COL_UNKNOWN));
+    if (cur) {
+        draw_rect_outline(dr, dx, dy, dw, dh, COL_CURSOR);
+        draw_rect_outline(dr, dx+1, dy+1, dw-2, dh-2, COL_CURSOR);
+    }
+
+    draw_update(dr, TOCOORD(ds->w, x), TOCOORD(ds->h, y),
+                TILE_SIZE, TILE_SIZE);
+}
+
+/*
+ * Draw the numbers for a single row or column.
+ */
+static void draw_numbers(drawing *dr, game_drawstate *ds,
+                         const game_state *state, int i, int erase, int colour)
+{
+    int rowlen = state->common->rowlen[i];
+    int *rowdata = state->common->rowdata + state->common->rowsize * i;
+    int nfit;
+    int j;
+
+    if (erase) {
+        if (i < state->common->w) {
+            draw_rect(dr, TOCOORD(state->common->w, i), 0,
+                      TILE_SIZE, BORDER + TLBORDER(state->common->h) * TILE_SIZE,
+                      COL_BACKGROUND);
+        } else {
+            draw_rect(dr, 0, TOCOORD(state->common->h, i - state->common->w),
+                      BORDER + TLBORDER(state->common->w) * TILE_SIZE, TILE_SIZE,
+                      COL_BACKGROUND);
+        }
+    }
+
+    /*
+     * Normally I space the numbers out by the same distance as the
+     * tile size. However, if there are more numbers than available
+     * spaces, I have to squash them up a bit.
+     */
+    if (i < state->common->w)
+        nfit = TLBORDER(state->common->h);
+    else
+        nfit = TLBORDER(state->common->w);
+    nfit = max(rowlen, nfit) - 1;
+    assert(nfit > 0);
+
+    for (j = 0; j < rowlen; j++) {
+        int x, y;
+        char str[80];
+
+        if (i < state->common->w) {
+            x = TOCOORD(state->common->w, i);
+            y = BORDER + TILE_SIZE * (TLBORDER(state->common->h)-1);
+            y -= ((rowlen-j-1)*TILE_SIZE) * (TLBORDER(state->common->h)-1) / nfit;
+        } else {
+            y = TOCOORD(state->common->h, i - state->common->w);
+            x = BORDER + TILE_SIZE * (TLBORDER(state->common->w)-1);
+            x -= ((rowlen-j-1)*TILE_SIZE) * (TLBORDER(state->common->w)-1) / nfit;
+        }
+
+        sprintf(str, "%d", rowdata[j]);
+        draw_text(dr, x+TILE_SIZE/2, y+TILE_SIZE/2, FONT_VARIABLE,
+                  TILE_SIZE/2, ALIGN_HCENTRE | ALIGN_VCENTRE, colour, str);
+    }
+
+    if (i < state->common->w) {
+        draw_update(dr, TOCOORD(state->common->w, i), 0,
+                    TILE_SIZE, BORDER + TLBORDER(state->common->h) * TILE_SIZE);
+    } else {
+        draw_update(dr, 0, TOCOORD(state->common->h, i - state->common->w),
+                    BORDER + TLBORDER(state->common->w) * TILE_SIZE, TILE_SIZE);
+    }
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int i, j;
+    int x1, x2, y1, y2;
+    int cx, cy, cmoved;
+
+    if (!ds->started) {
+        /*
+         * The initial contents of the window are not guaranteed
+         * and can vary with front ends. To be on the safe side,
+         * all games should start by drawing a big background-
+         * colour rectangle covering the whole window.
+         */
+        draw_rect(dr, 0, 0, SIZE(ds->w), SIZE(ds->h), COL_BACKGROUND);
+
+        /*
+         * Draw the grid outline.
+         */
+        draw_rect(dr, TOCOORD(ds->w, 0) - 1, TOCOORD(ds->h, 0) - 1,
+                  ds->w * TILE_SIZE + 3, ds->h * TILE_SIZE + 3,
+                  COL_GRID);
+
+        ds->started = TRUE;
+
+        draw_update(dr, 0, 0, SIZE(ds->w), SIZE(ds->h));
+    }
+
+    if (ui->dragging) {
+        x1 = min(ui->drag_start_x, ui->drag_end_x);
+        x2 = max(ui->drag_start_x, ui->drag_end_x);
+        y1 = min(ui->drag_start_y, ui->drag_end_y);
+        y2 = max(ui->drag_start_y, ui->drag_end_y);
+    } else {
+        x1 = x2 = y1 = y2 = -1;        /* placate gcc warnings */
+    }
+
+    if (ui->cur_visible) {
+        cx = ui->cur_x; cy = ui->cur_y;
+    } else {
+        cx = cy = -1;
+    }
+    cmoved = (cx != ds->cur_x || cy != ds->cur_y);
+
+    /*
+     * Now draw any grid squares which have changed since last
+     * redraw.
+     */
+    for (i = 0; i < ds->h; i++) {
+        for (j = 0; j < ds->w; j++) {
+            int val, cc = 0;
+
+            /*
+             * Work out what state this square should be drawn in,
+             * taking any current drag operation into account.
+             */
+            if (ui->dragging && x1 <= j && j <= x2 && y1 <= i && i <= y2 &&
+                !state->common->immutable[i * state->common->w + j])
+                val = ui->state;
+            else
+                val = state->grid[i * state->common->w + j];
+
+            if (cmoved) {
+                /* the cursor has moved; if we were the old or
+                 * the new cursor position we need to redraw. */
+                if (j == cx && i == cy) cc = 1;
+                if (j == ds->cur_x && i == ds->cur_y) cc = 1;
+            }
+
+            /*
+             * Briefly invert everything twice during a completion
+             * flash.
+             */
+            if (flashtime > 0 &&
+                (flashtime <= FLASH_TIME/3 || flashtime >= FLASH_TIME*2/3) &&
+                val != GRID_UNKNOWN)
+                val = (GRID_FULL ^ GRID_EMPTY) ^ val;
+
+            if (ds->visible[i * ds->w + j] != val || cc) {
+                grid_square(dr, ds, i, j, val,
+                            (j == cx && i == cy));
+                ds->visible[i * ds->w + j] = val;
+            }
+        }
+    }
+    ds->cur_x = cx; ds->cur_y = cy;
+
+    /*
+     * Redraw any numbers which have changed their colour due to error
+     * indication.
+     */
+    for (i = 0; i < state->common->w + state->common->h; i++) {
+        int colour = check_errors(state, i) ? COL_ERROR : COL_TEXT;
+        if (ds->numcolours[i] != colour) {
+            draw_numbers(dr, ds, state, i, TRUE, colour);
+            ds->numcolours[i] = colour;
+        }
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 5mm squares by default.
+     */
+    game_compute_size(params, 500, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->common->w, h = state->common->h;
+    int ink = print_mono_colour(dr, 0);
+    int x, y, i;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    /*
+     * Border.
+     */
+    print_line_width(dr, TILE_SIZE / 16);
+    draw_rect_outline(dr, TOCOORD(w, 0), TOCOORD(h, 0),
+                      w*TILE_SIZE, h*TILE_SIZE, ink);
+
+    /*
+     * Grid.
+     */
+    for (x = 1; x < w; x++) {
+        print_line_width(dr, TILE_SIZE / (x % 5 ? 128 : 24));
+        draw_line(dr, TOCOORD(w, x), TOCOORD(h, 0),
+                  TOCOORD(w, x), TOCOORD(h, h), ink);
+    }
+    for (y = 1; y < h; y++) {
+        print_line_width(dr, TILE_SIZE / (y % 5 ? 128 : 24));
+        draw_line(dr, TOCOORD(w, 0), TOCOORD(h, y),
+                  TOCOORD(w, w), TOCOORD(h, y), ink);
+    }
+
+    /*
+     * Clues.
+     */
+    for (i = 0; i < state->common->w + state->common->h; i++)
+        draw_numbers(dr, ds, state, i, FALSE, ink);
+
+    /*
+     * Solution.
+     */
+    print_line_width(dr, TILE_SIZE / 128);
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            if (state->grid[y*w+x] == GRID_FULL)
+                draw_rect(dr, TOCOORD(w, x), TOCOORD(h, y),
+                          TILE_SIZE, TILE_SIZE, ink);
+            else if (state->grid[y*w+x] == GRID_EMPTY)
+                draw_circle(dr, TOCOORD(w, x) + TILE_SIZE/2,
+                            TOCOORD(h, y) + TILE_SIZE/2,
+                            TILE_SIZE/12, ink, ink);
+        }
+}
+
+#ifdef COMBINED
+#define thegame pattern
+#endif
+
+const struct game thegame = {
+    "Pattern", "games.pattern", "pattern",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON,                   /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (*p == '-') {
+            if (!strcmp(p, "-v")) {
+                verbose = TRUE;
+            } else {
+                fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+                return 1;
+            }
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    {
+        int w = p->w, h = p->h, i, j, max, cluewid = 0;
+        unsigned char *matrix, *workspace;
+        unsigned int *changed_h, *changed_w;
+        int *rowdata;
+
+        matrix = snewn(w*h, unsigned char);
+        max = max(w, h);
+        workspace = snewn(max*7, unsigned char);
+        changed_h = snewn(max+1, unsigned int);
+        changed_w = snewn(max+1, unsigned int);
+        rowdata = snewn(max+1, int);
+
+        if (verbose) {
+            int thiswid;
+            /*
+             * Work out the maximum text width of the clue numbers
+             * in a row or column, so we can print the solver's
+             * working in a nicely lined up way.
+             */
+            for (i = 0; i < (w+h); i++) {
+                char buf[80];
+                for (thiswid = -1, j = 0; j < s->common->rowlen[i]; j++)
+                    thiswid += sprintf
+                        (buf, " %d",
+                         s->common->rowdata[s->common->rowsize*i+j]);
+                if (cluewid < thiswid)
+                    cluewid = thiswid;
+            }
+        }
+
+        solve_puzzle(s, NULL, w, h, matrix, workspace,
+                     changed_h, changed_w, rowdata, cluewid);
+
+        for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+                int c = (matrix[i*w+j] == UNKNOWN ? '?' :
+                         matrix[i*w+j] == BLOCK ? '#' :
+                         matrix[i*w+j] == DOT ? '.' :
+                         '!');
+                putchar(c);
+            }
+            printf("\n");
+        }
+    }
+
+    return 0;
+}
+
+#endif
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+
+/*
+ * Main program for the standalone picture generator. To use it,
+ * simply provide it with an XBM-format bitmap file (note XBM, not
+ * XPM) on standard input, and it will output a game ID in return.
+ * For example:
+ *
+ *   $ ./patternpicture < calligraphic-A.xbm
+ *   15x15:2/4/2/2/2/3/3/3.1/3.1/3.1/11/14/12/6/1/2/2/3/4/5/1.3/2.3/1.3/2.3/1.4/9/1.1.3/2.2.3/5.4/3.2
+ *
+ * That looks easy, of course - all the program has done is to count
+ * up the clue numbers! But in fact, it's done more than that: it's
+ * also checked that the result is uniquely soluble from just the
+ * numbers. If it hadn't been, then it would have also left some
+ * filled squares in the playing area as extra clues.
+ *
+ *   $ ./patternpicture < cube.xbm
+ *   15x15:10/2.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.10/1.1.1/1.1.1/1.1.1/2.1/10/10/1.2/1.1.1/1.1.1/1.1.1/10.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.2/10,TNINzzzzGNzw
+ *
+ * This enables a reasonably convenient design workflow for coming up
+ * with pictorial Pattern puzzles which _are_ uniquely soluble without
+ * those inelegant pre-filled squares. Fire up a bitmap editor (X11
+ * bitmap(1) is good enough), save a trial .xbm, and then test it by
+ * running a command along the lines of
+ *
+ *   $ ./pattern $(./patternpicture < test.xbm)
+ *
+ * If the resulting window pops up with some pre-filled squares, then
+ * that tells you which parts of the image are giving rise to
+ * ambiguities, so try making tweaks in those areas, try the test
+ * command again, and see if it helps. Once you have a design for
+ * which the Pattern starting grid comes out empty, there's your game
+ * ID.
+ */
+
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+    game_params *par;
+    char *params, *desc;
+    random_state *rs;
+    time_t seed = time(NULL);
+    char buf[4096];
+    int i;
+    int x, y;
+
+    par = default_params();
+    if (argc > 1)
+        decode_params(par, argv[1]);   /* get difficulty */
+    par->w = par->h = -1;
+
+    /*
+     * Now read an XBM file from standard input. This is simple and
+     * hacky and will do very little error detection, so don't feed
+     * it bogus data.
+     */
+    picture = NULL;
+    x = y = 0;
+    while (fgets(buf, sizeof(buf), stdin)) {
+        buf[strcspn(buf, "\r\n")] = '\0';
+        if (!strncmp(buf, "#define", 7)) {
+            /*
+             * Lines starting `#define' give the width and height.
+             */
+            char *num = buf + strlen(buf);
+            char *symend;
+
+            while (num > buf && isdigit((unsigned char)num[-1]))
+                num--;
+            symend = num;
+            while (symend > buf && isspace((unsigned char)symend[-1]))
+                symend--;
+
+            if (symend-5 >= buf && !strncmp(symend-5, "width", 5))
+                par->w = atoi(num);
+            else if (symend-6 >= buf && !strncmp(symend-6, "height", 6))
+                par->h = atoi(num);
+        } else {
+            /*
+             * Otherwise, break the string up into words and take
+             * any word of the form `0x' plus hex digits to be a
+             * byte.
+             */
+            char *p, *wordstart;
+
+            if (!picture) {
+                if (par->w < 0 || par->h < 0) {
+                    printf("failed to read width and height\n");
+                    return 1;
+                }
+                picture = snewn(par->w * par->h, unsigned char);
+                for (i = 0; i < par->w * par->h; i++)
+                    picture[i] = GRID_UNKNOWN;
+            }
+
+            p = buf;
+            while (*p) {
+                while (*p && (*p == ',' || isspace((unsigned char)*p)))
+                    p++;
+                wordstart = p;
+                while (*p && !(*p == ',' || *p == '}' ||
+                               isspace((unsigned char)*p)))
+                    p++;
+                if (*p)
+                    *p++ = '\0';
+
+                if (wordstart[0] == '0' &&
+                    (wordstart[1] == 'x' || wordstart[1] == 'X') &&
+                    !wordstart[2 + strspn(wordstart+2,
+                                          "0123456789abcdefABCDEF")]) {
+                    unsigned long byte = strtoul(wordstart+2, NULL, 16);
+                    for (i = 0; i < 8; i++) {
+                        int bit = (byte >> i) & 1;
+                        if (y < par->h && x < par->w)
+                            picture[y * par->w + x] =
+                                bit ? GRID_FULL : GRID_EMPTY;
+                        x++;
+                    }
+
+                    if (x >= par->w) {
+                        x = 0;
+                        y++;
+                    }
+                }
+            }
+        }
+    }
+
+    for (i = 0; i < par->w * par->h; i++)
+        if (picture[i] == GRID_UNKNOWN) {
+            fprintf(stderr, "failed to read enough bitmap data\n");
+            return 1;
+        }
+
+    rs = random_new((void*)&seed, sizeof(time_t));
+
+    desc = new_game_desc(par, rs, NULL, FALSE);
+    params = encode_params(par, FALSE);
+    printf("%s:%s\n", params, desc);
+
+    sfree(desc);
+    sfree(params);
+    free_params(par);
+    random_free(rs);
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/pearl.R b/apps/plugins/puzzles/pearl.R
new file mode 100644
index 0000000000..79bc7325c7
--- /dev/null
+++ b/apps/plugins/puzzles/pearl.R
@@ -0,0 +1,23 @@
+# -*- makefile -*-
+
+PEARL_EXTRA    = dsf tree234 grid penrose loopgen tdq
+
+pearl          : [X] GTK COMMON pearl PEARL_EXTRA pearl-icon|no-icon
+pearl          : [G] WINDOWS COMMON pearl PEARL_EXTRA pearl.res?
+
+pearlbench     : [U] pearl[STANDALONE_SOLVER] PEARL_EXTRA STANDALONE m.lib
+pearlbench     : [C] pearl[STANDALONE_SOLVER] PEARL_EXTRA STANDALONE
+
+ALL += pearl[COMBINED] PEARL_EXTRA
+
+!begin am gtk
+GAMES += pearl
+!end
+
+!begin >list.c
+    A(pearl) \
+!end
+
+!begin >gamedesc.txt
+pearl:pearl.exe:Pearl:Loop-drawing puzzle:Draw a single closed loop, given clues about corner and straight squares.
+!end
diff --git a/apps/plugins/puzzles/pearl.c b/apps/plugins/puzzles/pearl.c
new file mode 100644
index 0000000000..59effeda40
--- /dev/null
+++ b/apps/plugins/puzzles/pearl.c
@@ -0,0 +1,2772 @@
+/*
+ * pearl.c: Nikoli's `Masyu' puzzle. 
+ */
+
+/*
+ * TODO:
+ *
+ *  - The current keyboard cursor mechanism works well on ordinary PC
+ *    keyboards, but for platforms with only arrow keys and a select
+ *    button or two, we may at some point need a simpler one which can
+ *    handle 'x' markings without needing shift keys. For instance, a
+ *    cursor with twice the grid resolution, so that it can range
+ *    across face centres, edge centres and vertices; 'clicks' on face
+ *    centres begin a drag as currently, clicks on edges toggle
+ *    markings, and clicks on vertices are ignored (but it would be
+ *    too confusing not to let the cursor rest on them). But I'm
+ *    pretty sure that would be less pleasant to play on a full
+ *    keyboard, so probably a #ifdef would be the thing.
+ *
+ *  - Generation is still pretty slow, due to difficulty coming up in
+ *    the first place with a loop that makes a soluble puzzle even
+ *    with all possible clues filled in.
+ *     + A possible alternative strategy to further tuning of the
+ *       existing loop generator would be to throw the entire
+ *       mechanism out and instead write a different generator from
+ *       scratch which evolves the solution along with the puzzle:
+ *       place a few clues, nail down a bit of the loop, place another
+ *       clue, nail down some more, etc. However, I don't have a
+ *       detailed plan for any such mechanism, so it may be a pipe
+ *       dream.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "grid.h"
+#include "loopgen.h"
+
+#define SWAP(i,j) do { int swaptmp = (i); (i) = (j); (j) = swaptmp; } while (0)
+
+#define NOCLUE 0
+#define CORNER 1
+#define STRAIGHT 2
+
+#define R 1
+#define U 2
+#define L 4
+#define D 8
+
+#define DX(d) ( ((d)==R) - ((d)==L) )
+#define DY(d) ( ((d)==D) - ((d)==U) )
+
+#define F(d) (((d << 2) | (d >> 2)) & 0xF)
+#define C(d) (((d << 3) | (d >> 1)) & 0xF)
+#define A(d) (((d << 1) | (d >> 3)) & 0xF)
+
+#define LR (L | R)
+#define RL (R | L)
+#define UD (U | D)
+#define DU (D | U)
+#define LU (L | U)
+#define UL (U | L)
+#define LD (L | D)
+#define DL (D | L)
+#define RU (R | U)
+#define UR (U | R)
+#define RD (R | D)
+#define DR (D | R)
+#define BLANK 0
+#define UNKNOWN 15
+
+#define bLR (1 << LR)
+#define bRL (1 << RL)
+#define bUD (1 << UD)
+#define bDU (1 << DU)
+#define bLU (1 << LU)
+#define bUL (1 << UL)
+#define bLD (1 << LD)
+#define bDL (1 << DL)
+#define bRU (1 << RU)
+#define bUR (1 << UR)
+#define bRD (1 << RD)
+#define bDR (1 << DR)
+#define bBLANK (1 << BLANK)
+
+enum {
+    COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT,
+    COL_CURSOR_BACKGROUND = COL_LOWLIGHT,
+    COL_BLACK, COL_WHITE,
+    COL_ERROR, COL_GRID, COL_FLASH,
+    COL_DRAGON, COL_DRAGOFF,
+    NCOLOURS
+};
+
+/* Macro ickery copied from slant.c */
+#define DIFFLIST(A) \
+    A(EASY,Easy,e) \
+    A(TRICKY,Tricky,t)
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const pearl_diffnames[] = { DIFFLIST(TITLE) "(count)" };
+static char const pearl_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+struct game_params {
+    int w, h;
+    int difficulty;
+    int nosolve;        /* XXX remove me! */
+};
+
+struct shared_state {
+    int w, h, sz;
+    char *clues;         /* size w*h */
+    int refcnt;
+};
+
+#define INGRID(state, gx, gy) ((gx) >= 0 && (gx) < (state)->shared->w && \
+                               (gy) >= 0 && (gy) < (state)->shared->h)
+struct game_state {
+    struct shared_state *shared;
+    char *lines;        /* size w*h: lines placed */
+    char *errors;       /* size w*h: errors detected */
+    char *marks;        /* size w*h: 'no line here' marks placed. */
+    int completed, used_solve;
+};
+
+#define DEFAULT_PRESET 3
+
+static const struct game_params pearl_presets[] = {
+    {6, 6,      DIFF_EASY},
+    {6, 6,      DIFF_TRICKY},
+    {8, 8,      DIFF_EASY},
+    {8, 8,      DIFF_TRICKY},
+    {10, 10,    DIFF_EASY},
+    {10, 10,    DIFF_TRICKY},
+    {12, 8,     DIFF_EASY},
+    {12, 8,     DIFF_TRICKY},
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    *ret = pearl_presets[DEFAULT_PRESET];
+    ret->nosolve = FALSE;
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[64];
+
+    if (i < 0 || i >= lenof(pearl_presets)) return FALSE;
+
+    ret = default_params();
+    *ret = pearl_presets[i]; /* struct copy */
+    *params = ret;
+
+    sprintf(buf, "%dx%d %s",
+            pearl_presets[i].w, pearl_presets[i].h,
+            pearl_diffnames[pearl_presets[i].difficulty]);
+    *name = dupstr(buf);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    while (*string && isdigit((unsigned char) *string)) ++string;
+    if (*string == 'x') {
+        string++;
+        ret->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+
+    ret->difficulty = DIFF_EASY;
+    if (*string == 'd') {
+        int i;
+        string++;
+        for (i = 0; i < DIFFCOUNT; i++)
+            if (*string == pearl_diffchars[i])
+                ret->difficulty = i;
+        if (*string) string++;
+    }
+
+    ret->nosolve = FALSE;
+    if (*string == 'n') {
+        ret->nosolve = TRUE;
+        string++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[256];
+    sprintf(buf, "%dx%d", params->w, params->h);
+    if (full)
+        sprintf(buf + strlen(buf), "d%c%s",
+                pearl_diffchars[params->difficulty],
+                params->nosolve ? "n" : "");
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[64];
+
+    ret = snewn(5, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Difficulty";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = DIFFCONFIG;
+    ret[2].ival = params->difficulty;
+
+    ret[3].name = "Allow unsoluble";
+    ret[3].type = C_BOOLEAN;
+    ret[3].sval = NULL;
+    ret[3].ival = params->nosolve;
+
+    ret[4].name = NULL;
+    ret[4].type = C_END;
+    ret[4].sval = NULL;
+    ret[4].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->difficulty = cfg[2].ival;
+    ret->nosolve = cfg[3].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 5) return "Width must be at least five";
+    if (params->h < 5) return "Height must be at least five";
+    if (params->difficulty < 0 || params->difficulty >= DIFFCOUNT)
+        return "Unknown difficulty level";
+
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver.
+ */
+
+int pearl_solve(int w, int h, char *clues, char *result,
+                int difficulty, int partial)
+{
+    int W = 2*w+1, H = 2*h+1;
+    short *workspace;
+    int *dsf, *dsfsize;
+    int x, y, b, d;
+    int ret = -1;
+
+    /*
+     * workspace[(2*y+1)*W+(2*x+1)] indicates the possible nature
+     * of the square (x,y), as a logical OR of bitfields.
+     * 
+     * workspace[(2*y)*W+(2*x+1)], for x odd and y even, indicates
+     * whether the horizontal edge between (x,y) and (x+1,y) is
+     * connected (1), disconnected (2) or unknown (3).
+     * 
+     * workspace[(2*y+1)*W+(2*x)], indicates the same about the
+     * vertical edge between (x,y) and (x,y+1).
+     * 
+     * Initially, every square is considered capable of being in
+     * any of the seven possible states (two straights, four
+     * corners and empty), except those corresponding to clue
+     * squares which are more restricted.
+     * 
+     * Initially, all edges are unknown, except the ones around the
+     * grid border which are known to be disconnected.
+     */
+    workspace = snewn(W*H, short);
+    for (x = 0; x < W*H; x++)
+        workspace[x] = 0;
+    /* Square states */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            switch (clues[y*w+x]) {
+              case CORNER:
+                workspace[(2*y+1)*W+(2*x+1)] = bLU|bLD|bRU|bRD;
+                break;
+              case STRAIGHT:
+                workspace[(2*y+1)*W+(2*x+1)] = bLR|bUD;
+                break;
+              default:
+                workspace[(2*y+1)*W+(2*x+1)] = bLR|bUD|bLU|bLD|bRU|bRD|bBLANK;
+                break;
+            }
+    /* Horizontal edges */
+    for (y = 0; y <= h; y++)
+        for (x = 0; x < w; x++)
+            workspace[(2*y)*W+(2*x+1)] = (y==0 || y==h ? 2 : 3);
+    /* Vertical edges */
+    for (y = 0; y < h; y++)
+        for (x = 0; x <= w; x++)
+            workspace[(2*y+1)*W+(2*x)] = (x==0 || x==w ? 2 : 3);
+
+    /*
+     * We maintain a dsf of connected squares, together with a
+     * count of the size of each equivalence class.
+     */
+    dsf = snewn(w*h, int);
+    dsfsize = snewn(w*h, int);
+
+    /*
+     * Now repeatedly try to find something we can do.
+     */
+    while (1) {
+        int done_something = FALSE;
+
+#ifdef SOLVER_DIAGNOSTICS
+        for (y = 0; y < H; y++) {
+            for (x = 0; x < W; x++)
+                printf("%*x", (x&1) ? 5 : 2, workspace[y*W+x]);
+            printf("\n");
+        }
+#endif
+
+        /*
+         * Go through the square state words, and discard any
+         * square state which is inconsistent with known facts
+         * about the edges around the square.
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++) {
+                for (b = 0; b < 0xD; b++)
+                    if (workspace[(2*y+1)*W+(2*x+1)] & (1<<b)) {
+                        /*
+                         * If any edge of this square is known to
+                         * be connected when state b would require
+                         * it disconnected, or vice versa, discard
+                         * the state.
+                         */
+                        for (d = 1; d <= 8; d += d) {
+                            int ex = 2*x+1 + DX(d), ey = 2*y+1 + DY(d);
+                            if (workspace[ey*W+ex] ==
+                                ((b & d) ? 2 : 1)) {
+                                workspace[(2*y+1)*W+(2*x+1)] &= ~(1<<b);
+#ifdef SOLVER_DIAGNOSTICS
+                                printf("edge (%d,%d)-(%d,%d) rules out state"
+                                       " %d for square (%d,%d)\n",
+                                       ex/2, ey/2, (ex+1)/2, (ey+1)/2,
+                                       b, x, y);
+#endif
+                                done_something = TRUE;
+                                break;
+                            }
+                        }
+                    }
+
+                /*
+                 * Consistency check: each square must have at
+                 * least one state left!
+                 */
+                if (!workspace[(2*y+1)*W+(2*x+1)]) {
+#ifdef SOLVER_DIAGNOSTICS
+                    printf("edge check at (%d,%d): inconsistency\n", x, y);
+#endif
+                    ret = 0;
+                    goto cleanup;
+                }
+            }
+
+        /*
+         * Now go through the states array again, and nail down any
+         * unknown edge if one of its neighbouring squares makes it
+         * known.
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++) {
+                int edgeor = 0, edgeand = 15;
+
+                for (b = 0; b < 0xD; b++)
+                    if (workspace[(2*y+1)*W+(2*x+1)] & (1<<b)) {
+                        edgeor |= b;
+                        edgeand &= b;
+                    }
+
+                /*
+                 * Now any bit clear in edgeor marks a disconnected
+                 * edge, and any bit set in edgeand marks a
+                 * connected edge.
+                 */
+
+                /* First check consistency: neither bit is both! */
+                if (edgeand & ~edgeor) {
+#ifdef SOLVER_DIAGNOSTICS
+                    printf("square check at (%d,%d): inconsistency\n", x, y);
+#endif
+                    ret = 0;
+                    goto cleanup;
+                }
+
+                for (d = 1; d <= 8; d += d) {
+                    int ex = 2*x+1 + DX(d), ey = 2*y+1 + DY(d);
+
+                    if (!(edgeor & d) && workspace[ey*W+ex] == 3) {
+                        workspace[ey*W+ex] = 2;
+                        done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                        printf("possible states of square (%d,%d) force edge"
+                               " (%d,%d)-(%d,%d) to be disconnected\n",
+                               x, y, ex/2, ey/2, (ex+1)/2, (ey+1)/2);
+#endif
+                    } else if ((edgeand & d) && workspace[ey*W+ex] == 3) {
+                        workspace[ey*W+ex] = 1;
+                        done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                        printf("possible states of square (%d,%d) force edge"
+                               " (%d,%d)-(%d,%d) to be connected\n",
+                               x, y, ex/2, ey/2, (ex+1)/2, (ey+1)/2);
+#endif
+                    }
+                }
+            }
+
+        if (done_something)
+            continue;
+
+        /*
+         * Now for longer-range clue-based deductions (using the
+         * rules that a corner clue must connect to two straight
+         * squares, and a straight clue must connect to at least
+         * one corner square).
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                switch (clues[y*w+x]) {
+                  case CORNER:
+                    for (d = 1; d <= 8; d += d) {
+                        int ex = 2*x+1 + DX(d), ey = 2*y+1 + DY(d);
+                        int fx = ex + DX(d), fy = ey + DY(d);
+                        int type = d | F(d);
+
+                        if (workspace[ey*W+ex] == 1) {
+                            /*
+                             * If a corner clue is connected on any
+                             * edge, then we can immediately nail
+                             * down the square beyond that edge as
+                             * being a straight in the appropriate
+                             * direction.
+                             */
+                            if (workspace[fy*W+fx] != (1<<type)) {
+                                workspace[fy*W+fx] = (1<<type);
+                                done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                                printf("corner clue at (%d,%d) forces square "
+                                       "(%d,%d) into state %d\n", x, y,
+                                       fx/2, fy/2, type);
+#endif
+                                
+                            }
+                        } else if (workspace[ey*W+ex] == 3) {
+                            /*
+                             * Conversely, if a corner clue is
+                             * separated by an unknown edge from a
+                             * square which _cannot_ be a straight
+                             * in the appropriate direction, we can
+                             * mark that edge as disconnected.
+                             */
+                            if (!(workspace[fy*W+fx] & (1<<type))) {
+                                workspace[ey*W+ex] = 2;
+                                done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                                printf("corner clue at (%d,%d), plus square "
+                                       "(%d,%d) not being state %d, "
+                                       "disconnects edge (%d,%d)-(%d,%d)\n",
+                                       x, y, fx/2, fy/2, type,
+                                       ex/2, ey/2, (ex+1)/2, (ey+1)/2);
+#endif
+
+                            }
+                        }
+                    }
+
+                    break;
+                  case STRAIGHT:
+                    /*
+                     * If a straight clue is between two squares
+                     * neither of which is capable of being a
+                     * corner connected to it, then the straight
+                     * clue cannot point in that direction.
+                     */
+                    for (d = 1; d <= 2; d += d) {
+                        int fx = 2*x+1 + 2*DX(d), fy = 2*y+1 + 2*DY(d);
+                        int gx = 2*x+1 - 2*DX(d), gy = 2*y+1 - 2*DY(d);
+                        int type = d | F(d);
+
+                        if (!(workspace[(2*y+1)*W+(2*x+1)] & (1<<type)))
+                            continue;
+
+                        if (!(workspace[fy*W+fx] & ((1<<(F(d)|A(d))) |
+                                                    (1<<(F(d)|C(d))))) &&
+                            !(workspace[gy*W+gx] & ((1<<(  d |A(d))) |
+                                                    (1<<(  d |C(d)))))) {
+                            workspace[(2*y+1)*W+(2*x+1)] &= ~(1<<type);
+                            done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                            printf("straight clue at (%d,%d) cannot corner at "
+                                   "(%d,%d) or (%d,%d) so is not state %d\n",
+                                   x, y, fx/2, fy/2, gx/2, gy/2, type);
+#endif
+                        }
+                                                    
+                    }
+
+                    /*
+                     * If a straight clue with known direction is
+                     * connected on one side to a known straight,
+                     * then on the other side it must be a corner.
+                     */
+                    for (d = 1; d <= 8; d += d) {
+                        int fx = 2*x+1 + 2*DX(d), fy = 2*y+1 + 2*DY(d);
+                        int gx = 2*x+1 - 2*DX(d), gy = 2*y+1 - 2*DY(d);
+                        int type = d | F(d);
+
+                        if (workspace[(2*y+1)*W+(2*x+1)] != (1<<type))
+                            continue;
+
+                        if (!(workspace[fy*W+fx] &~ (bLR|bUD)) &&
+                            (workspace[gy*W+gx] &~ (bLU|bLD|bRU|bRD))) {
+                            workspace[gy*W+gx] &= (bLU|bLD|bRU|bRD);
+                            done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                            printf("straight clue at (%d,%d) connecting to "
+                                   "straight at (%d,%d) makes (%d,%d) a "
+                                   "corner\n", x, y, fx/2, fy/2, gx/2, gy/2);
+#endif
+                        }
+                                                    
+                    }
+                    break;
+                }
+
+        if (done_something)
+            continue;
+
+        /*
+         * Now detect shortcut loops.
+         */
+
+        {
+            int nonblanks, loopclass;
+
+            dsf_init(dsf, w*h);
+            for (x = 0; x < w*h; x++)
+                dsfsize[x] = 1;
+
+            /*
+             * First go through the edge entries and update the dsf
+             * of which squares are connected to which others. We
+             * also track the number of squares in each equivalence
+             * class, and count the overall number of
+             * known-non-blank squares.
+             *
+             * In the process of doing this, we must notice if a
+             * loop has already been formed. If it has, we blank
+             * out any square which isn't part of that loop
+             * (failing a consistency check if any such square does
+             * not have BLANK as one of its remaining options) and
+             * exit the deduction loop with success.
+             */
+            nonblanks = 0;
+            loopclass = -1;
+            for (y = 1; y < H-1; y++)
+                for (x = 1; x < W-1; x++)
+                    if ((y ^ x) & 1) {
+                        /*
+                         * (x,y) are the workspace coordinates of
+                         * an edge field. Compute the normal-space
+                         * coordinates of the squares it connects.
+                         */
+                        int ax = (x-1)/2, ay = (y-1)/2, ac = ay*w+ax;
+                        int bx = x/2, by = y/2, bc = by*w+bx;
+
+                        /*
+                         * If the edge is connected, do the dsf
+                         * thing.
+                         */
+                        if (workspace[y*W+x] == 1) {
+                            int ae, be;
+
+                            ae = dsf_canonify(dsf, ac);
+                            be = dsf_canonify(dsf, bc);
+
+                            if (ae == be) {
+                                /*
+                                 * We have a loop!
+                                 */
+                                if (loopclass != -1) {
+                                    /*
+                                     * In fact, we have two
+                                     * separate loops, which is
+                                     * doom.
+                                     */
+#ifdef SOLVER_DIAGNOSTICS
+                                    printf("two loops found in grid!\n");
+#endif
+                                    ret = 0;
+                                    goto cleanup;
+                                }
+                                loopclass = ae;
+                            } else {
+                                /*
+                                 * Merge the two equivalence
+                                 * classes.
+                                 */
+                                int size = dsfsize[ae] + dsfsize[be];
+                                dsf_merge(dsf, ac, bc);
+                                ae = dsf_canonify(dsf, ac);
+                                dsfsize[ae] = size;
+                            }
+                        }
+                    } else if ((y & x) & 1) {
+                        /*
+                         * (x,y) are the workspace coordinates of a
+                         * square field. If the square is
+                         * definitely not blank, count it.
+                         */
+                        if (!(workspace[y*W+x] & bBLANK))
+                            nonblanks++;
+                    }
+
+            /*
+             * If we discovered an existing loop above, we must now
+             * blank every square not part of it, and exit the main
+             * deduction loop.
+             */
+            if (loopclass != -1) {
+#ifdef SOLVER_DIAGNOSTICS
+                printf("loop found in grid!\n");
+#endif
+                for (y = 0; y < h; y++)
+                    for (x = 0; x < w; x++)
+                        if (dsf_canonify(dsf, y*w+x) != loopclass) {
+                            if (workspace[(y*2+1)*W+(x*2+1)] & bBLANK) {
+                                workspace[(y*2+1)*W+(x*2+1)] = bBLANK;
+                            } else {
+                                /*
+                                 * This square is not part of the
+                                 * loop, but is known non-blank. We
+                                 * have goofed.
+                                 */
+#ifdef SOLVER_DIAGNOSTICS
+                                printf("non-blank square (%d,%d) found outside"
+                                       " loop!\n", x, y);
+#endif
+                                ret = 0;
+                                goto cleanup;
+                            }
+                        }
+                /*
+                 * And we're done.
+                 */
+                ret = 1;
+                break;
+            }
+
+            /* Further deductions are considered 'tricky'. */
+            if (difficulty == DIFF_EASY) goto done_deductions;
+
+            /*
+             * Now go through the workspace again and mark any edge
+             * which would cause a shortcut loop (i.e. would
+             * connect together two squares in the same equivalence
+             * class, and that equivalence class does not contain
+             * _all_ the known-non-blank squares currently in the
+             * grid) as disconnected. Also, mark any _square state_
+             * which would cause a shortcut loop as disconnected.
+             */
+            for (y = 1; y < H-1; y++)
+                for (x = 1; x < W-1; x++)
+                    if ((y ^ x) & 1) {
+                        /*
+                         * (x,y) are the workspace coordinates of
+                         * an edge field. Compute the normal-space
+                         * coordinates of the squares it connects.
+                         */
+                        int ax = (x-1)/2, ay = (y-1)/2, ac = ay*w+ax;
+                        int bx = x/2, by = y/2, bc = by*w+bx;
+
+                        /*
+                         * If the edge is currently unknown, and
+                         * sits between two squares in the same
+                         * equivalence class, and the size of that
+                         * class is less than nonblanks, then
+                         * connecting this edge would be a shortcut
+                         * loop and so we must not do so.
+                         */
+                        if (workspace[y*W+x] == 3) {
+                            int ae, be;
+
+                            ae = dsf_canonify(dsf, ac);
+                            be = dsf_canonify(dsf, bc);
+
+                            if (ae == be) {
+                                /*
+                                 * We have a loop. Is it a shortcut?
+                                 */
+                                if (dsfsize[ae] < nonblanks) {
+                                    /*
+                                     * Yes! Mark this edge disconnected.
+                                     */
+                                    workspace[y*W+x] = 2;
+                                    done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                                    printf("edge (%d,%d)-(%d,%d) would create"
+                                           " a shortcut loop, hence must be"
+                                           " disconnected\n", x/2, y/2,
+                                           (x+1)/2, (y+1)/2);
+#endif
+                                }
+                            }
+                        }
+                    } else if ((y & x) & 1) {
+                        /*
+                         * (x,y) are the workspace coordinates of a
+                         * square field. Go through its possible
+                         * (non-blank) states and see if any gives
+                         * rise to a shortcut loop.
+                         * 
+                         * This is slightly fiddly, because we have
+                         * to check whether this square is already
+                         * part of the same equivalence class as
+                         * the things it's joining.
+                         */
+                        int ae = dsf_canonify(dsf, (y/2)*w+(x/2));
+
+                        for (b = 2; b < 0xD; b++)
+                            if (workspace[y*W+x] & (1<<b)) {
+                                /*
+                                 * Find the equivalence classes of
+                                 * the two squares this one would
+                                 * connect if it were in this
+                                 * state.
+                                 */
+                                int e = -1;
+
+                                for (d = 1; d <= 8; d += d) if (b & d) {
+                                    int xx = x/2 + DX(d), yy = y/2 + DY(d);
+                                    int ee = dsf_canonify(dsf, yy*w+xx);
+
+                                    if (e == -1)
+                                        ee = e;
+                                    else if (e != ee)
+                                        e = -2;
+                                }
+
+                                if (e >= 0) {
+                                    /*
+                                     * This square state would form
+                                     * a loop on equivalence class
+                                     * e. Measure the size of that
+                                     * loop, and see if it's a
+                                     * shortcut.
+                                     */
+                                    int loopsize = dsfsize[e];
+                                    if (e != ae)
+                                        loopsize++;/* add the square itself */
+                                    if (loopsize < nonblanks) {
+                                        /*
+                                         * It is! Mark this square
+                                         * state invalid.
+                                         */
+                                        workspace[y*W+x] &= ~(1<<b);
+                                        done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                                        printf("square (%d,%d) would create a "
+                                               "shortcut loop in state %d, "
+                                               "hence cannot be\n",
+                                               x/2, y/2, b);
+#endif
+                                    }
+                                }
+                            }
+                    }
+        }
+
+done_deductions:
+
+        if (done_something)
+            continue;
+
+        /*
+         * If we reach here, there is nothing left we can do.
+         * Return 2 for ambiguous puzzle.
+         */
+        ret = 2;
+        break;
+    }
+
+cleanup:
+
+    /*
+     * If ret = 1 then we've successfully achieved a solution. This
+     * means that we expect every square to be nailed down to
+     * exactly one possibility. If this is the case, or if the caller
+     * asked for a partial solution anyway, transcribe those
+     * possibilities into the result array.
+     */
+    if (ret == 1 || partial) {
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                for (b = 0; b < 0xD; b++)
+                    if (workspace[(2*y+1)*W+(2*x+1)] == (1<<b)) {
+                        result[y*w+x] = b;
+                        break;
+                    }
+               if (ret == 1) assert(b < 0xD); /* we should have had a break by now */
+            }
+        }
+    }
+
+    sfree(dsfsize);
+    sfree(dsf);
+    sfree(workspace);
+    assert(ret >= 0);
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Loop generator.
+ */
+
+/*
+ * We use the loop generator code from loopy, hard-coding to a square
+ * grid of the appropriate size. Knowing the grid layout and the tile
+ * size we can shrink that to our small grid and then make our line
+ * layout from the face colour info.
+ *
+ * We provide a bias function to the loop generator which tries to
+ * bias in favour of loops with more scope for Pearl black clues. This
+ * seems to improve the success rate of the puzzle generator, in that
+ * such loops have a better chance of being soluble with all valid
+ * clues put in.
+ */
+
+struct pearl_loopgen_bias_ctx {
+    /*
+     * Our bias function counts the number of 'black clue' corners
+     * (i.e. corners adjacent to two straights) in both the
+     * BLACK/nonBLACK and WHITE/nonWHITE boundaries. In order to do
+     * this, we must:
+     *
+     *  - track the edges that are part of each of those loops
+     *  - track the types of vertex in each loop (corner, straight,
+     *    none)
+     *  - track the current black-clue status of each vertex in each
+     *    loop.
+     *
+     * Each of these chunks of data is updated incrementally from the
+     * previous one, to avoid slowdown due to the bias function
+     * rescanning the whole grid every time it's called.
+     *
+     * So we need a lot of separate arrays, plus a tdq for each one,
+     * and we must repeat it all twice for the BLACK and WHITE
+     * boundaries.
+     */
+    struct pearl_loopgen_bias_ctx_boundary {
+        int colour;                    /* FACE_WHITE or FACE_BLACK */
+
+        char *edges;                   /* is each edge part of the loop? */
+        tdq *edges_todo;
+
+        char *vertextypes;             /* bits 0-3 == outgoing edge bitmap;
+                                        * bit 4 set iff corner clue.
+                                        * Hence, 0 means non-vertex;
+                                        * nonzero but bit 4 zero = straight. */
+        int *neighbour[2];          /* indices of neighbour vertices in loop */
+        tdq *vertextypes_todo;
+
+        char *blackclues;              /* is each vertex a black clue site? */
+        tdq *blackclues_todo;
+    } boundaries[2];                   /* boundaries[0]=WHITE, [1]=BLACK */
+
+    char *faces;          /* remember last-seen colour of each face */
+    tdq *faces_todo;
+
+    int score;
+
+    grid *g;
+};
+int pearl_loopgen_bias(void *vctx, char *board, int face)
+{
+    struct pearl_loopgen_bias_ctx *ctx = (struct pearl_loopgen_bias_ctx *)vctx;
+    grid *g = ctx->g;
+    int oldface, newface;
+    int i, j, k;
+
+    tdq_add(ctx->faces_todo, face);
+    while ((j = tdq_remove(ctx->faces_todo)) >= 0) {
+        oldface = ctx->faces[j];
+        ctx->faces[j] = newface = board[j];
+        for (i = 0; i < 2; i++) {
+            struct pearl_loopgen_bias_ctx_boundary *b = &ctx->boundaries[i];
+            int c = b->colour;
+
+            /*
+             * If the face has changed either from or to colour c, we need
+             * to reprocess the edges for this boundary.
+             */
+            if (oldface == c || newface == c) {
+                grid_face *f = &g->faces[face];
+                for (k = 0; k < f->order; k++)
+                    tdq_add(b->edges_todo, f->edges[k] - g->edges);
+            }
+        }
+    }
+
+    for (i = 0; i < 2; i++) {
+        struct pearl_loopgen_bias_ctx_boundary *b = &ctx->boundaries[i];
+        int c = b->colour;
+
+        /*
+         * Go through the to-do list of edges. For each edge, decide
+         * anew whether it's part of this boundary or not. Any edge
+         * that changes state has to have both its endpoints put on
+         * the vertextypes_todo list.
+         */
+        while ((j = tdq_remove(b->edges_todo)) >= 0) {
+            grid_edge *e = &g->edges[j];
+            int fc1 = e->face1 ? board[e->face1 - g->faces] : FACE_BLACK;
+            int fc2 = e->face2 ? board[e->face2 - g->faces] : FACE_BLACK;
+            int oldedge = b->edges[j];
+            int newedge = (fc1==c) ^ (fc2==c);
+            if (oldedge != newedge) {
+                b->edges[j] = newedge;
+                tdq_add(b->vertextypes_todo, e->dot1 - g->dots);
+                tdq_add(b->vertextypes_todo, e->dot2 - g->dots);
+            }
+        }
+
+        /*
+         * Go through the to-do list of vertices whose types need
+         * refreshing. For each one, decide whether it's a corner, a
+         * straight, or a vertex not in the loop, and in the former
+         * two cases also work out the indices of its neighbour
+         * vertices along the loop. Any vertex that changes state must
+         * be put back on the to-do list for deciding if it's a black
+         * clue site, and so must its two new neighbours _and_ its two
+         * old neighbours.
+         */
+        while ((j = tdq_remove(b->vertextypes_todo)) >= 0) {
+            grid_dot *d = &g->dots[j];
+            int neighbours[2], type = 0, n = 0;
+            
+            for (k = 0; k < d->order; k++) {
+                grid_edge *e = d->edges[k];
+                grid_dot *d2 = (e->dot1 == d ? e->dot2 : e->dot1);
+                /* dir == 0,1,2,3 for an edge going L,U,R,D */
+                int dir = (d->y == d2->y) + 2*(d->x+d->y > d2->x+d2->y);
+                int ei = e - g->edges;
+                if (b->edges[ei]) {
+                    type |= 1 << dir;
+                    neighbours[n] = d2 - g->dots; 
+                    n++;
+                }
+            }
+
+            /*
+             * Decide if it's a corner, and set the corner flag if so.
+             */
+            if (type != 0 && type != 0x5 && type != 0xA)
+                type |= 0x10;
+
+            if (type != b->vertextypes[j]) {
+                /*
+                 * Recompute old neighbours, if any.
+                 */
+                if (b->vertextypes[j]) {
+                    tdq_add(b->blackclues_todo, b->neighbour[0][j]);
+                    tdq_add(b->blackclues_todo, b->neighbour[1][j]);
+                }
+                /*
+                 * Recompute this vertex.
+                 */
+                tdq_add(b->blackclues_todo, j);
+                b->vertextypes[j] = type;
+                /*
+                 * Recompute new neighbours, if any.
+                 */
+                if (b->vertextypes[j]) {
+                    b->neighbour[0][j] = neighbours[0];
+                    b->neighbour[1][j] = neighbours[1];
+                    tdq_add(b->blackclues_todo, b->neighbour[0][j]);
+                    tdq_add(b->blackclues_todo, b->neighbour[1][j]);
+                }
+            }
+        }
+
+        /*
+         * Go through the list of vertices which we must check to see
+         * if they're black clue sites. Each one is a black clue site
+         * iff it is a corner and its loop neighbours are non-corners.
+         * Adjust the running total of black clues we've counted.
+         */
+        while ((j = tdq_remove(b->blackclues_todo)) >= 0) {
+            ctx->score -= b->blackclues[j];
+            b->blackclues[j] = ((b->vertextypes[j] & 0x10) &&
+                                !((b->vertextypes[b->neighbour[0][j]] |
+                                   b->vertextypes[b->neighbour[1][j]])
+                                  & 0x10));
+            ctx->score += b->blackclues[j];
+        }
+    }
+
+    return ctx->score;
+}
+
+void pearl_loopgen(int w, int h, char *lines, random_state *rs)
+{
+    grid *g = grid_new(GRID_SQUARE, w-1, h-1, NULL);
+    char *board = snewn(g->num_faces, char);
+    int i, s = g->tilesize;
+    struct pearl_loopgen_bias_ctx biasctx;
+
+    memset(lines, 0, w*h);
+
+    /*
+     * Initialise the context for the bias function. Initially we fill
+     * all the to-do lists, so that the first call will scan
+     * everything; thereafter the lists stay empty so we make
+     * incremental changes.
+     */
+    biasctx.g = g;
+    biasctx.faces = snewn(g->num_faces, char);
+    biasctx.faces_todo = tdq_new(g->num_faces);
+    tdq_fill(biasctx.faces_todo);
+    biasctx.score = 0;
+    memset(biasctx.faces, FACE_GREY, g->num_faces);
+    for (i = 0; i < 2; i++) {
+        biasctx.boundaries[i].edges = snewn(g->num_edges, char);
+        memset(biasctx.boundaries[i].edges, 0, g->num_edges);
+        biasctx.boundaries[i].edges_todo = tdq_new(g->num_edges);
+        tdq_fill(biasctx.boundaries[i].edges_todo);
+        biasctx.boundaries[i].vertextypes = snewn(g->num_dots, char);
+        memset(biasctx.boundaries[i].vertextypes, 0, g->num_dots);
+        biasctx.boundaries[i].neighbour[0] = snewn(g->num_dots, int);
+        biasctx.boundaries[i].neighbour[1] = snewn(g->num_dots, int);
+        biasctx.boundaries[i].vertextypes_todo = tdq_new(g->num_dots);
+        tdq_fill(biasctx.boundaries[i].vertextypes_todo);
+        biasctx.boundaries[i].blackclues = snewn(g->num_dots, char);
+        memset(biasctx.boundaries[i].blackclues, 0, g->num_dots);
+        biasctx.boundaries[i].blackclues_todo = tdq_new(g->num_dots);
+        tdq_fill(biasctx.boundaries[i].blackclues_todo);
+    }
+    biasctx.boundaries[0].colour = FACE_WHITE;
+    biasctx.boundaries[1].colour = FACE_BLACK;
+    generate_loop(g, board, rs, pearl_loopgen_bias, &biasctx);
+    sfree(biasctx.faces);
+    tdq_free(biasctx.faces_todo);
+    for (i = 0; i < 2; i++) {
+        sfree(biasctx.boundaries[i].edges);
+        tdq_free(biasctx.boundaries[i].edges_todo);
+        sfree(biasctx.boundaries[i].vertextypes);
+        sfree(biasctx.boundaries[i].neighbour[0]);
+        sfree(biasctx.boundaries[i].neighbour[1]);
+        tdq_free(biasctx.boundaries[i].vertextypes_todo);
+        sfree(biasctx.boundaries[i].blackclues);
+        tdq_free(biasctx.boundaries[i].blackclues_todo);
+    }
+
+    for (i = 0; i < g->num_edges; i++) {
+        grid_edge *e = g->edges + i;
+        enum face_colour c1 = FACE_COLOUR(e->face1);
+        enum face_colour c2 = FACE_COLOUR(e->face2);
+        assert(c1 != FACE_GREY);
+        assert(c2 != FACE_GREY);
+        if (c1 != c2) {
+            /* This grid edge is on the loop: lay line along it */
+            int x1 = e->dot1->x/s, y1 = e->dot1->y/s;
+            int x2 = e->dot2->x/s, y2 = e->dot2->y/s;
+
+            /* (x1,y1) and (x2,y2) are now in our grid coords (0-w,0-h). */
+            if (x1 == x2) {
+                if (y1 > y2) SWAP(y1,y2);
+
+                assert(y1+1 == y2);
+                lines[y1*w+x1] |= D;
+                lines[y2*w+x1] |= U;
+            } else if (y1 == y2) {
+                if (x1 > x2) SWAP(x1,x2);
+
+                assert(x1+1 == x2);
+                lines[y1*w+x1] |= R;
+                lines[y1*w+x2] |= L;
+            } else
+                assert(!"grid with diagonal coords?!");
+        }
+    }
+
+    grid_free(g);
+    sfree(board);
+
+#if defined LOOPGEN_DIAGNOSTICS && !defined GENERATION_DIAGNOSTICS
+    printf("as returned:\n");
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            int type = lines[y*w+x];
+            char s[5], *p = s;
+            if (type & L) *p++ = 'L';
+            if (type & R) *p++ = 'R';
+            if (type & U) *p++ = 'U';
+            if (type & D) *p++ = 'D';
+            *p = '\0';
+            printf("%3s", s);
+        }
+        printf("\n");
+    }
+    printf("\n");
+#endif
+}
+
+static int new_clues(const game_params *params, random_state *rs,
+                     char *clues, char *grid)
+{
+    int w = params->w, h = params->h, diff = params->difficulty;
+    int ngen = 0, x, y, d, ret, i;
+
+
+    /*
+     * Difficulty exception: 5x5 Tricky is not generable (the
+     * generator will spin forever trying) and so we fudge it to Easy.
+     */
+    if (w == 5 && h == 5 && diff > DIFF_EASY)
+        diff = DIFF_EASY;
+
+    while (1) {
+        ngen++;
+        pearl_loopgen(w, h, grid, rs);
+
+#ifdef GENERATION_DIAGNOSTICS
+        printf("grid array:\n");
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                int type = grid[y*w+x];
+                char s[5], *p = s;
+                if (type & L) *p++ = 'L';
+                if (type & R) *p++ = 'R';
+                if (type & U) *p++ = 'U';
+                if (type & D) *p++ = 'D';
+                *p = '\0';
+                printf("%2s ", s);
+            }
+            printf("\n");
+        }
+        printf("\n");
+#endif
+
+        /*
+         * Set up the maximal clue array.
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++) {
+                int type = grid[y*w+x];
+
+                clues[y*w+x] = NOCLUE;
+
+                if ((bLR|bUD) & (1 << type)) {
+                    /*
+                     * This is a straight; see if it's a viable
+                     * candidate for a straight clue. It qualifies if
+                     * at least one of the squares it connects to is a
+                     * corner.
+                     */
+                    for (d = 1; d <= 8; d += d) if (type & d) {
+                        int xx = x + DX(d), yy = y + DY(d);
+                        assert(xx >= 0 && xx < w && yy >= 0 && yy < h);
+                        if ((bLU|bLD|bRU|bRD) & (1 << grid[yy*w+xx]))
+                            break;
+                    }
+                    if (d <= 8)        /* we found one */
+                        clues[y*w+x] = STRAIGHT;
+                } else if ((bLU|bLD|bRU|bRD) & (1 << type)) {
+                    /*
+                     * This is a corner; see if it's a viable candidate
+                     * for a corner clue. It qualifies if all the
+                     * squares it connects to are straights.
+                     */
+                    for (d = 1; d <= 8; d += d) if (type & d) {
+                        int xx = x + DX(d), yy = y + DY(d);
+                        assert(xx >= 0 && xx < w && yy >= 0 && yy < h);
+                        if (!((bLR|bUD) & (1 << grid[yy*w+xx])))
+                            break;
+                    }
+                    if (d > 8)         /* we didn't find a counterexample */
+                        clues[y*w+x] = CORNER;
+                }
+            }
+
+#ifdef GENERATION_DIAGNOSTICS
+        printf("clue array:\n");
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                printf("%c", " *O"[(unsigned char)clues[y*w+x]]);
+            }
+            printf("\n");
+        }
+        printf("\n");
+#endif
+
+        if (!params->nosolve) {
+            int *cluespace, *straights, *corners;
+            int nstraights, ncorners, nstraightpos, ncornerpos;
+
+            /*
+             * See if we can solve the puzzle just like this.
+             */
+            ret = pearl_solve(w, h, clues, grid, diff, FALSE);
+            assert(ret > 0);           /* shouldn't be inconsistent! */
+            if (ret != 1)
+                continue;                      /* go round and try again */
+
+            /*
+             * Check this puzzle isn't too easy.
+             */
+            if (diff > DIFF_EASY) {
+                ret = pearl_solve(w, h, clues, grid, diff-1, FALSE);
+                assert(ret > 0);
+                if (ret == 1)
+                    continue; /* too easy: try again */
+            }
+
+            /*
+             * Now shuffle the grid points and gradually remove the
+             * clues to find a minimal set which still leaves the
+             * puzzle soluble.
+             *
+             * We preferentially attempt to remove whichever type of
+             * clue is currently most numerous, to combat a general
+             * tendency of plain random generation to bias in favour
+             * of many white clues and few black.
+             *
+             * 'nstraights' and 'ncorners' count the number of clues
+             * of each type currently remaining in the grid;
+             * 'nstraightpos' and 'ncornerpos' count the clues of each
+             * type we have left to try to remove. (Clues which we
+             * have tried and failed to remove are counted by the
+             * former but not the latter.)
+             */
+            cluespace = snewn(w*h, int);
+            straights = cluespace;
+            nstraightpos = 0;
+            for (i = 0; i < w*h; i++)
+                if (clues[i] == STRAIGHT)
+                    straights[nstraightpos++] = i;
+            corners = straights + nstraightpos;
+            ncornerpos = 0;
+            for (i = 0; i < w*h; i++)
+                if (clues[i] == STRAIGHT)
+                    corners[ncornerpos++] = i;
+            nstraights = nstraightpos;
+            ncorners = ncornerpos;
+
+            shuffle(straights, nstraightpos, sizeof(*straights), rs);
+            shuffle(corners, ncornerpos, sizeof(*corners), rs);
+            while (nstraightpos > 0 || ncornerpos > 0) {
+                int cluepos;
+                int clue;
+
+                /*
+                 * Decide which clue to try to remove next. If both
+                 * types are available, we choose whichever kind is
+                 * currently overrepresented; otherwise we take
+                 * whatever we can get.
+                 */
+                if (nstraightpos > 0 && ncornerpos > 0) {
+                    if (nstraights >= ncorners)
+                        cluepos = straights[--nstraightpos];
+                    else
+                        cluepos = straights[--ncornerpos];
+                } else {
+                    if (nstraightpos > 0)
+                        cluepos = straights[--nstraightpos];
+                    else
+                        cluepos = straights[--ncornerpos];
+                }
+
+                y = cluepos / w;
+                x = cluepos % w;
+
+                clue = clues[y*w+x];
+                clues[y*w+x] = 0;              /* try removing this clue */
+
+                ret = pearl_solve(w, h, clues, grid, diff, FALSE);
+                assert(ret > 0);
+                if (ret != 1)
+                    clues[y*w+x] = clue;   /* oops, put it back again */
+            }
+            sfree(cluespace);
+        }
+
+#ifdef FINISHED_PUZZLE
+        printf("clue array:\n");
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                printf("%c", " *O"[(unsigned char)clues[y*w+x]]);
+            }
+            printf("\n");
+        }
+        printf("\n");
+#endif
+
+        break;                         /* got it */
+    }
+
+    debug(("%d %dx%d loops before finished puzzle.\n", ngen, w, h));
+
+    return ngen;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    char *grid, *clues;
+    char *desc;
+    int w = params->w, h = params->h, i, j;
+
+    grid = snewn(w*h, char);
+    clues = snewn(w*h, char);
+
+    new_clues(params, rs, clues, grid);
+
+    desc = snewn(w * h + 1, char);
+    for (i = j = 0; i < w*h; i++) {
+        if (clues[i] == NOCLUE && j > 0 &&
+            desc[j-1] >= 'a' && desc[j-1] < 'z')
+            desc[j-1]++;
+        else if (clues[i] == NOCLUE)
+            desc[j++] = 'a';
+        else if (clues[i] == CORNER)
+            desc[j++] = 'B';
+        else if (clues[i] == STRAIGHT)
+            desc[j++] = 'W';
+    }
+    desc[j] = '\0';
+
+    *aux = snewn(w*h+1, char);
+    for (i = 0; i < w*h; i++)
+        (*aux)[i] = (grid[i] < 10) ? (grid[i] + '0') : (grid[i] + 'A' - 10);
+    (*aux)[w*h] = '\0';
+
+    sfree(grid);
+    sfree(clues);
+
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int i, sizesofar;
+    const int totalsize = params->w * params->h;
+
+    sizesofar = 0;
+    for (i = 0; desc[i]; i++) {
+        if (desc[i] >= 'a' && desc[i] <= 'z')
+            sizesofar += desc[i] - 'a' + 1;
+        else if (desc[i] == 'B' || desc[i] == 'W')
+            sizesofar++;
+        else
+            return "unrecognised character in string";
+    }
+
+    if (sizesofar > totalsize)
+        return "string too long";
+    else if (sizesofar < totalsize)
+        return "string too short";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    int i, j, sz = params->w*params->h;
+
+    state->completed = state->used_solve = FALSE;
+    state->shared = snew(struct shared_state);
+
+    state->shared->w = params->w;
+    state->shared->h = params->h;
+    state->shared->sz = sz;
+    state->shared->refcnt = 1;
+    state->shared->clues = snewn(sz, char);
+    for (i = j = 0; desc[i]; i++) {
+        assert(j < sz);
+        if (desc[i] >= 'a' && desc[i] <= 'z') {
+            int n = desc[i] - 'a' + 1;
+            assert(j + n <= sz);
+            while (n-- > 0)
+                state->shared->clues[j++] = NOCLUE;
+        } else if (desc[i] == 'B') {
+            state->shared->clues[j++] = CORNER;
+        } else if (desc[i] == 'W') {
+            state->shared->clues[j++] = STRAIGHT;
+        }
+    }
+
+    state->lines = snewn(sz, char);
+    state->errors = snewn(sz, char);
+    state->marks = snewn(sz, char);
+    for (i = 0; i < sz; i++)
+        state->lines[i] = state->errors[i] = state->marks[i] = BLANK;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+    int sz = state->shared->sz, i;
+
+    ret->shared = state->shared;
+    ret->completed = state->completed;
+    ret->used_solve = state->used_solve;
+    ++ret->shared->refcnt;
+
+    ret->lines = snewn(sz, char);
+    ret->errors = snewn(sz, char);
+    ret->marks = snewn(sz, char);
+    for (i = 0; i < sz; i++) {
+        ret->lines[i] = state->lines[i];
+        ret->errors[i] = state->errors[i];
+        ret->marks[i] = state->marks[i];
+    }
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    assert(state);
+    if (--state->shared->refcnt == 0) {
+        sfree(state->shared->clues);
+        sfree(state->shared);
+    }
+    sfree(state->lines);
+    sfree(state->errors);
+    sfree(state->marks);
+    sfree(state);
+}
+
+static char nbits[16] = { 0, 1, 1, 2,
+                          1, 2, 2, 3,
+                          1, 2, 2, 3,
+                          2, 3, 3, 4 };
+#define NBITS(l) ( ((l) < 0 || (l) > 15) ? 4 : nbits[l] )
+
+#define ERROR_CLUE 16
+
+static void dsf_update_completion(game_state *state, int ax, int ay, char dir,
+                                 int *dsf)
+{
+    int w = state->shared->w /*, h = state->shared->h */;
+    int ac = ay*w+ax, bx, by, bc;
+
+    if (!(state->lines[ac] & dir)) return; /* no link */
+    bx = ax + DX(dir); by = ay + DY(dir);
+
+    assert(INGRID(state, bx, by)); /* should not have a link off grid */
+
+    bc = by*w+bx;
+    assert(state->lines[bc] & F(dir)); /* should have reciprocal link */
+    if (!(state->lines[bc] & F(dir))) return;
+
+    dsf_merge(dsf, ac, bc);
+}
+
+static void check_completion(game_state *state, int mark)
+{
+    int w = state->shared->w, h = state->shared->h, x, y, i, d;
+    int had_error = FALSE;
+    int *dsf, *component_state;
+    int nsilly, nloop, npath, largest_comp, largest_size, total_pathsize;
+    enum { COMP_NONE, COMP_LOOP, COMP_PATH, COMP_SILLY, COMP_EMPTY };
+
+    if (mark) {
+        for (i = 0; i < w*h; i++) {
+            state->errors[i] = 0;
+        }
+    }
+
+#define ERROR(x,y,e) do { had_error = TRUE; if (mark) state->errors[(y)*w+(x)] |= (e); } while(0)
+
+    /*
+     * Analyse the solution into loops, paths and stranger things.
+     * Basic strategy here is all the same as in Loopy - see the big
+     * comment in loopy.c's check_completion() - and for exactly the
+     * same reasons, since Loopy and Pearl have basically the same
+     * form of expected solution.
+     */
+    dsf = snew_dsf(w*h);
+
+    /* Build the dsf. */
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            dsf_update_completion(state, x, y, R, dsf);
+            dsf_update_completion(state, x, y, D, dsf);
+        }
+    }
+
+    /* Initialise a state variable for each connected component. */
+    component_state = snewn(w*h, int);
+    for (i = 0; i < w*h; i++) {
+        if (dsf_canonify(dsf, i) == i)
+            component_state[i] = COMP_LOOP;
+        else
+            component_state[i] = COMP_NONE;
+    }
+
+    /*
+     * Classify components, and mark errors where a square has more
+     * than two line segments.
+     */
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            int type = state->lines[y*w+x];
+            int degree = NBITS(type);
+            int comp = dsf_canonify(dsf, y*w+x);
+            if (degree > 2) {
+                ERROR(x,y,type);
+                component_state[comp] = COMP_SILLY;
+            } else if (degree == 0) {
+                component_state[comp] = COMP_EMPTY;
+            } else if (degree == 1) {
+                if (component_state[comp] != COMP_SILLY)
+                    component_state[comp] = COMP_PATH;
+            }
+        }
+    }
+
+    /* Count the components, and find the largest sensible one. */
+    nsilly = nloop = npath = 0;
+    total_pathsize = 0;
+    largest_comp = largest_size = -1;
+    for (i = 0; i < w*h; i++) {
+        if (component_state[i] == COMP_SILLY) {
+            nsilly++;
+        } else if (component_state[i] == COMP_PATH) {
+            total_pathsize += dsf_size(dsf, i);
+            npath = 1;
+        } else if (component_state[i] == COMP_LOOP) {
+            int this_size;
+
+            nloop++;
+
+            if ((this_size = dsf_size(dsf, i)) > largest_size) {
+                largest_comp = i;
+                largest_size = this_size;
+            }
+        }
+    }
+    if (largest_size < total_pathsize) {
+        largest_comp = -1;             /* means the paths */
+        largest_size = total_pathsize;
+    }
+
+    if (nloop > 0 && nloop + npath > 1) {
+        /*
+         * If there are at least two sensible components including at
+         * least one loop, highlight every sensible component that is
+         * not the largest one.
+         */
+        for (i = 0; i < w*h; i++) {
+            int comp = dsf_canonify(dsf, i);
+            if (component_state[comp] == COMP_PATH)
+                comp = -1; /* part of the 'all paths' quasi-component */
+            if ((component_state[comp] == COMP_PATH &&
+                 -1 != largest_comp) ||
+                (component_state[comp] == COMP_LOOP &&
+                 comp != largest_comp))
+                ERROR(i%w, i/w, state->lines[i]);
+        }
+    }
+
+    /* Now we've finished with the dsf and component states. The only
+     * thing we'll need to remember later on is whether all edges were
+     * part of a single loop, for which our counter variables
+     * nsilly,nloop,npath are enough. */
+    sfree(component_state);
+    sfree(dsf);
+
+    /*
+     * Check that no clues are contradicted. This code is similar to
+     * the code that sets up the maximal clue array for any given
+     * loop.
+     */
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            int type = state->lines[y*w+x];
+            if (state->shared->clues[y*w+x] == CORNER) {
+                /* Supposed to be a corner: will find a contradiction if
+                 * it actually contains a straight line, or if it touches any
+                 * corners. */
+                if ((bLR|bUD) & (1 << type)) {
+                    ERROR(x,y,ERROR_CLUE); /* actually straight */
+                }
+                for (d = 1; d <= 8; d += d) if (type & d) {
+                    int xx = x + DX(d), yy = y + DY(d);
+                    if (!INGRID(state, xx, yy)) {
+                        ERROR(x,y,d); /* leads off grid */
+                    } else {
+                        if ((bLU|bLD|bRU|bRD) & (1 << state->lines[yy*w+xx])) {
+                            ERROR(x,y,ERROR_CLUE); /* touches corner */
+                        }
+                    }
+                }
+            } else if (state->shared->clues[y*w+x] == STRAIGHT) {
+                /* Supposed to be straight: will find a contradiction if
+                 * it actually contains a corner, or if it only touches
+                 * straight lines. */
+                if ((bLU|bLD|bRU|bRD) & (1 << type)) {
+                    ERROR(x,y,ERROR_CLUE); /* actually a corner */
+                }
+                i = 0;
+                for (d = 1; d <= 8; d += d) if (type & d) {
+                    int xx = x + DX(d), yy = y + DY(d);
+                    if (!INGRID(state, xx, yy)) {
+                        ERROR(x,y,d); /* leads off grid */
+                    } else {
+                        if ((bLR|bUD) & (1 << state->lines[yy*w+xx]))
+                            i++; /* a straight */
+                    }
+                }
+                if (i >= 2 && NBITS(type) >= 2) {
+                    ERROR(x,y,ERROR_CLUE); /* everything touched is straight */
+                }
+            }
+        }
+    }
+
+    if (nloop == 1 && nsilly == 0 && npath == 0) {
+        /*
+         * If there's exactly one loop (so that the puzzle is at least
+         * potentially complete), we need to ensure it hasn't left any
+         * clue out completely.
+         */
+        for (x = 0; x < w; x++) {
+            for (y = 0; y < h; y++) {
+                if (state->lines[y*w+x] == BLANK) {
+                    if (state->shared->clues[y*w+x] != NOCLUE) {
+                        /* the loop doesn't include this clue square! */
+                        ERROR(x, y, ERROR_CLUE);
+                    }
+                }
+            }
+        }
+
+        /*
+         * But if not, then we're done!
+         */
+        if (!had_error)
+            state->completed = TRUE;
+    }
+}
+
+/* completion check:
+ *
+ * - no clues must be contradicted (highlight clue itself in error if so)
+ * - if there is a closed loop it must include every line segment laid
+ *    - if there's a smaller closed loop then highlight whole loop as error
+ * - no square must have more than 2 lines radiating from centre point
+ *   (highlight all lines in that square as error if so)
+ */
+
+static char *solve_for_diff(game_state *state, char *old_lines, char *new_lines)
+{
+    int w = state->shared->w, h = state->shared->h, i;
+    char *move = snewn(w*h*40, char), *p = move;
+
+    *p++ = 'S';
+    for (i = 0; i < w*h; i++) {
+        if (old_lines[i] != new_lines[i]) {
+            p += sprintf(p, ";R%d,%d,%d", new_lines[i], i%w, i/w);
+        }
+    }
+    *p++ = '\0';
+    move = sresize(move, p - move, char);
+
+    return move;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    game_state *solved = dup_game(state);
+    int i, ret, sz = state->shared->sz;
+    char *move;
+
+    if (aux) {
+        for (i = 0; i < sz; i++) {
+            if (aux[i] >= '0' && aux[i] <= '9')
+                solved->lines[i] = aux[i] - '0';
+            else if (aux[i] >= 'A' && aux[i] <= 'F')
+                solved->lines[i] = aux[i] - 'A' + 10;
+            else {
+                *error = "invalid char in aux";
+                move = NULL;
+                goto done;
+            }
+        }
+        ret = 1;
+    } else {
+        /* Try to solve with present (half-solved) state first: if there's no
+         * solution from there go back to original state. */
+        ret = pearl_solve(currstate->shared->w, currstate->shared->h,
+                          currstate->shared->clues, solved->lines,
+                          DIFFCOUNT, FALSE);
+        if (ret < 1)
+            ret = pearl_solve(state->shared->w, state->shared->h,
+                              state->shared->clues, solved->lines,
+                              DIFFCOUNT, FALSE);
+
+    }
+
+    if (ret < 1) {
+        *error = "Unable to find solution";
+        move = NULL;
+    } else {
+        move = solve_for_diff(solved, currstate->lines, solved->lines);
+    }
+
+done:
+    free_game(solved);
+    return move;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->shared->w, h = state->shared->h, cw = 4, ch = 2;
+    int gw = cw*(w-1) + 2, gh = ch*(h-1) + 1, len = gw * gh, r, c, j;
+    char *board = snewn(len + 1, char);
+
+    assert(board);
+    memset(board, ' ', len);
+
+    for (r = 0; r < h; ++r) {
+        for (c = 0; c < w; ++c) {
+            int i = r*w + c, cell = r*ch*gw + c*cw;
+            board[cell] = "+BW"[(unsigned char)state->shared->clues[i]];
+            if (c < w - 1 && (state->lines[i] & R || state->lines[i+1] & L))
+                memset(board + cell + 1, '-', cw - 1);
+            if (r < h - 1 && (state->lines[i] & D || state->lines[i+w] & U))
+                for (j = 1; j < ch; ++j) board[cell + j*gw] = '|';
+            if (c < w - 1 && (state->marks[i] & R || state->marks[i+1] & L))
+                board[cell + cw/2] = 'x';
+            if (r < h - 1 && (state->marks[i] & D || state->marks[i+w] & U))
+                board[cell + (ch/2 * gw)] = 'x';
+        }
+
+        for (j = 0; j < (r == h - 1 ? 1 : ch); ++j)
+            board[r*ch*gw + (gw - 1) + j*gw] = '\n';
+    }
+
+    board[len] = '\0';
+    return board;
+}
+
+struct game_ui {
+    int *dragcoords;       /* list of (y*w+x) coords in drag so far */
+    int ndragcoords;       /* number of entries in dragcoords.
+                            * 0 = click but no drag yet. -1 = no drag at all */
+    int clickx, clicky;    /* pixel position of initial click */
+
+    int curx, cury;        /* grid position of keyboard cursor */
+    int cursor_active;     /* TRUE iff cursor is shown */
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    int sz = state->shared->sz;
+
+    ui->ndragcoords = -1;
+    ui->dragcoords = snewn(sz, int);
+    ui->cursor_active = FALSE;
+    ui->curx = ui->cury = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui->dragcoords);
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+#define PREFERRED_TILE_SIZE 31
+#define HALFSZ (ds->halfsz)
+#define TILE_SIZE (ds->halfsz*2 + 1)
+
+#define BORDER ((get_gui_style() == GUI_LOOPY) ? (TILE_SIZE/8) : (TILE_SIZE/2))
+
+#define BORDER_WIDTH (max(TILE_SIZE / 32, 1))
+
+#define COORD(x) ( (x) * TILE_SIZE + BORDER )
+#define CENTERED_COORD(x) ( COORD(x) + TILE_SIZE/2 )
+#define FROMCOORD(x) ( ((x) < BORDER) ? -1 : ( ((x) - BORDER) / TILE_SIZE) )
+
+#define DS_ESHIFT 4     /* R/U/L/D shift, for error flags */
+#define DS_DSHIFT 8     /* R/U/L/D shift, for drag-in-progress flags */
+#define DS_MSHIFT 12    /* shift for no-line mark */
+
+#define DS_ERROR_CLUE (1 << 20)
+#define DS_FLASH (1 << 21)
+#define DS_CURSOR (1 << 22)
+
+enum { GUI_MASYU, GUI_LOOPY };
+
+static int get_gui_style(void)
+{
+    static int gui_style = -1;
+
+    if (gui_style == -1) {
+        char *env = getenv("PEARL_GUI_LOOPY");
+        if (env && (env[0] == 'y' || env[0] == 'Y'))
+            gui_style = GUI_LOOPY;
+        else
+            gui_style = GUI_MASYU;
+    }
+    return gui_style;
+}
+
+struct game_drawstate {
+    int halfsz;
+    int started;
+
+    int w, h, sz;
+    unsigned int *lflags;       /* size w*h */
+
+    char *draglines;            /* size w*h; lines flipped by current drag */
+};
+
+static void update_ui_drag(const game_state *state, game_ui *ui,
+                           int gx, int gy)
+{
+    int /* sz = state->shared->sz, */ w = state->shared->w;
+    int i, ox, oy, pos;
+    int lastpos;
+
+    if (!INGRID(state, gx, gy))
+        return;                        /* square is outside grid */
+
+    if (ui->ndragcoords < 0)
+        return;                        /* drag not in progress anyway */
+
+    pos = gy * w + gx;
+
+    lastpos = ui->dragcoords[ui->ndragcoords > 0 ? ui->ndragcoords-1 : 0];
+    if (pos == lastpos)
+        return;             /* same square as last visited one */
+
+    /* Drag confirmed, if it wasn't already. */
+    if (ui->ndragcoords == 0)
+        ui->ndragcoords = 1;
+
+    /*
+     * Dragging the mouse into a square that's already been visited by
+     * the drag path so far has the effect of truncating the path back
+     * to that square, so a player can back out part of an uncommitted
+     * drag without having to let go of the mouse.
+     */
+    for (i = 0; i < ui->ndragcoords; i++)
+        if (pos == ui->dragcoords[i]) {
+            ui->ndragcoords = i+1;
+            return;
+        }
+
+    /*
+     * Otherwise, dragging the mouse into a square that's a rook-move
+     * away from the last one on the path extends the path.
+     */
+    oy = ui->dragcoords[ui->ndragcoords-1] / w;
+    ox = ui->dragcoords[ui->ndragcoords-1] % w;
+    if (ox == gx || oy == gy) {
+        int dx = (gx < ox ? -1 : gx > ox ? +1 : 0);
+        int dy = (gy < oy ? -1 : gy > oy ? +1 : 0);
+        int dir = (dy>0 ? D : dy<0 ? U : dx>0 ? R : L);
+        while (ox != gx || oy != gy) {
+            /*
+             * If the drag attempts to cross a 'no line here' mark,
+             * stop there. We physically don't allow the user to drag
+             * over those marks.
+             */
+            if (state->marks[oy*w+ox] & dir)
+                break;
+            ox += dx;
+            oy += dy;
+            ui->dragcoords[ui->ndragcoords++] = oy * w + ox;
+        }
+    }
+
+    /*
+     * Failing that, we do nothing at all: if the user has dragged
+     * diagonally across the board, they'll just have to return the
+     * mouse to the last known position and do whatever they meant to
+     * do again, more slowly and clearly.
+     */
+}
+
+/*
+ * Routine shared between interpret_move and game_redraw to work out
+ * the intended effect of a drag path on the grid.
+ *
+ * Call it in a loop, like this:
+ *
+ *     int clearing = TRUE;
+ *     for (i = 0; i < ui->ndragcoords - 1; i++) {
+ *         int sx, sy, dx, dy, dir, oldstate, newstate;
+ *         interpret_ui_drag(state, ui, &clearing, i, &sx, &sy, &dx, &dy,
+ *                           &dir, &oldstate, &newstate);
+ *
+ *         [do whatever is needed to handle the fact that the drag
+ *         wants the edge from sx,sy to dx,dy (heading in direction
+ *         'dir' at the sx,sy end) to be changed from state oldstate
+ *         to state newstate, each of which equals either 0 or dir]
+ *     }
+ */
+static void interpret_ui_drag(const game_state *state, const game_ui *ui,
+                              int *clearing, int i, int *sx, int *sy,
+                              int *dx, int *dy, int *dir,
+                              int *oldstate, int *newstate)
+{
+    int w = state->shared->w;
+    int sp = ui->dragcoords[i], dp = ui->dragcoords[i+1];
+    *sy = sp/w;
+    *sx = sp%w;
+    *dy = dp/w;
+    *dx = dp%w;
+    *dir = (*dy>*sy ? D : *dy<*sy ? U : *dx>*sx ? R : L);
+    *oldstate = state->lines[sp] & *dir;
+    if (*oldstate) {
+        /*
+         * The edge we've dragged over was previously
+         * present. Set it to absent, unless we've already
+         * stopped doing that.
+         */
+        *newstate = *clearing ? 0 : *dir;
+    } else {
+        /*
+         * The edge we've dragged over was previously
+         * absent. Set it to present, and cancel the
+         * 'clearing' flag so that all subsequent edges in
+         * the drag are set rather than cleared.
+         */
+        *newstate = *dir;
+        *clearing = FALSE;
+    }
+}
+
+static char *mark_in_direction(const game_state *state, int x, int y, int dir,
+                               int primary, char *buf)
+{
+    int w = state->shared->w /*, h = state->shared->h, sz = state->shared->sz */;
+    int x2 = x + DX(dir);
+    int y2 = y + DY(dir);
+    int dir2 = F(dir);
+
+    char ch = primary ? 'F' : 'M', *other;
+
+    if (!INGRID(state, x, y) || !INGRID(state, x2, y2)) return "";
+
+    /* disallow laying a mark over a line, or vice versa. */
+    other = primary ? state->marks : state->lines;
+    if (other[y*w+x] & dir || other[y2*w+x2] & dir2) return "";
+    
+    sprintf(buf, "%c%d,%d,%d;%c%d,%d,%d", ch, dir, x, y, ch, dir2, x2, y2);
+    return dupstr(buf);
+}
+
+#define KEY_DIRECTION(btn) (\
+    (btn) == CURSOR_DOWN ? D : (btn) == CURSOR_UP ? U :\
+    (btn) == CURSOR_LEFT ? L : R)
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->shared->w, h = state->shared->h /*, sz = state->shared->sz */;
+    int gx = FROMCOORD(x), gy = FROMCOORD(y), i;
+    int release = FALSE;
+    char tmpbuf[80];
+
+    int shift = button & MOD_SHFT, control = button & MOD_CTRL;
+    button &= ~MOD_MASK;
+
+    if (IS_MOUSE_DOWN(button)) {
+        ui->cursor_active = FALSE;
+
+        if (!INGRID(state, gx, gy)) {
+            ui->ndragcoords = -1;
+            return NULL;
+        }
+
+        ui->clickx = x; ui->clicky = y;
+        ui->dragcoords[0] = gy * w + gx;
+        ui->ndragcoords = 0;           /* will be 1 once drag is confirmed */
+
+        return "";
+    }
+
+    if (button == LEFT_DRAG && ui->ndragcoords >= 0) {
+        update_ui_drag(state, ui, gx, gy);
+        return "";
+    }
+
+    if (IS_MOUSE_RELEASE(button)) release = TRUE;
+
+    if (IS_CURSOR_MOVE(button)) {
+        if (!ui->cursor_active) {
+            ui->cursor_active = TRUE;
+        } else if (control | shift) {
+            char *move;
+            if (ui->ndragcoords > 0) return NULL;
+            ui->ndragcoords = -1;
+            move = mark_in_direction(state, ui->curx, ui->cury,
+                                     KEY_DIRECTION(button), control, tmpbuf);
+            if (control && !shift && *move)
+                move_cursor(button, &ui->curx, &ui->cury, w, h, FALSE);
+            return move;
+        } else {
+            move_cursor(button, &ui->curx, &ui->cury, w, h, FALSE);
+            if (ui->ndragcoords >= 0)
+                update_ui_drag(state, ui, ui->curx, ui->cury);
+        }
+        return "";
+    }
+
+    if (IS_CURSOR_SELECT(button)) {
+        if (!ui->cursor_active) {
+            ui->cursor_active = TRUE;
+            return "";
+        } else if (button == CURSOR_SELECT) {
+            if (ui->ndragcoords == -1) {
+                ui->ndragcoords = 0;
+                ui->dragcoords[0] = ui->cury * w + ui->curx;
+                ui->clickx = CENTERED_COORD(ui->curx);
+                ui->clicky = CENTERED_COORD(ui->cury);
+                return "";
+            } else release = TRUE;
+        } else if (button == CURSOR_SELECT2 && ui->ndragcoords >= 0) {
+            ui->ndragcoords = -1;
+            return "";
+        }
+    }
+
+    if (button == 27 || button == '\b') {
+        ui->ndragcoords = -1;
+        return "";
+    }
+
+    if (release) {
+        if (ui->ndragcoords > 0) {
+            /* End of a drag: process the cached line data. */
+            int buflen = 0, bufsize = 256, tmplen;
+            char *buf = NULL;
+            const char *sep = "";
+            int clearing = TRUE;
+
+            for (i = 0; i < ui->ndragcoords - 1; i++) {
+                int sx, sy, dx, dy, dir, oldstate, newstate;
+                interpret_ui_drag(state, ui, &clearing, i, &sx, &sy, &dx, &dy,
+                                  &dir, &oldstate, &newstate);
+
+                if (oldstate != newstate) {
+                    if (!buf) buf = snewn(bufsize, char);
+                    tmplen = sprintf(tmpbuf, "%sF%d,%d,%d;F%d,%d,%d", sep,
+                                     dir, sx, sy, F(dir), dx, dy);
+                    if (buflen + tmplen >= bufsize) {
+                        bufsize = (buflen + tmplen) * 5 / 4 + 256;
+                        buf = sresize(buf, bufsize, char);
+                    }
+                    strcpy(buf + buflen, tmpbuf);
+                    buflen += tmplen;
+                    sep = ";";
+                }
+            }
+
+            ui->ndragcoords = -1;
+
+            return buf ? buf : "";
+        } else if (ui->ndragcoords == 0) {
+            /* Click (or tiny drag). Work out which edge we were
+             * closest to. */
+            int cx, cy;
+
+            ui->ndragcoords = -1;
+
+            /*
+             * We process clicks based on the mouse-down location,
+             * because that's more natural for a user to carefully
+             * control than the mouse-up.
+             */
+            x = ui->clickx;
+            y = ui->clicky;
+
+            gx = FROMCOORD(x);
+            gy = FROMCOORD(y);
+            cx = CENTERED_COORD(gx);
+            cy = CENTERED_COORD(gy);
+
+            if (!INGRID(state, gx, gy)) return "";
+
+            if (max(abs(x-cx),abs(y-cy)) < TILE_SIZE/4) {
+                /* TODO closer to centre of grid: process as a cell click not an edge click. */
+
+                return "";
+            } else {
+                int direction;
+                if (abs(x-cx) < abs(y-cy)) {
+                    /* Closest to top/bottom edge. */
+                    direction = (y < cy) ? U : D;
+                } else {
+                    /* Closest to left/right edge. */
+                    direction = (x < cx) ? L : R;
+                }
+                return mark_in_direction(state, gx, gy, direction,
+                                         (button == LEFT_RELEASE), tmpbuf);
+            }
+        }
+    }
+
+    if (button == 'H' || button == 'h')
+        return dupstr("H");
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int w = state->shared->w, h = state->shared->h;
+    char c;
+    int x, y, l, n;
+    game_state *ret = dup_game(state);
+
+    debug(("move: %s\n", move));
+
+    while (*move) {
+        c = *move;
+        if (c == 'S') {
+            ret->used_solve = TRUE;
+            move++;
+        } else if (c == 'L' || c == 'N' || c == 'R' || c == 'F' || c == 'M') {
+            /* 'line' or 'noline' or 'replace' or 'flip' or 'mark' */
+            move++;
+            if (sscanf(move, "%d,%d,%d%n", &l, &x, &y, &n) != 3)
+                goto badmove;
+            if (!INGRID(state, x, y)) goto badmove;
+            if (l < 0 || l > 15) goto badmove;
+
+            if (c == 'L')
+                ret->lines[y*w + x] |= (char)l;
+            else if (c == 'N')
+                ret->lines[y*w + x] &= ~((char)l);
+            else if (c == 'R') {
+                ret->lines[y*w + x] = (char)l;
+                ret->marks[y*w + x] &= ~((char)l); /* erase marks too */
+            } else if (c == 'F')
+                ret->lines[y*w + x] ^= (char)l;
+            else if (c == 'M')
+                ret->marks[y*w + x] ^= (char)l;
+
+            /*
+             * If we ended up trying to lay a line _over_ a mark,
+             * that's a failed move: interpret_move() should have
+             * ensured we never received a move string like that in
+             * the first place.
+             */
+            if ((ret->lines[y*w + x] & (char)l) &&
+                (ret->marks[y*w + x] & (char)l))
+                goto badmove;
+
+            move += n;
+        } else if (strcmp(move, "H") == 0) {
+            pearl_solve(ret->shared->w, ret->shared->h,
+                        ret->shared->clues, ret->lines, DIFFCOUNT, TRUE);
+            for (n = 0; n < w*h; n++)
+                ret->marks[n] &= ~ret->lines[n]; /* erase marks too */
+            move++;
+        } else {
+            goto badmove;
+        }
+        if (*move == ';')
+            move++;
+        else if (*move)
+            goto badmove;
+    }
+
+    check_completion(ret, TRUE);
+
+    return ret;
+
+badmove:
+    free_game(ret);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define FLASH_TIME 0.5F
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int halfsz; } ads, *ds = &ads;
+    ads.halfsz = (tilesize-1)/2;
+
+    *x = (params->w) * TILE_SIZE + 2 * BORDER;
+    *y = (params->h) * TILE_SIZE + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->halfsz = (tilesize-1)/2;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_BLACK * 3 + i] = 0.0F;
+        ret[COL_WHITE * 3 + i] = 1.0F;
+        ret[COL_GRID * 3 + i] = 0.4F;
+    }
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_DRAGON * 3 + 0] = 0.0F;
+    ret[COL_DRAGON * 3 + 1] = 0.0F;
+    ret[COL_DRAGON * 3 + 2] = 1.0F;
+
+    ret[COL_DRAGOFF * 3 + 0] = 0.8F;
+    ret[COL_DRAGOFF * 3 + 1] = 0.8F;
+    ret[COL_DRAGOFF * 3 + 2] = 1.0F;
+
+    ret[COL_FLASH * 3 + 0] = 1.0F;
+    ret[COL_FLASH * 3 + 1] = 1.0F;
+    ret[COL_FLASH * 3 + 2] = 1.0F;
+
+    *ncolours = NCOLOURS;
+
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->halfsz = 0;
+    ds->started = FALSE;
+
+    ds->w = state->shared->w;
+    ds->h = state->shared->h;
+    ds->sz = state->shared->sz;
+    ds->lflags = snewn(ds->sz, unsigned int);
+    for (i = 0; i < ds->sz; i++)
+        ds->lflags[i] = 0;
+
+    ds->draglines = snewn(ds->sz, char);
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->draglines);
+    sfree(ds->lflags);
+    sfree(ds);
+}
+
+static void draw_lines_specific(drawing *dr, game_drawstate *ds,
+                                int x, int y, unsigned int lflags,
+                                unsigned int shift, int c)
+{
+    int ox = COORD(x), oy = COORD(y);
+    int t2 = HALFSZ, t16 = HALFSZ/4;
+    int cx = ox + t2, cy = oy + t2;
+    int d;
+
+    /* Draw each of the four directions, where laid (or error, or drag, etc.) */
+    for (d = 1; d < 16; d *= 2) {
+        int xoff = t2 * DX(d), yoff = t2 * DY(d);
+        int xnudge = abs(t16 * DX(C(d))), ynudge = abs(t16 * DY(C(d)));
+
+        if ((lflags >> shift) & d) {
+            int lx = cx + ((xoff < 0) ? xoff : 0) - xnudge;
+            int ly = cy + ((yoff < 0) ? yoff : 0) - ynudge;
+
+            if (c == COL_DRAGOFF && !(lflags & d))
+                continue;
+            if (c == COL_DRAGON && (lflags & d))
+                continue;
+
+            draw_rect(dr, lx, ly,
+                      abs(xoff)+2*xnudge+1,
+                      abs(yoff)+2*ynudge+1, c);
+            /* end cap */
+            draw_rect(dr, cx - t16, cy - t16, 2*t16+1, 2*t16+1, c);
+        }
+    }
+}
+
+static void draw_square(drawing *dr, game_drawstate *ds, const game_ui *ui,
+                        int x, int y, unsigned int lflags, char clue)
+{
+    int ox = COORD(x), oy = COORD(y);
+    int t2 = HALFSZ, t16 = HALFSZ/4;
+    int cx = ox + t2, cy = oy + t2;
+    int d;
+
+    assert(dr);
+
+    /* Clip to the grid square. */
+    clip(dr, ox, oy, TILE_SIZE, TILE_SIZE);
+
+    /* Clear the square. */
+    draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE,
+              (lflags & DS_CURSOR) ?
+              COL_CURSOR_BACKGROUND : COL_BACKGROUND);
+              
+
+    if (get_gui_style() == GUI_LOOPY) {
+        /* Draw small dot, underneath any lines. */
+        draw_circle(dr, cx, cy, t16, COL_GRID, COL_GRID);
+    } else {
+        /* Draw outline of grid square */
+        draw_line(dr, ox, oy, COORD(x+1), oy, COL_GRID);
+        draw_line(dr, ox, oy, ox, COORD(y+1), COL_GRID);
+    }
+
+    /* Draw grid: either thin gridlines, or no-line marks.
+     * We draw these first because the thick laid lines should be on top. */
+    for (d = 1; d < 16; d *= 2) {
+        int xoff = t2 * DX(d), yoff = t2 * DY(d);
+
+        if ((x == 0 && d == L) ||
+            (y == 0 && d == U) ||
+            (x == ds->w-1 && d == R) ||
+            (y == ds->h-1 && d == D))
+            continue; /* no gridlines out to the border. */
+
+        if ((lflags >> DS_MSHIFT) & d) {
+            /* either a no-line mark ... */
+            int mx = cx + xoff, my = cy + yoff, msz = t16;
+
+            draw_line(dr, mx-msz, my-msz, mx+msz, my+msz, COL_BLACK);
+            draw_line(dr, mx-msz, my+msz, mx+msz, my-msz, COL_BLACK);
+        } else {
+            if (get_gui_style() == GUI_LOOPY) {
+                /* draw grid lines connecting centre of cells */
+                draw_line(dr, cx, cy, cx+xoff, cy+yoff, COL_GRID);
+            }
+        }
+    }
+
+    /* Draw each of the four directions, where laid (or error, or drag, etc.)
+     * Order is important here, specifically for the eventual colours of the
+     * exposed end caps. */
+    draw_lines_specific(dr, ds, x, y, lflags, 0,
+                        (lflags & DS_FLASH ? COL_FLASH : COL_BLACK));
+    draw_lines_specific(dr, ds, x, y, lflags, DS_ESHIFT, COL_ERROR);
+    draw_lines_specific(dr, ds, x, y, lflags, DS_DSHIFT, COL_DRAGOFF);
+    draw_lines_specific(dr, ds, x, y, lflags, DS_DSHIFT, COL_DRAGON);
+
+    /* Draw a clue, if present */
+    if (clue != NOCLUE) {
+        int c = (lflags & DS_FLASH) ? COL_FLASH :
+                (clue == STRAIGHT) ? COL_WHITE : COL_BLACK;
+
+        if (lflags & DS_ERROR_CLUE) /* draw a bigger 'error' clue circle. */
+            draw_circle(dr, cx, cy, TILE_SIZE*3/8, COL_ERROR, COL_ERROR);
+
+        draw_circle(dr, cx, cy, TILE_SIZE/4, c, COL_BLACK);
+    }
+
+    unclip(dr);
+    draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->shared->w, h = state->shared->h, sz = state->shared->sz;
+    int x, y, force = 0, flashing = 0;
+
+    if (!ds->started) {
+        /*
+         * The initial contents of the window are not guaranteed and
+         * can vary with front ends. To be on the safe side, all games
+         * should start by drawing a big background-colour rectangle
+         * covering the whole window.
+         */
+        draw_rect(dr, 0, 0, w*TILE_SIZE + 2*BORDER, h*TILE_SIZE + 2*BORDER,
+                  COL_BACKGROUND);
+
+        if (get_gui_style() == GUI_MASYU) {
+            /*
+             * Smaller black rectangle which is the main grid.
+             */
+            draw_rect(dr, BORDER - BORDER_WIDTH, BORDER - BORDER_WIDTH,
+                      w*TILE_SIZE + 2*BORDER_WIDTH + 1,
+                      h*TILE_SIZE + 2*BORDER_WIDTH + 1,
+                      COL_GRID);
+        }
+
+        draw_update(dr, 0, 0, w*TILE_SIZE + 2*BORDER, h*TILE_SIZE + 2*BORDER);
+
+        ds->started = TRUE;
+        force = 1;
+    }
+
+    if (flashtime > 0 &&
+        (flashtime <= FLASH_TIME/3 ||
+         flashtime >= FLASH_TIME*2/3))
+        flashing = DS_FLASH;
+
+    memset(ds->draglines, 0, sz);
+    if (ui->ndragcoords > 0) {
+        int i, clearing = TRUE;
+        for (i = 0; i < ui->ndragcoords - 1; i++) {
+            int sx, sy, dx, dy, dir, oldstate, newstate;
+            interpret_ui_drag(state, ui, &clearing, i, &sx, &sy, &dx, &dy,
+                              &dir, &oldstate, &newstate);
+            ds->draglines[sy*w+sx] ^= (oldstate ^ newstate);
+            ds->draglines[dy*w+dx] ^= (F(oldstate) ^ F(newstate));
+        }
+    }   
+
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            unsigned int f = (unsigned int)state->lines[y*w+x];
+            unsigned int eline = (unsigned int)(state->errors[y*w+x] & (R|U|L|D));
+
+            f |= eline << DS_ESHIFT;
+            f |= ((unsigned int)ds->draglines[y*w+x]) << DS_DSHIFT;
+            f |= ((unsigned int)state->marks[y*w+x]) << DS_MSHIFT;
+
+            if (state->errors[y*w+x] & ERROR_CLUE)
+                f |= DS_ERROR_CLUE;
+
+            f |= flashing;
+
+            if (ui->cursor_active && x == ui->curx && y == ui->cury)
+                f |= DS_CURSOR;
+
+            if (f != ds->lflags[y*w+x] || force) {
+                ds->lflags[y*w+x] = f;
+                draw_square(dr, ds, ui, x, y, f, state->shared->clues[y*w+x]);
+            }
+        }
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->used_solve && !newstate->used_solve)
+        return FLASH_TIME;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 6mm squares by default.
+     */
+    game_compute_size(params, 600, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->shared->w, h = state->shared->h, x, y;
+    int black = print_mono_colour(dr, 0);
+    int white = print_mono_colour(dr, 1);
+
+    /* No GUI_LOOPY here: only use the familiar masyu style. */
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate *ds = game_new_drawstate(dr, state);
+    game_set_size(dr, ds, NULL, tilesize);
+
+    /* Draw grid outlines (black). */
+    for (x = 0; x <= w; x++)
+        draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h), black);
+    for (y = 0; y <= h; y++)
+        draw_line(dr, COORD(0), COORD(y), COORD(w), COORD(y), black);
+
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            int cx = COORD(x) + HALFSZ, cy = COORD(y) + HALFSZ;
+            int clue = state->shared->clues[y*w+x];
+
+            draw_lines_specific(dr, ds, x, y, state->lines[y*w+x], 0, black);
+
+            if (clue != NOCLUE) {
+                int c = (clue == CORNER) ? black : white;
+                draw_circle(dr, cx, cy, TILE_SIZE/4, c, black);
+            }
+        }
+    }
+
+    game_free_drawstate(dr, ds);
+}
+
+#ifdef COMBINED
+#define thegame pearl
+#endif
+
+const struct game thegame = {
+    "Pearl", "games.pearl", "pearl",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+#include <time.h>
+#include <stdarg.h>
+
+const char *quis = NULL;
+
+static void usage(FILE *out) {
+    fprintf(out, "usage: %s <params>\n", quis);
+}
+
+static void pnum(int n, int ntot, const char *desc)
+{
+    printf("%2.1f%% (%d) %s", (double)n*100.0 / (double)ntot, n, desc);
+}
+
+static void start_soak(game_params *p, random_state *rs, int nsecs)
+{
+    time_t tt_start, tt_now, tt_last;
+    int n = 0, nsolved = 0, nimpossible = 0, ret;
+    char *grid, *clues;
+
+    tt_start = tt_last = time(NULL);
+
+    /* Currently this generates puzzles of any difficulty (trying to solve it
+     * on the maximum difficulty level and not checking it's not too easy). */
+    printf("Soak-testing a %dx%d grid (any difficulty)", p->w, p->h);
+    if (nsecs > 0) printf(" for %d seconds", nsecs);
+    printf(".\n");
+
+    p->nosolve = TRUE;
+
+    grid = snewn(p->w*p->h, char);
+    clues = snewn(p->w*p->h, char);
+
+    while (1) {
+        n += new_clues(p, rs, clues, grid); /* should be 1, with nosolve */
+
+        ret = pearl_solve(p->w, p->h, clues, grid, DIFF_TRICKY, FALSE);
+        if (ret <= 0) nimpossible++;
+        if (ret == 1) nsolved++;
+
+        tt_now = time(NULL);
+        if (tt_now > tt_last) {
+            tt_last = tt_now;
+
+            printf("%d total, %3.1f/s, ",
+                   n, (double)n / ((double)tt_now - tt_start));
+            pnum(nsolved, n, "solved"); printf(", ");
+            printf("%3.1f/s", (double)nsolved / ((double)tt_now - tt_start));
+            if (nimpossible > 0)
+                pnum(nimpossible, n, "impossible");
+            printf("\n");
+        }
+        if (nsecs > 0 && (tt_now - tt_start) > nsecs) {
+            printf("\n");
+            break;
+        }
+    }
+
+    sfree(grid);
+    sfree(clues);
+}
+
+int main(int argc, const char *argv[])
+{
+    game_params *p = NULL;
+    random_state *rs = NULL;
+    time_t seed = time(NULL);
+    char *id = NULL, *err;
+
+    setvbuf(stdout, NULL, _IONBF, 0);
+
+    quis = argv[0];
+
+    while (--argc > 0) {
+        char *p = (char*)(*++argv);
+        if (!strcmp(p, "-e") || !strcmp(p, "--seed")) {
+            seed = atoi(*++argv);
+            argc--;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            usage(stderr);
+            exit(1);
+        } else {
+            id = p;
+        }
+    }
+
+    rs = random_new((void*)&seed, sizeof(time_t));
+    p = default_params();
+
+    if (id) {
+        if (strchr(id, ':')) {
+            fprintf(stderr, "soak takes params only.\n");
+            goto done;
+        }
+
+        decode_params(p, id);
+        err = validate_params(p, 1);
+        if (err) {
+            fprintf(stderr, "%s: %s", argv[0], err);
+            goto done;
+        }
+
+        start_soak(p, rs, 0); /* run forever */
+    } else {
+        int i;
+
+        for (i = 5; i <= 12; i++) {
+            p->w = p->h = i;
+            start_soak(p, rs, 5);
+        }
+    }
+
+done:
+    free_params(p);
+    random_free(rs);
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/pegs.R b/apps/plugins/puzzles/pegs.R
new file mode 100644
index 0000000000..1e79e99ca0
--- /dev/null
+++ b/apps/plugins/puzzles/pegs.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+PEGS_EXTRA = tree234
+
+pegs     : [X] GTK COMMON pegs PEGS_EXTRA pegs-icon|no-icon
+
+pegs     : [G] WINDOWS COMMON pegs PEGS_EXTRA pegs.res|noicon.res
+
+ALL += pegs[COMBINED] PEGS_EXTRA
+
+!begin am gtk
+GAMES += pegs
+!end
+
+!begin >list.c
+    A(pegs) \
+!end
+
+!begin >gamedesc.txt
+pegs:pegs.exe:Pegs:Peg solitaire puzzle:Jump pegs over each other to remove all but one.
+!end
diff --git a/apps/plugins/puzzles/pegs.c b/apps/plugins/puzzles/pegs.c
new file mode 100644
index 0000000000..f02e25cafa
--- /dev/null
+++ b/apps/plugins/puzzles/pegs.c
@@ -0,0 +1,1340 @@
+/*
+ * pegs.c: the classic Peg Solitaire game.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+
+#define GRID_HOLE 0
+#define GRID_PEG  1
+#define GRID_OBST 2
+
+#define GRID_CURSOR 10
+#define GRID_JUMPING 20
+
+enum {
+    COL_BACKGROUND,
+    COL_HIGHLIGHT,
+    COL_LOWLIGHT,
+    COL_PEG,
+    COL_CURSOR,
+    NCOLOURS
+};
+
+/*
+ * Grid shapes. I do some macro ickery here to ensure that my enum
+ * and the various forms of my name list always match up.
+ */
+#define TYPELIST(A) \
+    A(CROSS,Cross,cross) \
+    A(OCTAGON,Octagon,octagon) \
+    A(RANDOM,Random,random)
+#define ENUM(upper,title,lower) TYPE_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define LOWER(upper,title,lower) #lower,
+#define CONFIG(upper,title,lower) ":" #title
+
+enum { TYPELIST(ENUM) TYPECOUNT };
+static char const *const pegs_titletypes[] = { TYPELIST(TITLE) };
+static char const *const pegs_lowertypes[] = { TYPELIST(LOWER) };
+#define TYPECONFIG TYPELIST(CONFIG)
+
+#define FLASH_FRAME 0.13F
+
+struct game_params {
+    int w, h;
+    int type;
+};
+
+struct game_state {
+    int w, h;
+    int completed;
+    unsigned char *grid;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 7;
+    ret->type = TYPE_CROSS;
+
+    return ret;
+}
+
+static const struct game_params pegs_presets[] = {
+    {7, 7, TYPE_CROSS},
+    {7, 7, TYPE_OCTAGON},
+    {5, 5, TYPE_RANDOM},
+    {7, 7, TYPE_RANDOM},
+    {9, 9, TYPE_RANDOM},
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(pegs_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = pegs_presets[i];
+
+    strcpy(str, pegs_titletypes[ret->type]);
+    if (ret->type == TYPE_RANDOM)
+        sprintf(str + strlen(str), " %dx%d", ret->w, ret->h);
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    char const *p = string;
+    int i;
+
+    params->w = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+    if (*p == 'x') {
+        p++;
+        params->h = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+    } else {
+        params->h = params->w;
+    }
+
+    for (i = 0; i < lenof(pegs_lowertypes); i++)
+        if (!strcmp(p, pegs_lowertypes[i]))
+            params->type = i;
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char str[80];
+
+    sprintf(str, "%dx%d", params->w, params->h);
+    if (full) {
+        assert(params->type >= 0 && params->type < lenof(pegs_lowertypes));
+        strcat(str, pegs_lowertypes[params->type]);
+    }
+    return dupstr(str);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret = snewn(4, config_item);
+    char buf[80];
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Board type";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = TYPECONFIG;
+    ret[2].ival = params->type;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->type = cfg[2].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (full && (params->w <= 3 || params->h <= 3))
+        return "Width and height must both be greater than three";
+
+    /*
+     * It might be possible to implement generalisations of Cross
+     * and Octagon, but only if I can find a proof that they're all
+     * soluble. For the moment, therefore, I'm going to disallow
+     * them at any size other than the standard one.
+     */
+    if (full && (params->type == TYPE_CROSS || params->type == TYPE_OCTAGON)) {
+        if (params->w != 7 || params->h != 7)
+            return "This board type is only supported at 7x7";
+    }
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Beginning of code to generate random Peg Solitaire boards.
+ * 
+ * This procedure is done with no aesthetic judgment, no effort at
+ * symmetry, no difficulty grading and generally no finesse
+ * whatsoever. We simply begin with an empty board containing a
+ * single peg, and repeatedly make random reverse moves until it's
+ * plausibly full. This typically yields a scrappy haphazard mess
+ * with several holes, an uneven shape, and no redeeming features
+ * except guaranteed solubility.
+ *
+ * My only concessions to sophistication are (a) to repeat the
+ * generation process until I at least get a grid that touches
+ * every edge of the specified board size, and (b) to try when
+ * selecting moves to reuse existing space rather than expanding
+ * into new space (so that non-rectangular board shape becomes a
+ * factor during play).
+ */
+
+struct move {
+    /*
+     * x,y are the start point of the move during generation (hence
+     * its endpoint during normal play).
+     * 
+     * dx,dy are the direction of the move during generation.
+     * Absolute value 1. Hence, for example, x=3,y=5,dx=1,dy=0
+     * means that the move during generation starts at (3,5) and
+     * ends at (5,5), and vice versa during normal play.
+     */
+    int x, y, dx, dy;
+    /*
+     * cost is 0, 1 or 2, depending on how many GRID_OBSTs we must
+     * turn into GRID_HOLEs to play this move.
+     */
+    int cost;
+};
+
+static int movecmp(void *av, void *bv)
+{
+    struct move *a = (struct move *)av;
+    struct move *b = (struct move *)bv;
+
+    if (a->y < b->y)
+        return -1;
+    else if (a->y > b->y)
+        return +1;
+
+    if (a->x < b->x)
+        return -1;
+    else if (a->x > b->x)
+        return +1;
+
+    if (a->dy < b->dy)
+        return -1;
+    else if (a->dy > b->dy)
+        return +1;
+
+    if (a->dx < b->dx)
+        return -1;
+    else if (a->dx > b->dx)
+        return +1;
+
+    return 0;
+}
+
+static int movecmpcost(void *av, void *bv)
+{
+    struct move *a = (struct move *)av;
+    struct move *b = (struct move *)bv;
+
+    if (a->cost < b->cost)
+        return -1;
+    else if (a->cost > b->cost)
+        return +1;
+
+    return movecmp(av, bv);
+}
+
+struct movetrees {
+    tree234 *bymove, *bycost;
+};
+
+static void update_moves(unsigned char *grid, int w, int h, int x, int y,
+                         struct movetrees *trees)
+{
+    struct move move;
+    int dir, pos;
+
+    /*
+     * There are twelve moves that can include (x,y): three in each
+     * of four directions. Check each one to see if it's possible.
+     */
+    for (dir = 0; dir < 4; dir++) {
+        int dx, dy;
+
+        if (dir & 1)
+            dx = 0, dy = dir - 2;
+        else
+            dy = 0, dx = dir - 1;
+
+        assert(abs(dx) + abs(dy) == 1);
+
+        for (pos = 0; pos < 3; pos++) {
+            int v1, v2, v3;
+
+            move.dx = dx;
+            move.dy = dy;
+            move.x = x - pos*dx;
+            move.y = y - pos*dy;
+
+            if (move.x < 0 || move.x >= w || move.y < 0 || move.y >= h)
+                continue;              /* completely invalid move */
+            if (move.x+2*move.dx < 0 || move.x+2*move.dx >= w ||
+                move.y+2*move.dy < 0 || move.y+2*move.dy >= h)
+                continue;              /* completely invalid move */
+
+            v1 = grid[move.y * w + move.x];
+            v2 = grid[(move.y+move.dy) * w + (move.x+move.dx)];
+            v3 = grid[(move.y+2*move.dy)*w + (move.x+2*move.dx)];
+            if (v1 == GRID_PEG && v2 != GRID_PEG && v3 != GRID_PEG) {
+                struct move *m;
+
+                move.cost = (v2 == GRID_OBST) + (v3 == GRID_OBST);
+
+                /*
+                 * This move is possible. See if it's already in
+                 * the tree.
+                 */
+                m = find234(trees->bymove, &move, NULL);
+                if (m && m->cost != move.cost) {
+                    /*
+                     * It's in the tree but listed with the wrong
+                     * cost. Remove the old version.
+                     */
+#ifdef GENERATION_DIAGNOSTICS
+                    printf("correcting %d%+d,%d%+d at cost %d\n",
+                           m->x, m->dx, m->y, m->dy, m->cost);
+#endif
+                    del234(trees->bymove, m);
+                    del234(trees->bycost, m);
+                    sfree(m);
+                    m = NULL;
+                }
+                if (!m) {
+                    struct move *m, *m2;
+                    m = snew(struct move);
+                    *m = move;
+                    m2 = add234(trees->bymove, m);
+                    m2 = add234(trees->bycost, m);
+                    assert(m2 == m);
+#ifdef GENERATION_DIAGNOSTICS
+                    printf("adding %d%+d,%d%+d at cost %d\n",
+                           move.x, move.dx, move.y, move.dy, move.cost);
+#endif
+                } else {
+#ifdef GENERATION_DIAGNOSTICS
+                    printf("not adding %d%+d,%d%+d at cost %d\n",
+                           move.x, move.dx, move.y, move.dy, move.cost);
+#endif
+                }
+            } else {
+                /*
+                 * This move is impossible. If it is already in the
+                 * tree, delete it.
+                 * 
+                 * (We make use here of the fact that del234
+                 * doesn't have to be passed a pointer to the
+                 * _actual_ element it's deleting: it merely needs
+                 * one that compares equal to it, and it will
+                 * return the one it deletes.)
+                 */
+                struct move *m = del234(trees->bymove, &move);
+#ifdef GENERATION_DIAGNOSTICS
+                printf("%sdeleting %d%+d,%d%+d\n", m ? "" : "not ",
+                       move.x, move.dx, move.y, move.dy);
+#endif
+                if (m) {
+                    del234(trees->bycost, m);
+                    sfree(m);
+                }
+            }
+        }
+    }
+}
+
+static void pegs_genmoves(unsigned char *grid, int w, int h, random_state *rs)
+{
+    struct movetrees atrees, *trees = &atrees;
+    struct move *m;
+    int x, y, i, nmoves;
+
+    trees->bymove = newtree234(movecmp);
+    trees->bycost = newtree234(movecmpcost);
+
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            if (grid[y*w+x] == GRID_PEG)
+                update_moves(grid, w, h, x, y, trees);
+
+    nmoves = 0;
+
+    while (1) {
+        int limit, maxcost, index;
+        struct move mtmp, move, *m;
+
+        /*
+         * See how many moves we can make at zero cost. Make one,
+         * if possible. Failing that, make a one-cost move, and
+         * then a two-cost one.
+         * 
+         * After filling at least half the input grid, we no longer
+         * accept cost-2 moves: if that's our only option, we give
+         * up and finish.
+         */
+        mtmp.y = h+1;
+        maxcost = (nmoves < w*h/2 ? 2 : 1);
+        m = NULL;                      /* placate optimiser */
+        for (mtmp.cost = 0; mtmp.cost <= maxcost; mtmp.cost++) {
+            limit = -1;
+            m = findrelpos234(trees->bycost, &mtmp, NULL, REL234_LT, &limit);
+#ifdef GENERATION_DIAGNOSTICS
+            printf("%d moves available with cost %d\n", limit+1, mtmp.cost);
+#endif
+            if (m)
+                break;
+        }
+        if (!m)
+            break;
+
+        index = random_upto(rs, limit+1);
+        move = *(struct move *)index234(trees->bycost, index);
+
+#ifdef GENERATION_DIAGNOSTICS
+        printf("selecting move %d%+d,%d%+d at cost %d\n",
+               move.x, move.dx, move.y, move.dy, move.cost);
+#endif
+
+        grid[move.y * w + move.x] = GRID_HOLE;
+        grid[(move.y+move.dy) * w + (move.x+move.dx)] = GRID_PEG;
+        grid[(move.y+2*move.dy)*w + (move.x+2*move.dx)] = GRID_PEG;
+
+        for (i = 0; i <= 2; i++) {
+            int tx = move.x + i*move.dx;
+            int ty = move.y + i*move.dy;
+            update_moves(grid, w, h, tx, ty, trees);
+        }
+
+        nmoves++;
+    }
+
+    while ((m = delpos234(trees->bymove, 0)) != NULL) {
+        del234(trees->bycost, m);
+        sfree(m);
+    }
+    freetree234(trees->bymove);
+    freetree234(trees->bycost);
+}
+
+static void pegs_generate(unsigned char *grid, int w, int h, random_state *rs)
+{
+    while (1) {
+        int x, y, extremes;
+
+        memset(grid, GRID_OBST, w*h);
+        grid[(h/2) * w + (w/2)] = GRID_PEG;
+#ifdef GENERATION_DIAGNOSTICS
+        printf("beginning move selection\n");
+#endif
+        pegs_genmoves(grid, w, h, rs);
+#ifdef GENERATION_DIAGNOSTICS
+        printf("finished move selection\n");
+#endif
+
+        extremes = 0;
+        for (y = 0; y < h; y++) {
+            if (grid[y*w+0] != GRID_OBST)
+                extremes |= 1;
+            if (grid[y*w+w-1] != GRID_OBST)
+                extremes |= 2;
+        }
+        for (x = 0; x < w; x++) {
+            if (grid[0*w+x] != GRID_OBST)
+                extremes |= 4;
+            if (grid[(h-1)*w+x] != GRID_OBST)
+                extremes |= 8;
+        }
+
+        if (extremes == 15)
+            break;
+#ifdef GENERATION_DIAGNOSTICS
+        printf("insufficient extent; trying again\n");
+#endif
+    }
+#ifdef GENERATION_DIAGNOSTICS
+    fflush(stdout);
+#endif
+}
+
+/* ----------------------------------------------------------------------
+ * End of board generation code. Now for the client code which uses
+ * it as part of the puzzle.
+ */
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, h = params->h;
+    unsigned char *grid;
+    char *ret;
+    int i;
+
+    grid = snewn(w*h, unsigned char);
+    if (params->type == TYPE_RANDOM) {
+        pegs_generate(grid, w, h, rs);
+    } else {
+        int x, y, cx, cy, v;
+
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++) {
+                v = GRID_OBST;         /* placate optimiser */
+                switch (params->type) {
+                  case TYPE_CROSS:
+                    cx = abs(x - w/2);
+                    cy = abs(y - h/2);
+                    if (cx == 0 && cy == 0)
+                        v = GRID_HOLE;
+                    else if (cx > 1 && cy > 1)
+                        v = GRID_OBST;
+                    else
+                        v = GRID_PEG;
+                    break;
+                  case TYPE_OCTAGON:
+                    cx = abs(x - w/2);
+                    cy = abs(y - h/2);
+                    if (cx + cy > 1 + max(w,h)/2)
+                        v = GRID_OBST;
+                    else
+                        v = GRID_PEG;
+                    break;
+                }
+                grid[y*w+x] = v;
+            }
+
+        if (params->type == TYPE_OCTAGON) {
+            /*
+             * The octagonal (European) solitaire layout is
+             * actually _insoluble_ with the starting hole at the
+             * centre. Here's a proof:
+             * 
+             * Colour the squares of the board diagonally in
+             * stripes of three different colours, which I'll call
+             * A, B and C. So the board looks like this:
+             * 
+             *     A B C
+             *   A B C A B
+             * A B C A B C A
+             * B C A B C A B
+             * C A B C A B C
+             *   B C A B C
+             *     A B C
+             * 
+             * Suppose we keep running track of the number of pegs
+             * occuping each colour of square. This colouring has
+             * the property that any valid move whatsoever changes
+             * all three of those counts by one (two of them go
+             * down and one goes up), which means that the _parity_
+             * of every count flips on every move.
+             * 
+             * If the centre square starts off unoccupied, then
+             * there are twelve pegs on each colour and all three
+             * counts start off even; therefore, after 35 moves all
+             * three counts would have to be odd, which isn't
+             * possible if there's only one peg left. []
+             * 
+             * This proof works just as well if the starting hole
+             * is _any_ of the thirteen positions labelled B. Also,
+             * we can stripe the board in the opposite direction
+             * and rule out any square labelled B in that colouring
+             * as well. This leaves:
+             * 
+             *     Y n Y
+             *   n n Y n n
+             * Y n n Y n n Y
+             * n Y Y n Y Y n
+             * Y n n Y n n Y
+             *   n n Y n n
+             *     Y n Y
+             * 
+             * where the ns are squares we've proved insoluble, and
+             * the Ys are the ones remaining.
+             * 
+             * That doesn't prove all those starting positions to
+             * be soluble, of course; they're merely the ones we
+             * _haven't_ proved to be impossible. Nevertheless, it
+             * turns out that they are all soluble, so when the
+             * user requests an Octagon board the simplest thing is
+             * to pick one of these at random.
+             * 
+             * Rather than picking equiprobably from those twelve
+             * positions, we'll pick equiprobably from the three
+             * equivalence classes
+             */
+            switch (random_upto(rs, 3)) {
+              case 0:
+                /* Remove a random corner piece. */
+                {
+                    int dx, dy;
+
+                    dx = random_upto(rs, 2) * 2 - 1;   /* +1 or -1 */
+                    dy = random_upto(rs, 2) * 2 - 1;   /* +1 or -1 */
+                    if (random_upto(rs, 2))
+                        dy *= 3;
+                    else
+                        dx *= 3;
+                    grid[(3+dy)*w+(3+dx)] = GRID_HOLE;
+                }
+                break;
+              case 1:
+                /* Remove a random piece two from the centre. */
+                {
+                    int dx, dy;
+                    dx = 2 * (random_upto(rs, 2) * 2 - 1);
+                    if (random_upto(rs, 2))
+                        dy = 0;
+                    else
+                        dy = dx, dx = 0;
+                    grid[(3+dy)*w+(3+dx)] = GRID_HOLE;
+                }
+                break;
+              default /* case 2 */:
+                /* Remove a random piece one from the centre. */
+                {
+                    int dx, dy;
+                    dx = random_upto(rs, 2) * 2 - 1;
+                    if (random_upto(rs, 2))
+                        dy = 0;
+                    else
+                        dy = dx, dx = 0;
+                    grid[(3+dy)*w+(3+dx)] = GRID_HOLE;
+                }
+                break;
+            }
+        }
+    }
+
+    /*
+     * Encode a game description which is simply a long list of P
+     * for peg, H for hole or O for obstacle.
+     */
+    ret = snewn(w*h+1, char);
+    for (i = 0; i < w*h; i++)
+        ret[i] = (grid[i] == GRID_PEG ? 'P' :
+                  grid[i] == GRID_HOLE ? 'H' : 'O');
+    ret[w*h] = '\0';
+
+    sfree(grid);
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int len = params->w * params->h;
+
+    if (len != strlen(desc))
+        return "Game description is wrong length";
+    if (len != strspn(desc, "PHO"))
+        return "Invalid character in game description";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, h = params->h;
+    game_state *state = snew(game_state);
+    int i;
+
+    state->w = w;
+    state->h = h;
+    state->completed = 0;
+    state->grid = snewn(w*h, unsigned char);
+    for (i = 0; i < w*h; i++)
+        state->grid[i] = (desc[i] == 'P' ? GRID_PEG :
+                          desc[i] == 'H' ? GRID_HOLE : GRID_OBST);
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w = state->w, h = state->h;
+    game_state *ret = snew(game_state);
+
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->completed = state->completed;
+    ret->grid = snewn(w*h, unsigned char);
+    memcpy(ret->grid, state->grid, w*h);
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return NULL;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->w, h = state->h;
+    int x, y;
+    char *ret;
+
+    ret = snewn((w+1)*h + 1, char);
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++)
+            ret[y*(w+1)+x] = (state->grid[y*w+x] == GRID_HOLE ? '-' :
+                              state->grid[y*w+x] == GRID_PEG ? '*' : ' ');
+        ret[y*(w+1)+w] = '\n';
+    }
+    ret[h*(w+1)] = '\0';
+
+    return ret;
+}
+
+struct game_ui {
+    int dragging;                      /* boolean: is a drag in progress? */
+    int sx, sy;                        /* grid coords of drag start cell */
+    int dx, dy;                        /* pixel coords of current drag posn */
+    int cur_x, cur_y, cur_visible, cur_jumping;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    int x, y, v;
+
+    ui->sx = ui->sy = ui->dx = ui->dy = 0;
+    ui->dragging = FALSE;
+    ui->cur_visible = ui->cur_jumping = 0;
+
+    /* make sure we start the cursor somewhere on the grid. */
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            v = state->grid[y*state->w+x];
+            if (v == GRID_PEG || v == GRID_HOLE) {
+                ui->cur_x = x; ui->cur_y = y;
+                goto found;
+            }
+        }
+    }
+    assert(!"new_ui found nowhere for cursor");
+found:
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    /*
+     * Cancel a drag, in case the source square has become
+     * unoccupied.
+     */
+    ui->dragging = FALSE;
+}
+
+#define PREFERRED_TILE_SIZE 33
+#define TILESIZE (ds->tilesize)
+#define BORDER (TILESIZE / 2)
+
+#define HIGHLIGHT_WIDTH (TILESIZE / 16)
+
+#define COORD(x)     ( BORDER + (x) * TILESIZE )
+#define FROMCOORD(x) ( ((x) + TILESIZE - BORDER) / TILESIZE - 1 )
+
+struct game_drawstate {
+    int tilesize;
+    blitter *drag_background;
+    int dragging, dragx, dragy;
+    int w, h;
+    unsigned char *grid;
+    int started;
+    int bgcolour;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->w, h = state->h;
+    char buf[80];
+
+    if (button == LEFT_BUTTON) {
+        int tx, ty;
+
+        /*
+         * Left button down: we attempt to start a drag.
+         */
+        
+        /*
+         * There certainly shouldn't be a current drag in progress,
+         * unless the midend failed to send us button events in
+         * order; it has a responsibility to always get that right,
+         * so we can legitimately punish it by failing an
+         * assertion.
+         */
+        assert(!ui->dragging);
+
+        tx = FROMCOORD(x);
+        ty = FROMCOORD(y);
+        if (tx >= 0 && tx < w && ty >= 0 && ty < h &&
+            state->grid[ty*w+tx] == GRID_PEG) {
+            ui->dragging = TRUE;
+            ui->sx = tx;
+            ui->sy = ty;
+            ui->dx = x;
+            ui->dy = y;
+            ui->cur_visible = ui->cur_jumping = 0;
+            return "";                 /* ui modified */
+        }
+    } else if (button == LEFT_DRAG && ui->dragging) {
+        /*
+         * Mouse moved; just move the peg being dragged.
+         */
+        ui->dx = x;
+        ui->dy = y;
+        return "";                     /* ui modified */
+    } else if (button == LEFT_RELEASE && ui->dragging) {
+        int tx, ty, dx, dy;
+
+        /*
+         * Button released. Identify the target square of the drag,
+         * see if it represents a valid move, and if so make it.
+         */
+        ui->dragging = FALSE;          /* cancel the drag no matter what */
+        tx = FROMCOORD(x);
+        ty = FROMCOORD(y);
+        if (tx < 0 || tx >= w || ty < 0 || ty >= h)
+            return "";                 /* target out of range */
+        dx = tx - ui->sx;
+        dy = ty - ui->sy;
+        if (max(abs(dx),abs(dy)) != 2 || min(abs(dx),abs(dy)) != 0)
+            return "";                 /* move length was wrong */
+        dx /= 2;
+        dy /= 2;
+
+        if (state->grid[ty*w+tx] != GRID_HOLE ||
+            state->grid[(ty-dy)*w+(tx-dx)] != GRID_PEG ||
+            state->grid[ui->sy*w+ui->sx] != GRID_PEG)
+            return "";                 /* grid contents were invalid */
+
+        /*
+         * We have a valid move. Encode it simply as source and
+         * destination coordinate pairs.
+         */
+        sprintf(buf, "%d,%d-%d,%d", ui->sx, ui->sy, tx, ty);
+        return dupstr(buf);
+    } else if (IS_CURSOR_MOVE(button)) {
+        if (!ui->cur_jumping) {
+            /* Not jumping; move cursor as usual, making sure we don't
+             * leave the gameboard (which may be an irregular shape) */
+            int cx = ui->cur_x, cy = ui->cur_y;
+            move_cursor(button, &cx, &cy, w, h, 0);
+            ui->cur_visible = 1;
+            if (state->grid[cy*w+cx] == GRID_HOLE ||
+                state->grid[cy*w+cx] == GRID_PEG) {
+                ui->cur_x = cx;
+                ui->cur_y = cy;
+            }
+            return "";
+        } else {
+            int dx, dy, mx, my, jx, jy;
+
+            /* We're jumping; if the requested direction has a hole, and
+             * there's a peg in the way, */
+            assert(state->grid[ui->cur_y*w+ui->cur_x] == GRID_PEG);
+            dx = (button == CURSOR_RIGHT) ? 1 : (button == CURSOR_LEFT) ? -1 : 0;
+            dy = (button == CURSOR_DOWN) ? 1 : (button == CURSOR_UP) ? -1 : 0;
+
+            mx = ui->cur_x+dx; my = ui->cur_y+dy;
+            jx = mx+dx; jy = my+dy;
+
+            ui->cur_jumping = 0; /* reset, whatever. */
+            if (jx >= 0 && jy >= 0 && jx < w && jy < h &&
+                state->grid[my*w+mx] == GRID_PEG &&
+                state->grid[jy*w+jx] == GRID_HOLE) {
+                /* Move cursor to the jumped-to location (this felt more
+                 * natural while playtesting) */
+                sprintf(buf, "%d,%d-%d,%d", ui->cur_x, ui->cur_y, jx, jy);
+                ui->cur_x = jx; ui->cur_y = jy;
+                return dupstr(buf);
+            }
+            return "";
+        }
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+        if (ui->cur_jumping) {
+            ui->cur_jumping = 0;
+            return "";
+        }
+        if (state->grid[ui->cur_y*w+ui->cur_x] == GRID_PEG) {
+            /* cursor is on peg: next arrow-move wil jump. */
+            ui->cur_jumping = 1;
+            return "";
+        }
+        return NULL;
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int w = state->w, h = state->h;
+    int sx, sy, tx, ty;
+    game_state *ret;
+
+    if (sscanf(move, "%d,%d-%d,%d", &sx, &sy, &tx, &ty) == 4) {
+        int mx, my, dx, dy;
+
+        if (sx < 0 || sx >= w || sy < 0 || sy >= h)
+            return NULL;               /* source out of range */
+        if (tx < 0 || tx >= w || ty < 0 || ty >= h)
+            return NULL;               /* target out of range */
+
+        dx = tx - sx;
+        dy = ty - sy;
+        if (max(abs(dx),abs(dy)) != 2 || min(abs(dx),abs(dy)) != 0)
+            return NULL;               /* move length was wrong */
+        mx = sx + dx/2;
+        my = sy + dy/2;
+
+        if (state->grid[sy*w+sx] != GRID_PEG ||
+            state->grid[my*w+mx] != GRID_PEG ||
+            state->grid[ty*w+tx] != GRID_HOLE)
+            return NULL;               /* grid contents were invalid */
+
+        ret = dup_game(state);
+        ret->grid[sy*w+sx] = GRID_HOLE;
+        ret->grid[my*w+mx] = GRID_HOLE;
+        ret->grid[ty*w+tx] = GRID_PEG;
+
+        /*
+         * Opinion varies on whether getting to a single peg counts as
+         * completing the game, or whether that peg has to be at a
+         * specific location (central in the classic cross game, for
+         * instance). For now we take the former, rather lax position.
+         */
+        if (!ret->completed) {
+            int count = 0, i;
+            for (i = 0; i < w*h; i++)
+                if (ret->grid[i] == GRID_PEG)
+                    count++;
+            if (count == 1)
+                ret->completed = 1;
+        }
+
+        return ret;
+    }
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = TILESIZE * params->w + 2 * BORDER;
+    *y = TILESIZE * params->h + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+
+    assert(TILESIZE > 0);
+
+    assert(!ds->drag_background);      /* set_size is never called twice */
+    ds->drag_background = blitter_new(dr, TILESIZE, TILESIZE);
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    ret[COL_PEG * 3 + 0] = 0.0F;
+    ret[COL_PEG * 3 + 1] = 0.0F;
+    ret[COL_PEG * 3 + 2] = 1.0F;
+
+    ret[COL_CURSOR * 3 + 0] = 0.5F;
+    ret[COL_CURSOR * 3 + 1] = 0.5F;
+    ret[COL_CURSOR * 3 + 2] = 1.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int w = state->w, h = state->h;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->tilesize = 0;                  /* not decided yet */
+
+    /* We can't allocate the blitter rectangle for the drag background
+     * until we know what size to make it. */
+    ds->drag_background = NULL;
+    ds->dragging = FALSE;
+
+    ds->w = w;
+    ds->h = h;
+    ds->grid = snewn(w*h, unsigned char);
+    memset(ds->grid, 255, w*h);
+
+    ds->started = FALSE;
+    ds->bgcolour = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    if (ds->drag_background)
+        blitter_free(dr, ds->drag_background);
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds,
+                      int x, int y, int v, int bgcolour)
+{
+    int cursor = 0, jumping = 0, bg;
+
+    if (bgcolour >= 0) {
+        draw_rect(dr, x, y, TILESIZE, TILESIZE, bgcolour);
+    }
+    if (v >= GRID_JUMPING) {
+        jumping = 1; v -= GRID_JUMPING;
+    }
+    if (v >= GRID_CURSOR) {
+        cursor = 1; v -= GRID_CURSOR;
+    }
+
+    if (v == GRID_HOLE) {
+        bg = cursor ? COL_HIGHLIGHT : COL_LOWLIGHT;
+        assert(!jumping); /* can't jump from a hole! */
+        draw_circle(dr, x+TILESIZE/2, y+TILESIZE/2, TILESIZE/4,
+                    bg, bg);
+    } else if (v == GRID_PEG) {
+        bg = (cursor || jumping) ? COL_CURSOR : COL_PEG;
+        draw_circle(dr, x+TILESIZE/2, y+TILESIZE/2, TILESIZE/3,
+                    bg, bg);
+        bg = (!cursor || jumping) ? COL_PEG : COL_CURSOR;
+        draw_circle(dr, x+TILESIZE/2, y+TILESIZE/2, TILESIZE/4,
+                    bg, bg);
+    }
+
+    draw_update(dr, x, y, TILESIZE, TILESIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->w, h = state->h;
+    int x, y;
+    int bgcolour;
+
+    if (flashtime > 0) {
+        int frame = (int)(flashtime / FLASH_FRAME);
+        bgcolour = (frame % 2 ? COL_LOWLIGHT : COL_HIGHLIGHT);
+    } else
+        bgcolour = COL_BACKGROUND;
+
+    /*
+     * Erase the sprite currently being dragged, if any.
+     */
+    if (ds->dragging) {
+        assert(ds->drag_background);
+        blitter_load(dr, ds->drag_background, ds->dragx, ds->dragy);
+        draw_update(dr, ds->dragx, ds->dragy, TILESIZE, TILESIZE);
+        ds->dragging = FALSE;
+    }
+
+    if (!ds->started) {
+        draw_rect(dr, 0, 0,
+                  TILESIZE * state->w + 2 * BORDER,
+                  TILESIZE * state->h + 2 * BORDER, COL_BACKGROUND);
+
+        /*
+         * Draw relief marks around all the squares that aren't
+         * GRID_OBST.
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                if (state->grid[y*w+x] != GRID_OBST) {
+                    /*
+                     * First pass: draw the full relief square.
+                     */
+                    int coords[6];
+                    coords[0] = COORD(x+1) + HIGHLIGHT_WIDTH - 1;
+                    coords[1] = COORD(y) - HIGHLIGHT_WIDTH;
+                    coords[2] = COORD(x) - HIGHLIGHT_WIDTH;
+                    coords[3] = COORD(y+1) + HIGHLIGHT_WIDTH - 1;
+                    coords[4] = COORD(x) - HIGHLIGHT_WIDTH;
+                    coords[5] = COORD(y) - HIGHLIGHT_WIDTH;
+                    draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+                    coords[4] = COORD(x+1) + HIGHLIGHT_WIDTH - 1;
+                    coords[5] = COORD(y+1) + HIGHLIGHT_WIDTH - 1;
+                    draw_polygon(dr, coords, 3, COL_LOWLIGHT, COL_LOWLIGHT);
+                }
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                if (state->grid[y*w+x] != GRID_OBST) {
+                    /*
+                     * Second pass: draw everything but the two
+                     * diagonal corners.
+                     */
+                    draw_rect(dr, COORD(x) - HIGHLIGHT_WIDTH,
+                              COORD(y) - HIGHLIGHT_WIDTH,
+                              TILESIZE + HIGHLIGHT_WIDTH,
+                              TILESIZE + HIGHLIGHT_WIDTH, COL_HIGHLIGHT);
+                    draw_rect(dr, COORD(x),
+                              COORD(y),
+                              TILESIZE + HIGHLIGHT_WIDTH,
+                              TILESIZE + HIGHLIGHT_WIDTH, COL_LOWLIGHT);
+                }
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                if (state->grid[y*w+x] != GRID_OBST) {
+                    /*
+                     * Third pass: draw a trapezium on each edge.
+                     */
+                    int coords[8];
+                    int dx, dy, s, sn, c;
+
+                    for (dx = 0; dx < 2; dx++) {
+                        dy = 1 - dx;
+                        for (s = 0; s < 2; s++) {
+                            sn = 2*s - 1;
+                            c = s ? COL_LOWLIGHT : COL_HIGHLIGHT;
+
+                            coords[0] = COORD(x) + (s*dx)*(TILESIZE-1);
+                            coords[1] = COORD(y) + (s*dy)*(TILESIZE-1);
+                            coords[2] = COORD(x) + (s*dx+dy)*(TILESIZE-1);
+                            coords[3] = COORD(y) + (s*dy+dx)*(TILESIZE-1);
+                            coords[4] = coords[2] - HIGHLIGHT_WIDTH * (dy-sn*dx);
+                            coords[5] = coords[3] - HIGHLIGHT_WIDTH * (dx-sn*dy);
+                            coords[6] = coords[0] + HIGHLIGHT_WIDTH * (dy+sn*dx);
+                            coords[7] = coords[1] + HIGHLIGHT_WIDTH * (dx+sn*dy);
+                            draw_polygon(dr, coords, 4, c, c);
+                        }
+                    }
+                }
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                if (state->grid[y*w+x] != GRID_OBST) {
+                    /*
+                     * Second pass: draw everything but the two
+                     * diagonal corners.
+                     */
+                    draw_rect(dr, COORD(x),
+                              COORD(y),
+                              TILESIZE,
+                              TILESIZE, COL_BACKGROUND);
+                }
+
+        ds->started = TRUE;
+
+        draw_update(dr, 0, 0,
+                    TILESIZE * state->w + 2 * BORDER,
+                    TILESIZE * state->h + 2 * BORDER);
+    }
+
+    /*
+     * Loop over the grid redrawing anything that looks as if it
+     * needs it.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int v;
+
+            v = state->grid[y*w+x];
+            /*
+             * Blank the source of a drag so it looks as if the
+             * user picked the peg up physically.
+             */
+            if (ui->dragging && ui->sx == x && ui->sy == y && v == GRID_PEG)
+                v = GRID_HOLE;
+
+            if (ui->cur_visible && ui->cur_x == x && ui->cur_y == y)
+                v += ui->cur_jumping ? GRID_JUMPING : GRID_CURSOR;
+
+            if (v != GRID_OBST &&
+                (bgcolour != ds->bgcolour || /* always redraw when flashing */
+                 v != ds->grid[y*w+x])) {
+                draw_tile(dr, ds, COORD(x), COORD(y), v, bgcolour);
+                ds->grid[y*w+x] = v;
+            }
+        }
+
+    /*
+     * Draw the dragging sprite if any.
+     */
+    if (ui->dragging) {
+        ds->dragging = TRUE;
+        ds->dragx = ui->dx - TILESIZE/2;
+        ds->dragy = ui->dy - TILESIZE/2;
+        blitter_save(dr, ds->drag_background, ds->dragx, ds->dragy);
+        draw_tile(dr, ds, ds->dragx, ds->dragy, GRID_PEG, -1);
+    }
+
+    ds->bgcolour = bgcolour;
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed)
+        return 2 * FLASH_FRAME;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    /*
+     * Dead-end situations are assumed to be rescuable by Undo, so we
+     * don't bother to identify them and return -1.
+     */
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame pegs
+#endif
+
+const struct game thegame = {
+    "Pegs", "games.pegs", "pegs",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    FALSE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/penrose.c b/apps/plugins/puzzles/penrose.c
new file mode 100644
index 0000000000..839b50a853
--- /dev/null
+++ b/apps/plugins/puzzles/penrose.c
@@ -0,0 +1,629 @@
+/* penrose.c
+ *
+ * Penrose tile generator.
+ *
+ * Uses half-tile technique outlined on:
+ *
+ * http://tartarus.org/simon/20110412-penrose/penrose.xhtml
+ */
+
+#include "rbassert.h"
+#include <string.h>
+#include <math.h>
+#include <stdio.h>
+
+#include "puzzles.h" /* for malloc routines, and PI */
+#include "penrose.h"
+
+/* -------------------------------------------------------
+ * 36-degree basis vector arithmetic routines.
+ */
+
+/* Imagine drawing a
+ * ten-point 'clock face' like this:
+ *
+ *                     -E
+ *                 -D   |   A
+ *                   \  |  /
+ *              -C.   \ | /   ,B
+ *                 `-._\|/_,-'
+ *                 ,-' /|\ `-.
+ *              -B'   / | \   `C
+ *                   /  |  \
+ *                 -A   |   D
+ *                      E
+ *
+ * In case the ASCII art isn't clear, those are supposed to be ten
+ * vectors of length 1, all sticking out from the origin at equal
+ * angular spacing (hence 36 degrees). Our basis vectors are A,B,C,D (I
+ * choose them to be symmetric about the x-axis so that the final
+ * translation into 2d coordinates will also be symmetric, which I
+ * think will avoid minor rounding uglinesses), so our vector
+ * representation sets
+ *
+ *   A = (1,0,0,0)
+ *   B = (0,1,0,0)
+ *   C = (0,0,1,0)
+ *   D = (0,0,0,1)
+ *
+ * The fifth vector E looks at first glance as if it needs to be
+ * another basis vector, but in fact it doesn't, because it can be
+ * represented in terms of the other four. Imagine starting from the
+ * origin and following the path -A, +B, -C, +D: you'll find you've
+ * traced four sides of a pentagram, and ended up one E-vector away
+ * from the origin. So we have
+ *
+ *   E = (-1,1,-1,1)
+ *
+ * This tells us that we can rotate any vector in this system by 36
+ * degrees: if we start with a*A + b*B + c*C + d*D, we want to end up
+ * with a*B + b*C + c*D + d*E, and we substitute our identity for E to
+ * turn that into a*B + b*C + c*D + d*(-A+B-C+D). In other words,
+ *
+ *   rotate_one_notch_clockwise(a,b,c,d) = (-d, d+a, -d+b, d+c)
+ *
+ * and you can verify for yourself that applying that operation
+ * repeatedly starting with (1,0,0,0) cycles round ten vectors and
+ * comes back to where it started.
+ *
+ * The other operation that may be required is to construct vectors
+ * with lengths that are multiples of phi. That can be done by
+ * observing that the vector C-B is parallel to E and has length 1/phi,
+ * and the vector D-A is parallel to E and has length phi. So this
+ * tells us that given any vector, we can construct one which points in
+ * the same direction and is 1/phi or phi times its length, like this:
+ *
+ *   divide_by_phi(vector) = rotate(vector, 2) - rotate(vector, 3)
+ *   multiply_by_phi(vector) = rotate(vector, 1) - rotate(vector, 4)
+ *
+ * where rotate(vector, n) means applying the above
+ * rotate_one_notch_clockwise primitive n times. Expanding out the
+ * applications of rotate gives the following direct representation in
+ * terms of the vector coordinates:
+ *
+ *   divide_by_phi(a,b,c,d) = (b-d, c+d-b, a+b-c, c-a)
+ *   multiply_by_phi(a,b,c,d) = (a+b-d, c+d, a+b, c+d-a)
+ *
+ * and you can verify for yourself that those two operations are
+ * inverses of each other (as you'd hope!).
+ *
+ * Having done all of this, testing for equality between two vectors is
+ * a trivial matter of comparing the four integer coordinates. (Which
+ * it _wouldn't_ have been if we'd kept E as a fifth basis vector,
+ * because then (-1,1,-1,1,0) and (0,0,0,0,1) would have had to be
+ * considered identical. So leaving E out is vital.)
+ */
+
+struct vector { int a, b, c, d; };
+
+static vector v_origin(void)
+{
+    vector v;
+    v.a = v.b = v.c = v.d = 0;
+    return v;
+}
+
+/* We start with a unit vector of B: this means we can easily
+ * draw an isoceles triangle centred on the X axis. */
+#ifdef TEST_VECTORS
+
+static vector v_unit(void)
+{
+    vector v;
+
+    v.b = 1;
+    v.a = v.c = v.d = 0;
+    return v;
+}
+
+#endif
+
+#define COS54 0.5877852
+#define SIN54 0.8090169
+#define COS18 0.9510565
+#define SIN18 0.3090169
+
+/* These two are a bit rough-and-ready for now. Note that B/C are
+ * 18 degrees from the x-axis, and A/D are 54 degrees. */
+double v_x(vector *vs, int i)
+{
+    return (vs[i].a + vs[i].d) * COS54 +
+           (vs[i].b + vs[i].c) * COS18;
+}
+
+double v_y(vector *vs, int i)
+{
+    return (vs[i].a - vs[i].d) * SIN54 +
+           (vs[i].b - vs[i].c) * SIN18;
+
+}
+
+static vector v_trans(vector v, vector trans)
+{
+    v.a += trans.a;
+    v.b += trans.b;
+    v.c += trans.c;
+    v.d += trans.d;
+    return v;
+}
+
+static vector v_rotate_36(vector v)
+{
+    vector vv;
+    vv.a = -v.d;
+    vv.b =  v.d + v.a;
+    vv.c = -v.d + v.b;
+    vv.d =  v.d + v.c;
+    return vv;
+}
+
+static vector v_rotate(vector v, int ang)
+{
+    int i;
+
+    assert((ang % 36) == 0);
+    while (ang < 0) ang += 360;
+    ang = 360-ang;
+    for (i = 0; i < (ang/36); i++)
+        v = v_rotate_36(v);
+    return v;
+}
+
+#ifdef TEST_VECTORS
+
+static vector v_scale(vector v, int sc)
+{
+    v.a *= sc;
+    v.b *= sc;
+    v.c *= sc;
+    v.d *= sc;
+    return v;
+}
+
+#endif
+
+static vector v_growphi(vector v)
+{
+    vector vv;
+    vv.a = v.a + v.b - v.d;
+    vv.b = v.c + v.d;
+    vv.c = v.a + v.b;
+    vv.d = v.c + v.d - v.a;
+    return vv;
+}
+
+static vector v_shrinkphi(vector v)
+{
+    vector vv;
+    vv.a = v.b - v.d;
+    vv.b = v.c + v.d - v.b;
+    vv.c = v.a + v.b - v.c;
+    vv.d = v.c - v.a;
+    return vv;
+}
+
+#ifdef TEST_VECTORS
+
+static const char *v_debug(vector v)
+{
+    static char buf[255];
+    sprintf(buf,
+             "(%d,%d,%d,%d)[%2.2f,%2.2f]",
+             v.a, v.b, v.c, v.d, v_x(&v,0), v_y(&v,0));
+    return buf;
+}
+
+#endif
+
+/* -------------------------------------------------------
+ * Tiling routines.
+ */
+
+static vector xform_coord(vector vo, int shrink, vector vtrans, int ang)
+{
+    if (shrink < 0)
+        vo = v_shrinkphi(vo);
+    else if (shrink > 0)
+        vo = v_growphi(vo);
+
+    vo = v_rotate(vo, ang);
+    vo = v_trans(vo, vtrans);
+
+    return vo;
+}
+
+
+#define XFORM(n,o,s,a) vs[(n)] = xform_coord(v_edge, (s), vs[(o)], (a))
+
+static int penrose_p2_small(penrose_state *state, int depth, int flip,
+                            vector v_orig, vector v_edge);
+
+static int penrose_p2_large(penrose_state *state, int depth, int flip,
+                            vector v_orig, vector v_edge)
+{
+    vector vv_orig, vv_edge;
+
+#ifdef DEBUG_PENROSE
+    {
+        vector vs[3];
+        vs[0] = v_orig;
+        XFORM(1, 0, 0, 0);
+        XFORM(2, 0, 0, -36*flip);
+
+        state->new_tile(state, vs, 3, depth);
+    }
+#endif
+
+    if (flip > 0) {
+        vector vs[4];
+
+        vs[0] = v_orig;
+        XFORM(1, 0, 0, -36);
+        XFORM(2, 0, 0, 0);
+        XFORM(3, 0, 0, 36);
+
+        state->new_tile(state, vs, 4, depth);
+    }
+    if (depth >= state->max_depth) return 0;
+
+    vv_orig = v_trans(v_orig, v_rotate(v_edge, -36*flip));
+    vv_edge = v_rotate(v_edge, 108*flip);
+
+    penrose_p2_small(state, depth+1, flip,
+                     v_orig, v_shrinkphi(v_edge));
+
+    penrose_p2_large(state, depth+1, flip,
+                     vv_orig, v_shrinkphi(vv_edge));
+    penrose_p2_large(state, depth+1, -flip,
+                     vv_orig, v_shrinkphi(vv_edge));
+
+    return 0;
+}
+
+static int penrose_p2_small(penrose_state *state, int depth, int flip,
+                            vector v_orig, vector v_edge)
+{
+    vector vv_orig;
+
+#ifdef DEBUG_PENROSE
+    {
+        vector vs[3];
+        vs[0] = v_orig;
+        XFORM(1, 0, 0, 0);
+        XFORM(2, 0, -1, -36*flip);
+
+        state->new_tile(state, vs, 3, depth);
+    }
+#endif
+
+    if (flip > 0) {
+        vector vs[4];
+
+        vs[0] = v_orig;
+        XFORM(1, 0, 0, -72);
+        XFORM(2, 0, -1, -36);
+        XFORM(3, 0, 0, 0);
+
+        state->new_tile(state, vs, 4, depth);
+    }
+
+    if (depth >= state->max_depth) return 0;
+
+    vv_orig = v_trans(v_orig, v_edge);
+
+    penrose_p2_large(state, depth+1, -flip,
+                     v_orig, v_shrinkphi(v_rotate(v_edge, -36*flip)));
+
+    penrose_p2_small(state, depth+1, flip,
+                     vv_orig, v_shrinkphi(v_rotate(v_edge, -144*flip)));
+
+    return 0;
+}
+
+static int penrose_p3_small(penrose_state *state, int depth, int flip,
+                            vector v_orig, vector v_edge);
+
+static int penrose_p3_large(penrose_state *state, int depth, int flip,
+                            vector v_orig, vector v_edge)
+{
+    vector vv_orig;
+
+#ifdef DEBUG_PENROSE
+    {
+        vector vs[3];
+        vs[0] = v_orig;
+        XFORM(1, 0, 1, 0);
+        XFORM(2, 0, 0, -36*flip);
+
+        state->new_tile(state, vs, 3, depth);
+    }
+#endif
+
+    if (flip > 0) {
+        vector vs[4];
+
+        vs[0] = v_orig;
+        XFORM(1, 0, 0, -36);
+        XFORM(2, 0, 1, 0);
+        XFORM(3, 0, 0, 36);
+
+        state->new_tile(state, vs, 4, depth);
+    }
+    if (depth >= state->max_depth) return 0;
+
+    vv_orig = v_trans(v_orig, v_edge);
+
+    penrose_p3_large(state, depth+1, -flip,
+                     vv_orig, v_shrinkphi(v_rotate(v_edge, 180)));
+
+    penrose_p3_small(state, depth+1, flip,
+                     vv_orig, v_shrinkphi(v_rotate(v_edge, -108*flip)));
+
+    vv_orig = v_trans(v_orig, v_growphi(v_edge));
+
+    penrose_p3_large(state, depth+1, flip,
+                     vv_orig, v_shrinkphi(v_rotate(v_edge, -144*flip)));
+
+
+    return 0;
+}
+
+static int penrose_p3_small(penrose_state *state, int depth, int flip,
+                            vector v_orig, vector v_edge)
+{
+    vector vv_orig;
+
+#ifdef DEBUG_PENROSE
+    {
+        vector vs[3];
+        vs[0] = v_orig;
+        XFORM(1, 0, 0, 0);
+        XFORM(2, 0, 0, -36*flip);
+
+        state->new_tile(state, vs, 3, depth);
+    }
+#endif
+
+    if (flip > 0) {
+        vector vs[4];
+
+        vs[0] = v_orig;
+        XFORM(1, 0, 0, -36);
+        XFORM(3, 0, 0, 0);
+        XFORM(2, 3, 0, -36);
+
+        state->new_tile(state, vs, 4, depth);
+    }
+    if (depth >= state->max_depth) return 0;
+
+    /* NB these two are identical to the first two of p3_large. */
+    vv_orig = v_trans(v_orig, v_edge);
+
+    penrose_p3_large(state, depth+1, -flip,
+                     vv_orig, v_shrinkphi(v_rotate(v_edge, 180)));
+
+    penrose_p3_small(state, depth+1, flip,
+                     vv_orig, v_shrinkphi(v_rotate(v_edge, -108*flip)));
+
+    return 0;
+}
+
+/* -------------------------------------------------------
+ * Utility routines.
+ */
+
+double penrose_side_length(double start_size, int depth)
+{
+  return start_size / pow(PHI, depth);
+}
+
+void penrose_count_tiles(int depth, int *nlarge, int *nsmall)
+{
+  /* Steal sgt's fibonacci thingummy. */
+}
+
+/*
+ * It turns out that an acute isosceles triangle with sides in ratio 1:phi:phi
+ * has an incentre which is conveniently 2*phi^-2 of the way from the apex to
+ * the base. Why's that convenient? Because: if we situate the incentre of the
+ * triangle at the origin, then we can place the apex at phi^-2 * (B+C), and
+ * the other two vertices at apex-B and apex-C respectively. So that's an acute
+ * triangle with its long sides of unit length, covering a circle about the
+ * origin of radius 1-(2*phi^-2), which is conveniently enough phi^-3.
+ *
+ * (later mail: this is an overestimate by about 5%)
+ */
+
+int penrose(penrose_state *state, int which, int angle)
+{
+    vector vo = v_origin();
+    vector vb = v_origin();
+
+    vo.b = vo.c = -state->start_size;
+    vo = v_shrinkphi(v_shrinkphi(vo));
+
+    vb.b = state->start_size;
+
+    vo = v_rotate(vo, angle);
+    vb = v_rotate(vb, angle);
+
+    if (which == PENROSE_P2)
+        return penrose_p2_large(state, 0, 1, vo, vb);
+    else
+        return penrose_p3_small(state, 0, 1, vo, vb);
+}
+
+/*
+ * We're asked for a MxN grid, which just means a tiling fitting into roughly
+ * an MxN space in some kind of reasonable unit - say, the side length of the
+ * two-arrow edges of the tiles. By some reasoning in a previous email, that
+ * means we want to pick some subarea of a circle of radius 3.11*sqrt(M^2+N^2).
+ * To cover that circle, we need to subdivide a triangle large enough that it
+ * contains a circle of that radius.
+ *
+ * Hence: start with those three vectors marking triangle vertices, scale them
+ * all up by phi repeatedly until the radius of the inscribed circle gets
+ * bigger than the target, and then recurse into that triangle with the same
+ * recursion depth as the number of times you scaled up. That will give you
+ * tiles of unit side length, covering a circle big enough that if you randomly
+ * choose an orientation and coordinates within the circle, you'll be able to
+ * get any valid piece of Penrose tiling of size MxN.
+ */
+#define INCIRCLE_RADIUS 0.22426 /* phi^-3 less 5%: see above */
+
+void penrose_calculate_size(int which, int tilesize, int w, int h,
+                            double *required_radius, int *start_size, int *depth)
+{
+    double rradius, size;
+    int n = 0;
+
+    /*
+     * Fudge factor to scale P2 and P3 tilings differently. This
+     * doesn't seem to have much relevance to questions like the
+     * average number of tiles per unit area; it's just aesthetic.
+     */
+    if (which == PENROSE_P2)
+        tilesize = tilesize * 3 / 2;
+    else
+        tilesize = tilesize * 5 / 4;
+
+    rradius = tilesize * 3.11 * sqrt((double)(w*w + h*h));
+    size = tilesize;
+
+    while ((size * INCIRCLE_RADIUS) < rradius) {
+        n++;
+        size = size * PHI;
+    }
+
+    *start_size = (int)size;
+    *depth = n;
+    *required_radius = rradius;
+}
+
+/* -------------------------------------------------------
+ * Test code.
+ */
+
+#ifdef TEST_PENROSE
+
+#include <stdio.h>
+#include <string.h>
+
+int show_recursion = 0;
+int ntiles, nfinal;
+
+int test_cb(penrose_state *state, vector *vs, int n, int depth)
+{
+    int i, xoff = 0, yoff = 0;
+    double l = penrose_side_length(state->start_size, depth);
+    double rball = l / 10.0;
+    const char *col;
+
+    ntiles++;
+    if (state->max_depth == depth) {
+        col = n == 4 ? "black" : "green";
+        nfinal++;
+    } else {
+        if (!show_recursion)
+            return 0;
+        col = n == 4 ? "red" : "blue";
+    }
+    if (n != 4) yoff = state->start_size;
+
+    printf("<polygon points=\"");
+    for (i = 0; i < n; i++) {
+        printf("%s%f,%f", (i == 0) ? "" : " ",
+               v_x(vs, i) + xoff, v_y(vs, i) + yoff);
+    }
+    printf("\" style=\"fill: %s; fill-opacity: 0.2; stroke: %s\" />\n", col, col);
+    printf("<ellipse cx=\"%f\" cy=\"%f\" rx=\"%f\" ry=\"%f\" fill=\"%s\" />",
+           v_x(vs, 0) + xoff, v_y(vs, 0) + yoff, rball, rball, col);
+
+    return 0;
+}
+
+void usage_exit(void)
+{
+    fprintf(stderr, "Usage: penrose-test [--recursion] P2|P3 SIZE DEPTH\n");
+    exit(1);
+}
+
+int main(int argc, char *argv[])
+{
+    penrose_state ps;
+    int which = 0;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-h") || !strcmp(p, "--help")) {
+            usage_exit();
+        } else if (!strcmp(p, "--recursion")) {
+            show_recursion = 1;
+        } else if (*p == '-') {
+            fprintf(stderr, "Unrecognised option '%s'\n", p);
+            exit(1);
+        } else {
+            break;
+        }
+    }
+
+    if (argc < 3) usage_exit();
+
+    if (strcmp(argv[0], "P2") == 0) which = PENROSE_P2;
+    else if (strcmp(argv[0], "P3") == 0) which = PENROSE_P3;
+    else usage_exit();
+
+    ps.start_size = atoi(argv[1]);
+    ps.max_depth = atoi(argv[2]);
+    ps.new_tile = test_cb;
+
+    ntiles = nfinal = 0;
+
+    printf("\
+<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n\
+<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 20010904//EN\"\n\
+\"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n\
+\n\
+<svg xmlns=\"http://www.w3.org/2000/svg\"\n\
+xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n\n");
+
+    printf("<g>\n");
+    penrose(&ps, which);
+    printf("</g>\n");
+
+    printf("<!-- %d tiles and %d leaf tiles total -->\n",
+           ntiles, nfinal);
+
+    printf("</svg>");
+
+    return 0;
+}
+
+#endif
+
+#ifdef TEST_VECTORS
+
+static void dbgv(const char *msg, vector v)
+{
+    printf("%s: %s\n", msg, v_debug(v));
+}
+
+int main(int argc, const char *argv[])
+{
+   vector v = v_unit();
+
+   dbgv("unit vector", v);
+   v = v_rotate(v, 36);
+   dbgv("rotated 36", v);
+   v = v_scale(v, 2);
+   dbgv("scaled x2", v);
+   v = v_shrinkphi(v);
+   dbgv("shrunk phi", v);
+   v = v_rotate(v, -36);
+   dbgv("rotated -36", v);
+
+   return 0;
+}
+
+#endif
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/penrose.h b/apps/plugins/puzzles/penrose.h
new file mode 100644
index 0000000000..ba5ae16f2c
--- /dev/null
+++ b/apps/plugins/puzzles/penrose.h
@@ -0,0 +1,59 @@
+/* penrose.h
+ *
+ * Penrose tiling functions.
+ *
+ * Provides an interface with which to generate Penrose tilings
+ * by recursive subdivision of an initial tile of choice (one of the
+ * four sets of two pairs kite/dart, or thin/thick rhombus).
+ *
+ * You supply a callback function and a context pointer, which is
+ * called with each tile in turn: you choose how many times to recurse.
+ */
+
+#ifndef _PENROSE_H
+#define _PENROSE_H
+
+#ifndef PHI
+#define PHI 1.6180339887
+#endif
+
+typedef struct vector vector;
+
+double v_x(vector *vs, int i);
+double v_y(vector *vs, int i);
+
+typedef struct penrose_state penrose_state;
+
+/* Return non-zero to clip the tree here (i.e. not recurse
+ * below this tile).
+ *
+ * Parameters are state, vector array, npoints, depth.
+ * ctx is inside state.
+ */
+typedef int (*tile_callback)(penrose_state *, vector *, int, int);
+
+struct penrose_state {
+    int start_size;  /* initial side length */
+    int max_depth;      /* Recursion depth */
+
+    tile_callback new_tile;
+    void *ctx;          /* for callback */
+};
+
+enum { PENROSE_P2, PENROSE_P3 };
+
+extern int penrose(penrose_state *state, int which, int angle);
+
+/* Returns the side-length of a penrose tile at recursion level
+ * gen, given a starting side length. */
+extern double penrose_side_length(double start_size, int depth);
+
+/* Returns the count of each type of tile at a given recursion depth. */
+extern void penrose_count_tiles(int gen, int *nlarge, int *nsmall);
+
+/* Calculate start size and recursion depth required to produce a
+ * width-by-height sized patch of penrose tiles with the given tilesize */
+extern void penrose_calculate_size(int which, int tilesize, int w, int h,
+                                   double *required_radius, int *start_size, int *depth);
+
+#endif
diff --git a/apps/plugins/puzzles/printing.c b/apps/plugins/puzzles/printing.c
new file mode 100644
index 0000000000..e921a4d545
--- /dev/null
+++ b/apps/plugins/puzzles/printing.c
@@ -0,0 +1,247 @@
+/*
+ * printing.c: Cross-platform printing manager. Handles document
+ * setup and layout.
+ */
+
+#include "puzzles.h"
+
+struct puzzle {
+    const game *game;
+    game_params *par;
+    game_state *st;
+    game_state *st2;
+};
+
+struct document {
+    int pw, ph;
+    int npuzzles;
+    struct puzzle *puzzles;
+    int puzzlesize;
+    int got_solns;
+    float *colwid, *rowht;
+    float userscale;
+};
+
+/*
+ * Create a new print document. pw and ph are the layout
+ * parameters: they state how many puzzles will be printed across
+ * the page, and down the page.
+ */
+document *document_new(int pw, int ph, float userscale)
+{
+    document *doc = snew(document);
+
+    doc->pw = pw;
+    doc->ph = ph;
+    doc->puzzles = NULL;
+    doc->puzzlesize = doc->npuzzles = 0;
+    doc->got_solns = FALSE;
+
+    doc->colwid = snewn(pw, float);
+    doc->rowht = snewn(ph, float);
+
+    doc->userscale = userscale;
+
+    return doc;
+}
+
+/*
+ * Free a document structure, whether it's been printed or not.
+ */
+void document_free(document *doc)
+{
+    int i;
+
+    for (i = 0; i < doc->npuzzles; i++) {
+        doc->puzzles[i].game->free_params(doc->puzzles[i].par);
+        doc->puzzles[i].game->free_game(doc->puzzles[i].st);
+        if (doc->puzzles[i].st2)
+            doc->puzzles[i].game->free_game(doc->puzzles[i].st2);
+    }
+
+    sfree(doc->colwid);
+    sfree(doc->rowht);
+
+    sfree(doc->puzzles);
+    sfree(doc);
+}
+
+/*
+ * Called from midend.c to add a puzzle to be printed. Provides a
+ * game_params (for initial layout computation), a game_state, and
+ * optionally a second game_state to be printed in parallel on
+ * another sheet (typically the solution to the first game_state).
+ */
+void document_add_puzzle(document *doc, const game *game, game_params *par,
+                         game_state *st, game_state *st2)
+{
+    if (doc->npuzzles >= doc->puzzlesize) {
+        doc->puzzlesize += 32;
+        doc->puzzles = sresize(doc->puzzles, doc->puzzlesize, struct puzzle);
+    }
+    doc->puzzles[doc->npuzzles].game = game;
+    doc->puzzles[doc->npuzzles].par = par;
+    doc->puzzles[doc->npuzzles].st = st;
+    doc->puzzles[doc->npuzzles].st2 = st2;
+    doc->npuzzles++;
+    if (st2)
+        doc->got_solns = TRUE;
+}
+
+static void get_puzzle_size(document *doc, struct puzzle *pz,
+                            float *w, float *h, float *scale)
+{
+    float ww, hh, ourscale;
+
+    /* Get the preferred size of the game, in mm. */
+    pz->game->print_size(pz->par, &ww, &hh);
+
+    /* Adjust for user-supplied scale factor. */
+    ourscale = doc->userscale;
+
+    /*
+     * FIXME: scale it down here if it's too big for the page size.
+     * Rather than do complicated things involving scaling all
+     * columns down in proportion, the simplest approach seems to
+     * me to be to scale down until the game fits within one evenly
+     * divided cell of the page (i.e. width/pw by height/ph).
+     * 
+     * In order to do this step we need the page size available.
+     */
+
+    *scale = ourscale;
+    *w = ww * ourscale;
+    *h = hh * ourscale;
+}
+
+/*
+ * Having accumulated a load of puzzles, actually do the printing.
+ */
+void document_print(document *doc, drawing *dr)
+{
+    int ppp;                           /* puzzles per page */
+    int pages, passes;
+    int page, pass;
+    int pageno;
+
+    ppp = doc->pw * doc->ph;
+    pages = (doc->npuzzles + ppp - 1) / ppp;
+    passes = (doc->got_solns ? 2 : 1);
+
+    print_begin_doc(dr, pages * passes);
+
+    pageno = 1;
+    for (pass = 0; pass < passes; pass++) {
+        for (page = 0; page < pages; page++) {
+            int i, n, offset;
+            float colsum, rowsum;
+
+            print_begin_page(dr, pageno);
+
+            offset = page * ppp;
+            n = min(ppp, doc->npuzzles - offset);
+
+            for (i = 0; i < doc->pw; i++)
+                doc->colwid[i] = 0;
+            for (i = 0; i < doc->ph; i++)
+                doc->rowht[i] = 0;
+
+            /*
+             * Lay the page out by computing all the puzzle sizes.
+             */
+            for (i = 0; i < n; i++) {
+                struct puzzle *pz = doc->puzzles + offset + i;
+                int x = i % doc->pw, y = i / doc->pw;
+                float w, h, scale;
+
+                get_puzzle_size(doc, pz, &w, &h, &scale);
+
+                /* Update the maximum width/height of this column. */
+                doc->colwid[x] = max(doc->colwid[x], w);
+                doc->rowht[y] = max(doc->rowht[y], h);
+            }
+
+            /*
+             * Add up the maximum column/row widths to get the
+             * total amount of space used up by puzzles on the
+             * page. We will use this to compute gutter widths.
+             */
+            colsum = 0.0;
+            for (i = 0; i < doc->pw; i++)
+                colsum += doc->colwid[i];
+            rowsum = 0.0;
+            for (i = 0; i < doc->ph; i++)
+                rowsum += doc->rowht[i];
+
+            /*
+             * Now do the printing.
+             */
+            for (i = 0; i < n; i++) {
+                struct puzzle *pz = doc->puzzles + offset + i;
+                int x = i % doc->pw, y = i / doc->pw, j;
+                float w, h, scale, xm, xc, ym, yc;
+                int pixw, pixh, tilesize;
+
+                if (pass == 1 && !pz->st2)
+                    continue;          /* nothing to do */
+
+                /*
+                 * The total amount of gutter space is the page
+                 * width minus colsum. This is divided into pw+1
+                 * gutters, so the amount of horizontal gutter
+                 * space appearing to the left of this puzzle
+                 * column is
+                 * 
+                 *   (width-colsum) * (x+1)/(pw+1)
+                 * = width * (x+1)/(pw+1) - (colsum * (x+1)/(pw+1))
+                 */
+                xm = (float)(x+1) / (doc->pw + 1);
+                xc = -xm * colsum;
+                /* And similarly for y. */
+                ym = (float)(y+1) / (doc->ph + 1);
+                yc = -ym * rowsum;
+
+                /*
+                 * However, the amount of space to the left of this
+                 * puzzle isn't just gutter space: we must also
+                 * count the widths of all the previous columns.
+                 */
+                for (j = 0; j < x; j++)
+                    xc += doc->colwid[j];
+                /* And similarly for rows. */
+                for (j = 0; j < y; j++)
+                    yc += doc->rowht[j];
+
+                /*
+                 * Now we adjust for this _specific_ puzzle, which
+                 * means centring it within the cell we've just
+                 * computed.
+                 */
+                get_puzzle_size(doc, pz, &w, &h, &scale);
+                xc += (doc->colwid[x] - w) / 2;
+                yc += (doc->rowht[y] - h) / 2;
+
+                /*
+                 * And now we know where and how big we want to
+                 * print the puzzle, just go ahead and do so. For
+                 * the moment I'll pick a standard pixel tile size
+                 * of 512.
+                 * 
+                 * (FIXME: would it be better to pick this value
+                 * with reference to the printer resolution? Or
+                 * permit each game to choose its own?)
+                 */
+                tilesize = 512;
+                pz->game->compute_size(pz->par, tilesize, &pixw, &pixh);
+                print_begin_puzzle(dr, xm, xc, ym, yc, pixw, pixh, w, scale);
+                pz->game->print(dr, pass == 0 ? pz->st : pz->st2, tilesize);
+                print_end_puzzle(dr);
+            }
+
+            print_end_page(dr, pageno);
+            pageno++;
+        }
+    }
+
+    print_end_doc(dr);
+}
diff --git a/apps/plugins/puzzles/ps.c b/apps/plugins/puzzles/ps.c
new file mode 100644
index 0000000000..67d76b4daa
--- /dev/null
+++ b/apps/plugins/puzzles/ps.c
@@ -0,0 +1,433 @@
+/*
+ * ps.c: PostScript printing functions.
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include "rbassert.h"
+
+#include "puzzles.h"
+
+#define ROOT2 1.414213562
+
+struct psdata {
+    FILE *fp;
+    int colour;
+    int ytop;
+    int clipped;
+    float hatchthick, hatchspace;
+    int gamewidth, gameheight;
+    drawing *drawing;
+};
+
+static void ps_printf(psdata *ps, char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    vfprintf(ps->fp, fmt, ap);
+    va_end(ap);
+}
+
+static void ps_fill(psdata *ps, int colour)
+{
+    int hatch;
+    float r, g, b;
+
+    print_get_colour(ps->drawing, colour, ps->colour, &hatch, &r, &g, &b);
+
+    if (hatch < 0) {
+        if (ps->colour)
+            ps_printf(ps, "%g %g %g setrgbcolor fill\n", r, g, b);
+        else
+            ps_printf(ps, "%g setgray fill\n", r);
+    } else {
+        /* Clip to the region. */
+        ps_printf(ps, "gsave clip\n");
+        /* Hatch the entire game printing area. */
+        ps_printf(ps, "newpath\n");
+        if (hatch == HATCH_VERT || hatch == HATCH_PLUS)
+            ps_printf(ps, "0 %g %d {\n"
+                      "  0 moveto 0 %d rlineto\n"
+                      "} for\n", ps->hatchspace, ps->gamewidth,
+                      ps->gameheight);
+        if (hatch == HATCH_HORIZ || hatch == HATCH_PLUS)
+            ps_printf(ps, "0 %g %d {\n"
+                      "  0 exch moveto %d 0 rlineto\n"
+                      "} for\n", ps->hatchspace, ps->gameheight,
+                      ps->gamewidth);
+        if (hatch == HATCH_SLASH || hatch == HATCH_X)
+            ps_printf(ps, "%d %g %d {\n"
+                      "  0 moveto %d dup rlineto\n"
+                      "} for\n", -ps->gameheight, ps->hatchspace * ROOT2,
+                      ps->gamewidth, max(ps->gamewidth, ps->gameheight));
+        if (hatch == HATCH_BACKSLASH || hatch == HATCH_X)
+            ps_printf(ps, "0 %g %d {\n"
+                      "  0 moveto %d neg dup neg rlineto\n"
+                      "} for\n", ps->hatchspace * ROOT2,
+                      ps->gamewidth+ps->gameheight,
+                      max(ps->gamewidth, ps->gameheight));
+        ps_printf(ps, "0 setgray %g setlinewidth stroke grestore\n",
+                  ps->hatchthick);
+    }
+}
+
+static void ps_setcolour_internal(psdata *ps, int colour, char *suffix)
+{
+    int hatch;
+    float r, g, b;
+
+    print_get_colour(ps->drawing, colour, ps->colour, &hatch, &r, &g, &b);
+
+    /*
+     * Stroking in hatched colours is not permitted.
+     */
+    assert(hatch < 0);
+    
+    if (ps->colour)
+        ps_printf(ps, "%g %g %g setrgbcolor%s\n", r, g, b, suffix);
+    else
+        ps_printf(ps, "%g setgray%s\n", r, suffix);
+}
+
+static void ps_setcolour(psdata *ps, int colour)
+{
+    ps_setcolour_internal(ps, colour, "");
+}
+
+static void ps_stroke(psdata *ps, int colour)
+{
+    ps_setcolour_internal(ps, colour, " stroke");
+}
+
+static void ps_draw_text(void *handle, int x, int y, int fonttype,
+                         int fontsize, int align, int colour, char *text)
+{
+    psdata *ps = (psdata *)handle;
+
+    y = ps->ytop - y;
+    ps_setcolour(ps, colour);
+    ps_printf(ps, "/%s findfont %d scalefont setfont\n",
+              fonttype == FONT_FIXED ? "Courier-L1" : "Helvetica-L1",
+              fontsize);
+    if (align & ALIGN_VCENTRE) {
+        ps_printf(ps, "newpath 0 0 moveto (X) true charpath flattenpath"
+                  " pathbbox\n"
+                  "3 -1 roll add 2 div %d exch sub %d exch moveto pop pop\n",
+                  y, x);
+    } else {
+        ps_printf(ps, "%d %d moveto\n", x, y);
+    }
+    ps_printf(ps, "(");
+    while (*text) {
+        if (*text == '\\' || *text == '(' || *text == ')')
+            ps_printf(ps, "\\");
+        ps_printf(ps, "%c", *text);
+        text++;
+    }
+    ps_printf(ps, ") ");
+    if (align & (ALIGN_HCENTRE | ALIGN_HRIGHT))
+        ps_printf(ps, "dup stringwidth pop %sneg 0 rmoveto show\n",
+                  (align & ALIGN_HCENTRE) ? "2 div " : "");
+    else
+        ps_printf(ps, "show\n");
+}
+
+static void ps_draw_rect(void *handle, int x, int y, int w, int h, int colour)
+{
+    psdata *ps = (psdata *)handle;
+
+    y = ps->ytop - y;
+    /*
+     * Offset by half a pixel for the exactness requirement.
+     */
+    ps_printf(ps, "newpath %g %g moveto %d 0 rlineto 0 %d rlineto"
+              " %d 0 rlineto closepath\n", x - 0.5, y + 0.5, w, -h, -w);
+    ps_fill(ps, colour);
+}
+
+static void ps_draw_line(void *handle, int x1, int y1, int x2, int y2,
+                         int colour)
+{
+    psdata *ps = (psdata *)handle;
+
+    y1 = ps->ytop - y1;
+    y2 = ps->ytop - y2;
+    ps_printf(ps, "newpath %d %d moveto %d %d lineto\n", x1, y1, x2, y2);
+    ps_stroke(ps, colour);
+}
+
+static void ps_draw_polygon(void *handle, int *coords, int npoints,
+                            int fillcolour, int outlinecolour)
+{
+    psdata *ps = (psdata *)handle;
+
+    int i;
+
+    ps_printf(ps, "newpath %d %d moveto\n", coords[0], ps->ytop - coords[1]);
+
+    for (i = 1; i < npoints; i++)
+        ps_printf(ps, "%d %d lineto\n", coords[i*2], ps->ytop - coords[i*2+1]);
+
+    ps_printf(ps, "closepath\n");
+
+    if (fillcolour >= 0) {
+        ps_printf(ps, "gsave\n");
+        ps_fill(ps, fillcolour);
+        ps_printf(ps, "grestore\n");
+    }
+    ps_stroke(ps, outlinecolour);
+}
+
+static void ps_draw_circle(void *handle, int cx, int cy, int radius,
+                           int fillcolour, int outlinecolour)
+{
+    psdata *ps = (psdata *)handle;
+
+    cy = ps->ytop - cy;
+
+    ps_printf(ps, "newpath %d %d %d 0 360 arc closepath\n", cx, cy, radius);
+
+    if (fillcolour >= 0) {
+        ps_printf(ps, "gsave\n");
+        ps_fill(ps, fillcolour);
+        ps_printf(ps, "grestore\n");
+    }
+    ps_stroke(ps, outlinecolour);
+}
+
+static void ps_unclip(void *handle)
+{
+    psdata *ps = (psdata *)handle;
+
+    assert(ps->clipped);
+    ps_printf(ps, "grestore\n");
+    ps->clipped = FALSE;
+}
+ 
+static void ps_clip(void *handle, int x, int y, int w, int h)
+{
+    psdata *ps = (psdata *)handle;
+
+    if (ps->clipped)
+        ps_unclip(ps);
+
+    y = ps->ytop - y;
+    /*
+     * Offset by half a pixel for the exactness requirement.
+     */
+    ps_printf(ps, "gsave\n");
+    ps_printf(ps, "newpath %g %g moveto %d 0 rlineto 0 %d rlineto"
+              " %d 0 rlineto closepath\n", x - 0.5, y + 0.5, w, -h, -w);
+    ps_printf(ps, "clip\n");
+    ps->clipped = TRUE;
+}
+
+static void ps_line_width(void *handle, float width)
+{
+    psdata *ps = (psdata *)handle;
+
+    ps_printf(ps, "%g setlinewidth\n", width);
+}
+
+static void ps_line_dotted(void *handle, int dotted)
+{
+    psdata *ps = (psdata *)handle;
+
+    if (dotted) {
+        ps_printf(ps, "[ currentlinewidth 3 mul ] 0 setdash\n");
+    } else {
+        ps_printf(ps, "[ ] 0 setdash\n");
+    }
+}
+
+static char *ps_text_fallback(void *handle, const char *const *strings,
+                              int nstrings)
+{
+    /*
+     * We can handle anything in ISO 8859-1, and we'll manually
+     * translate it out of UTF-8 for the purpose.
+     */
+    int i, maxlen;
+    char *ret;
+
+    maxlen = 0;
+    for (i = 0; i < nstrings; i++) {
+        int len = strlen(strings[i]);
+        if (maxlen < len) maxlen = len;
+    }
+
+    ret = snewn(maxlen + 1, char);
+
+    for (i = 0; i < nstrings; i++) {
+        const char *p = strings[i];
+        char *q = ret;
+
+        while (*p) {
+            int c = (unsigned char)*p++;
+            if (c < 0x80) {
+                *q++ = c;              /* ASCII */
+            } else if ((c == 0xC2 || c == 0xC3) && (*p & 0xC0) == 0x80) {
+                *q++ = (c << 6) | (*p++ & 0x3F);   /* top half of 8859-1 */
+            } else {
+                break;
+            }
+        }
+
+        if (!*p) {
+            *q = '\0';
+            return ret;
+        }
+    }
+
+    assert(!"Should never reach here");
+    return NULL;
+}
+
+static void ps_begin_doc(void *handle, int pages)
+{
+    psdata *ps = (psdata *)handle;
+
+    fputs("%!PS-Adobe-3.0\n", ps->fp);
+    fputs("%%Creator: Simon Tatham's Portable Puzzle Collection\n", ps->fp);
+    fputs("%%DocumentData: Clean7Bit\n", ps->fp);
+    fputs("%%LanguageLevel: 1\n", ps->fp);
+    fprintf(ps->fp, "%%%%Pages: %d\n", pages);
+    fputs("%%DocumentNeededResources:\n", ps->fp);
+    fputs("%%+ font Helvetica\n", ps->fp);
+    fputs("%%+ font Courier\n", ps->fp);
+    fputs("%%EndComments\n", ps->fp);
+    fputs("%%BeginSetup\n", ps->fp);
+    fputs("%%IncludeResource: font Helvetica\n", ps->fp);
+    fputs("%%IncludeResource: font Courier\n", ps->fp);
+    fputs("%%EndSetup\n", ps->fp);
+    fputs("%%BeginProlog\n", ps->fp);
+    /*
+     * Re-encode Helvetica and Courier into ISO-8859-1, which gives
+     * us times and divide signs - and also (according to the
+     * Language Reference Manual) a bonus in that the ASCII '-' code
+     * point now points to a minus sign instead of a hyphen.
+     */
+    fputs("/Helvetica findfont " /* get the font dictionary */
+          "dup maxlength dict dup begin " /* create and open a new dict */
+          "exch " /* move the original font to top of stack */
+          "{1 index /FID ne {def} {pop pop} ifelse} forall "
+                                       /* copy everything except FID */
+          "/Encoding ISOLatin1Encoding def "
+                              /* set the thing we actually wanted to change */
+          "/FontName /Helvetica-L1 def " /* set a new font name */
+          "FontName end exch definefont" /* and define the font */
+          "\n", ps->fp);
+    fputs("/Courier findfont " /* get the font dictionary */
+          "dup maxlength dict dup begin " /* create and open a new dict */
+          "exch " /* move the original font to top of stack */
+          "{1 index /FID ne {def} {pop pop} ifelse} forall "
+                                       /* copy everything except FID */
+          "/Encoding ISOLatin1Encoding def "
+                              /* set the thing we actually wanted to change */
+          "/FontName /Courier-L1 def " /* set a new font name */
+          "FontName end exch definefont" /* and define the font */
+          "\n", ps->fp);
+    fputs("%%EndProlog\n", ps->fp);
+}
+
+static void ps_begin_page(void *handle, int number)
+{
+    psdata *ps = (psdata *)handle;
+
+    fprintf(ps->fp, "%%%%Page: %d %d\ngsave save\n%g dup scale\n",
+            number, number, 72.0 / 25.4);
+}
+
+static void ps_begin_puzzle(void *handle, float xm, float xc,
+                            float ym, float yc, int pw, int ph, float wmm)
+{
+    psdata *ps = (psdata *)handle;
+
+    fprintf(ps->fp, "gsave\n"
+            "clippath flattenpath pathbbox pop pop translate\n"
+            "clippath flattenpath pathbbox 4 2 roll pop pop\n"
+            "exch %g mul %g add exch dup %g mul %g add sub translate\n"
+            "%g dup scale\n"
+            "0 -%d translate\n", xm, xc, ym, yc, wmm/pw, ph);
+    ps->ytop = ph;
+    ps->clipped = FALSE;
+    ps->gamewidth = pw;
+    ps->gameheight = ph;
+    ps->hatchthick = 0.2 * pw / wmm;
+    ps->hatchspace = 1.0 * pw / wmm;
+}
+
+static void ps_end_puzzle(void *handle)
+{
+    psdata *ps = (psdata *)handle;
+
+    fputs("grestore\n", ps->fp);
+}
+
+static void ps_end_page(void *handle, int number)
+{
+    psdata *ps = (psdata *)handle;
+
+    fputs("restore grestore showpage\n", ps->fp);
+}
+
+static void ps_end_doc(void *handle)
+{
+    psdata *ps = (psdata *)handle;
+
+    fputs("%%EOF\n", ps->fp);
+}
+
+static const struct drawing_api ps_drawing = {
+    ps_draw_text,
+    ps_draw_rect,
+    ps_draw_line,
+    ps_draw_polygon,
+    ps_draw_circle,
+    NULL /* draw_update */,
+    ps_clip,
+    ps_unclip,
+    NULL /* start_draw */,
+    NULL /* end_draw */,
+    NULL /* status_bar */,
+    NULL /* blitter_new */,
+    NULL /* blitter_free */,
+    NULL /* blitter_save */,
+    NULL /* blitter_load */,
+    ps_begin_doc,
+    ps_begin_page,
+    ps_begin_puzzle,
+    ps_end_puzzle,
+    ps_end_page,
+    ps_end_doc,
+    ps_line_width,
+    ps_line_dotted,
+    ps_text_fallback,
+};
+
+psdata *ps_init(FILE *outfile, int colour)
+{
+    psdata *ps = snew(psdata);
+
+    ps->fp = outfile;
+    ps->colour = colour;
+    ps->ytop = 0;
+    ps->clipped = FALSE;
+    ps->hatchthick = ps->hatchspace = ps->gamewidth = ps->gameheight = 0;
+    ps->drawing = drawing_new(&ps_drawing, NULL, ps);
+
+    return ps;
+}
+
+void ps_free(psdata *ps)
+{
+    drawing_free(ps->drawing);
+    sfree(ps);
+}
+
+drawing *ps_drawing_api(psdata *ps)
+{
+    return ps->drawing;
+}
diff --git a/apps/plugins/puzzles/puzzles.but b/apps/plugins/puzzles/puzzles.but
new file mode 100644
index 0000000000..2508fe3337
--- /dev/null
+++ b/apps/plugins/puzzles/puzzles.but
@@ -0,0 +1,3401 @@
+\title Simon Tatham's Portable Puzzle Collection
+
+\cfg{winhelp-filename}{puzzles.hlp}
+\cfg{winhelp-contents-titlepage}{Contents}
+
+\cfg{text-filename}{puzzles.txt}
+
+\cfg{html-contents-filename}{index.html}
+\cfg{html-template-filename}{%k.html}
+\cfg{html-index-filename}{docindex.html}
+\cfg{html-leaf-level}{1}
+\cfg{html-contents-depth-0}{1}
+\cfg{html-contents-depth-1}{2}
+\cfg{html-leaf-contains-contents}{true}
+
+\cfg{info-filename}{puzzles.info}
+
+\cfg{ps-filename}{puzzles.ps}
+\cfg{pdf-filename}{puzzles.pdf}
+
+\define{by} \u00D7{x}
+
+\define{dash} \u2013{-}
+
+\define{times} \u00D7{*}
+
+\define{divide} \u00F7{/}
+
+\define{minus} \u2212{-}
+
+This is a collection of small one-player puzzle games.
+
+\copyright This manual is copyright 2004-2014 Simon Tatham. All rights
+reserved. You may distribute this documentation under the MIT licence.
+See \k{licence} for the licence text in full.
+
+\cfg{html-local-head}{<meta name="AppleTitle" content="Puzzles Help">}
+
+\C{intro} Introduction
+
+I wrote this collection because I thought there should be more small
+desktop toys available: little games you can pop up in a window and
+play for two or three minutes while you take a break from whatever
+else you were doing. And I was also annoyed that every time I found
+a good game on (say) \i{Unix}, it wasn't available the next time I
+was sitting at a \i{Windows} machine, or vice versa; so I arranged
+that everything in my personal puzzle collection will happily run on
+both, and have more recently done a port to \i{Mac OS X} as well. When I
+find (or perhaps invent) further puzzle games that I like, they'll
+be added to this collection and will immediately be available on
+both platforms. And if anyone feels like writing any other front
+ends \dash PocketPC, Mac OS pre-10, or whatever it might be \dash
+then all the games in this framework will immediately become
+available on another platform as well.
+
+The actual games in this collection were mostly not my invention; they
+are re-implementations of existing game concepts within my portable
+puzzle framework. I do not claim credit, in general, for inventing the
+rules of any of these puzzles. (I don't even claim authorship of all
+the code; some of the puzzles have been submitted by other authors.)
+
+This collection is distributed under the \i{MIT licence} (see
+\k{licence}). This means that you can do pretty much anything you like
+with the game binaries or the code, except pretending you wrote them
+yourself, or suing me if anything goes wrong. 
+
+The most recent versions, and \i{source code}, can be found at
+\I{website}\W{http://www.chiark.greenend.org.uk/~sgtatham/puzzles/}\cw{http://www.chiark.greenend.org.uk/~sgtatham/puzzles/}.
+
+Please report \I{feedback}\i{bugs} to
+\W{mailto:anakin@pobox.com}\cw{anakin@pobox.com}.
+You might find it helpful to read this article before reporting a bug:
+
+\W{http://www.chiark.greenend.org.uk/~sgtatham/bugs.html}\cw{http://www.chiark.greenend.org.uk/~sgtatham/bugs.html}
+
+\ii{Patches} are welcome. Especially if they provide a new front end
+(to make all these games run on another platform), or a new game.
+
+
+\C{common} \ii{Common features}
+
+This chapter describes features that are common to all the games.
+
+\H{common-actions} \I{controls}Common actions
+
+These actions are all available from the \I{Game menu}\q{Game} menu
+and via \I{keys}keyboard shortcuts, in addition to any game-specific
+actions.
+
+(On \i{Mac OS X}, to conform with local user interface standards, these
+actions are situated on the \I{File menu}\q{File} and \I{Edit
+menu}\q{Edit} menus instead.)
+
+\dt \ii\e{New game} (\q{N}, Ctrl+\q{N})
+
+\dd Starts a new game, with a random initial state.
+
+\dt \ii\e{Restart game}
+
+\dd Resets the current game to its initial state. (This can be undone.)
+
+\dt \ii\e{Load}
+
+\dd Loads a saved game from a file on disk.
+
+\dt \ii\e{Save}
+
+\dd Saves the current state of your game to a file on disk.
+
+\lcont{
+
+The Load and Save operations preserve your entire game
+history (so you can save, reload, and still Undo and Redo things you
+had done before saving).
+
+}
+
+\dt \I{printing, on Windows}\e{Print}
+
+\dd Where supported (currently only on Windows), brings up a dialog
+allowing you to print an arbitrary number of puzzles randomly
+generated from the current parameters, optionally including the
+current puzzle. (Only for puzzles which make sense to print, of
+course \dash it's hard to think of a sensible printable representation
+of Fifteen!)
+
+\dt \ii\e{Undo} (\q{U}, Ctrl+\q{Z}, Ctrl+\q{_})
+
+\dd Undoes a single move. (You can undo moves back to the start of the
+session.)
+
+\dt \ii\e{Redo} (\q{R}, Ctrl+\q{R})
+
+\dd Redoes a previously undone move.
+
+\dt \ii\e{Copy}
+
+\dd Copies the current state of your game to the clipboard in text
+format, so that you can paste it into (say) an e-mail client or a
+web message board if you're discussing the game with someone else.
+(Not all games support this feature.)
+
+\dt \ii\e{Solve}
+
+\dd Transforms the puzzle instantly into its solved state. For some
+games (Cube) this feature is not supported at all because it is of
+no particular use. For other games (such as Pattern), the solved
+state can be used to give you information, if you can't see how a
+solution can exist at all or you want to know where you made a
+mistake. For still other games (such as Sixteen), automatic solution
+tells you nothing about how to \e{get} to the solution, but it does
+provide a useful way to get there quickly so that you can experiment
+with set-piece moves and transformations.
+
+\lcont{
+
+Some games (such as Solo) are capable of solving a game ID you have
+typed in from elsewhere. Other games (such as Rectangles) cannot
+solve a game ID they didn't invent themself, but when they did
+invent the game ID they know what the solution is already. Still
+other games (Pattern) can solve \e{some} external game IDs, but only
+if they aren't too difficult.
+
+The \q{Solve} command adds the solved state to the end of the undo
+chain for the puzzle. In other words, if you want to go back to
+solving it yourself after seeing the answer, you can just press Undo.
+
+}
+
+\dt \I{exit}\ii\e{Quit} (\q{Q}, Ctrl+\q{Q})
+
+\dd Closes the application entirely.
+
+\H{common-id} Specifying games with the \ii{game ID}
+
+There are two ways to save a game specification out of a puzzle and
+recreate it later, or recreate it in somebody else's copy of the
+same puzzle.
+
+The \q{\i{Specific}} and \q{\i{Random Seed}} options from the
+\I{Game menu}\q{Game} menu (or the \q{File} menu, on \i{Mac OS X}) each
+show a piece of text (a \q{game ID}) which is sufficient to
+reconstruct precisely the same game at a later date.
+
+You can enter either of these pieces of text back into the program
+(via the same \q{Specific} or \q{Random Seed} menu options) at a
+later point, and it will recreate the same game. You can also use
+either one as a \i{command line} argument (on Windows or Unix); see
+\k{common-cmdline} for more detail.
+
+The difference between the two forms is that a descriptive game ID
+is a literal \e{description} of the \i{initial state} of the game,
+whereas a random seed is just a piece of arbitrary text which was
+provided as input to the random number generator used to create the
+puzzle. This means that:
+
+\b Descriptive game IDs tend to be longer in many puzzles (although
+some, such as Cube (\k{cube}), only need very short descriptions).
+So a random seed is often a \e{quicker} way to note down the puzzle
+you're currently playing, or to tell it to somebody else so they can
+play the same one as you.
+
+\b Any text at all is a valid random seed. The automatically
+generated ones are fifteen-digit numbers, but anything will do; you
+can type in your full name, or a word you just made up, and a valid
+puzzle will be generated from it. This provides a way for two or
+more people to race to complete the same puzzle: you think of a
+random seed, then everybody types it in at the same time, and nobody
+has an advantage due to having seen the generated puzzle before
+anybody else.
+
+\b It is often possible to convert puzzles from other sources (such
+as \q{nonograms} or \q{sudoku} from newspapers) into descriptive
+game IDs suitable for use with these programs.
+
+\b Random seeds are not guaranteed to produce the same result if you
+use them with a different \i\e{version} of the puzzle program. This
+is because the generation algorithm might have been improved or
+modified in later versions of the code, and will therefore produce a
+different result when given the same sequence of random numbers. Use
+a descriptive game ID if you aren't sure that it will be used on the
+same version of the program as yours.
+
+\lcont{(Use the \q{About} menu option to find out the version number
+of the program. Programs with the same version number running on
+different platforms should still be random-seed compatible.)}
+
+\I{ID format}A descriptive game ID starts with a piece of text which
+encodes the \i\e{parameters} of the current game (such as grid
+size). Then there is a colon, and after that is the description of
+the game's initial state. A random seed starts with a similar string
+of parameters, but then it contains a hash sign followed by
+arbitrary data.
+
+If you enter a descriptive game ID, the program will not be able to
+show you the random seed which generated it, since it wasn't
+generated \e{from} a random seed. If you \e{enter} a random seed,
+however, the program will be able to show you the descriptive game
+ID derived from that random seed.
+
+Note that the game parameter strings are not always identical
+between the two forms. For some games, there will be parameter data
+provided with the random seed which is not included in the
+descriptive game ID. This is because that parameter information is
+only relevant when \e{generating} puzzle grids, and is not important
+when playing them. Thus, for example, the difficulty level in Solo
+(\k{solo}) is not mentioned in the descriptive game ID.
+
+These additional parameters are also not set permanently if you type
+in a game ID. For example, suppose you have Solo set to \q{Advanced}
+difficulty level, and then a friend wants your help with a
+\q{Trivial} puzzle; so the friend reads out a random seed specifying
+\q{Trivial} difficulty, and you type it in. The program will
+generate you the same \q{Trivial} grid which your friend was having
+trouble with, but once you have finished playing it, when you ask
+for a new game it will automatically go back to the \q{Advanced}
+difficulty which it was previously set on.
+
+\H{common-type} The \q{Type} menu
+
+The \I{Type menu}\q{Type} menu, if present, may contain a list of
+\i{preset} game settings. Selecting one of these will start a new
+random game with the parameters specified.
+
+The \q{Type} menu may also contain a \q{\i{Custom}} option which
+allows you to fine-tune game \i{parameters}. The parameters
+available are specific to each game and are described in the
+following sections.
+
+\H{common-cmdline} Specifying game parameters on the \i{command line}
+
+(This section does not apply to the \i{Mac OS X} version.)
+
+The games in this collection deliberately do not ever save
+information on to the computer they run on: they have no high score
+tables and no saved preferences. (This is because I expect at least
+some people to play them at work, and those people will probably
+appreciate leaving as little evidence as possible!)
+
+However, if you do want to arrange for one of these games to
+\I{default parameters, specifying}default to a particular set of
+parameters, you can specify them on the command line.
+
+The easiest way to do this is to set up the parameters you want
+using the \q{Type} menu (see \k{common-type}), and then to select
+\q{Random Seed} from the \q{Game} or \q{File} menu (see
+\k{common-id}). The text in the \q{Game ID} box will be composed of
+two parts, separated by a hash. The first of these parts represents
+the game parameters (the size of the playing area, for example, and
+anything else you set using the \q{Type} menu).
+
+If you run the game with just that parameter text on the command
+line, it will start up with the settings you specified.
+
+For example: if you run Cube (see \k{cube}), select \q{Octahedron}
+from the \q{Type} menu, and then go to the game ID selection, you
+will see a string of the form \cq{o2x2#338686542711620}. Take only
+the part before the hash (\cq{o2x2}), and start Cube with that text
+on the command line: \cq{PREFIX-cube o2x2}.
+
+If you copy the \e{entire} game ID on to the command line, the game
+will start up in the specific game that was described. This is
+occasionally a more convenient way to start a particular game ID
+than by pasting it into the game ID selection box.
+
+(You could also retrieve the encoded game parameters using the
+\q{Specific} menu option instead of \q{Random Seed}, but if you do
+then some options, such as the difficulty level in Solo, will be
+missing. See \k{common-id} for more details on this.)
+
+\H{common-unix-cmdline} \i{Unix} \i{command-line} options
+
+(This section only applies to the Unix port.)
+
+In addition to being able to specify game parameters on the command
+line (see \k{common-cmdline}), there are various other options:
+
+\dt \cw{--game}
+
+\dt \cw{--load}
+
+\dd These options respectively determine whether the command-line
+argument is treated as specifying game parameters or a \i{save} file
+to \i{load}. Only one should be specified. If neither of these options
+is specified, a guess is made based on the format of the argument.
+
+\dt \cw{--generate }\e{n}
+
+\dd If this option is specified, instead of a puzzle being displayed,
+a number of descriptive game IDs will be \I{generating game IDs}invented
+and printed on standard output. This is useful for gaining access to
+the game generation algorithms without necessarily using the frontend.
+
+\lcont{
+
+If game parameters are specified on the command-line, they will be
+used to generate the game IDs; otherwise a default set of parameters
+will be used.
+
+The most common use of this option is in conjunction with \c{--print},
+in which case its behaviour is slightly different; see below.
+
+}
+
+\dt \I{printing, on Unix}\cw{--print }\e{w}\cw{x}\e{h}
+
+\dd If this option is specified, instead of a puzzle being displayed,
+a printed representation of one or more unsolved puzzles is sent to
+standard output, in \i{PostScript} format.
+
+\lcont{
+
+On each page of puzzles, there will be \e{w} across and \e{h} down. If
+there are more puzzles than \e{w}\by\e{h}, more than one page will be
+printed.
+
+If \c{--generate} has also been specified, the invented game IDs will
+be used to generate the printed output. Otherwise, a list of game IDs
+is expected on standard input (which can be descriptive or random
+seeds; see \k{common-id}), in the same format produced by
+\c{--generate}.
+
+For example:
+
+\c PREFIX-net --generate 12 --print 2x3 7x7w | lpr
+
+will generate two pages of printed Net puzzles (each of which will
+have a 7\by\.7 wrapping grid), and pipe the output to the \c{lpr}
+command, which on many systems will send them to an actual printer.
+
+There are various other options which affect printing; see below.
+
+}
+
+\dt \cw{--save }\e{file-prefix} [ \cw{--save-suffix }\e{file-suffix} ]
+
+\dd If this option is specified, instead of a puzzle being
+displayed, saved-game files for one or more unsolved puzzles are
+written to files constructed from the supplied prefix and/or suffix.
+
+\lcont{
+
+If \c{--generate} has also been specified, the invented game IDs will
+be used to generate the printed output. Otherwise, a list of game IDs
+is expected on standard input (which can be descriptive or random
+seeds; see \k{common-id}), in the same format produced by
+\c{--generate}.
+
+For example:
+
+\c PREFIX-net --generate 12 --save game --save-suffix .sav
+
+will generate twelve Net saved-game files with the names
+\cw{game0.sav} to \cw{game11.sav}.
+
+}
+
+\dt \cw{--version}
+
+\dd Prints version information about the game, and then quits.
+
+The following options are only meaningful if \c{--print} is also
+specified:
+
+\dt \cw{--with-solutions}
+
+\dd The set of pages filled with unsolved puzzles will be followed by
+the solutions to those puzzles.
+
+\dt \cw{--scale }\e{n}
+
+\dd Adjusts how big each puzzle is when printed. Larger numbers make
+puzzles bigger; the default is 1.0.
+
+\dt \cw{--colour}
+
+\dd Puzzles will be printed in colour, rather than in black and white
+(if supported by the puzzle).
+
+
+\C{net} \i{Net}
+
+\cfg{winhelp-topic}{games.net}
+
+(\e{Note:} the \i{Windows} version of this game is called
+\i\cw{NETGAME.EXE} to avoid clashing with Windows's own \cw{NET.EXE}.)
+
+I originally saw this in the form of a Flash game called \i{FreeNet}
+\k{FreeNet}, written by Pavils Jurjans; there are several other
+implementations under the name \i{NetWalk}. The computer prepares a
+network by connecting up the centres of squares in a grid, and then
+shuffles the network by rotating every tile randomly. Your job is to
+rotate it all back into place. The successful solution will be an
+entirely connected network, with no closed loops. \#{The latter
+clause means that there are no closed paths within the network.
+Could this be clearer? "No closed paths"?} As a visual aid,
+all tiles which are connected to the one in the middle are
+highlighted. 
+
+\B{FreeNet} \W{http://www.jurjans.lv/stuff/net/FreeNet.htm}\cw{http://www.jurjans.lv/stuff/net/FreeNet.htm}
+
+\H{net-controls} \i{Net controls}
+
+\IM{Net controls} controls, for Net
+\IM{Net controls} keys, for Net
+\IM{Net controls} shortcuts (keyboard), for Net
+
+This game can be played with either the keyboard or the mouse. The
+controls are:
+
+\dt \e{Select tile}: mouse pointer, arrow keys
+
+\dt \e{Rotate tile anticlockwise}: left mouse button, \q{A} key
+
+\dt \e{Rotate tile clockwise}: right mouse button, \q{D} key
+
+\dt \e{Rotate tile by 180 degrees}: \q{F} key
+
+\dt \e{Lock (or unlock) tile}: middle mouse button, shift-click, \q{S} key
+
+\dd You can lock a tile once you're sure of its orientation. You can
+also unlock it again, but while it's locked you can't accidentally
+turn it.
+
+The following controls are not necessary to complete the game, but may
+be useful:
+
+\dt \e{Shift grid}: Shift + arrow keys
+
+\dd On grids that wrap, you can move the origin of the grid, so that
+tiles that were on opposite sides of the grid can be seen together.
+
+\dt \e{Move centre}: Ctrl + arrow keys
+
+\dd You can change which tile is used as the source of highlighting.
+(It doesn't ultimately matter which tile this is, as every tile will
+be connected to every other tile in a correct solution, but it may be
+helpful in the intermediate stages of solving the puzzle.)
+
+\dt \e{Jumble tiles}: \q{J} key
+
+\dd This key turns all tiles that are not locked to random
+orientations.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{net-params} \I{parameters, for Net}Net parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in tiles.
+
+\dt \e{Walls wrap around}
+
+\dd If checked, flow can pass from the left edge to the right edge,
+and from top to bottom, and vice versa.
+
+\dt \e{Barrier probability}
+
+\dd A number between 0.0 and 1.0 controlling whether an immovable
+barrier is placed between two tiles to prevent flow between them (a
+higher number gives more barriers). Since barriers are immovable, they
+act as constraints on the solution (i.e., hints).
+
+\lcont{
+
+The grid generation in Net has been carefully arranged so that the
+barriers are independent of the rest of the grid. This means that if
+you note down the random seed used to generate the current puzzle
+(see \k{common-id}), change the \e{Barrier probability} parameter,
+and then re-enter the same random seed, you should see exactly the
+same starting grid, with the only change being the number of
+barriers. So if you're stuck on a particular grid and need a hint,
+you could start up another instance of Net, set up the same
+parameters but a higher barrier probability, and enter the game seed
+from the original Net window.
+
+}
+
+\dt \e{Ensure unique solution}
+
+\dd Normally, Net will make sure that the puzzles it presents have
+only one solution. Puzzles with ambiguous sections can be more
+difficult and more subtle, so if you like you can turn off this
+feature and risk having ambiguous puzzles. (Also, finding \e{all}
+the possible solutions can be an additional challenge for an
+advanced player.)
+
+
+\C{cube} \i{Cube}
+
+\cfg{winhelp-topic}{games.cube}
+
+This is another one I originally saw as a web game. This one was a
+Java game \k{cube-java-game}, by Paul Scott. You have a grid of 16
+squares, six of which are blue; on one square rests a cube. Your move
+is to use the arrow keys to roll the cube through 90 degrees so that
+it moves to an adjacent square. If you roll the cube on to a blue
+square, the blue square is picked up on one face of the cube; if you
+roll a blue face of the cube on to a non-blue square, the blueness is
+put down again. (In general, whenever you roll the cube, the two faces
+that come into contact swap colours.) Your job is to get all six blue
+squares on to the six faces of the cube at the same time. Count your
+moves and try to do it in as few as possible. 
+
+Unlike the original Java game, my version has an additional feature:
+once you've mastered the game with a cube rolling on a square grid,
+you can change to a triangular grid and roll any of a tetrahedron, an
+octahedron or an icosahedron. 
+
+\B{cube-java-game} \W{http://www3.sympatico.ca/paulscott/cube/cube.htm}\cw{http://www3.sympatico.ca/paulscott/cube/cube.htm}
+
+\H{cube-controls} \i{Cube controls}
+
+\IM{Cube controls} controls, for Cube
+\IM{Cube controls} keys, for Cube
+\IM{Cube controls} shortcuts (keyboard), for Cube
+
+This game can be played with either the keyboard or the mouse.
+
+Left-clicking anywhere on the window will move the cube (or other
+solid) towards the mouse pointer.
+
+The arrow keys can also used to roll the cube on its square grid in
+the four cardinal directions.
+On the triangular grids, the mapping of arrow keys to directions is
+more approximate. Vertical movement is disallowed where it doesn't
+make sense. The four keys surrounding the arrow keys on the numeric
+keypad (\q{7}, \q{9}, \q{1}, \q{3}) can be used for diagonal movement.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{cube-params} \I{parameters, for Cube}Cube parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Type of solid}
+
+\dd Selects the solid to roll (and hence the shape of the grid):
+tetrahedron, cube, octahedron, or icosahedron.
+
+\dt \e{Width / top}, \e{Height / bottom}
+
+\dd On a square grid, horizontal and vertical dimensions. On a
+triangular grid, the number of triangles on the top and bottom rows
+respectively.
+
+
+\C{fifteen} \i{Fifteen}
+
+\cfg{winhelp-topic}{games.fifteen}
+
+The old ones are the best: this is the good old \q{\i{15-puzzle}}
+with sliding tiles. You have a 4\by\.4 square grid; 15 squares
+contain numbered tiles, and the sixteenth is empty. Your move is to
+choose a tile next to the empty space, and slide it into the space.
+The aim is to end up with the tiles in numerical order, with the
+space in the bottom right (so that the top row reads 1,2,3,4 and the
+bottom row reads 13,14,15,\e{space}).
+
+\H{fifteen-controls} \i{Fifteen controls}
+
+\IM{Fifteen controls} controls, for Fifteen
+\IM{Fifteen controls} keys, for Fifteen
+\IM{Fifteen controls} shortcuts (keyboard), for Fifteen
+
+This game can be controlled with the mouse or the keyboard.
+
+A left-click with the mouse in the row or column containing the empty
+space will move as many tiles as necessary to move the space to the
+mouse pointer.
+
+The arrow keys will move a tile adjacent to the space in the direction
+indicated (moving the space in the \e{opposite} direction).
+
+Pressing \q{h} will make a suggested move.  Pressing \q{h} enough
+times will solve the game, but it may scramble your progress while
+doing so.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{fifteen-params} \I{parameters, for Fifteen}Fifteen parameters
+
+The only options available from the \q{Custom...} option on the \q{Type}
+menu are \e{Width} and \e{Height}, which are self-explanatory. (Once
+you've changed these, it's not a \q{15-puzzle} any more, of course!)
+
+
+\C{sixteen} \i{Sixteen}
+
+\cfg{winhelp-topic}{games.sixteen}
+
+Another sliding tile puzzle, visually similar to Fifteen (see
+\k{fifteen}) but with a different type of move. This time, there is no
+hole: all 16 squares on the grid contain numbered squares. Your move
+is to shift an entire row left or right, or shift an entire column up
+or down; every time you do that, the tile you shift off the grid
+re-appears at the other end of the same row, in the space you just
+vacated. To win, arrange the tiles into numerical order (1,2,3,4 on
+the top row, 13,14,15,16 on the bottom). When you've done that, try
+playing on different sizes of grid. 
+
+I \e{might} have invented this game myself, though only by accident if
+so (and I'm sure other people have independently invented it). I
+thought I was imitating a screensaver I'd seen, but I have a feeling
+that the screensaver might actually have been a Fifteen-type puzzle
+rather than this slightly different kind. So this might be the one
+thing in my puzzle collection which represents creativity on my part
+rather than just engineering.
+
+\H{sixteen-controls} \I{controls, for Sixteen}Sixteen controls
+
+Left-clicking on an arrow will move the appropriate row or column in
+the direction indicated.  Right-clicking will move it in the opposite
+direction.
+
+Alternatively, use the cursor keys to move the position indicator
+around the edge of the grid, and use the return key to move the
+row/column in the direction indicated. 
+
+You can also move the tiles directly.  Move the cursor onto a tile,
+hold Control and press an arrow key to move the tile under the
+cursor and move the cursor along with the tile.  Or, hold Shift to
+move only the tile.  Pressing Enter simulates holding down Control
+(press Enter again to release), while pressing Space simulates
+holding down shift.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{sixteen-params} \I{parameters, for Sixteen}Sixteen parameters
+
+The parameters available from the \q{Custom...} option on the
+\q{Type} menu are:
+
+\b \e{Width} and \e{Height}, which are self-explanatory.
+
+\b You can ask for a limited shuffling operation to be performed on
+the grid. By default, Sixteen will shuffle the grid in such a way
+that any arrangement is about as probable as any other. You can
+override this by requesting a precise number of shuffling moves to
+be performed. Typically your aim is then to determine the precise
+set of shuffling moves and invert them exactly, so that you answer
+(say) a four-move shuffle with a four-move solution. Note that the
+more moves you ask for, the more likely it is that solutions shorter
+than the target length will turn out to be possible.
+
+
+\C{twiddle} \i{Twiddle}
+
+\cfg{winhelp-topic}{games.twiddle}
+
+Twiddle is a tile-rearrangement puzzle, visually similar to Sixteen
+(see \k{sixteen}): you are given a grid of square tiles, each
+containing a number, and your aim is to arrange the numbers into
+ascending order.
+
+In basic Twiddle, your move is to rotate a square group of four
+tiles about their common centre. (Orientation is not significant in
+the basic puzzle, although you can select it.) On more advanced
+settings, you can rotate a larger square group of tiles.
+
+I first saw this type of puzzle in the GameCube game \q{Metroid
+Prime 2}. In the Main Gyro Chamber in that game, there is a puzzle
+you solve to unlock a door, which is a special case of Twiddle. I
+developed this game as a generalisation of that puzzle.
+
+\H{twiddle-controls} \I{controls, for Twiddle}Twiddle controls
+
+To play Twiddle, click the mouse in the centre of the square group
+you wish to rotate. In the basic mode, you rotate a 2\by\.2 square,
+which means you have to click at a corner point where four tiles
+meet.
+
+In more advanced modes you might be rotating 3\by\.3 or even more at
+a time; if the size of the square is odd then you simply click in
+the centre tile of the square you want to rotate.
+
+Clicking with the left mouse button rotates the group anticlockwise.
+Clicking with the right button rotates it clockwise.
+
+You can also move an outline square around the grid with the cursor
+keys; the square is the size above (2\by\.2 by default, or larger).
+Pressing the return key or space bar will rotate the current square
+anticlockwise or clockwise respectively.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{twiddle-parameters} \I{parameters, for Twiddle}Twiddle parameters
+
+Twiddle provides several configuration options via the \q{Custom}
+option on the \q{Type} menu:
+
+\b You can configure the width and height of the puzzle grid.
+
+\b You can configure the size of square block that rotates at a time.
+
+\b You can ask for every square in the grid to be distinguishable
+(the default), or you can ask for a simplified puzzle in which there
+are groups of identical numbers. In the simplified puzzle your aim
+is just to arrange all the 1s into the first row, all the 2s into
+the second row, and so on.
+
+\b You can configure whether the orientation of tiles matters. If
+you ask for an orientable puzzle, each tile will have a triangle
+drawn in it. All the triangles must be pointing upwards to complete
+the puzzle.
+
+\b You can ask for a limited shuffling operation to be performed on
+the grid. By default, Twiddle will shuffle the grid so much that any
+arrangement is about as probable as any other. You can override this
+by requesting a precise number of shuffling moves to be performed.
+Typically your aim is then to determine the precise set of shuffling
+moves and invert them exactly, so that you answer (say) a four-move
+shuffle with a four-move solution. Note that the more moves you ask
+for, the more likely it is that solutions shorter than the target
+length will turn out to be possible.
+
+
+\C{rect} \i{Rectangles}
+
+\cfg{winhelp-topic}{games.rectangles}
+
+You have a grid of squares, with numbers written in some (but not all)
+of the squares. Your task is to subdivide the grid into rectangles of
+various sizes, such that (a) every rectangle contains exactly one
+numbered square, and (b) the area of each rectangle is equal to the
+number written in its numbered square.
+
+Credit for this game goes to the Japanese puzzle magazine \i{Nikoli}
+\k{nikoli-rect}; I've also seen a Palm implementation at \i{Puzzle
+Palace} \k{puzzle-palace-rect}. Unlike Puzzle Palace's
+implementation, my version automatically generates random grids of
+any size you like. The quality of puzzle design is therefore not
+quite as good as hand-crafted puzzles would be, but on the plus side
+you get an inexhaustible supply of puzzles tailored to your own
+specification.
+
+\B{nikoli-rect} \W{http://www.nikoli.co.jp/en/puzzles/shikaku.html}\cw{http://www.nikoli.co.jp/en/puzzles/shikaku.html}
+(beware of Flash)
+
+\B{puzzle-palace-rect} \W{https://web.archive.org/web/20041024001459/http://www.puzzle.gr.jp/puzzle/sikaku/palm/index.html.en}\cw{https://web.archive.org/web/20041024001459/http://www.puzzle.gr.jp/puzzle/sikaku/palm/index.html.en}
+
+\H{rectangles-controls} \I{controls, for Rectangles}Rectangles controls
+
+This game is played with the mouse or cursor keys.
+
+Left-click any edge to toggle it on or off, or left-click and drag to draw
+an entire rectangle (or line) on the grid in one go (removing any existing
+edges within that rectangle). Right-clicking and dragging will allow you
+to erase the contents of a rectangle without affecting its edges. 
+
+Alternatively, use the cursor keys to move the position indicator
+around the board. Pressing the return key then allows you to use the
+cursor keys to drag a rectangle out from that position, and pressing
+the return key again completes the rectangle. Using the space bar
+instead of the return key allows you to erase the contents of a
+rectangle without affecting its edges, as above. Pressing escape
+cancels a drag.
+
+When a rectangle of the correct size is completed, it will be shaded.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{rectangles-params} \I{parameters, for Rectangles}Rectangles parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid, in squares.
+
+\dt \e{Expansion factor}
+
+\dd This is a mechanism for changing the type of grids generated by
+the program. Some people prefer a grid containing a few large
+rectangles to one containing many small ones. So you can ask
+Rectangles to essentially generate a \e{smaller} grid than the size
+you specified, and then to expand it by adding rows and columns.
+
+\lcont{
+
+The default expansion factor of zero means that Rectangles will
+simply generate a grid of the size you ask for, and do nothing
+further. If you set an expansion factor of (say) 0.5, it means that
+each dimension of the grid will be expanded to half again as big
+after generation. In other words, the initial grid will be 2/3 the
+size in each dimension, and will be expanded to its full size
+without adding any more rectangles.
+
+Setting an expansion factor of around 0.5 tends to make the game
+more difficult, and also (in my experience) rewards a less deductive
+and more intuitive playing style. If you set it \e{too} high,
+though, the game simply cannot generate more than a few rectangles
+to cover the entire grid, and the game becomes trivial.
+
+}
+
+\dt \e{Ensure unique solution}
+
+\dd Normally, Rectangles will make sure that the puzzles it presents
+have only one solution. Puzzles with ambiguous sections can be more
+difficult and more subtle, so if you like you can turn off this
+feature and risk having ambiguous puzzles. Also, finding \e{all} the
+possible solutions can be an additional challenge for an advanced
+player. Turning off this option can also speed up puzzle generation.
+
+
+\C{netslide} \i{Netslide}
+
+\cfg{winhelp-topic}{games.netslide}
+
+This game combines the grid generation of Net (see \k{net}) with the
+movement of Sixteen (see \k{sixteen}): you have a Net grid, but
+instead of rotating tiles back into place you have to slide them
+into place by moving a whole row at a time. 
+
+As in Sixteen, \I{controls, for Netslide}control is with the mouse or
+cursor keys. See \k{sixteen-controls}.
+
+\I{parameters, for Netslide}The available game parameters have similar
+meanings to those in Net (see \k{net-params}) and Sixteen (see
+\k{sixteen-params}).
+
+Netslide was contributed to this collection by Richard Boulton.
+
+
+\C{pattern} \i{Pattern}
+
+\cfg{winhelp-topic}{games.pattern}
+
+You have a grid of squares, which must all be filled in either black
+or white. Beside each row of the grid are listed the lengths of the
+runs of black squares on that row; above each column are listed the
+lengths of the runs of black squares in that column. Your aim is to
+fill in the entire grid black or white.
+
+I first saw this puzzle form around 1995, under the name
+\q{\i{nonograms}}. I've seen it in various places since then, under
+different names.
+
+Normally, puzzles of this type turn out to be a meaningful picture
+of something once you've solved them. However, since this version
+generates the puzzles automatically, they will just look like random
+groupings of squares. (One user has suggested that this is actually
+a \e{good} thing, since it prevents you from guessing the colour of
+squares based on the picture, and forces you to use logic instead.)
+The advantage, though, is that you never run out of them.
+
+\H{pattern-controls} \I{controls, for Pattern}Pattern controls
+
+This game is played with the mouse.
+
+Left-click in a square to colour it black. Right-click to colour it
+white. If you make a mistake, you can middle-click, or hold down
+Shift while clicking with any button, to colour the square in the
+default grey (meaning \q{undecided}) again.
+
+You can click and drag with the left or right mouse button to colour
+a vertical or horizontal line of squares black or white at a time
+(respectively). If you click and drag with the middle button, or
+with Shift held down, you can colour a whole rectangle of squares
+grey.
+
+You can also move around the grid with the cursor keys. Pressing the
+return key will cycle the current cell through empty, then black, then
+white, then empty, and the space bar does the same cycle in reverse.
+
+Moving the cursor while holding Control will colour the moved-over
+squares black.  Holding Shift will colour the moved-over squares
+white, and holding both will colour them grey.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{pattern-parameters} \I{parameters, for Pattern}Pattern parameters
+
+The only options available from the \q{Custom...} option on the \q{Type}
+menu are \e{Width} and \e{Height}, which are self-explanatory.
+
+
+\C{solo} \i{Solo}
+
+\cfg{winhelp-topic}{games.solo}
+
+You have a square grid, which is divided into as many equally sized
+sub-blocks as the grid has rows. Each square must be filled in with
+a digit from 1 to the size of the grid, in such a way that
+
+\b every row contains only one occurrence of each digit
+
+\b every column contains only one occurrence of each digit
+
+\b every block contains only one occurrence of each digit.
+
+\b (optionally, by default off) each of the square's two main
+diagonals contains only one occurrence of each digit.
+
+You are given some of the numbers as clues; your aim is to place the
+rest of the numbers correctly.
+
+Under the default settings, the sub-blocks are square or
+rectangular. The default puzzle size is 3\by\.3 (a 9\by\.9 actual
+grid, divided into nine 3\by\.3 blocks). You can also select sizes
+with rectangular blocks instead of square ones, such as 2\by\.3 (a
+6\by\.6 grid divided into six 3\by\.2 blocks). Alternatively, you
+can select \q{jigsaw} mode, in which the sub-blocks are arbitrary
+shapes which differ between individual puzzles.
+
+Another available mode is \q{killer}. In this mode, clues are not
+given in the form of filled-in squares; instead, the grid is divided
+into \q{cages} by coloured lines, and for each cage the game tells
+you what the sum of all the digits in that cage should be. Also, no
+digit may appear more than once within a cage, even if the cage
+crosses the boundaries of existing regions.
+
+If you select a puzzle size which requires more than 9 digits, the
+additional digits will be letters of the alphabet. For example, if
+you select 3\by\.4 then the digits which go in your grid will be 1
+to 9, plus \cq{a}, \cq{b} and \cq{c}. This cannot be selected for
+killer puzzles.
+
+I first saw this puzzle in \i{Nikoli} \k{nikoli-solo}, although it's
+also been popularised by various newspapers under the name
+\q{Sudoku} or \q{Su Doku}.  Howard Garns is considered the inventor
+of the modern form of the puzzle, and it was first published in
+\e{Dell Pencil Puzzles and Word Games}.  A more elaborate treatment
+of the history of the puzzle can be found on Wikipedia
+\k{wikipedia-solo}.
+
+\B{nikoli-solo} \W{http://www.nikoli.co.jp/en/puzzles/sudoku.html}\cw{http://www.nikoli.co.jp/en/puzzles/sudoku.html}
+(beware of Flash)
+
+\B{wikipedia-solo} \W{http://en.wikipedia.org/wiki/Sudoku}\cw{http://en.wikipedia.org/wiki/Sudoku}
+
+\H{solo-controls} \I{controls, for Solo}Solo controls
+
+To play Solo, simply click the mouse in any empty square and then
+type a digit or letter on the keyboard to fill that square. If you
+make a mistake, click the mouse in the incorrect square and press
+Space to clear it again (or use the Undo feature).
+
+If you \e{right}-click in a square and then type a number, that
+number will be entered in the square as a \q{pencil mark}. You can
+have pencil marks for multiple numbers in the same square. Squares
+containing filled-in numbers cannot also contain pencil marks.
+
+The game pays no attention to pencil marks, so exactly what you use
+them for is up to you: you can use them as reminders that a
+particular square needs to be re-examined once you know more about a
+particular number, or you can use them as lists of the possible
+numbers in a given square, or anything else you feel like.
+
+To erase a single pencil mark, right-click in the square and type
+the same number again.
+
+All pencil marks in a square are erased when you left-click and type
+a number, or when you left-click and press space. Right-clicking and
+pressing space will also erase pencil marks.
+
+Alternatively, use the cursor keys to move the mark around the grid.
+Pressing the return key toggles the mark (from a normal mark to a
+pencil mark), and typing a number in is entered in the square in the
+appropriate way; typing in a 0 or using the space bar will clear a
+filled square. 
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{solo-parameters} \I{parameters, for Solo}Solo parameters
+
+Solo allows you to configure two separate dimensions of the puzzle
+grid on the \q{Type} menu: the number of columns, and the number of
+rows, into which the main grid is divided. (The size of a block is
+the inverse of this: for example, if you select 2 columns and 3 rows,
+each actual block will have 3 columns and 2 rows.)
+
+If you tick the \q{X} checkbox, Solo will apply the optional extra
+constraint that the two main diagonals of the grid also contain one
+of every digit. (This is sometimes known as \q{Sudoku-X} in
+newspapers.) In this mode, the squares on the two main diagonals
+will be shaded slightly so that you know it's enabled.
+
+If you tick the \q{Jigsaw} checkbox, Solo will generate randomly
+shaped sub-blocks. In this mode, the actual grid size will be taken
+to be the product of the numbers entered in the \q{Columns} and
+\q{Rows} boxes. There is no reason why you have to enter a number
+greater than 1 in both boxes; Jigsaw mode has no constraint on the
+grid size, and it can even be a prime number if you feel like it.
+
+If you tick the \q{Killer} checkbox, Solo will generate a set of
+of cages, which are randomly shaped and drawn in an outline of a
+different colour.  Each of these regions contains a smaller clue
+which shows the digit sum of all the squares in this region.
+
+You can also configure the type of symmetry shown in the generated
+puzzles. More symmetry makes the puzzles look prettier but may also
+make them easier, since the symmetry constraints can force more
+clues than necessary to be present. Completely asymmetric puzzles
+have the freedom to contain as few clues as possible.
+
+Finally, you can configure the difficulty of the generated puzzles.
+Difficulty levels are judged by the complexity of the techniques of
+deduction required to solve the puzzle: each level requires a mode
+of reasoning which was not necessary in the previous one. In
+particular, on difficulty levels \q{Trivial} and \q{Basic} there
+will be a square you can fill in with a single number at all times,
+whereas at \q{Intermediate} level and beyond you will have to make
+partial deductions about the \e{set} of squares a number could be in
+(or the set of numbers that could be in a square).
+\#{Advanced, Extreme?}
+At \q{Unreasonable} level, even this is not enough, and you will
+eventually have to make a guess, and then backtrack if it turns out
+to be wrong.
+
+Generating difficult puzzles is itself difficult: if you select one
+of the higher difficulty levels, Solo may have to make many attempts
+at generating a puzzle before it finds one hard enough for you. Be
+prepared to wait, especially if you have also configured a large
+puzzle size.
+
+
+\C{mines} \i{Mines}
+
+\cfg{winhelp-topic}{games.mines}
+
+You have a grid of covered squares, some of which contain mines, but
+you don't know which. Your job is to uncover every square which does
+\e{not} contain a mine. If you uncover a square containing a mine,
+you lose. If you uncover a square which does not contain a mine, you
+are told how many mines are contained within the eight surrounding
+squares.
+
+This game needs no introduction; popularised by Windows, it is
+perhaps the single best known desktop puzzle game in existence.
+
+This version of it has an unusual property. By default, it will
+generate its mine positions in such a way as to ensure that you
+never need to \e{guess} where a mine is: you will always be able to
+deduce it somehow. So you will never, as can happen in other
+versions, get to the last four squares and discover that there are
+two mines left but you have no way of knowing for sure where they
+are.
+
+\H{mines-controls} \I{controls, for Mines}Mines controls
+
+This game is played with the mouse.
+
+If you left-click in a covered square, it will be uncovered.
+
+If you right-click in a covered square, it will place a flag which
+indicates that the square is believed to be a mine. Left-clicking in
+a marked square will not uncover it, for safety. You can right-click
+again to remove a mark placed in error.
+
+If you left-click in an \e{uncovered} square, it will \q{clear
+around} the square. This means: if the square has exactly as many
+flags surrounding it as it should have mines, then all the covered
+squares next to it which are \e{not} flagged will be uncovered. So
+once you think you know the location of all the mines around a
+square, you can use this function as a shortcut to avoid having to
+click on each of the remaining squares one by one.
+
+If you uncover a square which has \e{no} mines in the surrounding
+eight squares, then it is obviously safe to uncover those squares in
+turn, and so on if any of them also has no surrounding mines. This
+will be done for you automatically; so sometimes when you uncover a
+square, a whole new area will open up to be explored.
+
+You can also use the cursor keys to move around the minefield.
+Pressing the return key in a covered square uncovers it, and in an
+uncovered square will clear around it (so it acts as the left button),
+pressing the space bar in a covered square will place a flag
+(similarly, it acts as the right button).
+
+All the actions described in \k{common-actions} are also available.
+
+Even Undo is available, although you might consider it cheating to
+use it. If you step on a mine, the program will only reveal the mine
+in question (unlike most other implementations, which reveal all of
+them). You can then Undo your fatal move and continue playing if you
+like. The program will track the number of times you died (and Undo
+will not reduce that counter), so when you get to the end of the
+game you know whether or not you did it without making any errors.
+
+(If you really want to know the full layout of the grid, which other
+implementations will show you after you die, you can always use the
+Solve menu option.)
+
+\H{mines-parameters} \I{parameters, for Mines}Mines parameters
+
+The options available from the \q{Custom...} option on the \q{Type}
+menu are:
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Mines}
+
+\dd Number of mines in the grid. You can enter this as an absolute
+mine count, or alternatively you can put a \cw{%} sign on the end in
+which case the game will arrange for that proportion of the squares
+in the grid to be mines.
+
+\lcont{
+
+Beware of setting the mine count too high. At very high densities,
+the program may spend forever searching for a solvable grid.
+
+}
+
+\dt \e{Ensure solubility}
+
+\dd When this option is enabled (as it is by default), Mines will
+ensure that the entire grid can be fully deduced starting from the
+initial open space. If you prefer the riskier grids generated by
+other implementations, you can switch off this option.
+
+
+\C{samegame} \i{Same Game}
+
+\cfg{winhelp-topic}{games.samegame}
+
+You have a grid of coloured squares, which you have to clear by 
+highlighting contiguous regions of more than one coloured square;
+the larger the region you highlight, the more points you get (and
+the faster you clear the arena).
+
+If you clear the grid you win. If you end up with nothing but 
+single squares (i.e., there are no more clickable regions left) you
+lose.
+
+Removing a region causes the rest of the grid to shuffle up:
+blocks that are suspended will fall down (first), and then empty
+columns are filled from the right. 
+
+Same Game was contributed to this collection by James Harvey.
+
+\H{samegame-controls} \i{Same Game controls}
+
+\IM{Same Game controls} controls, for Same Game
+\IM{Same Game controls} keys, for Same Game
+\IM{Same Game controls} shortcuts (keyboard), for Same Game
+
+This game can be played with either the keyboard or the mouse.
+
+If you left-click an unselected region, it becomes selected (possibly
+clearing the current selection). 
+
+If you left-click the selected region, it will be removed (and the
+rest of the grid shuffled immediately).
+
+If you right-click the selected region, it will be unselected. 
+
+The cursor keys move a cursor around the grid. Pressing the Space or
+Enter keys while the cursor is in an unselected region selects it;
+pressing Space or Enter again removes it as above.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{samegame-parameters} \I{parameters, for Same Game}Same Game parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{No. of colours}
+
+\dd Number of different colours used to fill the grid; the more colours,
+the fewer large regions of colour and thus the more difficult it is to
+successfully clear the grid.
+
+\dt \e{Scoring system}
+
+\dd Controls the precise mechanism used for scoring. With the default
+system, \q{(n-2)^2}, only regions of three squares or more will score
+any points at all. With the alternative \q{(n-1)^2} system, regions of
+two squares score a point each, and larger regions score relatively
+more points.
+
+\dt \e{Ensure solubility}
+
+\dd If this option is ticked (the default state), generated grids
+will be guaranteed to have at least one solution.
+
+\lcont{
+
+If you turn it off, the game generator will not try to guarantee
+soluble grids; it will, however, still ensure that there are at
+least 2 squares of each colour on the grid at the start (since a
+grid with exactly one square of a given colour is \e{definitely}
+insoluble). Grids generated with this option disabled may contain
+more large areas of contiguous colour, leading to opportunities for
+higher scores; they can also take less time to generate.
+
+}
+
+
+\C{flip} \i{Flip}
+
+\cfg{winhelp-topic}{games.flip}
+
+You have a grid of squares, some light and some dark. Your aim is to
+light all the squares up at the same time. You can choose any square
+and flip its state from light to dark or dark to light, but when you
+do so, other squares around it change state as well.
+
+Each square contains a small diagram showing which other squares
+change when you flip it.
+
+\H{flip-controls} \i{Flip controls}
+
+\IM{Flip controls} controls, for Flip
+\IM{Flip controls} keys, for Flip
+\IM{Flip controls} shortcuts (keyboard), for Flip
+
+This game can be played with either the keyboard or the mouse.
+
+Left-click in a square to flip it and its associated squares, or
+use the cursor keys to choose a square and the space bar or Enter
+key to flip.
+
+If you use the \q{Solve} function on this game, it will mark some of
+the squares in red. If you click once in every square with a red
+mark, the game should be solved. (If you click in a square
+\e{without} a red mark, a red mark will appear in it to indicate
+that you will need to reverse that operation to reach the solution.)
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{flip-parameters} \I{parameters, for flip}Flip parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Shape type}
+
+\dd This control determines the shape of the region which is flipped
+by clicking in any given square. The default setting, \q{Crosses},
+causes every square to flip itself and its four immediate neighbours
+(or three or two if it's at an edge or corner). The other setting,
+\q{Random}, causes a random shape to be chosen for every square, so
+the game is different every time.
+
+
+\C{guess} \i{Guess}
+
+\cfg{winhelp-topic}{games.guess}
+
+You have a set of coloured pegs, and have to reproduce a
+predetermined sequence of them (chosen by the computer) within a
+certain number of guesses. 
+
+Each guess gets marked with the number of correctly-coloured pegs
+in the correct places (in black), and also the number of
+correctly-coloured pegs in the wrong places (in white). 
+
+This game is also known (and marketed, by Hasbro, mainly) as
+a board game \q{\i{Mastermind}}, with 6 colours, 4 pegs per row,
+and 10 guesses. However, this version allows custom settings of number
+of colours (up to 10), number of pegs per row, and number of guesses. 
+
+Guess was contributed to this collection by James Harvey.
+
+\H{guess-controls} \i{Guess controls}
+
+\IM{Guess controls} controls, for Guess
+\IM{Guess controls} keys, for Guess
+\IM{Guess controls} shortcuts (keyboard), for Guess
+
+This game can be played with either the keyboard or the mouse.
+
+With the mouse, drag a coloured peg from the tray on the left-hand
+side to its required position in the current guess; pegs may also be
+dragged from current and past guesses to copy them elsewhere. To
+remove a peg, drag it off its current position to somewhere invalid.
+
+Right-clicking in the current guess adds a \q{hold} marker; pegs
+that have hold markers will be automatically added to the next guess
+after marking.
+
+Alternatively, with the keyboard, the up and down cursor keys can be
+used to select a peg colour, the left and right keys to select a
+peg position, and the space bar or Enter key to place a peg of the
+selected colour in the chosen position. \q{D} or Backspace removes a
+peg, and Space adds a hold marker.
+
+Pressing \q{h} or \q{?} will fill the current guess with a suggested
+guess.  Using this is not recommended for 10 or more pegs as it is
+slow.
+
+When the guess is complete, the smaller feedback pegs will be highlighted;
+clicking on these (or moving the peg cursor to them with the arrow keys
+and pressing the space bar or Enter key) will mark the current guess,
+copy any held pegs to the next guess, and move the \q{current guess}
+marker.
+
+If you correctly position all the pegs the solution will be displayed
+below; if you run out of guesses (or select \q{Solve...}) the solution
+will also be revealed.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{guess-parameters} \I{parameters, for Guess}Guess parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu. The default game matches the parameters for the 
+board game \q{Mastermind}. 
+
+\dt \e{Colours}
+
+\dd Number of colours the solution is chosen from; from 2 to 10
+(more is harder).
+
+\dt \e{Pegs per guess}
+
+\dd Number of pegs per guess (more is harder).
+
+\dt \e{Guesses}
+
+\dd Number of guesses you have to find the solution in (fewer is harder).
+
+\dt \e{Allow blanks}
+
+\dd Allows blank pegs to be given as part of a guess (makes it easier, because
+you know that those will never be counted as part of the solution). This
+is turned off by default. 
+
+\lcont{
+
+Note that this doesn't allow blank pegs in the solution; if you really wanted
+that, use one extra colour.
+
+}
+
+\dt \e{Allow duplicates}
+
+\dd Allows the solution (and the guesses) to contain colours more than once;
+this increases the search space (making things harder), and is turned on by
+default.
+
+
+\C{pegs} \i{Pegs}
+
+\cfg{winhelp-topic}{games.pegs}
+
+A number of pegs are placed in holes on a board. You can remove a
+peg by jumping an adjacent peg over it (horizontally or vertically)
+to a vacant hole on the other side. Your aim is to remove all but one
+of the pegs initially present.
+
+This game, best known as \I{Solitaire, Peg}\q{Peg Solitaire}, is
+possibly one of the oldest puzzle games still commonly known.
+
+\H{pegs-controls} \i{Pegs controls}
+
+\IM{Pegs controls} controls, for Pegs
+
+To move a peg, drag it with the mouse from its current position to
+its final position. If the final position is exactly two holes away
+from the initial position, is currently unoccupied by a peg, and
+there is a peg in the intervening square, the move will be permitted
+and the intervening peg will be removed.
+
+Vacant spaces which you can move a peg into are marked with holes. A
+space with no peg and no hole is not available for moving at all: it
+is an obstacle which you must work around.
+
+You can also use the cursor keys to move a position indicator around
+the board. Pressing the return key while over a peg, followed by a
+cursor key, will jump the peg in that direction (if that is a legal
+move).
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{pegs-parameters} \I{parameters, for Pegs}Pegs parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in holes.
+
+\dt \e{Board type}
+
+\dd Controls whether you are given a board of a standard shape or a
+randomly generated shape. The two standard shapes currently
+supported are \q{Cross} and \q{Octagon} (also commonly known as the
+English and European traditional board layouts respectively).
+Selecting \q{Random} will give you a different board shape every
+time (but always one that is known to have a solution).
+
+
+\C{dominosa} \i{Dominosa}
+
+\cfg{winhelp-topic}{games.dominosa}
+
+A normal set of dominoes \dash that is, one instance of every
+(unordered) pair of numbers from 0 to 6 \dash has been arranged
+irregularly into a rectangle; then the number in each square has
+been written down and the dominoes themselves removed. Your task is
+to reconstruct the pattern by arranging the set of dominoes to match
+the provided array of numbers.
+
+This puzzle is widely credited to O. S. Adler, and takes part of its
+name from those initials.
+
+\H{dominosa-controls} \i{Dominosa controls}
+
+\IM{Dominosa controls} controls, for Dominosa
+
+Left-clicking between any two adjacent numbers places a domino
+covering them, or removes one if it is already present. Trying to
+place a domino which overlaps existing dominoes will remove the ones
+it overlaps.
+
+Right-clicking between two adjacent numbers draws a line between
+them, which you can use to remind yourself that you know those two
+numbers are \e{not} covered by a single domino. Right-clicking again
+removes the line.
+
+You can also use the cursor keys to move a cursor around the grid.
+When the cursor is half way between two adjacent numbers, pressing
+the return key will place a domino covering those numbers, or
+pressing the space bar will lay a line between the two squares.
+Repeating either action removes the domino or line.
+
+Pressing a number key will highlight all occurrences of that
+number. Pressing that number again will clear the highlighting. Up to two
+different numbers can be highlighted at any given time.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{dominosa-parameters} \I{parameters, for Dominosa}Dominosa parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Maximum number on dominoes}
+
+\dd Controls the size of the puzzle, by controlling the size of the
+set of dominoes used to make it. Dominoes with numbers going up to N
+will give rise to an (N+2) \by (N+1) rectangle; so, in particular,
+the default value of 6 gives an 8\by\.7 grid.
+
+\dt \e{Ensure unique solution}
+
+\dd Normally, Dominosa will make sure that the puzzles it presents
+have only one solution. Puzzles with ambiguous sections can be more
+difficult and sometimes more subtle, so if you like you can turn off
+this feature. Also, finding \e{all} the possible solutions can be an
+additional challenge for an advanced player. Turning off this option
+can also speed up puzzle generation.
+
+
+\C{untangle} \i{Untangle}
+
+\cfg{winhelp-topic}{games.untangle}
+
+You are given a number of points, some of which have lines drawn
+between them. You can move the points about arbitrarily; your aim is
+to position the points so that no line crosses another.
+
+I originally saw this in the form of a Flash game called \i{Planarity}
+\k{Planarity}, written by John Tantalo.
+
+\B{Planarity} \W{http://planarity.net}\cw{http://planarity.net}
+
+\H{untangle-controls} \i{Untangle controls}
+
+\IM{Untangle controls} controls, for Untangle
+
+To move a point, click on it with the left mouse button and drag it
+into a new position.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{untangle-parameters} \I{parameters, for Untangle}Untangle parameters
+
+There is only one parameter available from the \q{Custom...} option
+on the \q{Type} menu:
+
+\dt \e{Number of points}
+
+\dd Controls the size of the puzzle, by specifying the number of
+points in the generated graph.
+
+
+\C{blackbox} \i{Black Box}
+
+\cfg{winhelp-topic}{games.blackbox}
+
+A number of balls are hidden in a rectangular arena. You have to
+deduce the positions of the balls by firing lasers positioned at
+the edges of the arena and observing how their beams are deflected. 
+
+Beams will travel straight from their origin until they hit the
+opposite side of the arena (at which point they emerge), unless
+affected by balls in one of the following ways:
+
+\b A beam that hits a ball head-on is absorbed and will never
+   re-emerge. This includes beams that meet a ball on the first rank
+   of the arena.
+
+\b A beam with a ball in its front-left square and no ball ahead of it
+   gets deflected 90 degrees to the right.
+
+\b A beam with a ball in its front-right square and no ball ahead of
+   it gets similarly deflected to the left.
+
+\b A beam that would re-emerge from its entry location is considered to be
+   \q{reflected}. 
+
+\b A beam which would get deflected before entering the arena by a
+   ball to the front-left or front-right of its entry point is also
+   considered to be \q{reflected}.
+
+Beams that are reflected appear as a \q{R}; beams that hit balls
+head-on appear as \q{H}. Otherwise, a number appears at the firing
+point and the location where the beam emerges (this number is unique
+to that shot).
+
+You can place guesses as to the location of the balls, based on the
+entry and exit patterns of the beams; once you have placed enough
+balls a button appears enabling you to have your guesses checked. 
+
+Here is a diagram showing how the positions of balls can create each
+of the beam behaviours shown above:
+
+\c  1RHR---- 
+\c |..O.O...|
+\c 2........3
+\c |........|
+\c |........|
+\c 3........|
+\c |......O.|
+\c H........|
+\c |.....O..|
+\c  12-RR---
+
+As shown, it is possible for a beam to receive multiple reflections
+before re-emerging (see turn 3). Similarly, a beam may be reflected
+(possibly more than once) before receiving a hit (the \q{H} on the
+left side of the example).
+
+Note that any layout with more than 4 balls may have a non-unique
+solution.  The following diagram illustrates this; if you know the
+board contains 5 balls, it is impossible to determine where the fifth
+ball is (possible positions marked with an \cw{x}):
+
+\c  -------- 
+\c |........|
+\c |........|
+\c |..O..O..|
+\c |...xx...|
+\c |...xx...|
+\c |..O..O..|
+\c |........|
+\c |........|
+\c  --------
+
+For this reason, when you have your guesses checked, the game will
+check that your solution \e{produces the same results} as the
+computer's, rather than that your solution is identical to the
+computer's. So in the above example, you could put the fifth ball at
+\e{any} of the locations marked with an \cw{x}, and you would still
+win.
+
+Black Box was contributed to this collection by James Harvey.
+
+\H{blackbox-controls} \i{Black Box controls}
+
+\IM{Black Box controls} controls, for Black Box
+\IM{Black Box controls} keys, for Black Box
+\IM{Black Box controls} shortcuts (keyboard), for Black Box
+
+To fire a laser beam, left-click in a square around the edge of the
+arena. The results will be displayed immediately. Clicking or holding
+the left button on one of these squares will highlight the current go
+(or a previous go) to confirm the exit point for that laser, if
+applicable.
+
+To guess the location of a ball, left-click within the arena and a
+black circle will appear marking the guess; click again to remove the
+guessed ball.
+
+Locations in the arena may be locked against modification by
+right-clicking; whole rows and columns may be similarly locked by
+right-clicking in the laser square above/below that column, or to the
+left/right of that row.
+
+The cursor keys may also be used to move around the grid. Pressing the
+Enter key will fire a laser or add a new ball-location guess, and
+pressing Space will lock a cell, row, or column.
+
+When an appropriate number of balls have been guessed, a button will
+appear at the top-left corner of the grid; clicking that (with mouse
+or cursor) will check your guesses. 
+
+If you click the \q{check} button and your guesses are not correct,
+the game will show you the minimum information necessary to
+demonstrate this to you, so you can try again. If your ball
+positions are not consistent with the beam paths you already know
+about, one beam path will be circled to indicate that it proves you
+wrong. If your positions match all the existing beam paths but are
+still wrong, one new beam path will be revealed (written in red)
+which is not consistent with your current guesses.
+
+If you decide to give up completely, you can select Solve to reveal
+the actual ball positions. At this point, correctly-placed balls
+will be displayed as filled black circles, incorrectly-placed balls
+as filled black circles with red crosses, and missing balls as filled
+red circles. In addition, a red circle marks any laser you had already
+fired which is not consistent with your ball layout (just as when you
+press the \q{check} button), and red text marks any laser you
+\e{could} have fired in order to distinguish your ball layout from the
+correct one.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{blackbox-parameters} \I{parameters, for Black Box}Black Box parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares. There are 2 \by \e{Width} \by \e{Height} lasers 
+per grid, two per row and two per column. 
+
+\dt \e{No. of balls}
+
+\dd Number of balls to place in the grid. This can be a single number,
+or a range (separated with a hyphen, like \q{2-6}), and determines the
+number of balls to place on the grid. The \q{reveal} button is only
+enabled if you have guessed an appropriate number of balls; a guess
+using a different number to the original solution is still acceptable,
+if all the beam inputs and outputs match.
+
+
+\C{slant} \i{Slant}
+
+\cfg{winhelp-topic}{games.slant}
+
+You have a grid of squares. Your aim is to draw a diagonal line
+through each square, and choose which way each line slants so that
+the following conditions are met:
+
+\b The diagonal lines never form a loop.
+
+\b Any point with a circled number has precisely that many lines
+meeting at it. (Thus, a 4 is the centre of a cross shape, whereas a
+zero is the centre of a diamond shape \dash or rather, a partial
+diamond shape, because a zero can never appear in the middle of the
+grid because that would immediately cause a loop.)
+
+Credit for this puzzle goes to \i{Nikoli} \k{nikoli-slant}.
+
+\B{nikoli-slant}
+\W{http://www.nikoli.co.jp/ja/puzzles/gokigen_naname}\cw{http://www.nikoli.co.jp/ja/puzzles/gokigen_naname}
+(in Japanese)
+
+\H{slant-controls} \i{Slant controls}
+
+\IM{Slant controls} controls, for Slant
+
+Left-clicking in a blank square will place a \cw{\\} in it (a line
+leaning to the left, i.e. running from the top left of the square to
+the bottom right). Right-clicking in a blank square will place a
+\cw{/} in it (leaning to the right, running from top right to bottom
+left).
+
+Continuing to click either button will cycle between the three
+possible square contents. Thus, if you left-click repeatedly in a
+blank square it will change from blank to \cw{\\} to \cw{/} back to
+blank, and if you right-click repeatedly the square will change from
+blank to \cw{/} to \cw{\\} back to blank. (Therefore, you can play
+the game entirely with one button if you need to.)
+
+You can also use the cursor keys to move around the grid. Pressing the
+return or space keys will place a \cw{\\} or a \cw{/}, respectively,
+and will then cycle them as above.  You can also press \cw{/} or
+\cw{\\} to place a \cw{/} or \cw{\\}, respectively, independent of
+what is already in the cursor square.  Backspace removes any line from
+the cursor square.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{slant-parameters} \I{parameters, for Slant}Slant parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle. At Hard level,
+you are required to do deductions based on knowledge of
+\e{relationships} between squares rather than always being able to
+deduce the exact contents of one square at a time. (For example, you
+might know that two squares slant in the same direction, even if you
+don't yet know what that direction is, and this might enable you to
+deduce something about still other squares.) Even at Hard level,
+guesswork and backtracking should never be necessary.
+
+
+\C{lightup} \i{Light Up}
+
+\cfg{winhelp-topic}{games.lightup}
+
+You have a grid of squares. Some are filled in black; some of the
+black squares are numbered. Your aim is to \q{light up} all the
+empty squares by placing light bulbs in some of them.
+
+Each light bulb illuminates the square it is on, plus all squares in
+line with it horizontally or vertically unless a black square is
+blocking the way.
+
+To win the game, you must satisfy the following conditions:
+
+\b All non-black squares are lit.
+
+\b No light is lit by another light.
+
+\b All numbered black squares have exactly that number of lights adjacent to
+   them (in the four squares above, below, and to the side).
+
+Non-numbered black squares may have any number of lights adjacent to them. 
+
+Credit for this puzzle goes to \i{Nikoli} \k{nikoli-lightup}.
+
+Light Up was contributed to this collection by James Harvey.
+
+\B{nikoli-lightup}
+\W{http://www.nikoli.co.jp/en/puzzles/akari.html}\cw{http://www.nikoli.co.jp/en/puzzles/akari.html}
+(beware of Flash)
+
+\H{lightup-controls} \i{Light Up controls}
+
+\IM{Light Up controls} controls, for Light Up
+
+Left-clicking in a non-black square will toggle the presence of a light
+in that square. Right-clicking in a non-black square toggles a mark there to aid
+solving; it can be used to highlight squares that cannot be lit, for example. 
+
+You may not place a light in a marked square, nor place a mark in a lit square.
+
+The game will highlight obvious errors in red. Lights lit by other
+lights are highlighted in this way, as are numbered squares which
+do not (or cannot) have the right number of lights next to them.
+  
+Thus, the grid is solved when all non-black squares have yellow
+highlights and there are no red lights.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{lightup-parameters} \I{parameters, for Light Up}Light Up parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{%age of black squares}
+
+\dd Rough percentage of black squares in the grid.
+
+\lcont{
+
+This is a hint rather than an instruction. If the grid generator is
+unable to generate a puzzle to this precise specification, it will
+increase the proportion of black squares until it can.
+
+}
+
+\dt \e{Symmetry}
+
+\dd Allows you to specify the required symmetry of the black squares
+in the grid. (This does not affect the difficulty of the puzzles
+noticeably.)
+
+\dt \e{Difficulty}
+
+\dd \q{Easy} means that the puzzles should be soluble without
+backtracking or guessing, \q{Hard} means that some guesses will
+probably be necessary.
+
+
+\C{map} \i{Map}
+
+\cfg{winhelp-topic}{games.map}
+
+You are given a map consisting of a number of regions. Your task is
+to colour each region with one of four colours, in such a way that
+no two regions sharing a boundary have the same colour. You are
+provided with some regions already coloured, sufficient to make the
+remainder of the solution unique.
+
+Only regions which share a length of border are required to be
+different colours. Two regions which meet at only one \e{point}
+(i.e. are diagonally separated) may be the same colour.
+
+I believe this puzzle is original; I've never seen an implementation
+of it anywhere else. The concept of a \i{four-colouring} puzzle was
+suggested by Owen Dunn; credit must also go to Nikoli and to Verity
+Allan for inspiring the train of thought that led to me realising
+Owen's suggestion was a viable puzzle. Thanks also to Gareth Taylor
+for many detailed suggestions.
+
+\H{map-controls} \i{Map controls}
+
+\IM{Map controls} controls, for Map
+
+To colour a region, click the left mouse button on an existing
+region of the desired colour and drag that colour into the new
+region.
+
+(The program will always ensure the starting puzzle has at least one
+region of each colour, so that this is always possible!)
+
+If you need to clear a region, you can drag from an empty region, or
+from the puzzle boundary if there are no empty regions left.
+
+Dragging a colour using the \e{right} mouse button will stipple the
+region in that colour, which you can use as a note to yourself that
+you think the region \e{might} be that colour. A region can contain
+stipples in multiple colours at once. (This is often useful at the
+harder difficulty levels.)
+
+You can also use the cursor keys to move around the map: the colour of
+the cursor indicates the position of the colour you would drag (which
+is not obvious if you're on a region's boundary, since it depends on the
+direction from which you approached the boundary). Pressing the return
+key starts a drag of that colour, as above, which you control with the
+cursor keys; pressing the return key again finishes the drag. The
+space bar can be used similarly to create a stippled region. 
+Double-pressing the return key (without moving the cursor) will clear
+the region, as a drag from an empty region does: this is useful with
+the cursor mode if you have filled the entire map in but need to 
+correct the layout.
+
+If you press L during play, the game will toggle display of a number
+in each region of the map. This is useful if you want to discuss a
+particular puzzle instance with a friend \dash having an unambiguous
+name for each region is much easier than trying to refer to them all
+by names such as \q{the one down and right of the brown one on the
+top border}.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{map-parameters} \I{parameters, for Map}Map parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Regions}
+
+\dd Number of regions in the generated map.
+
+\dt \e{Difficulty}
+
+\dd In \q{Easy} mode, there should always be at least one region
+whose colour can be determined trivially. In \q{Normal} and \q{Hard}
+modes, you will have to use increasingly complex logic to deduce the
+colour of some regions. However, it will always be possible without
+having to guess or backtrack.
+
+\lcont{
+
+In \q{Unreasonable} mode, the program will feel free to generate
+puzzles which are as hard as it can possibly make them: the only
+constraint is that they should still have a unique solution. Solving
+Unreasonable puzzles may require guessing and backtracking.
+
+}
+
+
+\C{loopy} \i{Loopy}
+
+\cfg{winhelp-topic}{games.loopy}
+
+You are given a grid of dots, marked with yellow lines to indicate
+which dots you are allowed to connect directly together. Your aim is
+to use some subset of those yellow lines to draw a single unbroken
+loop from dot to dot within the grid.
+
+Some of the spaces between the lines contain numbers. These numbers
+indicate how many of the lines around that space form part of the
+loop. The loop you draw must correctly satisfy all of these clues to
+be considered a correct solution.
+
+In the default mode, the dots are arranged in a grid of squares;
+however, you can also play on triangular or hexagonal grids, or even
+more exotic ones.
+
+Credit for the basic puzzle idea goes to \i{Nikoli}
+\k{nikoli-loopy}.
+
+Loopy was originally contributed to this collection by Mike Pinna,
+and subsequently enhanced to handle various types of non-square grid
+by Lambros Lambrou.
+
+\B{nikoli-loopy}
+\W{http://www.nikoli.co.jp/en/puzzles/slitherlink.html}\cw{http://www.nikoli.co.jp/en/puzzles/slitherlink.html}
+(beware of Flash)
+
+\H{loopy-controls} \i{Loopy controls}
+
+\IM{Loopy controls} controls, for Loopy
+
+Click the left mouse button on a yellow line to turn it black,
+indicating that you think it is part of the loop. Click again to
+turn the line yellow again (meaning you aren't sure yet).
+
+If you are sure that a particular line segment is \e{not} part of
+the loop, you can click the right mouse button to remove it
+completely. Again, clicking a second time will turn the line back to
+yellow.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{loopy-parameters} \I{parameters, for Loopy}Loopy parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid, measured in number of regions across and down. For
+square grids, it's clear how this is counted; for other types of
+grid you may have to think a bit to see how the dimensions are
+measured.
+
+\dt \e{Grid type}
+
+\dd Allows you to choose between a selection of types of tiling.
+Some have all the faces the same but may have multiple different
+types of vertex (e.g. the \e{Cairo} or \e{Kites} mode); others have
+all the vertices the same but may have different types of face (e.g.
+the \e{Great Hexagonal}). The square, triangular and honeycomb grids
+are fully regular, and have all their vertices \e{and} faces the
+same; this makes them the least confusing to play.
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle.
+\#{FIXME: what distinguishes Easy, Medium, and Hard? In particular,
+when are backtracking/guesswork required, if ever?}
+
+
+\C{inertia} \i{Inertia}
+
+\cfg{winhelp-topic}{games.inertia}
+
+You are a small green ball sitting in a grid full of obstacles. Your
+aim is to collect all the gems without running into any mines.
+
+You can move the ball in any orthogonal \e{or diagonal} direction.
+Once the ball starts moving, it will continue until something stops
+it. A wall directly in its path will stop it (but if it is moving
+diagonally, it will move through a diagonal gap between two other
+walls without stopping). Also, some of the squares are \q{stops};
+when the ball moves on to a stop, it will stop moving no matter what
+direction it was going in. Gems do \e{not} stop the ball; it picks
+them up and keeps on going.
+
+Running into a mine is fatal. Even if you picked up the last gem in
+the same move which then hit a mine, the game will count you as dead
+rather than victorious.
+
+This game was originally implemented for Windows by Ben Olmstead
+\k{bem}, who was kind enough to release his source code on request
+so that it could be re-implemented for this collection.
+
+\B{bem} \W{http://xn13.com/}\cw{http://xn13.com/}
+
+\H{inertia-controls} \i{Inertia controls}
+
+\IM{Inertia controls} controls, for Inertia
+\IM{Inertia controls} keys, for Inertia
+\IM{Inertia controls} shortcuts (keyboard), for Inertia
+
+You can move the ball in any of the eight directions using the
+numeric keypad. Alternatively, if you click the left mouse button on
+the grid, the ball will begin a move in the general direction of
+where you clicked.
+
+If you use the \q{Solve} function on this game, the program will
+compute a path through the grid which collects all the remaining
+gems and returns to the current position. A hint arrow will appear
+on the ball indicating the direction in which you should move to
+begin on this path. If you then move in that direction, the arrow
+will update to indicate the next direction on the path. You can also
+press Space to automatically move in the direction of the hint
+arrow. If you move in a different direction from the one shown by
+the arrow, arrows will be shown only if the puzzle is still solvable.
+
+All the actions described in \k{common-actions} are also available.
+In particular, if you do run into a mine and die, you can use the
+Undo function and resume playing from before the fatal move. The
+game will keep track of the number of times you have done this.
+
+\H{inertia-parameters} \I{parameters, for Inertia}Inertia parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+
+\C{tents} \i{Tents}
+
+\cfg{winhelp-topic}{games.tents}
+
+You have a grid of squares, some of which contain trees. Your aim is
+to place tents in some of the remaining squares, in such a way that
+the following conditions are met:
+
+\b There are exactly as many tents as trees.
+
+\b The tents and trees can be matched up in such a way that each
+tent is directly adjacent (horizontally or vertically, but not
+diagonally) to its own tree. However, a tent may be adjacent to
+other trees as well as its own.
+
+\b No two tents are adjacent horizontally, vertically \e{or
+diagonally}.
+
+\b The number of tents in each row, and in each column, matches the
+numbers given round the sides of the grid.
+
+This puzzle can be found in several places on the Internet, and was
+brought to my attention by e-mail. I don't know who I should credit
+for inventing it.
+
+\H{tents-controls} \i{Tents controls}
+
+\IM{Tents controls} controls, for Tents
+
+Left-clicking in a blank square will place a tent in it.
+Right-clicking in a blank square will colour it green, indicating
+that you are sure it \e{isn't} a tent. Clicking either button in an
+occupied square will clear it.
+
+If you \e{drag} with the right button along a row or column, every
+blank square in the region you cover will be turned green, and no
+other squares will be affected. (This is useful for clearing the
+remainder of a row once you have placed all its tents.)
+
+You can also use the cursor keys to move around the grid. Pressing the
+return key over an empty square will place a tent, and pressing the
+space bar over an empty square will colour it green; either key will
+clear an occupied square.  Holding Shift and pressing the cursor keys
+will colour empty squares green.  Holding Control and pressing the
+cursor keys will colour green both empty squares and squares with tents.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{tents-parameters} \I{parameters, for Tents}Tents parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle. More difficult
+puzzles require more complex deductions, but at present none of the
+available difficulty levels requires guesswork or backtracking.
+
+
+\C{bridges} \i{Bridges}
+
+\cfg{winhelp-topic}{games.bridges}
+
+You have a set of islands distributed across the playing area. Each
+island contains a number. Your aim is to connect the islands
+together with bridges, in such a way that:
+
+\b Bridges run horizontally or vertically.
+
+\b The number of bridges terminating at any island is equal to the
+number written in that island.
+
+\b Two bridges may run in parallel between the same two islands, but
+no more than two may do so.
+
+\b No bridge crosses another bridge.
+
+\b All the islands are connected together.
+
+There are some configurable alternative modes, which involve
+changing the parallel-bridge limit to something other than 2, and
+introducing the additional constraint that no sequence of bridges
+may form a loop from one island back to the same island. The rules
+stated above are the default ones.
+
+Credit for this puzzle goes to \i{Nikoli} \k{nikoli-bridges}.
+
+Bridges was contributed to this collection by James Harvey.
+
+\B{nikoli-bridges}
+\W{http://www.nikoli.co.jp/en/puzzles/hashiwokakero.html}\cw{http://www.nikoli.co.jp/en/puzzles/hashiwokakero.html}
+(beware of Flash)
+
+\H{bridges-controls} \i{Bridges controls}
+
+\IM{Bridges controls} controls, for Bridges
+
+To place a bridge between two islands, click the mouse down on one
+island and drag it towards the other. You do not need to drag all
+the way to the other island; you only need to move the mouse far
+enough for the intended bridge direction to be unambiguous. (So you
+can keep the mouse near the starting island and conveniently throw
+bridges out from it in many directions.)
+
+Doing this again when a bridge is already present will add another
+parallel bridge. If there are already as many bridges between the
+two islands as permitted by the current game rules (i.e. two by
+default), the same dragging action will remove all of them.
+
+If you want to remind yourself that two islands definitely \e{do
+not} have a bridge between them, you can right-drag between them in
+the same way to draw a \q{non-bridge} marker.
+
+If you think you have finished with an island (i.e. you have placed
+all its bridges and are confident that they are in the right
+places), you can mark the island as finished by left-clicking on it.
+This will highlight it and all the bridges connected to it, and you
+will be prevented from accidentally modifying any of those bridges
+in future. Left-clicking again on a highlighted island will unmark
+it and restore your ability to modify it.
+
+You can also use the cursor keys to move around the grid: if possible
+the cursor will always move orthogonally, otherwise it will move
+towards the nearest island to the indicated direction. Holding Control
+and pressing a cursor key will lay a bridge in that direction (if
+available); Shift and a cursor key will lay a \q{non-bridge} marker.
+Pressing the return key followed by a cursor key will also lay a
+bridge in that direction.
+
+You can mark an island as finished by pressing the space bar or by
+pressing the return key twice.
+
+By pressing a number key, you can jump to the nearest island with that
+number.  Letters \q{a}, ..., \q{f} count as 10, ..., 15 and \q{0} as
+16.
+
+Violations of the puzzle rules will be marked in red:
+
+\b An island with too many bridges will be highlighted in red.
+
+\b An island with too few bridges will be highlighted in red if it
+is definitely an error (as opposed to merely not being finished
+yet): if adding enough bridges would involve having to cross another
+bridge or remove a non-bridge marker, or if the island has been
+highlighted as complete.
+
+\b A group of islands and bridges may be highlighted in red if it is
+a closed subset of the puzzle with no way to connect it to the rest
+of the islands. For example, if you directly connect two 1s together
+with a bridge and they are not the only two islands on the grid,
+they will light up red to indicate that such a group cannot be
+contained in any valid solution.
+
+\b If you have selected the (non-default) option to disallow loops
+in the solution, a group of bridges which forms a loop will be
+highlighted.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{bridges-parameters} \I{parameters, for Bridges}Bridges parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Difficulty}
+
+\dd Difficulty level of puzzle.
+
+\dt \e{Allow loops}
+
+\dd This is set by default. If cleared, puzzles will be generated in
+such a way that they are always soluble without creating a loop, and
+solutions which do involve a loop will be disallowed.
+
+\dt \e{Max. bridges per direction}
+
+\dd Maximum number of bridges in any particular direction. The
+default is 2, but you can change it to 1, 3 or 4. In general, fewer
+is easier.
+
+\dt \e{%age of island squares}
+
+\dd Gives a rough percentage of islands the generator will try and
+lay before finishing the puzzle. Certain layouts will not manage to
+lay enough islands; this is an upper bound.
+
+\dt \e{Expansion factor (%age)}
+
+\dd The grid generator works by picking an existing island at random
+(after first creating an initial island somewhere). It then decides
+on a direction (at random), and then works out how far it could
+extend before creating another island. This parameter determines how
+likely it is to extend as far as it can, rather than choosing
+somewhere closer.
+
+\lcont{
+
+High expansion factors usually mean easier puzzles with fewer
+possible islands; low expansion factors can create lots of
+tightly-packed islands.
+
+}
+
+
+\C{unequal} \i{Unequal}
+
+\cfg{winhelp-topic}{games.unequal}
+
+You have a square grid; each square may contain a digit from 1 to
+the size of the grid, and some squares have clue signs between
+them. Your aim is to fully populate the grid with numbers such that:
+
+\b Each row contains only one occurrence of each digit
+
+\b Each column contains only one occurrence of each digit
+
+\b All the clue signs are satisfied. 
+
+There are two modes for this game, \q{Unequal} and \q{Adjacent}.
+
+In \q{Unequal} mode, the clue signs are greater-than symbols indicating one
+square's value is greater than its neighbour's. In this mode not all clues
+may be visible, particularly at higher difficulty levels. 
+
+In \q{Adjacent} mode, the clue signs are bars indicating
+one square's value is numerically adjacent (i.e. one higher or one lower)
+than its neighbour. In this mode all clues are always visible: absence of
+a bar thus means that a square's value is definitely not numerically adjacent
+to that neighbour's.  
+
+In \q{Trivial} difficulty level (available via the \q{Custom} game type
+selector), there are no greater-than signs in \q{Unequal} mode; the puzzle is
+to solve the \i{Latin square} only.
+
+At the time of writing, the \q{Unequal} mode of this puzzle is appearing in the
+Guardian weekly under the name \q{\i{Futoshiki}}.
+
+Unequal was contributed to this collection by James Harvey.
+
+\H{unequal-controls} \i{Unequal controls}
+
+\IM{Unequal controls} controls, for Unequal
+
+Unequal shares much of its control system with Solo.
+
+To play Unequal, simply click the mouse in any empty square and then
+type a digit or letter on the keyboard to fill that square. If you
+make a mistake, click the mouse in the incorrect square and press
+Space to clear it again (or use the Undo feature).
+
+If you \e{right}-click in a square and then type a number, that
+number will be entered in the square as a \q{pencil mark}. You can
+have pencil marks for multiple numbers in the same square. Squares
+containing filled-in numbers cannot also contain pencil marks.
+
+The game pays no attention to pencil marks, so exactly what you use
+them for is up to you: you can use them as reminders that a
+particular square needs to be re-examined once you know more about a
+particular number, or you can use them as lists of the possible
+numbers in a given square, or anything else you feel like.
+
+To erase a single pencil mark, right-click in the square and type
+the same number again.
+
+All pencil marks in a square are erased when you left-click and type
+a number, or when you left-click and press space. Right-clicking and
+pressing space will also erase pencil marks.
+
+As for Solo, the cursor keys can be used in conjunction with the digit
+keys to set numbers or pencil marks. You can also use the \q{M} key to
+auto-fill every numeric hint, ready for removal as required, or the \q{H}
+key to do the same but also to remove all obvious hints. 
+
+Alternatively, use the cursor keys to move the mark around the grid.
+Pressing the return key toggles the mark (from a normal mark to a
+pencil mark), and typing a number in is entered in the square in the
+appropriate way; typing in a 0 or using the space bar will clear a
+filled square. 
+
+Left-clicking a clue will mark it as done (grey it out), or unmark it
+if it is already marked.  Holding Control or Shift and pressing an
+arrow key likewise marks any clue adjacent to the cursor in the given
+direction.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{unequal-parameters} \I{parameters, for Unequal}Unequal parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Mode}
+
+\dd Mode of the puzzle (\q{Unequal} or \q{Adjacent})
+
+\dt \e{Size (s*s)}
+
+\dd Size of grid.
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle. At Trivial
+level, there are no greater-than signs; the puzzle is to solve the
+Latin square only. At Recursive level (only available via the
+\q{Custom} game type selector) backtracking will be required, but
+the solution should still be unique. The levels in between require
+increasingly complex reasoning to avoid having to backtrack.
+
+
+
+\C{galaxies} \i{Galaxies}
+
+\cfg{winhelp-topic}{games.galaxies}
+
+You have a rectangular grid containing a number of dots. Your aim is
+to draw edges along the grid lines which divide the rectangle into
+regions in such a way that every region is 180\u00b0{-degree}
+rotationally symmetric, and contains exactly one dot which is
+located at its centre of symmetry.
+
+This puzzle was invented by \i{Nikoli} \k{nikoli-galaxies}, under
+the name \q{Tentai Show}; its name is commonly translated into
+English as \q{Spiral Galaxies}.
+
+Galaxies was contributed to this collection by James Harvey.
+
+\B{nikoli-galaxies} \W{http://www.nikoli.co.jp/en/puzzles/astronomical_show.html}\cw{http://www.nikoli.co.jp/en/puzzles/astronomical_show.html}
+
+\H{galaxies-controls} \i{Galaxies controls}
+
+\IM{Galaxies controls} controls, for Galaxies
+
+Left-click on any grid line to draw an edge if there isn't one
+already, or to remove one if there is. When you create a valid
+region (one which is closed, contains exactly one dot, is
+180\u00b0{-degree} symmetric about that dot, and contains no
+extraneous edges inside it) it will be highlighted automatically; so
+your aim is to have the whole grid highlighted in that way.
+
+During solving, you might know that a particular grid square belongs
+to a specific dot, but not be sure of where the edges go and which
+other squares are connected to the dot. In order to mark this so you
+don't forget, you can right-click on the dot and drag, which will
+create an arrow marker pointing at the dot. Drop that in a square of
+your choice and it will remind you which dot it's associated with.
+You can also right-click on existing arrows to pick them up and move
+them, or destroy them by dropping them off the edge of the grid.
+(Also, if you're not sure which dot an arrow is pointing at, you can
+pick it up and move it around to make it clearer. It will swivel
+constantly as you drag it, to stay pointed at its parent dot.)
+
+You can also use the cursor keys to move around the grid squares and
+lines.  Pressing the return key when over a grid line will draw or
+clear its edge, as above. Pressing the return key when over a dot will
+pick up an arrow, to be dropped the next time the return key is
+pressed; this can also be used to move existing arrows around, removing
+them by dropping them on a dot or another arrow.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{galaxies-parameters} \I{parameters, for Galaxies}Galaxies parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle. More difficult
+puzzles require more complex deductions, and the \q{Unreasonable}
+difficulty level may require backtracking.
+
+
+
+\C{filling} \i{Filling}
+
+\cfg{winhelp-topic}{games.filling}
+
+You have a grid of squares, some of which contain digits, and the
+rest of which are empty. Your job is to fill in digits in the empty
+squares, in such a way that each connected region of squares all
+containing the same digit has an area equal to that digit.
+
+(\q{Connected region}, for the purposes of this game, does not count
+diagonally separated squares as adjacent.)
+
+For example, it follows that no square can contain a zero, and that
+two adjacent squares can not both contain a one.  No region has an
+area greater than 9 (because then its area would not be a single
+digit).
+
+Credit for this puzzle goes to \i{Nikoli} \k{nikoli-fillomino}.
+
+Filling was contributed to this collection by Jonas K\u00F6{oe}lker.
+
+\B{nikoli-fillomino}
+\W{http://www.nikoli.co.jp/en/puzzles/fillomino.html}\cw{http://www.nikoli.co.jp/en/puzzles/fillomino.html}
+
+\H{filling-controls} \I{controls, for Filling}Filling controls
+
+To play Filling, simply click the mouse in any empty square and then
+type a digit on the keyboard to fill that square. By dragging the
+mouse, you can select multiple squares to fill with a single keypress.
+If you make a mistake, click the mouse in the incorrect square and
+press 0, Space, Backspace or Enter to clear it again (or use the Undo
+feature).
+
+You can also move around the grid with the cursor keys; typing a digit will
+fill the square containing the cursor with that number; typing 0 will clear
+it.  You can also select multiple squares for numbering or clearing with the
+return and arrow keys, before typing a digit to fill or clear the highlighted
+squares (as above).  The space bar adds and removes single squares to and from
+the selection.  Backspace and escape remove all squares from the selection.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{filling-parameters} \I{parameters, for Filling}Filling parameters
+
+Filling allows you to configure the number of rows and columns of the
+grid, through the \q{Type} menu.
+
+
+\C{keen} \i{Keen}
+
+\cfg{winhelp-topic}{games.keen}
+
+You have a square grid; each square may contain a digit from 1 to
+the size of the grid. The grid is divided into blocks of varying
+shape and size, with arithmetic clues written in them. Your aim is
+to fully populate the grid with digits such that:
+
+\b Each row contains only one occurrence of each digit
+
+\b Each column contains only one occurrence of each digit
+
+\b The digits in each block can be combined to form the number
+stated in the clue, using the arithmetic operation given in the
+clue. That is:
+
+\lcont{
+
+\b An addition clue means that the sum of the digits in the block
+must be the given number. For example, \q{15+} means the contents of
+the block adds up to fifteen.
+
+\b A multiplication clue (e.g. \q{60\times}), similarly, means that
+the product of the digits in the block must be the given number.
+
+\b A subtraction clue will always be written in a block of size two,
+and it means that one of the digits in the block is greater than the
+other by the given amount. For example, \q{2\minus} means that one
+of the digits in the block is 2 more than the other, or equivalently
+that one digit minus the other one is 2. The two digits could be
+either way round, though.
+
+\b A division clue (e.g. \q{3\divide}), similarly, is always in a
+block of size two and means that one digit divided by the other is
+equal to the given amount.
+
+Note that a block may contain the same digit more than once
+(provided the identical ones are not in the same row and column).
+This rule is precisely the opposite of the rule in Solo's \q{Killer}
+mode (see \k{solo}).
+
+}
+
+This puzzle appears in the Times under the name \q{\i{KenKen}}.
+
+
+\H{keen-controls} \i{Keen controls}
+
+\IM{Keen controls} controls, for Keen
+
+Keen shares much of its control system with Solo (and Unequal).
+
+To play Keen, simply click the mouse in any empty square and then
+type a digit on the keyboard to fill that square. If you make a
+mistake, click the mouse in the incorrect square and press Space to
+clear it again (or use the Undo feature).
+
+If you \e{right}-click in a square and then type a number, that
+number will be entered in the square as a \q{pencil mark}. You can
+have pencil marks for multiple numbers in the same square. Squares
+containing filled-in numbers cannot also contain pencil marks.
+
+The game pays no attention to pencil marks, so exactly what you use
+them for is up to you: you can use them as reminders that a
+particular square needs to be re-examined once you know more about a
+particular number, or you can use them as lists of the possible
+numbers in a given square, or anything else you feel like.
+
+To erase a single pencil mark, right-click in the square and type
+the same number again.
+
+All pencil marks in a square are erased when you left-click and type
+a number, or when you left-click and press space. Right-clicking and
+pressing space will also erase pencil marks.
+
+As for Solo, the cursor keys can be used in conjunction with the
+digit keys to set numbers or pencil marks. Use the cursor keys to
+move a highlight around the grid, and type a digit to enter it in
+the highlighted square. Pressing return toggles the highlight into a
+mode in which you can enter or remove pencil marks.
+
+Pressing M will fill in a full set of pencil marks in every square
+that does not have a main digit in it.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{keen-parameters} \I{parameters, for Keen}Keen parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Grid size}
+
+\dd Specifies the size of the grid. Lower limit is 3; upper limit is
+9 (because the user interface would become more difficult with
+\q{digits} bigger than 9!).
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle. At Unreasonable
+level, some backtracking will be required, but the solution should
+still be unique. The remaining levels require increasingly complex
+reasoning to avoid having to backtrack.
+
+\dt \e{Multiplication only}
+
+\dd If this is enabled, all boxes will be multiplication boxes.
+With this rule, the puzzle is known as \q{Inshi No Heya}.
+
+\C{towers} \i{Towers}
+
+\cfg{winhelp-topic}{games.towers}
+
+You have a square grid. On each square of the grid you can build a
+tower, with its height ranging from 1 to the size of the grid.
+Around the edge of the grid are some numeric clues.
+
+Your task is to build a tower on every square, in such a way that:
+
+\b Each row contains every possible height of tower once
+
+\b Each column contains every possible height of tower once
+
+\b Each numeric clue describes the number of towers that can be seen
+if you look into the square from that direction, assuming that
+shorter towers are hidden behind taller ones. For example, in a
+5\by\.5 grid, a clue marked \q{5} indicates that the five tower
+heights must appear in increasing order (otherwise you would not be
+able to see all five towers), whereas a clue marked \q{1} indicates
+that the tallest tower (the one marked 5) must come first.
+
+In harder or larger puzzles, some towers will be specified for you
+as well as the clues round the edge, and some edge clues may be
+missing.
+
+This puzzle appears on the web under various names, particularly
+\q{\i{Skyscrapers}}, but I don't know who first invented it.
+
+
+\H{towers-controls} \i{Towers controls}
+
+\IM{Towers controls} controls, for Towers
+
+Towers shares much of its control system with Solo, Unequal and Keen.
+
+To play Towers, simply click the mouse in any empty square and then
+type a digit on the keyboard to fill that square with a tower of the
+given height. If you make a mistake, click the mouse in the
+incorrect square and press Space to clear it again (or use the Undo
+feature).
+
+If you \e{right}-click in a square and then type a number, that
+number will be entered in the square as a \q{pencil mark}. You can
+have pencil marks for multiple numbers in the same square. A square
+containing a tower cannot also contain pencil marks.
+
+The game pays no attention to pencil marks, so exactly what you use
+them for is up to you: you can use them as reminders that a
+particular square needs to be re-examined once you know more about a
+particular number, or you can use them as lists of the possible
+numbers in a given square, or anything else you feel like.
+
+To erase a single pencil mark, right-click in the square and type
+the same number again.
+
+All pencil marks in a square are erased when you left-click and type
+a number, or when you left-click and press space. Right-clicking and
+pressing space will also erase pencil marks.
+
+As for Solo, the cursor keys can be used in conjunction with the
+digit keys to set numbers or pencil marks. Use the cursor keys to
+move a highlight around the grid, and type a digit to enter it in
+the highlighted square. Pressing return toggles the highlight into a
+mode in which you can enter or remove pencil marks.
+
+Pressing M will fill in a full set of pencil marks in every square
+that does not have a main digit in it.
+
+Left-clicking a clue will mark it as done (grey it out), or unmark it
+if it is already marked.  Holding Control or Shift and pressing an
+arrow key likewise marks any clue in the given direction.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{towers-parameters} \I{parameters, for Towers}Towers parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Grid size}
+
+\dd Specifies the size of the grid. Lower limit is 3; upper limit is
+9 (because the user interface would become more difficult with
+\q{digits} bigger than 9!).
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle. At Unreasonable
+level, some backtracking will be required, but the solution should
+still be unique. The remaining levels require increasingly complex
+reasoning to avoid having to backtrack.
+
+
+\C{singles} \i{Singles}
+
+\cfg{winhelp-topic}{games.singles}
+
+You have a grid of white squares, all of which contain numbers. Your task
+is to colour some of the squares black (removing the number) so as to satisfy
+all of the following conditions:
+
+\b No number occurs more than once in any row or column.
+
+\b No black square is horizontally or vertically adjacent to any other black
+square.
+
+\b The remaining white squares must all form one contiguous region
+(connected by edges, not just touching at corners).
+
+Credit for this puzzle goes to \i{Nikoli} \k{nikoli-hitori} who call it
+\i{Hitori}. 
+
+Singles was contributed to this collection by James Harvey.
+
+\B{nikoli-hitori}
+\W{http://www.nikoli.com/en/puzzles/hitori.html}\cw{http://www.nikoli.com/en/puzzles/hitori.html}
+(beware of Flash)
+
+\H{singles-controls} \i{Singles controls}
+
+\IM{Singles controls} controls, for Singles
+
+Left-clicking on an empty square will colour it black; left-clicking again 
+will restore the number. Right-clicking will add a circle (useful for 
+indicating that a cell is definitely not black). 
+
+You can also use the cursor keys to move around the grid. Pressing the
+return or space keys will turn a square black or add a circle respectively,
+and pressing the key again will restore the number or remove the circle.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{singles-parameters} \I{parameters, for Singles}Singles parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle.
+
+
+\C{magnets} \i{Magnets}
+
+\cfg{winhelp-topic}{games.magnets}
+
+A rectangular grid has been filled with a mixture of magnets (that is,
+dominoes with one positive end and one negative end) and blank dominoes
+(that is, dominoes with two neutral poles).
+These dominoes are initially only seen in silhouette. Around the grid
+are placed a number of clues indicating the number of positive and
+negative poles contained in certain columns and rows.
+
+Your aim is to correctly place the magnets and blank dominoes such that
+all the clues are satisfied, with the additional constraint that no two
+similar magnetic poles may be orthogonally adjacent (since they repel).
+Neutral poles do not repel, and can be adjacent to any other pole. 
+
+Credit for this puzzle goes to \i{Janko} \k{janko-magnets}.
+
+Magnets was contributed to this collection by James Harvey.
+
+\B{janko-magnets}
+\W{http://www.janko.at/Raetsel/Magnete/index.htm}\cw{http://www.janko.at/Raetsel/Magnete/index.htm}
+
+\H{magnets-controls} \i{Magnets controls}
+
+\IM{Magnets controls} controls, for Magnets
+
+Left-clicking on an empty square places a magnet at that position with
+the positive pole on the square and the negative pole on the other half
+of the magnet; left-clicking again reverses the polarity, and a third
+click removes the magnet.
+
+Right-clicking on an empty square places a blank domino there.
+Right-clicking again places two question marks on the domino, signifying
+\q{this cannot be blank} (which can be useful to note deductions while
+solving), and right-clicking again empties the domino. 
+
+Left-clicking a clue will mark it as done (grey it out), or unmark it if
+it is already marked.
+
+You can also use the cursor keys to move a cursor around the grid. 
+Pressing the return key will lay a domino with a positive pole at that
+position; pressing again reverses the polarity and then removes the
+domino, as with left-clicking. Using the space bar allows placement
+of blank dominoes and cannot-be-blank hints, as for right-clicking. 
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{magnets-parameters} \I{parameters, for Magnets}Magnets parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares. There will be half \e{Width} \by \e{Height}
+dominoes in the grid: if this number is odd then one square will be blank.
+
+\lcont{
+
+(Grids with at least one odd dimension tend to be easier to solve.)
+
+}
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle. At Tricky level,
+you are required to make more deductions about empty dominoes and
+row/column counts. 
+
+\dt \e{Strip clues}
+
+\dd If true, some of the clues around the grid are removed at generation
+time, making the puzzle more difficult.
+
+
+\C{signpost} \i{Signpost}
+
+\cfg{winhelp-topic}{games.signpost}
+
+You have a grid of squares; each square (except the last one)
+contains an arrow, and some squares also contain numbers. Your job
+is to connect the squares to form a continuous list of numbers
+starting at 1 and linked in the direction of the arrows \dash so the
+arrow inside the square with the number 1 will point to the square
+containing the number 2, which will point to the square containing
+the number 3, etc. Each square can be any distance away from the
+previous one, as long as it is somewhere in the direction of the
+arrow.
+
+By convention the first and last numbers are shown; one or more
+interim numbers may also appear at the beginning. 
+
+Credit for this puzzle goes to \i{Janko} \k{janko-arrowpath}, who call it
+\q{Pfeilpfad} (\q{arrow path}).
+
+Signpost was contributed to this collection by James Harvey.
+
+\B{janko-arrowpath}
+\W{http://janko.at/Raetsel/Pfeilpfad/index.htm}\cw{http://janko.at/Raetsel/Pfeilpfad/index.htm}
+
+\H{signpost-controls} \I{controls, for Signpost}Signpost controls
+
+To play Signpost, you connect squares together by dragging from one
+square to another, indicating that they are adjacent in the
+sequence. Drag with the left button from a square to its successor,
+or with the right button from a square to its predecessor.
+
+If you connect together two squares in this way and one of them has
+a number in it, the appropriate number will appear in the other
+square. If you connect two non-numbered squares, they will be
+assigned temporary algebraic labels: on the first occasion, they
+will be labelled \cq{a} and \cq{a+1}, and then \cq{b} and \cq{b+1},
+and so on. Connecting more squares on to the ends of such a chain
+will cause them all to be labelled with the same letter.
+
+When you left-click or right-click in a square, the legal squares to
+connect it to will be shown.
+
+The arrow in each square starts off black, and goes grey once you
+connect the square to its successor. Also, each square which needs a
+predecessor has a small dot in the bottom left corner, which
+vanishes once you link a square to it. So your aim is always to
+connect a square with a black arrow to a square with a dot.
+
+To remove any links for a particular square (both incoming and
+outgoing), left-drag it off the grid. To remove a whole chain,
+right-drag any square in the chain off the grid.
+
+You can also use the cursor keys to move around the grid squares and
+lines. Pressing the return key when over a square starts a link
+operation, and pressing the return key again over a square will
+finish the link, if allowable. Pressing the space bar over a square
+will show the other squares pointing to it, and allow you to form a
+backward link, and pressing the space bar again cancels this.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{signpost-parameters} \I{parameters, for Signpost}Signpost parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Force start/end to corners}
+
+\dd If true, the start and end squares are always placed in opposite corners
+(the start at the top left, and the end at the bottom right). If false the start
+and end squares are placed randomly (although always both shown). 
+
+\C{range} \i{Range}
+
+\cfg{winhelp-topic}{games.range}
+
+You have a grid of squares; some squares contain numbers.  Your job is
+to colour some of the squares black, such that several criteria are
+satisfied:
+
+\b no square with a number is coloured black.
+
+\b no two black squares are adjacent (horizontally or vertically).
+
+\b for any two white squares, there is a path between them using only
+white squares.
+
+\b for each square with a number, that number denotes the total number
+of white squares reachable from that square going in a straight line
+in any horizontal or vertical direction until hitting a wall or a
+black square; the square with the number is included in the total
+(once).
+
+For instance, a square containing the number one must have four black
+squares as its neighbours by the last criterion; but then it's
+impossible for it to be connected to any outside white square, which
+violates the second to last criterion.  So no square will contain the
+number one.
+
+Credit for this puzzle goes to \i{Nikoli}, who have variously called
+it \q{Kurodoko}, \q{Kuromasu} or \q{Where is Black Cells}.
+\k{nikoli-range}.
+
+Range was contributed to this collection by Jonas K\u00F6{oe}lker.
+
+\B{nikoli-range}
+\W{http://www.nikoli.co.jp/en/puzzles/where_is_black_cells.html}\cw{http://www.nikoli.co.jp/en/puzzles/where_is_black_cells.html}
+
+\H{range-controls} \I{controls, for Range}Range controls
+
+Click with the left button to paint a square black, or with the right
+button to mark a square with a dot to indicate that you are sure it
+should \e{not} be painted black. Repeated clicking with either button
+will cycle the square through the three possible states (filled,
+dotted or empty) in opposite directions.
+
+You can also use the cursor keys to move around the grid squares.
+Pressing Return does the same as clicking with the left button, while
+pressing Space does the same as a right button click.  Moving with the
+cursor keys while holding Shift will place dots in all squares that
+are moved through.
+
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{range-parameters} \I{parameters, for Range}Range parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\C{pearl} \i{Pearl}
+
+\cfg{winhelp-topic}{games.pearl}
+
+You have a grid of squares. Your job is to draw lines between the
+centres of horizontally or vertically adjacent squares, so that the
+lines form a single closed loop. In the resulting grid, some of the
+squares that the loop passes through will contain corners, and some
+will be straight horizontal or vertical lines. (And some squares can
+be completely empty \dash the loop doesn't have to pass through every
+square.)
+
+Some of the squares contain black and white circles, which are clues
+that the loop must satisfy.
+
+A black circle in a square indicates that that square is a corner, but
+neither of the squares adjacent to it in the loop is also a corner.
+
+A white circle indicates that the square is a straight edge, but \e{at
+least one} of the squares adjacent to it in the loop is a corner.
+
+(In both cases, the clue only constrains the two squares adjacent
+\e{in the loop}, that is, the squares that the loop passes into after
+leaving the clue square. The squares that are only adjacent \e{in the
+grid} are not constrained.)
+
+Credit for this puzzle goes to \i{Nikoli}, who call it \q{Masyu}.
+\k{nikoli-pearl}
+
+Thanks to James Harvey for assistance with the implementation.
+
+\B{nikoli-pearl}
+\W{http://www.nikoli.co.jp/en/puzzles/masyu.html}\cw{http://www.nikoli.co.jp/en/puzzles/masyu.html}
+(beware of Flash)
+
+\H{pearl-controls} \I{controls, for Pearl}Pearl controls
+
+Click with the left button on a grid edge to draw a segment of the
+loop through that edge, or to remove a segment once it is drawn.
+
+Drag with the left button through a series of squares to draw more
+than one segment of the loop in one go. Alternatively, drag over an
+existing part of the loop to undraw it, or to undraw part of it and
+then go in a different direction.
+
+Click with the right button on a grid edge to mark it with a cross,
+indicating that you are sure the loop does not go through that edge.
+(For instance, if you have decided which of the squares adjacent to a
+white clue has to be a corner, but don't yet know which way the corner
+turns, you might mark the one way it \e{can't} go with a cross.)
+
+Alternatively, use the cursor keys to move the cursor.  Use the Enter
+key to begin and end keyboard \q{drag} operations.  Use the Space,
+Escape or Backspace keys to cancel the drag.  Or, hold Control while
+dragging with the cursor keys to toggle segments as you move between
+squares.
+
+Pressing Control-Shift-arrowkey or Shift-arrowkey simulates a left or
+right click, respectively, on the edge in the direction of the key.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{pearl-parameters} \I{parameters, for Pearl}Pearl parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\C{undead} \i{Undead}
+
+\cfg{winhelp-topic}{games.undead}
+
+You are given a grid of squares, some of which contain diagonal
+mirrors. Every square which is not a mirror must be filled with one of
+three types of undead monster: a ghost, a vampire, or a zombie.
+
+Vampires can be seen directly, but are invisible when reflected in
+mirrors. Ghosts are the opposite way round: they can be seen in
+mirrors, but are invisible when looked at directly. Zombies are
+visible by any means.
+
+You are also told the total number of each type of monster in the
+grid. Also around the edge of the grid are written numbers, which
+indicate how many monsters can be seen if you look into the grid along
+a row or column starting from that position. (The diagonal mirrors are
+reflective on both sides. If your reflected line of sight crosses the
+same monster more than once, the number will count it each time it is
+visible, not just once.)
+
+This puzzle type was invented by David Millar, under the name
+\q{Haunted Mirror Maze}. See \k{janko-undead} for more details.
+
+Undead was contributed to this collection by Steffen Bauer.
+
+\B{janko-undead}
+\W{http://www.janko.at/Raetsel/Spukschloss/index.htm}\cw{http://www.janko.at/Raetsel/Spukschloss/index.htm}
+
+\H{undead-controls} \I{controls, for Undead}Undead controls
+
+Undead has a similar control system to Solo, Unequal and Keen.
+
+To play Undead, click the mouse in any empty square and then type a
+letter on the keyboard indicating the type of monster: \q{G} for a
+ghost, \q{V} for a vampire, or \q{Z} for a zombie. If you make a
+mistake, click the mouse in the incorrect square and press Space to
+clear it again (or use the Undo feature).
+
+If you \e{right}-click in a square and then type a letter, the
+corresponding monster will be shown in reduced size in that square, as
+a \q{pencil mark}. You can have pencil marks for multiple monsters in
+the same square. A square containing a full-size monster cannot also
+contain pencil marks.
+
+The game pays no attention to pencil marks, so exactly what you use
+them for is up to you: you can use them as reminders that a particular
+square needs to be re-examined once you know more about a particular
+monster, or you can use them as lists of the possible monster in a
+given square, or anything else you feel like.
+
+To erase a single pencil mark, right-click in the square and type
+the same letter again.
+
+All pencil marks in a square are erased when you left-click and type a
+monster letter, or when you left-click and press Space. Right-clicking
+and pressing space will also erase pencil marks.
+
+As for Solo, the cursor keys can be used in conjunction with the letter
+keys to place monsters or pencil marks. Use the cursor keys to move a
+highlight around the grid, and type a monster letter to enter it in
+the highlighted square. Pressing return toggles the highlight into a
+mode in which you can enter or remove pencil marks.
+
+If you prefer plain letters of the alphabet to cute monster pictures,
+you can press \q{A} to toggle between showing the monsters as monsters or
+showing them as letters.
+
+Left-clicking a clue will mark it as done (grey it out), or unmark it
+if it is already marked.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{undead-parameters} \I{parameters, for Undead}Undead parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle.
+
+\C{unruly} \i{Unruly}
+
+\cfg{winhelp-topic}{games.unruly}
+
+You are given a grid of squares, which you must colour either black or
+white. Some squares are provided as clues; the rest are left for you
+to fill in. Each row and column must contain the same number of black
+and white squares, and no row or column may contain three consecutive
+squares of the same colour.
+
+This puzzle type was invented by Adolfo Zanellati, under the name
+\q{Tohu wa Vohu}. See \k{janko-unruly} for more details.
+
+Unruly was contributed to this collection by Lennard Sprong.
+
+\B{janko-unruly}
+\W{http://www.janko.at/Raetsel/Tohu-Wa-Vohu/index.htm}\cw{http://www.janko.at/Raetsel/Tohu-Wa-Vohu/index.htm}
+
+\H{unruly-controls} \I{controls, for Unruly}Unruly controls
+
+To play Unruly, click the mouse in a square to change its colour.
+Left-clicking an empty square will turn it black, and right-clicking
+will turn it white. Keep clicking the same button to cycle through the
+three possible states for the square. If you middle-click in a square
+it will be reset to empty.
+
+You can also use the cursor keys to move around the grid. Pressing the
+return or space keys will turn an empty square black or white
+respectively (and then cycle the colours in the same way as the mouse
+buttons), and pressing Backspace will reset a square to empty.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{unruly-parameters} \I{parameters, for Unruly}Unruly parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares. (Note that the rules of the game require
+both the width and height to be even numbers.)
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle.
+
+\dt \e{Unique rows and columns}
+
+\dd If enabled, no two rows are permitted to have exactly the same
+pattern, and likewise columns. (A row and a column can match, though.)
+
+\C{flood} \i{Flood}
+
+\cfg{winhelp-topic}{games.flood}
+
+You are given a grid of squares, coloured at random in multiple
+colours. In each move, you can flood-fill the top left square in a
+colour of your choice (i.e. every square reachable from the starting
+square by an orthogonally connected path of squares all the same
+colour will be filled in the new colour). As you do this, more and
+more of the grid becomes connected to the starting square.
+
+Your aim is to make the whole grid the same colour, in as few moves as
+possible. The game will set a limit on the number of moves, based on
+running its own internal solver. You win if you can make the whole
+grid the same colour in that many moves or fewer.
+
+I saw this game (with a fixed grid size, fixed number of colours, and
+fixed move limit) at http://floodit.appspot.com (no longer accessible).
+
+\H{flood-controls} \I{controls, for Flood}Flood controls
+
+To play Flood, click the mouse in a square. The top left corner and
+everything connected to it will be flood-filled with the colour of the
+square you clicked. Clicking a square the same colour as the top left
+corner has no effect, and therefore does not count as a move.
+
+You can also use the cursor keys to move a cursor (outline black
+square) around the grid. Pressing the return key will fill the top
+left corner in the colour of the square under the cursor.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{flood-parameters} \I{parameters, for Flood}Flood parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of the grid, in squares.
+
+\dt \e{Colours}
+
+\dd Number of colours used to fill the grid. Must be at least 3 (with
+two colours there would only be one legal move at any stage, hence no
+choice to make at all), and at most 10.
+
+\dt \e{Extra moves permitted}
+
+\dd Controls the difficulty of the puzzle, by increasing the move
+limit. In each new grid, Flood will run an internal solver to generate
+its own solution, and then the value in this field will be added to
+the length of Flood's solution to generate the game's move limit. So a
+value of 0 requires you to be just as efficient as Flood's automated
+solver, and a larger value makes it easier.
+
+\lcont{
+
+(Note that Flood's internal solver will not necessarily find the
+shortest possible solution, though I believe it's pretty close. For a
+real challenge, set this value to 0 and then try to solve a grid in
+\e{strictly fewer} moves than the limit you're given!)
+
+}
+
+\C{tracks} \i{Tracks}
+
+\cfg{winhelp-topic}{games.tracks}
+
+You are given a grid of squares, some of which are filled with train
+tracks. You need to complete the track from A to B so that the rows and
+columns contain the same number of track segments as are indicated in the
+clues to the top and right of the grid.
+
+There are only straight and 90 degree curved rails, and the track may not
+cross itself.
+
+Tracks was contributed to this collection by James Harvey.
+
+\H{tracks-controls} \I{controls, for Tracks}Tracks controls
+
+Left-clicking on an edge between two squares adds a track segment between
+the two squares. Right-clicking on an edge adds a cross on the edge,
+indicating no track is possible there.
+
+Left-clicking in a square adds a colour indicator showing that you know the
+square must contain a track, even if you don't know which edges it crosses
+yet. Right-clicking in a square adds a cross indicating it contains no
+track segment.
+
+Left- or right-dragging between squares allows you to lay a straight line
+of is-track or is-not-track indicators, useful for filling in rows or
+columns to match the clue.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{tracks-parameters} \I{parameters, for Tracks}Tracks parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of the grid, in squares.
+
+\dt \e{Difficulty}
+
+\dd Controls the difficulty of the generated puzzle: at Tricky level,
+you are required to make more deductions regarding disregarding moves
+that would lead to impossible crossings later.
+
+\dt \e{Disallow consecutive 1 clues}
+
+\dd Controls whether the Tracks game generation permits two adjacent
+rows or columns to have a 1 clue, or permits the row or column of the
+track's endpoint to have a 1 clue. By default this is not permitted,
+to avoid long straight boring segments of track and make the games
+more twiddly and interesting. If you want to restore the possibility,
+turn this option off.
+
+
+\C{palisade} \i{Palisade}
+
+\cfg{winhelp-topic}{games.palisade}
+
+You're given a grid of squares, some of which contain numbers.  Your
+goal is to subdivide the grid into contiguous regions, all of the same
+(given) size, such that each square containing a number is adjacent to
+exactly that many edges (including those between the inside and the
+outside of the grid).
+
+Credit for this puzzle goes to \i{Nikoli}, who call it \q{Five Cells}.
+\k{nikoli-palisade}.
+
+Palisade was contributed to this collection by Jonas K\u00F6{oe}lker.
+
+\B{nikoli-palisade}
+\W{http://nikoli.co.jp/en/puzzles/five_cells.html}\cw{http://nikoli.co.jp/en/puzzles/five_cells.html}
+
+\H{palisade-controls} \I{controls, for Palisade}Palisade controls
+
+Left-click to place an edge.  Right-click to indicate \q{no edge}.
+Alternatively, the arrow keys will move a keyboard cursor.  Holding
+Control while pressing an arrow key will place an edge.  Press
+Shift-arrowkey to switch off an edge.  Repeat an action to perform
+its inverse.
+
+(All the actions described in \k{common-actions} are also available.)
+
+\H{Palisade-parameters} \I{parameters, for Palisade}Palisade parameters
+
+These parameters are available from the \q{Custom...} option on the
+\q{Type} menu.
+
+\dt \e{Width}, \e{Height}
+
+\dd Size of grid in squares.
+
+\dt \e{Region size}
+
+\dd The size of the regions into which the grid must be subdivided.
+
+\A{licence} \I{MIT licence}\ii{Licence}
+
+This software is \i{copyright} 2004-2014 Simon Tatham.
+
+Portions copyright Richard Boulton, James Harvey, Mike Pinna, Jonas
+K\u00F6{oe}lker, Dariusz Olszewski, Michael Schierl, Lambros Lambrou,
+Bernd Schmidt, Steffen Bauer, Lennard Sprong and Rogier Goossens.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation files
+(the \q{Software}), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED \q{AS IS}, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+\IM{command-line}{command line} command line
+
+\IM{default parameters, specifying} default parameters, specifying
+\IM{default parameters, specifying} preferences, specifying default
+
+\IM{Unix} Unix
+\IM{Unix} Linux
+
+\IM{generating game IDs} generating game IDs
+\IM{generating game IDs} game ID, generating
+
+\IM{specific} \q{Specific}, menu option
+\IM{custom} \q{Custom}, menu option
+
+\IM{game ID} game ID
+\IM{game ID} ID, game
+\IM{ID format} ID format
+\IM{ID format} format, ID
+\IM{ID format} game ID, format
+
+\IM{keys} keys
+\IM{keys} shortcuts (keyboard)
+
+\IM{initial state} initial state
+\IM{initial state} state, initial
+
+\IM{MIT licence} MIT licence
+\IM{MIT licence} licence, MIT
diff --git a/apps/plugins/puzzles/puzzles.h b/apps/plugins/puzzles/puzzles.h
new file mode 100644
index 0000000000..c70b33ccbf
--- /dev/null
+++ b/apps/plugins/puzzles/puzzles.h
@@ -0,0 +1,636 @@
+/*
+ * puzzles.h: header file for my puzzle collection
+ */
+
+#ifndef PUZZLES_PUZZLES_H
+#define PUZZLES_PUZZLES_H
+
+#include "plugin.h"
+#include <tlsf.h>
+#include "rbcompat.h"
+#include "lib/pluginlib_exit.h"
+
+#ifdef ROCKBOX
+#if LCD_WIDTH < LCD_HEIGHT
+#define PORTRAIT_SCREEN
+#endif
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#define PI 3.141592653589793238462643383279502884197169399
+
+#define lenof(array) ( sizeof(array) / sizeof(*(array)) )
+
+#undef STR
+#define STR_INT(x) #x
+#define STR(x) STR_INT(x)
+
+/* NB not perfect because they evaluate arguments multiple times. */
+#ifndef max
+#define max(x,y) ( (x)>(y) ? (x) : (y) )
+#endif /* max */
+#ifndef min
+#define min(x,y) ( (x)<(y) ? (x) : (y) )
+#endif /* min */
+
+enum {
+    LEFT_BUTTON = 0x0200,
+    MIDDLE_BUTTON,
+    RIGHT_BUTTON,
+    LEFT_DRAG,
+    MIDDLE_DRAG,
+    RIGHT_DRAG,
+    LEFT_RELEASE,
+    MIDDLE_RELEASE,
+    RIGHT_RELEASE,
+    CURSOR_UP,
+    CURSOR_DOWN,
+    CURSOR_LEFT,
+    CURSOR_RIGHT,
+    CURSOR_SELECT,
+    CURSOR_SELECT2,
+    
+    /* made smaller because of 'limited range of datatype' errors. */
+    MOD_CTRL       = 0x1000,
+    MOD_SHFT       = 0x2000,
+    MOD_NUM_KEYPAD = 0x4000,
+    MOD_MASK       = 0x7000 /* mask for all modifiers */
+};
+
+#define IS_MOUSE_DOWN(m) ( (unsigned)((m) - LEFT_BUTTON) <= \
+                               (unsigned)(RIGHT_BUTTON - LEFT_BUTTON))
+#define IS_MOUSE_DRAG(m) ( (unsigned)((m) - LEFT_DRAG) <= \
+                               (unsigned)(RIGHT_DRAG - LEFT_DRAG))
+#define IS_MOUSE_RELEASE(m) ( (unsigned)((m) - LEFT_RELEASE) <= \
+                               (unsigned)(RIGHT_RELEASE - LEFT_RELEASE))
+#define IS_CURSOR_MOVE(m) ( (m) == CURSOR_UP || (m) == CURSOR_DOWN || \
+                            (m) == CURSOR_RIGHT || (m) == CURSOR_LEFT )
+#define IS_CURSOR_SELECT(m) ( (m) == CURSOR_SELECT || (m) == CURSOR_SELECT2)
+
+/*
+ * Flags in the back end's `flags' word.
+ */
+/* Bit flags indicating mouse button priorities */
+#define BUTTON_BEATS(x,y) ( 1 << (((x)-LEFT_BUTTON)*3+(y)-LEFT_BUTTON) )
+/* Flag indicating that Solve operations should be animated */
+#define SOLVE_ANIMATES ( 1 << 9 )
+/* Pocket PC: Game requires right mouse button emulation */
+#define REQUIRE_RBUTTON ( 1 << 10 )
+/* Pocket PC: Game requires numeric input */
+#define REQUIRE_NUMPAD ( 1 << 11 )
+/* end of `flags' word definitions */
+
+#ifdef _WIN32_WCE
+  /* Pocket PC devices have small, portrait screen that requires more vivid colours */
+  #define SMALL_SCREEN
+  #define PORTRAIT_SCREEN
+  #define VIVID_COLOURS
+  #define STYLUS_BASED
+#endif
+
+#define IGNOREARG(x) ( (x) = (x) )
+
+typedef struct frontend frontend;
+typedef struct config_item config_item;
+typedef struct midend midend;
+typedef struct random_state random_state;
+typedef struct game_params game_params;
+typedef struct game_state game_state;
+typedef struct game_ui game_ui;
+typedef struct game_drawstate game_drawstate;
+typedef struct game game;
+typedef struct blitter blitter;
+typedef struct document document;
+typedef struct drawing_api drawing_api;
+typedef struct drawing drawing;
+typedef struct psdata psdata;
+
+#define ALIGN_VNORMAL 0x000
+#define ALIGN_VCENTRE 0x100
+
+#define ALIGN_HLEFT   0x000
+#define ALIGN_HCENTRE 0x001
+#define ALIGN_HRIGHT  0x002
+
+#define FONT_FIXED    0
+#define FONT_VARIABLE 1
+
+/* For printing colours */
+#define HATCH_SLASH     1
+#define HATCH_BACKSLASH 2
+#define HATCH_HORIZ     3
+#define HATCH_VERT      4
+#define HATCH_PLUS      5
+#define HATCH_X         6
+
+/*
+ * Structure used to pass configuration data between frontend and
+ * game
+ */
+enum { C_STRING, C_CHOICES, C_BOOLEAN, C_END };
+struct config_item {
+    /*
+     * `name' is never dynamically allocated.
+     */
+    char *name;
+    /*
+     * `type' contains one of the above values.
+     */
+    int type;
+    /*
+     * For C_STRING, `sval' is always dynamically allocated and
+     * non-NULL. For C_BOOLEAN and C_END, `sval' is always NULL.
+     * For C_CHOICES, `sval' is non-NULL, _not_ dynamically
+     * allocated, and contains a set of option strings separated by
+     * a delimiter. The delimeter is also the first character in
+     * the string, so for example ":Foo:Bar:Baz" gives three
+     * options `Foo', `Bar' and `Baz'.
+     */
+    char *sval;
+    /*
+     * For C_BOOLEAN, this is TRUE or FALSE. For C_CHOICES, it
+     * indicates the chosen index from the `sval' list. In the
+     * above example, 0==Foo, 1==Bar and 2==Baz.
+     */
+    int ival;
+};
+
+/*
+ * Platform routines
+ */
+
+/* We can't use #ifdef DEBUG, because Cygwin defines it by default. */
+#ifdef DEBUGGING
+#define debug(x) (debug_printf x)
+void debug_printf(char *fmt, ...);
+#else
+#define debug(x)
+#endif
+
+void fatal(char *fmt, ...);
+void frontend_default_colour(frontend *fe, float *output);
+void deactivate_timer(frontend *fe);
+void activate_timer(frontend *fe);
+void get_random_seed(void **randseed, int *randseedsize);
+
+/*
+ * drawing.c
+ */
+drawing *drawing_new(const drawing_api *api, midend *me, void *handle);
+void drawing_free(drawing *dr);
+void draw_text(drawing *dr, int x, int y, int fonttype, int fontsize,
+               int align, int colour, char *text);
+void draw_rect(drawing *dr, int x, int y, int w, int h, int colour);
+void draw_line(drawing *dr, int x1, int y1, int x2, int y2, int colour);
+void draw_polygon(drawing *dr, int *coords, int npoints,
+                  int fillcolour, int outlinecolour);
+void draw_circle(drawing *dr, int cx, int cy, int radius,
+                 int fillcolour, int outlinecolour);
+void draw_thick_line(drawing *dr, float thickness,
+                     float x1, float y1, float x2, float y2, int colour);
+void clip(drawing *dr, int x, int y, int w, int h);
+void unclip(drawing *dr);
+void start_draw(drawing *dr);
+void draw_update(drawing *dr, int x, int y, int w, int h);
+void end_draw(drawing *dr);
+char *text_fallback(drawing *dr, const char *const *strings, int nstrings);
+void status_bar(drawing *dr, char *text);
+blitter *blitter_new(drawing *dr, int w, int h);
+void blitter_free(drawing *dr, blitter *bl);
+/* save puts the portion of the current display with top-left corner
+ * (x,y) to the blitter. load puts it back again to the specified
+ * coords, or else wherever it was saved from
+ * (if x = y = BLITTER_FROMSAVED). */
+void blitter_save(drawing *dr, blitter *bl, int x, int y);
+#define BLITTER_FROMSAVED (-1)
+void blitter_load(drawing *dr, blitter *bl, int x, int y);
+void print_begin_doc(drawing *dr, int pages);
+void print_begin_page(drawing *dr, int number);
+void print_begin_puzzle(drawing *dr, float xm, float xc,
+                        float ym, float yc, int pw, int ph, float wmm,
+                        float scale);
+void print_end_puzzle(drawing *dr);
+void print_end_page(drawing *dr, int number);
+void print_end_doc(drawing *dr);
+void print_get_colour(drawing *dr, int colour, int printing_in_colour,
+                      int *hatch, float *r, float *g, float *b);
+int print_mono_colour(drawing *dr, int grey); /* 0==black, 1==white */
+int print_grey_colour(drawing *dr, float grey);
+int print_hatched_colour(drawing *dr, int hatch);
+int print_rgb_mono_colour(drawing *dr, float r, float g, float b, int mono);
+int print_rgb_grey_colour(drawing *dr, float r, float g, float b, float grey);
+int print_rgb_hatched_colour(drawing *dr, float r, float g, float b,
+                             int hatch);
+void print_line_width(drawing *dr, int width);
+void print_line_dotted(drawing *dr, int dotted);
+
+/*
+ * midend.c
+ */
+midend *midend_new(frontend *fe, const game *ourgame,
+                   const drawing_api *drapi, void *drhandle);
+void midend_free(midend *me);
+const game *midend_which_game(midend *me);
+void midend_set_params(midend *me, game_params *params);
+game_params *midend_get_params(midend *me);
+void midend_size(midend *me, int *x, int *y, int user_size);
+void midend_reset_tilesize(midend *me);
+void midend_new_game(midend *me);
+void midend_restart_game(midend *me);
+void midend_stop_anim(midend *me);
+int midend_process_key(midend *me, int x, int y, int button);
+void midend_force_redraw(midend *me);
+void midend_redraw(midend *me);
+float *midend_colours(midend *me, int *ncolours);
+void midend_freeze_timer(midend *me, float tprop);
+void midend_timer(midend *me, float tplus);
+int midend_num_presets(midend *me);
+void midend_fetch_preset(midend *me, int n,
+                         char **name, game_params **params);
+int midend_which_preset(midend *me);
+int midend_wants_statusbar(midend *me);
+enum { CFG_SETTINGS, CFG_SEED, CFG_DESC, CFG_FRONTEND_SPECIFIC };
+config_item *midend_get_config(midend *me, int which, char **wintitle);
+char *midend_set_config(midend *me, int which, config_item *cfg);
+char *midend_game_id(midend *me, char *id);
+char *midend_get_game_id(midend *me);
+char *midend_get_random_seed(midend *me);
+int midend_can_format_as_text_now(midend *me);
+char *midend_text_format(midend *me);
+char *midend_solve(midend *me);
+int midend_status(midend *me);
+int midend_can_undo(midend *me);
+int midend_can_redo(midend *me);
+void midend_supersede_game_desc(midend *me, char *desc, char *privdesc);
+char *midend_rewrite_statusbar(midend *me, char *text);
+void midend_serialise(midend *me,
+                      void (*write)(void *ctx, void *buf, int len),
+                      void *wctx);
+char *midend_deserialise(midend *me,
+                         int (*read)(void *ctx, void *buf, int len),
+                         void *rctx);
+char *identify_game(char **name, int (*read)(void *ctx, void *buf, int len),
+                    void *rctx);
+void midend_request_id_changes(midend *me, void (*notify)(void *), void *ctx);
+/* Printing functions supplied by the mid-end */
+char *midend_print_puzzle(midend *me, document *doc, int with_soln);
+int midend_tilesize(midend *me);
+
+/*
+ * malloc.c
+ */
+void *smalloc(size_t size);
+void *srealloc(void *p, size_t size);
+void sfree(void *p);
+char *dupstr(const char *s);
+#define snew(type) \
+    ( (type *) smalloc (sizeof (type)) )
+#define snewn(number, type) \
+    ( (type *) smalloc ((number) * sizeof (type)) )
+#define sresize(array, number, type) \
+    ( (type *) srealloc ((array), (number) * sizeof (type)) )
+
+/*
+ * misc.c
+ */
+void free_cfg(config_item *cfg);
+void obfuscate_bitmap(unsigned char *bmp, int bits, int decode);
+
+/* allocates output each time. len is always in bytes of binary data.
+ * May assert (or just go wrong) if lengths are unchecked. */
+char *bin2hex(const unsigned char *in, int inlen);
+unsigned char *hex2bin(const char *in, int outlen);
+
+/* Sets (and possibly dims) background from frontend default colour,
+ * and auto-generates highlight and lowlight colours too. */
+void game_mkhighlight(frontend *fe, float *ret,
+                      int background, int highlight, int lowlight);
+/* As above, but starts from a provided background colour rather
+ * than the frontend default. */
+void game_mkhighlight_specific(frontend *fe, float *ret,
+                               int background, int highlight, int lowlight);
+
+/* Randomly shuffles an array of items. */
+void shuffle(void *array, int nelts, int eltsize, random_state *rs);
+
+/* Draw a rectangle outline, using the drawing API's draw_line. */
+void draw_rect_outline(drawing *dr, int x, int y, int w, int h,
+                       int colour);
+
+/* Draw a set of rectangle corners (e.g. for a cursor display). */
+void draw_rect_corners(drawing *dr, int cx, int cy, int r, int col);
+
+void move_cursor(int button, int *x, int *y, int maxw, int maxh, int wrap);
+
+/* Used in netslide.c and sixteen.c for cursor movement around edge. */
+int c2pos(int w, int h, int cx, int cy);
+int c2diff(int w, int h, int cx, int cy, int button);
+void pos2c(int w, int h, int pos, int *cx, int *cy);
+
+/* Draws text with an 'outline' formed by offsetting the text
+ * by one pixel; useful for highlighting. Outline is omitted if -1. */
+void draw_text_outline(drawing *dr, int x, int y, int fonttype,
+                       int fontsize, int align,
+                       int text_colour, int outline_colour, char *text);
+/*
+ * dsf.c
+ */
+int *snew_dsf(int size);
+
+void print_dsf(int *dsf, int size);
+
+/* Return the canonical element of the equivalence class containing element
+ * val.  If 'inverse' is non-NULL, this function will put into it a flag
+ * indicating whether the canonical element is inverse to val. */
+int edsf_canonify(int *dsf, int val, int *inverse);
+int dsf_canonify(int *dsf, int val);
+int dsf_size(int *dsf, int val);
+
+/* Allow the caller to specify that two elements should be in the same
+ * equivalence class.  If 'inverse' is TRUE, the elements are actually opposite
+ * to one another in some sense.  This function will fail an assertion if the
+ * caller gives it self-contradictory data, ie if two elements are claimed to
+ * be both opposite and non-opposite. */
+void edsf_merge(int *dsf, int v1, int v2, int inverse);
+void dsf_merge(int *dsf, int v1, int v2);
+void dsf_init(int *dsf, int len);
+
+/*
+ * tdq.c
+ */
+
+/*
+ * Data structure implementing a 'to-do queue', a simple
+ * de-duplicating to-do list mechanism.
+ *
+ * Specification: a tdq is a queue which can hold integers from 0 to
+ * n-1, where n was some constant specified at tdq creation time. No
+ * integer may appear in the queue's current contents more than once;
+ * an attempt to add an already-present integer again will do nothing,
+ * so that that integer is removed from the queue at the position
+ * where it was _first_ inserted. The add and remove operations take
+ * constant time.
+ *
+ * The idea is that you might use this in applications like solvers:
+ * keep a tdq listing the indices of grid squares that you currently
+ * need to process in some way. Whenever you modify a square in a way
+ * that will require you to re-scan its neighbours, add them to the
+ * list with tdq_add; meanwhile you're constantly taking elements off
+ * the list when you need another square to process. In solvers where
+ * deductions are mostly localised, this should prevent repeated
+ * O(N^2) loops over the whole grid looking for something to do. (But
+ * if only _most_ of the deductions are localised, then you should
+ * respond to an empty to-do list by re-adding everything using
+ * tdq_fill, so _then_ you rescan the whole grid looking for newly
+ * enabled non-local deductions. Only if you've done that and emptied
+ * the list again finding nothing new to do are you actually done.)
+ */
+typedef struct tdq tdq;
+tdq *tdq_new(int n);
+void tdq_free(tdq *tdq);
+void tdq_add(tdq *tdq, int k);
+int tdq_remove(tdq *tdq);        /* returns -1 if nothing available */
+void tdq_fill(tdq *tdq);         /* add everything to the tdq at once */
+
+/*
+ * laydomino.c
+ */
+int *domino_layout(int w, int h, random_state *rs);
+void domino_layout_prealloc(int w, int h, random_state *rs,
+                            int *grid, int *grid2, int *list);
+/*
+ * version.c
+ */
+extern char ver[];
+
+/*
+ * random.c
+ */
+random_state *random_new(const char *seed, int len);
+random_state *random_copy(random_state *tocopy);
+unsigned long random_bits(random_state *state, int bits);
+unsigned long random_upto(random_state *state, unsigned long limit);
+void random_free(random_state *state);
+char *random_state_encode(random_state *state);
+random_state *random_state_decode(const char *input);
+/* random.c also exports SHA, which occasionally comes in useful. */
+#if __STDC_VERSION__ >= 199901L
+#include <stdint.h>
+typedef uint32_t uint32;
+#elif UINT_MAX >= 4294967295L
+typedef unsigned int uint32;
+#else
+typedef unsigned long uint32;
+#endif
+typedef struct {
+    uint32 h[5];
+    unsigned char block[64];
+    int blkused;
+    uint32 lenhi, lenlo;
+} SHA_State;
+void SHA_Init(SHA_State *s);
+void SHA_Bytes(SHA_State *s, const void *p, int len);
+void SHA_Final(SHA_State *s, unsigned char *output);
+void SHA_Simple(const void *p, int len, unsigned char *output);
+
+/*
+ * printing.c
+ */
+document *document_new(int pw, int ph, float userscale);
+void document_free(document *doc);
+void document_add_puzzle(document *doc, const game *game, game_params *par,
+                         game_state *st, game_state *st2);
+void document_print(document *doc, drawing *dr);
+
+/*
+ * ps.c
+ */
+//psdata *ps_init(FILE *outfile, int colour);
+//void ps_free(psdata *ps);
+//drawing *ps_drawing_api(psdata *ps);
+
+/*
+ * combi.c: provides a structure and functions for iterating over
+ * combinations (i.e. choosing r things out of n).
+ */
+typedef struct _combi_ctx {
+  int r, n, nleft, total;
+  int *a;
+} combi_ctx;
+
+combi_ctx *new_combi(int r, int n);
+void reset_combi(combi_ctx *combi);
+combi_ctx *next_combi(combi_ctx *combi); /* returns NULL for end */
+void free_combi(combi_ctx *combi);
+
+/*
+ * divvy.c
+ */
+/* divides w*h rectangle into pieces of size k. Returns w*h dsf. */
+int *divvy_rectangle(int w, int h, int k, random_state *rs);
+
+/*
+ * findloop.c
+ */
+struct findloopstate;
+struct findloopstate *findloop_new_state(int nvertices);
+void findloop_free_state(struct findloopstate *);
+/*
+ * Callback provided by the client code to enumerate the graph
+ * vertices joined directly to a given vertex.
+ *
+ * Semantics: if vertex >= 0, return one of its neighbours; if vertex
+ * < 0, return a previously unmentioned neighbour of whatever vertex
+ * was last passed as input. Write to 'ctx' as necessary to store
+ * state. In either case, return < 0 if no such vertex can be found.
+ */
+typedef int (*neighbour_fn_t)(int vertex, void *ctx);
+/*
+ * Actual function to find loops. 'ctx' will be passed unchanged to
+ * the 'neighbour' function to query graph edges. Returns FALSE if no
+ * loop was found, or TRUE if one was.
+ */
+int findloop_run(struct findloopstate *state, int nvertices,
+                 neighbour_fn_t neighbour, void *ctx);
+/*
+ * Query whether an edge is part of a loop, in the output of
+ * find_loops.
+ *
+ * Due to the internal storage format, if you pass u,v which are not
+ * connected at all, the output will be TRUE. (The algorithm actually
+ * stores an exhaustive list of *non*-loop edges, because there are
+ * fewer of those, so really it's querying whether the edge is on that
+ * list.)
+ */
+int findloop_is_loop_edge(struct findloopstate *state, int u, int v);
+
+/*
+ * Data structure containing the function calls and data specific
+ * to a particular game. This is enclosed in a data structure so
+ * that a particular platform can choose, if it wishes, to compile
+ * all the games into a single combined executable rather than
+ * having lots of little ones.
+ */
+struct game {
+    const char *name;
+    const char *winhelp_topic, *htmlhelp_topic;
+    game_params *(*default_params)(void);
+    int (*fetch_preset)(int i, char **name, game_params **params);
+    void (*decode_params)(game_params *, char const *string);
+    char *(*encode_params)(const game_params *, int full);
+    void (*free_params)(game_params *params);
+    game_params *(*dup_params)(const game_params *params);
+    int can_configure;
+    config_item *(*configure)(const game_params *params);
+    game_params *(*custom_params)(const config_item *cfg);
+    char *(*validate_params)(const game_params *params, int full);
+    char *(*new_desc)(const game_params *params, random_state *rs,
+                      char **aux, int interactive);
+    char *(*validate_desc)(const game_params *params, const char *desc);
+    game_state *(*new_game)(midend *me, const game_params *params,
+                            const char *desc);
+    game_state *(*dup_game)(const game_state *state);
+    void (*free_game)(game_state *state);
+    int can_solve;
+    char *(*solve)(const game_state *orig, const game_state *curr,
+                   const char *aux, char **error);
+    int can_format_as_text_ever;
+    int (*can_format_as_text_now)(const game_params *params);
+    char *(*text_format)(const game_state *state);
+    game_ui *(*new_ui)(const game_state *state);
+    void (*free_ui)(game_ui *ui);
+    char *(*encode_ui)(const game_ui *ui);
+    void (*decode_ui)(game_ui *ui, const char *encoding);
+    void (*changed_state)(game_ui *ui, const game_state *oldstate,
+                          const game_state *newstate);
+    char *(*interpret_move)(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds, int x, int y, int button);
+    game_state *(*execute_move)(const game_state *state, const char *move);
+    int preferred_tilesize;
+    void (*compute_size)(const game_params *params, int tilesize,
+                         int *x, int *y);
+    void (*set_size)(drawing *dr, game_drawstate *ds,
+                     const game_params *params, int tilesize);
+    float *(*colours)(frontend *fe, int *ncolours);
+    game_drawstate *(*new_drawstate)(drawing *dr, const game_state *state);
+    void (*free_drawstate)(drawing *dr, game_drawstate *ds);
+    void (*redraw)(drawing *dr, game_drawstate *ds, const game_state *oldstate,
+                   const game_state *newstate, int dir, const game_ui *ui,
+                   float anim_time, float flash_time);
+    float (*anim_length)(const game_state *oldstate,
+                         const game_state *newstate, int dir, game_ui *ui);
+    float (*flash_length)(const game_state *oldstate,
+                          const game_state *newstate, int dir, game_ui *ui);
+    int (*status)(const game_state *state);
+    int can_print, can_print_in_colour;
+    void (*print_size)(const game_params *params, float *x, float *y);
+    void (*print)(drawing *dr, const game_state *state, int tilesize);
+    int wants_statusbar;
+    int is_timed;
+    int (*timing_state)(const game_state *state, game_ui *ui);
+    int flags;
+};
+
+/*
+ * Data structure containing the drawing API implemented by the
+ * front end and also by cross-platform printing modules such as
+ * PostScript.
+ */
+struct drawing_api {
+    void (*draw_text)(void *handle, int x, int y, int fonttype, int fontsize,
+                      int align, int colour, char *text);
+    void (*draw_rect)(void *handle, int x, int y, int w, int h, int colour);
+    void (*draw_line)(void *handle, int x1, int y1, int x2, int y2,
+                      int colour);
+    void (*draw_polygon)(void *handle, int *coords, int npoints,
+                         int fillcolour, int outlinecolour);
+    void (*draw_circle)(void *handle, int cx, int cy, int radius,
+                        int fillcolour, int outlinecolour);
+    void (*draw_update)(void *handle, int x, int y, int w, int h);
+    void (*clip)(void *handle, int x, int y, int w, int h);
+    void (*unclip)(void *handle);
+    void (*start_draw)(void *handle);
+    void (*end_draw)(void *handle);
+    void (*status_bar)(void *handle, char *text);
+    blitter *(*blitter_new)(void *handle, int w, int h);
+    void (*blitter_free)(void *handle, blitter *bl);
+    void (*blitter_save)(void *handle, blitter *bl, int x, int y);
+    void (*blitter_load)(void *handle, blitter *bl, int x, int y);
+    void (*begin_doc)(void *handle, int pages);
+    void (*begin_page)(void *handle, int number);
+    void (*begin_puzzle)(void *handle, float xm, float xc,
+                         float ym, float yc, int pw, int ph, float wmm);
+    void (*end_puzzle)(void *handle);
+    void (*end_page)(void *handle, int number);
+    void (*end_doc)(void *handle);
+    void (*line_width)(void *handle, float width);
+    void (*line_dotted)(void *handle, int dotted);
+    char *(*text_fallback)(void *handle, const char *const *strings,
+                           int nstrings);
+    void (*draw_thick_line)(void *handle, float thickness,
+                            float x1, float y1, float x2, float y2,
+                            int colour);
+};
+
+/*
+ * For one-game-at-a-time platforms, there's a single structure
+ * like the above, under a fixed name. For all-at-once platforms,
+ * there's a list of all available puzzles in array form.
+ */
+#ifdef COMBINED
+extern const game *gamelist[];
+extern const int gamecount;
+#else
+extern const game thegame;
+#endif
+
+/* A little bit of help to lazy developers */
+#define DEFAULT_STATUSBAR_TEXT "Use status_bar() to fill this in."
+
+#endif /* PUZZLES_PUZZLES_H */
diff --git a/apps/plugins/puzzles/puzzles.make b/apps/plugins/puzzles/puzzles.make
new file mode 100644
index 0000000000..054e53eeb1
--- /dev/null
+++ b/apps/plugins/puzzles/puzzles.make
@@ -0,0 +1,113 @@
+#             __________               __   ___.
+#   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+#   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+#   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+#   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+#                     \/            \/     \/    \/            \/
+# $Id$
+#
+
+PUZZLES_SRCDIR = $(APPSDIR)/plugins/puzzles
+PUZZLES_OBJDIR = $(BUILDDIR)/apps/plugins/puzzles
+
+# define this as "yes" to do a monolithic build -- remember to also
+# uncomment the sgt-puzzles loader in apps/plugins/SOURCES
+PUZZLES_COMBINED =
+
+ifdef PUZZLES_COMBINED
+PUZZLES_SRC := $(call preprocess, $(PUZZLES_SRCDIR)/SOURCES, -DCOMBINED)
+else
+PUZZLES_SRC := $(call preprocess, $(PUZZLES_SRCDIR)/SOURCES)
+endif
+
+ifndef PUZZLES_COMBINED
+PUZZLES_SHARED_OBJ := $(call c2obj, $(PUZZLES_SRC))
+endif
+
+PUZZLES_GAMES_SRC := $(call preprocess, $(PUZZLES_SRCDIR)/SOURCES.games)
+PUZZLES_SRC += $(PUZZLES_GAMES_SRC)
+PUZZLES_OBJ := $(call c2obj, $(PUZZLES_SRC))
+OTHER_SRC += $(PUZZLES_SRC)
+
+ifdef PUZZLES_COMBINED
+ifndef APP_TYPE
+ROCKS += $(PUZZLES_OBJDIR)/puzzles.ovl
+PUZZLES_OUTLDS = $(PUZZLES_OBJDIR)/puzzles.link
+PUZZLES_OVLFLAGS = -T$(PUZZLES_OUTLDS) -Wl,--gc-sections -Wl,-Map,$(basename $@).map
+else
+ROCKS += $(PUZZLES_OBJDIR)/puzzles.rock
+endif
+else
+PUZZLES_ROCKS := $(addprefix $(PUZZLES_OBJDIR)/sgt-, $(notdir $(PUZZLES_GAMES_SRC:.c=.rock)))
+ROCKS += $(PUZZLES_ROCKS)
+endif
+
+PUZZLESFLAGS = $(filter-out -O%,$(PLUGINFLAGS)) -Os             \
+                -Wno-unused-parameter -Wno-sign-compare -Wno-strict-aliasing -w \
+                -DFOR_REAL
+ifdef PUZZLES_COMBINED
+PUZZLESFLAGS += -DCOMBINED
+endif
+
+ifdef PUZZLES_COMBINED
+$(PUZZLES_OBJDIR)/puzzles.rock: $(PUZZLES_OBJ) $(TLSFLIB)
+
+$(PUZZLES_OBJDIR)/puzzles.refmap: $(PUZZLES_OBJ) $(TLSFLIB)
+
+$(PUZZLES_OUTLDS): $(PLUGIN_LDS) $(PUZZLES_OBJDIR)/puzzles.refmap
+        $(call PRINTS,PP $(@F))$(call preprocess2file,$<,$@,-DOVERLAY_OFFSET=$(shell \
+                $(TOOLSDIR)/ovl_offset.pl $(PUZZLES_OBJDIR)/puzzles.refmap))
+
+$(PUZZLES_OBJDIR)/puzzles.ovl: $(PUZZLES_OBJ) $(PUZZLES_OUTLDS) $(TLSFLIB)
+        $(SILENT)$(CC) $(PLUGINFLAGS) -o $(basename $@).elf \
+                $(filter %.o, $^) \
+                $(filter %.a, $+) \
+                -lgcc $(PUZZLES_OVLFLAGS)
+        $(call PRINTS,LD $(@F))$(call objcopy,$(basename $@).elf,$@)
+else
+# todo: figure out how to do this with wildcards
+$(PUZZLES_OBJDIR)/sgt-blackbox.rock: $(PUZZLES_OBJDIR)/blackbox.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-bridges.rock: $(PUZZLES_OBJDIR)/bridges.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-cube.rock: $(PUZZLES_OBJDIR)/cube.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-dominosa.rock: $(PUZZLES_OBJDIR)/dominosa.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-fifteen.rock: $(PUZZLES_OBJDIR)/fifteen.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-filling.rock: $(PUZZLES_OBJDIR)/filling.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-flip.rock: $(PUZZLES_OBJDIR)/flip.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-flood.rock: $(PUZZLES_OBJDIR)/flood.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-galaxies.rock: $(PUZZLES_OBJDIR)/galaxies.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-guess.rock: $(PUZZLES_OBJDIR)/guess.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-inertia.rock: $(PUZZLES_OBJDIR)/inertia.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-keen.rock: $(PUZZLES_OBJDIR)/keen.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-lightup.rock: $(PUZZLES_OBJDIR)/lightup.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-loopy.rock: $(PUZZLES_OBJDIR)/loopy.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-magnets.rock: $(PUZZLES_OBJDIR)/magnets.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-map.rock: $(PUZZLES_OBJDIR)/map.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-mines.rock: $(PUZZLES_OBJDIR)/mines.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-net.rock: $(PUZZLES_OBJDIR)/net.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-netslide.rock: $(PUZZLES_OBJDIR)/netslide.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-palisade.rock: $(PUZZLES_OBJDIR)/palisade.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-pattern.rock: $(PUZZLES_OBJDIR)/pattern.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-pearl.rock: $(PUZZLES_OBJDIR)/pearl.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-pegs.rock: $(PUZZLES_OBJDIR)/pegs.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-range.rock: $(PUZZLES_OBJDIR)/range.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-rect.rock: $(PUZZLES_OBJDIR)/rect.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-samegame.rock: $(PUZZLES_OBJDIR)/samegame.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-signpost.rock: $(PUZZLES_OBJDIR)/signpost.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-singles.rock: $(PUZZLES_OBJDIR)/singles.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-sixteen.rock: $(PUZZLES_OBJDIR)/sixteen.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-slant.rock: $(PUZZLES_OBJDIR)/slant.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-solo.rock: $(PUZZLES_OBJDIR)/solo.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-tents.rock: $(PUZZLES_OBJDIR)/tents.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-towers.rock: $(PUZZLES_OBJDIR)/towers.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-tracks.rock: $(PUZZLES_OBJDIR)/tracks.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-twiddle.rock: $(PUZZLES_OBJDIR)/twiddle.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-undead.rock: $(PUZZLES_OBJDIR)/undead.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-unequal.rock: $(PUZZLES_OBJDIR)/unequal.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-unruly.rock: $(PUZZLES_OBJDIR)/unruly.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+$(PUZZLES_OBJDIR)/sgt-untangle.rock: $(PUZZLES_OBJDIR)/untangle.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+endif
+
+# special pattern rule for compiling puzzles with extra flags
+$(PUZZLES_OBJDIR)/%.o: $(PUZZLES_SRCDIR)/%.c $(PUZZLES_SRCDIR)/puzzles.make
+        $(SILENT)mkdir -p $(dir $@)
+        $(call PRINTS,CC $(subst $(ROOTDIR)/,,$<))$(CC) -I$(dir $<) $(PUZZLESFLAGS) -c $< -o $@
diff --git a/apps/plugins/puzzles/puzzles.rc2 b/apps/plugins/puzzles/puzzles.rc2
new file mode 100644
index 0000000000..4442a9b138
--- /dev/null
+++ b/apps/plugins/puzzles/puzzles.rc2
@@ -0,0 +1,65 @@
+/* Standard stuff that goes into the Windows resources for all puzzles. */
+
+#ifdef _WIN32_WCE
+
+#include <winuser.h>
+#include <commctrl.h>
+
+#define SHMENUBAR       RCDATA
+#define I_IMAGENONE     (-2)
+#define IDC_STATIC      (-1)
+
+#include "resource.h"
+
+IDR_MENUBAR1 MENU DISCARDABLE 
+BEGIN
+    POPUP "Game"
+    BEGIN
+        MENUITEM "Dummy", 0
+    END
+    POPUP "Type"
+    BEGIN
+        MENUITEM "Dummy", 0
+    END
+END
+
+IDR_MENUBAR1 SHMENUBAR DISCARDABLE 
+BEGIN
+    IDR_MENUBAR1, 2,
+    I_IMAGENONE, ID_GAME, TBSTATE_ENABLED, 
+    TBSTYLE_DROPDOWN | TBSTYLE_AUTOSIZE, IDS_CAP_GAME, 0, 0,
+    I_IMAGENONE, ID_TYPE, TBSTATE_ENABLED, 
+    TBSTYLE_DROPDOWN | TBSTYLE_AUTOSIZE, IDS_CAP_TYPE, 0, 1,
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_CAP_GAME            "Game"
+    IDS_CAP_TYPE            "Type"
+END
+
+IDD_ABOUT DIALOG DISCARDABLE  0, 0, 0, 0
+STYLE WS_POPUP
+FONT 8, "Tahoma"
+BEGIN
+    LTEXT "", IDC_ABOUT_CAPTION,        4,  4, 150,  8
+    LTEXT "", IDC_ABOUT_LINE,           4, 16, 150,  1, WS_BORDER
+    LTEXT "", IDC_ABOUT_GAME,           4, 22, 150,  8
+    LTEXT "from Simon Tatham's Portable Puzzle Collection",
+              IDC_STATIC,               4, 36, 150,  8, SS_LEFTNOWORDWRAP
+    LTEXT "Pocket PC port by Darek Olszewski",
+              IDC_STATIC,               4, 46, 150,  8
+    LTEXT "", IDC_ABOUT_VERSION,        4, 60, 150,  8
+END
+
+IDD_CONFIG DIALOG DISCARDABLE  0, 0, 0, 0
+STYLE WS_POPUP
+FONT 8, "Tahoma"
+BEGIN
+    LTEXT "", IDC_CONFIG_CAPTION,       4,  4, 150,  8
+    LTEXT "", IDC_CONFIG_LINE,          4, 16, 150,  1, WS_BORDER
+END
+
+IDR_PADTOOLBAR BITMAP DISCARDABLE "padtoolbar.bmp"
+
+#endif /* _WIN32_WCE */
diff --git a/apps/plugins/puzzles/random.c b/apps/plugins/puzzles/random.c
new file mode 100644
index 0000000000..c129a8d2ba
--- /dev/null
+++ b/apps/plugins/puzzles/random.c
@@ -0,0 +1,350 @@
+/*
+ * random.c: Internal random number generator, guaranteed to work
+ * the same way on all platforms. Used when generating an initial
+ * game state from a random game seed; required to ensure that game
+ * seeds can be exchanged between versions of a puzzle compiled for
+ * different platforms.
+ * 
+ * The generator is based on SHA-1. This is almost certainly
+ * overkill, but I had the SHA-1 code kicking around and it was
+ * easier to reuse it than to do anything else!
+ */
+
+#include <string.h>
+#include <stdio.h>
+
+#include "puzzles.h"
+
+/* ----------------------------------------------------------------------
+ * Core SHA algorithm: processes 16-word blocks into a message digest.
+ */
+
+#define rol(x,y) ( ((x) << (y)) | (((uint32)x) >> (32-y)) )
+
+static void SHA_Core_Init(uint32 h[5])
+{
+    h[0] = 0x67452301;
+    h[1] = 0xefcdab89;
+    h[2] = 0x98badcfe;
+    h[3] = 0x10325476;
+    h[4] = 0xc3d2e1f0;
+}
+
+static void SHATransform(uint32 * digest, uint32 * block)
+{
+    uint32 w[80];
+    uint32 a, b, c, d, e;
+    int t;
+
+    for (t = 0; t < 16; t++)
+        w[t] = block[t];
+
+    for (t = 16; t < 80; t++) {
+        uint32 tmp = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16];
+        w[t] = rol(tmp, 1);
+    }
+
+    a = digest[0];
+    b = digest[1];
+    c = digest[2];
+    d = digest[3];
+    e = digest[4];
+
+    for (t = 0; t < 20; t++) {
+        uint32 tmp =
+            rol(a, 5) + ((b & c) | (d & ~b)) + e + w[t] + 0x5a827999;
+        e = d;
+        d = c;
+        c = rol(b, 30);
+        b = a;
+        a = tmp;
+    }
+    for (t = 20; t < 40; t++) {
+        uint32 tmp = rol(a, 5) + (b ^ c ^ d) + e + w[t] + 0x6ed9eba1;
+        e = d;
+        d = c;
+        c = rol(b, 30);
+        b = a;
+        a = tmp;
+    }
+    for (t = 40; t < 60; t++) {
+        uint32 tmp = rol(a,
+                         5) + ((b & c) | (b & d) | (c & d)) + e + w[t] +
+            0x8f1bbcdc;
+        e = d;
+        d = c;
+        c = rol(b, 30);
+        b = a;
+        a = tmp;
+    }
+    for (t = 60; t < 80; t++) {
+        uint32 tmp = rol(a, 5) + (b ^ c ^ d) + e + w[t] + 0xca62c1d6;
+        e = d;
+        d = c;
+        c = rol(b, 30);
+        b = a;
+        a = tmp;
+    }
+
+    digest[0] += a;
+    digest[1] += b;
+    digest[2] += c;
+    digest[3] += d;
+    digest[4] += e;
+}
+
+/* ----------------------------------------------------------------------
+ * Outer SHA algorithm: take an arbitrary length byte string,
+ * convert it into 16-word blocks with the prescribed padding at
+ * the end, and pass those blocks to the core SHA algorithm.
+ */
+
+void SHA_Init(SHA_State * s)
+{
+    SHA_Core_Init(s->h);
+    s->blkused = 0;
+    s->lenhi = s->lenlo = 0;
+}
+
+void SHA_Bytes(SHA_State * s, const void *p, int len)
+{
+    unsigned char *q = (unsigned char *) p;
+    uint32 wordblock[16];
+    uint32 lenw = len;
+    int i;
+
+    /*
+     * Update the length field.
+     */
+    s->lenlo += lenw;
+    s->lenhi += (s->lenlo < lenw);
+
+    if (s->blkused && s->blkused + len < 64) {
+        /*
+         * Trivial case: just add to the block.
+         */
+        memcpy(s->block + s->blkused, q, len);
+        s->blkused += len;
+    } else {
+        /*
+         * We must complete and process at least one block.
+         */
+        while (s->blkused + len >= 64) {
+            memcpy(s->block + s->blkused, q, 64 - s->blkused);
+            q += 64 - s->blkused;
+            len -= 64 - s->blkused;
+            /* Now process the block. Gather bytes big-endian into words */
+            for (i = 0; i < 16; i++) {
+                wordblock[i] =
+                    (((uint32) s->block[i * 4 + 0]) << 24) |
+                    (((uint32) s->block[i * 4 + 1]) << 16) |
+                    (((uint32) s->block[i * 4 + 2]) << 8) |
+                    (((uint32) s->block[i * 4 + 3]) << 0);
+            }
+            SHATransform(s->h, wordblock);
+            s->blkused = 0;
+        }
+        memcpy(s->block, q, len);
+        s->blkused = len;
+    }
+}
+
+void SHA_Final(SHA_State * s, unsigned char *output)
+{
+    int i;
+    int pad;
+    unsigned char c[64];
+    uint32 lenhi, lenlo;
+
+    if (s->blkused >= 56)
+        pad = 56 + 64 - s->blkused;
+    else
+        pad = 56 - s->blkused;
+
+    lenhi = (s->lenhi << 3) | (s->lenlo >> (32 - 3));
+    lenlo = (s->lenlo << 3);
+
+    memset(c, 0, pad);
+    c[0] = 0x80;
+    SHA_Bytes(s, &c, pad);
+
+    c[0] = (unsigned char)((lenhi >> 24) & 0xFF);
+    c[1] = (unsigned char)((lenhi >> 16) & 0xFF);
+    c[2] = (unsigned char)((lenhi >> 8) & 0xFF);
+    c[3] = (unsigned char)((lenhi >> 0) & 0xFF);
+    c[4] = (unsigned char)((lenlo >> 24) & 0xFF);
+    c[5] = (unsigned char)((lenlo >> 16) & 0xFF);
+    c[6] = (unsigned char)((lenlo >> 8) & 0xFF);
+    c[7] = (unsigned char)((lenlo >> 0) & 0xFF);
+
+    SHA_Bytes(s, &c, 8);
+
+    for (i = 0; i < 5; i++) {
+        output[i * 4] = (unsigned char)((s->h[i] >> 24) & 0xFF);
+        output[i * 4 + 1] = (unsigned char)((s->h[i] >> 16) & 0xFF);
+        output[i * 4 + 2] = (unsigned char)((s->h[i] >> 8) & 0xFF);
+        output[i * 4 + 3] = (unsigned char)((s->h[i]) & 0xFF);
+    }
+}
+
+void SHA_Simple(const void *p, int len, unsigned char *output)
+{
+    SHA_State s;
+
+    SHA_Init(&s);
+    SHA_Bytes(&s, p, len);
+    SHA_Final(&s, output);
+}
+
+/* ----------------------------------------------------------------------
+ * The random number generator.
+ */
+
+struct random_state {
+    unsigned char seedbuf[40];
+    unsigned char databuf[20];
+    int pos;
+};
+
+random_state *random_new(const char *seed, int len)
+{
+    random_state *state;
+
+    state = snew(random_state);
+
+    SHA_Simple(seed, len, state->seedbuf);
+    SHA_Simple(state->seedbuf, 20, state->seedbuf + 20);
+    SHA_Simple(state->seedbuf, 40, state->databuf);
+    state->pos = 0;
+
+    return state;
+}
+
+random_state *random_copy(random_state *tocopy)
+{
+    random_state *result;
+    result = snew(random_state);
+    memcpy(result->seedbuf, tocopy->seedbuf, sizeof(result->seedbuf));
+    memcpy(result->databuf, tocopy->databuf, sizeof(result->databuf));
+    result->pos = tocopy->pos;
+    return result;
+}
+
+unsigned long random_bits(random_state *state, int bits)
+{
+    unsigned long ret = 0;
+    int n;
+
+    for (n = 0; n < bits; n += 8) {
+        if (state->pos >= 20) {
+            int i;
+
+            for (i = 0; i < 20; i++) {
+                if (state->seedbuf[i] != 0xFF) {
+                    state->seedbuf[i]++;
+                    break;
+                } else
+                    state->seedbuf[i] = 0;
+            }
+            SHA_Simple(state->seedbuf, 40, state->databuf);
+            state->pos = 0;
+        }
+        ret = (ret << 8) | state->databuf[state->pos++];
+    }
+
+    /*
+     * `(1 << bits) - 1' is not good enough, since if bits==32 on a
+     * 32-bit machine, behaviour is undefined and Intel has a nasty
+     * habit of shifting left by zero instead. We'll shift by
+     * bits-1 and then separately shift by one.
+     */
+    ret &= (1 << (bits-1)) * 2 - 1;
+    return ret;
+}
+
+unsigned long random_upto(random_state *state, unsigned long limit)
+{
+    int bits = 0;
+    unsigned long max, divisor, data;
+
+    while ((limit >> bits) != 0)
+        bits++;
+
+    bits += 3;
+    //assert(bits < 32);
+
+    max = 1L << bits;
+    divisor = max / limit;
+    max = limit * divisor;
+
+    do {
+        data = random_bits(state, bits);
+    } while (data >= max);
+
+    return data / divisor;
+}
+
+void random_free(random_state *state)
+{
+    sfree(state);
+}
+
+char *random_state_encode(random_state *state)
+{
+    char retbuf[256];
+    int len = 0, i;
+
+    for (i = 0; i < lenof(state->seedbuf); i++)
+        len += sprintf(retbuf+len, "%02x", state->seedbuf[i]);
+    for (i = 0; i < lenof(state->databuf); i++)
+        len += sprintf(retbuf+len, "%02x", state->databuf[i]);
+    len += sprintf(retbuf+len, "%02x", state->pos);
+
+    return dupstr(retbuf);
+}
+
+random_state *random_state_decode(const char *input)
+{
+    random_state *state;
+    int pos, byte, digits;
+
+    state = snew(random_state);
+
+    memset(state->seedbuf, 0, sizeof(state->seedbuf));
+    memset(state->databuf, 0, sizeof(state->databuf));
+    state->pos = 0;
+
+    byte = digits = 0;
+    pos = 0;
+    while (*input) {
+        int v = *input++;
+
+        if (v >= '0' && v <= '9')
+            v = v - '0';
+        else if (v >= 'A' && v <= 'F')
+            v = v - 'A' + 10;
+        else if (v >= 'a' && v <= 'f')
+            v = v - 'a' + 10;
+        else
+            v = 0;
+
+        byte = (byte << 4) | v;
+        digits++;
+
+        if (digits == 2) {
+            /*
+             * We have a byte. Put it somewhere.
+             */
+            if (pos < lenof(state->seedbuf))
+                state->seedbuf[pos++] = byte;
+            else if (pos < lenof(state->seedbuf) + lenof(state->databuf))
+                state->databuf[pos++ - lenof(state->seedbuf)] = byte;
+            else if (pos == lenof(state->seedbuf) + lenof(state->databuf) &&
+                     byte <= lenof(state->databuf))
+                state->pos = byte;
+            byte = digits = 0;
+        }
+    }
+
+    return state;
+}
diff --git a/apps/plugins/puzzles/range.R b/apps/plugins/puzzles/range.R
new file mode 100644
index 0000000000..f1256efd1e
--- /dev/null
+++ b/apps/plugins/puzzles/range.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+RANGE_EXTRA = dsf
+
+range    : [X] GTK COMMON range RANGE_EXTRA range-icon|no-icon
+
+range    : [G] WINDOWS COMMON range RANGE_EXTRA range.res|noicon.res
+
+ALL += range[COMBINED] RANGE_EXTRA
+
+!begin am gtk
+GAMES += range
+!end
+
+!begin >list.c
+    A(range) \
+!end
+
+!begin >gamedesc.txt
+range:range.exe:Range:Visible-distance puzzle:Place black squares to limit the visible distance from each numbered cell.
+!end
diff --git a/apps/plugins/puzzles/range.c b/apps/plugins/puzzles/range.c
new file mode 100644
index 0000000000..e1067cbcc5
--- /dev/null
+++ b/apps/plugins/puzzles/range.c
@@ -0,0 +1,1833 @@
+/*
+ * range.c: implementation of the Nikoli game 'Kurodoko' / 'Kuromasu'.
+ */
+
+/*
+ * Puzzle rules: the player is given a WxH grid of white squares, some
+ * of which contain numbers. The goal is to paint some of the squares
+ * black, such that:
+ *
+ *  - no cell (err, cell = square) with a number is painted black
+ *  - no black cells have an adjacent (horz/vert) black cell
+ *  - the white cells are all connected (through other white cells)
+ *  - if a cell contains a number n, let h and v be the lengths of the
+ *    maximal horizontal and vertical white sequences containing that
+ *    cell.  Then n must equal h + v - 1.
+ */
+
+/* example instance with its encoding and textual representation, both
+ * solved and unsolved (made by thegame.solve and thegame.text_format)
+ *
+ * +--+--+--+--+--+--+--+
+ * |  |  |  |  | 7|  |  |
+ * +--+--+--+--+--+--+--+
+ * | 3|  |  |  |  |  | 8|
+ * +--+--+--+--+--+--+--+
+ * |  |  |  |  |  | 5|  |
+ * +--+--+--+--+--+--+--+
+ * |  |  | 7|  | 7|  |  |
+ * +--+--+--+--+--+--+--+
+ * |  |13|  |  |  |  |  |
+ * +--+--+--+--+--+--+--+
+ * | 4|  |  |  |  |  | 8|
+ * +--+--+--+--+--+--+--+
+ * |  |  | 4|  |  |  |  |
+ * +--+--+--+--+--+--+--+
+ *
+ * 7x7:d7b3e8e5c7a7c13e4d8b4d
+ *
+ * +--+--+--+--+--+--+--+
+ * |..|..|..|..| 7|..|..|
+ * +--+--+--+--+--+--+--+
+ * | 3|..|##|..|##|..| 8|
+ * +--+--+--+--+--+--+--+
+ * |##|..|..|##|..| 5|..|
+ * +--+--+--+--+--+--+--+
+ * |..|..| 7|..| 7|##|..|
+ * +--+--+--+--+--+--+--+
+ * |..|13|..|..|..|..|..|
+ * +--+--+--+--+--+--+--+
+ * | 4|..|##|..|##|..| 8|
+ * +--+--+--+--+--+--+--+
+ * |##|..| 4|..|..|##|..|
+ * +--+--+--+--+--+--+--+
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#include <stdarg.h>
+
+#define setmember(obj, field) ( (obj) . field = field )
+
+static char *nfmtstr(int n, char *fmt, ...) {
+    va_list va;
+    char *ret = snewn(n+1, char);
+    va_start(va, fmt);
+    vsprintf(ret, fmt, va);
+    va_end(va);
+    return ret;
+}
+
+#define SWAP(type, lvar1, lvar2) do { \
+    type tmp = (lvar1); \
+    (lvar1) = (lvar2); \
+    (lvar2) = tmp; \
+} while (0)
+
+/* ----------------------------------------------------------------------
+ * Game parameters, presets, states
+ */
+
+typedef signed char puzzle_size;
+
+struct game_params {
+    puzzle_size w;
+    puzzle_size h;
+};
+
+struct game_state {
+    struct game_params params;
+    unsigned int has_cheated: 1;
+    unsigned int was_solved: 1;
+    puzzle_size *grid;
+};
+
+#define DEFAULT_PRESET 0
+static struct game_params range_presets[] = {{9, 6}, {12, 8}, {13, 9}, {16, 11}};
+/* rationale: I want all four combinations of {odd/even, odd/even}, as
+ * they play out differently with respect to two-way symmetry.  I also
+ * want them to be generated relatively fast yet still be large enough
+ * to be entertaining for a decent amount of time, and I want them to
+ * make good use of monitor real estate (the typical screen resolution
+ * is why I do 13x9 and not 9x13).
+ */
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+    *ret = range_presets[DEFAULT_PRESET]; /* structure copy */
+    return ret;
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params; /* structure copy */
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+
+    if (i < 0 || i >= lenof(range_presets)) return FALSE;
+
+    ret = default_params();
+    *ret = range_presets[i]; /* struct copy */
+    *params = ret;
+
+    *name = nfmtstr(40, "%d x %d", range_presets[i].w, range_presets[i].h);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    /* FIXME check for puzzle_size overflow and decoding issues */
+    params->w = params->h = atoi(string);
+    while (*string && isdigit((unsigned char) *string)) ++string;
+    if (*string == 'x') {
+        string++;
+        params->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char str[80];
+    sprintf(str, "%dx%d", params->w, params->h);
+    return dupstr(str);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+
+    ret = snewn(3, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    ret[0].sval = nfmtstr(10, "%d", params->w);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    ret[1].sval = nfmtstr(10, "%d", params->h);
+    ret[1].ival = 0;
+
+    ret[2].name = NULL;
+    ret[2].type = C_END;
+    ret[2].sval = NULL;
+    ret[2].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *configuration)
+{
+    game_params *ret = snew(game_params);
+    ret->w = atoi(configuration[0].sval);
+    ret->h = atoi(configuration[1].sval);
+    return ret;
+}
+
+#define memdup(dst, src, n, type) do { \
+    dst = snewn(n, type); \
+    memcpy(dst, src, n * sizeof (type)); \
+} while (0)
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+    int const n = state->params.w * state->params.h;
+
+    *ret = *state; /* structure copy */
+
+    /* copy the poin_tee_, set a new value of the poin_ter_ */
+    memdup(ret->grid, state->grid, n, puzzle_size);
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    sfree(state);
+}
+
+
+/* ----------------------------------------------------------------------
+ * The solver subsystem.
+ *
+ * The solver is used for two purposes:
+ *  - To solve puzzles when the user selects `Solve'.
+ *  - To test solubility of a grid as clues are being removed from it
+ *    during the puzzle generation.
+ *
+ * It supports the following ways of reasoning:
+ *
+ *  - A cell adjacent to a black cell must be white.
+ *
+ *  - If painting a square black would bisect the white regions, that
+ *    square is white (by finding biconnected components' cut points)
+ *
+ *  - A cell with number n, covering at most k white squares in three
+ *    directions must white-cover n-k squares in the last direction.
+ *
+ *  - A cell with number n known to cover k squares, if extending the
+ *    cover by one square in a given direction causes the cell to
+ *    cover _more_ than n squares, that extension cell must be black.
+ *
+ *    (either if the square already covers n, or if it extends into a
+ *    chunk of size > n - k)
+ *
+ *  - Recursion.  Pick any cell and see if this leads to either a
+ *    contradiction or a solution (and then act appropriately).
+ *
+ *
+ * TODO:
+ *
+ * (propagation upper limit)
+ *  - If one has two numbers on the same line, the smaller limits the
+ *    larger.  Example: in |b|_|_|8|4|_|_|b|, only two _'s can be both
+ *    white and connected to the "8" cell; so that cell will propagate
+ *    at least four cells orthogonally to the displayed line (which is
+ *    better than the current "at least 2").
+ *
+ * (propagation upper limit)
+ *  - cells can't propagate into other cells if doing so exceeds that
+ *    number.  Example: in |b|4|.|.|2|b|, at most one _ can be white;
+ *    otherwise, the |2| would have too many reaching white cells.
+ *
+ * (propagation lower and upper limit)
+ *  - `Full Combo': in each four directions d_1 ... d_4, find a set of
+ *    possible propagation distances S_1 ... S_4.  For each i=1..4,
+ *    for each x in S_i: if not exists (y, z, w) in the other sets
+ *    such that (x+y+z+w+1 == clue value): then remove x from S_i.
+ *    Repeat until this stabilizes.  If any cell would contradict
+ */
+
+#define idx(i, j, w) ((i)*(w) + (j))
+#define out_of_bounds(r, c, w, h) \
+   ((r) < 0 || (r) >= h || (c) < 0 || (c) >= w)
+
+typedef struct square {
+    puzzle_size r, c;
+} square;
+
+enum {BLACK = -2, WHITE, EMPTY};
+/* white is for pencil marks, empty is undecided */
+
+static int const dr[4] = {+1,  0, -1,  0};
+static int const dc[4] = { 0, +1,  0, -1};
+static int const cursors[4] = /* must match dr and dc */
+{CURSOR_DOWN, CURSOR_RIGHT, CURSOR_UP, CURSOR_LEFT};
+
+typedef struct move {
+    square square;
+    unsigned int colour: 1;
+} move;
+enum {M_BLACK = 0, M_WHITE = 1};
+
+typedef move *(reasoning)(game_state *state,
+                          int nclues,
+                          const square *clues,
+                          move *buf);
+
+static reasoning solver_reasoning_not_too_big;
+static reasoning solver_reasoning_adjacency;
+static reasoning solver_reasoning_connectedness;
+static reasoning solver_reasoning_recursion;
+
+enum {
+    DIFF_NOT_TOO_BIG,
+    DIFF_ADJACENCY,
+    DIFF_CONNECTEDNESS,
+    DIFF_RECURSION
+};
+
+static move *solve_internal(const game_state *state, move *base, int diff);
+
+static char *solve_game(const game_state *orig, const game_state *curpos,
+                        const char *aux, char **error)
+{
+    int const n = orig->params.w * orig->params.h;
+    move *const base = snewn(n, move);
+    move *moves = solve_internal(orig, base, DIFF_RECURSION);
+
+    char *ret = NULL;
+
+    if (moves != NULL) {
+        int const k = moves - base;
+        char *str = ret = snewn(15*k + 2, char);
+        char colour[2] = "BW";
+        move *it;
+        *str++ = 'S';
+        *str = '\0';
+        for (it = base; it < moves; ++it)
+            str += sprintf(str, "%c,%d,%d", colour[it->colour],
+                           it->square.r, it->square.c);
+    } else *error = "This puzzle instance contains a contradiction";
+
+    sfree(base);
+    return ret;
+}
+
+static square *find_clues(const game_state *state, int *ret_nclues);
+static move *do_solve(game_state *state,
+                      int nclues,
+                      const square *clues,
+                      move *move_buffer,
+                      int difficulty);
+
+/* new_game_desc entry point in the solver subsystem */
+static move *solve_internal(const game_state *state, move *base, int diff)
+{
+    int nclues;
+    square *const clues = find_clues(state, &nclues);
+    game_state *dup = dup_game(state);
+    move *const moves = do_solve(dup, nclues, clues, base, diff);
+    free_game(dup);
+    sfree(clues);
+    return moves;
+}
+
+static reasoning *const reasonings[] = {
+    solver_reasoning_not_too_big,
+    solver_reasoning_adjacency,
+    solver_reasoning_connectedness,
+    solver_reasoning_recursion
+};
+
+static move *do_solve(game_state *state,
+                      int nclues,
+                      const square *clues,
+                      move *move_buffer,
+                      int difficulty)
+{
+    struct move *buf = move_buffer, *oldbuf;
+    int i;
+
+    do {
+        oldbuf = buf;
+        for (i = 0; i < lenof(reasonings) && i <= difficulty; ++i) {
+            /* only recurse if all else fails */
+            if (i == DIFF_RECURSION && buf > oldbuf) continue;
+            buf = (*reasonings[i])(state, nclues, clues, buf);
+            if (buf == NULL) return NULL;
+        }
+    } while (buf > oldbuf);
+
+    return buf;
+}
+
+#define MASK(n) (1 << ((n) + 2))
+
+static int runlength(puzzle_size r, puzzle_size c,
+                     puzzle_size dr, puzzle_size dc,
+                     const game_state *state, int colourmask)
+{
+    int const w = state->params.w, h = state->params.h;
+    int sz = 0;
+    while (TRUE) {
+        int cell = idx(r, c, w);
+        if (out_of_bounds(r, c, w, h)) break;
+        if (state->grid[cell] > 0) {
+            if (!(colourmask & ~(MASK(BLACK) | MASK(WHITE) | MASK(EMPTY))))
+                break;
+        } else if (!(MASK(state->grid[cell]) & colourmask)) break;
+        ++sz;
+        r += dr;
+        c += dc;
+    }
+    return sz;
+}
+
+static void solver_makemove(puzzle_size r, puzzle_size c, int colour,
+                            game_state *state, move **buffer_ptr)
+{
+    int const cell = idx(r, c, state->params.w);
+    if (out_of_bounds(r, c, state->params.w, state->params.h)) return;
+    if (state->grid[cell] != EMPTY) return;
+    setmember((*buffer_ptr)->square, r);
+    setmember((*buffer_ptr)->square, c);
+    setmember(**buffer_ptr, colour);
+    ++*buffer_ptr;
+    state->grid[cell] = (colour == M_BLACK ? BLACK : WHITE);
+}
+
+static move *solver_reasoning_adjacency(game_state *state,
+                                        int nclues,
+                                        const square *clues,
+                                        move *buf)
+{
+    int r, c, i;
+    for (r = 0; r < state->params.h; ++r)
+        for (c = 0; c < state->params.w; ++c) {
+            int const cell = idx(r, c, state->params.w);
+            if (state->grid[cell] != BLACK) continue;
+            for (i = 0; i < 4; ++i)
+                solver_makemove(r + dr[i], c + dc[i], M_WHITE, state, &buf);
+        }
+    return buf;
+}
+
+enum {NOT_VISITED = -1};
+
+static int dfs_biconnect_visit(puzzle_size r, puzzle_size c,
+                               game_state *state,
+                               square *dfs_parent, int *dfs_depth,
+                               move **buf);
+
+static move *solver_reasoning_connectedness(game_state *state,
+                                            int nclues,
+                                            const square *clues,
+                                            move *buf)
+{
+    int const w = state->params.w, h = state->params.h, n = w * h;
+
+    square *const dfs_parent = snewn(n, square);
+    int *const dfs_depth = snewn(n, int);
+
+    int i;
+    for (i = 0; i < n; ++i) {
+        dfs_parent[i].r = NOT_VISITED;
+        dfs_depth[i] = -n;
+    }
+
+    for (i = 0; i < n && state->grid[i] == BLACK; ++i);
+
+    dfs_parent[i].r = i / w;
+    dfs_parent[i].c = i % w; /* `dfs root`.parent == `dfs root` */
+    dfs_depth[i] = 0;
+
+    dfs_biconnect_visit(i / w, i % w, state, dfs_parent, dfs_depth, &buf);
+
+    sfree(dfs_parent);
+    sfree(dfs_depth);
+
+    return buf;
+}
+
+/* returns the `lowpoint` of (r, c) */
+static int dfs_biconnect_visit(puzzle_size r, puzzle_size c,
+                               game_state *state,
+                               square *dfs_parent, int *dfs_depth,
+                               move **buf)
+{
+    const puzzle_size w = state->params.w, h = state->params.h;
+    int const i = idx(r, c, w), mydepth = dfs_depth[i];
+    int lowpoint = mydepth, j, nchildren = 0;
+
+    for (j = 0; j < 4; ++j) {
+        const puzzle_size rr = r + dr[j], cc = c + dc[j];
+        int const cell = idx(rr, cc, w);
+
+        if (out_of_bounds(rr, cc, w, h)) continue;
+        if (state->grid[cell] == BLACK) continue;
+
+        if (dfs_parent[cell].r == NOT_VISITED) {
+            int child_lowpoint;
+            dfs_parent[cell].r = r;
+            dfs_parent[cell].c = c;
+            dfs_depth[cell] = mydepth + 1;
+            child_lowpoint = dfs_biconnect_visit(rr, cc, state, dfs_parent,
+                                                 dfs_depth, buf);
+
+            if (child_lowpoint >= mydepth && mydepth > 0)
+                solver_makemove(r, c, M_WHITE, state, buf);
+
+            lowpoint = min(lowpoint, child_lowpoint);
+            ++nchildren;
+        } else if (rr != dfs_parent[i].r || cc != dfs_parent[i].c) {
+            lowpoint = min(lowpoint, dfs_depth[cell]);
+        }
+    }
+
+    if (mydepth == 0 && nchildren >= 2)
+        solver_makemove(r, c, M_WHITE, state, buf);
+
+    return lowpoint;
+}
+
+static move *solver_reasoning_not_too_big(game_state *state,
+                                          int nclues,
+                                          const square *clues,
+                                          move *buf)
+{
+    int const w = state->params.w, runmasks[4] = {
+        ~(MASK(BLACK) | MASK(EMPTY)),
+        MASK(EMPTY),
+        ~(MASK(BLACK) | MASK(EMPTY)),
+        ~(MASK(BLACK))
+    };
+    enum {RUN_WHITE, RUN_EMPTY, RUN_BEYOND, RUN_SPACE};
+
+    int i, runlengths[4][4];
+
+    for (i = 0; i < nclues; ++i) {
+        int j, k, whites, space;
+
+        const puzzle_size row = clues[i].r, col = clues[i].c;
+        int const clue = state->grid[idx(row, col, w)];
+
+        for (j = 0; j < 4; ++j) {
+            puzzle_size r = row + dr[j], c = col + dc[j];
+            runlengths[RUN_SPACE][j] = 0;
+            for (k = 0; k <= RUN_SPACE; ++k) {
+                int l = runlength(r, c, dr[j], dc[j], state, runmasks[k]);
+                if (k < RUN_SPACE) {
+                    runlengths[k][j] = l;
+                    r += dr[j] * l;
+                    c += dc[j] * l;
+                }
+                runlengths[RUN_SPACE][j] += l;
+            }
+        }
+
+        whites = 1;
+        for (j = 0; j < 4; ++j) whites += runlengths[RUN_WHITE][j];
+
+        for (j = 0; j < 4; ++j) {
+            int const delta = 1 + runlengths[RUN_WHITE][j];
+            const puzzle_size r = row + delta * dr[j];
+            const puzzle_size c = col + delta * dc[j];
+
+            if (whites == clue) {
+                solver_makemove(r, c, M_BLACK, state, &buf);
+                continue;
+            }
+
+            if (runlengths[RUN_EMPTY][j] == 1 &&
+                whites
+                + runlengths[RUN_EMPTY][j]
+                + runlengths[RUN_BEYOND][j]
+                > clue) {
+                solver_makemove(r, c, M_BLACK, state, &buf);
+                continue;
+            }
+
+            if (whites
+                + runlengths[RUN_EMPTY][j]
+                + runlengths[RUN_BEYOND][j]
+                > clue) {
+                runlengths[RUN_SPACE][j] =
+                    runlengths[RUN_WHITE][j] +
+                    runlengths[RUN_EMPTY][j] - 1;
+
+                if (runlengths[RUN_EMPTY][j] == 1)
+                    solver_makemove(r, c, M_BLACK, state, &buf);
+            }
+        }
+
+        space = 1;
+        for (j = 0; j < 4; ++j) space += runlengths[RUN_SPACE][j];
+        for (j = 0; j < 4; ++j) {
+            puzzle_size r = row + dr[j], c = col + dc[j];
+
+            int k = space - runlengths[RUN_SPACE][j];
+            if (k >= clue) continue;
+
+            for (; k < clue; ++k, r += dr[j], c += dc[j])
+                solver_makemove(r, c, M_WHITE, state, &buf);
+        }
+    }
+    return buf;
+}
+
+static move *solver_reasoning_recursion(game_state *state,
+                                        int nclues,
+                                        const square *clues,
+                                        move *buf)
+{
+    int const w = state->params.w, n = w * state->params.h;
+    int cell, colour;
+
+    for (cell = 0; cell < n; ++cell) {
+        int const r = cell / w, c = cell % w;
+        int i;
+        game_state *newstate;
+        move *recursive_result;
+
+        if (state->grid[cell] != EMPTY) continue;
+
+        /* FIXME: add enum alias for smallest and largest (or N) */
+        for (colour = M_BLACK; colour <= M_WHITE; ++colour) {
+            newstate = dup_game(state);
+            newstate->grid[cell] = colour;
+            recursive_result = do_solve(newstate, nclues, clues, buf,
+                                        DIFF_RECURSION);
+            free_game(newstate);
+            if (recursive_result == NULL) {
+                solver_makemove(r, c, M_BLACK + M_WHITE - colour, state, &buf);
+                return buf;
+            }
+            for (i = 0; i < n && newstate->grid[i] != EMPTY; ++i);
+            if (i == n) return buf;
+        }
+    }
+    return buf;
+}
+
+static square *find_clues(const game_state *state, int *ret_nclues)
+{
+    int r, c, i, nclues = 0;
+    square *ret = snewn(state->params.w * state->params.h, struct square);
+
+    for (i = r = 0; r < state->params.h; ++r)
+        for (c = 0; c < state->params.w; ++c, ++i)
+            if (state->grid[i] > 0) {
+                ret[nclues].r = r;
+                ret[nclues].c = c;
+                ++nclues;
+            }
+
+    *ret_nclues = nclues;
+    return sresize(ret, nclues + (nclues == 0), square);
+}
+
+/* ----------------------------------------------------------------------
+ * Puzzle generation
+ *
+ * Generating kurodoko instances is rather straightforward:
+ *
+ *  - Start with a white grid and add black squares at randomly chosen
+ *    locations, unless colouring that square black would violate
+ *    either the adjacency or connectedness constraints.
+ *
+ *  - For each white square, compute the number it would contain if it
+ *    were given as a clue.
+ *
+ *  - From a starting point of "give _every_ white square as a clue",
+ *    for each white square (in a random order), see if the board is
+ *    solvable when that square is not given as a clue.  If not, don't
+ *    give it as a clue, otherwise do.
+ *
+ * This never fails, but it's only _almost_ what I do.  The real final
+ * step is this:
+ *
+ *  - From a starting point of "give _every_ white square as a clue",
+ *    first remove all clues that are two-way rotationally symmetric
+ *    to a black square.  If this leaves the puzzle unsolvable, throw
+ *    it out and try again.  Otherwise, remove all _pairs_ of clues
+ *    (that are rotationally symmetric) which can be removed without
+ *    rendering the puzzle unsolvable.
+ *
+ * This can fail even if one only removes the black and symmetric
+ * clues; indeed it happens often (avg. once or twice per puzzle) when
+ * generating 1xN instances.  (If you add black cells they must be in
+ * the end, and if you only add one, it's ambiguous where).
+ */
+
+/* forward declarations of internal calls */
+static void newdesc_choose_black_squares(game_state *state,
+                                         const int *shuffle_1toN);
+static void newdesc_compute_clues(game_state *state);
+static int newdesc_strip_clues(game_state *state, int *shuffle_1toN);
+static char *newdesc_encode_game_description(int n, puzzle_size *grid);
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int const w = params->w, h = params->h, n = w * h;
+
+    puzzle_size *const grid = snewn(n, puzzle_size);
+    int *const shuffle_1toN = snewn(n, int);
+
+    int i, clues_removed;
+
+    char *encoding;
+
+    game_state state;
+    state.params = *params;
+    state.grid = grid;
+
+    interactive = 0; /* I don't need it, I shouldn't use it*/
+
+    for (i = 0; i < n; ++i) shuffle_1toN[i] = i;
+
+    while (TRUE) {
+        shuffle(shuffle_1toN, n, sizeof (int), rs);
+        newdesc_choose_black_squares(&state, shuffle_1toN);
+
+        newdesc_compute_clues(&state);
+
+        shuffle(shuffle_1toN, n, sizeof (int), rs);
+        clues_removed = newdesc_strip_clues(&state, shuffle_1toN);
+
+        if (clues_removed < 0) continue; else break;
+    }
+
+    encoding = newdesc_encode_game_description(n, grid);
+
+    sfree(grid);
+    sfree(shuffle_1toN);
+
+    return encoding;
+}
+
+static int dfs_count_white(game_state *state, int cell);
+
+static void newdesc_choose_black_squares(game_state *state,
+                                         const int *shuffle_1toN)
+{
+    int const w = state->params.w, h = state->params.h, n = w * h;
+
+    int k, any_white_cell, n_black_cells;
+
+    for (k = 0; k < n; ++k) state->grid[k] = WHITE;
+
+    any_white_cell = shuffle_1toN[n - 1];
+    n_black_cells = 0;
+
+    /* I like the puzzles that result from n / 3, but maybe this
+     * could be made a (generation, i.e. non-full) parameter? */
+    for (k = 0; k < n / 3; ++k) {
+        int const i = shuffle_1toN[k], c = i % w, r = i / w;
+
+        int j;
+        for (j = 0; j < 4; ++j) {
+            int const rr = r + dr[j], cc = c + dc[j], cell = idx(rr, cc, w);
+            /* if you're out of bounds, we skip you */
+            if (out_of_bounds(rr, cc, w, h)) continue;
+            if (state->grid[cell] == BLACK) break; /* I can't be black */
+        } if (j < 4) continue; /* I have black neighbour: I'm white */
+
+        state->grid[i] = BLACK;
+        ++n_black_cells;
+
+        j = dfs_count_white(state, any_white_cell);
+        if (j + n_black_cells < n) {
+            state->grid[i] = WHITE;
+            --n_black_cells;
+        }
+    }
+}
+
+static void newdesc_compute_clues(game_state *state)
+{
+    int const w = state->params.w, h = state->params.h;
+    int r, c;
+
+    for (r = 0; r < h; ++r) {
+        int run_size = 0, c, cc;
+        for (c = 0; c <= w; ++c) {
+            if (c == w || state->grid[idx(r, c, w)] == BLACK) {
+                for (cc = c - run_size; cc < c; ++cc)
+                    state->grid[idx(r, cc, w)] += run_size;
+                run_size = 0;
+            } else ++run_size;
+        }
+    }
+
+    for (c = 0; c < w; ++c) {
+        int run_size = 0, r, rr;
+        for (r = 0; r <= h; ++r) {
+            if (r == h || state->grid[idx(r, c, w)] == BLACK) {
+                for (rr = r - run_size; rr < r; ++rr)
+                    state->grid[idx(rr, c, w)] += run_size;
+                run_size = 0;
+            } else ++run_size;
+        }
+    }
+}
+
+#define rotate(x) (n - 1 - (x))
+
+static int newdesc_strip_clues(game_state *state, int *shuffle_1toN)
+{
+    int const w = state->params.w, n = w * state->params.h;
+
+    move *const move_buffer = snewn(n, move);
+    move *buf;
+    game_state *dupstate;
+
+    /*
+     * do a partition/pivot of shuffle_1toN into three groups:
+     * (1) squares rotationally-symmetric to (3)
+     * (2) squares not in (1) or (3)
+     * (3) black squares
+     *
+     * They go from [0, left), [left, right) and [right, n) in
+     * shuffle_1toN (and from there into state->grid[ ])
+     *
+     * Then, remove clues from the grid one by one in shuffle_1toN
+     * order, until the solver becomes unhappy.  If we didn't remove
+     * all of (1), return (-1).  Else, we're happy.
+     */
+
+    /* do the partition */
+    int clues_removed, k = 0, left = 0, right = n;
+
+    for (;; ++k) {
+        while (k < right && state->grid[shuffle_1toN[k]] == BLACK) {
+            --right;
+            SWAP(int, shuffle_1toN[right], shuffle_1toN[k]);
+            assert(state->grid[shuffle_1toN[right]] == BLACK);
+        }
+        if (k >= right) break;
+        assert (k >= left);
+        if (state->grid[rotate(shuffle_1toN[k])] == BLACK) {
+            SWAP(int, shuffle_1toN[k], shuffle_1toN[left]);
+            ++left;
+        }
+        assert (state->grid[rotate(shuffle_1toN[k])] != BLACK
+                || k == left - 1);
+    }
+
+    for (k = 0; k < left; ++k) {
+        assert (state->grid[rotate(shuffle_1toN[k])] == BLACK);
+        state->grid[shuffle_1toN[k]] = EMPTY;
+    }
+    for (k = left; k < right; ++k) {
+        assert (state->grid[rotate(shuffle_1toN[k])] != BLACK);
+        assert (state->grid[shuffle_1toN[k]] != BLACK);
+    }
+    for (k = right; k < n; ++k) {
+        assert (state->grid[shuffle_1toN[k]] == BLACK);
+        state->grid[shuffle_1toN[k]] = EMPTY;
+    }
+
+    clues_removed = (left - 0) + (n - right);
+
+    dupstate = dup_game(state);
+    buf = solve_internal(dupstate, move_buffer, DIFF_RECURSION - 1);
+    free_game(dupstate);
+    if (buf - move_buffer < clues_removed) {
+        /* branch prediction: I don't think I'll go here */
+        clues_removed = -1;
+        goto ret;
+    }
+
+    for (k = left; k < right; ++k) {
+        const int i = shuffle_1toN[k], j = rotate(i);
+        int const clue = state->grid[i], clue_rot = state->grid[j];
+        if (clue == BLACK) continue;
+        state->grid[i] = state->grid[j] = EMPTY;
+        dupstate = dup_game(state);
+        buf = solve_internal(dupstate, move_buffer, DIFF_RECURSION - 1);
+        free_game(dupstate);
+        clues_removed += 2 - (i == j);
+        /* if i is the center square, then i == (j = rotate(i))
+         * when i and j are one, removing i and j removes only one */
+        if (buf - move_buffer == clues_removed) continue;
+        /* if the solver is sound, refilling all removed clues means
+         * we have filled all squares, i.e. solved the puzzle. */
+        state->grid[i] = clue;
+        state->grid[j] = clue_rot;
+        clues_removed -= 2 - (i == j);
+    }
+    
+ret:
+    sfree(move_buffer);
+    return clues_removed;
+}
+
+static int dfs_count_rec(puzzle_size *grid, int r, int c, int w, int h)
+{
+    int const cell = idx(r, c, w);
+    if (out_of_bounds(r, c, w, h)) return 0;
+    if (grid[cell] != WHITE) return 0;
+    grid[cell] = EMPTY;
+    return 1 +
+        dfs_count_rec(grid, r + 0, c + 1, w, h) +
+        dfs_count_rec(grid, r + 0, c - 1, w, h) +
+        dfs_count_rec(grid, r + 1, c + 0, w, h) +
+        dfs_count_rec(grid, r - 1, c + 0, w, h);
+}
+
+static int dfs_count_white(game_state *state, int cell)
+{
+    int const w = state->params.w, h = state->params.h, n = w * h;
+    int const r = cell / w, c = cell % w;
+    int i, k = dfs_count_rec(state->grid, r, c, w, h);
+    for (i = 0; i < n; ++i)
+        if (state->grid[i] == EMPTY)
+            state->grid[i] = WHITE;
+    return k;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    int const w = params->w, h = params->h;
+    if (w < 1) return "Error: width is less than 1";
+    if (h < 1) return "Error: height is less than 1";
+    if (w * h < 1) return "Error: size is less than 1";
+    if (w + h - 1 > SCHAR_MAX) return "Error: w + h is too big";
+    /* I might be unable to store clues in my puzzle_size *grid; */
+    if (full) {
+        if (w == 2 && h == 2) return "Error: can't create 2x2 puzzles";
+        if (w == 1 && h == 2) return "Error: can't create 1x2 puzzles";
+        if (w == 2 && h == 1) return "Error: can't create 2x1 puzzles";
+        if (w == 1 && h == 1) return "Error: can't create 1x1 puzzles";
+    }
+    return NULL;
+}
+
+/* Definition: a puzzle instance is _good_ if:
+ *  - it has a unique solution
+ *  - the solver can find this solution without using recursion
+ *  - the solution contains at least one black square
+ *  - the clues are 2-way rotationally symmetric
+ *
+ * (the idea being: the generator can not output any _bad_ puzzles)
+ *
+ * Theorem: validate_params, when full != 0, discards exactly the set
+ * of parameters for which there are _no_ good puzzle instances.
+ *
+ * Proof: it's an immediate consequence of the five lemmas below.
+ *
+ * Observation: not only do puzzles on non-tiny grids exist, the
+ * generator is pretty fast about coming up with them.  On my pre-2004
+ * desktop box, it generates 100 puzzles on the highest preset (16x11)
+ * in 8.383 seconds, or <= 0.1 second per puzzle.
+ *
+ * ----------------------------------------------------------------------
+ *
+ * Lemma: On a 1x1 grid, there are no good puzzles.
+ *
+ * Proof: the one square can't be a clue because at least one square
+ * is black.  But both a white square and a black square satisfy the
+ * solution criteria, so the puzzle is ambiguous (and hence bad).
+ *
+ * Lemma: On a 1x2 grid, there are no good puzzles.
+ *
+ * Proof: let's name the squares l and r.  Note that there can be at
+ * most one black square, or adjacency is violated.  By assumption at
+ * least one square is black, so let's call that one l.  By clue
+ * symmetry, neither l nor r can be given as a clue, so the puzzle
+ * instance is blank and thus ambiguous.
+ *
+ * Corollary: On a 2x1 grid, there are no good puzzles.
+ * Proof: rotate the above proof 90 degrees ;-)
+ *
+ * ----------------------------------------------------------------------
+ *
+ * Lemma: On a 2x2 grid, there are no soluble puzzles with 2-way
+ * rotational symmetric clues and at least one black square.
+ *
+ * Proof: Let's name the squares a, b, c, and d, with a and b on the
+ * top row, a and c in the left column.  Let's consider the case where
+ * a is black.  Then no other square can be black: b and c would both
+ * violate the adjacency constraint; d would disconnect b from c.
+ *
+ * So exactly one square is black (and by 4-way rotation symmetry of
+ * the 2x2 square, it doesn't matter which one, so let's stick to a).
+ * By 2-way rotational symmetry of the clues and the rule about not
+ * painting numbers black, neither a nor d can be clues.  A blank
+ * puzzle would be ambiguous, so one of {b, c} is a clue; by symmetry,
+ * so is the other one.
+ *
+ * It is readily seen that their clue value is 2.  But "a is black"
+ * and "d is black" are both valid solutions in this case, so the
+ * puzzle is ambiguous (and hence bad).
+ *
+ * ----------------------------------------------------------------------
+ *
+ * Lemma: On a wxh grid with w, h >= 1 and (w > 2 or h > 2), there is
+ * at least one good puzzle.
+ *
+ * Proof: assume that w > h (otherwise rotate the proof again).  Paint
+ * the top left and bottom right corners black, and fill a clue into
+ * all the other squares.  Present this board to the solver code (or
+ * player, hypothetically), except with the two black squares as blank
+ * squares.
+ *
+ * For an Nx1 puzzle, observe that every clue is N - 2, and there are
+ * N - 2 of them in one connected sequence, so the remaining two
+ * squares can be deduced to be black, which solves the puzzle.
+ *
+ * For any other puzzle, let j be a cell in the same row as a black
+ * cell, but not in the same column (such a cell doesn't exist in 2x3
+ * puzzles, but we assume w > h and such cells exist in 3x2 puzzles).
+ *
+ * Note that the number of cells in axis parallel `rays' going out
+ * from j exceeds j's clue value by one.  Only one such cell is a
+ * non-clue, so it must be black.  Similarly for the other corner (let
+ * j' be a cell in the same row as the _other_ black cell, but not in
+ * the same column as _any_ black cell; repeat this argument at j').
+ *
+ * This fills the grid and satisfies all clues and the adjacency
+ * constraint and doesn't paint on top of any clues.  All that is left
+ * to see is connectedness.
+ *
+ * Observe that the white cells in each column form a single connected
+ * `run', and each column contains a white cell adjacent to a white
+ * cell in the column to the right, if that column exists.
+ *
+ * Thus, any cell in the left-most column can reach any other cell:
+ * first go to the target column (by repeatedly going to the cell in
+ * your current column that lets you go right, then going right), then
+ * go up or down to the desired cell.
+ *
+ * As reachability is symmetric (in undirected graphs) and transitive,
+ * any cell can reach any left-column cell, and from there any other
+ * cell.
+ */
+
+/* ----------------------------------------------------------------------
+ * Game encoding and decoding
+ */
+
+#define NDIGITS_BASE '!'
+
+static char *newdesc_encode_game_description(int area, puzzle_size *grid)
+{
+    char *desc = NULL;
+    int desclen = 0, descsize = 0;
+    int run, i;
+
+    run = 0;
+    for (i = 0; i <= area; i++) {
+        int n = (i < area ? grid[i] : -1);
+
+        if (!n)
+            run++;
+        else {
+            if (descsize < desclen + 40) {
+                descsize = desclen * 3 / 2 + 40;
+                desc = sresize(desc, descsize, char);
+            }
+            if (run) {
+                while (run > 0) {
+                    int c = 'a' - 1 + run;
+                    if (run > 26)
+                        c = 'z';
+                    desc[desclen++] = c;
+                    run -= c - ('a' - 1);
+                }
+            } else {
+                /*
+                 * If there's a number in the very top left or
+                 * bottom right, there's no point putting an
+                 * unnecessary _ before or after it.
+                 */
+                if (desclen > 0 && n > 0)
+                    desc[desclen++] = '_';
+            }
+            if (n > 0)
+                desclen += sprintf(desc+desclen, "%d", n);
+            run = 0;
+        }
+    }
+    desc[desclen] = '\0';
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int const n = params->w * params->h;
+    int squares = 0;
+    int range = params->w + params->h - 1;   /* maximum cell value */
+
+    while (*desc && *desc != ',') {
+        int c = *desc++;
+        if (c >= 'a' && c <= 'z') {
+            squares += c - 'a' + 1;
+        } else if (c == '_') {
+            /* do nothing */;
+        } else if (c > '0' && c <= '9') {
+            int val = atoi(desc-1);
+            if (val < 1 || val > range)
+                return "Out-of-range number in game description";
+            squares++;
+            while (*desc >= '0' && *desc <= '9')
+                desc++;
+        } else
+            return "Invalid character in game description";
+    }
+
+    if (squares < n)
+        return "Not enough data to fill grid";
+
+    if (squares > n)
+        return "Too much data to fit in grid";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int i;
+    const char *p;
+
+    int const n = params->w * params->h;
+    game_state *state = snew(game_state);
+
+    me = NULL; /* I don't need it, I shouldn't use it */
+
+    state->params = *params; /* structure copy */
+    state->grid = snewn(n, puzzle_size);
+
+    p = desc;
+    i = 0;
+    while (i < n && *p) {
+        int c = *p++;
+        if (c >= 'a' && c <= 'z') {
+            int squares = c - 'a' + 1;
+            while (squares--)
+                state->grid[i++] = 0;
+        } else if (c == '_') {
+            /* do nothing */;
+        } else if (c > '0' && c <= '9') {
+            int val = atoi(p-1);
+            assert(val >= 1 && val <= params->w+params->h-1);
+            state->grid[i++] = val;
+            while (*p >= '0' && *p <= '9')
+                p++;
+        }
+    }
+    assert(i == n);
+    state->has_cheated = FALSE;
+    state->was_solved = FALSE;
+
+    return state;
+}
+
+/* ----------------------------------------------------------------------
+ * User interface: ascii
+ */
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int cellsize, r, c, i, w_string, h_string, n_string;
+    char *ret, *buf, *gridline;
+
+    int const w = state->params.w, h = state->params.h;
+
+    cellsize = 0; /* or may be used uninitialized */
+
+    for (c = 0; c < w; ++c) {
+        for (r = 0; r < h; ++r) {
+            puzzle_size k = state->grid[idx(r, c, w)];
+            int d;
+            for (d = 0; k; k /= 10, ++d);
+            cellsize = max(cellsize, d);
+        }
+    }
+
+    ++cellsize;
+
+    w_string = w * cellsize + 2; /* "|%d|%d|...|\n" */
+    h_string = 2 * h + 1; /* "+--+--+...+\n%s\n+--+--+...+\n" */
+    n_string = w_string * h_string;
+
+    gridline = snewn(w_string + 1, char); /* +1: NUL terminator */
+    memset(gridline, '-', w_string);
+    for (c = 0; c <= w; ++c) gridline[c * cellsize] = '+';
+    gridline[w_string - 1] = '\n';
+    gridline[w_string - 0] = '\0';
+
+    buf = ret = snewn(n_string + 1, char); /* +1: NUL terminator */
+    for (i = r = 0; r < h; ++r) {
+        memcpy(buf, gridline, w_string);
+        buf += w_string;
+        for (c = 0; c < w; ++c, ++i) {
+            char ch;
+            switch (state->grid[i]) {
+              case BLACK: ch = '#'; break;
+              case WHITE: ch = '.'; break;
+              case EMPTY: ch = ' '; break;
+              default:
+                buf += sprintf(buf, "|%*d", cellsize - 1, state->grid[i]);
+                continue;
+            }
+            *buf++ = '|';
+            memset(buf, ch, cellsize - 1);
+            buf += cellsize - 1;
+        }
+        buf += sprintf(buf, "|\n");
+    }
+    memcpy(buf, gridline, w_string);
+    buf += w_string;
+    assert (buf - ret == n_string);
+    *buf = '\0';
+
+    sfree(gridline);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * User interfaces: interactive
+ */
+
+struct game_ui {
+    puzzle_size r, c; /* cursor position */
+    unsigned int cursor_show: 1;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    struct game_ui *ui = snew(game_ui);
+    ui->r = ui->c = 0;
+    ui->cursor_show = FALSE;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+typedef struct drawcell {
+    puzzle_size value;
+    unsigned int error: 1;
+    unsigned int cursor: 1;
+    unsigned int flash: 1;
+} drawcell;
+
+struct game_drawstate {
+    int tilesize;
+    drawcell *grid;
+    unsigned int started: 1;
+};
+
+#define TILESIZE (ds->tilesize)
+#define BORDER (TILESIZE / 2)
+#define COORD(x) ((x) * TILESIZE + BORDER)
+#define FROMCOORD(x) (((x) - BORDER) / TILESIZE)
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    enum {none, forwards, backwards, hint};
+    int const w = state->params.w, h = state->params.h;
+    int r = ui->r, c = ui->c, action = none, cell;
+    int shift = button & MOD_SHFT;
+    button &= ~shift;
+
+    if (IS_CURSOR_SELECT(button) && !ui->cursor_show) return NULL;
+
+    if (IS_MOUSE_DOWN(button)) {
+        r = FROMCOORD(y + TILESIZE) - 1; /* or (x, y) < TILESIZE) */
+        c = FROMCOORD(x + TILESIZE) - 1; /* are considered inside */
+        if (out_of_bounds(r, c, w, h)) return NULL;
+        ui->r = r;
+        ui->c = c;
+        ui->cursor_show = FALSE;
+    }
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        /*
+         * Utterly awful hack, exactly analogous to the one in Slant,
+         * to configure the left and right mouse buttons the opposite
+         * way round.
+         *
+         * The original puzzle submitter thought it would be more
+         * useful to have the left button turn an empty square into a
+         * dotted one, on the grounds that that was what you did most
+         * often; I (SGT) felt instinctively that the left button
+         * ought to place black squares and the right button place
+         * dots, on the grounds that that was consistent with many
+         * other puzzles in which the left button fills in the data
+         * used by the solution checker while the right button places
+         * pencil marks for the user's convenience.
+         *
+         * My first beta-player wasn't sure either, so I thought I'd
+         * pre-emptively put in a 'configuration' mechanism just in
+         * case.
+         */
+        {
+            static int swap_buttons = -1;
+            if (swap_buttons < 0) {
+                char *env = getenv("RANGE_SWAP_BUTTONS");
+                swap_buttons = (env && (env[0] == 'y' || env[0] == 'Y'));
+            }
+            if (swap_buttons) {
+                if (button == LEFT_BUTTON)
+                    button = RIGHT_BUTTON;
+                else
+                    button = LEFT_BUTTON;
+            }
+        }
+    }
+
+    switch (button) {
+      case CURSOR_SELECT : case   LEFT_BUTTON: action = backwards; break;
+      case CURSOR_SELECT2: case  RIGHT_BUTTON: action =  forwards; break;
+      case 'h': case 'H' :                     action =      hint; break;
+      case CURSOR_UP: case CURSOR_DOWN:
+      case CURSOR_LEFT: case CURSOR_RIGHT:
+        if (ui->cursor_show) {
+            int i;
+            for (i = 0; i < 4 && cursors[i] != button; ++i);
+            assert (i < 4);
+            if (shift) {
+                int pre_r = r, pre_c = c, do_pre, do_post;
+                cell = state->grid[idx(r, c, state->params.w)];
+                do_pre = (cell == EMPTY);
+
+                if (out_of_bounds(ui->r + dr[i], ui->c + dc[i], w, h)) {
+                    if (do_pre)
+                        return nfmtstr(40, "W,%d,%d", pre_r, pre_c);
+                    else
+                        return NULL;
+                }
+
+                ui->r += dr[i];
+                ui->c += dc[i];
+
+                cell = state->grid[idx(ui->r, ui->c, state->params.w)];
+                do_post = (cell == EMPTY);
+
+                /* (do_pre ? "..." : "") concat (do_post ? "..." : "") */
+                if (do_pre && do_post)
+                    return nfmtstr(80, "W,%d,%dW,%d,%d",
+                                   pre_r, pre_c, ui->r, ui->c);
+                else if (do_pre)
+                    return nfmtstr(40, "W,%d,%d", pre_r, pre_c);
+                else if (do_post)
+                    return nfmtstr(40, "W,%d,%d", ui->r, ui->c);
+                else
+                    return "";
+
+            } else if (!out_of_bounds(ui->r + dr[i], ui->c + dc[i], w, h)) {
+                ui->r += dr[i];
+                ui->c += dc[i];
+            }
+        } else ui->cursor_show = TRUE;
+        return "";
+    }
+
+    if (action == hint) {
+        move *end, *buf = snewn(state->params.w * state->params.h,
+                                struct move);
+        char *ret = NULL;
+        end = solve_internal(state, buf, DIFF_RECURSION);
+        if (end != NULL && end > buf) {
+            ret = nfmtstr(40, "%c,%d,%d",
+                          buf->colour == M_BLACK ? 'B' : 'W',
+                          buf->square.r, buf->square.c);
+            /* We used to set a flag here in the game_ui indicating
+             * that the player had used the hint function. I (SGT)
+             * retired it, on grounds of consistency with other games
+             * (most of these games will still flash to indicate
+             * completion if you solved and undid it, so why not if
+             * you got a hint?) and because the flash is as much about
+             * checking you got it all right than about congratulating
+             * you on a job well done. */
+        }
+        sfree(buf);
+        return ret;
+    }
+
+    cell = state->grid[idx(r, c, state->params.w)];
+    if (cell > 0) return NULL;
+
+    if (action == forwards) switch (cell) {
+      case EMPTY: return nfmtstr(40, "W,%d,%d", r, c);
+      case WHITE: return nfmtstr(40, "B,%d,%d", r, c);
+      case BLACK: return nfmtstr(40, "E,%d,%d", r, c);
+    }
+
+    else if (action == backwards) switch (cell) {
+      case BLACK: return nfmtstr(40, "W,%d,%d", r, c);
+      case WHITE: return nfmtstr(40, "E,%d,%d", r, c);
+      case EMPTY: return nfmtstr(40, "B,%d,%d", r, c);
+    }
+
+    return NULL;
+}
+
+static int find_errors(const game_state *state, int *report)
+{
+    int const w = state->params.w, h = state->params.h, n = w * h;
+    int *dsf;
+
+    int r, c, i;
+
+    int nblack = 0, any_white_cell = -1;
+    game_state *dup = dup_game(state);
+
+    for (i = r = 0; r < h; ++r)
+        for (c = 0; c < w; ++c, ++i) {
+            switch (state->grid[i]) {
+
+              case BLACK:
+                {
+                    int j;
+                    ++nblack;
+                    for (j = 0; j < 4; ++j) {
+                        int const rr = r + dr[j], cc = c + dc[j];
+                        if (out_of_bounds(rr, cc, w, h)) continue;
+                        if (state->grid[idx(rr, cc, w)] != BLACK) continue;
+                        if (!report) goto found_error;
+                        report[i] = TRUE;
+                        break;
+                    }
+                }
+                break;
+              default:
+                {
+                    int j, runs;
+                    for (runs = 1, j = 0; j < 4; ++j) {
+                        int const rr = r + dr[j], cc = c + dc[j];
+                        runs += runlength(rr, cc, dr[j], dc[j], state,
+                                          ~MASK(BLACK));
+                    }
+                    if (!report) {
+                        if (runs != state->grid[i]) goto found_error;
+                    } else if (runs < state->grid[i]) report[i] = TRUE;
+                    else {
+                        for (runs = 1, j = 0; j < 4; ++j) {
+                            int const rr = r + dr[j], cc = c + dc[j];
+                            runs += runlength(rr, cc, dr[j], dc[j], state,
+                                              ~(MASK(BLACK) | MASK(EMPTY)));
+                        }
+                        if (runs > state->grid[i]) report[i] = TRUE;
+                    }
+                }
+
+                /* note: fallthrough _into_ these cases */
+              case EMPTY:
+              case WHITE: any_white_cell = i;
+            }
+        }
+
+    /*
+     * Check that all the white cells form a single connected component.
+     */
+    dsf = snew_dsf(n);
+    for (r = 0; r < h-1; ++r)
+        for (c = 0; c < w; ++c)
+            if (state->grid[r*w+c] != BLACK &&
+                state->grid[(r+1)*w+c] != BLACK)
+                dsf_merge(dsf, r*w+c, (r+1)*w+c);
+    for (r = 0; r < h; ++r)
+        for (c = 0; c < w-1; ++c)
+            if (state->grid[r*w+c] != BLACK &&
+                state->grid[r*w+(c+1)] != BLACK)
+                dsf_merge(dsf, r*w+c, r*w+(c+1));
+    if (nblack + dsf_size(dsf, any_white_cell) < n) {
+        int biggest, canonical;
+
+        if (!report) {
+            sfree(dsf);
+            goto found_error;
+        }
+
+        /*
+         * Report this error by choosing one component to be the
+         * canonical one (we pick the largest, arbitrarily
+         * tie-breaking towards lower array indices) and highlighting
+         * as an error any square in a different component.
+         */
+        canonical = -1;
+        biggest = 0;
+        for (i = 0; i < n; ++i)
+            if (state->grid[i] != BLACK) {
+                int size = dsf_size(dsf, i);
+                if (size > biggest) {
+                    biggest = size;
+                    canonical = dsf_canonify(dsf, i);
+                }
+            }
+
+        for (i = 0; i < n; ++i)
+            if (state->grid[i] != BLACK && dsf_canonify(dsf, i) != canonical)
+                report[i] = TRUE;
+    }
+    sfree(dsf);
+
+    free_game(dup);
+    return FALSE; /* if report != NULL, this is ignored */
+
+found_error:
+    free_game(dup);
+    return TRUE;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    signed int r, c, value, nchars, ntok;
+    signed char what_to_do;
+    game_state *ret;
+
+    assert (move);
+
+    ret = dup_game(state);
+
+    if (*move == 'S') {
+        ++move;
+        ret->has_cheated = ret->was_solved = TRUE;
+    }
+
+    for (; *move; move += nchars) {
+        ntok = sscanf(move, "%c,%d,%d%n", &what_to_do, &r, &c, &nchars);
+        if (ntok < 3) goto failure;
+        switch (what_to_do) {
+          case 'W': value = WHITE; break;
+          case 'E': value = EMPTY; break;
+          case 'B': value = BLACK; break;
+          default: goto failure;
+        }
+        if (out_of_bounds(r, c, ret->params.w, ret->params.h)) goto failure;
+        ret->grid[idx(r, c, ret->params.w)] = value;
+    }
+
+    if (ret->was_solved == FALSE)
+        ret->was_solved = !find_errors(ret, NULL);
+
+    return ret;
+
+failure:
+    free_game(ret);
+    return NULL;
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+#define FLASH_TIME 0.7F
+
+static float game_flash_length(const game_state *from,
+                               const game_state *to, int dir, game_ui *ui)
+{
+    if (!from->was_solved && to->was_solved && !to->has_cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->was_solved ? +1 : 0;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define PREFERRED_TILE_SIZE 32
+
+enum {
+    COL_BACKGROUND = 0,
+    COL_GRID,
+    COL_BLACK = COL_GRID,
+    COL_TEXT = COL_GRID,
+    COL_USER = COL_GRID,
+    COL_ERROR,
+    COL_LOWLIGHT,
+    COL_HIGHLIGHT = COL_ERROR, /* mkhighlight needs it, I don't */
+    COL_CURSOR = COL_LOWLIGHT,
+    NCOLOURS
+};
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    *x = (1 + params->w) * tilesize;
+    *y = (1 + params->h) * tilesize;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+#define COLOUR(ret, i, r, g, b) \
+   ((ret[3*(i)+0] = (r)), (ret[3*(i)+1] = (g)), (ret[3*(i)+2] = (b)))
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+    COLOUR(ret, COL_GRID,  0.0F, 0.0F, 0.0F);
+    COLOUR(ret, COL_ERROR, 1.0F, 0.0F, 0.0F);
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static drawcell makecell(puzzle_size value, int error, int cursor, int flash)
+{
+    drawcell ret;
+    setmember(ret, value);
+    setmember(ret, error);
+    setmember(ret, cursor);
+    setmember(ret, flash);
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int const w = state->params.w, h = state->params.h, n = w * h;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = 0;
+    ds->started = FALSE;
+
+    ds->grid = snewn(n, drawcell);
+    for (i = 0; i < n; ++i)
+        ds->grid[i] = makecell(w + h, FALSE, FALSE, FALSE);
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+#define cmpmember(a, b, field) ((a) . field == (b) . field)
+
+static int cell_eq(drawcell a, drawcell b)
+{
+    return
+        cmpmember(a, b, value) &&
+        cmpmember(a, b, error) &&
+        cmpmember(a, b, cursor) &&
+        cmpmember(a, b, flash);
+}
+
+static void draw_cell(drawing *dr, game_drawstate *ds, int r, int c,
+                      drawcell cell);
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int const w = state->params.w, h = state->params.h, n = w * h;
+    int const wpx = (w+1) * ds->tilesize, hpx = (h+1) * ds->tilesize;
+    int const flash = ((int) (flashtime * 5 / FLASH_TIME)) % 2;
+
+    int r, c, i;
+
+    int *errors = snewn(n, int);
+    memset(errors, FALSE, n * sizeof (int));
+    find_errors(state, errors);
+
+    assert (oldstate == NULL); /* only happens if animating moves */
+
+    if (!ds->started) {
+        ds->started = TRUE;
+        draw_rect(dr, 0, 0, wpx, hpx, COL_BACKGROUND);
+        draw_update(dr, 0, 0, wpx, hpx);
+    }
+
+    for (i = r = 0; r < h; ++r) {
+        for (c = 0; c < w; ++c, ++i) {
+            drawcell cell = makecell(state->grid[i], errors[i], FALSE, flash);
+            if (r == ui->r && c == ui->c && ui->cursor_show)
+                cell.cursor = TRUE;
+            if (!cell_eq(cell, ds->grid[i])) {
+                draw_cell(dr, ds, r, c, cell);
+                ds->grid[i] = cell;
+            }
+        }
+    }
+
+    sfree(errors);
+}
+
+static void draw_cell(drawing *draw, game_drawstate *ds, int r, int c,
+                      drawcell cell)
+{
+    int const ts = ds->tilesize;
+    int const y = BORDER + ts * r, x = BORDER + ts * c;
+    int const tx = x + (ts / 2), ty = y + (ts / 2);
+    int const dotsz = (ds->tilesize + 9) / 10;
+
+    int const colour = (cell.value == BLACK ?
+                        cell.error ? COL_ERROR : COL_BLACK :
+                        cell.flash || cell.cursor ?
+                        COL_LOWLIGHT : COL_BACKGROUND);
+
+    draw_rect_outline(draw, x,     y,     ts + 1, ts + 1, COL_GRID);
+    draw_rect        (draw, x + 1, y + 1, ts - 1, ts - 1, colour);
+    if (cell.error)
+        draw_rect_outline(draw, x + 1, y + 1, ts - 1, ts - 1, COL_ERROR);
+
+    switch (cell.value) {
+      case WHITE: draw_rect(draw, tx - dotsz / 2, ty - dotsz / 2, dotsz, dotsz,
+                            cell.error ? COL_ERROR : COL_USER);
+      case BLACK: case EMPTY: break;
+      default:
+        {
+            int const colour = (cell.error ? COL_ERROR : COL_GRID);
+            char *msg = nfmtstr(10, "%d", cell.value);
+            draw_text(draw, tx, ty, FONT_VARIABLE, ts * 3 / 5,
+                      ALIGN_VCENTRE | ALIGN_HCENTRE, colour, msg);
+            sfree(msg);
+        }
+    }
+
+    draw_update(draw, x, y, ts + 1, ts + 1);
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    puts("warning: game_timing_state was called (this shouldn't happen)");
+    return FALSE; /* the (non-existing) timer should not be running */
+}
+
+/* ----------------------------------------------------------------------
+ * User interface: print
+ */
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int print_width, print_height;
+    game_compute_size(params, 800, &print_width, &print_height);
+    *x = print_width  / 100.0F;
+    *y = print_height / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int const w = state->params.w, h = state->params.h;
+    game_drawstate ds_obj, *ds = &ds_obj;
+    int r, c, i, colour;
+
+    ds->tilesize = tilesize;
+
+    colour = print_mono_colour(dr, 1); assert(colour == COL_BACKGROUND);
+    colour = print_mono_colour(dr, 0); assert(colour == COL_GRID);
+    colour = print_mono_colour(dr, 1); assert(colour == COL_ERROR);
+    colour = print_mono_colour(dr, 0); assert(colour == COL_LOWLIGHT);
+    colour = print_mono_colour(dr, 0); assert(colour == NCOLOURS);
+
+    for (i = r = 0; r < h; ++r)
+        for (c = 0; c < w; ++c, ++i)
+            draw_cell(dr, ds, r, c,
+                      makecell(state->grid[i], FALSE, FALSE, FALSE));
+
+    print_line_width(dr, 3 * tilesize / 40);
+    draw_rect_outline(dr, BORDER, BORDER, w*TILESIZE, h*TILESIZE, COL_GRID);
+}
+
+/* And that's about it ;-) **************************************************/
+
+#ifdef COMBINED
+#define thegame range
+#endif
+
+struct game const thegame = {
+    "Range", "games.range", "range",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE, /* wants_statusbar */
+    FALSE, game_timing_state,
+    0, /* flags */
+};
diff --git a/apps/plugins/puzzles/rbassert.h b/apps/plugins/puzzles/rbassert.h
new file mode 100644
index 0000000000..f3fef84351
--- /dev/null
+++ b/apps/plugins/puzzles/rbassert.h
@@ -0,0 +1,13 @@
+/*
+  copied from firmware/assert.h
+*/
+
+#undef assert
+
+#ifdef NDEBUG           /* required by ANSI standard */
+#define assert(p)       ((void)0)
+#else
+
+#define assert(e)       ((e) ? (void)0 : fatal("assertion failed %s:%d", __FILE__, __LINE__))
+
+#endif /* NDEBUG */
diff --git a/apps/plugins/puzzles/rbcompat.h b/apps/plugins/puzzles/rbcompat.h
new file mode 100644
index 0000000000..148aaef073
--- /dev/null
+++ b/apps/plugins/puzzles/rbcompat.h
@@ -0,0 +1,62 @@
+#include "plugin.h"
+#include "rbassert.h"
+
+int sprintf_wrapper(char *str, const char *fmt, ...);
+char *getenv_wrapper(const char *c);
+int puts_wrapper(const char *s);
+double sin_wrapper(double rads);
+double cos_wrapper(double rads);
+int vsprintf_wrapper(char *s, const char *fmt, va_list ap);
+float fabs_wrapper(float n);
+float floor_wrapper(float n);
+
+float atan_wrapper(float x);
+float atan2_wrapper(float y, float x);
+float sqrt_wrapper(float x);
+long strtol_wrapper(const char *nptr, char **endptr, int base);
+int64_t strtoq_wrapper(const char *nptr, char **endptr, int base);
+uint64_t strtouq_wrapper(const char *nptr, char **endptr, int base);
+float pow_wrapper(float x, float y);
+float ceil_wrapper(float x);
+
+size_t strspn_wrapper(const char *s1, const char *s2);
+size_t strcspn_wrapper(const char *s1, const char *s2);
+int sscanf_wrapper(const char *ibuf, const char *fmt, ...);
+double atof_wrapper(const char *s);
+double acos_wrapper(double x);
+
+#define acos acos_wrapper
+#define atan atan_wrapper
+#define atan2 atan2_wrapper
+#define atof atof_wrapper
+#define atoi rb->atoi
+#define atol atoi
+#define calloc tlsf_calloc
+#define ceil ceil_wrapper
+#define cos cos_wrapper
+#define fabs fabs_wrapper
+#define floor floor_wrapper
+#define free tlsf_free
+#define getenv getenv_wrapper
+#define malloc tlsf_malloc
+#define memchr rb->memchr
+#define pow pow_wrapper
+#define printf LOGF
+#define puts puts_wrapper
+#define qsort rb->qsort
+#define realloc tlsf_realloc
+#define sin sin_wrapper
+#define sprintf sprintf_wrapper
+#define sqrt sqrt_wrapper
+#define sscanf sscanf_wrapper
+#define strcat rb->strcat
+#define strchr rb->strchr
+#define strcmp rb->strcmp
+#define strcpy rb->strcpy
+#define strcspn strcspn_wrapper
+#define strlen rb->strlen
+#define strspn strspn_wrapper
+#define strtol strtol_wrapper
+#define strtoq strtoq_wrapper
+#define strtouq strtouq_wrapper
+#define vsprintf vsprintf_wrapper
diff --git a/apps/plugins/puzzles/rbwrappers.c b/apps/plugins/puzzles/rbwrappers.c
new file mode 100644
index 0000000000..8eca1909c3
--- /dev/null
+++ b/apps/plugins/puzzles/rbwrappers.c
@@ -0,0 +1,2378 @@
+#include <puzzles.h>
+#include "fixedpoint.h"
+
+int sprintf_wrapper(char *str, const char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    int ret = rb->vsnprintf(str, 9999, fmt, ap);
+    va_end(ap);
+    return ret;
+}
+
+char *getenv_wrapper(const char *c)
+{
+    return NULL;
+}
+
+int puts_wrapper(const char *s)
+{
+    LOGF("%s", s);
+    return 0;
+}
+
+/* fixed-point wrappers */
+double sin_wrapper(double rads)
+{
+    int degs = rads * 180/PI;
+    long fixed = fp14_sin(degs);
+    return fixed / (16384.0);
+}
+
+double cos_wrapper(double rads)
+{
+    int degs = rads * 180/PI;
+    long fixed = fp14_cos(degs);
+    return fixed / (16384.0);
+}
+
+int vsprintf_wrapper(char *s, const char *fmt, va_list ap)
+{
+    return rb->vsnprintf(s, 9999, fmt, ap);
+
+}
+
+/* Absolute value, simple calculus */
+float fabs_wrapper(float x)
+{
+    return (x < 0.0f) ? -x : x;
+}
+
+float floor_wrapper(float n)
+{
+    if(n < 0.0f)
+        return ((int)n - 1);
+    else
+        return (int)n;
+}
+
+/* Natural logarithm.
+   Taken from glibc-2.8 */
+static const float
+ln2_hi =   6.9313812256e-01,    /* 0x3f317180 */
+ln2_lo =   9.0580006145e-06,    /* 0x3717f7d1 */
+two25 =    3.355443200e+07,     /* 0x4c000000 */
+Lg1 = 6.6666668653e-01, /* 3F2AAAAB */
+Lg2 = 4.0000000596e-01, /* 3ECCCCCD */
+Lg3 = 2.8571429849e-01, /* 3E924925 */
+Lg4 = 2.2222198546e-01, /* 3E638E29 */
+Lg5 = 1.8183572590e-01, /* 3E3A3325 */
+Lg6 = 1.5313838422e-01, /* 3E1CD04F */
+Lg7 = 1.4798198640e-01; /* 3E178897 */
+
+static const float zero   =  0.0;
+
+/* A union which permits us to convert between a float and a 32 bit
+   int.  */
+
+typedef union
+{
+  float value;
+  uint32_t word;
+} ieee_float_shape_type;
+
+/* Get a 32 bit int from a float.  */
+
+#define GET_FLOAT_WORD(i,d)                                     \
+do {                                                            \
+  ieee_float_shape_type gf_u;                                   \
+  gf_u.value = (d);                                             \
+  (i) = gf_u.word;                                              \
+} while (0)
+
+/* Set a float from a 32 bit int.  */
+
+#define SET_FLOAT_WORD(d,i)                                     \
+do {                                                            \
+  ieee_float_shape_type sf_u;                                   \
+  sf_u.word = (i);                                              \
+  (d) = sf_u.value;                                             \
+} while (0)
+
+#ifdef ROCKBOX_LITTLE_ENDIAN
+#define __HI(x) *(1+(int*)&x)
+#define __LO(x) *(int*)&x
+#define __HIp(x) *(1+(int*)x)
+#define __LOp(x) *(int*)x
+#else
+#define __HI(x) *(int*)&x
+#define __LO(x) *(1+(int*)&x)
+#define __HIp(x) *(int*)x
+#define __LOp(x) *(1+(int*)x)
+#endif
+
+static float rb_log(float x)
+{
+    float hfsq, f, s, z, R, w, t1, t2, dk;
+    int32_t k, ix, i, j;
+
+    GET_FLOAT_WORD(ix,x);
+
+    k=0;
+    if (ix < 0x00800000) {          /* x < 2**-126  */
+        if ((ix&0x7fffffff)==0)
+            return -two25/(x-x);                /* log(+-0)=-inf */
+        if (ix<0) return (x-x)/(x-x);   /* log(-#) = NaN */
+        k -= 25; x *= two25; /* subnormal number, scale up x */
+        GET_FLOAT_WORD(ix,x);
+    }
+    if (ix >= 0x7f800000) return x+x;
+    k += (ix>>23)-127;
+    ix &= 0x007fffff;
+    i = (ix+(0x95f64<<3))&0x800000;
+    SET_FLOAT_WORD(x,ix|(i^0x3f800000));        /* normalize x or x/2 */
+    k += (i>>23);
+    f = x-(float)1.0;
+    if((0x007fffff&(15+ix))<16) {       /* |f| < 2**-20 */
+        if(f==zero) {
+            if(k==0)
+                return zero;
+            else
+            {
+                dk=(float)k;
+                return dk*ln2_hi+dk*ln2_lo;
+            }
+        }
+        R = f*f*((float)0.5-(float)0.33333333333333333*f);
+        if(k==0)
+            return f-R;
+        else
+        {
+            dk=(float)k;
+            return dk*ln2_hi-((R-dk*ln2_lo)-f);
+        }
+    }
+    s = f/((float)2.0+f);
+    dk = (float)k;
+    z = s*s;
+    i = ix-(0x6147a<<3);
+    w = z*z;
+    j = (0x6b851<<3)-ix;
+    t1= w*(Lg2+w*(Lg4+w*Lg6));
+    t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7)));
+    i |= j;
+    R = t2+t1;
+    if(i>0) {
+        hfsq=(float)0.5*f*f;
+        if(k==0)
+            return f-(hfsq-s*(hfsq+R));
+        else
+            return dk*ln2_hi-((hfsq-(s*(hfsq+R)+dk*ln2_lo))-f);
+    } else {
+        if(k==0)
+            return f-s*(f-R);
+        else
+            return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f);
+    }
+}
+
+union ieee754_double
+  {
+    double d;
+
+    /* This is the IEEE 754 double-precision format.  */
+    struct
+      {
+#ifdef ROCKBOX_BIG_ENDIAN
+        unsigned int negative:1;
+        unsigned int exponent:11;
+        /* Together these comprise the mantissa.  */
+        unsigned int mantissa0:20;
+        unsigned int mantissa1:32;
+#else /* ROCKBOX_LITTLE_ENDIAN */
+        /* Together these comprise the mantissa.  */
+        unsigned int mantissa1:32;
+        unsigned int mantissa0:20;
+        unsigned int exponent:11;
+        unsigned int negative:1;
+#endif /* ROCKBOX_LITTLE_ENDIAN */
+      } ieee;
+
+    /* This format makes it easier to see if a NaN is a signalling NaN.  */
+    struct
+      {
+#ifdef ROCKBOX_BIG_ENDIAN
+        unsigned int negative:1;
+        unsigned int exponent:11;
+        unsigned int quiet_nan:1;
+        /* Together these comprise the mantissa.  */
+        unsigned int mantissa0:19;
+        unsigned int mantissa1:32;
+#else /* ROCKBOX_LITTLE_ENDIAN */
+        /* Together these comprise the mantissa.  */
+        unsigned int mantissa1:32;
+        unsigned int mantissa0:19;
+        unsigned int quiet_nan:1;
+        unsigned int exponent:11;
+        unsigned int negative:1;
+#endif /* ROCKBOX_LITTLE_ENDIAN */
+      } ieee_nan;
+  };
+
+static const volatile float TWOM100 = 7.88860905e-31;
+static const volatile float TWO127 = 1.7014118346e+38;
+
+/* Exponential function,
+   taken from glibc-2.8
+   As it uses double values and udefines some symbols,
+   it was moved to the end of the source code */
+
+#define W52 (2.22044605e-16)
+#define W55 (2.77555756e-17)
+#define W58 (3.46944695e-18)
+#define W59 (1.73472348e-18)
+#define W60 (8.67361738e-19)
+const float __exp_deltatable[178] = {
+         0*W60,  16558714*W60, -10672149*W59,   1441652*W60,
+ -15787963*W55,    462888*W60,   7291806*W60,   1698880*W60,
+ -14375103*W58,  -2021016*W60,    728829*W60,  -3759654*W60,
+   3202123*W60, -10916019*W58,   -251570*W60,  -1043086*W60,
+   8207536*W60,   -409964*W60,  -5993931*W60,   -475500*W60,
+   2237522*W60,    324170*W60,   -244117*W60,     32077*W60,
+    123907*W60,  -1019734*W60,      -143*W60,    813077*W60,
+    743345*W60,    462461*W60,    629794*W60,   2125066*W60,
+  -2339121*W60,   -337951*W60,   9922067*W60,   -648704*W60,
+    149407*W60,  -2687209*W60,   -631608*W60,   2128280*W60,
+  -4882082*W60,   2001360*W60,    175074*W60,   2923216*W60,
+   -538947*W60,  -1212193*W60,  -1920926*W60,  -1080577*W60,
+   3690196*W60,   2643367*W60,   2911937*W60,    671455*W60,
+  -1128674*W60,    593282*W60,  -5219347*W60,  -1941490*W60,
+  11007953*W60,    239609*W60,  -2969658*W60,  -1183650*W60,
+    942998*W60,    699063*W60,    450569*W60,   -329250*W60,
+  -7257875*W60,   -312436*W60,     51626*W60,    555877*W60,
+   -641761*W60,   1565666*W60,    884327*W60, -10960035*W60,
+  -2004679*W60,   -995793*W60,  -2229051*W60,   -146179*W60,
+   -510327*W60,   1453482*W60,  -3778852*W60,  -2238056*W60,
+  -4895983*W60,   3398883*W60,   -252738*W60,   1230155*W60,
+    346918*W60,   1109352*W60,    268941*W60,  -2930483*W60,
+  -1036263*W60,  -1159280*W60,   1328176*W60,   2937642*W60,
+  -9371420*W60,  -6902650*W60,  -1419134*W60,   1442904*W60,
+  -1319056*W60,    -16369*W60,    696555*W60,   -279987*W60,
+  -7919763*W60,    252741*W60,    459711*W60,  -1709645*W60,
+    354913*W60,   6025867*W60,   -421460*W60,   -853103*W60,
+   -338649*W60,    962151*W60,    955965*W60,    784419*W60,
+  -3633653*W60,   2277133*W60,  -8847927*W52,   1223028*W60,
+   5907079*W60,    623167*W60,   5142888*W60,   2599099*W60,
+   1214280*W60,   4870359*W60,    593349*W60,    -57705*W60,
+   7761209*W60,  -5564097*W60,   2051261*W60,   6216869*W60,
+   4692163*W60,    601691*W60,  -5264906*W60,   1077872*W60,
+  -3205949*W60,   1833082*W60,   2081746*W60,   -987363*W60,
+  -1049535*W60,   2015244*W60,    874230*W60,   2168259*W60,
+  -1740124*W60, -10068269*W60,    -18242*W60,  -3013583*W60,
+    580601*W60,  -2547161*W60,   -535689*W60,   2220815*W60,
+   1285067*W60,   2806933*W60,   -983086*W60,  -1729097*W60,
+  -1162985*W60,  -2561904*W60,    801988*W60,    244351*W60,
+   1441893*W60,  -7517981*W60,    271781*W60, -15021588*W60,
+  -2341588*W60,   -919198*W60,   1642232*W60,   4771771*W60,
+  -1220099*W60,  -3062372*W60,    628624*W60,   1278114*W60,
+  13083513*W60, -10521925*W60,   3180310*W60,  -1659307*W60,
+   3543773*W60,   2501203*W60,      4151*W60,   -340748*W60,
+  -2285625*W60,   2495202*W60
+};
+
+const double __exp_atable[355] /* __attribute__((mode(DF))) */ = {
+ 0.707722561055888932371, /* 0x0.b52d4e46605c27ffd */
+ 0.709106182438804188967, /* 0x0.b587fb96f75097ffb */
+ 0.710492508843861281234, /* 0x0.b5e2d649899167ffd */
+ 0.711881545564593931623, /* 0x0.b63dde74d36bdfffe */
+ 0.713273297897442870573, /* 0x0.b699142f945f87ffc */
+ 0.714667771153751463236, /* 0x0.b6f477909c4ea0001 */
+ 0.716064970655995725059, /* 0x0.b75008aec758f8004 */
+ 0.717464901723956938193, /* 0x0.b7abc7a0eea7e0002 */
+ 0.718867569715736398602, /* 0x0.b807b47e1586c7ff8 */
+ 0.720272979947266023271, /* 0x0.b863cf5d10e380003 */
+ 0.721681137825144314297, /* 0x0.b8c01855195c37ffb */
+ 0.723092048691992950199, /* 0x0.b91c8f7d213740004 */
+ 0.724505717938892290800, /* 0x0.b97934ec5002d0007 */
+ 0.725922150953176470431, /* 0x0.b9d608b9c92ea7ffc */
+ 0.727341353138962865022, /* 0x0.ba330afcc29e98003 */
+ 0.728763329918453162104, /* 0x0.ba903bcc8618b7ffc */
+ 0.730188086709957051568, /* 0x0.baed9b40591ba0000 */
+ 0.731615628948127705309, /* 0x0.bb4b296f931e30002 */
+ 0.733045962086486091436, /* 0x0.bba8e671a05617ff9 */
+ 0.734479091556371366251, /* 0x0.bc06d25dd49568001 */
+ 0.735915022857225542529, /* 0x0.bc64ed4bce8f6fff9 */
+ 0.737353761441304711410, /* 0x0.bcc33752f915d7ff9 */
+ 0.738795312814142124419, /* 0x0.bd21b08af98e78005 */
+ 0.740239682467211168593, /* 0x0.bd80590b65e9a8000 */
+ 0.741686875913991849885, /* 0x0.bddf30ebec4a10000 */
+ 0.743136898669507939299, /* 0x0.be3e38443c84e0007 */
+ 0.744589756269486091620, /* 0x0.be9d6f2c1d32a0002 */
+ 0.746045454254026796384, /* 0x0.befcd5bb59baf8004 */
+ 0.747503998175051087583, /* 0x0.bf5c6c09ca84c0003 */
+ 0.748965393601880857739, /* 0x0.bfbc322f5b18b7ff8 */
+ 0.750429646104262104698, /* 0x0.c01c2843f776fffff */
+ 0.751896761271877989160, /* 0x0.c07c4e5fa18b88002 */
+ 0.753366744698445112140, /* 0x0.c0dca49a5fb18fffd */
+ 0.754839601988627206827, /* 0x0.c13d2b0c444db0005 */
+ 0.756315338768691947122, /* 0x0.c19de1cd798578006 */
+ 0.757793960659406629066, /* 0x0.c1fec8f623723fffd */
+ 0.759275473314173443536, /* 0x0.c25fe09e8a0f47ff8 */
+ 0.760759882363831851927, /* 0x0.c2c128dedc88f8000 */
+ 0.762247193485956486805, /* 0x0.c322a1cf7d6e7fffa */
+ 0.763737412354726363781, /* 0x0.c3844b88cb9347ffc */
+ 0.765230544649828092739, /* 0x0.c3e626232bd8f7ffc */
+ 0.766726596071518051729, /* 0x0.c44831b719bf18002 */
+ 0.768225572321911687194, /* 0x0.c4aa6e5d12d078001 */
+ 0.769727479119219348810, /* 0x0.c50cdc2da64a37ffb */
+ 0.771232322196981678892, /* 0x0.c56f7b41744490001 */
+ 0.772740107296721268087, /* 0x0.c5d24bb1259e70004 */
+ 0.774250840160724651565, /* 0x0.c6354d95640dd0007 */
+ 0.775764526565368872643, /* 0x0.c6988106fec447fff */
+ 0.777281172269557396602, /* 0x0.c6fbe61eb1bd0ffff */
+ 0.778800783068235302750, /* 0x0.c75f7cf560942fffc */
+ 0.780323364758801041312, /* 0x0.c7c345a3f1983fffe */
+ 0.781848923151573727006, /* 0x0.c8274043594cb0002 */
+ 0.783377464064598849602, /* 0x0.c88b6cec94b3b7ff9 */
+ 0.784908993312207869935, /* 0x0.c8efcbb89cba27ffe */
+ 0.786443516765346961618, /* 0x0.c9545cc0a88c70003 */
+ 0.787981040257604625744, /* 0x0.c9b9201dc643bfffa */
+ 0.789521569657452682047, /* 0x0.ca1e15e92a5410007 */
+ 0.791065110849462849192, /* 0x0.ca833e3c1ae510005 */
+ 0.792611669712891875319, /* 0x0.cae8992fd84667ffd */
+ 0.794161252150049179450, /* 0x0.cb4e26ddbc207fff8 */
+ 0.795713864077794763584, /* 0x0.cbb3e75f301b60003 */
+ 0.797269511407239561694, /* 0x0.cc19dacd978cd8002 */
+ 0.798828200086368567220, /* 0x0.cc8001427e55d7ffb */
+ 0.800389937624300440456, /* 0x0.cce65ade24d360006 */
+ 0.801954725261124767840, /* 0x0.cd4ce7a5de839fffb */
+ 0.803522573691593189330, /* 0x0.cdb3a7c79a678fffd */
+ 0.805093487311204114563, /* 0x0.ce1a9b563965ffffc */
+ 0.806667472122675088819, /* 0x0.ce81c26b838db8000 */
+ 0.808244534127439906441, /* 0x0.cee91d213f8428002 */
+ 0.809824679342317166307, /* 0x0.cf50ab9144d92fff9 */
+ 0.811407913793616542005, /* 0x0.cfb86dd5758c2ffff */
+ 0.812994243520784198882, /* 0x0.d0206407c20e20005 */
+ 0.814583674571603966162, /* 0x0.d0888e4223facfff9 */
+ 0.816176213022088536960, /* 0x0.d0f0ec9eb3f7c8002 */
+ 0.817771864936188586101, /* 0x0.d1597f377d6768002 */
+ 0.819370636400374108252, /* 0x0.d1c24626a46eafff8 */
+ 0.820972533518165570298, /* 0x0.d22b41865ff1e7ff9 */
+ 0.822577562404315121269, /* 0x0.d2947170f32ec7ff9 */
+ 0.824185729164559344159, /* 0x0.d2fdd60097795fff8 */
+ 0.825797039949601741075, /* 0x0.d3676f4fb796d0001 */
+ 0.827411500902565544264, /* 0x0.d3d13d78b5f68fffb */
+ 0.829029118181348834154, /* 0x0.d43b40960546d8001 */
+ 0.830649897953322891022, /* 0x0.d4a578c222a058000 */
+ 0.832273846408250750368, /* 0x0.d50fe617a3ba78005 */
+ 0.833900969738858188772, /* 0x0.d57a88b1218e90002 */
+ 0.835531274148056613016, /* 0x0.d5e560a94048f8006 */
+ 0.837164765846411529371, /* 0x0.d6506e1aac8078003 */
+ 0.838801451086016225394, /* 0x0.d6bbb1204074e0001 */
+ 0.840441336100884561780, /* 0x0.d72729d4c28518004 */
+ 0.842084427144139224814, /* 0x0.d792d8530e12b0001 */
+ 0.843730730487052604790, /* 0x0.d7febcb61273e7fff */
+ 0.845380252404570153833, /* 0x0.d86ad718c308dfff9 */
+ 0.847032999194574087728, /* 0x0.d8d727962c69d7fff */
+ 0.848688977161248581090, /* 0x0.d943ae49621ce7ffb */
+ 0.850348192619261200615, /* 0x0.d9b06b4d832ef8005 */
+ 0.852010651900976245816, /* 0x0.da1d5ebdc22220005 */
+ 0.853676361342631029337, /* 0x0.da8a88b555baa0006 */
+ 0.855345327311054837175, /* 0x0.daf7e94f965f98004 */
+ 0.857017556155879489641, /* 0x0.db6580a7c98f7fff8 */
+ 0.858693054267390953857, /* 0x0.dbd34ed9617befff8 */
+ 0.860371828028939855647, /* 0x0.dc4153ffc8b65fff9 */
+ 0.862053883854957292436, /* 0x0.dcaf90368bfca8004 */
+ 0.863739228154875360306, /* 0x0.dd1e0399328d87ffe */
+ 0.865427867361348468455, /* 0x0.dd8cae435d303fff9 */
+ 0.867119807911702289458, /* 0x0.ddfb9050b1cee8006 */
+ 0.868815056264353846599, /* 0x0.de6aa9dced8448001 */
+ 0.870513618890481399881, /* 0x0.ded9fb03db7320006 */
+ 0.872215502247877139094, /* 0x0.df4983e1380657ff8 */
+ 0.873920712852848668986, /* 0x0.dfb94490ffff77ffd */
+ 0.875629257204025623884, /* 0x0.e0293d2f1cb01fff9 */
+ 0.877341141814212965880, /* 0x0.e0996dd786fff0007 */
+ 0.879056373217612985183, /* 0x0.e109d6a64f5d57ffc */
+ 0.880774957955916648615, /* 0x0.e17a77b78e72a7ffe */
+ 0.882496902590150900078, /* 0x0.e1eb5127722cc7ff8 */
+ 0.884222213673356738383, /* 0x0.e25c63121fb0c8006 */
+ 0.885950897802399772740, /* 0x0.e2cdad93ec5340003 */
+ 0.887682961567391237685, /* 0x0.e33f30c925fb97ffb */
+ 0.889418411575228162725, /* 0x0.e3b0ecce2d05ffff9 */
+ 0.891157254447957902797, /* 0x0.e422e1bf727718006 */
+ 0.892899496816652704641, /* 0x0.e4950fb9713fc7ffe */
+ 0.894645145323828439008, /* 0x0.e50776d8b0e60fff8 */
+ 0.896394206626591749641, /* 0x0.e57a1739c8fadfffc */
+ 0.898146687421414902124, /* 0x0.e5ecf0f97c5798007 */
+ 0.899902594367530173098, /* 0x0.e660043464e378005 */
+ 0.901661934163603406867, /* 0x0.e6d3510747e150006 */
+ 0.903424713533971135418, /* 0x0.e746d78f06cd97ffd */
+ 0.905190939194458810123, /* 0x0.e7ba97e879c91fffc */
+ 0.906960617885092856864, /* 0x0.e82e92309390b0007 */
+ 0.908733756358986566306, /* 0x0.e8a2c6845544afffa */
+ 0.910510361377119825629, /* 0x0.e9173500c8abc7ff8 */
+ 0.912290439722343249336, /* 0x0.e98bddc30f98b0002 */
+ 0.914073998177417412765, /* 0x0.ea00c0e84bc4c7fff */
+ 0.915861043547953501680, /* 0x0.ea75de8db8094fffe */
+ 0.917651582652244779397, /* 0x0.eaeb36d09d3137ffe */
+ 0.919445622318405764159, /* 0x0.eb60c9ce4ed3dffff */
+ 0.921243169397334638073, /* 0x0.ebd697a43995b0007 */
+ 0.923044230737526172328, /* 0x0.ec4ca06fc7768fffa */
+ 0.924848813220121135342, /* 0x0.ecc2e44e865b6fffb */
+ 0.926656923710931002014, /* 0x0.ed39635df34e70006 */
+ 0.928468569126343790092, /* 0x0.edb01dbbc2f5b7ffa */
+ 0.930283756368834757725, /* 0x0.ee2713859aab57ffa */
+ 0.932102492359406786818, /* 0x0.ee9e44d9342870004 */
+ 0.933924784042873379360, /* 0x0.ef15b1d4635438005 */
+ 0.935750638358567643520, /* 0x0.ef8d5a94f60f50007 */
+ 0.937580062297704630580, /* 0x0.f0053f38f345cffff */
+ 0.939413062815381727516, /* 0x0.f07d5fde3a2d98001 */
+ 0.941249646905368053689, /* 0x0.f0f5bca2d481a8004 */
+ 0.943089821583810716806, /* 0x0.f16e55a4e497d7ffe */
+ 0.944933593864477061592, /* 0x0.f1e72b028a2827ffb */
+ 0.946780970781518460559, /* 0x0.f2603cd9fb5430001 */
+ 0.948631959382661205081, /* 0x0.f2d98b497d2a87ff9 */
+ 0.950486566729423554277, /* 0x0.f353166f63e3dffff */
+ 0.952344799896018723290, /* 0x0.f3ccde6a11ae37ffe */
+ 0.954206665969085765512, /* 0x0.f446e357f66120000 */
+ 0.956072172053890279009, /* 0x0.f4c12557964f0fff9 */
+ 0.957941325265908139014, /* 0x0.f53ba48781046fffb */
+ 0.959814132734539637840, /* 0x0.f5b66106555d07ffa */
+ 0.961690601603558903308, /* 0x0.f6315af2c2027fffc */
+ 0.963570739036113010927, /* 0x0.f6ac926b8aeb80004 */
+ 0.965454552202857141381, /* 0x0.f728078f7c5008002 */
+ 0.967342048278315158608, /* 0x0.f7a3ba7d66a908001 */
+ 0.969233234469444204768, /* 0x0.f81fab543e1897ffb */
+ 0.971128118008140250896, /* 0x0.f89bda33122c78007 */
+ 0.973026706099345495256, /* 0x0.f9184738d4cf97ff8 */
+ 0.974929006031422851235, /* 0x0.f994f284d3a5c0008 */
+ 0.976835024947348973265, /* 0x0.fa11dc35bc7820002 */
+ 0.978744770239899142285, /* 0x0.fa8f046b4fb7f8007 */
+ 0.980658249138918636210, /* 0x0.fb0c6b449ab1cfff9 */
+ 0.982575468959622777535, /* 0x0.fb8a10e1088fb7ffa */
+ 0.984496437054508843888, /* 0x0.fc07f5602d79afffc */
+ 0.986421160608523028820, /* 0x0.fc8618e0e55e47ffb */
+ 0.988349647107594098099, /* 0x0.fd047b83571b1fffa */
+ 0.990281903873210800357, /* 0x0.fd831d66f4c018002 */
+ 0.992217938695037382475, /* 0x0.fe01fead3320bfff8 */
+ 0.994157757657894713987, /* 0x0.fe811f703491e8006 */
+ 0.996101369488558541238, /* 0x0.ff007fd5744490005 */
+ 0.998048781093141101932, /* 0x0.ff801ffa9b9280007 */
+ 1.000000000000000000000, /* 0x1.00000000000000000 */
+ 1.001955033605393285965, /* 0x1.0080200565d29ffff */
+ 1.003913889319761887310, /* 0x1.0100802aa0e80fff0 */
+ 1.005876574715736104818, /* 0x1.01812090377240007 */
+ 1.007843096764807100351, /* 0x1.020201541aad7fff6 */
+ 1.009813464316352327214, /* 0x1.0283229c4c9820007 */
+ 1.011787683565730677817, /* 0x1.030484836910a000e */
+ 1.013765762469146736174, /* 0x1.0386272b9c077fffe */
+ 1.015747708536026694351, /* 0x1.04080ab526304fff0 */
+ 1.017733529475172815584, /* 0x1.048a2f412375ffff0 */
+ 1.019723232714418781378, /* 0x1.050c94ef7ad5e000a */
+ 1.021716825883923762690, /* 0x1.058f3be0f1c2d0004 */
+ 1.023714316605201180057, /* 0x1.06122436442e2000e */
+ 1.025715712440059545995, /* 0x1.06954e0fec63afff2 */
+ 1.027721021151397406936, /* 0x1.0718b98f41c92fff6 */
+ 1.029730250269221158939, /* 0x1.079c66d49bb2ffff1 */
+ 1.031743407506447551857, /* 0x1.082056011a9230009 */
+ 1.033760500517691527387, /* 0x1.08a487359ebd50002 */
+ 1.035781537016238873464, /* 0x1.0928fa93490d4fff3 */
+ 1.037806524719013578963, /* 0x1.09adb03b3e5b3000d */
+ 1.039835471338248051878, /* 0x1.0a32a84e9e5760004 */
+ 1.041868384612101516848, /* 0x1.0ab7e2eea5340ffff */
+ 1.043905272300907460835, /* 0x1.0b3d603ca784f0009 */
+ 1.045946142174331239262, /* 0x1.0bc3205a042060000 */
+ 1.047991002016745332165, /* 0x1.0c4923682a086fffe */
+ 1.050039859627715177527, /* 0x1.0ccf698898f3a000d */
+ 1.052092722826109660856, /* 0x1.0d55f2dce5d1dfffb */
+ 1.054149599440827866881, /* 0x1.0ddcbf86b09a5fff6 */
+ 1.056210497317612961855, /* 0x1.0e63cfa7abc97fffd */
+ 1.058275424318780855142, /* 0x1.0eeb23619c146fffb */
+ 1.060344388322010722446, /* 0x1.0f72bad65714bffff */
+ 1.062417397220589476718, /* 0x1.0ffa9627c38d30004 */
+ 1.064494458915699715017, /* 0x1.1082b577d0eef0003 */
+ 1.066575581342167566880, /* 0x1.110b18e893a90000a */
+ 1.068660772440545025953, /* 0x1.1193c09c267610006 */
+ 1.070750040138235936705, /* 0x1.121cacb4959befff6 */
+ 1.072843392435016474095, /* 0x1.12a5dd543cf36ffff */
+ 1.074940837302467588937, /* 0x1.132f529d59552000b */
+ 1.077042382749654914030, /* 0x1.13b90cb250d08fff5 */
+ 1.079148036789447484528, /* 0x1.14430bb58da3dfff9 */
+ 1.081257807444460983297, /* 0x1.14cd4fc984c4a000e */
+ 1.083371702785017154417, /* 0x1.1557d910df9c7000e */
+ 1.085489730853784307038, /* 0x1.15e2a7ae292d30002 */
+ 1.087611899742884524772, /* 0x1.166dbbc422d8c0004 */
+ 1.089738217537583819804, /* 0x1.16f9157586772ffff */
+ 1.091868692357631731528, /* 0x1.1784b4e533cacfff0 */
+ 1.094003332327482702577, /* 0x1.18109a360fc23fff2 */
+ 1.096142145591650907149, /* 0x1.189cc58b155a70008 */
+ 1.098285140311341168136, /* 0x1.1929370751ea50002 */
+ 1.100432324652149906842, /* 0x1.19b5eecdd79cefff0 */
+ 1.102583706811727015711, /* 0x1.1a42ed01dbdba000e */
+ 1.104739294993289488947, /* 0x1.1ad031c69a2eafff0 */
+ 1.106899097422573863281, /* 0x1.1b5dbd3f66e120003 */
+ 1.109063122341542140286, /* 0x1.1beb8f8fa8150000b */
+ 1.111231377994659874592, /* 0x1.1c79a8dac6ad0fff4 */
+ 1.113403872669181282605, /* 0x1.1d0809445a97ffffc */
+ 1.115580614653132185460, /* 0x1.1d96b0effc9db000e */
+ 1.117761612217810673898, /* 0x1.1e25a001332190000 */
+ 1.119946873713312474002, /* 0x1.1eb4d69bdb2a9fff1 */
+ 1.122136407473298902480, /* 0x1.1f4454e3bfae00006 */
+ 1.124330221845670330058, /* 0x1.1fd41afcbb48bfff8 */
+ 1.126528325196519908506, /* 0x1.2064290abc98c0001 */
+ 1.128730725913251964394, /* 0x1.20f47f31c9aa7000f */
+ 1.130937432396844410880, /* 0x1.21851d95f776dfff0 */
+ 1.133148453059692917203, /* 0x1.2216045b6784efffa */
+ 1.135363796355857157764, /* 0x1.22a733a6692ae0004 */
+ 1.137583470716100553249, /* 0x1.2338ab9b3221a0004 */
+ 1.139807484614418608939, /* 0x1.23ca6c5e27aadfff7 */
+ 1.142035846532929888057, /* 0x1.245c7613b7f6c0004 */
+ 1.144268564977221958089, /* 0x1.24eec8e06b035000c */
+ 1.146505648458203463465, /* 0x1.258164e8cea85fff8 */
+ 1.148747105501412235671, /* 0x1.26144a5180d380009 */
+ 1.150992944689175123667, /* 0x1.26a7793f5de2efffa */
+ 1.153243174560058870217, /* 0x1.273af1d712179000d */
+ 1.155497803703682491111, /* 0x1.27ceb43d81d42fff1 */
+ 1.157756840726344771440, /* 0x1.2862c097a3d29000c */
+ 1.160020294239811677834, /* 0x1.28f7170a74cf4fff1 */
+ 1.162288172883275239058, /* 0x1.298bb7bb0faed0004 */
+ 1.164560485298402170388, /* 0x1.2a20a2ce920dffff4 */
+ 1.166837240167474476460, /* 0x1.2ab5d86a4631ffff6 */
+ 1.169118446164539637555, /* 0x1.2b4b58b36d5220009 */
+ 1.171404112007080167155, /* 0x1.2be123cf786790002 */
+ 1.173694246390975415341, /* 0x1.2c7739e3c0aac000d */
+ 1.175988858069749065617, /* 0x1.2d0d9b15deb58fff6 */
+ 1.178287955789017793514, /* 0x1.2da4478b627040002 */
+ 1.180591548323240091978, /* 0x1.2e3b3f69fb794fffc */
+ 1.182899644456603782686, /* 0x1.2ed282d76421d0004 */
+ 1.185212252993012693694, /* 0x1.2f6a11f96c685fff3 */
+ 1.187529382762033236513, /* 0x1.3001ecf60082ffffa */
+ 1.189851042595508889847, /* 0x1.309a13f30f28a0004 */
+ 1.192177241354644978669, /* 0x1.31328716a758cfff7 */
+ 1.194507987909589896687, /* 0x1.31cb4686e1e85fffb */
+ 1.196843291137896336843, /* 0x1.32645269dfd04000a */
+ 1.199183159977805113226, /* 0x1.32fdaae604c39000f */
+ 1.201527603343041317132, /* 0x1.339750219980dfff3 */
+ 1.203876630171082595692, /* 0x1.3431424300e480007 */
+ 1.206230249419600664189, /* 0x1.34cb8170b3fee000e */
+ 1.208588470077065268869, /* 0x1.35660dd14dbd4fffc */
+ 1.210951301134513435915, /* 0x1.3600e78b6bdfc0005 */
+ 1.213318751604272271958, /* 0x1.369c0ec5c38ebfff2 */
+ 1.215690830512196507537, /* 0x1.373783a718d29000f */
+ 1.218067546930756250870, /* 0x1.37d3465662f480007 */
+ 1.220448909901335365929, /* 0x1.386f56fa770fe0008 */
+ 1.222834928513994334780, /* 0x1.390bb5ba5fc540004 */
+ 1.225225611877684750397, /* 0x1.39a862bd3c7a8fff3 */
+ 1.227620969111500981433, /* 0x1.3a455e2a37bcafffd */
+ 1.230021009336254911271, /* 0x1.3ae2a8287dfbefff6 */
+ 1.232425741726685064472, /* 0x1.3b8040df76f39fffa */
+ 1.234835175450728295084, /* 0x1.3c1e287682e48fff1 */
+ 1.237249319699482263931, /* 0x1.3cbc5f151b86bfff8 */
+ 1.239668183679933477545, /* 0x1.3d5ae4e2cc0a8000f */
+ 1.242091776620540377629, /* 0x1.3df9ba07373bf0006 */
+ 1.244520107762172811399, /* 0x1.3e98deaa0d8cafffe */
+ 1.246953186383919165383, /* 0x1.3f3852f32973efff0 */
+ 1.249391019292643401078, /* 0x1.3fd816ffc72b90001 */
+ 1.251833623164381181797, /* 0x1.40782b17863250005 */
+ 1.254280999953110153911, /* 0x1.41188f42caf400000 */
+ 1.256733161434815393410, /* 0x1.41b943b42945bfffd */
+ 1.259190116985283935980, /* 0x1.425a4893e5f10000a */
+ 1.261651875958665236542, /* 0x1.42fb9e0a2df4c0009 */
+ 1.264118447754797758244, /* 0x1.439d443f608c4fff9 */
+ 1.266589841787181258708, /* 0x1.443f3b5bebf850008 */
+ 1.269066067469190262045, /* 0x1.44e183883e561fff7 */
+ 1.271547134259576328224, /* 0x1.45841cecf7a7a0001 */
+ 1.274033051628237434048, /* 0x1.462707b2c43020009 */
+ 1.276523829025464573684, /* 0x1.46ca44023aa410007 */
+ 1.279019475999373156531, /* 0x1.476dd2045d46ffff0 */
+ 1.281520002043128991825, /* 0x1.4811b1e1f1f19000b */
+ 1.284025416692967214122, /* 0x1.48b5e3c3edd74fff4 */
+ 1.286535729509738823464, /* 0x1.495a67d3613c8fff7 */
+ 1.289050950070396384145, /* 0x1.49ff3e396e19d000b */
+ 1.291571087985403654081, /* 0x1.4aa4671f5b401fff1 */
+ 1.294096152842774794011, /* 0x1.4b49e2ae56d19000d */
+ 1.296626154297237043484, /* 0x1.4befb10fd84a3fff4 */
+ 1.299161101984141142272, /* 0x1.4c95d26d41d84fff8 */
+ 1.301701005575179204100, /* 0x1.4d3c46f01d9f0fff3 */
+ 1.304245874766450485904, /* 0x1.4de30ec21097d0003 */
+ 1.306795719266019562007, /* 0x1.4e8a2a0ccce3d0002 */
+ 1.309350548792467483458, /* 0x1.4f3198fa10346fff5 */
+ 1.311910373099227200545, /* 0x1.4fd95bb3be8cffffd */
+ 1.314475201942565174546, /* 0x1.50817263bf0e5fffb */
+ 1.317045045107389400535, /* 0x1.5129dd3418575000e */
+ 1.319619912422941299109, /* 0x1.51d29c4f01c54ffff */
+ 1.322199813675649204855, /* 0x1.527bafde83a310009 */
+ 1.324784758729532718739, /* 0x1.5325180cfb8b3fffd */
+ 1.327374757430096474625, /* 0x1.53ced504b2bd0fff4 */
+ 1.329969819671041886272, /* 0x1.5478e6f02775e0001 */
+ 1.332569955346704748651, /* 0x1.55234df9d8a59fff8 */
+ 1.335175174370685002822, /* 0x1.55ce0a4c5a6a9fff6 */
+ 1.337785486688218616860, /* 0x1.56791c1263abefff7 */
+ 1.340400902247843806217, /* 0x1.57248376aef21fffa */
+ 1.343021431036279800211, /* 0x1.57d040a420c0bfff3 */
+ 1.345647083048053138662, /* 0x1.587c53c5a630f0002 */
+ 1.348277868295411074918, /* 0x1.5928bd063fd7bfff9 */
+ 1.350913796821875845231, /* 0x1.59d57c9110ad60006 */
+ 1.353554878672557082439, /* 0x1.5a8292913d68cfffc */
+ 1.356201123929036356254, /* 0x1.5b2fff3212db00007 */
+ 1.358852542671913132777, /* 0x1.5bddc29edcc06fff3 */
+ 1.361509145047255398051, /* 0x1.5c8bdd032ed16000f */
+ 1.364170941142184734180, /* 0x1.5d3a4e8a5bf61fff4 */
+ 1.366837941171020309735, /* 0x1.5de9176042f1effff */
+ 1.369510155261156381121, /* 0x1.5e9837b062f4e0005 */
+ 1.372187593620959988833, /* 0x1.5f47afa69436cfff1 */
+ 1.374870266463378287715, /* 0x1.5ff77f6eb3f8cfffd */
+ 1.377558184010425845733, /* 0x1.60a7a734a9742fff9 */
+ 1.380251356531521533853, /* 0x1.6158272490016000c */
+ 1.382949794301995272203, /* 0x1.6208ff6a8978a000f */
+ 1.385653507605306700170, /* 0x1.62ba3032c0a280004 */
+ 1.388362506772382154503, /* 0x1.636bb9a994784000f */
+ 1.391076802081129493127, /* 0x1.641d9bfb29a7bfff6 */
+ 1.393796403973427855412, /* 0x1.64cfd7545928b0002 */
+ 1.396521322756352656542, /* 0x1.65826be167badfff8 */
+ 1.399251568859207761660, /* 0x1.663559cf20826000c */
+ 1.401987152677323100733, /* 0x1.66e8a14a29486fffc */
+ 1.404728084651919228815, /* 0x1.679c427f5a4b6000b */
+ 1.407474375243217723560, /* 0x1.68503d9ba0add000f */
+ 1.410226034922914983815, /* 0x1.690492cbf6303fff9 */
+ 1.412983074197955213304, /* 0x1.69b9423d7b548fff6 */
+};
+
+/* All floating-point numbers can be put in one of these categories.  */
+enum
+  {
+    FP_NAN,
+# define FP_NAN FP_NAN
+    FP_INFINITE,
+# define FP_INFINITE FP_INFINITE
+    FP_ZERO,
+# define FP_ZERO FP_ZERO
+    FP_SUBNORMAL,
+# define FP_SUBNORMAL FP_SUBNORMAL
+    FP_NORMAL
+# define FP_NORMAL FP_NORMAL
+  };
+
+
+int
+__fpclassifyf (float x)
+{
+  uint32_t wx;
+  int retval = FP_NORMAL;
+
+  GET_FLOAT_WORD (wx, x);
+  wx &= 0x7fffffff;
+  if (wx == 0)
+    retval = FP_ZERO;
+  else if (wx < 0x800000)
+    retval = FP_SUBNORMAL;
+  else if (wx >= 0x7f800000)
+    retval = wx > 0x7f800000 ? FP_NAN : FP_INFINITE;
+
+  return retval;
+}
+
+
+int
+__isinff (float x)
+{
+        int32_t ix,t;
+        GET_FLOAT_WORD(ix,x);
+        t = ix & 0x7fffffff;
+        t ^= 0x7f800000;
+        t |= -t;
+        return ~(t >> 31) & (ix >> 30);
+}
+
+/* Return nonzero value if arguments are unordered.  */
+#define fpclassify(x) \
+     (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : __fpclassifyf (x))
+
+#ifndef isunordered
+#define isunordered(u, v) \
+  (__extension__                                                              \
+   ({ __typeof__(u) __u = (u); __typeof__(v) __v = (v);                       \
+      fpclassify (__u) == FP_NAN || fpclassify (__v) == FP_NAN; }))
+#endif
+
+/* Return nonzero value if X is less than Y.  */
+#ifndef isless
+#define isless(x, y) \
+  (__extension__                                                              \
+   ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
+      !isunordered (__x, __y) && __x < __y; }))
+#endif
+
+/* Return nonzero value if X is greater than Y.  */
+#ifndef isgreater
+#define isgreater(x, y) \
+  (__extension__                                                              \
+   ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
+       !isunordered (__x, __y) && __x > __y; }))
+#endif
+
+float rb_exp(float x)
+{
+  static const float himark = 88.72283935546875;
+  static const float lomark = -103.972084045410;
+  /* Check for usual case.  */
+  if (isless (x, himark) && isgreater (x, lomark))
+    {
+      static const float THREEp42 = 13194139533312.0;
+      static const float THREEp22 = 12582912.0;
+      /* 1/ln(2).  */
+#undef M_1_LN2
+      static const float M_1_LN2 = 1.44269502163f;
+      /* ln(2) */
+#undef M_LN2
+      static const double M_LN2 = .6931471805599452862;
+
+      int tval;
+      double x22, t, result, dx;
+      float n, delta;
+      union ieee754_double ex2_u;
+#ifndef ROCKBOX
+      fenv_t oldenv;
+
+      feholdexcept (&oldenv);
+#endif
+
+#ifdef FE_TONEAREST
+      fesetround (FE_TONEAREST);
+#endif
+
+      /* Calculate n.  */
+      n = x * M_1_LN2 + THREEp22;
+      n -= THREEp22;
+      dx = x - n*M_LN2;
+
+      /* Calculate t/512.  */
+      t = dx + THREEp42;
+      t -= THREEp42;
+      dx -= t;
+
+      /* Compute tval = t.  */
+      tval = (int) (t * 512.0);
+
+      if (t >= 0)
+        delta = - __exp_deltatable[tval];
+      else
+        delta = __exp_deltatable[-tval];
+
+      /* Compute ex2 = 2^n e^(t/512+delta[t]).  */
+      ex2_u.d = __exp_atable[tval+177];
+      ex2_u.ieee.exponent += (int) n;
+
+      /* Approximate e^(dx+delta) - 1, using a second-degree polynomial,
+         with maximum error in [-2^-10-2^-28,2^-10+2^-28]
+         less than 5e-11.  */
+      x22 = (0.5000000496709180453 * dx + 1.0000001192102037084) * dx + delta;
+
+      /* Return result.  */
+#ifndef ROCKBOX
+      fesetenv (&oldenv);
+#endif
+
+      result = x22 * ex2_u.d + ex2_u.d;
+      return (float) result;
+    }
+  /* Exceptional cases:  */
+  else if (isless (x, himark))
+    {
+      if (__isinff (x))
+        /* e^-inf == 0, with no error.  */
+        return 0;
+      else
+        /* Underflow */
+        return TWOM100 * TWOM100;
+    }
+  else
+    /* Return x, if x is a NaN or Inf; or overflow, otherwise.  */
+    return TWO127*x;
+}
+
+/* Arc tangent,
+   taken from glibc-2.8. */
+
+static const float atanhi[] = {
+  4.6364760399e-01, /* atan(0.5)hi 0x3eed6338 */
+  7.8539812565e-01, /* atan(1.0)hi 0x3f490fda */
+  9.8279368877e-01, /* atan(1.5)hi 0x3f7b985e */
+  1.5707962513e+00, /* atan(inf)hi 0x3fc90fda */
+};
+
+static const float atanlo[] = {
+  5.0121582440e-09, /* atan(0.5)lo 0x31ac3769 */
+  3.7748947079e-08, /* atan(1.0)lo 0x33222168 */
+  3.4473217170e-08, /* atan(1.5)lo 0x33140fb4 */
+  7.5497894159e-08, /* atan(inf)lo 0x33a22168 */
+};
+
+static const float aT[] = {
+  3.3333334327e-01, /* 0x3eaaaaaa */
+ -2.0000000298e-01, /* 0xbe4ccccd */
+  1.4285714924e-01, /* 0x3e124925 */
+ -1.1111110449e-01, /* 0xbde38e38 */
+  9.0908870101e-02, /* 0x3dba2e6e */
+ -7.6918758452e-02, /* 0xbd9d8795 */
+  6.6610731184e-02, /* 0x3d886b35 */
+ -5.8335702866e-02, /* 0xbd6ef16b */
+  4.9768779427e-02, /* 0x3d4bda59 */
+ -3.6531571299e-02, /* 0xbd15a221 */
+  1.6285819933e-02, /* 0x3c8569d7 */
+};
+
+static const float
+huge = 1.0e+30,
+tiny = 1.0e-30,
+one  = 1.0f;
+
+float atan_wrapper(float x)
+{
+        float w,s1,s2,z;
+        int32_t ix,hx,id;
+
+        GET_FLOAT_WORD(hx,x);
+        ix = hx&0x7fffffff;
+        if(ix>=0x50800000) {    /* if |x| >= 2^34 */
+            if(ix>0x7f800000)
+                return x+x;             /* NaN */
+            if(hx>0) return  atanhi[3]+atanlo[3];
+            else     return -atanhi[3]-atanlo[3];
+        } if (ix < 0x3ee00000) {        /* |x| < 0.4375 */
+            if (ix < 0x31000000) {      /* |x| < 2^-29 */
+                if(huge+x>one) return x;        /* raise inexact */
+            }
+            id = -1;
+        } else {
+        x = fabs_wrapper(x);
+        if (ix < 0x3f980000) {          /* |x| < 1.1875 */
+            if (ix < 0x3f300000) {      /* 7/16 <=|x|<11/16 */
+                id = 0; x = ((float)2.0*x-one)/((float)2.0+x);
+            } else {                    /* 11/16<=|x|< 19/16 */
+                id = 1; x  = (x-one)/(x+one);
+            }
+        } else {
+            if (ix < 0x401c0000) {      /* |x| < 2.4375 */
+                id = 2; x  = (x-(float)1.5)/(one+(float)1.5*x);
+            } else {                    /* 2.4375 <= |x| < 2^66 */
+                id = 3; x  = -(float)1.0/x;
+            }
+        }}
+    /* end of argument reduction */
+        z = x*x;
+        w = z*z;
+    /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
+        s1 = z*(aT[0]+w*(aT[2]+w*(aT[4]+w*(aT[6]+w*(aT[8]+w*aT[10])))));
+        s2 = w*(aT[1]+w*(aT[3]+w*(aT[5]+w*(aT[7]+w*aT[9]))));
+        if (id<0) return x - x*(s1+s2);
+        else {
+            z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
+            return (hx<0)? -z:z;
+        }
+}
+
+/* Arc tangent from two variables, original. */
+
+static const float
+pi_o_4  = 7.8539818525e-01,  /* 0x3f490fdb */
+pi_o_2  = 1.5707963705e+00,  /* 0x3fc90fdb */
+pi      = 3.1415927410e+00,  /* 0x40490fdb */
+pi_lo   = -8.7422776573e-08; /* 0xb3bbbd2e */
+
+float atan2_wrapper(float y, float x)
+{
+        float z;
+        int32_t k,m,hx,hy,ix,iy;
+
+        GET_FLOAT_WORD(hx,x);
+        ix = hx&0x7fffffff;
+        GET_FLOAT_WORD(hy,y);
+        iy = hy&0x7fffffff;
+        if((ix>0x7f800000)||
+           (iy>0x7f800000))     /* x or y is NaN */
+           return x+y;
+        if(hx==0x3f800000) return atan_wrapper(y);   /* x=1.0 */
+        m = ((hy>>31)&1)|((hx>>30)&2);  /* 2*sign(x)+sign(y) */
+
+    /* when y = 0 */
+        if(iy==0) {
+            switch(m) {
+                case 0:
+                case 1: return y;       /* atan(+-0,+anything)=+-0 */
+                case 2: return  pi+tiny;/* atan(+0,-anything) = pi */
+                case 3: return -pi-tiny;/* atan(-0,-anything) =-pi */
+            }
+        }
+    /* when x = 0 */
+        if(ix==0) return (hy<0)?  -pi_o_2-tiny: pi_o_2+tiny;
+
+    /* when x is INF */
+        if(ix==0x7f800000) {
+            if(iy==0x7f800000) {
+                switch(m) {
+                    case 0: return  pi_o_4+tiny;/* atan(+INF,+INF) */
+                    case 1: return -pi_o_4-tiny;/* atan(-INF,+INF) */
+                    case 2: return  (float)3.0*pi_o_4+tiny;/*atan(+INF,-INF)*/
+                    case 3: return (float)-3.0*pi_o_4-tiny;/*atan(-INF,-INF)*/
+                }
+            } else {
+                switch(m) {
+                    case 0: return  zero  ;     /* atan(+...,+INF) */
+                    case 1: return -zero  ;     /* atan(-...,+INF) */
+                    case 2: return  pi+tiny  ;  /* atan(+...,-INF) */
+                    case 3: return -pi-tiny  ;  /* atan(-...,-INF) */
+                }
+            }
+        }
+    /* when y is INF */
+        if(iy==0x7f800000) return (hy<0)? -pi_o_2-tiny: pi_o_2+tiny;
+
+    /* compute y/x */
+        k = (iy-ix)>>23;
+        if(k > 60) z=pi_o_2+(float)0.5*pi_lo;   /* |y/x| >  2**60 */
+        else if(hx<0&&k<-60) z=0.0;     /* |y|/x < -2**60 */
+        else z=atan_wrapper(fabs_wrapper(y/x));   /* safe to do y/x */
+        switch (m) {
+            case 0: return       z  ;   /* atan(+,+) */
+            case 1: {
+                      uint32_t zh;
+                      GET_FLOAT_WORD(zh,z);
+                      SET_FLOAT_WORD(z,zh ^ 0x80000000);
+                    }
+                    return       z  ;   /* atan(-,+) */
+            case 2: return  pi-(z-pi_lo);/* atan(+,-) */
+            default: /* case 3 */
+                    return  (z-pi_lo)-pi;/* atan(-,-) */
+        }
+}
+
+/* Square root function, original. */
+float sqrt_wrapper(float x)
+{
+        float z;
+        int32_t sign = (int)0x80000000;
+        int32_t ix,s,q,m,t,i;
+        uint32_t r;
+
+        GET_FLOAT_WORD(ix,x);
+
+    /* take care of Inf and NaN */
+        if((ix&0x7f800000)==0x7f800000) {
+            return x*x+x;               /* sqrt(NaN)=NaN, sqrt(+inf)=+inf
+                                           sqrt(-inf)=sNaN */
+        }
+    /* take care of zero */
+        if(ix<=0) {
+            if((ix&(~sign))==0) return x;/* sqrt(+-0) = +-0 */
+            else if(ix<0)
+                return (x-x)/(x-x);             /* sqrt(-ve) = sNaN */
+        }
+    /* normalize x */
+        m = (ix>>23);
+        if(m==0) {                              /* subnormal x */
+            for(i=0;(ix&0x00800000)==0;i++) ix<<=1;
+            m -= i-1;
+        }
+        m -= 127;       /* unbias exponent */
+        ix = (ix&0x007fffff)|0x00800000;
+        if(m&1) /* odd m, double x to make it even */
+            ix += ix;
+        m >>= 1;        /* m = [m/2] */
+
+    /* generate sqrt(x) bit by bit */
+        ix += ix;
+        q = s = 0;              /* q = sqrt(x) */
+        r = 0x01000000;         /* r = moving bit from right to left */
+
+        while(r!=0) {
+            t = s+r;
+            if(t<=ix) {
+                s    = t+r;
+                ix  -= t;
+                q   += r;
+            }
+            ix += ix;
+            r>>=1;
+        }
+
+    /* use floating add to find out rounding direction */
+        if(ix!=0) {
+            z = one-tiny; /* trigger inexact flag */
+            if (z>=one) {
+                z = one+tiny;
+                if (z>one)
+                    q += 2;
+                else
+                    q += (q&1);
+            }
+        }
+        ix = (q>>1)+0x3f000000;
+        ix += (m <<23);
+        SET_FLOAT_WORD(z,ix);
+        return z;
+}
+
+/* @(#)e_acos.c 1.3 95/01/18 */
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+/* __ieee754_acos(x)
+ * Method :
+ *      acos(x)  = pi/2 - asin(x)
+ *      acos(-x) = pi/2 + asin(x)
+ * For |x|<=0.5
+ *      acos(x) = pi/2 - (x + x*x^2*R(x^2))     (see asin.c)
+ * For x>0.5
+ *      acos(x) = pi/2 - (pi/2 - 2asin(sqrt((1-x)/2)))
+ *              = 2asin(sqrt((1-x)/2))
+ *              = 2s + 2s*z*R(z)        ...z=(1-x)/2, s=sqrt(z)
+ *              = 2f + (2c + 2s*z*R(z))
+ *     where f=hi part of s, and c = (z-f*f)/(s+f) is the correction term
+ *     for f so that f+c ~ sqrt(z).
+ * For x<-0.5
+ *      acos(x) = pi - 2asin(sqrt((1-|x|)/2))
+ *              = pi - 0.5*(s+s*z*R(z)), where z=(1-|x|)/2,s=sqrt(z)
+ *
+ * Special cases:
+ *      if x is NaN, return x itself;
+ *      if |x|>1, return NaN with invalid signal.
+ *
+ * Function needed: sqrt
+ */
+
+#ifdef __STDC__
+static const double
+#else
+static double
+#endif
+pio2_hi =  1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */
+pio2_lo =  6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */
+pS0 =  1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
+pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
+pS2 =  2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
+pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
+pS4 =  7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
+pS5 =  3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
+qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
+qS2 =  2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
+qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
+qS4 =  7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
+
+double acos_wrapper(double x)
+{
+        double z,p,q,r,w,s,c,df;
+        int hx,ix;
+        hx = __HI(x);
+        ix = hx&0x7fffffff;
+        if(ix>=0x3ff00000) {    /* |x| >= 1 */
+            if(((ix-0x3ff00000)|__LO(x))==0) {  /* |x|==1 */
+                if(hx>0) return 0.0;            /* acos(1) = 0  */
+                else return pi+2.0*pio2_lo;     /* acos(-1)= pi */
+            }
+            return (x-x)/(x-x);         /* acos(|x|>1) is NaN */
+        }
+        if(ix<0x3fe00000) {     /* |x| < 0.5 */
+            if(ix<=0x3c600000) return pio2_hi+pio2_lo;/*if|x|<2**-57*/
+            z = x*x;
+            p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
+            q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
+            r = p/q;
+            return pio2_hi - (x - (pio2_lo-x*r));
+        } else  if (hx<0) {             /* x < -0.5 */
+            z = (one+x)*0.5;
+            p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
+            q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
+            s = sqrt_wrapper(z);
+            r = p/q;
+            w = r*s-pio2_lo;
+            return pi - 2.0*(s+w);
+        } else {                        /* x > 0.5 */
+            z = (one-x)*0.5;
+            s = sqrt_wrapper(z);
+            df = s;
+            __LO(df) = 0;
+            c  = (z-df*df)/(s+df);
+            p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
+            q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
+            r = p/q;
+            w = r*s+c;
+            return 2.0*(df+w);
+        }
+
+}
+
+/*
+ * Copyright (C) 2004 by egnite Software GmbH. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EGNITE
+ * SOFTWARE GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * For additional information see http://www.ethernut.de/
+ *
+ *-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * $Log$
+ * Revision 1.4  2008/02/15 17:13:01  haraldkipp
+ * Use configurable constant attribute.
+ *
+ * Revision 1.3  2006/10/08 16:48:08  haraldkipp
+ * Documentation fixed
+ *
+ * Revision 1.2  2005/08/02 17:46:47  haraldkipp
+ * Major API documentation update.
+ *
+ * Revision 1.1  2004/09/08 10:23:35  haraldkipp
+ * Generic C stdlib added
+ *
+ */
+
+#define CONST const
+long strtol_wrapper(CONST char *nptr, char **endptr, int base)
+{
+    register CONST char *s;
+    register long acc, cutoff;
+    register int c;
+    register int neg, any, cutlim;
+
+    /*
+     * Skip white space and pick up leading +/- sign if any.
+     * If base is 0, allow 0x for hex and 0 for octal, else
+     * assume decimal; if base is already 16, allow 0x.
+     */
+    s = nptr;
+    do {
+        c = (unsigned char) *s++;
+    } while (isspace(c));
+    if (c == '-') {
+        neg = 1;
+        c = *s++;
+    } else {
+        neg = 0;
+        if (c == '+')
+            c = *s++;
+    }
+    if ((base == 0 || base == 16) && c == '0' && (*s == 'x' || *s == 'X')) {
+        c = s[1];
+        s += 2;
+        base = 16;
+    }
+    if (base == 0)
+        base = c == '0' ? 8 : 10;
+
+    /*
+     * Compute the cutoff value between legal numbers and illegal
+     * numbers.  That is the largest legal value, divided by the
+     * base.  An input number that is greater than this value, if
+     * followed by a legal input character, is too big.  One that
+     * is equal to this value may be valid or not; the limit
+     * between valid and invalid numbers is then based on the last
+     * digit.  For instance, if the range for longs is
+     * [-2147483648..2147483647] and the input base is 10,
+     * cutoff will be set to 214748364 and cutlim to either
+     * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
+     * a value > 214748364, or equal but the next digit is > 7 (or 8),
+     * the number is too big, and we will return a range error.
+     *
+     * Set any if any `digits' consumed; make it negative to indicate
+     * overflow.
+     */
+    cutoff = neg ? LONG_MIN : LONG_MAX;
+    cutlim = cutoff % base;
+    cutoff /= base;
+    if (neg) {
+        if (cutlim > 0) {
+            cutlim -= base;
+            cutoff += 1;
+        }
+        cutlim = -cutlim;
+    }
+    for (acc = 0, any = 0;; c = (unsigned char) *s++) {
+        if (isdigit(c))
+            c -= '0';
+        else if (isalpha(c))
+            c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+        else
+            break;
+        if (c >= base)
+            break;
+        if (any < 0)
+            continue;
+        if (neg) {
+            if ((acc < cutoff || acc == cutoff) && c > cutlim) {
+                any = -1;
+                acc = LONG_MIN;
+            } else {
+                any = 1;
+                acc *= base;
+                acc -= c;
+            }
+        } else {
+            if ((acc > cutoff || acc == cutoff) && c > cutlim) {
+                any = -1;
+                acc = LONG_MAX;
+            } else {
+                any = 1;
+                acc *= base;
+                acc += c;
+            }
+        }
+    }
+    if (endptr != 0)
+        *endptr = (char *) (any ? s - 1 : nptr);
+    return (acc);
+}
+
+int64_t strtoq_wrapper(CONST char *nptr, char **endptr, int base)
+{
+    return strtol(nptr, endptr, base);
+}
+
+uint64_t strtouq_wrapper(CONST char *nptr, char **endptr, int base)
+{
+    return strtol(nptr, endptr, base);
+}
+
+/* Power function, taken from glibc-2.8 and dietlibc-0.32 */
+float pow_wrapper(float x, float y)
+{
+    unsigned int e;
+    float result;
+
+    /* Special cases 0^x */
+    if(x == 0.0f)
+    {
+        if(y > 0.0f)
+            return 0.0f;
+        else if(y == 0.0f)
+            return 1.0f;
+        else
+            return 1.0f / x;
+    }
+
+    /* Special case x^n where n is integer */
+    if(y == (int) (e = (int) y))
+    {
+        if((int) e < 0)
+        {
+            e = -e;
+            x = 1.0f / x;
+        }
+
+        result = 1.0f;
+
+        while(1)
+        {
+            if(e & 1)
+                result *= x;
+
+            if((e >>= 1) == 0)
+                break;
+
+            x *= x;
+        }
+
+        return result;
+    }
+
+    /* Normal case */
+    return rb_exp(rb_log(x) * y);
+}
+
+/* @(#)s_copysign.c 1.3 95/01/18 */
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+/*
+ * copysign(double x, double y)
+ * copysign(x,y) returns a value with the magnitude of x and
+ * with the sign bit of y.
+ */
+
+double copysign_wrapper(double x, double y)
+{
+        __HI(x) = (__HI(x)&0x7fffffff)|(__HI(y)&0x80000000);
+        return x;
+}
+
+/* @(#)s_scalbn.c 1.3 95/01/18 */
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+/*
+ * scalbn (double x, int n)
+ * scalbn(x,n) returns x* 2**n  computed by  exponent
+ * manipulation rather than by actually performing an
+ * exponentiation or a multiplication.
+ */
+
+#ifdef __STDC__
+static const double
+#else
+static double
+#endif
+two54   =  1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
+    twom54  =  5.55111512312578270212e-17; /* 0x3C900000, 0x00000000 */
+
+double scalbn_wrapper (double x, int n)
+{
+        int  k,hx,lx;
+        hx = __HI(x);
+        lx = __LO(x);
+        k = (hx&0x7ff00000)>>20;                /* extract exponent */
+        if (k==0) {                             /* 0 or subnormal x */
+            if ((lx|(hx&0x7fffffff))==0) return x; /* +-0 */
+            x *= two54;
+            hx = __HI(x);
+            k = ((hx&0x7ff00000)>>20) - 54;
+            if (n< -50000) return tiny*x;       /*underflow*/
+            }
+        if (k==0x7ff) return x+x;               /* NaN or Inf */
+        k = k+n;
+        if (k >  0x7fe) return huge*copysign_wrapper(huge,x); /* overflow  */
+        if (k > 0)                              /* normal result */
+            {__HI(x) = (hx&0x800fffff)|(k<<20); return x;}
+        if (k <= -54)
+            if (n > 50000)      /* in case integer overflow in n+k */
+                return huge*copysign_wrapper(huge,x);   /*overflow*/
+            else return tiny*copysign_wrapper(tiny,x);  /*underflow*/
+        k += 54;                                /* subnormal result */
+        __HI(x) = (hx&0x800fffff)|(k<<20);
+        return x*twom54;
+}
+
+/* horrible hack */
+float ceil_wrapper(float x)
+{
+    return floor_wrapper(x) + 1.0;
+}
+
+/* Implementation of strtod() and atof(),
+   taken from SanOS (http://www.jbox.dk/sanos/). */
+static int rb_errno = 0;
+
+static double rb_strtod(const char *str, char **endptr)
+{
+  double number;
+  int exponent;
+  int negative;
+  char *p = (char *) str;
+  double p10;
+  int n;
+  int num_digits;
+  int num_decimals;
+
+    /* Reset Rockbox errno -- W.B. */
+#ifdef ROCKBOX
+    rb_errno = 0;
+#endif
+
+  // Skip leading whitespace
+  while (isspace(*p)) p++;
+
+  // Handle optional sign
+  negative = 0;
+  switch (*p)
+  {
+    case '-': negative = 1; // Fall through to increment position
+    case '+': p++;
+  }
+
+  number = 0.;
+  exponent = 0;
+  num_digits = 0;
+  num_decimals = 0;
+
+  // Process string of digits
+  while (isdigit(*p))
+  {
+    number = number * 10. + (*p - '0');
+    p++;
+    num_digits++;
+  }
+
+  // Process decimal part
+  if (*p == '.')
+  {
+    p++;
+
+    while (isdigit(*p))
+    {
+      number = number * 10. + (*p - '0');
+      p++;
+      num_digits++;
+      num_decimals++;
+    }
+
+    exponent -= num_decimals;
+  }
+
+  if (num_digits == 0)
+  {
+#ifdef ROCKBOX
+    rb_errno = 1;
+#else
+    errno = ERANGE;
+#endif
+    return 0.0;
+  }
+
+  // Correct for sign
+  if (negative) number = -number;
+
+  // Process an exponent string
+  if (*p == 'e' || *p == 'E')
+  {
+    // Handle optional sign
+    negative = 0;
+    switch(*++p)
+    {
+      case '-': negative = 1;   // Fall through to increment pos
+      case '+': p++;
+    }
+
+    // Process string of digits
+    n = 0;
+    while (isdigit(*p))
+    {
+      n = n * 10 + (*p - '0');
+      p++;
+    }
+
+    if (negative)
+      exponent -= n;
+    else
+      exponent += n;
+  }
+
+#ifndef ROCKBOX
+  if (exponent < DBL_MIN_EXP  || exponent > DBL_MAX_EXP)
+  {
+    errno = ERANGE;
+    return HUGE_VAL;
+  }
+#endif
+
+  // Scale the result
+  p10 = 10.;
+  n = exponent;
+  if (n < 0) n = -n;
+  while (n)
+  {
+    if (n & 1)
+    {
+      if (exponent < 0)
+        number /= p10;
+      else
+        number *= p10;
+    }
+    n >>= 1;
+    p10 *= p10;
+  }
+
+#ifndef ROCKBOX
+  if (number == HUGE_VAL) errno = ERANGE;
+#endif
+  if (endptr) *endptr = p;
+
+  return number;
+}
+
+double atof_wrapper(const char *str)
+{
+    return rb_strtod(str, NULL);
+}
+
+/*
+ * Copyright (c) 2004 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/*-
+ * Copyright (c) 1990, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "rbcompat.h"
+
+#define BUF             32      /* Maximum length of numeric string. */
+
+/*
+ * Flags used during conversion.
+ */
+#define LONG            0x01    /* l: long or double */
+#define SHORT           0x04    /* h: short */
+#define SUPPRESS        0x08    /* *: suppress assignment */
+#define POINTER         0x10    /* p: void * (as hex) */
+#define NOSKIP          0x20    /* [ or c: do not skip blanks */
+#define LONGLONG        0x400   /* ll: long long (+ deprecated q: quad) */
+#define SHORTSHORT      0x4000  /* hh: char */
+#define UNSIGNED        0x8000  /* %[oupxX] conversions */
+
+/*
+ * The following are used in numeric conversions only:
+ * SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;
+ * SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.
+ */
+#define SIGNOK          0x40    /* +/- is (still) legal */
+#define NDIGITS         0x80    /* no digits detected */
+
+#define DPTOK           0x100   /* (float) decimal point is still legal */
+#define EXPOK           0x200   /* (float) exponent (e+3, etc) still legal */
+
+#define PFXOK           0x100   /* 0x prefix is (still) legal */
+#define NZDIGITS        0x200   /* no zero digits detected */
+
+/*
+ * Conversion types.
+ */
+#define CT_CHAR         0       /* %c conversion */
+#define CT_CCL          1       /* %[...] conversion */
+#define CT_STRING       2       /* %s conversion */
+#define CT_INT          3       /* %[dioupxX] conversion */
+
+typedef unsigned char u_char;
+typedef uint64_t      u_quad_t;
+
+static const u_char *__sccl(char *, const u_char *);
+
+void bcopy(const void *src, void *dst, size_t n)
+{
+    memmove(dst, src, n);
+}
+
+int
+sscanf_wrapper(const char *ibuf, const char *fmt, ...)
+{
+        va_list ap;
+        int ret;
+
+        va_start(ap, fmt);
+        ret = vsscanf(ibuf, fmt, ap);
+        va_end(ap);
+        return(ret);
+}
+
+int
+vsscanf(const char *inp, char const *fmt0, va_list ap)
+{
+        int inr;
+        const u_char *fmt = (const u_char *)fmt0;
+        int c;                  /* character from format, or conversion */
+        size_t width;           /* field width, or 0 */
+        char *p;                /* points into all kinds of strings */
+        int n;                  /* handy integer */
+        int flags;              /* flags as defined above */
+        char *p0;               /* saves original value of p when necessary */
+        int nassigned;          /* number of fields assigned */
+        int nconversions;       /* number of conversions */
+        int nread;              /* number of characters consumed from fp */
+        int base;               /* base argument to conversion function */
+        char ccltab[256];       /* character class table for %[...] */
+        char buf[BUF];          /* buffer for numeric conversions */
+
+        /* `basefix' is used to avoid `if' tests in the integer scanner */
+        static short basefix[17] =
+                { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
+
+        inr = strlen(inp);
+
+        nassigned = 0;
+        nconversions = 0;
+        nread = 0;
+        base = 0;               /* XXX just to keep gcc happy */
+        for (;;) {
+                c = *fmt++;
+                if (c == 0)
+                        return (nassigned);
+                if (isspace(c)) {
+                        while (inr > 0 && isspace(*inp))
+                                nread++, inr--, inp++;
+                        continue;
+                }
+                if (c != '%')
+                        goto literal;
+                width = 0;
+                flags = 0;
+                /*
+                 * switch on the format.  continue if done;
+                 * break once format type is derived.
+                 */
+again:          c = *fmt++;
+                switch (c) {
+                case '%':
+literal:
+                        if (inr <= 0)
+                                goto input_failure;
+                        if (*inp != c)
+                                goto match_failure;
+                        inr--, inp++;
+                        nread++;
+                        continue;
+
+                case '*':
+                        flags |= SUPPRESS;
+                        goto again;
+                case 'l':
+                        if (flags & LONG) {
+                                flags &= ~LONG;
+                                flags |= LONGLONG;
+                        } else
+                                flags |= LONG;
+                        goto again;
+                case 'q':
+                        flags |= LONGLONG;      /* not quite */
+                        goto again;
+                case 'h':
+                        if (flags & SHORT) {
+                                flags &= ~SHORT;
+                                flags |= SHORTSHORT;
+                        } else
+                                flags |= SHORT;
+                        goto again;
+
+                case '0': case '1': case '2': case '3': case '4':
+                case '5': case '6': case '7': case '8': case '9':
+                        width = width * 10 + c - '0';
+                        goto again;
+
+                /*
+                 * Conversions.
+                 */
+                case 'd':
+                        c = CT_INT;
+                        base = 10;
+                        break;
+
+                case 'i':
+                        c = CT_INT;
+                        base = 0;
+                        break;
+
+                case 'o':
+                        c = CT_INT;
+                        flags |= UNSIGNED;
+                        base = 8;
+                        break;
+
+                case 'u':
+                        c = CT_INT;
+                        flags |= UNSIGNED;
+                        base = 10;
+                        break;
+
+                case 'X':
+                case 'x':
+                        flags |= PFXOK; /* enable 0x prefixing */
+                        c = CT_INT;
+                        flags |= UNSIGNED;
+                        base = 16;
+                        break;
+
+                case 's':
+                        c = CT_STRING;
+                        break;
+
+                case '[':
+                        fmt = __sccl(ccltab, fmt);
+                        flags |= NOSKIP;
+                        c = CT_CCL;
+                        break;
+
+                case 'c':
+                        flags |= NOSKIP;
+                        c = CT_CHAR;
+                        break;
+
+                case 'p':       /* pointer format is like hex */
+                        flags |= POINTER | PFXOK;
+                        c = CT_INT;
+                        flags |= UNSIGNED;
+                        base = 16;
+                        break;
+
+                case 'n':
+                        nconversions++;
+                        if (flags & SUPPRESS)   /* ??? */
+                                continue;
+                        if (flags & SHORTSHORT)
+                                *va_arg(ap, char *) = nread;
+                        else if (flags & SHORT)
+                                *va_arg(ap, short *) = nread;
+                        else if (flags & LONG)
+                                *va_arg(ap, long *) = nread;
+                        else if (flags & LONGLONG)
+                                *va_arg(ap, long long *) = nread;
+                        else
+                                *va_arg(ap, int *) = nread;
+                        continue;
+                }
+
+                /*
+                 * We have a conversion that requires input.
+                 */
+                if (inr <= 0)
+                        goto input_failure;
+
+                /*
+                 * Consume leading white space, except for formats
+                 * that suppress this.
+                 */
+                if ((flags & NOSKIP) == 0) {
+                        while (isspace(*inp)) {
+                                nread++;
+                                if (--inr > 0)
+                                        inp++;
+                                else
+                                        goto input_failure;
+                        }
+                        /*
+                         * Note that there is at least one character in
+                         * the buffer, so conversions that do not set NOSKIP
+                         * can no longer result in an input failure.
+                         */
+                }
+
+                /*
+                 * Do the conversion.
+                 */
+                switch (c) {
+
+                case CT_CHAR:
+                        /* scan arbitrary characters (sets NOSKIP) */
+                        if (width == 0)
+                                width = 1;
+                        if (flags & SUPPRESS) {
+                                size_t sum = 0;
+                                for (;;) {
+                                        if ((n = inr) < (int)width) {
+                                                sum += n;
+                                                width -= n;
+                                                inp += n;
+                                                if (sum == 0)
+                                                        goto input_failure;
+                                                break;
+                                        } else {
+                                                sum += width;
+                                                inr -= width;
+                                                inp += width;
+                                                break;
+                                        }
+                                }
+                                nread += sum;
+                        } else {
+                                bcopy(inp, va_arg(ap, char *), width);
+                                inr -= width;
+                                inp += width;
+                                nread += width;
+                                nassigned++;
+                        }
+                        nconversions++;
+                        break;
+
+                case CT_CCL:
+                        /* scan a (nonempty) character class (sets NOSKIP) */
+                        if (width == 0)
+                                width = (size_t)~0;     /* `infinity' */
+                        /* take only those things in the class */
+                        if (flags & SUPPRESS) {
+                                n = 0;
+                                while (ccltab[(unsigned char)*inp]) {
+                                        n++, inr--, inp++;
+                                        if (--width == 0)
+                                                break;
+                                        if (inr <= 0) {
+                                                if (n == 0)
+                                                        goto input_failure;
+                                                break;
+                                        }
+                                }
+                                if (n == 0)
+                                        goto match_failure;
+                        } else {
+                                p0 = p = va_arg(ap, char *);
+                                while (ccltab[(unsigned char)*inp]) {
+                                        inr--;
+                                        *p++ = *inp++;
+                                        if (--width == 0)
+                                                break;
+                                        if (inr <= 0) {
+                                                if (p == p0)
+                                                        goto input_failure;
+                                                break;
+                                        }
+                                }
+                                n = p - p0;
+                                if (n == 0)
+                                        goto match_failure;
+                                *p = 0;
+                                nassigned++;
+                        }
+                        nread += n;
+                        nconversions++;
+                        break;
+
+                case CT_STRING:
+                        /* like CCL, but zero-length string OK, & no NOSKIP */
+                        if (width == 0)
+                                width = (size_t)~0;
+                        if (flags & SUPPRESS) {
+                                n = 0;
+                                while (!isspace(*inp)) {
+                                        n++, inr--, inp++;
+                                        if (--width == 0)
+                                                break;
+                                        if (inr <= 0)
+                                                break;
+                                }
+                                nread += n;
+                        } else {
+                                p0 = p = va_arg(ap, char *);
+                                while (!isspace(*inp)) {
+                                        inr--;
+                                        *p++ = *inp++;
+                                        if (--width == 0)
+                                                break;
+                                        if (inr <= 0)
+                                                break;
+                                }
+                                *p = 0;
+                                nread += p - p0;
+                                nassigned++;
+                        }
+                        nconversions++;
+                        continue;
+
+                case CT_INT:
+                        /* scan an integer as if by the conversion function */
+#ifdef hardway
+                        if (width == 0 || width > sizeof(buf) - 1)
+                                width = sizeof(buf) - 1;
+#else
+                        /* size_t is unsigned, hence this optimisation */
+                        if (--width > sizeof(buf) - 2)
+                                width = sizeof(buf) - 2;
+                        width++;
+#endif
+                        flags |= SIGNOK | NDIGITS | NZDIGITS;
+                        for (p = buf; width; width--) {
+                                c = *inp;
+                                /*
+                                 * Switch on the character; `goto ok'
+                                 * if we accept it as a part of number.
+                                 */
+                                switch (c) {
+
+                                /*
+                                 * The digit 0 is always legal, but is
+                                 * special.  For %i conversions, if no
+                                 * digits (zero or nonzero) have been
+                                 * scanned (only signs), we will have
+                                 * base==0.  In that case, we should set
+                                 * it to 8 and enable 0x prefixing.
+                                 * Also, if we have not scanned zero digits
+                                 * before this, do not turn off prefixing
+                                 * (someone else will turn it off if we
+                                 * have scanned any nonzero digits).
+                                 */
+                                case '0':
+                                        if (base == 0) {
+                                                base = 8;
+                                                flags |= PFXOK;
+                                        }
+                                        if (flags & NZDIGITS)
+                                            flags &= ~(SIGNOK|NZDIGITS|NDIGITS);
+                                        else
+                                            flags &= ~(SIGNOK|PFXOK|NDIGITS);
+                                        goto ok;
+
+                                /* 1 through 7 always legal */
+                                case '1': case '2': case '3':
+                                case '4': case '5': case '6': case '7':
+                                        base = basefix[base];
+                                        flags &= ~(SIGNOK | PFXOK | NDIGITS);
+                                        goto ok;
+
+                                /* digits 8 and 9 ok iff decimal or hex */
+                                case '8': case '9':
+                                        base = basefix[base];
+                                        if (base <= 8)
+                                                break;  /* not legal here */
+                                        flags &= ~(SIGNOK | PFXOK | NDIGITS);
+                                        goto ok;
+
+                                /* letters ok iff hex */
+                                case 'A': case 'B': case 'C':
+                                case 'D': case 'E': case 'F':
+                                case 'a': case 'b': case 'c':
+                                case 'd': case 'e': case 'f':
+                                        /* no need to fix base here */
+                                        if (base <= 10)
+                                                break;  /* not legal here */
+                                        flags &= ~(SIGNOK | PFXOK | NDIGITS);
+                                        goto ok;
+
+                                /* sign ok only as first character */
+                                case '+': case '-':
+                                        if (flags & SIGNOK) {
+                                                flags &= ~SIGNOK;
+                                                goto ok;
+                                        }
+                                        break;
+
+                                /* x ok iff flag still set & 2nd char */
+                                case 'x': case 'X':
+                                        if (flags & PFXOK && p == buf + 1) {
+                                                base = 16;      /* if %i */
+                                                flags &= ~PFXOK;
+                                                goto ok;
+                                        }
+                                        break;
+                                }
+
+                                /*
+                                 * If we got here, c is not a legal character
+                                 * for a number.  Stop accumulating digits.
+                                 */
+                                break;
+                ok:
+                                /*
+                                 * c is legal: store it and look at the next.
+                                 */
+                                *p++ = c;
+                                if (--inr > 0)
+                                        inp++;
+                                else
+                                        break;          /* end of input */
+                        }
+                        /*
+                         * If we had only a sign, it is no good; push
+                         * back the sign.  If the number ends in `x',
+                         * it was [sign] '0' 'x', so push back the x
+                         * and treat it as [sign] '0'.
+                         */
+                        if (flags & NDIGITS) {
+                                if (p > buf) {
+                                        inp--;
+                                        inr++;
+                                }
+                                goto match_failure;
+                        }
+                        c = ((u_char *)p)[-1];
+                        if (c == 'x' || c == 'X') {
+                                --p;
+                                inp--;
+                                inr++;
+                        }
+                        if ((flags & SUPPRESS) == 0) {
+                                u_quad_t res;
+
+                                *p = 0;
+                                if ((flags & UNSIGNED) == 0)
+                                    res = strtoq(buf, (char **)NULL, base);
+                                else
+                                    res = strtouq(buf, (char **)NULL, base);
+                                if (flags & POINTER)
+                                        *va_arg(ap, void **) =
+                                                (void *)(uintptr_t)res;
+                                else if (flags & SHORTSHORT)
+                                        *va_arg(ap, char *) = res;
+                                else if (flags & SHORT)
+                                        *va_arg(ap, short *) = res;
+                                else if (flags & LONG)
+                                        *va_arg(ap, long *) = res;
+                                else if (flags & LONGLONG)
+                                        *va_arg(ap, long long *) = res;
+                                else
+                                        *va_arg(ap, int *) = res;
+                                nassigned++;
+                        }
+                        nread += p - buf;
+                        nconversions++;
+                        break;
+
+                }
+        }
+input_failure:
+        return (nconversions != 0 ? nassigned : -1);
+match_failure:
+        return (nassigned);
+}
+
+/*
+ * Fill in the given table from the scanset at the given format
+ * (just after `[').  Return a pointer to the character past the
+ * closing `]'.  The table has a 1 wherever characters should be
+ * considered part of the scanset.
+ */
+static const u_char *
+__sccl(char *tab, const u_char *fmt)
+{
+        int c, n, v;
+
+        /* first `clear' the whole table */
+        c = *fmt++;             /* first char hat => negated scanset */
+        if (c == '^') {
+                v = 1;          /* default => accept */
+                c = *fmt++;     /* get new first char */
+        } else
+                v = 0;          /* default => reject */
+
+        /* XXX: Will not work if sizeof(tab*) > sizeof(char) */
+        (void) memset(tab, v, 256);
+
+        if (c == 0)
+                return (fmt - 1);/* format ended before closing ] */
+
+        /*
+         * Now set the entries corresponding to the actual scanset
+         * to the opposite of the above.
+         *
+         * The first character may be ']' (or '-') without being special;
+         * the last character may be '-'.
+         */
+        v = 1 - v;
+        for (;;) {
+                tab[c] = v;             /* take character c */
+doswitch:
+                n = *fmt++;             /* and examine the next */
+                switch (n) {
+
+                case 0:                 /* format ended too soon */
+                        return (fmt - 1);
+
+                case '-':
+                        /*
+                         * A scanset of the form
+                         *      [01+-]
+                         * is defined as `the digit 0, the digit 1,
+                         * the character +, the character -', but
+                         * the effect of a scanset such as
+                         *      [a-zA-Z0-9]
+                         * is implementation defined.  The V7 Unix
+                         * scanf treats `a-z' as `the letters a through
+                         * z', but treats `a-a' as `the letter a, the
+                         * character -, and the letter a'.
+                         *
+                         * For compatibility, the `-' is not considerd
+                         * to define a range if the character following
+                         * it is either a close bracket (required by ANSI)
+                         * or is not numerically greater than the character
+                         * we just stored in the table (c).
+                         */
+                        n = *fmt;
+                        if (n == ']' || n < c) {
+                                c = '-';
+                                break;  /* resume the for(;;) */
+                        }
+                        fmt++;
+                        /* fill in the range */
+                        do {
+                            tab[++c] = v;
+                        } while (c < n);
+                        c = n;
+                        /*
+                         * Alas, the V7 Unix scanf also treats formats
+                         * such as [a-c-e] as `the letters a through e'.
+                         * This too is permitted by the standard....
+                         */
+                        goto doswitch;
+                        break;
+
+                case ']':               /* end of scanset */
+                        return (fmt);
+
+                default:                /* just another character */
+                        c = n;
+                        break;
+                }
+        }
+        /* NOTREACHED */
+}
+
+/*
+ * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * The contents of this file constitute Original Code as defined in and
+ * are subject to the Apple Public Source License Version 1.1 (the
+ * "License").  You may not use this file except in compliance with the
+ * License.  Please obtain a copy of the License at
+ * http://www.apple.com/publicsource and read it before using this file.
+ *
+ * This Original Code and all software distributed under the License are
+ * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
+ * License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+/*
+ * Copyright (c) 1990, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "plugin.h"
+
+/*
+ * Span the complement of string s2.
+ */
+size_t
+strcspn_wrapper(const char *s1, const char *s2)
+{
+        register const char *p, *spanp;
+        register char c, sc;
+
+        /*
+         * Stop as soon as we find any character from s2.  Note that there
+         * must be a NUL in s2; it suffices to stop when we find that, too.
+         */
+        for (p = s1;;) {
+                c = *p++;
+                spanp = s2;
+                do {
+                        if ((sc = *spanp++) == c)
+                                return (p - 1 - s1);
+                } while (sc != 0);
+        }
+        /* NOTREACHED */
+}
+
+/*
+ * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * The contents of this file constitute Original Code as defined in and
+ * are subject to the Apple Public Source License Version 1.1 (the
+ * "License").  You may not use this file except in compliance with the
+ * License.  Please obtain a copy of the License at
+ * http://www.apple.com/publicsource and read it before using this file.
+ *
+ * This Original Code and all software distributed under the License are
+ * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
+ * License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+/*
+ * Copyright (c) 1989, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "rbcompat.h"
+
+/*
+ * Span the string s2 (skip characters that are in s2).
+ */
+size_t
+strspn_wrapper(const char *s1, const char *s2)
+{
+        register const char *p = s1, *spanp;
+        register char c, sc;
+
+        /*
+         * Skip any characters in s2, excluding the terminating \0.
+         */
+cont:
+        c = *p++;
+        for (spanp = s2; (sc = *spanp++) != 0;)
+                if (sc == c)
+                        goto cont;
+        return (p - 1 - s1);
+}
diff --git a/apps/plugins/puzzles/rect.R b/apps/plugins/puzzles/rect.R
new file mode 100644
index 0000000000..1448c0fa63
--- /dev/null
+++ b/apps/plugins/puzzles/rect.R
@@ -0,0 +1,19 @@
+# -*- makefile -*-
+
+rect     : [X] GTK COMMON rect rect-icon|no-icon
+
+rect     : [G] WINDOWS COMMON rect rect.res|noicon.res
+
+ALL += rect[COMBINED]
+
+!begin am gtk
+GAMES += rect
+!end
+
+!begin >list.c
+    A(rect) \
+!end
+
+!begin >gamedesc.txt
+rect:rect.exe:Rectangles:Rectangles puzzle:Divide the grid into rectangles with areas equal to the numbers.
+!end
diff --git a/apps/plugins/puzzles/rect.c b/apps/plugins/puzzles/rect.c
new file mode 100644
index 0000000000..ca3cb984ea
--- /dev/null
+++ b/apps/plugins/puzzles/rect.c
@@ -0,0 +1,3000 @@
+/*
+ * rect.c: Puzzle from nikoli.co.jp. You have a square grid with
+ * numbers in some squares; you must divide the square grid up into
+ * variously sized rectangles, such that every rectangle contains
+ * exactly one numbered square and the area of each rectangle is
+ * equal to the number contained in it.
+ */
+
+/*
+ * TODO:
+ * 
+ *  - Improve singleton removal.
+ *     + It would be nice to limit the size of the generated
+ *       rectangles in accordance with existing constraints such as
+ *       the maximum rectangle size and the one about not
+ *       generating a rectangle the full width or height of the
+ *       grid.
+ *     + This could be achieved by making a less random choice
+ *       about which of the available options to use.
+ *     + Alternatively, we could create our rectangle and then
+ *       split it up.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+enum {
+    COL_BACKGROUND,
+    COL_CORRECT,
+    COL_LINE,
+    COL_TEXT,
+    COL_GRID,
+    COL_DRAG, COL_DRAGERASE,
+    COL_CURSOR,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h;
+    float expandfactor;
+    int unique;
+};
+
+#define INDEX(state, x, y)    (((y) * (state)->w) + (x))
+#define index(state, a, x, y) ((a) [ INDEX(state,x,y) ])
+#define grid(state,x,y)       index(state, (state)->grid, x, y)
+#define vedge(state,x,y)      index(state, (state)->vedge, x, y)
+#define hedge(state,x,y)      index(state, (state)->hedge, x, y)
+
+#define CRANGE(state,x,y,dx,dy) ( (x) >= dx && (x) < (state)->w && \
+                                (y) >= dy && (y) < (state)->h )
+#define RANGE(state,x,y)  CRANGE(state,x,y,0,0)
+#define HRANGE(state,x,y) CRANGE(state,x,y,0,1)
+#define VRANGE(state,x,y) CRANGE(state,x,y,1,0)
+
+#define PREFERRED_TILE_SIZE 24
+#define TILE_SIZE (ds->tilesize)
+#ifdef SMALL_SCREEN
+#define BORDER (2)
+#else
+#define BORDER (TILE_SIZE * 3 / 4)
+#endif
+
+#define CORNER_TOLERANCE 0.15F
+#define CENTRE_TOLERANCE 0.15F
+
+#define FLASH_TIME 0.13F
+
+#define COORD(x) ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x) ( ((x) - BORDER) / TILE_SIZE )
+
+struct game_state {
+    int w, h;
+    int *grid;                         /* contains the numbers */
+    unsigned char *vedge;              /* (w+1) x h */
+    unsigned char *hedge;              /* w x (h+1) */
+    int completed, cheated;
+    unsigned char *correct;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 7;
+    ret->expandfactor = 0.0F;
+    ret->unique = TRUE;
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    int w, h;
+    char buf[80];
+
+    switch (i) {
+      case 0: w = 7, h = 7; break;
+      case 1: w = 9, h = 9; break;
+      case 2: w = 11, h = 11; break;
+      case 3: w = 13, h = 13; break;
+      case 4: w = 15, h = 15; break;
+#ifndef SMALL_SCREEN
+      case 5: w = 17, h = 17; break;
+      case 6: w = 19, h = 19; break;
+#endif
+      default: return FALSE;
+    }
+
+    sprintf(buf, "%dx%d", w, h);
+    *name = dupstr(buf);
+    *params = ret = snew(game_params);
+    ret->w = w;
+    ret->h = h;
+    ret->expandfactor = 0.0F;
+    ret->unique = TRUE;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        ret->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 'e') {
+        string++;
+        ret->expandfactor = (float)atof(string);
+        while (*string &&
+               (*string == '.' || isdigit((unsigned char)*string))) string++;
+    }
+    if (*string == 'a') {
+        string++;
+        ret->unique = FALSE;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    sprintf(data, "%dx%d", params->w, params->h);
+    if (full && params->expandfactor)
+        sprintf(data + strlen(data), "e%g", params->expandfactor);
+    if (full && !params->unique)
+        strcat(data, "a");
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(5, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Expansion factor";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%g", params->expandfactor);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = "Ensure unique solution";
+    ret[3].type = C_BOOLEAN;
+    ret[3].sval = NULL;
+    ret[3].ival = params->unique;
+
+    ret[4].name = NULL;
+    ret[4].type = C_END;
+    ret[4].sval = NULL;
+    ret[4].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->expandfactor = (float)atof(cfg[2].sval);
+    ret->unique = cfg[3].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w <= 0 || params->h <= 0)
+        return "Width and height must both be greater than zero";
+    if (params->w*params->h < 2)
+        return "Grid area must be greater than one";
+    if (params->expandfactor < 0.0F)
+        return "Expansion factor may not be negative";
+    return NULL;
+}
+
+struct point {
+    int x, y;
+};
+
+struct rect {
+    int x, y;
+    int w, h;
+};
+
+struct rectlist {
+    struct rect *rects;
+    int n;
+};
+
+struct numberdata {
+    int area;
+    int npoints;
+    struct point *points;
+};
+
+/* ----------------------------------------------------------------------
+ * Solver for Rectangles games.
+ * 
+ * This solver is souped up beyond the needs of actually _solving_
+ * a puzzle. It is also designed to cope with uncertainty about
+ * where the numbers have been placed. This is because I run it on
+ * my generated grids _before_ placing the numbers, and have it
+ * tell me where I need to place the numbers to ensure a unique
+ * solution.
+ */
+
+static void remove_rect_placement(int w, int h,
+                                  struct rectlist *rectpositions,
+                                  int *overlaps,
+                                  int rectnum, int placement)
+{
+    int x, y, xx, yy;
+
+#ifdef SOLVER_DIAGNOSTICS
+    printf("ruling out rect %d placement at %d,%d w=%d h=%d\n", rectnum,
+           rectpositions[rectnum].rects[placement].x,
+           rectpositions[rectnum].rects[placement].y,
+           rectpositions[rectnum].rects[placement].w,
+           rectpositions[rectnum].rects[placement].h);
+#endif
+
+    /*
+     * Decrement each entry in the overlaps array to reflect the
+     * removal of this rectangle placement.
+     */
+    for (yy = 0; yy < rectpositions[rectnum].rects[placement].h; yy++) {
+        y = yy + rectpositions[rectnum].rects[placement].y;
+        for (xx = 0; xx < rectpositions[rectnum].rects[placement].w; xx++) {
+            x = xx + rectpositions[rectnum].rects[placement].x;
+
+            assert(overlaps[(rectnum * h + y) * w + x] != 0);
+
+            if (overlaps[(rectnum * h + y) * w + x] > 0)
+                overlaps[(rectnum * h + y) * w + x]--;
+        }
+    }
+
+    /*
+     * Remove the placement from the list of positions for that
+     * rectangle, by interchanging it with the one on the end.
+     */
+    if (placement < rectpositions[rectnum].n - 1) {
+        struct rect t;
+
+        t = rectpositions[rectnum].rects[rectpositions[rectnum].n - 1];
+        rectpositions[rectnum].rects[rectpositions[rectnum].n - 1] =
+            rectpositions[rectnum].rects[placement];
+        rectpositions[rectnum].rects[placement] = t;
+    }
+    rectpositions[rectnum].n--;
+}
+
+static void remove_number_placement(int w, int h, struct numberdata *number,
+                                    int index, int *rectbyplace)
+{
+    /*
+     * Remove the entry from the rectbyplace array.
+     */
+    rectbyplace[number->points[index].y * w + number->points[index].x] = -1;
+
+    /*
+     * Remove the placement from the list of candidates for that
+     * number, by interchanging it with the one on the end.
+     */
+    if (index < number->npoints - 1) {
+        struct point t;
+
+        t = number->points[number->npoints - 1];
+        number->points[number->npoints - 1] = number->points[index];
+        number->points[index] = t;
+    }
+    number->npoints--;
+}
+
+/*
+ * Returns 0 for failure to solve due to inconsistency; 1 for
+ * success; 2 for failure to complete a solution due to either
+ * ambiguity or it being too difficult.
+ */
+static int rect_solver(int w, int h, int nrects, struct numberdata *numbers,
+                       unsigned char *hedge, unsigned char *vedge,
+                       random_state *rs)
+{
+    struct rectlist *rectpositions;
+    int *overlaps, *rectbyplace, *workspace;
+    int i, ret;
+
+    /*
+     * Start by setting up a list of candidate positions for each
+     * rectangle.
+     */
+    rectpositions = snewn(nrects, struct rectlist);
+    for (i = 0; i < nrects; i++) {
+        int rw, rh, area = numbers[i].area;
+        int j, minx, miny, maxx, maxy;
+        struct rect *rlist;
+        int rlistn, rlistsize;
+
+        /*
+         * For each rectangle, begin by finding the bounding
+         * rectangle of its candidate number placements.
+         */
+        maxx = maxy = -1;
+        minx = w;
+        miny = h;
+        for (j = 0; j < numbers[i].npoints; j++) {
+            if (minx > numbers[i].points[j].x) minx = numbers[i].points[j].x;
+            if (miny > numbers[i].points[j].y) miny = numbers[i].points[j].y;
+            if (maxx < numbers[i].points[j].x) maxx = numbers[i].points[j].x;
+            if (maxy < numbers[i].points[j].y) maxy = numbers[i].points[j].y;
+        }
+
+        /*
+         * Now loop over all possible rectangle placements
+         * overlapping a point within that bounding rectangle;
+         * ensure each one actually contains a candidate number
+         * placement, and add it to the list.
+         */
+        rlist = NULL;
+        rlistn = rlistsize = 0;
+
+        for (rw = 1; rw <= area && rw <= w; rw++) {
+            int x, y;
+
+            if (area % rw)
+                continue;
+            rh = area / rw;
+            if (rh > h)
+                continue;
+
+            for (y = miny - rh + 1; y <= maxy; y++) {
+                if (y < 0 || y+rh > h)
+                    continue;
+
+                for (x = minx - rw + 1; x <= maxx; x++) {
+                    if (x < 0 || x+rw > w)
+                        continue;
+
+                    /*
+                     * See if we can find a candidate number
+                     * placement within this rectangle.
+                     */
+                    for (j = 0; j < numbers[i].npoints; j++)
+                        if (numbers[i].points[j].x >= x &&
+                            numbers[i].points[j].x < x+rw &&
+                            numbers[i].points[j].y >= y &&
+                            numbers[i].points[j].y < y+rh)
+                            break;
+
+                    if (j < numbers[i].npoints) {
+                        /*
+                         * Add this to the list of candidate
+                         * placements for this rectangle.
+                         */
+                        if (rlistn >= rlistsize) {
+                            rlistsize = rlistn + 32;
+                            rlist = sresize(rlist, rlistsize, struct rect);
+                        }
+                        rlist[rlistn].x = x;
+                        rlist[rlistn].y = y;
+                        rlist[rlistn].w = rw;
+                        rlist[rlistn].h = rh;
+#ifdef SOLVER_DIAGNOSTICS
+                        printf("rect %d [area %d]: candidate position at"
+                               " %d,%d w=%d h=%d\n",
+                               i, area, x, y, rw, rh);
+#endif
+                        rlistn++;
+                    }
+                }
+            }
+        }
+
+        rectpositions[i].rects = rlist;
+        rectpositions[i].n = rlistn;
+    }
+
+    /*
+     * Next, construct a multidimensional array tracking how many
+     * candidate positions for each rectangle overlap each square.
+     * 
+     * Indexing of this array is by the formula
+     * 
+     *   overlaps[(rectindex * h + y) * w + x]
+     * 
+     * A positive or zero value indicates what it sounds as if it
+     * should; -1 indicates that this square _cannot_ be part of
+     * this rectangle; and -2 indicates that it _definitely_ is
+     * (which is distinct from 1, because one might very well know
+     * that _if_ square S is part of rectangle R then it must be
+     * because R is placed in a certain position without knowing
+     * that it definitely _is_).
+     */
+    overlaps = snewn(nrects * w * h, int);
+    memset(overlaps, 0, nrects * w * h * sizeof(int));
+    for (i = 0; i < nrects; i++) {
+        int j;
+
+        for (j = 0; j < rectpositions[i].n; j++) {
+            int xx, yy;
+
+            for (yy = 0; yy < rectpositions[i].rects[j].h; yy++)
+                for (xx = 0; xx < rectpositions[i].rects[j].w; xx++)
+                    overlaps[(i * h + yy+rectpositions[i].rects[j].y) * w +
+                             xx+rectpositions[i].rects[j].x]++;
+        }
+    }
+
+    /*
+     * Also we want an array covering the grid once, to make it
+     * easy to figure out which squares are candidate number
+     * placements for which rectangles. (The existence of this
+     * single array assumes that no square starts off as a
+     * candidate number placement for more than one rectangle. This
+     * assumption is justified, because this solver is _either_
+     * used to solve real problems - in which case there is a
+     * single placement for every number - _or_ used to decide on
+     * number placements for a new puzzle, in which case each
+     * number's placements are confined to the intended position of
+     * the rectangle containing that number.)
+     */
+    rectbyplace = snewn(w * h, int);
+    for (i = 0; i < w*h; i++)
+        rectbyplace[i] = -1;
+
+    for (i = 0; i < nrects; i++) {
+        int j;
+
+        for (j = 0; j < numbers[i].npoints; j++) {
+            int x = numbers[i].points[j].x;
+            int y = numbers[i].points[j].y;
+
+            assert(rectbyplace[y * w + x] == -1);
+            rectbyplace[y * w + x] = i;
+        }
+    }
+
+    workspace = snewn(nrects, int);
+
+    /*
+     * Now run the actual deduction loop.
+     */
+    while (1) {
+        int done_something = FALSE;
+
+#ifdef SOLVER_DIAGNOSTICS
+        printf("starting deduction loop\n");
+
+        for (i = 0; i < nrects; i++) {
+            printf("rect %d overlaps:\n", i);
+            {
+                int x, y;
+                for (y = 0; y < h; y++) {
+                    for (x = 0; x < w; x++) {
+                        printf("%3d", overlaps[(i * h + y) * w + x]);
+                    }
+                    printf("\n");
+                }
+            }
+        }
+        printf("rectbyplace:\n");
+        {
+            int x, y;
+            for (y = 0; y < h; y++) {
+                for (x = 0; x < w; x++) {
+                    printf("%3d", rectbyplace[y * w + x]);
+                }
+                printf("\n");
+            }
+        }
+#endif
+
+        /*
+         * Housekeeping. Look for rectangles whose number has only
+         * one candidate position left, and mark that square as
+         * known if it isn't already.
+         */
+        for (i = 0; i < nrects; i++) {
+            if (numbers[i].npoints == 1) {
+                int x = numbers[i].points[0].x;
+                int y = numbers[i].points[0].y;
+                if (overlaps[(i * h + y) * w + x] >= -1) {
+                    int j;
+
+                    if (overlaps[(i * h + y) * w + x] <= 0) {
+                        ret = 0;       /* inconsistency */
+                        goto cleanup;
+                    }
+#ifdef SOLVER_DIAGNOSTICS
+                    printf("marking %d,%d as known for rect %d"
+                           " (sole remaining number position)\n", x, y, i);
+#endif
+
+                    for (j = 0; j < nrects; j++)
+                        overlaps[(j * h + y) * w + x] = -1;
+                    
+                    overlaps[(i * h + y) * w + x] = -2;
+                }
+            }
+        }
+
+        /*
+         * Now look at the intersection of all possible placements
+         * for each rectangle, and mark all squares in that
+         * intersection as known for that rectangle if they aren't
+         * already.
+         */
+        for (i = 0; i < nrects; i++) {
+            int minx, miny, maxx, maxy, xx, yy, j;
+
+            minx = miny = 0;
+            maxx = w;
+            maxy = h;
+
+            for (j = 0; j < rectpositions[i].n; j++) {
+                int x = rectpositions[i].rects[j].x;
+                int y = rectpositions[i].rects[j].y;
+                int w = rectpositions[i].rects[j].w;
+                int h = rectpositions[i].rects[j].h;
+
+                if (minx < x) minx = x;
+                if (miny < y) miny = y;
+                if (maxx > x+w) maxx = x+w;
+                if (maxy > y+h) maxy = y+h;
+            }
+
+            for (yy = miny; yy < maxy; yy++)
+                for (xx = minx; xx < maxx; xx++)
+                    if (overlaps[(i * h + yy) * w + xx] >= -1) {
+                        if (overlaps[(i * h + yy) * w + xx] <= 0) {
+                            ret = 0;   /* inconsistency */
+                            goto cleanup;
+                        }
+#ifdef SOLVER_DIAGNOSTICS
+                        printf("marking %d,%d as known for rect %d"
+                               " (intersection of all placements)\n",
+                               xx, yy, i);
+#endif
+
+                        for (j = 0; j < nrects; j++)
+                            overlaps[(j * h + yy) * w + xx] = -1;
+                    
+                        overlaps[(i * h + yy) * w + xx] = -2;
+                    }
+        }
+
+        /*
+         * Rectangle-focused deduction. Look at each rectangle in
+         * turn and try to rule out some of its candidate
+         * placements.
+         */
+        for (i = 0; i < nrects; i++) {
+            int j;
+
+            for (j = 0; j < rectpositions[i].n; j++) {
+                int xx, yy, k;
+                int del = FALSE;
+
+                for (k = 0; k < nrects; k++)
+                    workspace[k] = 0;
+
+                for (yy = 0; yy < rectpositions[i].rects[j].h; yy++) {
+                    int y = yy + rectpositions[i].rects[j].y;
+                    for (xx = 0; xx < rectpositions[i].rects[j].w; xx++) {
+                        int x = xx + rectpositions[i].rects[j].x;
+ 
+                        if (overlaps[(i * h + y) * w + x] == -1) {
+                            /*
+                             * This placement overlaps a square
+                             * which is _known_ to be part of
+                             * another rectangle. Therefore we must
+                             * rule it out.
+                             */
+#ifdef SOLVER_DIAGNOSTICS
+                            printf("rect %d placement at %d,%d w=%d h=%d "
+                                   "contains %d,%d which is known-other\n", i,
+                                   rectpositions[i].rects[j].x,
+                                   rectpositions[i].rects[j].y,
+                                   rectpositions[i].rects[j].w,
+                                   rectpositions[i].rects[j].h,
+                                   x, y);
+#endif
+                            del = TRUE;
+                        }
+
+                        if (rectbyplace[y * w + x] != -1) {
+                            /*
+                             * This placement overlaps one of the
+                             * candidate number placements for some
+                             * rectangle. Count it.
+                             */
+                            workspace[rectbyplace[y * w + x]]++;
+                        }
+                    }
+                }
+
+                if (!del) {
+                    /*
+                     * If we haven't ruled this placement out
+                     * already, see if it overlaps _all_ of the
+                     * candidate number placements for any
+                     * rectangle. If so, we can rule it out.
+                     */
+                    for (k = 0; k < nrects; k++)
+                        if (k != i && workspace[k] == numbers[k].npoints) {
+#ifdef SOLVER_DIAGNOSTICS
+                            printf("rect %d placement at %d,%d w=%d h=%d "
+                                   "contains all number points for rect %d\n",
+                                   i,
+                                   rectpositions[i].rects[j].x,
+                                   rectpositions[i].rects[j].y,
+                                   rectpositions[i].rects[j].w,
+                                   rectpositions[i].rects[j].h,
+                                   k);
+#endif
+                            del = TRUE;
+                            break;
+                        }
+
+                    /*
+                     * Failing that, see if it overlaps at least
+                     * one of the candidate number placements for
+                     * itself! (This might not be the case if one
+                     * of those number placements has been removed
+                     * recently.).
+                     */
+                    if (!del && workspace[i] == 0) {
+#ifdef SOLVER_DIAGNOSTICS
+                        printf("rect %d placement at %d,%d w=%d h=%d "
+                               "contains none of its own number points\n",
+                               i,
+                               rectpositions[i].rects[j].x,
+                               rectpositions[i].rects[j].y,
+                               rectpositions[i].rects[j].w,
+                               rectpositions[i].rects[j].h);
+#endif
+                        del = TRUE;
+                    }
+                }
+
+                if (del) {
+                    remove_rect_placement(w, h, rectpositions, overlaps, i, j);
+
+                    j--;               /* don't skip over next placement */
+
+                    done_something = TRUE;
+                }
+            }
+        }
+
+        /*
+         * Square-focused deduction. Look at each square not marked
+         * as known, and see if there are any which can only be
+         * part of a single rectangle.
+         */
+        {
+            int x, y, n, index;
+            for (y = 0; y < h; y++) for (x = 0; x < w; x++) {
+                /* Known squares are marked as <0 everywhere, so we only need
+                 * to check the overlaps entry for rect 0. */
+                if (overlaps[y * w + x] < 0)
+                    continue;          /* known already */
+
+                n = 0;
+                index = -1;
+                for (i = 0; i < nrects; i++)
+                    if (overlaps[(i * h + y) * w + x] > 0)
+                        n++, index = i;
+
+                if (n == 1) {
+                    int j;
+
+                    /*
+                     * Now we can rule out all placements for
+                     * rectangle `index' which _don't_ contain
+                     * square x,y.
+                     */
+#ifdef SOLVER_DIAGNOSTICS
+                    printf("square %d,%d can only be in rectangle %d\n",
+                           x, y, index);
+#endif
+                    for (j = 0; j < rectpositions[index].n; j++) {
+                        struct rect *r = &rectpositions[index].rects[j];
+                        if (x >= r->x && x < r->x + r->w &&
+                            y >= r->y && y < r->y + r->h)
+                            continue;  /* this one is OK */
+                        remove_rect_placement(w, h, rectpositions, overlaps,
+                                              index, j);
+                        j--;           /* don't skip over next placement */
+                        done_something = TRUE;
+                    }
+                }
+            }
+        }
+
+        /*
+         * If we've managed to deduce anything by normal means,
+         * loop round again and see if there's more to be done.
+         * Only if normal deduction has completely failed us should
+         * we now move on to narrowing down the possible number
+         * placements.
+         */
+        if (done_something)
+            continue;
+
+        /*
+         * Now we have done everything we can with the current set
+         * of number placements. So we need to winnow the number
+         * placements so as to narrow down the possibilities. We do
+         * this by searching for a candidate placement (of _any_
+         * rectangle) which overlaps a candidate placement of the
+         * number for some other rectangle.
+         */
+        if (rs) {
+            struct rpn {
+                int rect;
+                int placement;
+                int number;
+            } *rpns = NULL;
+            size_t nrpns = 0, rpnsize = 0;
+            int j;
+
+            for (i = 0; i < nrects; i++) {
+                for (j = 0; j < rectpositions[i].n; j++) {
+                    int xx, yy;
+
+                    for (yy = 0; yy < rectpositions[i].rects[j].h; yy++) {
+                        int y = yy + rectpositions[i].rects[j].y;
+                        for (xx = 0; xx < rectpositions[i].rects[j].w; xx++) {
+                            int x = xx + rectpositions[i].rects[j].x;
+
+                            if (rectbyplace[y * w + x] >= 0 &&
+                                rectbyplace[y * w + x] != i) {
+                                /*
+                                 * Add this to the list of
+                                 * winnowing possibilities.
+                                 */
+                                if (nrpns >= rpnsize) {
+                                    rpnsize = rpnsize * 3 / 2 + 32;
+                                    rpns = sresize(rpns, rpnsize, struct rpn);
+                                }
+                                rpns[nrpns].rect = i;
+                                rpns[nrpns].placement = j;
+                                rpns[nrpns].number = rectbyplace[y * w + x];
+                                nrpns++;
+                            }
+                        }
+                    }
+ 
+                }
+            }
+
+#ifdef SOLVER_DIAGNOSTICS
+            printf("%d candidate rect placements we could eliminate\n", nrpns);
+#endif
+            if (nrpns > 0) {
+                /*
+                 * Now choose one of these unwanted rectangle
+                 * placements, and eliminate it.
+                 */
+                int index = random_upto(rs, nrpns);
+                int k, m;
+                struct rpn rpn = rpns[index];
+                struct rect r;
+                sfree(rpns);
+
+                i = rpn.rect;
+                j = rpn.placement;
+                k = rpn.number;
+                r = rectpositions[i].rects[j];
+
+                /*
+                 * We rule out placement j of rectangle i by means
+                 * of removing all of rectangle k's candidate
+                 * number placements which do _not_ overlap it.
+                 * This will ensure that it is eliminated during
+                 * the next pass of rectangle-focused deduction.
+                 */
+#ifdef SOLVER_DIAGNOSTICS
+                printf("ensuring number for rect %d is within"
+                       " rect %d's placement at %d,%d w=%d h=%d\n",
+                       k, i, r.x, r.y, r.w, r.h);
+#endif
+
+                for (m = 0; m < numbers[k].npoints; m++) {
+                    int x = numbers[k].points[m].x;
+                    int y = numbers[k].points[m].y;
+
+                    if (x < r.x || x >= r.x + r.w ||
+                        y < r.y || y >= r.y + r.h) {
+#ifdef SOLVER_DIAGNOSTICS
+                        printf("eliminating number for rect %d at %d,%d\n",
+                               k, x, y);
+#endif
+                        remove_number_placement(w, h, &numbers[k],
+                                                m, rectbyplace);
+                        m--;           /* don't skip the next one */
+                        done_something = TRUE;
+                    }
+                }
+            }
+        }
+
+        if (!done_something) {
+#ifdef SOLVER_DIAGNOSTICS
+            printf("terminating deduction loop\n");
+#endif
+            break;
+        }
+    }
+
+    cleanup:
+    ret = 1;
+    for (i = 0; i < nrects; i++) {
+#ifdef SOLVER_DIAGNOSTICS
+        printf("rect %d has %d possible placements\n",
+               i, rectpositions[i].n);
+#endif
+        if (rectpositions[i].n <= 0) {
+            ret = 0;                   /* inconsistency */
+        } else if (rectpositions[i].n > 1) {
+            ret = 2;                   /* remaining uncertainty */
+        } else if (hedge && vedge) {
+            /*
+             * Place the rectangle in its only possible position.
+             */
+            int x, y;
+            struct rect *r = &rectpositions[i].rects[0];
+
+            for (y = 0; y < r->h; y++) {
+                if (r->x > 0)
+                    vedge[(r->y+y) * w + r->x] = 1;
+                if (r->x+r->w < w)
+                    vedge[(r->y+y) * w + r->x+r->w] = 1;
+            }
+            for (x = 0; x < r->w; x++) {
+                if (r->y > 0)
+                    hedge[r->y * w + r->x+x] = 1;
+                if (r->y+r->h < h)
+                    hedge[(r->y+r->h) * w + r->x+x] = 1;
+            }
+        }
+    }
+
+    /*
+     * Free up all allocated storage.
+     */
+    sfree(workspace);
+    sfree(rectbyplace);
+    sfree(overlaps);
+    for (i = 0; i < nrects; i++)
+        sfree(rectpositions[i].rects);
+    sfree(rectpositions);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Grid generation code.
+ */
+
+/*
+ * This function does one of two things. If passed r==NULL, it
+ * counts the number of possible rectangles which cover the given
+ * square, and returns it in *n. If passed r!=NULL then it _reads_
+ * *n to find an index, counts the possible rectangles until it
+ * reaches the nth, and writes it into r.
+ * 
+ * `scratch' is expected to point to an array of 2 * params->w
+ * ints, used internally as scratch space (and passed in like this
+ * to avoid re-allocating and re-freeing it every time round a
+ * tight loop).
+ */
+static void enum_rects(game_params *params, int *grid, struct rect *r, int *n,
+                       int sx, int sy, int *scratch)
+{
+    int rw, rh, mw, mh;
+    int x, y, dx, dy;
+    int maxarea, realmaxarea;
+    int index = 0;
+    int *top, *bottom;
+
+    /*
+     * Maximum rectangle area is 1/6 of total grid size, unless
+     * this means we can't place any rectangles at all in which
+     * case we set it to 2 at minimum.
+     */
+    maxarea = params->w * params->h / 6;
+    if (maxarea < 2)
+        maxarea = 2;
+
+    /*
+     * Scan the grid to find the limits of the region within which
+     * any rectangle containing this point must fall. This will
+     * save us trawling the inside of every rectangle later on to
+     * see if it contains any used squares.
+     */
+    top = scratch;
+    bottom = scratch + params->w;
+    for (dy = -1; dy <= +1; dy += 2) {
+        int *array = (dy == -1 ? top : bottom);
+        for (dx = -1; dx <= +1; dx += 2) {
+            for (x = sx; x >= 0 && x < params->w; x += dx) {
+                array[x] = -2 * params->h * dy;
+                for (y = sy; y >= 0 && y < params->h; y += dy) {
+                    if (index(params, grid, x, y) == -1 &&
+                        (x == sx || dy*y <= dy*array[x-dx]))
+                        array[x] = y;
+                    else
+                        break;
+                }
+            }
+        }
+    }
+
+    /*
+     * Now scan again to work out the largest rectangles we can fit
+     * in the grid, so that we can terminate the following loops
+     * early once we get down to not having much space left in the
+     * grid.
+     */
+    realmaxarea = 0;
+    for (x = 0; x < params->w; x++) {
+        int x2;
+
+        rh = bottom[x] - top[x] + 1;
+        if (rh <= 0)
+            continue;                  /* no rectangles can start here */
+
+        dx = (x > sx ? -1 : +1);
+        for (x2 = x; x2 >= 0 && x2 < params->w; x2 += dx)
+            if (bottom[x2] < bottom[x] || top[x2] > top[x])
+                break;
+
+        rw = abs(x2 - x);
+        if (realmaxarea < rw * rh)
+            realmaxarea = rw * rh;
+    }
+
+    if (realmaxarea > maxarea)
+        realmaxarea = maxarea;
+
+    /*
+     * Rectangles which go right the way across the grid are
+     * boring, although they can't be helped in the case of
+     * extremely small grids. (Also they might be generated later
+     * on by the singleton-removal process; we can't help that.)
+     */
+    mw = params->w - 1;
+    if (mw < 3) mw++;
+    mh = params->h - 1;
+    if (mh < 3) mh++;
+
+    for (rw = 1; rw <= mw; rw++)
+        for (rh = 1; rh <= mh; rh++) {
+            if (rw * rh > realmaxarea)
+                continue;
+            if (rw * rh == 1)
+                continue;
+            for (x = max(sx - rw + 1, 0); x <= min(sx, params->w - rw); x++)
+                for (y = max(sy - rh + 1, 0); y <= min(sy, params->h - rh);
+                     y++) {
+                    /*
+                     * Check this rectangle against the region we
+                     * defined above.
+                     */
+                    if (top[x] <= y && top[x+rw-1] <= y &&
+                        bottom[x] >= y+rh-1 && bottom[x+rw-1] >= y+rh-1) {
+                        if (r && index == *n) {
+                            r->x = x;
+                            r->y = y;
+                            r->w = rw;
+                            r->h = rh;
+                            return;
+                        }
+                        index++;
+                    }
+                }
+        }
+
+    assert(!r);
+    *n = index;
+}
+
+static void place_rect(game_params *params, int *grid, struct rect r)
+{
+    int idx = INDEX(params, r.x, r.y);
+    int x, y;
+
+    for (x = r.x; x < r.x+r.w; x++)
+        for (y = r.y; y < r.y+r.h; y++) {
+            index(params, grid, x, y) = idx;
+        }
+#ifdef GENERATION_DIAGNOSTICS
+    printf("    placing rectangle at (%d,%d) size %d x %d\n",
+           r.x, r.y, r.w, r.h);
+#endif
+}
+
+static struct rect find_rect(game_params *params, int *grid, int x, int y)
+{
+    int idx, w, h;
+    struct rect r;
+
+    /*
+     * Find the top left of the rectangle.
+     */
+    idx = index(params, grid, x, y);
+
+    if (idx < 0) {
+        r.x = x;
+        r.y = y;
+        r.w = r.h = 1;
+        return r;                      /* 1x1 singleton here */
+    }
+
+    y = idx / params->w;
+    x = idx % params->w;
+
+    /*
+     * Find the width and height of the rectangle.
+     */
+    for (w = 1;
+         (x+w < params->w && index(params,grid,x+w,y)==idx);
+         w++);
+    for (h = 1;
+         (y+h < params->h && index(params,grid,x,y+h)==idx);
+         h++);
+
+    r.x = x;
+    r.y = y;
+    r.w = w;
+    r.h = h;
+
+    return r;
+}
+
+#ifdef GENERATION_DIAGNOSTICS
+static void display_grid(game_params *params, int *grid, int *numbers, int all)
+{
+    unsigned char *egrid = snewn((params->w*2+3) * (params->h*2+3),
+                                 unsigned char);
+    int x, y;
+    int r = (params->w*2+3);
+
+    memset(egrid, 0, (params->w*2+3) * (params->h*2+3));
+
+    for (x = 0; x < params->w; x++)
+        for (y = 0; y < params->h; y++) {
+            int i = index(params, grid, x, y);
+            if (x == 0 || index(params, grid, x-1, y) != i)
+                egrid[(2*y+2) * r + (2*x+1)] = 1;
+            if (x == params->w-1 || index(params, grid, x+1, y) != i)
+                egrid[(2*y+2) * r + (2*x+3)] = 1;
+            if (y == 0 || index(params, grid, x, y-1) != i)
+                egrid[(2*y+1) * r + (2*x+2)] = 1;
+            if (y == params->h-1 || index(params, grid, x, y+1) != i)
+                egrid[(2*y+3) * r + (2*x+2)] = 1;
+        }
+
+    for (y = 1; y < 2*params->h+2; y++) {
+        for (x = 1; x < 2*params->w+2; x++) {
+            if (!((y|x)&1)) {
+                int k = numbers ? index(params, numbers, x/2-1, y/2-1) : 0;
+                if (k || (all && numbers)) printf("%2d", k); else printf("  ");
+            } else if (!((y&x)&1)) {
+                int v = egrid[y*r+x];
+                if ((y&1) && v) v = '-';
+                if ((x&1) && v) v = '|';
+                if (!v) v = ' ';
+                putchar(v);
+                if (!(x&1)) putchar(v);
+            } else {
+                int c, d = 0;
+                if (egrid[y*r+(x+1)]) d |= 1;
+                if (egrid[(y-1)*r+x]) d |= 2;
+                if (egrid[y*r+(x-1)]) d |= 4;
+                if (egrid[(y+1)*r+x]) d |= 8;
+                c = " ??+?-++?+|+++++"[d];
+                putchar(c);
+                if (!(x&1)) putchar(c);
+            }
+        }
+        putchar('\n');
+    }
+
+    sfree(egrid);
+}
+#endif
+
+static char *new_game_desc(const game_params *params_in, random_state *rs,
+                           char **aux, int interactive)
+{
+    game_params params_copy = *params_in; /* structure copy */
+    game_params *params = &params_copy;
+    int *grid, *numbers = NULL;
+    int x, y, y2, y2last, yx, run, i, nsquares;
+    char *desc, *p;
+    int *enum_rects_scratch;
+    game_params params2real, *params2 = &params2real;
+
+    while (1) {
+        /*
+         * Set up the smaller width and height which we will use to
+         * generate the base grid.
+         */
+        params2->w = (int)((float)params->w / (1.0F + params->expandfactor));
+        if (params2->w < 2 && params->w >= 2) params2->w = 2;
+        params2->h = (int)((float)params->h / (1.0F + params->expandfactor));
+        if (params2->h < 2 && params->h >= 2) params2->h = 2;
+
+        grid = snewn(params2->w * params2->h, int);
+
+        enum_rects_scratch = snewn(2 * params2->w, int);
+
+        nsquares = 0;
+        for (y = 0; y < params2->h; y++)
+            for (x = 0; x < params2->w; x++) {
+                index(params2, grid, x, y) = -1;
+                nsquares++;
+            }
+
+        /*
+         * Place rectangles until we can't any more. We do this by
+         * finding a square we haven't yet covered, and randomly
+         * choosing a rectangle to cover it.
+         */
+        
+        while (nsquares > 0) {
+            int square = random_upto(rs, nsquares);
+            int n;
+            struct rect r;
+
+            x = params2->w;
+            y = params2->h;
+            for (y = 0; y < params2->h; y++) {
+                for (x = 0; x < params2->w; x++) {
+                    if (index(params2, grid, x, y) == -1 && square-- == 0)
+                        break;
+                }
+                if (x < params2->w)
+                    break;
+            }
+            assert(x < params2->w && y < params2->h);
+
+            /*
+             * Now see how many rectangles fit around this one.
+             */
+            enum_rects(params2, grid, NULL, &n, x, y, enum_rects_scratch);
+
+            if (!n) {
+                /*
+                 * There are no possible rectangles covering this
+                 * square, meaning it must be a singleton. Mark it
+                 * -2 so we know not to keep trying.
+                 */
+                index(params2, grid, x, y) = -2;
+                nsquares--;
+            } else {
+                /*
+                 * Pick one at random.
+                 */
+                n = random_upto(rs, n);
+                enum_rects(params2, grid, &r, &n, x, y, enum_rects_scratch);
+
+                /*
+                 * Place it.
+                 */
+                place_rect(params2, grid, r);
+                nsquares -= r.w * r.h;
+            }
+        }
+
+        sfree(enum_rects_scratch);
+
+        /*
+         * Deal with singleton spaces remaining in the grid, one by
+         * one.
+         *
+         * We do this by making a local change to the layout. There are
+         * several possibilities:
+         *
+         *     +-----+-----+    Here, we can remove the singleton by
+         *     |     |     |    extending the 1x2 rectangle below it
+         *     +--+--+-----+    into a 1x3.
+         *     |  |  |     |
+         *     |  +--+     |
+         *     |  |  |     |
+         *     |  |  |     |
+         *     |  |  |     |
+         *     +--+--+-----+
+         *
+         *     +--+--+--+       Here, that trick doesn't work: there's no
+         *     |     |  |       1 x n rectangle with the singleton at one
+         *     |     |  |       end. Instead, we extend a 1 x n rectangle
+         *     |     |  |       _out_ from the singleton, shaving a layer
+         *     +--+--+  |       off the end of another rectangle. So if we
+         *     |  |  |  |       extended up, we'd make our singleton part
+         *     |  +--+--+       of a 1x3 and generate a 1x2 where the 2x2
+         *     |  |     |       used to be; or we could extend right into
+         *     +--+-----+       a 2x1, turning the 1x3 into a 1x2.
+         *
+         *     +-----+--+       Here, we can't even do _that_, since any
+         *     |     |  |       direction we choose to extend the singleton
+         *     +--+--+  |       will produce a new singleton as a result of
+         *     |  |  |  |       truncating one of the size-2 rectangles.
+         *     |  +--+--+       Fortunately, this case can _only_ occur when
+         *     |  |     |       a singleton is surrounded by four size-2s
+         *     +--+-----+       in this fashion; so instead we can simply
+         *                      replace the whole section with a single 3x3.
+         */
+        for (x = 0; x < params2->w; x++) {
+            for (y = 0; y < params2->h; y++) {
+                if (index(params2, grid, x, y) < 0) {
+                    int dirs[4], ndirs;
+
+#ifdef GENERATION_DIAGNOSTICS
+                    display_grid(params2, grid, NULL, FALSE);
+                    printf("singleton at %d,%d\n", x, y);
+#endif
+
+                    /*
+                     * Check in which directions we can feasibly extend
+                     * the singleton. We can extend in a particular
+                     * direction iff either:
+                     *
+                     *  - the rectangle on that side of the singleton
+                     *    is not 2x1, and we are at one end of the edge
+                     *    of it we are touching
+                     *
+                     *  - it is 2x1 but we are on its short side.
+                     *
+                     * FIXME: we could plausibly choose between these
+                     * based on the sizes of the rectangles they would
+                     * create?
+                     */
+                    ndirs = 0;
+                    if (x < params2->w-1) {
+                        struct rect r = find_rect(params2, grid, x+1, y);
+                        if ((r.w * r.h > 2 && (r.y==y || r.y+r.h-1==y)) || r.h==1)
+                            dirs[ndirs++] = 1;   /* right */
+                    }
+                    if (y > 0) {
+                        struct rect r = find_rect(params2, grid, x, y-1);
+                        if ((r.w * r.h > 2 && (r.x==x || r.x+r.w-1==x)) || r.w==1)
+                            dirs[ndirs++] = 2;   /* up */
+                    }
+                    if (x > 0) {
+                        struct rect r = find_rect(params2, grid, x-1, y);
+                        if ((r.w * r.h > 2 && (r.y==y || r.y+r.h-1==y)) || r.h==1)
+                            dirs[ndirs++] = 4;   /* left */
+                    }
+                    if (y < params2->h-1) {
+                        struct rect r = find_rect(params2, grid, x, y+1);
+                        if ((r.w * r.h > 2 && (r.x==x || r.x+r.w-1==x)) || r.w==1)
+                            dirs[ndirs++] = 8;   /* down */
+                    }
+
+                    if (ndirs > 0) {
+                        int which, dir;
+                        struct rect r1, r2;
+                        memset(&r1, 0, sizeof(struct rect));
+                        memset(&r2, 0, sizeof(struct rect));
+                        which = random_upto(rs, ndirs);
+                        dir = dirs[which];
+
+                        switch (dir) {
+                          case 1:          /* right */
+                            assert(x < params2->w+1);
+#ifdef GENERATION_DIAGNOSTICS
+                            printf("extending right\n");
+#endif
+                            r1 = find_rect(params2, grid, x+1, y);
+                            r2.x = x;
+                            r2.y = y;
+                            r2.w = 1 + r1.w;
+                            r2.h = 1;
+                            if (r1.y == y)
+                                r1.y++;
+                            r1.h--;
+                            break;
+                          case 2:          /* up */
+                            assert(y > 0);
+#ifdef GENERATION_DIAGNOSTICS
+                            printf("extending up\n");
+#endif
+                            r1 = find_rect(params2, grid, x, y-1);
+                            r2.x = x;
+                            r2.y = r1.y;
+                            r2.w = 1;
+                            r2.h = 1 + r1.h;
+                            if (r1.x == x)
+                                r1.x++;
+                            r1.w--;
+                            break;
+                          case 4:          /* left */
+                            assert(x > 0);
+#ifdef GENERATION_DIAGNOSTICS
+                            printf("extending left\n");
+#endif
+                            r1 = find_rect(params2, grid, x-1, y);
+                            r2.x = r1.x;
+                            r2.y = y;
+                            r2.w = 1 + r1.w;
+                            r2.h = 1;
+                            if (r1.y == y)
+                                r1.y++;
+                            r1.h--;
+                            break;
+                          case 8:          /* down */
+                            assert(y < params2->h+1);
+#ifdef GENERATION_DIAGNOSTICS
+                            printf("extending down\n");
+#endif
+                            r1 = find_rect(params2, grid, x, y+1);
+                            r2.x = x;
+                            r2.y = y;
+                            r2.w = 1;
+                            r2.h = 1 + r1.h;
+                            if (r1.x == x)
+                                r1.x++;
+                            r1.w--;
+                            break;
+                          default:     /* should never happen */
+                            assert(!"invalid direction");
+                        }
+                        if (r1.h > 0 && r1.w > 0)
+                            place_rect(params2, grid, r1);
+                        place_rect(params2, grid, r2);
+                    } else {
+#ifndef NDEBUG
+                        /*
+                         * Sanity-check that there really is a 3x3
+                         * rectangle surrounding this singleton and it
+                         * contains absolutely everything we could
+                         * possibly need.
+                         */
+                        {
+                            int xx, yy;
+                            assert(x > 0 && x < params2->w-1);
+                            assert(y > 0 && y < params2->h-1);
+
+                            for (xx = x-1; xx <= x+1; xx++)
+                                for (yy = y-1; yy <= y+1; yy++) {
+                                    struct rect r = find_rect(params2,grid,xx,yy);
+                                    assert(r.x >= x-1);
+                                    assert(r.y >= y-1);
+                                    assert(r.x+r.w-1 <= x+1);
+                                    assert(r.y+r.h-1 <= y+1);
+                                }
+                        }
+#endif
+
+#ifdef GENERATION_DIAGNOSTICS
+                        printf("need the 3x3 trick\n");
+#endif
+
+                        /*
+                         * FIXME: If the maximum rectangle area for
+                         * this grid is less than 9, we ought to
+                         * subdivide the 3x3 in some fashion. There are
+                         * five other possibilities:
+                         *
+                         *  - a 6 and a 3
+                         *  - a 4, a 3 and a 2
+                         *  - three 3s
+                         *  - a 3 and three 2s (two different arrangements).
+                         */
+
+                        {
+                            struct rect r;
+                            r.x = x-1;
+                            r.y = y-1;
+                            r.w = r.h = 3;
+                            place_rect(params2, grid, r);
+                        }
+                    }
+                }
+            }
+        }
+
+        /*
+         * We have now constructed a grid of the size specified in
+         * params2. Now we extend it into a grid of the size specified
+         * in params. We do this in two passes: we extend it vertically
+         * until it's the right height, then we transpose it, then
+         * extend it vertically again (getting it effectively the right
+         * width), then finally transpose again.
+         */
+        for (i = 0; i < 2; i++) {
+            int *grid2, *expand, *where;
+            game_params params3real, *params3 = &params3real;
+
+#ifdef GENERATION_DIAGNOSTICS
+            printf("before expansion:\n");
+            display_grid(params2, grid, NULL, TRUE);
+#endif
+
+            /*
+             * Set up the new grid.
+             */
+            grid2 = snewn(params2->w * params->h, int);
+            expand = snewn(params2->h-1, int);
+            where = snewn(params2->w, int);
+            params3->w = params2->w;
+            params3->h = params->h;
+
+            /*
+             * Decide which horizontal edges are going to get expanded,
+             * and by how much.
+             */
+            for (y = 0; y < params2->h-1; y++)
+                expand[y] = 0;
+            for (y = params2->h; y < params->h; y++) {
+                x = random_upto(rs, params2->h-1);
+                expand[x]++;
+            }
+
+#ifdef GENERATION_DIAGNOSTICS
+            printf("expand[] = {");
+            for (y = 0; y < params2->h-1; y++)
+                printf(" %d", expand[y]);
+            printf(" }\n");
+#endif
+
+            /*
+             * Perform the expansion. The way this works is that we
+             * alternately:
+             *
+             *  - copy a row from grid into grid2
+             *
+             *  - invent some number of additional rows in grid2 where
+             *    there was previously only a horizontal line between
+             *    rows in grid, and make random decisions about where
+             *    among these to place each rectangle edge that ran
+             *    along this line.
+             */
+            for (y = y2 = y2last = 0; y < params2->h; y++) {
+                /*
+                 * Copy a single line from row y of grid into row y2 of
+                 * grid2.
+                 */
+                for (x = 0; x < params2->w; x++) {
+                    int val = index(params2, grid, x, y);
+                    if (val / params2->w == y &&   /* rect starts on this line */
+                        (y2 == 0 ||            /* we're at the very top, or... */
+                         index(params3, grid2, x, y2-1) / params3->w < y2last
+                         /* this rect isn't already started */))
+                        index(params3, grid2, x, y2) =
+                        INDEX(params3, val % params2->w, y2);
+                    else
+                        index(params3, grid2, x, y2) =
+                        index(params3, grid2, x, y2-1);
+                }
+
+                /*
+                 * If that was the last line, terminate the loop early.
+                 */
+                if (++y2 == params3->h)
+                    break;
+
+                y2last = y2;
+
+                /*
+                 * Invent some number of additional lines. First walk
+                 * along this line working out where to put all the
+                 * edges that coincide with it.
+                 */
+                yx = -1;
+                for (x = 0; x < params2->w; x++) {
+                    if (index(params2, grid, x, y) !=
+                        index(params2, grid, x, y+1)) {
+                        /*
+                         * This is a horizontal edge, so it needs
+                         * placing.
+                         */
+                        if (x == 0 ||
+                            (index(params2, grid, x-1, y) !=
+                             index(params2, grid, x, y) &&
+                             index(params2, grid, x-1, y+1) !=
+                             index(params2, grid, x, y+1))) {
+                            /*
+                             * Here we have the chance to make a new
+                             * decision.
+                             */
+                            yx = random_upto(rs, expand[y]+1);
+                        } else {
+                            /*
+                             * Here we just reuse the previous value of
+                             * yx.
+                             */
+                        }
+                    } else
+                        yx = -1;
+                    where[x] = yx;
+                }
+
+                for (yx = 0; yx < expand[y]; yx++) {
+                    /*
+                     * Invent a single row. For each square in the row,
+                     * we copy the grid entry from the square above it,
+                     * unless we're starting the new rectangle here.
+                     */
+                    for (x = 0; x < params2->w; x++) {
+                        if (yx == where[x]) {
+                            int val = index(params2, grid, x, y+1);
+                            val %= params2->w;
+                            val = INDEX(params3, val, y2);
+                            index(params3, grid2, x, y2) = val;
+                        } else
+                            index(params3, grid2, x, y2) =
+                            index(params3, grid2, x, y2-1);
+                    }
+
+                    y2++;
+                }
+            }
+
+            sfree(expand);
+            sfree(where);
+
+#ifdef GENERATION_DIAGNOSTICS
+            printf("after expansion:\n");
+            display_grid(params3, grid2, NULL, TRUE);
+#endif
+            /*
+             * Transpose.
+             */
+            params2->w = params3->h;
+            params2->h = params3->w;
+            sfree(grid);
+            grid = snewn(params2->w * params2->h, int);
+            for (x = 0; x < params2->w; x++)
+                for (y = 0; y < params2->h; y++) {
+                    int idx1 = INDEX(params2, x, y);
+                    int idx2 = INDEX(params3, y, x);
+                    int tmp;
+
+                    tmp = grid2[idx2];
+                    tmp = (tmp % params3->w) * params2->w + (tmp / params3->w);
+                    grid[idx1] = tmp;
+                }
+
+            sfree(grid2);
+
+            {
+                int tmp;
+                tmp = params->w;
+                params->w = params->h;
+                params->h = tmp;
+            }
+
+#ifdef GENERATION_DIAGNOSTICS
+            printf("after transposition:\n");
+            display_grid(params2, grid, NULL, TRUE);
+#endif
+        }
+
+        /*
+         * Run the solver to narrow down the possible number
+         * placements.
+         */
+        {
+            struct numberdata *nd;
+            int nnumbers, i, ret;
+
+            /* Count the rectangles. */
+            nnumbers = 0;
+            for (y = 0; y < params->h; y++) {
+                for (x = 0; x < params->w; x++) {
+                    int idx = INDEX(params, x, y);
+                    if (index(params, grid, x, y) == idx)
+                        nnumbers++;
+                }
+            }
+
+            nd = snewn(nnumbers, struct numberdata);
+
+            /* Now set up each number's candidate position list. */
+            i = 0;
+            for (y = 0; y < params->h; y++) {
+                for (x = 0; x < params->w; x++) {
+                    int idx = INDEX(params, x, y);
+                    if (index(params, grid, x, y) == idx) {
+                        struct rect r = find_rect(params, grid, x, y);
+                        int j, k, m;
+
+                        nd[i].area = r.w * r.h;
+                        nd[i].npoints = nd[i].area;
+                        nd[i].points = snewn(nd[i].npoints, struct point);
+                        m = 0;
+                        for (j = 0; j < r.h; j++)
+                            for (k = 0; k < r.w; k++) {
+                                nd[i].points[m].x = k + r.x;
+                                nd[i].points[m].y = j + r.y;
+                                m++;
+                            }
+                        assert(m == nd[i].npoints);
+
+                        i++;
+                    }
+                }
+            }
+
+            if (params->unique)
+                ret = rect_solver(params->w, params->h, nnumbers, nd,
+                                  NULL, NULL, rs);
+            else
+                ret = 1;               /* allow any number placement at all */
+
+            if (ret == 1) {
+                /*
+                 * Now place the numbers according to the solver's
+                 * recommendations.
+                 */
+                numbers = snewn(params->w * params->h, int);
+
+                for (y = 0; y < params->h; y++)
+                    for (x = 0; x < params->w; x++) {
+                        index(params, numbers, x, y) = 0;
+                    }
+
+                for (i = 0; i < nnumbers; i++) {
+                    int idx = random_upto(rs, nd[i].npoints);
+                    int x = nd[i].points[idx].x;
+                    int y = nd[i].points[idx].y;
+                    index(params,numbers,x,y) = nd[i].area;
+                }
+            }
+
+            /*
+             * Clean up.
+             */
+            for (i = 0; i < nnumbers; i++)
+                sfree(nd[i].points);
+            sfree(nd);
+
+            /*
+             * If we've succeeded, then terminate the loop.
+             */
+            if (ret == 1)
+                break;
+        }
+
+        /*
+         * Give up and go round again.
+         */
+        sfree(grid);
+    }
+
+    /*
+     * Store the solution in aux.
+     */
+    {
+        char *ai;
+        int len;
+
+        len = 2 + (params->w-1)*params->h + (params->h-1)*params->w;
+        ai = snewn(len, char);
+
+        ai[0] = 'S';
+
+        p = ai+1;
+
+        for (y = 0; y < params->h; y++)
+            for (x = 1; x < params->w; x++)
+                *p++ = (index(params, grid, x, y) !=
+                        index(params, grid, x-1, y) ? '1' : '0');
+
+        for (y = 1; y < params->h; y++)
+            for (x = 0; x < params->w; x++)
+                *p++ = (index(params, grid, x, y) !=
+                        index(params, grid, x, y-1) ? '1' : '0');
+
+        assert(p - ai == len-1);
+        *p = '\0';
+
+        *aux = ai;
+    }
+
+#ifdef GENERATION_DIAGNOSTICS
+    display_grid(params, grid, numbers, FALSE);
+#endif
+
+    desc = snewn(11 * params->w * params->h, char);
+    p = desc;
+    run = 0;
+    for (i = 0; i <= params->w * params->h; i++) {
+        int n = (i < params->w * params->h ? numbers[i] : -1);
+
+        if (!n)
+            run++;
+        else {
+            if (run) {
+                while (run > 0) {
+                    int c = 'a' - 1 + run;
+                    if (run > 26)
+                        c = 'z';
+                    *p++ = c;
+                    run -= c - ('a' - 1);
+                }
+            } else {
+                /*
+                 * If there's a number in the very top left or
+                 * bottom right, there's no point putting an
+                 * unnecessary _ before or after it.
+                 */
+                if (p > desc && n > 0)
+                    *p++ = '_';
+            }
+            if (n > 0)
+                p += sprintf(p, "%d", n);
+            run = 0;
+        }
+    }
+    *p = '\0';
+
+    sfree(grid);
+    sfree(numbers);
+
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int area = params->w * params->h;
+    int squares = 0;
+
+    while (*desc) {
+        int n = *desc++;
+        if (n >= 'a' && n <= 'z') {
+            squares += n - 'a' + 1;
+        } else if (n == '_') {
+            /* do nothing */;
+        } else if (n > '0' && n <= '9') {
+            squares++;
+            while (*desc >= '0' && *desc <= '9')
+                desc++;
+        } else
+            return "Invalid character in game description";
+    }
+
+    if (squares < area)
+        return "Not enough data to fill grid";
+
+    if (squares > area)
+        return "Too much data to fit in grid";
+
+    return NULL;
+}
+
+static unsigned char *get_correct(game_state *state)
+{
+    unsigned char *ret;
+    int x, y;
+
+    ret = snewn(state->w * state->h, unsigned char);
+    memset(ret, 0xFF, state->w * state->h);
+
+    for (x = 0; x < state->w; x++)
+        for (y = 0; y < state->h; y++)
+            if (index(state,ret,x,y) == 0xFF) {
+                int rw, rh;
+                int xx, yy;
+                int num, area, valid;
+
+                /*
+                 * Find a rectangle starting at this point.
+                 */
+                rw = 1;
+                while (x+rw < state->w && !vedge(state,x+rw,y))
+                    rw++;
+                rh = 1;
+                while (y+rh < state->h && !hedge(state,x,y+rh))
+                    rh++;
+
+                /*
+                 * We know what the dimensions of the rectangle
+                 * should be if it's there at all. Find out if we
+                 * really have a valid rectangle.
+                 */
+                valid = TRUE;
+                /* Check the horizontal edges. */
+                for (xx = x; xx < x+rw; xx++) {
+                    for (yy = y; yy <= y+rh; yy++) {
+                        int e = !HRANGE(state,xx,yy) || hedge(state,xx,yy);
+                        int ec = (yy == y || yy == y+rh);
+                        if (e != ec)
+                            valid = FALSE;
+                    }
+                }
+                /* Check the vertical edges. */
+                for (yy = y; yy < y+rh; yy++) {
+                    for (xx = x; xx <= x+rw; xx++) {
+                        int e = !VRANGE(state,xx,yy) || vedge(state,xx,yy);
+                        int ec = (xx == x || xx == x+rw);
+                        if (e != ec)
+                            valid = FALSE;
+                    }
+                }
+
+                /*
+                 * If this is not a valid rectangle with no other
+                 * edges inside it, we just mark this square as not
+                 * complete and proceed to the next square.
+                 */
+                if (!valid) {
+                    index(state, ret, x, y) = 0;
+                    continue;
+                }
+
+                /*
+                 * We have a rectangle. Now see what its area is,
+                 * and how many numbers are in it.
+                 */
+                num = 0;
+                area = 0;
+                for (xx = x; xx < x+rw; xx++) {
+                    for (yy = y; yy < y+rh; yy++) {
+                        area++;
+                        if (grid(state,xx,yy)) {
+                            if (num > 0)
+                                valid = FALSE;   /* two numbers */
+                            num = grid(state,xx,yy);
+                        }
+                    }
+                }
+                if (num != area)
+                    valid = FALSE;
+
+                /*
+                 * Now fill in the whole rectangle based on the
+                 * value of `valid'.
+                 */
+                for (xx = x; xx < x+rw; xx++) {
+                    for (yy = y; yy < y+rh; yy++) {
+                        index(state, ret, xx, yy) = valid;
+                    }
+                }
+            }
+
+    return ret;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    int x, y, i, area;
+
+    state->w = params->w;
+    state->h = params->h;
+
+    area = state->w * state->h;
+
+    state->grid = snewn(area, int);
+    state->vedge = snewn(area, unsigned char);
+    state->hedge = snewn(area, unsigned char);
+    state->completed = state->cheated = FALSE;
+
+    i = 0;
+    while (*desc) {
+        int n = *desc++;
+        if (n >= 'a' && n <= 'z') {
+            int run = n - 'a' + 1;
+            assert(i + run <= area);
+            while (run-- > 0)
+                state->grid[i++] = 0;
+        } else if (n == '_') {
+            /* do nothing */;
+        } else if (n > '0' && n <= '9') {
+            assert(i < area);
+            state->grid[i++] = atoi(desc-1);
+            while (*desc >= '0' && *desc <= '9')
+                desc++;
+        } else {
+            assert(!"We can't get here");
+        }
+    }
+    assert(i == area);
+
+    for (y = 0; y < state->h; y++)
+        for (x = 0; x < state->w; x++)
+            vedge(state,x,y) = hedge(state,x,y) = 0;
+
+    state->correct = get_correct(state);
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->w = state->w;
+    ret->h = state->h;
+
+    ret->vedge = snewn(state->w * state->h, unsigned char);
+    ret->hedge = snewn(state->w * state->h, unsigned char);
+    ret->grid = snewn(state->w * state->h, int);
+    ret->correct = snewn(ret->w * ret->h, unsigned char);
+
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+
+    memcpy(ret->grid, state->grid, state->w * state->h * sizeof(int));
+    memcpy(ret->vedge, state->vedge, state->w*state->h*sizeof(unsigned char));
+    memcpy(ret->hedge, state->hedge, state->w*state->h*sizeof(unsigned char));
+
+    memcpy(ret->correct, state->correct, state->w*state->h*sizeof(unsigned char));
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    sfree(state->vedge);
+    sfree(state->hedge);
+    sfree(state->correct);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *ai, char **error)
+{
+    unsigned char *vedge, *hedge;
+    int x, y, len;
+    char *ret, *p;
+    int i, j, n;
+    struct numberdata *nd;
+
+    if (ai)
+        return dupstr(ai);
+
+    /*
+     * Attempt the in-built solver.
+     */
+
+    /* Set up each number's (very short) candidate position list. */
+    for (i = n = 0; i < state->h * state->w; i++)
+        if (state->grid[i])
+            n++;
+
+    nd = snewn(n, struct numberdata);
+
+    for (i = j = 0; i < state->h * state->w; i++)
+        if (state->grid[i]) {
+            nd[j].area = state->grid[i];
+            nd[j].npoints = 1;
+            nd[j].points = snewn(1, struct point);
+            nd[j].points[0].x = i % state->w;
+            nd[j].points[0].y = i / state->w;
+            j++;
+        }
+
+    assert(j == n);
+
+    vedge = snewn(state->w * state->h, unsigned char);
+    hedge = snewn(state->w * state->h, unsigned char);
+    memset(vedge, 0, state->w * state->h);
+    memset(hedge, 0, state->w * state->h);
+
+    rect_solver(state->w, state->h, n, nd, hedge, vedge, NULL);
+
+    /*
+     * Clean up.
+     */
+    for (i = 0; i < n; i++)
+        sfree(nd[i].points);
+    sfree(nd);
+
+    len = 2 + (state->w-1)*state->h + (state->h-1)*state->w;
+    ret = snewn(len, char);
+
+    p = ret;
+    *p++ = 'S';
+    for (y = 0; y < state->h; y++)
+        for (x = 1; x < state->w; x++)
+            *p++ = vedge[y*state->w+x] ? '1' : '0';
+    for (y = 1; y < state->h; y++)
+        for (x = 0; x < state->w; x++)
+            *p++ = hedge[y*state->w+x] ? '1' : '0';
+    *p++ = '\0';
+    assert(p - ret == len);
+
+    sfree(vedge);
+    sfree(hedge);
+
+    return ret;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    char *ret, *p, buf[80];
+    int i, x, y, col, maxlen;
+
+    /*
+     * First determine the number of spaces required to display a
+     * number. We'll use at least two, because one looks a bit
+     * silly.
+     */
+    col = 2;
+    for (i = 0; i < state->w * state->h; i++) {
+        x = sprintf(buf, "%d", state->grid[i]);
+        if (col < x) col = x;
+    }
+
+    /*
+     * Now we know the exact total size of the grid we're going to
+     * produce: it's got 2*h+1 rows, each containing w lots of col,
+     * w+1 boundary characters and a trailing newline.
+     */
+    maxlen = (2*state->h+1) * (state->w * (col+1) + 2);
+
+    ret = snewn(maxlen+1, char);
+    p = ret;
+
+    for (y = 0; y <= 2*state->h; y++) {
+        for (x = 0; x <= 2*state->w; x++) {
+            if (x & y & 1) {
+                /*
+                 * Display a number.
+                 */
+                int v = grid(state, x/2, y/2);
+                if (v)
+                    sprintf(buf, "%*d", col, v);
+                else
+                    sprintf(buf, "%*s", col, "");
+                memcpy(p, buf, col);
+                p += col;
+            } else if (x & 1) {
+                /*
+                 * Display a horizontal edge or nothing.
+                 */
+                int h = (y==0 || y==2*state->h ? 1 :
+                         HRANGE(state, x/2, y/2) && hedge(state, x/2, y/2));
+                int i;
+                if (h)
+                    h = '-';
+                else
+                    h = ' ';
+                for (i = 0; i < col; i++)
+                    *p++ = h;
+            } else if (y & 1) {
+                /*
+                 * Display a vertical edge or nothing.
+                 */
+                int v = (x==0 || x==2*state->w ? 1 :
+                         VRANGE(state, x/2, y/2) && vedge(state, x/2, y/2));
+                if (v)
+                    *p++ = '|';
+                else
+                    *p++ = ' ';
+            } else {
+                /*
+                 * Display a corner, or a vertical edge, or a
+                 * horizontal edge, or nothing.
+                 */
+                int hl = (y==0 || y==2*state->h ? 1 :
+                          HRANGE(state, (x-1)/2, y/2) && hedge(state, (x-1)/2, y/2));
+                int hr = (y==0 || y==2*state->h ? 1 :
+                          HRANGE(state, (x+1)/2, y/2) && hedge(state, (x+1)/2, y/2));
+                int vu = (x==0 || x==2*state->w ? 1 :
+                          VRANGE(state, x/2, (y-1)/2) && vedge(state, x/2, (y-1)/2));
+                int vd = (x==0 || x==2*state->w ? 1 :
+                          VRANGE(state, x/2, (y+1)/2) && vedge(state, x/2, (y+1)/2));
+                if (!hl && !hr && !vu && !vd)
+                    *p++ = ' ';
+                else if (hl && hr && !vu && !vd)
+                    *p++ = '-';
+                else if (!hl && !hr && vu && vd)
+                    *p++ = '|';
+                else
+                    *p++ = '+';
+            }
+        }
+        *p++ = '\n';
+    }
+
+    assert(p - ret == maxlen);
+    *p = '\0';
+    return ret;
+}
+
+struct game_ui {
+    /*
+     * These coordinates are 2 times the obvious grid coordinates.
+     * Hence, the top left of the grid is (0,0), the grid point to
+     * the right of that is (2,0), the one _below that_ is (2,2)
+     * and so on. This is so that we can specify a drag start point
+     * on an edge (one odd coordinate) or in the middle of a square
+     * (two odd coordinates) rather than always at a corner.
+     * 
+     * -1,-1 means no drag is in progress.
+     */
+    int drag_start_x;
+    int drag_start_y;
+    int drag_end_x;
+    int drag_end_y;
+    /*
+     * This flag is set as soon as a dragging action moves the
+     * mouse pointer away from its starting point, so that even if
+     * the pointer _returns_ to its starting point the action is
+     * treated as a small drag rather than a click.
+     */
+    int dragged;
+    /* This flag is set if we're doing an erase operation (i.e.
+     * removing edges in the centre of the rectangle without altering
+     * the outlines).
+     */
+    int erasing;
+    /*
+     * These are the co-ordinates of the top-left and bottom-right squares
+     * in the drag box, respectively, or -1 otherwise.
+     */
+    int x1;
+    int y1;
+    int x2;
+    int y2;
+    /*
+     * These are the coordinates of a cursor, whether it's visible, and
+     * whether it was used to start a drag.
+     */
+    int cur_x, cur_y, cur_visible, cur_dragging;
+};
+
+static void reset_ui(game_ui *ui)
+{
+    ui->drag_start_x = -1;
+    ui->drag_start_y = -1;
+    ui->drag_end_x = -1;
+    ui->drag_end_y = -1;
+    ui->x1 = -1;
+    ui->y1 = -1;
+    ui->x2 = -1;
+    ui->y2 = -1;
+    ui->dragged = FALSE;
+}
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    reset_ui(ui);
+    ui->erasing = FALSE;
+    ui->cur_x = ui->cur_y = ui->cur_visible = ui->cur_dragging = 0;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void coord_round(float x, float y, int *xr, int *yr)
+{
+    float xs, ys, xv, yv, dx, dy, dist;
+
+    /*
+     * Find the nearest square-centre.
+     */
+    xs = (float)floor(x) + 0.5F;
+    ys = (float)floor(y) + 0.5F;
+
+    /*
+     * And find the nearest grid vertex.
+     */
+    xv = (float)floor(x + 0.5F);
+    yv = (float)floor(y + 0.5F);
+
+    /*
+     * We allocate clicks in parts of the grid square to either
+     * corners, edges or square centres, as follows:
+     * 
+     *   +--+--------+--+
+     *   |  |        |  |
+     *   +--+        +--+
+     *   |   `.    ,'   |
+     *   |     +--+     |
+     *   |     |  |     |
+     *   |     +--+     |
+     *   |   ,'    `.   |
+     *   +--+        +--+
+     *   |  |        |  |
+     *   +--+--------+--+
+     * 
+     * (Not to scale!)
+     * 
+     * In other words: we measure the square distance (i.e.
+     * max(dx,dy)) from the click to the nearest corner, and if
+     * it's within CORNER_TOLERANCE then we return a corner click.
+     * We measure the square distance from the click to the nearest
+     * centre, and if that's within CENTRE_TOLERANCE we return a
+     * centre click. Failing that, we find which of the two edge
+     * centres is nearer to the click and return that edge.
+     */
+
+    /*
+     * Check for corner click.
+     */
+    dx = (float)fabs(x - xv);
+    dy = (float)fabs(y - yv);
+    dist = (dx > dy ? dx : dy);
+    if (dist < CORNER_TOLERANCE) {
+        *xr = 2 * (int)xv;
+        *yr = 2 * (int)yv;
+    } else {
+        /*
+         * Check for centre click.
+         */
+        dx = (float)fabs(x - xs);
+        dy = (float)fabs(y - ys);
+        dist = (dx > dy ? dx : dy);
+        if (dist < CENTRE_TOLERANCE) {
+            *xr = 1 + 2 * (int)xs;
+            *yr = 1 + 2 * (int)ys;
+        } else {
+            /*
+             * Failing both of those, see which edge we're closer to.
+             * Conveniently, this is simply done by testing the relative
+             * magnitude of dx and dy (which are currently distances from
+             * the square centre).
+             */
+            if (dx > dy) {
+                /* Vertical edge: x-coord of corner,
+                 * y-coord of square centre. */
+                *xr = 2 * (int)xv;
+                *yr = 1 + 2 * (int)floor(ys);
+            } else {
+                /* Horizontal edge: x-coord of square centre,
+                 * y-coord of corner. */
+                *xr = 1 + 2 * (int)floor(xs);
+                *yr = 2 * (int)yv;
+            }
+        }
+    }
+}
+
+/*
+ * Returns TRUE if it has made any change to the grid.
+ */
+static int grid_draw_rect(const game_state *state,
+                          unsigned char *hedge, unsigned char *vedge,
+                          int c, int really, int outline,
+                          int x1, int y1, int x2, int y2)
+{
+    int x, y;
+    int changed = FALSE;
+
+    /*
+     * Draw horizontal edges of rectangles.
+     */
+    for (x = x1; x < x2; x++)
+        for (y = y1; y <= y2; y++)
+            if (HRANGE(state,x,y)) {
+                int val = index(state,hedge,x,y);
+                if (y == y1 || y == y2) {
+                    if (!outline) continue;
+                    val = c;
+                } else if (c == 1)
+                    val = 0;
+                changed = changed || (index(state,hedge,x,y) != val);
+                if (really)
+                    index(state,hedge,x,y) = val;
+            }
+
+    /*
+     * Draw vertical edges of rectangles.
+     */
+    for (y = y1; y < y2; y++)
+        for (x = x1; x <= x2; x++)
+            if (VRANGE(state,x,y)) {
+                int val = index(state,vedge,x,y);
+                if (x == x1 || x == x2) {
+                    if (!outline) continue;
+                    val = c;
+                } else if (c == 1)
+                    val = 0;
+                changed = changed || (index(state,vedge,x,y) != val);
+                if (really)
+                    index(state,vedge,x,y) = val;
+            }
+
+    return changed;
+}
+
+static int ui_draw_rect(const game_state *state, const game_ui *ui,
+                        unsigned char *hedge, unsigned char *vedge, int c,
+                        int really, int outline)
+{
+    return grid_draw_rect(state, hedge, vedge, c, really, outline,
+                          ui->x1, ui->y1, ui->x2, ui->y2);
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int started;
+    int w, h, tilesize;
+    unsigned long *visible;
+};
+
+static char *interpret_move(const game_state *from, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int xc, yc;
+    int startdrag = FALSE, enddrag = FALSE, active = FALSE, erasing = FALSE;
+    char buf[80], *ret;
+
+    button &= ~MOD_MASK;
+
+    coord_round(FROMCOORD((float)x), FROMCOORD((float)y), &xc, &yc);
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        if (ui->drag_start_x >= 0 && ui->cur_dragging)
+            reset_ui(ui); /* cancel keyboard dragging */
+        startdrag = TRUE;
+        ui->cur_visible = ui->cur_dragging = FALSE;
+        active = TRUE;
+        erasing = (button == RIGHT_BUTTON);
+    } else if (button == LEFT_RELEASE || button == RIGHT_RELEASE) {
+        /* We assert we should have had a LEFT_BUTTON first. */
+        if (ui->cur_visible) {
+            ui->cur_visible = FALSE;
+            active = TRUE;
+        }
+        assert(!ui->cur_dragging);
+        enddrag = TRUE;
+        erasing = (button == RIGHT_RELEASE);
+    } else if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->cur_x, &ui->cur_y, from->w, from->h, 0);
+        ui->cur_visible = TRUE;
+        active = TRUE;
+        if (!ui->cur_dragging) return "";
+        coord_round((float)ui->cur_x + 0.5F, (float)ui->cur_y + 0.5F, &xc, &yc);
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (ui->drag_start_x >= 0 && !ui->cur_dragging) {
+            /*
+             * If a mouse drag is in progress, ignore attempts to
+             * start a keyboard one.
+             */
+            return NULL;
+        }
+        if (!ui->cur_visible) {
+            assert(!ui->cur_dragging);
+            ui->cur_visible = TRUE;
+            return "";
+        }
+        coord_round((float)ui->cur_x + 0.5F, (float)ui->cur_y + 0.5F, &xc, &yc);
+        erasing = (button == CURSOR_SELECT2);
+        if (ui->cur_dragging) {
+            ui->cur_dragging = FALSE;
+            enddrag = TRUE;
+            active = TRUE;
+        } else {
+            ui->cur_dragging = TRUE;
+            startdrag = TRUE;
+            active = TRUE;
+        }
+    } else if (button == '\b' || button == 27) {
+        if (!ui->cur_dragging) {
+            ui->cur_visible = FALSE;
+        } else {
+            assert(ui->cur_visible);
+            reset_ui(ui); /* cancel keyboard dragging */
+            ui->cur_dragging = FALSE;
+        }
+        return "";
+    } else if (button != LEFT_DRAG && button != RIGHT_DRAG) {
+        return NULL;
+    }
+
+    if (startdrag &&
+        xc >= 0 && xc <= 2*from->w &&
+        yc >= 0 && yc <= 2*from->h) {
+
+        ui->drag_start_x = xc;
+        ui->drag_start_y = yc;
+        ui->drag_end_x = -1;
+        ui->drag_end_y = -1;
+        ui->dragged = FALSE;
+        ui->erasing = erasing;
+        active = TRUE;
+    }
+
+    if (ui->drag_start_x >= 0 &&
+        (xc != ui->drag_end_x || yc != ui->drag_end_y)) {
+        int t;
+
+        if (ui->drag_end_x != -1 && ui->drag_end_y != -1)
+            ui->dragged = TRUE;
+        ui->drag_end_x = xc;
+        ui->drag_end_y = yc;
+        active = TRUE;
+
+        if (xc >= 0 && xc <= 2*from->w &&
+            yc >= 0 && yc <= 2*from->h) {
+            ui->x1 = ui->drag_start_x;
+            ui->x2 = ui->drag_end_x;
+            if (ui->x2 < ui->x1) { t = ui->x1; ui->x1 = ui->x2; ui->x2 = t; }
+
+            ui->y1 = ui->drag_start_y;
+            ui->y2 = ui->drag_end_y;
+            if (ui->y2 < ui->y1) { t = ui->y1; ui->y1 = ui->y2; ui->y2 = t; }
+
+            ui->x1 = ui->x1 / 2;               /* rounds down */
+            ui->x2 = (ui->x2+1) / 2;           /* rounds up */
+            ui->y1 = ui->y1 / 2;               /* rounds down */
+            ui->y2 = (ui->y2+1) / 2;           /* rounds up */
+        } else {
+            ui->x1 = -1;
+            ui->y1 = -1;
+            ui->x2 = -1;
+            ui->y2 = -1;
+        }
+    }
+
+    ret = NULL;
+
+    if (enddrag && (ui->drag_start_x >= 0)) {
+        if (xc >= 0 && xc <= 2*from->w &&
+            yc >= 0 && yc <= 2*from->h &&
+            erasing == ui->erasing) {
+
+            if (ui->dragged) {
+                if (ui_draw_rect(from, ui, from->hedge,
+                                 from->vedge, 1, FALSE, !ui->erasing)) {
+                    sprintf(buf, "%c%d,%d,%d,%d",
+                            (int)(ui->erasing ? 'E' : 'R'),
+                            ui->x1, ui->y1, ui->x2 - ui->x1, ui->y2 - ui->y1);
+                    ret = dupstr(buf);
+                }
+            } else {
+                if ((xc & 1) && !(yc & 1) && HRANGE(from,xc/2,yc/2)) {
+                    sprintf(buf, "H%d,%d", xc/2, yc/2);
+                    ret = dupstr(buf);
+                }
+                if ((yc & 1) && !(xc & 1) && VRANGE(from,xc/2,yc/2)) {
+                    sprintf(buf, "V%d,%d", xc/2, yc/2);
+                    ret = dupstr(buf);
+                }
+            }
+        }
+
+        reset_ui(ui);
+        active = TRUE;
+    }
+
+    if (ret)
+        return ret;                    /* a move has been made */
+    else if (active)
+        return "";                     /* UI activity has occurred */
+    else
+        return NULL;
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    game_state *ret;
+    int x1, y1, x2, y2, mode;
+
+    if (move[0] == 'S') {
+        const char *p = move+1;
+        int x, y;
+
+        ret = dup_game(from);
+        ret->cheated = TRUE;
+
+        for (y = 0; y < ret->h; y++)
+            for (x = 1; x < ret->w; x++) {
+                vedge(ret, x, y) = (*p == '1');
+                if (*p) p++;
+            }
+        for (y = 1; y < ret->h; y++)
+            for (x = 0; x < ret->w; x++) {
+                hedge(ret, x, y) = (*p == '1');
+                if (*p) p++;
+            }
+
+        sfree(ret->correct);
+        ret->correct = get_correct(ret);
+
+        return ret;
+
+    } else if ((move[0] == 'R' || move[0] == 'E') &&
+        sscanf(move+1, "%d,%d,%d,%d", &x1, &y1, &x2, &y2) == 4 &&
+        x1 >= 0 && x2 >= 0 && x1+x2 <= from->w &&
+        y1 >= 0 && y2 >= 0 && y1+y2 <= from->h) {
+        x2 += x1;
+        y2 += y1;
+        mode = move[0];
+    } else if ((move[0] == 'H' || move[0] == 'V') &&
+               sscanf(move+1, "%d,%d", &x1, &y1) == 2 &&
+               (move[0] == 'H' ? HRANGE(from, x1, y1) :
+                VRANGE(from, x1, y1))) {
+        mode = move[0];
+    } else
+        return NULL;                   /* can't parse move string */
+
+    ret = dup_game(from);
+
+    if (mode == 'R' || mode == 'E') {
+        grid_draw_rect(ret, ret->hedge, ret->vedge, 1, TRUE,
+                       mode == 'R', x1, y1, x2, y2);
+    } else if (mode == 'H') {
+        hedge(ret,x1,y1) = !hedge(ret,x1,y1);
+    } else if (mode == 'V') {
+        vedge(ret,x1,y1) = !vedge(ret,x1,y1);
+    }
+
+    sfree(ret->correct);
+    ret->correct = get_correct(ret);
+
+    /*
+     * We've made a real change to the grid. Check to see
+     * if the game has been completed.
+     */
+    if (!ret->completed) {
+        int x, y, ok;
+
+        ok = TRUE;
+        for (x = 0; x < ret->w; x++)
+            for (y = 0; y < ret->h; y++)
+                if (!index(ret, ret->correct, x, y))
+                    ok = FALSE;
+
+        if (ok)
+            ret->completed = TRUE;
+    }
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define CORRECT (1L<<16)
+#define CURSOR  (1L<<17)
+
+#define COLOUR(k) ( (k)==1 ? COL_LINE : (k)==2 ? COL_DRAG : COL_DRAGERASE )
+#define MAX4(x,y,z,w) ( max(max(x,y),max(z,w)) )
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = params->w * TILE_SIZE + 2*BORDER + 1;
+    *y = params->h * TILE_SIZE + 2*BORDER + 1;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_GRID * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_GRID * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_GRID * 3 + 2] = 0.5F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_DRAG * 3 + 0] = 1.0F;
+    ret[COL_DRAG * 3 + 1] = 0.0F;
+    ret[COL_DRAG * 3 + 2] = 0.0F;
+
+    ret[COL_DRAGERASE * 3 + 0] = 0.2F;
+    ret[COL_DRAGERASE * 3 + 1] = 0.2F;
+    ret[COL_DRAGERASE * 3 + 2] = 1.0F;
+
+    ret[COL_CORRECT * 3 + 0] = 0.75F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_CORRECT * 3 + 1] = 0.75F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_CORRECT * 3 + 2] = 0.75F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_LINE * 3 + 0] = 0.0F;
+    ret[COL_LINE * 3 + 1] = 0.0F;
+    ret[COL_LINE * 3 + 2] = 0.0F;
+
+    ret[COL_TEXT * 3 + 0] = 0.0F;
+    ret[COL_TEXT * 3 + 1] = 0.0F;
+    ret[COL_TEXT * 3 + 2] = 0.0F;
+
+    ret[COL_CURSOR * 3 + 0] = 1.0F;
+    ret[COL_CURSOR * 3 + 1] = 0.5F;
+    ret[COL_CURSOR * 3 + 2] = 0.5F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->started = FALSE;
+    ds->w = state->w;
+    ds->h = state->h;
+    ds->visible = snewn(ds->w * ds->h, unsigned long);
+    ds->tilesize = 0;                  /* not decided yet */
+    for (i = 0; i < ds->w * ds->h; i++)
+        ds->visible[i] = 0xFFFF;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->visible);
+    sfree(ds);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds, const game_state *state,
+                      int x, int y, unsigned char *hedge, unsigned char *vedge,
+                      unsigned char *corners, unsigned long bgflags)
+{
+    int cx = COORD(x), cy = COORD(y);
+    char str[80];
+
+    draw_rect(dr, cx, cy, TILE_SIZE+1, TILE_SIZE+1, COL_GRID);
+    draw_rect(dr, cx+1, cy+1, TILE_SIZE-1, TILE_SIZE-1,
+              (bgflags & CURSOR) ? COL_CURSOR :
+              (bgflags & CORRECT) ? COL_CORRECT : COL_BACKGROUND);
+
+    if (grid(state,x,y)) {
+        sprintf(str, "%d", grid(state,x,y));
+        draw_text(dr, cx+TILE_SIZE/2, cy+TILE_SIZE/2, FONT_VARIABLE,
+                  TILE_SIZE/2, ALIGN_HCENTRE | ALIGN_VCENTRE, COL_TEXT, str);
+    }
+
+    /*
+     * Draw edges.
+     */
+    if (!HRANGE(state,x,y) || index(state,hedge,x,y))
+        draw_rect(dr, cx, cy, TILE_SIZE+1, 2,
+                  HRANGE(state,x,y) ? COLOUR(index(state,hedge,x,y)) :
+                  COL_LINE);
+    if (!HRANGE(state,x,y+1) || index(state,hedge,x,y+1))
+        draw_rect(dr, cx, cy+TILE_SIZE-1, TILE_SIZE+1, 2,
+                  HRANGE(state,x,y+1) ? COLOUR(index(state,hedge,x,y+1)) :
+                  COL_LINE);
+    if (!VRANGE(state,x,y) || index(state,vedge,x,y))
+        draw_rect(dr, cx, cy, 2, TILE_SIZE+1,
+                  VRANGE(state,x,y) ? COLOUR(index(state,vedge,x,y)) :
+                  COL_LINE);
+    if (!VRANGE(state,x+1,y) || index(state,vedge,x+1,y))
+        draw_rect(dr, cx+TILE_SIZE-1, cy, 2, TILE_SIZE+1,
+                  VRANGE(state,x+1,y) ? COLOUR(index(state,vedge,x+1,y)) :
+                  COL_LINE);
+
+    /*
+     * Draw corners.
+     */
+    if (index(state,corners,x,y))
+        draw_rect(dr, cx, cy, 2, 2,
+                  COLOUR(index(state,corners,x,y)));
+    if (x+1 < state->w && index(state,corners,x+1,y))
+        draw_rect(dr, cx+TILE_SIZE-1, cy, 2, 2,
+                  COLOUR(index(state,corners,x+1,y)));
+    if (y+1 < state->h && index(state,corners,x,y+1))
+        draw_rect(dr, cx, cy+TILE_SIZE-1, 2, 2,
+                  COLOUR(index(state,corners,x,y+1)));
+    if (x+1 < state->w && y+1 < state->h && index(state,corners,x+1,y+1))
+        draw_rect(dr, cx+TILE_SIZE-1, cy+TILE_SIZE-1, 2, 2,
+                  COLOUR(index(state,corners,x+1,y+1)));
+
+    draw_update(dr, cx, cy, TILE_SIZE+1, TILE_SIZE+1);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int x, y;
+    unsigned char *hedge, *vedge, *corners;
+
+    if (ui->dragged) {
+        hedge = snewn(state->w*state->h, unsigned char);
+        vedge = snewn(state->w*state->h, unsigned char);
+        memcpy(hedge, state->hedge, state->w*state->h);
+        memcpy(vedge, state->vedge, state->w*state->h);
+        ui_draw_rect(state, ui, hedge, vedge, ui->erasing ? 3 : 2, TRUE, TRUE);
+    } else {
+        hedge = state->hedge;
+        vedge = state->vedge;
+    }
+
+    corners = snewn(state->w * state->h, unsigned char);
+    memset(corners, 0, state->w * state->h);
+    for (x = 0; x < state->w; x++)
+        for (y = 0; y < state->h; y++) {
+            if (x > 0) {
+                int e = index(state, vedge, x, y);
+                if (index(state,corners,x,y) < e)
+                    index(state,corners,x,y) = e;
+                if (y+1 < state->h &&
+                    index(state,corners,x,y+1) < e)
+                    index(state,corners,x,y+1) = e;
+            }
+            if (y > 0) {
+                int e = index(state, hedge, x, y);
+                if (index(state,corners,x,y) < e)
+                    index(state,corners,x,y) = e;
+                if (x+1 < state->w &&
+                    index(state,corners,x+1,y) < e)
+                    index(state,corners,x+1,y) = e;
+            }
+        }
+
+    if (!ds->started) {
+        draw_rect(dr, 0, 0,
+                  state->w * TILE_SIZE + 2*BORDER + 1,
+                  state->h * TILE_SIZE + 2*BORDER + 1, COL_BACKGROUND);
+        draw_rect(dr, COORD(0)-1, COORD(0)-1,
+                  ds->w*TILE_SIZE+3, ds->h*TILE_SIZE+3, COL_LINE);
+        ds->started = TRUE;
+        draw_update(dr, 0, 0,
+                    state->w * TILE_SIZE + 2*BORDER + 1,
+                    state->h * TILE_SIZE + 2*BORDER + 1);
+    }
+
+    for (x = 0; x < state->w; x++)
+        for (y = 0; y < state->h; y++) {
+            unsigned long c = 0;
+
+            if (HRANGE(state,x,y))
+                c |= index(state,hedge,x,y);
+            if (HRANGE(state,x,y+1))
+                c |= index(state,hedge,x,y+1) << 2;
+            if (VRANGE(state,x,y))
+                c |= index(state,vedge,x,y) << 4;
+            if (VRANGE(state,x+1,y))
+                c |= index(state,vedge,x+1,y) << 6;
+            c |= index(state,corners,x,y) << 8;
+            if (x+1 < state->w)
+                c |= index(state,corners,x+1,y) << 10;
+            if (y+1 < state->h)
+                c |= index(state,corners,x,y+1) << 12;
+            if (x+1 < state->w && y+1 < state->h)
+                /* cast to prevent 2<<14 sign-extending on promotion to long */
+                c |= (unsigned long)index(state,corners,x+1,y+1) << 14;
+            if (index(state, state->correct, x, y) && !flashtime)
+                c |= CORRECT;
+            if (ui->cur_visible && ui->cur_x == x && ui->cur_y == y)
+                c |= CURSOR;
+
+            if (index(ds,ds->visible,x,y) != c) {
+                draw_tile(dr, ds, state, x, y, hedge, vedge, corners,
+                          (c & (CORRECT|CURSOR)) );
+                index(ds,ds->visible,x,y) = c;
+            }
+        }
+
+    {
+        char buf[256];
+
+        if (ui->dragged &&
+            ui->x1 >= 0 && ui->y1 >= 0 &&
+            ui->x2 >= 0 && ui->y2 >= 0) {
+            sprintf(buf, "%dx%d ",
+                    ui->x2-ui->x1,
+                    ui->y2-ui->y1);
+        } else {
+            buf[0] = '\0';
+        }
+
+        if (state->cheated)
+            strcat(buf, "Auto-solved.");
+        else if (state->completed)
+            strcat(buf, "COMPLETED!");
+
+        status_bar(dr, buf);
+    }
+
+    if (hedge != state->hedge) {
+        sfree(hedge);
+        sfree(vedge);
+    }
+
+    sfree(corners);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 5mm squares by default.
+     */
+    game_compute_size(params, 500, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->w, h = state->h;
+    int ink = print_mono_colour(dr, 0);
+    int x, y;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    /*
+     * Border.
+     */
+    print_line_width(dr, TILE_SIZE / 10);
+    draw_rect_outline(dr, COORD(0), COORD(0), w*TILE_SIZE, h*TILE_SIZE, ink);
+
+    /*
+     * Grid. We have to make the grid lines particularly thin,
+     * because users will be drawing lines _along_ them and we want
+     * those lines to be visible.
+     */
+    print_line_width(dr, TILE_SIZE / 256);
+    for (x = 1; x < w; x++)
+        draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h), ink);
+    for (y = 1; y < h; y++)
+        draw_line(dr, COORD(0), COORD(y), COORD(w), COORD(y), ink);
+
+    /*
+     * Solution.
+     */
+    print_line_width(dr, TILE_SIZE / 10);
+    for (y = 0; y <= h; y++)
+        for (x = 0; x <= w; x++) {
+            if (HRANGE(state,x,y) && hedge(state,x,y))
+                draw_line(dr, COORD(x), COORD(y), COORD(x+1), COORD(y), ink);
+            if (VRANGE(state,x,y) && vedge(state,x,y))
+                draw_line(dr, COORD(x), COORD(y), COORD(x), COORD(y+1), ink);
+        }
+
+    /*
+     * Clues.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            if (grid(state,x,y)) {
+                char str[80];
+                sprintf(str, "%d", grid(state,x,y));
+                draw_text(dr, COORD(x)+TILE_SIZE/2, COORD(y)+TILE_SIZE/2,
+                          FONT_VARIABLE, TILE_SIZE/2,
+                          ALIGN_HCENTRE | ALIGN_VCENTRE, ink, str);
+            }
+}
+
+#ifdef COMBINED
+#define thegame rect
+#endif
+
+const struct game thegame = {
+    "Rectangles", "games.rectangles", "rect",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/resource.h b/apps/plugins/puzzles/resource.h
new file mode 100644
index 0000000000..f0bfa16d6d
--- /dev/null
+++ b/apps/plugins/puzzles/resource.h
@@ -0,0 +1,20 @@
+
+#define IDR_MENUBAR1                    101
+
+#define ID_GAME                         40005
+#define ID_TYPE                         40006
+
+#define IDS_CAP_GAME                    40105
+#define IDS_CAP_TYPE                    40106
+
+#define IDD_ABOUT                       2000
+#define IDC_ABOUT_CAPTION               2001
+#define IDC_ABOUT_LINE                  2002
+#define IDC_ABOUT_GAME                  2003
+#define IDC_ABOUT_VERSION               2004
+
+#define IDD_CONFIG                      2100
+#define IDC_CONFIG_CAPTION              2101
+#define IDC_CONFIG_LINE                 2102
+
+#define IDR_PADTOOLBAR                  4000
diff --git a/apps/plugins/puzzles/rockbox.c b/apps/plugins/puzzles/rockbox.c
new file mode 100644
index 0000000000..3a1c00e615
--- /dev/null
+++ b/apps/plugins/puzzles/rockbox.c
@@ -0,0 +1,1682 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2016 Franklin Wei
+ *
+ * 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* rockbox frontend for puzzles */
+
+#include "plugin.h"
+
+#include "puzzles.h"
+#include "keymaps.h"
+
+#ifndef COMBINED
+#include "lib/playback_control.h"
+#endif
+#include "lib/xlcd.h"
+
+/* how many ticks between timer callbacks */
+#define TIMER_INTERVAL (HZ / 50)
+#define BG_R .9f /* very light gray */
+#define BG_G .9f
+#define BG_B .9f
+
+#ifdef COMBINED
+#define SAVE_FILE PLUGIN_GAMES_DATA_DIR "/puzzles.sav"
+#else
+static char save_file_path[MAX_PATH];
+#define SAVE_FILE ((const char*)save_file_path)
+#endif
+
+#define BG_COLOR LCD_RGBPACK((int)(255*BG_R), (int)(255*BG_G), (int)(255*BG_B))
+
+#define MURICA
+
+#ifdef MURICA
+#define midend_serialize midend_serialise
+#define midend_deserialize midend_deserialise
+#define frontend_default_color frontend_default_colour
+#define midend_colors midend_colours
+#endif
+
+static midend *me = NULL;
+static unsigned *colors = NULL;
+static int ncolors = 0;
+static long last_keystate = 0;
+
+static void fix_size(void);
+
+static void rb_start_draw(void *handle)
+{
+    (void) handle;
+}
+
+static struct viewport clip_rect;
+static bool clipped = false;
+
+static struct settings_t {
+    int slowmo_factor;
+    bool bulk, timerflash;
+} settings;
+
+/* clipping is implemented through viewports and offsetting
+ * coordinates */
+static void rb_clip(void *handle, int x, int y, int w, int h)
+{
+    LOGF("rb_clip(%d %d %d %d)", x, y, w, h);
+    clip_rect.x = x;
+    clip_rect.y = y;
+    clip_rect.width  = w;
+    clip_rect.height = h;
+    clip_rect.font = FONT_UI;
+    clip_rect.drawmode = DRMODE_SOLID;
+#if LCD_DEPTH > 1
+    clip_rect.fg_pattern = LCD_DEFAULT_FG;
+    clip_rect.bg_pattern = LCD_DEFAULT_BG;
+#endif
+    rb->lcd_set_viewport(&clip_rect);
+    clipped = true;
+}
+
+static void rb_unclip(void *handle)
+{
+    LOGF("rb_unclip");
+    rb->lcd_set_viewport(NULL);
+    clipped = false;
+}
+
+static void offset_coords(int *x, int *y)
+{
+    if(clipped)
+    {
+        *x -= clip_rect.x;
+        *y -= clip_rect.y;
+    }
+}
+
+static void rb_color(int n)
+{
+    if(n < 0)
+    {
+        fatal("bad color %d", n);
+        return;
+    }
+    rb->lcd_set_foreground(colors[n]);
+}
+
+static void rb_draw_text(void *handle, int x, int y, int fonttype,
+                         int fontsize, int align, int color, char *text)
+{
+    (void) fontsize;
+    LOGF("rb_draw_text(%d %d %s)", x, y, text);
+
+    offset_coords(&x, &y);
+
+    /* TODO: variable font size */
+    switch(fonttype)
+    {
+    case FONT_FIXED:
+        rb->lcd_setfont(FONT_SYSFIXED);
+        break;
+    case FONT_VARIABLE:
+        rb->lcd_setfont(FONT_UI);
+        break;
+    default:
+        fatal("bad font");
+        break;
+    }
+
+    int w, h;
+    rb->lcd_getstringsize(text, &w, &h);
+
+    static int cap_h = -1;
+    if(cap_h < 0)
+        rb->lcd_getstringsize("X", NULL, &cap_h);
+
+    if(align & ALIGN_VNORMAL)
+        y -= h;
+    else if(align & ALIGN_VCENTRE)
+        y -= cap_h / 2;
+
+    if(align & ALIGN_HCENTRE)
+        x -= w / 2;
+    else if(align & ALIGN_HRIGHT)
+        x -= w;
+
+    rb_color(color);
+    rb->lcd_set_drawmode(DRMODE_COMPLEMENT);
+    rb->lcd_putsxy(x, y, text);
+    rb->lcd_set_drawmode(DRMODE_SOLID);
+}
+
+static void rb_draw_rect(void *handle, int x, int y, int w, int h, int color)
+{
+    LOGF("rb_draw_rect(%d, %d, %d, %d, %d)", x, y, w, h, color);
+    rb_color(color);
+    offset_coords(&x, &y);
+    rb->lcd_fillrect(x, y, w, h);
+}
+
+static void rb_draw_line(void *handle, int x1, int y1, int x2, int y2,
+                         int color)
+{
+    LOGF("rb_draw_line(%d, %d, %d, %d, %d)", x1, y1, x2, y2, color);
+    offset_coords(&x1, &y1);
+    offset_coords(&x2, &y2);
+    rb_color(color);
+    rb->lcd_drawline(x1, y1, x2, y2);
+}
+
+/*
+ * draw filled polygon
+ * originally by Sebastian Leonhardt (ulmutul)
+ * 'count' : number of coordinate pairs
+ * 'pxy': array of coordinates. pxy[0]=x0,pxy[1]=y0,...
+ * note: provide space for one extra coordinate, because the starting point
+ * will automatically be inserted as end point.
+ */
+
+/*
+ * helper function:
+ * find points of intersection between polygon and scanline
+ */
+
+#define MAX_INTERSECTION 32
+
+static void fill_poly_line(int scanline, int count, int *pxy)
+{
+    int i;
+    int j;
+    int num_of_intersects;
+    int direct, old_direct;
+    //intersections of every line with scanline (y-coord)
+    int intersection[MAX_INTERSECTION];
+    /* add starting point as ending point */
+    pxy[count*2] = pxy[0];
+    pxy[count*2+1] = pxy[1];
+
+    old_direct=0;
+    num_of_intersects=0;
+    for (i=0; i<count*2; i+=2) {
+        int x1=pxy[i];
+        int y1=pxy[i+1];
+        int x2=pxy[i+2];
+        int y2=pxy[i+3];
+        // skip if line is outside of scanline
+        if (y1 < y2) {
+            if (scanline < y1 || scanline > y2)
+                continue;
+        }
+        else {
+            if (scanline < y2 || scanline > y1)
+                continue;
+        }
+        // calculate x-coord of intersection
+        if (y1==y2) {
+            direct=0;
+        }
+        else {
+            direct = y1>y2 ? 1 : -1;
+            // omit double intersections, if both lines lead in the same direction
+            intersection[num_of_intersects] =
+                x1+((scanline-y1)*(x2-x1))/(y2-y1);
+            if ( (direct!=old_direct)
+                  || (intersection[num_of_intersects] != intersection[num_of_intersects-1])
+                )
+                ++num_of_intersects;
+        }
+        old_direct = direct;
+    }
+
+    // sort points of intersection
+    for (i=0; i<num_of_intersects-1; ++i) {
+        for (j=i+1; j<num_of_intersects; ++j) {
+            if (intersection[j]<intersection[i]) {
+                int temp=intersection[i];
+                intersection[i]=intersection[j];
+                intersection[j]=temp;
+            }
+        }
+    }
+    // draw
+    for (i=0; i<num_of_intersects; i+=2) {
+        rb->lcd_hline(intersection[i], intersection[i+1], scanline);
+    }
+}
+
+/* two extra elements at end of pxy needed */
+static void v_fillarea(int count, int *pxy)
+{
+    int i;
+    int y1, y2;
+
+    // find min and max y coords
+    y1=y2=pxy[1];
+    for (i=3; i<count*2; i+=2) {
+        if (pxy[i] < y1) y1 = pxy[i];
+        else if (pxy[i] > y2) y2 = pxy[i];
+    }
+
+    for (i=y1; i<=y2; ++i) {
+        fill_poly_line(i, count, pxy);
+    }
+}
+
+static void rb_draw_poly(void *handle, int *coords, int npoints,
+                         int fillcolor, int outlinecolor)
+{
+    LOGF("rb_draw_poly");
+
+    if(fillcolor >= 0)
+    {
+        rb_color(fillcolor);
+#if 1
+        /* serious hack: draw a bunch of triangles between adjacent points */
+        /* this generally works, even with some concave polygons */
+        for(int i = 2; i < npoints; ++i)
+        {
+            int x1, y1, x2, y2, x3, y3;
+            x1 = coords[0];
+            y1 = coords[1];
+            x2 = coords[(i - 1) * 2];
+            y2 = coords[(i - 1) * 2 + 1];
+            x3 = coords[i * 2];
+            y3 = coords[i * 2 + 1];
+            offset_coords(&x1, &y1);
+            offset_coords(&x2, &y2);
+            offset_coords(&x3, &y3);
+            xlcd_filltriangle(x1, y1,
+                              x2, y2,
+                              x3, y3);
+
+#if 0
+            /* debug code */
+            rb->lcd_set_foreground(LCD_RGBPACK(255,0,0));
+            rb->lcd_drawpixel(x1, y1);
+            rb->lcd_drawpixel(x2, y2);
+            rb->lcd_drawpixel(x3, y3);
+            rb->lcd_update();
+            rb->sleep(HZ);
+            rb_color(fillcolor);
+            rb->lcd_drawpixel(x1, y1);
+            rb->lcd_drawpixel(x2, y2);
+            rb->lcd_drawpixel(x3, y3);
+            rb->lcd_update();
+#endif
+        }
+#else
+        int *pxy = smalloc(sizeof(int) * 2 * npoints + 2);
+        /* copy points, offsetted */
+        for(int i = 0; i < npoints; ++i)
+        {
+            pxy[2 * i + 0] = coords[2 * i + 0];
+            pxy[2 * i + 1] = coords[2 * i + 1];
+            offset_coords(&pxy[2*i+0], &pxy[2*i+1]);
+        }
+        v_fillarea(npoints, pxy);
+        sfree(pxy);
+#endif
+    }
+
+    /* draw outlines last so they're not covered by the fill */
+    assert(outlinecolor >= 0);
+    rb_color(outlinecolor);
+
+    for(int i = 1; i < npoints; ++i)
+    {
+        int x1, y1, x2, y2;
+        x1 = coords[2 * (i - 1)];
+        y1 = coords[2 * (i - 1) + 1];
+        x2 = coords[2 * i];
+        y2 = coords[2 * i + 1];
+        offset_coords(&x1, &y1);
+        offset_coords(&x2, &y2);
+        rb->lcd_drawline(x1, y1,
+                         x2, y2);
+        //rb->lcd_update();
+        //rb->sleep(HZ/2);
+    }
+
+    int x1, y1, x2, y2;
+    x1 = coords[0];
+    y1 = coords[1];
+    x2 = coords[2 * (npoints - 1)];
+    y2 = coords[2 * (npoints - 1) + 1];
+    offset_coords(&x1, &y1);
+    offset_coords(&x2, &y2);
+
+    rb->lcd_drawline(x1, y1,
+                     x2, y2);
+}
+
+static void rb_draw_circle(void *handle, int cx, int cy, int radius,
+                           int fillcolor, int outlinecolor)
+{
+    LOGF("rb_draw_circle(%d, %d, %d)", cx, cy, radius);
+    offset_coords(&cx, &cy);
+
+    if(fillcolor >= 0)
+    {
+        rb_color(fillcolor);
+        xlcd_fillcircle(cx, cy, radius - 1);
+    }
+
+    assert(outlinecolor >= 0);
+    rb_color(outlinecolor);
+    xlcd_drawcircle(cx, cy, radius - 1);
+}
+
+struct blitter {
+    bool have_data;
+    int x, y;
+    struct bitmap bmp;
+};
+
+static blitter *rb_blitter_new(void *handle, int w, int h)
+{
+    LOGF("rb_blitter_new");
+    blitter *b = snew(blitter);
+    b->bmp.width = w;
+    b->bmp.height = h;
+    b->bmp.data = smalloc(w * h * sizeof(fb_data));
+    b->have_data = false;
+    return b;
+}
+
+static void rb_blitter_free(void *handle, blitter *bl)
+{
+    LOGF("rb_blitter_free");
+    sfree(bl->bmp.data);
+    sfree(bl);
+    return;
+}
+
+static void trim_rect(int *x, int *y, int *w, int *h)
+{
+    int x0, x1, y0, y1;
+
+    /*
+     * Reduce the size of the copied rectangle to stop it going
+     * outside the bounds of the canvas.
+     */
+
+    /* Transform from x,y,w,h form into coordinates of all edges */
+    x0 = *x;
+    y0 = *y;
+    x1 = *x + *w;
+    y1 = *y + *h;
+
+    /* Clip each coordinate at both extremes of the canvas */
+    x0 = (x0 < 0 ? 0 : x0 > LCD_WIDTH ? LCD_WIDTH : x0);
+    x1 = (x1 < 0 ? 0 : x1 > LCD_WIDTH ? LCD_WIDTH : x1);
+    y0 = (y0 < 0 ? 0 : y0 > LCD_HEIGHT ? LCD_HEIGHT : y0);
+    y1 = (y1 < 0 ? 0 : y1 > LCD_HEIGHT ? LCD_HEIGHT : y1);
+
+    /* Transform back into x,y,w,h to return */
+    *x = x0;
+    *y = y0;
+    *w = x1 - x0;
+    *h = y1 - y0;
+}
+
+/* copy a section of the framebuffer */
+static void rb_blitter_save(void *handle, blitter *bl, int x, int y)
+{
+    /* no viewport offset */
+#if defined(LCD_STRIDEFORMAT) && (LCD_STRIDEFORMAT == VERTICAL_STRIDE)
+#error no vertical stride
+#else
+    if(bl->bmp.data)
+    {
+        int w = bl->bmp.width, h = bl->bmp.height;
+        trim_rect(&x, &y, &w, &h);
+        LOGF("rb_blitter_save(%d, %d, %d, %d)", x, y, w, h);
+        for(int i = 0; i < h; ++i)
+        {
+            /* copy line-by-line */
+            rb->memcpy(bl->bmp.data + sizeof(fb_data) * i * w,
+                       rb->lcd_framebuffer + (y + i) * LCD_WIDTH + x,
+                       w * sizeof(fb_data));
+        }
+        bl->x = x;
+        bl->y = y;
+        bl->have_data = true;
+    }
+#endif
+}
+
+static void rb_blitter_load(void *handle, blitter *bl, int x, int y)
+{
+    LOGF("rb_blitter_load");
+    if(!bl->have_data)
+        return;
+    int w = bl->bmp.width, h = bl->bmp.height;
+
+    if(x == BLITTER_FROMSAVED) x = bl->x;
+    if(y == BLITTER_FROMSAVED) y = bl->y;
+
+    offset_coords(&x, &y);
+    trim_rect(&x, &y, &w, &h);
+    rb->lcd_bitmap((fb_data*)bl->bmp.data, x, y, w, h);
+}
+
+static void rb_draw_update(void *handle, int x, int y, int w, int h)
+{
+    LOGF("rb_draw_update(%d, %d, %d, %d)", x, y, w, h);
+    if(!settings.bulk)
+        rb->lcd_update_rect(x, y, w, h);
+    else
+        rb->lcd_update();
+}
+
+static void rb_end_draw(void *handle)
+{
+    LOGF("rb_end_draw");
+}
+
+static char *titlebar = NULL;
+
+static void rb_status_bar(void *handle, char *text)
+{
+    if(titlebar)
+        sfree(titlebar);
+    titlebar = dupstr(text);
+    LOGF("game title is %s\n", text);
+}
+
+static void draw_title(void)
+{
+    const char *str = NULL;
+    if(titlebar)
+        str = titlebar;
+    else
+        str = midend_which_game(me)->name;
+
+    /* quick hack */
+    bool orig_clipped = clipped;
+    if(orig_clipped)
+        rb_unclip(NULL);
+
+    int h;
+    rb->lcd_setfont(FONT_UI);
+    rb->lcd_getstringsize(str, NULL, &h);
+
+    rb->lcd_set_foreground(BG_COLOR);
+    rb->lcd_fillrect(0, LCD_HEIGHT - h, LCD_WIDTH, h);
+
+    rb->lcd_set_foreground(LCD_BLACK);
+    rb->lcd_putsxy(0, LCD_HEIGHT - h, str);
+    rb->lcd_update_rect(0, LCD_HEIGHT - h, LCD_WIDTH, h);
+
+    if(orig_clipped)
+        rb_clip(NULL, clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height);
+}
+
+static char *rb_text_fallback(void *handle, const char *const *strings,
+                              int nstrings)
+{
+    return dupstr(strings[0]);
+}
+
+const drawing_api rb_drawing = {
+    rb_draw_text,
+    rb_draw_rect,
+    rb_draw_line,
+    rb_draw_poly,
+    rb_draw_circle,
+    rb_draw_update,
+    rb_clip,
+    rb_unclip,
+    rb_start_draw,
+    rb_end_draw,
+    rb_status_bar,
+    rb_blitter_new,
+    rb_blitter_free,
+    rb_blitter_save,
+    rb_blitter_load,
+    NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */
+    NULL, NULL,                        /* line_width, line_dotted */
+    rb_text_fallback,
+    NULL,
+};
+
+void frontend_default_color(frontend *fe, float *out)
+{
+    *out++ = BG_R;
+    *out++ = BG_G;
+    *out++ = BG_B;
+}
+
+void fatal(char *fmt, ...)
+{
+    va_list ap;
+
+    rb->splash(HZ, "FATAL ERROR");
+
+    va_start(ap, fmt);
+    char buf[80];
+    rb->vsnprintf(buf, 80, fmt, ap);
+    rb->splash(HZ * 2, buf);
+    va_end(ap);
+
+    exit(1);
+}
+
+void get_random_seed(void **randseed, int *randseedsize)
+{
+    *randseed = snew(long);
+    long seed = *rb->current_tick;
+    rb->memcpy(*randseed, &seed, sizeof(seed));
+    //*(long*)*randseed = 42; // debug
+    //rb->splash(HZ, "DEBUG SEED ON");
+    *randseedsize = sizeof(long);
+}
+
+const char *config_choices_formatter(int sel, void *data, char *buf, size_t len)
+{
+    /* we can't rely on being called in any particular order */
+    char *list = dupstr(data);
+    char delimbuf[2] = { *list, 0 };
+    char *save = NULL;
+    char *str = rb->strtok_r(list, delimbuf, &save);
+    for(int i = 0; i < sel; ++i)
+        str = rb->strtok_r(NULL, delimbuf, &save);
+    rb->snprintf(buf, len, "%s", str);
+    sfree(list);
+    return buf;
+}
+
+static int list_choose(const char *list_str, const char *title)
+{
+    char delim = *list_str;
+
+    const char *ptr = list_str + 1;
+    int n = 0;
+    while(ptr)
+    {
+        n++;
+        ptr = strchr(ptr + 1, delim);
+    }
+
+    struct gui_synclist list;
+
+    rb->gui_synclist_init(&list, &config_choices_formatter, (void*)list_str, false, 1, NULL);
+    rb->gui_synclist_set_icon_callback(&list, NULL);
+    rb->gui_synclist_set_nb_items(&list, n);
+    rb->gui_synclist_limit_scroll(&list, false);
+
+    rb->gui_synclist_select_item(&list, 0);
+
+    rb->gui_synclist_set_title(&list, (char*)title, NOICON);
+    while (1)
+    {
+        rb->gui_synclist_draw(&list);
+        int button = rb->get_action(CONTEXT_LIST, TIMEOUT_BLOCK);
+        if(rb->gui_synclist_do_button(&list, &button, LIST_WRAP_ON))
+            continue;
+        switch(button)
+        {
+        case ACTION_STD_OK:
+            return rb->gui_synclist_get_sel_pos(&list);
+        case ACTION_STD_PREV:
+        case ACTION_STD_CANCEL:
+            return -1;
+        default:
+            break;
+        }
+    }
+}
+
+static void do_configure_item(config_item *cfg)
+{
+    switch(cfg->type)
+    {
+    case C_STRING:
+    {
+#define MAX_STRLEN 128
+        char *newstr = smalloc(MAX_STRLEN);
+        rb->strlcpy(newstr, cfg->sval, MAX_STRLEN);
+        rb->lcd_set_foreground(LCD_WHITE);
+        rb->lcd_set_background(LCD_BLACK);
+        if(rb->kbd_input(newstr, MAX_STRLEN) < 0)
+        {
+            sfree(newstr);
+            break;
+        }
+        sfree(cfg->sval);
+        cfg->sval = newstr;
+        break;
+    }
+    case C_BOOLEAN:
+    {
+        bool res = cfg->ival != 0;
+        rb->set_bool(cfg->name, &res);
+        cfg->ival = res;
+        break;
+    }
+    case C_CHOICES:
+    {
+        int sel = list_choose(cfg->sval, cfg->name);
+        if(sel >= 0)
+            cfg->ival = sel;
+        break;
+    }
+    default:
+        fatal("bad type");
+        break;
+    }
+}
+
+const char *config_formatter(int sel, void *data, char *buf, size_t len)
+{
+    config_item *cfg = data;
+    cfg += sel;
+    rb->snprintf(buf, len, "%s", cfg->name);
+    return buf;
+}
+
+static void config_menu(void)
+{
+    char *title;
+    config_item *config = midend_get_config(me, CFG_SETTINGS, &title);
+
+    if(!config)
+    {
+        rb->splash(HZ, "Nothing to configure.");
+        goto done;
+    }
+
+    /* count */
+    int n = 0;
+    config_item *ptr = config;
+    while(ptr->type != C_END)
+    {
+        n++;
+        ptr++;
+    }
+
+    /* display a list */
+    struct gui_synclist list;
+
+    rb->gui_synclist_init(&list, &config_formatter, config, false, 1, NULL);
+    rb->gui_synclist_set_icon_callback(&list, NULL);
+    rb->gui_synclist_set_nb_items(&list, n);
+    rb->gui_synclist_limit_scroll(&list, false);
+
+    rb->gui_synclist_select_item(&list, 0);
+
+    bool done = false;
+    rb->gui_synclist_set_title(&list, title, NOICON);
+    while (!done)
+    {
+        rb->gui_synclist_draw(&list);
+        int button = rb->get_action(CONTEXT_LIST, TIMEOUT_BLOCK);
+        if(rb->gui_synclist_do_button(&list, &button, LIST_WRAP_ON))
+            continue;
+        switch(button)
+        {
+        case ACTION_STD_OK:
+        {
+            config_item old;
+            int pos = rb->gui_synclist_get_sel_pos(&list);
+            memcpy(&old, config + pos, sizeof(old));
+            do_configure_item(config + pos);
+            char *err = midend_set_config(me, CFG_SETTINGS, config);
+            if(err)
+            {
+                rb->splash(HZ, err);
+                memcpy(config + pos, &old, sizeof(old));
+            }
+            break;
+        }
+        case ACTION_STD_PREV:
+        case ACTION_STD_CANCEL:
+            done = true;
+            break;
+        default:
+            break;
+        }
+    }
+
+done:
+    sfree(title);
+    free_cfg(config);
+}
+
+const char *preset_formatter(int sel, void *data, char *buf, size_t len)
+{
+    char *name;
+    game_params *junk;
+    midend_fetch_preset(me, sel, &name, &junk);
+    rb->strlcpy(buf, name, len);
+    return buf;
+}
+
+static void presets_menu(void)
+{
+    if(!midend_num_presets(me))
+    {
+        rb->splash(HZ, "No presets!");
+        return;
+    }
+
+    /* display a list */
+    struct gui_synclist list;
+
+    rb->gui_synclist_init(&list, &preset_formatter, NULL, false, 1, NULL);
+    rb->gui_synclist_set_icon_callback(&list, NULL);
+    rb->gui_synclist_set_nb_items(&list, midend_num_presets(me));
+    rb->gui_synclist_limit_scroll(&list, false);
+
+    int current = midend_which_preset(me);
+    rb->gui_synclist_select_item(&list, current >= 0 ? current : 0);
+
+    bool done = false;
+    rb->gui_synclist_set_title(&list, "Game Type", NOICON);
+    while (!done)
+    {
+        rb->gui_synclist_draw(&list);
+        int button = rb->get_action(CONTEXT_LIST, TIMEOUT_BLOCK);
+        if(rb->gui_synclist_do_button(&list, &button, LIST_WRAP_ON))
+            continue;
+        switch(button)
+        {
+        case ACTION_STD_OK:
+        {
+            int sel = rb->gui_synclist_get_sel_pos(&list);
+            char *junk;
+            game_params *params;
+            midend_fetch_preset(me, sel, &junk, &params);
+            midend_set_params(me, params);
+            done = true;
+            break;
+        }
+        case ACTION_STD_PREV:
+        case ACTION_STD_CANCEL:
+            done = true;
+            break;
+        default:
+            break;
+        }
+    }
+}
+
+static const struct {
+    const char *game, *help;
+} quick_help_text[] = {
+    { "Black Box", "Find the hidden balls in the box by bouncing laser beams off them." },
+    { "Bridges", "Connect all the islands with a network of bridges." },
+    { "Cube", "Pick up all the blue squares by rolling the cube over them." },
+    { "Dominosa", "Tile the rectangle with a full set of dominoes." },
+    { "Fifteen", "Slide the tiles around to arrange them into order." },
+    { "Filling", "Mark every square with the area of its containing region." },
+    { "Flip", "Flip groups of squares to light them all up at once." },
+    { "Flood", "Turn the grid the same colour in as few flood fills as possible." },
+    { "Galaxies", "Divide the grid into rotationally symmetric regions each centred on a dot." },
+    { "Guess", "Guess the hidden combination of colours." },
+    { "Inertia", "Collect all the gems without running into any of the mines." },
+    { "Keen", "Complete the latin square in accordance with the arithmetic clues." },
+    { "Light Up", "Place bulbs to light up all the squares." },
+    { "Loopy", "Draw a single closed loop, given clues about number of adjacent edges." },
+    { "Magnets", "Place magnets to satisfy the clues and avoid like poles touching." },
+    { "Map", "Colour the map so that adjacent regions are never the same colour." },
+    { "Mines", "Find all the mines without treading on any of them." },
+    { "Net", "Rotate each tile to reassemble the network." },
+    { "Netslide", "Slide a row at a time to reassemble the network." },
+    { "Palisade", "Divide the grid into equal-sized areas in accordance with the clues." },
+    { "Pattern", "Fill in the pattern in the grid, given only the lengths of runs of black squares." },
+    { "Pearl", "Draw a single closed loop, given clues about corner and straight squares." },
+    { "Pegs", "Jump pegs over each other to remove all but one." },
+    { "Range", "Place black squares to limit the visible distance from each numbered cell." },
+    { "Rectangles", "Divide the grid into rectangles with areas equal to the numbers." },
+    { "Same Game", "Clear the grid by removing touching groups of the same colour squares." },
+    { "Signpost", "Connect the squares into a path following the arrows." },
+    { "Singles", "Black out the right set of duplicate numbers." },
+    { "Sixteen", "Slide a row at a time to arrange the tiles into order." },
+    { "Slant", "Draw a maze of slanting lines that matches the clues." },
+    { "Solo", "Fill in the grid so that each row, column and square block contains one of every digit." },
+    { "Tents", "Place a tent next to each tree." },
+    { "Towers", "Complete the latin square of towers in accordance with the clues." },
+    { "Tracks", "Fill in the railway track according to the clues." },
+    { "Twiddle", "Rotate the tiles around themselves to arrange them into order." },
+    { "Undead", "Place ghosts, vampires and zombies so that the right numbers of them can be seen in mirrors." },
+    { "Unequal", "Complete the latin square in accordance with the > signs." },
+    { "Unruly", "Fill in the black and white grid to avoid runs of three." },
+    { "Untangle", "Reposition the points so that the lines do not cross." },
+};
+
+static void quick_help(void)
+{
+    for(int i = 0; i < ARRAYLEN(quick_help_text); ++i)
+    {
+        if(!strcmp(midend_which_game(me)->name, quick_help_text[i].game))
+        {
+            rb->splash(0, quick_help_text[i].help);
+            rb->button_get(true);
+            return;
+        }
+    }
+}
+
+static void full_help(void)
+{
+    /* TODO */
+}
+
+static void init_default_settings(void)
+{
+    settings.slowmo_factor = 1;
+    settings.bulk = false;
+    settings.timerflash = false;
+}
+
+static void debug_menu(void)
+{
+    MENUITEM_STRINGLIST(menu, "Debug Menu", NULL,
+                        "Slowmo factor",
+                        "Randomize colors",
+                        "Toggle bulk update",
+                        "Toggle flash pixel on timer",
+                        "Back");
+    bool quit = false;
+    int sel = 0;
+    while(!quit)
+    {
+        switch(rb->do_menu(&menu, &sel, NULL, false))
+        {
+        case 0:
+            rb->set_int("Slowmo factor", "", UNIT_INT, &settings.slowmo_factor, NULL, 1, 1, 10, NULL);
+            break;
+        case 1:
+        {
+            unsigned *ptr = colors;
+            for(int i = 0; i < ncolors; ++i)
+            {
+                /* not seeded, who cares? */
+                *ptr++ = LCD_RGBPACK(rb->rand()%255, rb->rand()%255, rb->rand()%255);
+            }
+            break;
+        }
+        case 2:
+            settings.bulk = !settings.bulk;
+            break;
+        case 3:
+            settings.timerflash = !settings.timerflash;
+            break;
+        case 4:
+        default:
+            quit = true;
+            break;
+        }
+    }
+}
+
+static int pausemenu_cb(int action, const struct menu_item_ex *this_item)
+{
+    int i = (intptr_t) this_item;
+    if(action == ACTION_REQUEST_MENUITEM)
+    {
+        switch(i)
+        {
+        case 3:
+            if(!midend_can_undo(me))
+                return ACTION_EXIT_MENUITEM;
+            break;
+        case 4:
+            if(!midend_can_redo(me))
+                return ACTION_EXIT_MENUITEM;
+            break;
+        case 5:
+            if(!midend_which_game(me)->can_solve)
+                return ACTION_EXIT_MENUITEM;
+            break;
+        case 7:
+#ifdef FOR_REAL
+            return ACTION_EXIT_MENUITEM;
+#else
+            break;
+#endif
+        case 8:
+            if(!midend_num_presets(me))
+                return ACTION_EXIT_MENUITEM;
+            break;
+        case 9:
+#ifdef FOR_REAL
+            return ACTION_EXIT_MENUITEM;
+#else
+            break;
+#endif
+        case 10:
+            if(!midend_which_game(me)->can_configure)
+                return ACTION_EXIT_MENUITEM;
+            break;
+        default:
+            break;
+        }
+    }
+    return action;
+}
+
+static int pause_menu(void)
+{
+#define static auto
+#define const
+    MENUITEM_STRINGLIST(menu, NULL, pausemenu_cb,
+                        "Resume Game",
+                        "New Game",
+                        "Restart Game",
+                        "Undo",
+                        "Redo",
+                        "Solve",
+                        "Quick Help",
+                        "Extensive Help",
+                        "Game Type",
+                        "Debug Menu",
+                        "Configure Game",
+#ifdef COMBINED
+                        "Select Another Game",
+#endif
+                        "Quit without Saving",
+                        "Quit");
+#undef static
+#undef const
+    /* HACK ALERT */
+    char title[32] = { 0 };
+    rb->snprintf(title, sizeof(title), "%s Menu", midend_which_game(me)->name);
+    menu__.desc = title;
+
+    bool quit = false;
+    int sel = 0;
+    while(!quit)
+    {
+        switch(rb->do_menu(&menu, &sel, NULL, false))
+        {
+        case 0:
+            quit = true;
+            break;
+        case 1:
+            midend_new_game(me);
+            fix_size();
+            quit = true;
+            break;
+        case 2:
+            midend_restart_game(me);
+            fix_size();
+            quit = true;
+            break;
+        case 3:
+            if(!midend_can_undo(me))
+                rb->splash(HZ, "Cannot undo.");
+            else
+                midend_process_key(me, 0, 0, 'u');
+            quit = true;
+            break;
+        case 4:
+            if(!midend_can_redo(me))
+                rb->splash(HZ, "Cannot redo.");
+            else
+                midend_process_key(me, 0, 0, 'r');
+            quit = true;
+            break;
+        case 5:
+        {
+            char *msg = midend_solve(me);
+            if(msg)
+                rb->splash(HZ, msg);
+            quit = true;
+            break;
+        }
+        case 6:
+            quick_help();
+            break;
+        case 7:
+            full_help();
+            break;
+        case 8:
+            presets_menu();
+            midend_new_game(me);
+            fix_size();
+            quit = true;
+            break;
+        case 9:
+            debug_menu();
+            break;
+        case 10:
+            config_menu();
+            midend_new_game(me);
+            fix_size();
+            quit = true;
+            break;
+#ifdef COMBINED
+        case 11:
+            return -1;
+        case 12:
+            return -2;
+        case 13:
+            return -3;
+#else
+        case 11:
+            return -2;
+        case 12:
+            return -3;
+#endif
+        default:
+            break;
+        }
+    }
+    rb->lcd_set_background(BG_COLOR);
+    rb->lcd_clear_display();
+    rb->lcd_update();
+    midend_force_redraw(me);
+    return 0;
+}
+
+static bool want_redraw = true;
+static bool accept_input = true;
+
+/* ignore the excess of LOGFs below... */
+#ifdef LOGF_ENABLE
+#undef LOGF_ENABLE
+#endif
+static int process_input(int tmo)
+{
+    LOGF("process_input start");
+    LOGF("------------------");
+    int state = 0;
+
+#ifdef HAVE_ADJUSTABLE_CPU_FREQ
+    rb->cpu_boost(false); /* about to block for button input */
+#endif
+
+    int button = rb->button_get_w_tmo(tmo);
+
+    /* weird stuff */
+    exit_on_usb(button);
+
+    button = rb->button_status();
+
+#ifdef HAVE_ADJUSTABLE_CPU_FREQ
+    rb->cpu_boost(true);
+#endif
+
+    if(button == BTN_PAUSE)
+    {
+        want_redraw = false;
+        /* quick hack to preserve the clipping state */
+        bool orig_clipped = clipped;
+        if(orig_clipped)
+            rb_unclip(NULL);
+
+        int rc = pause_menu();
+
+        if(orig_clipped)
+            rb_clip(NULL, clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height);
+
+        last_keystate = 0;
+        accept_input = true;
+
+        return rc;
+    }
+
+    /* special case for inertia: moves occur after RELEASES */
+    if(!strcmp("Inertia", midend_which_game(me)->name))
+    {
+        LOGF("received button 0x%08x", button);
+
+        unsigned released = ~button & last_keystate;
+        last_keystate = button;
+
+        if(!button)
+        {
+            if(!accept_input)
+            {
+                LOGF("ignoring, all keys released but not accepting input before, can accept input later");
+                accept_input = true;
+                return 0;
+            }
+        }
+
+        if(!released || !accept_input)
+        {
+            LOGF("released keys detected: 0x%08x", released);
+            LOGF("ignoring, either no keys released or not accepting input");
+            return 0;
+        }
+
+        button |= released;
+        if(last_keystate)
+        {
+            LOGF("ignoring input from now until all released");
+            accept_input = false;
+        }
+        LOGF("accepting event 0x%08x", button);
+    }
+    /* not inertia: events fire on presses */
+    else
+    {
+        /* start accepting input again after a release */
+        if(!button)
+        {
+            accept_input = true;
+            return 0;
+        }
+        /* ignore repeats */
+        if(!accept_input)
+            return 0;
+        accept_input = false;
+    }
+
+    switch(button)
+    {
+    case BTN_UP:
+        state = CURSOR_UP;
+        break;
+    case BTN_DOWN:
+        state = CURSOR_DOWN;
+        break;
+    case BTN_LEFT:
+        state = CURSOR_LEFT;
+        break;
+    case BTN_RIGHT:
+        state = CURSOR_RIGHT;
+        break;
+
+        /* handle diagonals (mainly for Inertia) */
+    case BTN_DOWN | BTN_LEFT:
+#ifdef BTN_DOWN_LEFT
+    case BTN_DOWN_LEFT:
+#endif
+        state = '1' | MOD_NUM_KEYPAD;
+        break;
+    case BTN_DOWN | BTN_RIGHT:
+#ifdef BTN_DOWN_RIGHT
+    case BTN_DOWN_RIGHT:
+#endif
+        state = '3' | MOD_NUM_KEYPAD;
+        break;
+    case BTN_UP | BTN_LEFT:
+#ifdef BTN_UP_LEFT
+    case BTN_UP_LEFT:
+#endif
+        state = '7' | MOD_NUM_KEYPAD;
+        break;
+    case BTN_UP | BTN_RIGHT:
+#ifdef BTN_UP_RIGHT
+    case BTN_UP_RIGHT:
+#endif
+        state = '9' | MOD_NUM_KEYPAD;
+        break;
+
+    case BTN_FIRE:
+        state = CURSOR_SELECT;
+        break;
+    }
+    LOGF("process_input done");
+    LOGF("------------------");
+    return state;
+}
+
+static long last_tstamp;
+
+static void timer_cb(void)
+{
+#if LCD_DEPTH != 24
+    if(settings.timerflash)
+    {
+        static bool what = false;
+        what = !what;
+        if(what)
+            rb->lcd_framebuffer[0] = LCD_BLACK;
+        else
+            rb->lcd_framebuffer[0] = LCD_WHITE;
+        rb->lcd_update();
+    }
+#endif
+
+    LOGF("timer callback");
+    midend_timer(me, ((float)(*rb->current_tick - last_tstamp) / (float)HZ) / settings.slowmo_factor);
+    last_tstamp = *rb->current_tick;
+}
+
+static volatile bool timer_on = false;
+
+void activate_timer(frontend *fe)
+{
+    last_tstamp = *rb->current_tick;
+    timer_on = true;
+}
+
+void deactivate_timer(frontend *fe)
+{
+    timer_on = false;
+}
+
+#ifdef COMBINED
+/* can't use audio buffer */
+static char giant_buffer[1024*1024*4];
+#else
+/* points to audiobuf */
+static char *giant_buffer = NULL;
+#endif
+static size_t giant_buffer_len = 0; /* set on start */
+
+#ifdef COMBINED
+const char *formatter(char *buf, size_t n, int i, const char *unit)
+{
+    rb->snprintf(buf, n, "%s", gamelist[i]->name);
+    return buf;
+}
+#endif
+
+static void fix_size(void)
+{
+    int w = LCD_WIDTH, h = LCD_HEIGHT, h_x;
+    rb->lcd_setfont(FONT_UI);
+    rb->lcd_getstringsize("X", NULL, &h_x);
+    h -= h_x;
+    midend_size(me, &w, &h, TRUE);
+}
+
+static void reset_tlsf(void)
+{
+    /* reset tlsf by nuking the signature */
+    /* will make any already-allocated memory point to garbage */
+    memset(giant_buffer, 0, 4);
+    init_memory_pool(giant_buffer_len, giant_buffer);
+}
+
+static int read_wrapper(void *ptr, void *buf, int len)
+{
+    int fd = (int) ptr;
+    return rb->read(fd, buf, len);
+}
+
+static void write_wrapper(void *ptr, void *buf, int len)
+{
+    int fd = (int) ptr;
+    rb->write(fd, buf, len);
+}
+
+static void clear_and_draw(void)
+{
+    rb->lcd_clear_display();
+    rb->lcd_update();
+
+    midend_force_redraw(me);
+    draw_title();
+}
+
+static char *init_for_game(const game *gm, int load_fd, bool draw)
+{
+    /* if we are loading a game tlsf has already been initialized */
+    if(load_fd < 0)
+        reset_tlsf();
+
+    me = midend_new(NULL, gm, &rb_drawing, NULL);
+
+    if(load_fd < 0)
+        midend_new_game(me);
+    else
+    {
+        char *ret = midend_deserialize(me, read_wrapper, (void*) load_fd);
+        if(ret)
+            return ret;
+    }
+
+    fix_size();
+
+    float *floatcolors = midend_colors(me, &ncolors);
+
+    /* convert them to packed RGB */
+    colors = smalloc(ncolors * sizeof(unsigned));
+    unsigned *ptr = colors;
+    float *floatptr = floatcolors;
+    for(int i = 0; i < ncolors; ++i)
+    {
+        int r = 255 * *(floatptr++);
+        int g = 255 * *(floatptr++);
+        int b = 255 * *(floatptr++);
+        LOGF("color %d is %d %d %d", i, r, g, b);
+        *ptr++ = LCD_RGBPACK(r, g, b);
+    }
+    sfree(floatcolors);
+
+    rb->lcd_set_viewport(NULL);
+    rb->lcd_set_backdrop(NULL);
+    rb->lcd_set_foreground(LCD_BLACK);
+    rb->lcd_set_background(BG_COLOR);
+
+    if(draw)
+    {
+        clear_and_draw();
+    }
+    return NULL;
+}
+
+static void exit_handler(void)
+{
+#ifdef HAVE_ADJUSTABLE_CPU_FREQ
+    rb->cpu_boost(false);
+#endif
+}
+
+/* expects a totally free me* pointer */
+static bool load_game(void)
+{
+    reset_tlsf();
+
+    int fd = rb->open(SAVE_FILE, O_RDONLY);
+    if(fd < 0)
+        return false;
+
+    rb->splash(0, "Loading...");
+
+    LOGF("opening %s", SAVE_FILE);
+
+    char *game;
+    char *ret = identify_game(&game, read_wrapper, (void*)fd);
+
+    if(!*game && ret)
+    {
+        sfree(game);
+        rb->splash(HZ, ret);
+        rb->close(fd);
+        return false;
+    }
+    else
+    {
+        /* seek to beginning */
+        rb->lseek(fd, 0, SEEK_SET);
+
+#ifdef COMBINED
+        /* search for the game and initialize the midend */
+        for(int i = 0; i < gamecount; ++i)
+        {
+            if(!strcmp(game, gamelist[i]->name))
+            {
+                sfree(ret);
+                ret = init_for_game(gamelist[i], fd, true);
+                if(ret)
+                {
+                    rb->splash(HZ, ret);
+                    sfree(ret);
+                    rb->close(fd);
+                    return false;
+                }
+                rb->close(fd);
+                /* success, we delete the save */
+                rb->remove(SAVE_FILE);
+                return true;
+            }
+        }
+        rb->splashf(HZ, "Incompatible game %s reported as compatible!?!? REEEPORT MEEEE!!!!", game);
+        rb->close(fd);
+        return false;
+#else
+        if(!strcmp(game, thegame.name))
+        {
+            sfree(ret);
+            ret = init_for_game(&thegame, fd, false);
+            if(ret)
+            {
+                rb->splash(HZ, ret);
+                sfree(ret);
+                rb->close(fd);
+                return false;
+            }
+            rb->close(fd);
+            /* success, we delete the save */
+            rb->remove(SAVE_FILE);
+            return true;
+        }
+        rb->splashf(HZ, "Cannot load save game for %s!", game);
+        return false;
+#endif
+    }
+}
+
+static void save_game(void)
+{
+    rb->splash(0, "Saving...");
+    int fd = rb->open(SAVE_FILE, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+    midend_serialize(me, write_wrapper, (void*) fd);
+    rb->close(fd);
+    rb->lcd_update();
+}
+
+static bool load_success;
+
+static int mainmenu_cb(int action, const struct menu_item_ex *this_item)
+{
+    int i = (intptr_t) this_item;
+    if(action == ACTION_REQUEST_MENUITEM)
+    {
+        switch(i)
+        {
+        case 0:
+        case 7:
+            if(!load_success)
+                return ACTION_EXIT_MENUITEM;
+            break;
+        case 3:
+#ifdef FOR_REAL
+            return ACTION_EXIT_MENUITEM;
+#else
+            break;
+#endif
+        case 5:
+            if(!midend_num_presets(me))
+                return ACTION_EXIT_MENUITEM;
+            break;
+        case 6:
+            if(!midend_which_game(me)->can_configure)
+                return ACTION_EXIT_MENUITEM;
+            break;
+        default:
+            break;
+        }
+    }
+    return action;
+}
+
+enum plugin_status plugin_start(const void *param)
+{
+    (void) param;
+
+#ifdef HAVE_ADJUSTABLE_CPU_FREQ
+    /* boost for init */
+    rb->cpu_boost(true);
+#endif
+
+#ifdef COMBINED
+    giant_buffer_len = sizeof(giant_buffer);
+#else
+    giant_buffer = rb->plugin_get_buffer(&giant_buffer_len);
+#endif
+
+#ifndef COMBINED
+    rb->snprintf(save_file_path, sizeof(save_file_path), "%s/sgt-%s.sav", PLUGIN_GAMES_DATA_DIR, thegame.htmlhelp_topic);
+#endif
+
+    rb_atexit(exit_handler);
+
+    if(fabs(sqrt(3)/2 - sin(PI/3)) > .01)
+        rb->splash(HZ, "WARNING: floating-point functions are being weird... report me!");
+
+    init_default_settings();
+
+    load_success = load_game();
+
+#ifndef COMBINED
+    if(!load_success)
+    {
+        /* our main menu expects a ready-to-use midend */
+        init_for_game(&thegame, -1, false);
+    }
+#endif
+
+#ifdef HAVE_ADJUSTABLE_CPU_FREQ
+    /* about to go to menu or button block */
+    rb->cpu_boost(false);
+#endif
+
+#ifndef COMBINED
+#define static auto
+#define const
+    MENUITEM_STRINGLIST(menu, NULL, mainmenu_cb,
+                        "Resume Game",
+                        "New Game",
+                        "Quick Help",
+                        "Extensive Help",
+                        "Playback Control",
+                        "Game Type",
+                        "Configure Game",
+                        "Quit without Saving",
+                        "Quit");
+#undef static
+#undef const
+
+    /* HACK ALERT */
+    char title[32] = { 0 };
+    rb->snprintf(title, sizeof(title), "%s Menu", midend_which_game(me)->name);
+    menu__.desc = title;
+
+    bool quit = false;
+    int sel = 0;
+    while(!quit)
+    {
+        switch(rb->do_menu(&menu, &sel, NULL, false))
+        {
+        case 0:
+            clear_and_draw();
+            goto game_loop;
+        case 1:
+            if(!load_success)
+            {
+                clear_and_draw();
+                goto game_loop;
+            }
+            quit = true;
+            break;
+        case 2:
+            quick_help();
+            break;
+        case 3:
+            full_help();
+            break;
+        case 4:
+            playback_control(NULL);
+            break;
+        case 5:
+            presets_menu();
+            break;
+        case 6:
+            config_menu();
+            break;
+        case 8:
+            if(load_success)
+                save_game();
+            /* fall through */
+        case 7:
+            /* we don't care about freeing anything because tlsf will
+             * be wiped out the next time around */
+            return PLUGIN_OK;
+        default:
+            break;
+        }
+    }
+#else
+    if(load_success)
+        goto game_loop;
+#endif
+
+#ifdef COMBINED
+    int gm = 0;
+#endif
+    while(1)
+    {
+#ifdef COMBINED
+        if(rb->set_int("Choose Game", "", UNIT_INT, &gm, NULL, 1, 0, gamecount - 1, formatter))
+            return PLUGIN_OK;
+
+        init_for_game(gamelist[gm], -1, true);
+#else
+        init_for_game(&thegame, -1, true);
+#endif
+
+        last_keystate = 0;
+        accept_input = true;
+
+    game_loop:
+        while(1)
+        {
+            want_redraw = true;
+
+            draw_title();
+
+            int button = process_input(timer_on ? TIMER_INTERVAL : -1);
+
+            if(button < 0)
+            {
+                rb_unclip(NULL);
+                deactivate_timer(NULL);
+
+                if(titlebar)
+                {
+                    sfree(titlebar);
+                    titlebar = NULL;
+                }
+
+                if(button == -1)
+                {
+                    /* new game */
+                    midend_free(me);
+                    break;
+                }
+                else if(button == -2)
+                {
+                    /* quit without saving */
+                    midend_free(me);
+                    sfree(colors);
+                    exit(PLUGIN_OK);
+                }
+                else if(button == -3)
+                {
+                    /* save and quit */
+                    save_game();
+                    midend_free(me);
+                    sfree(colors);
+                    exit(PLUGIN_OK);
+                }
+            }
+
+            if(button)
+                midend_process_key(me, 0, 0, button);
+
+            if(want_redraw)
+                midend_redraw(me);
+
+            if(timer_on)
+                timer_cb();
+
+            rb->yield();
+        }
+        sfree(colors);
+    }
+}
diff --git a/apps/plugins/puzzles/samegame.R b/apps/plugins/puzzles/samegame.R
new file mode 100644
index 0000000000..cc0d350041
--- /dev/null
+++ b/apps/plugins/puzzles/samegame.R
@@ -0,0 +1,19 @@
+# -*- makefile -*-
+
+samegame : [X] GTK COMMON samegame samegame-icon|no-icon
+
+samegame : [G] WINDOWS COMMON samegame samegame.res|noicon.res
+
+ALL += samegame[COMBINED]
+
+!begin am gtk
+GAMES += samegame
+!end
+
+!begin >list.c
+    A(samegame) \
+!end
+
+!begin >gamedesc.txt
+samegame:samegame.exe:Same Game:Block-clearing puzzle:Clear the grid by removing touching groups of the same colour squares.
+!end
diff --git a/apps/plugins/puzzles/samegame.c b/apps/plugins/puzzles/samegame.c
new file mode 100644
index 0000000000..ed5efd224e
--- /dev/null
+++ b/apps/plugins/puzzles/samegame.c
@@ -0,0 +1,1679 @@
+/*
+ * 'same game' -- try to remove all the coloured squares by
+ *                selecting regions of contiguous colours.
+ */
+
+/*
+ * TODO on grid generation:
+ * 
+ *  - Generation speed could still be improved.
+ *     * 15x10c3 is the only really difficult one of the existing
+ *       presets. The others are all either small enough, or have
+ *       the great flexibility given by four colours, that they
+ *       don't take long at all.
+ *     * I still suspect many problems arise from separate
+ *       subareas. I wonder if we can also somehow prioritise left-
+ *       or rightmost insertions so as to avoid area splitting at
+ *       all where feasible? It's not easy, though, because the
+ *       current shuffle-then-try-all-options approach to move
+ *       choice doesn't leave room for `soft' probabilistic
+ *       prioritisation: we either try all class A moves before any
+ *       class B ones, or we don't.
+ *
+ *  - The current generation algorithm inserts exactly two squares
+ *    at a time, with a single exception at the beginning of
+ *    generation for grids of odd overall size. An obvious
+ *    extension would be to permit larger inverse moves during
+ *    generation.
+ *     * this might reduce the number of failed generations by
+ *       making the insertion algorithm more flexible
+ *     * on the other hand, it would be significantly more complex
+ *     * if I do this I'll need to take out the odd-subarea
+ *       avoidance
+ *     * a nice feature of the current algorithm is that the
+ *       computer's `intended' solution always receives the minimum
+ *       possible score, so that pretty much the player's entire
+ *       score represents how much better they did than the
+ *       computer.
+ *
+ *  - Is it possible we can _temporarily_ tolerate neighbouring
+ *    squares of the same colour, until we've finished setting up
+ *    our inverse move?
+ *     * or perhaps even not choose the colour of our inserted
+ *       region until we have finished placing it, and _then_ look
+ *       at what colours border on it?
+ *     * I don't think this is currently meaningful unless we're
+ *       placing more than a domino at a time.
+ *
+ *  - possibly write out a full solution so that Solve can somehow
+ *    show it step by step?
+ *     * aux_info would have to encode the click points
+ *     * solve_game() would have to encode not only those click
+ *       points but also give a move string which reconstructed the
+ *       initial state
+ *     * the game_state would include a pointer to a solution move
+ *       list, plus an index into that list
+ *     * game_changed_state would auto-select the next move if
+ *       handed a new state which had a solution move list active
+ *     * execute_move, if passed such a state as input, would check
+ *       to see whether the move being made was the same as the one
+ *       stated by the solution, and if so would advance the move
+ *       index. Failing that it would return a game_state without a
+ *       solution move list active at all.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#define TILE_INNER (ds->tileinner)
+#define TILE_GAP (ds->tilegap)
+#define TILE_SIZE (TILE_INNER + TILE_GAP)
+#define PREFERRED_TILE_SIZE 32
+#define BORDER (TILE_SIZE / 2)
+#define HIGHLIGHT_WIDTH 2
+
+#define FLASH_FRAME 0.13F
+
+#define COORD(x)  ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
+
+#define X(state, i) ( (i) % (state)->params.w )
+#define Y(state, i) ( (i) / (state)->params.w )
+#define C(state, x, y) ( (y) * (state)->w + (x) )
+
+enum {
+    COL_BACKGROUND,
+    COL_1, COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8, COL_9,
+    COL_IMPOSSIBLE, COL_SEL, COL_HIGHLIGHT, COL_LOWLIGHT,
+    NCOLOURS
+};
+
+/* scoresub is 1 or 2 (for (n-1)^2 or (n-2)^2) */
+struct game_params {
+    int w, h, ncols, scoresub;
+    int soluble;                       /* choose generation algorithm */
+};
+
+/* These flags must be unique across all uses; in the game_state,
+ * the game_ui, and the drawstate (as they all get combined in the
+ * drawstate). */
+#define TILE_COLMASK    0x00ff
+#define TILE_SELECTED   0x0100 /* used in ui and drawstate */
+#define TILE_JOINRIGHT  0x0200 /* used in drawstate */
+#define TILE_JOINDOWN   0x0400 /* used in drawstate */
+#define TILE_JOINDIAG   0x0800 /* used in drawstate */
+#define TILE_HASSEL     0x1000 /* used in drawstate */
+#define TILE_IMPOSSIBLE 0x2000 /* used in drawstate */
+
+#define TILE(gs,x,y) ((gs)->tiles[(gs)->params.w*(y)+(x)])
+#define COL(gs,x,y) (TILE(gs,x,y) & TILE_COLMASK)
+#define ISSEL(gs,x,y) (TILE(gs,x,y) & TILE_SELECTED)
+
+#define SWAPTILE(gs,x1,y1,x2,y2) do {   \
+    int t = TILE(gs,x1,y1);               \
+    TILE(gs,x1,y1) = TILE(gs,x2,y2);      \
+    TILE(gs,x2,y2) = t;                   \
+} while (0)
+
+static int npoints(const game_params *params, int nsel)
+{
+    int sdiff = nsel - params->scoresub;
+    return (sdiff > 0) ? sdiff * sdiff : 0;
+}
+
+struct game_state {
+    struct game_params params;
+    int n;
+    int *tiles; /* colour only */
+    int score;
+    int complete, impossible;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+    ret->w = 5;
+    ret->h = 5;
+    ret->ncols = 3;
+    ret->scoresub = 2;
+    ret->soluble = TRUE;
+    return ret;
+}
+
+static const struct game_params samegame_presets[] = {
+    { 5, 5, 3, 2, TRUE },
+    { 10, 5, 3, 2, TRUE },
+#ifdef SLOW_SYSTEM
+    { 10, 10, 3, 2, TRUE },
+#else
+    { 15, 10, 3, 2, TRUE },
+#endif
+    { 15, 10, 4, 2, TRUE },
+    { 20, 15, 4, 2, TRUE }
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(samegame_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = samegame_presets[i];
+
+    sprintf(str, "%dx%d, %d colours", ret->w, ret->h, ret->ncols);
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    char const *p = string;
+
+    params->w = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+    if (*p == 'x') {
+        p++;
+        params->h = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+    } else {
+        params->h = params->w;
+    }
+    if (*p == 'c') {
+        p++;
+        params->ncols = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+    } else {
+        params->ncols = 3;
+    }
+    if (*p == 's') {
+        p++;
+        params->scoresub = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+    } else {
+        params->scoresub = 2;
+    }
+    if (*p == 'r') {
+        p++;
+        params->soluble = FALSE;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char ret[80];
+
+    sprintf(ret, "%dx%dc%ds%d%s",
+            params->w, params->h, params->ncols, params->scoresub,
+            full && !params->soluble ? "r" : "");
+    return dupstr(ret);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(6, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "No. of colours";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->ncols);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = "Scoring system";
+    ret[3].type = C_CHOICES;
+    ret[3].sval = ":(n-1)^2:(n-2)^2";
+    ret[3].ival = params->scoresub-1;
+
+    ret[4].name = "Ensure solubility";
+    ret[4].type = C_BOOLEAN;
+    ret[4].sval = NULL;
+    ret[4].ival = params->soluble;
+
+    ret[5].name = NULL;
+    ret[5].type = C_END;
+    ret[5].sval = NULL;
+    ret[5].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->ncols = atoi(cfg[2].sval);
+    ret->scoresub = cfg[3].ival + 1;
+    ret->soluble = cfg[4].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 1 || params->h < 1)
+        return "Width and height must both be positive";
+
+    if (params->ncols > 9)
+        return "Maximum of 9 colours";
+
+    if (params->soluble) {
+        if (params->ncols < 3)
+            return "Number of colours must be at least three";
+        if (params->w * params->h <= 1)
+            return "Grid area must be greater than 1";
+    } else {
+        if (params->ncols < 2)
+            return "Number of colours must be at least three";
+        /* ...and we must make sure we can generate at least 2 squares
+         * of each colour so it's theoretically soluble. */
+        if ((params->w * params->h) < (params->ncols * 2))
+            return "Too many colours makes given grid size impossible";
+    }
+
+    if ((params->scoresub < 1) || (params->scoresub > 2))
+        return "Scoring system not recognised";
+
+    return NULL;
+}
+
+/*
+ * Guaranteed-soluble grid generator.
+ */
+static void gen_grid(int w, int h, int nc, int *grid, random_state *rs)
+{
+    int wh = w*h, tc = nc+1;
+    int i, j, k, c, x, y, pos, n;
+    int *list, *grid2;
+    int ok, failures = 0;
+
+    /*
+     * We'll use `list' to track the possible places to put our
+     * next insertion. There are up to h places to insert in each
+     * column: in a column of height n there are n+1 places because
+     * we can insert at the very bottom or the very top, but a
+     * column of height h can't have anything at all inserted in it
+     * so we have up to h in each column. Likewise, with n columns
+     * present there are n+1 places to fit a new one in between but
+     * we can't insert a column if there are already w; so there
+     * are a maximum of w new columns too. Total is wh + w.
+     */
+    list = snewn(wh + w, int);
+    grid2 = snewn(wh, int);
+
+    do {
+        /*
+         * Start with two or three squares - depending on parity of w*h
+         * - of a random colour.
+         */
+        for (i = 0; i < wh; i++)
+            grid[i] = 0;
+        j = 2 + (wh % 2);
+        c = 1 + random_upto(rs, nc);
+        if (j <= w) {
+            for (i = 0; i < j; i++)
+                grid[(h-1)*w+i] = c;
+        } else {
+            assert(j <= h);
+            for (i = 0; i < j; i++)
+                grid[(h-1-i)*w] = c;
+        }
+
+        /*
+         * Now repeatedly insert a two-square blob in the grid, of
+         * whatever colour will go at the position we chose.
+         */
+        while (1) {
+            n = 0;
+
+            /*
+             * Build up a list of insertion points. Each point is
+             * encoded as y*w+x; insertion points between columns are
+             * encoded as h*w+x.
+             */
+
+            if (grid[wh - 1] == 0) {
+                /*
+                 * The final column is empty, so we can insert new
+                 * columns.
+                 */
+                for (i = 0; i < w; i++) {
+                    list[n++] = wh + i;
+                    if (grid[(h-1)*w + i] == 0)
+                        break;
+                }
+            }
+
+            /*
+             * Now look for places to insert within columns.
+             */
+            for (i = 0; i < w; i++) {
+                if (grid[(h-1)*w+i] == 0)
+                    break;                     /* no more columns */
+
+                if (grid[i] != 0)
+                    continue;          /* this column is full */
+
+                for (j = h; j-- > 0 ;) {
+                    list[n++] = j*w+i;
+                    if (grid[j*w+i] == 0)
+                        break;         /* this column is exhausted */
+                }
+            }
+
+            if (n == 0)
+                break;                 /* we're done */
+
+#ifdef GENERATION_DIAGNOSTICS
+            printf("initial grid:\n");
+            {
+                int x,y;
+                for (y = 0; y < h; y++) {
+                    for (x = 0; x < w; x++) {
+                        if (grid[y*w+x] == 0)
+                            printf("-");
+                        else
+                            printf("%d", grid[y*w+x]);
+                    }
+                    printf("\n");
+                }
+            }
+#endif
+
+            /*
+             * Now go through the list one element at a time in
+             * random order, and actually attempt to insert
+             * something there.
+             */
+            while (n-- > 0) {
+                int dirs[4], ndirs, dir;
+
+                i = random_upto(rs, n+1);
+                pos = list[i];
+                list[i] = list[n];
+
+                x = pos % w;
+                y = pos / w;
+
+                memcpy(grid2, grid, wh * sizeof(int));
+
+                if (y == h) {
+                    /*
+                     * Insert a column at position x.
+                     */
+                    for (i = w-1; i > x; i--)
+                        for (j = 0; j < h; j++)
+                            grid2[j*w+i] = grid2[j*w+(i-1)];
+                    /*
+                     * Clear the new column.
+                     */
+                    for (j = 0; j < h; j++)
+                        grid2[j*w+x] = 0;
+                    /*
+                     * Decrement y so that our first square is actually
+                     * inserted _in_ the grid rather than just below it.
+                     */
+                    y--;
+                }
+
+                /*
+                 * Insert a square within column x at position y.
+                 */
+                for (i = 0; i+1 <= y; i++)
+                    grid2[i*w+x] = grid2[(i+1)*w+x];
+
+#ifdef GENERATION_DIAGNOSTICS
+                printf("trying at n=%d (%d,%d)\n", n, x, y);
+                grid2[y*w+x] = tc;
+                {
+                    int x,y;
+                    for (y = 0; y < h; y++) {
+                        for (x = 0; x < w; x++) {
+                            if (grid2[y*w+x] == 0)
+                                printf("-");
+                            else if (grid2[y*w+x] <= nc)
+                                printf("%d", grid2[y*w+x]);
+                            else
+                                printf("*");
+                        }
+                        printf("\n");
+                    }
+                }
+#endif
+
+                /*
+                 * Pick our square colour so that it doesn't match any
+                 * of its neighbours.
+                 */
+                {
+                    int wrongcol[4], nwrong = 0;
+
+                    /*
+                     * List the neighbouring colours.
+                     */
+                    if (x > 0)
+                        wrongcol[nwrong++] = grid2[y*w+(x-1)];
+                    if (x+1 < w)
+                        wrongcol[nwrong++] = grid2[y*w+(x+1)];
+                    if (y > 0)
+                        wrongcol[nwrong++] = grid2[(y-1)*w+x];
+                    if (y+1 < h)
+                        wrongcol[nwrong++] = grid2[(y+1)*w+x];
+
+                    /*
+                     * Eliminate duplicates. We can afford a shoddy
+                     * algorithm here because the problem size is
+                     * bounded.
+                     */
+                    for (i = j = 0 ;; i++) {
+                        int pos = -1, min = 0;
+                        if (j > 0)
+                            min = wrongcol[j-1];
+                        for (k = i; k < nwrong; k++)
+                            if (wrongcol[k] > min &&
+                                (pos == -1 || wrongcol[k] < wrongcol[pos]))
+                                pos = k;
+                        if (pos >= 0) {
+                            int v = wrongcol[pos];
+                            wrongcol[pos] = wrongcol[j];
+                            wrongcol[j++] = v;
+                        } else
+                            break;
+                    }
+                    nwrong = j;
+
+                    /*
+                     * If no colour will go here, stop trying.
+                     */
+                    if (nwrong == nc)
+                        continue;
+
+                    /*
+                     * Otherwise, pick a colour from the remaining
+                     * ones.
+                     */
+                    c = 1 + random_upto(rs, nc - nwrong);
+                    for (i = 0; i < nwrong; i++) {
+                        if (c >= wrongcol[i])
+                            c++;
+                        else
+                            break;
+                    }
+                }
+
+                /*
+                 * Place the new square.
+                 * 
+                 * Although I've _chosen_ the new region's colour
+                 * (so that we can check adjacency), I'm going to
+                 * actually place it as an invalid colour (tc)
+                 * until I'm sure it's viable. This is so that I
+                 * can conveniently check that I really have made a
+                 * _valid_ inverse move later on.
+                 */
+#ifdef GENERATION_DIAGNOSTICS
+                printf("picked colour %d\n", c);
+#endif
+                grid2[y*w+x] = tc;
+
+                /*
+                 * Now attempt to extend it in one of three ways: left,
+                 * right or up.
+                 */
+                ndirs = 0;
+                if (x > 0 &&
+                    grid2[y*w+(x-1)] != c &&
+                    grid2[x-1] == 0 &&
+                    (y+1 >= h || grid2[(y+1)*w+(x-1)] != c) &&
+                    (y+1 >= h || grid2[(y+1)*w+(x-1)] != 0) &&
+                    (x <= 1 || grid2[y*w+(x-2)] != c))
+                    dirs[ndirs++] = -1;    /* left */
+                if (x+1 < w &&
+                    grid2[y*w+(x+1)] != c &&
+                    grid2[x+1] == 0 &&
+                    (y+1 >= h || grid2[(y+1)*w+(x+1)] != c) &&
+                    (y+1 >= h || grid2[(y+1)*w+(x+1)] != 0) &&
+                    (x+2 >= w || grid2[y*w+(x+2)] != c))
+                    dirs[ndirs++] = +1;    /* right */
+                if (y > 0 &&
+                    grid2[x] == 0 &&
+                    (x <= 0 || grid2[(y-1)*w+(x-1)] != c) &&
+                    (x+1 >= w || grid2[(y-1)*w+(x+1)] != c)) {
+                    /*
+                     * We add this possibility _twice_, so that the
+                     * probability of placing a vertical domino is
+                     * about the same as that of a horizontal. This
+                     * should yield less bias in the generated
+                     * grids.
+                     */
+                    dirs[ndirs++] = 0;     /* up */
+                    dirs[ndirs++] = 0;     /* up */
+                }
+
+                if (ndirs == 0)
+                    continue;
+
+                dir = dirs[random_upto(rs, ndirs)];
+
+#ifdef GENERATION_DIAGNOSTICS
+                printf("picked dir %d\n", dir);
+#endif
+
+                /*
+                 * Insert a square within column (x+dir) at position y.
+                 */
+                for (i = 0; i+1 <= y; i++)
+                    grid2[i*w+x+dir] = grid2[(i+1)*w+x+dir];
+                grid2[y*w+x+dir] = tc;
+
+                /*
+                 * See if we've divided the remaining grid squares
+                 * into sub-areas. If so, we need every sub-area to
+                 * have an even area or we won't be able to
+                 * complete generation.
+                 * 
+                 * If the height is odd and not all columns are
+                 * present, we can increase the area of a subarea
+                 * by adding a new column in it, so in that
+                 * situation we don't mind having as many odd
+                 * subareas as there are spare columns.
+                 * 
+                 * If the height is even, we can't fix it at all.
+                 */
+                {
+                    int nerrs = 0, nfix = 0;
+                    k = 0;             /* current subarea size */
+                    for (i = 0; i < w; i++) {
+                        if (grid2[(h-1)*w+i] == 0) {
+                            if (h % 2)
+                                nfix++;
+                            continue;
+                        }
+                        for (j = 0; j < h && grid2[j*w+i] == 0; j++);
+                        assert(j < h);
+                        if (j == 0) {
+                            /*
+                             * End of previous subarea.
+                             */
+                            if (k % 2)
+                                nerrs++;
+                            k = 0;
+                        } else {
+                            k += j;
+                        }
+                    }
+                    if (k % 2)
+                        nerrs++;
+                    if (nerrs > nfix)
+                        continue;      /* try a different placement */
+                }
+
+                /*
+                 * We've made a move. Verify that it is a valid
+                 * move and that if made it would indeed yield the
+                 * previous grid state. The criteria are:
+                 * 
+                 *  (a) removing all the squares of colour tc (and
+                 *      shuffling the columns up etc) from grid2
+                 *      would yield grid
+                 *  (b) no square of colour tc is adjacent to one
+                 *      of colour c
+                 *  (c) all the squares of colour tc form a single
+                 *      connected component
+                 * 
+                 * We verify the latter property at the same time
+                 * as checking that removing all the tc squares
+                 * would yield the previous grid. Then we colour
+                 * the tc squares in colour c by breadth-first
+                 * search, which conveniently permits us to test
+                 * that they're all connected.
+                 */
+                {
+                    int x1, x2, y1, y2;
+                    int ok = TRUE;
+                    int fillstart = -1, ntc = 0;
+
+#ifdef GENERATION_DIAGNOSTICS
+                    {
+                        int x,y;
+                        printf("testing move (new, old):\n");
+                        for (y = 0; y < h; y++) {
+                            for (x = 0; x < w; x++) {
+                                if (grid2[y*w+x] == 0)
+                                    printf("-");
+                                else if (grid2[y*w+x] <= nc)
+                                    printf("%d", grid2[y*w+x]);
+                                else
+                                    printf("*");
+                            }
+                            printf("   ");
+                            for (x = 0; x < w; x++) {
+                                if (grid[y*w+x] == 0)
+                                    printf("-");
+                                else
+                                    printf("%d", grid[y*w+x]);
+                            }
+                            printf("\n");
+                        }
+                    }
+#endif
+
+                    for (x1 = x2 = 0; x2 < w; x2++) {
+                        int usedcol = FALSE;
+
+                        for (y1 = y2 = h-1; y2 >= 0; y2--) {
+                            if (grid2[y2*w+x2] == tc) {
+                                ntc++;
+                                if (fillstart == -1)
+                                    fillstart = y2*w+x2;
+                                if ((y2+1 < h && grid2[(y2+1)*w+x2] == c) ||
+                                    (y2-1 >= 0 && grid2[(y2-1)*w+x2] == c) ||
+                                    (x2+1 < w && grid2[y2*w+x2+1] == c) ||
+                                    (x2-1 >= 0 && grid2[y2*w+x2-1] == c)) {
+#ifdef GENERATION_DIAGNOSTICS
+                                    printf("adjacency failure at %d,%d\n",
+                                           x2, y2);
+#endif
+                                    ok = FALSE;
+                                }
+                                continue;
+                            }
+                            if (grid2[y2*w+x2] == 0)
+                                break;
+                            usedcol = TRUE;
+                            if (grid2[y2*w+x2] != grid[y1*w+x1]) {
+#ifdef GENERATION_DIAGNOSTICS
+                                printf("matching failure at %d,%d vs %d,%d\n",
+                                       x2, y2, x1, y1);
+#endif
+                                ok = FALSE;
+                            }
+                            y1--;
+                        }
+
+                        /*
+                         * If we've reached the top of the column
+                         * in grid2, verify that we've also reached
+                         * the top of the column in `grid'.
+                         */
+                        if (usedcol) {
+                            while (y1 >= 0) {
+                                if (grid[y1*w+x1] != 0) {
+#ifdef GENERATION_DIAGNOSTICS
+                                    printf("junk at column top (%d,%d)\n",
+                                           x1, y1);
+#endif
+                                    ok = FALSE;
+                                }
+                                y1--;
+                            }
+                        }
+
+                        if (!ok)
+                            break;
+
+                        if (usedcol)
+                            x1++;
+                    }
+
+                    if (!ok) {
+                        assert(!"This should never happen");
+
+                        /*
+                         * If this game is compiled NDEBUG so that
+                         * the assertion doesn't bring it to a
+                         * crashing halt, the only thing we can do
+                         * is to give up, loop round again, and
+                         * hope to randomly avoid making whatever
+                         * type of move just caused this failure.
+                         */
+                        continue;
+                    }
+
+                    /*
+                     * Now use bfs to fill in the tc section as
+                     * colour c. We use `list' to store the set of
+                     * squares we have to process.
+                     */
+                    i = j = 0;
+                    assert(fillstart >= 0);
+                    list[i++] = fillstart;
+#ifdef OUTPUT_SOLUTION
+                    printf("M");
+#endif
+                    while (j < i) {
+                        k = list[j];
+                        x = k % w;
+                        y = k / w;
+#ifdef OUTPUT_SOLUTION
+                        printf("%s%d", j ? "," : "", k);
+#endif
+                        j++;
+
+                        assert(grid2[k] == tc);
+                        grid2[k] = c;
+
+                        if (x > 0 && grid2[k-1] == tc)
+                            list[i++] = k-1;
+                        if (x+1 < w && grid2[k+1] == tc)
+                            list[i++] = k+1;
+                        if (y > 0 && grid2[k-w] == tc)
+                            list[i++] = k-w;
+                        if (y+1 < h && grid2[k+w] == tc)
+                            list[i++] = k+w;
+                    }
+#ifdef OUTPUT_SOLUTION
+                    printf("\n");
+#endif
+
+                    /*
+                     * Check that we've filled the same number of
+                     * tc squares as we originally found.
+                     */
+                    assert(j == ntc);
+                }
+
+                memcpy(grid, grid2, wh * sizeof(int));
+
+                break;                 /* done it! */
+            }
+
+#ifdef GENERATION_DIAGNOSTICS
+            {
+                int x,y;
+                printf("n=%d\n", n);
+                for (y = 0; y < h; y++) {
+                    for (x = 0; x < w; x++) {
+                        if (grid[y*w+x] == 0)
+                            printf("-");
+                        else
+                            printf("%d", grid[y*w+x]);
+                    }
+                    printf("\n");
+                }
+            }
+#endif
+
+            if (n < 0)
+                break;
+        }
+
+        ok = TRUE;
+        for (i = 0; i < wh; i++)
+            if (grid[i] == 0) {
+                ok = FALSE;
+                failures++;
+#if defined GENERATION_DIAGNOSTICS || defined SHOW_INCOMPLETE
+                {
+                    int x,y;
+                    printf("incomplete grid:\n");
+                    for (y = 0; y < h; y++) {
+                        for (x = 0; x < w; x++) {
+                            if (grid[y*w+x] == 0)
+                                printf("-");
+                            else
+                                printf("%d", grid[y*w+x]);
+                        }
+                        printf("\n");
+                    }
+                }
+#endif
+                break;
+            }
+
+    } while (!ok);
+
+#if defined GENERATION_DIAGNOSTICS || defined COUNT_FAILURES
+    printf("%d failures\n", failures);
+#endif
+#ifdef GENERATION_DIAGNOSTICS
+    {
+        int x,y;
+        printf("final grid:\n");
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                printf("%d", grid[y*w+x]);
+            }
+            printf("\n");
+        }
+    }
+#endif
+
+    sfree(grid2);
+    sfree(list);
+}
+
+/*
+ * Not-guaranteed-soluble grid generator; kept as a legacy, and in
+ * case someone finds the slightly odd quality of the guaranteed-
+ * soluble grids to be aesthetically displeasing or finds its CPU
+ * utilisation to be excessive.
+ */
+static void gen_grid_random(int w, int h, int nc, int *grid, random_state *rs)
+{
+    int i, j, c;
+    int n = w * h;
+
+    for (i = 0; i < n; i++)
+        grid[i] = 0;
+
+    /*
+     * Our sole concession to not gratuitously generating insoluble
+     * grids is to ensure we have at least two of every colour.
+     */
+    for (c = 1; c <= nc; c++) {
+        for (j = 0; j < 2; j++) {
+            do {
+                i = (int)random_upto(rs, n);
+            } while (grid[i] != 0);
+            grid[i] = c;
+        }
+    }
+
+    /*
+     * Fill in the rest of the grid at random.
+     */
+    for (i = 0; i < n; i++) {
+        if (grid[i] == 0)
+            grid[i] = (int)random_upto(rs, nc)+1;
+    }
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    char *ret;
+    int n, i, retlen, *tiles;
+
+    n = params->w * params->h;
+    tiles = snewn(n, int);
+
+    if (params->soluble)
+        gen_grid(params->w, params->h, params->ncols, tiles, rs);
+    else
+        gen_grid_random(params->w, params->h, params->ncols, tiles, rs);
+
+    ret = NULL;
+    retlen = 0;
+    for (i = 0; i < n; i++) {
+        char buf[80];
+        int k;
+
+        k = sprintf(buf, "%d,", tiles[i]);
+        ret = sresize(ret, retlen + k + 1, char);
+        strcpy(ret + retlen, buf);
+        retlen += k;
+    }
+    ret[retlen-1] = '\0'; /* delete last comma */
+
+    sfree(tiles);
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int area = params->w * params->h, i;
+    const char *p = desc;
+
+    for (i = 0; i < area; i++) {
+        const char *q = p;
+        int n;
+
+        if (!isdigit((unsigned char)*p))
+            return "Not enough numbers in string";
+        while (isdigit((unsigned char)*p)) p++;
+
+        if (i < area-1 && *p != ',')
+            return "Expected comma after number";
+        else if (i == area-1 && *p)
+            return "Excess junk at end of string";
+
+        n = atoi(q);
+        if (n < 0 || n > params->ncols)
+            return "Colour out of range";
+
+        if (*p) p++; /* eat comma */
+    }
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    const char *p = desc;
+    int i;
+
+    state->params = *params; /* struct copy */
+    state->n = state->params.w * state->params.h;
+    state->tiles = snewn(state->n, int);
+
+    for (i = 0; i < state->n; i++) {
+        assert(*p);
+        state->tiles[i] = atoi(p);
+        while (*p && *p != ',')
+            p++;
+        if (*p) p++;                   /* eat comma */
+    }
+    state->complete = state->impossible = 0;
+    state->score = 0;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    *ret = *state; /* structure copy, except... */
+
+    ret->tiles = snewn(state->n, int);
+    memcpy(ret->tiles, state->tiles, state->n * sizeof(int));
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->tiles);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return NULL;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    char *ret, *p;
+    int x, y, maxlen;
+
+    maxlen = state->params.h * (state->params.w + 1);
+    ret = snewn(maxlen+1, char);
+    p = ret;
+
+    for (y = 0; y < state->params.h; y++) {
+        for (x = 0; x < state->params.w; x++) {
+            int t = TILE(state,x,y);
+            if (t <= 0)      *p++ = ' ';
+            else if (t < 10) *p++ = '0'+t;
+            else             *p++ = 'a'+(t-10);
+        }
+        *p++ = '\n';
+    }
+    assert(p - ret == maxlen);
+    *p = '\0';
+    return ret;
+}
+
+struct game_ui {
+    struct game_params params;
+    int *tiles; /* selected-ness only */
+    int nselected;
+    int xsel, ysel, displaysel;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->params = state->params; /* structure copy */
+    ui->tiles = snewn(state->n, int);
+    memset(ui->tiles, 0, state->n*sizeof(int));
+    ui->nselected = 0;
+
+    ui->xsel = ui->ysel = ui->displaysel = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui->tiles);
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void sel_clear(game_ui *ui, const game_state *state)
+{
+    int i;
+
+    for (i = 0; i < state->n; i++)
+        ui->tiles[i] &= ~TILE_SELECTED;
+    ui->nselected = 0;
+}
+
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    sel_clear(ui, newstate);
+
+    /*
+     * If the game state has just changed into an unplayable one
+     * (either completed or impossible), we vanish the keyboard-
+     * control cursor.
+     */
+    if (newstate->complete || newstate->impossible)
+        ui->displaysel = 0;
+}
+
+static char *sel_movedesc(game_ui *ui, const game_state *state)
+{
+    int i;
+    char *ret, *sep, buf[80];
+    int retlen, retsize;
+
+    retsize = 256;
+    ret = snewn(retsize, char);
+    retlen = 0;
+    ret[retlen++] = 'M';
+    sep = "";
+
+    for (i = 0; i < state->n; i++) {
+        if (ui->tiles[i] & TILE_SELECTED) {
+            sprintf(buf, "%s%d", sep, i);
+            sep = ",";
+            if (retlen + (int)strlen(buf) >= retsize) {
+                retsize = retlen + strlen(buf) + 256;
+                ret = sresize(ret, retsize, char);
+            }
+            strcpy(ret + retlen, buf);
+            retlen += strlen(buf);
+
+            ui->tiles[i] &= ~TILE_SELECTED;
+        }
+    }
+    ui->nselected = 0;
+
+    assert(retlen < retsize);
+    ret[retlen++] = '\0';
+    return sresize(ret, retlen, char);
+}
+
+static void sel_expand(game_ui *ui, const game_state *state, int tx, int ty)
+{
+    int ns = 1, nadded, x, y, c;
+
+    TILE(ui,tx,ty) |= TILE_SELECTED;
+    do {
+        nadded = 0;
+
+        for (x = 0; x < state->params.w; x++) {
+            for (y = 0; y < state->params.h; y++) {
+                if (x == tx && y == ty) continue;
+                if (ISSEL(ui,x,y)) continue;
+
+                c = COL(state,x,y);
+                if ((x > 0) &&
+                    ISSEL(ui,x-1,y) && COL(state,x-1,y) == c) {
+                    TILE(ui,x,y) |= TILE_SELECTED;
+                    nadded++;
+                    continue;
+                }
+
+                if ((x+1 < state->params.w) &&
+                    ISSEL(ui,x+1,y) && COL(state,x+1,y) == c) {
+                    TILE(ui,x,y) |= TILE_SELECTED;
+                    nadded++;
+                    continue;
+                }
+
+                if ((y > 0) &&
+                    ISSEL(ui,x,y-1) && COL(state,x,y-1) == c) {
+                    TILE(ui,x,y) |= TILE_SELECTED;
+                    nadded++;
+                    continue;
+                }
+
+                if ((y+1 < state->params.h) &&
+                    ISSEL(ui,x,y+1) && COL(state,x,y+1) == c) {
+                    TILE(ui,x,y) |= TILE_SELECTED;
+                    nadded++;
+                    continue;
+                }
+            }
+        }
+        ns += nadded;
+    } while (nadded > 0);
+
+    if (ns > 1) {
+        ui->nselected = ns;
+    } else {
+        sel_clear(ui, state);
+    }
+}
+
+static int sg_emptycol(game_state *ret, int x)
+{
+    int y;
+    for (y = 0; y < ret->params.h; y++) {
+        if (COL(ret,x,y)) return 0;
+    }
+    return 1;
+}
+
+
+static void sg_snuggle(game_state *ret)
+{
+    int x,y, ndone;
+
+    /* make all unsupported tiles fall down. */
+    do {
+        ndone = 0;
+        for (x = 0; x < ret->params.w; x++) {
+            for (y = ret->params.h-1; y > 0; y--) {
+                if (COL(ret,x,y) != 0) continue;
+                if (COL(ret,x,y-1) != 0) {
+                    SWAPTILE(ret,x,y,x,y-1);
+                    ndone++;
+                }
+            }
+        }
+    } while (ndone);
+
+    /* shuffle all columns as far left as they can go. */
+    do {
+        ndone = 0;
+        for (x = 0; x < ret->params.w-1; x++) {
+            if (sg_emptycol(ret,x) && !sg_emptycol(ret,x+1)) {
+                ndone++;
+                for (y = 0; y < ret->params.h; y++) {
+                    SWAPTILE(ret,x,y,x+1,y);
+                }
+            }
+        }
+    } while (ndone);
+}
+
+static void sg_check(game_state *ret)
+{
+    int x,y, complete = 1, impossible = 1;
+
+    for (x = 0; x < ret->params.w; x++) {
+        for (y = 0; y < ret->params.h; y++) {
+            if (COL(ret,x,y) == 0)
+                continue;
+            complete = 0;
+            if (x+1 < ret->params.w) {
+                if (COL(ret,x,y) == COL(ret,x+1,y))
+                    impossible = 0;
+            }
+            if (y+1 < ret->params.h) {
+                if (COL(ret,x,y) == COL(ret,x,y+1))
+                    impossible = 0;
+            }
+        }
+    }
+    ret->complete = complete;
+    ret->impossible = impossible;
+}
+
+struct game_drawstate {
+    int started, bgcolour;
+    int tileinner, tilegap;
+    int *tiles; /* contains colour and SELECTED. */
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int tx, ty;
+    char *ret = "";
+
+    ui->displaysel = 0;
+
+    if (button == RIGHT_BUTTON || button == LEFT_BUTTON) {
+        tx = FROMCOORD(x); ty= FROMCOORD(y);
+    } else if (IS_CURSOR_MOVE(button)) {
+        int dx = 0, dy = 0;
+        ui->displaysel = 1;
+        dx = (button == CURSOR_LEFT) ? -1 : ((button == CURSOR_RIGHT) ? +1 : 0);
+        dy = (button == CURSOR_DOWN) ? +1 : ((button == CURSOR_UP)    ? -1 : 0);
+        ui->xsel = (ui->xsel + state->params.w + dx) % state->params.w;
+        ui->ysel = (ui->ysel + state->params.h + dy) % state->params.h;
+        return ret;
+    } else if (IS_CURSOR_SELECT(button)) {
+        ui->displaysel = 1;
+        tx = ui->xsel;
+        ty = ui->ysel;
+    } else
+        return NULL;
+
+    if (tx < 0 || tx >= state->params.w || ty < 0 || ty >= state->params.h)
+        return NULL;
+    if (COL(state, tx, ty) == 0) return NULL;
+
+    if (ISSEL(ui,tx,ty)) {
+        if (button == RIGHT_BUTTON || button == CURSOR_SELECT2)
+            sel_clear(ui, state);
+        else
+            ret = sel_movedesc(ui, state);
+    } else {
+        sel_clear(ui, state); /* might be no-op */
+        sel_expand(ui, state, tx, ty);
+    }
+
+    return ret;
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    int i, n;
+    game_state *ret;
+
+    if (move[0] == 'M') {
+        ret = dup_game(from);
+
+        n = 0;
+        move++;
+
+        while (*move) {
+            i = atoi(move);
+            if (i < 0 || i >= ret->n) {
+                free_game(ret);
+                return NULL;
+            }
+            n++;
+            ret->tiles[i] = 0;
+
+            while (*move && isdigit((unsigned char)*move)) move++;
+            if (*move == ',') move++;
+        }
+
+        ret->score += npoints(&ret->params, n);
+
+        sg_snuggle(ret); /* shifts blanks down and to the left */
+        sg_check(ret);   /* checks for completeness or impossibility */
+
+        return ret;
+    } else
+        return NULL;                   /* couldn't parse move string */
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilegap = 2;
+    ds->tileinner = tilesize - ds->tilegap;
+}
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up tile size variables for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(NULL, ds, params, tilesize);
+
+    *x = TILE_SIZE * params->w + 2 * BORDER - TILE_GAP;
+    *y = TILE_SIZE * params->h + 2 * BORDER - TILE_GAP;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_1 * 3 + 0] = 0.0F;
+    ret[COL_1 * 3 + 1] = 0.0F;
+    ret[COL_1 * 3 + 2] = 1.0F;
+
+    ret[COL_2 * 3 + 0] = 0.0F;
+    ret[COL_2 * 3 + 1] = 0.5F;
+    ret[COL_2 * 3 + 2] = 0.0F;
+
+    ret[COL_3 * 3 + 0] = 1.0F;
+    ret[COL_3 * 3 + 1] = 0.0F;
+    ret[COL_3 * 3 + 2] = 0.0F;
+
+    ret[COL_4 * 3 + 0] = 1.0F;
+    ret[COL_4 * 3 + 1] = 1.0F;
+    ret[COL_4 * 3 + 2] = 0.0F;
+
+    ret[COL_5 * 3 + 0] = 1.0F;
+    ret[COL_5 * 3 + 1] = 0.0F;
+    ret[COL_5 * 3 + 2] = 1.0F;
+
+    ret[COL_6 * 3 + 0] = 0.0F;
+    ret[COL_6 * 3 + 1] = 1.0F;
+    ret[COL_6 * 3 + 2] = 1.0F;
+
+    ret[COL_7 * 3 + 0] = 0.5F;
+    ret[COL_7 * 3 + 1] = 0.5F;
+    ret[COL_7 * 3 + 2] = 1.0F;
+
+    ret[COL_8 * 3 + 0] = 0.5F;
+    ret[COL_8 * 3 + 1] = 1.0F;
+    ret[COL_8 * 3 + 2] = 0.5F;
+
+    ret[COL_9 * 3 + 0] = 1.0F;
+    ret[COL_9 * 3 + 1] = 0.5F;
+    ret[COL_9 * 3 + 2] = 0.5F;
+
+    ret[COL_IMPOSSIBLE * 3 + 0] = 0.0F;
+    ret[COL_IMPOSSIBLE * 3 + 1] = 0.0F;
+    ret[COL_IMPOSSIBLE * 3 + 2] = 0.0F;
+
+    ret[COL_SEL * 3 + 0] = 1.0F;
+    ret[COL_SEL * 3 + 1] = 1.0F;
+    ret[COL_SEL * 3 + 2] = 1.0F;
+
+    ret[COL_HIGHLIGHT * 3 + 0] = 1.0F;
+    ret[COL_HIGHLIGHT * 3 + 1] = 1.0F;
+    ret[COL_HIGHLIGHT * 3 + 2] = 1.0F;
+
+    ret[COL_LOWLIGHT * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 2.0F / 3.0F;
+    ret[COL_LOWLIGHT * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 2.0F / 3.0F;
+    ret[COL_LOWLIGHT * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 2.0F / 3.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->started = 0;
+    ds->tileinner = ds->tilegap = 0;   /* not decided yet */
+    ds->tiles = snewn(state->n, int);
+    ds->bgcolour = -1;
+    for (i = 0; i < state->n; i++)
+        ds->tiles[i] = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->tiles);
+    sfree(ds);
+}
+
+/* Drawing routing for the tile at (x,y) is responsible for drawing
+ * itself and the gaps to its right and below. If we're the same colour
+ * as the tile to our right, then we fill in the gap; ditto below, and if
+ * both then we fill the teeny tiny square in the corner as well.
+ */
+
+static void tile_redraw(drawing *dr, game_drawstate *ds,
+                        int x, int y, int dright, int dbelow,
+                        int tile, int bgcolour)
+{
+    int outer = bgcolour, inner = outer, col = tile & TILE_COLMASK;
+
+    if (col) {
+        if (tile & TILE_IMPOSSIBLE) {
+            outer = col;
+            inner = COL_IMPOSSIBLE;
+        } else if (tile & TILE_SELECTED) {
+            outer = COL_SEL;
+            inner = col;
+        } else {
+            outer = inner = col;
+        }
+    }
+    draw_rect(dr, COORD(x), COORD(y), TILE_INNER, TILE_INNER, outer);
+    draw_rect(dr, COORD(x)+TILE_INNER/4, COORD(y)+TILE_INNER/4,
+              TILE_INNER/2, TILE_INNER/2, inner);
+
+    if (dright)
+        draw_rect(dr, COORD(x)+TILE_INNER, COORD(y), TILE_GAP, TILE_INNER,
+                  (tile & TILE_JOINRIGHT) ? outer : bgcolour);
+    if (dbelow)
+        draw_rect(dr, COORD(x), COORD(y)+TILE_INNER, TILE_INNER, TILE_GAP,
+                  (tile & TILE_JOINDOWN) ? outer : bgcolour);
+    if (dright && dbelow)
+        draw_rect(dr, COORD(x)+TILE_INNER, COORD(y)+TILE_INNER, TILE_GAP, TILE_GAP,
+                  (tile & TILE_JOINDIAG) ? outer : bgcolour);
+
+    if (tile & TILE_HASSEL) {
+        int sx = COORD(x)+2, sy = COORD(y)+2, ssz = TILE_INNER-5;
+        int scol = (outer == COL_SEL) ? COL_LOWLIGHT : COL_HIGHLIGHT;
+        draw_line(dr, sx,     sy,     sx+ssz, sy,     scol);
+        draw_line(dr, sx+ssz, sy,     sx+ssz, sy+ssz, scol);
+        draw_line(dr, sx+ssz, sy+ssz, sx,     sy+ssz, scol);
+        draw_line(dr, sx,     sy+ssz, sx,     sy,     scol);
+    }
+
+    draw_update(dr, COORD(x), COORD(y), TILE_SIZE, TILE_SIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int bgcolour, x, y;
+
+    /* This was entirely cloned from fifteen.c; it should probably be
+     * moved into some generic 'draw-recessed-rectangle' utility fn. */
+    if (!ds->started) {
+        int coords[10];
+
+        draw_rect(dr, 0, 0,
+                  TILE_SIZE * state->params.w + 2 * BORDER,
+                  TILE_SIZE * state->params.h + 2 * BORDER, COL_BACKGROUND);
+        draw_update(dr, 0, 0,
+                    TILE_SIZE * state->params.w + 2 * BORDER,
+                    TILE_SIZE * state->params.h + 2 * BORDER);
+
+        /*
+         * Recessed area containing the whole puzzle.
+         */
+        coords[0] = COORD(state->params.w) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
+        coords[1] = COORD(state->params.h) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
+        coords[2] = COORD(state->params.w) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
+        coords[3] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[4] = coords[2] - TILE_SIZE;
+        coords[5] = coords[3] + TILE_SIZE;
+        coords[8] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[9] = COORD(state->params.h) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
+        coords[6] = coords[8] + TILE_SIZE;
+        coords[7] = coords[9] - TILE_SIZE;
+        draw_polygon(dr, coords, 5, COL_HIGHLIGHT, COL_HIGHLIGHT);
+
+        coords[1] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
+        draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
+
+        ds->started = 1;
+    }
+
+    if (flashtime > 0.0) {
+        int frame = (int)(flashtime / FLASH_FRAME);
+        bgcolour = (frame % 2 ? COL_LOWLIGHT : COL_HIGHLIGHT);
+    } else
+        bgcolour = COL_BACKGROUND;
+
+    for (x = 0; x < state->params.w; x++) {
+        for (y = 0; y < state->params.h; y++) {
+            int i = (state->params.w * y) + x;
+            int col = COL(state,x,y), tile = col;
+            int dright = (x+1 < state->params.w);
+            int dbelow = (y+1 < state->params.h);
+
+            tile |= ISSEL(ui,x,y);
+            if (state->impossible)
+                tile |= TILE_IMPOSSIBLE;
+            if (dright && COL(state,x+1,y) == col)
+                tile |= TILE_JOINRIGHT;
+            if (dbelow && COL(state,x,y+1) == col)
+                tile |= TILE_JOINDOWN;
+            if ((tile & TILE_JOINRIGHT) && (tile & TILE_JOINDOWN) &&
+                COL(state,x+1,y+1) == col)
+                tile |= TILE_JOINDIAG;
+
+            if (ui->displaysel && ui->xsel == x && ui->ysel == y)
+                tile |= TILE_HASSEL;
+
+            /* For now we're never expecting oldstate at all (because we have
+             * no animation); when we do we might well want to be looking
+             * at the tile colours from oldstate, not state. */
+            if ((oldstate && COL(oldstate,x,y) != col) ||
+                (ds->bgcolour != bgcolour) ||
+                (tile != ds->tiles[i])) {
+                tile_redraw(dr, ds, x, y, dright, dbelow, tile, bgcolour);
+                ds->tiles[i] = tile;
+            }
+        }
+    }
+    ds->bgcolour = bgcolour;
+
+    {
+        char status[255], score[80];
+
+        sprintf(score, "Score: %d", state->score);
+
+        if (state->complete)
+            sprintf(status, "COMPLETE! %s", score);
+        else if (state->impossible)
+            sprintf(status, "Cannot move! %s", score);
+        else if (ui->nselected)
+            sprintf(status, "%s  Selected: %d (%d)",
+                    score, ui->nselected, npoints(&state->params, ui->nselected));
+        else
+            sprintf(status, "%s", score);
+        status_bar(dr, status);
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if ((!oldstate->complete && newstate->complete) ||
+        (!oldstate->impossible && newstate->impossible))
+        return 2 * FLASH_FRAME;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    /*
+     * Dead-end situations are assumed to be rescuable by Undo, so we
+     * don't bother to identify them and return -1.
+     */
+    return state->complete ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame samegame
+#endif
+
+const struct game thegame = {
+    "Same Game", "games.samegame", "samegame",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    FALSE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
diff --git a/apps/plugins/puzzles/signpost.R b/apps/plugins/puzzles/signpost.R
new file mode 100644
index 0000000000..09ea367d57
--- /dev/null
+++ b/apps/plugins/puzzles/signpost.R
@@ -0,0 +1,23 @@
+# -*- makefile -*-
+
+SIGNPOST_EXTRA = dsf
+
+signpost : [X] GTK COMMON signpost SIGNPOST_EXTRA signpost-icon|no-icon
+signpost : [G] WINDOWS COMMON signpost SIGNPOST_EXTRA signpost.res|noicon.res
+
+signpostsolver : [U] signpost[STANDALONE_SOLVER] SIGNPOST_EXTRA STANDALONE m.lib
+signpostsolver : [C] signpost[STANDALONE_SOLVER] SIGNPOST_EXTRA STANDALONE
+
+ALL += signpost[COMBINED] SIGNPOST_EXTRA
+
+!begin am gtk
+GAMES += signpost
+!end
+
+!begin >list.c
+    A(signpost) \
+!end
+
+!begin >gamedesc.txt
+signpost:signpost.exe:Signpost:Square-connecting puzzle:Connect the squares into a path following the arrows.
+!end
diff --git a/apps/plugins/puzzles/signpost.c b/apps/plugins/puzzles/signpost.c
new file mode 100644
index 0000000000..a2e431e746
--- /dev/null
+++ b/apps/plugins/puzzles/signpost.c
@@ -0,0 +1,2480 @@
+/*
+ * signpost.c: implementation of the janko game 'arrow path'
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#define PREFERRED_TILE_SIZE 48
+#define TILE_SIZE (ds->tilesize)
+#define BLITTER_SIZE TILE_SIZE
+#define BORDER    (TILE_SIZE / 2)
+
+#define COORD(x)  ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
+
+#define INGRID(s,x,y) ((x) >= 0 && (x) < (s)->w && (y) >= 0 && (y) < (s)->h)
+
+#define FLASH_SPIN 0.7F
+
+#define NBACKGROUNDS 16
+
+enum {
+    COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT,
+    COL_GRID, COL_CURSOR, COL_ERROR, COL_DRAG_ORIGIN,
+    COL_ARROW, COL_ARROW_BG_DIM,
+    COL_NUMBER, COL_NUMBER_SET, COL_NUMBER_SET_MID,
+    COL_B0,                             /* background colours */
+    COL_M0 =   COL_B0 + 1*NBACKGROUNDS, /* mid arrow colours */
+    COL_D0 =   COL_B0 + 2*NBACKGROUNDS, /* dim arrow colours */
+    COL_X0 =   COL_B0 + 3*NBACKGROUNDS, /* dim arrow colours */
+    NCOLOURS = COL_B0 + 4*NBACKGROUNDS
+};
+
+struct game_params {
+    int w, h;
+    int force_corner_start;
+};
+
+enum { DIR_N = 0, DIR_NE, DIR_E, DIR_SE, DIR_S, DIR_SW, DIR_W, DIR_NW, DIR_MAX };
+static const char *dirstrings[8] = { "N ", "NE", "E ", "SE", "S ", "SW", "W ", "NW" };
+
+static const int dxs[DIR_MAX] = {  0,  1, 1, 1, 0, -1, -1, -1 };
+static const int dys[DIR_MAX] = { -1, -1, 0, 1, 1,  1,  0, -1 };
+
+#define DIR_OPPOSITE(d) ((d+4)%8)
+
+struct game_state {
+    int w, h, n;
+    int completed, used_solve, impossible;
+    int *dirs;                  /* direction enums, size n */
+    int *nums;                  /* numbers, size n */
+    unsigned int *flags;        /* flags, size n */
+    int *next, *prev;           /* links to other cell indexes, size n (-1 absent) */
+    int *dsf;                   /* connects regions with a dsf. */
+    int *numsi;                 /* for each number, which index is it in? (-1 absent) */
+};
+
+#define FLAG_IMMUTABLE  1
+#define FLAG_ERROR      2
+
+/* --- Generally useful functions --- */
+
+#define ISREALNUM(state, num) ((num) > 0 && (num) <= (state)->n)
+
+static int whichdir(int fromx, int fromy, int tox, int toy)
+{
+    int i, dx, dy;
+
+    dx = tox - fromx;
+    dy = toy - fromy;
+
+    if (dx && dy && abs(dx) != abs(dy)) return -1;
+
+    if (dx) dx = dx / abs(dx); /* limit to (-1, 0, 1) */
+    if (dy) dy = dy / abs(dy); /* ditto */
+
+    for (i = 0; i < DIR_MAX; i++) {
+        if (dx == dxs[i] && dy == dys[i]) return i;
+    }
+    return -1;
+}
+
+static int whichdiri(game_state *state, int fromi, int toi)
+{
+    int w = state->w;
+    return whichdir(fromi%w, fromi/w, toi%w, toi/w);
+}
+
+static int ispointing(const game_state *state, int fromx, int fromy,
+                      int tox, int toy)
+{
+    int w = state->w, dir = state->dirs[fromy*w+fromx];
+
+    /* (by convention) squares do not point to themselves. */
+    if (fromx == tox && fromy == toy) return 0;
+
+    /* the final number points to nothing. */
+    if (state->nums[fromy*w + fromx] == state->n) return 0;
+
+    while (1) {
+        if (!INGRID(state, fromx, fromy)) return 0;
+        if (fromx == tox && fromy == toy) return 1;
+        fromx += dxs[dir]; fromy += dys[dir];
+    }
+    return 0; /* not reached */
+}
+
+static int ispointingi(game_state *state, int fromi, int toi)
+{
+    int w = state->w;
+    return ispointing(state, fromi%w, fromi/w, toi%w, toi/w);
+}
+
+/* Taking the number 'num', work out the gap between it and the next
+ * available number up or down (depending on d). Return 1 if the region
+ * at (x,y) will fit in that gap, or 0 otherwise. */
+static int move_couldfit(const game_state *state, int num, int d, int x, int y)
+{
+    int n, gap, i = y*state->w+x, sz;
+
+    assert(d != 0);
+    /* The 'gap' is the number of missing numbers in the grid between
+     * our number and the next one in the sequence (up or down), or
+     * the end of the sequence (if we happen not to have 1/n present) */
+    for (n = num + d, gap = 0;
+         ISREALNUM(state, n) && state->numsi[n] == -1;
+         n += d, gap++) ; /* empty loop */
+
+    if (gap == 0) {
+        /* no gap, so the only allowable move is that that directly
+         * links the two numbers. */
+        n = state->nums[i];
+        return (n == num+d) ? 0 : 1;
+    }
+    if (state->prev[i] == -1 && state->next[i] == -1)
+        return 1; /* single unconnected square, always OK */
+
+    sz = dsf_size(state->dsf, i);
+    return (sz > gap) ? 0 : 1;
+}
+
+static int isvalidmove(const game_state *state, int clever,
+                       int fromx, int fromy, int tox, int toy)
+{
+    int w = state->w, from = fromy*w+fromx, to = toy*w+tox;
+    int nfrom, nto;
+
+    if (!INGRID(state, fromx, fromy) || !INGRID(state, tox, toy))
+        return 0;
+
+    /* can only move where we point */
+    if (!ispointing(state, fromx, fromy, tox, toy))
+        return 0;
+
+    nfrom = state->nums[from]; nto = state->nums[to];
+
+    /* can't move _from_ the preset final number, or _to_ the preset 1. */
+    if (((nfrom == state->n) && (state->flags[from] & FLAG_IMMUTABLE)) ||
+        ((nto   == 1)        && (state->flags[to]   & FLAG_IMMUTABLE)))
+        return 0;
+
+    /* can't create a new connection between cells in the same region
+     * as that would create a loop. */
+    if (dsf_canonify(state->dsf, from) == dsf_canonify(state->dsf, to))
+        return 0;
+
+    /* if both cells are actual numbers, can't drag if we're not
+     * one digit apart. */
+    if (ISREALNUM(state, nfrom) && ISREALNUM(state, nto)) {
+        if (nfrom != nto-1)
+            return 0;
+    } else if (clever && ISREALNUM(state, nfrom)) {
+        if (!move_couldfit(state, nfrom, +1, tox, toy))
+            return 0;
+    } else if (clever && ISREALNUM(state, nto)) {
+        if (!move_couldfit(state, nto, -1, fromx, fromy))
+            return 0;
+    }
+
+    return 1;
+}
+
+static void makelink(game_state *state, int from, int to)
+{
+    if (state->next[from] != -1)
+        state->prev[state->next[from]] = -1;
+    state->next[from] = to;
+
+    if (state->prev[to] != -1)
+        state->next[state->prev[to]] = -1;
+    state->prev[to] = from;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    if (params->w * params->h >= 100) return 0;
+    return 1;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int len = state->h * 2 * (4*state->w + 1) + state->h + 2;
+    int x, y, i, num, n, set;
+    char *ret, *p;
+
+    p = ret = snewn(len, char);
+
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->h; x++) {
+            i = y*state->w+x;
+            *p++ = dirstrings[state->dirs[i]][0];
+            *p++ = dirstrings[state->dirs[i]][1];
+            *p++ = (state->flags[i] & FLAG_IMMUTABLE) ? 'I' : ' ';
+            *p++ = ' ';
+        }
+        *p++ = '\n';
+        for (x = 0; x < state->h; x++) {
+            i = y*state->w+x;
+            num = state->nums[i];
+            if (num == 0) {
+                *p++ = ' ';
+                *p++ = ' ';
+                *p++ = ' ';
+            } else {
+                n = num % (state->n+1);
+                set = num / (state->n+1);
+
+                assert(n <= 99); /* two digits only! */
+
+                if (set != 0)
+                    *p++ = set+'a'-1;
+
+                *p++ = (n >= 10) ? ('0' + (n/10)) : ' ';
+                *p++ = '0' + (n%10);
+
+                if (set == 0)
+                    *p++ = ' ';
+            }
+            *p++ = ' ';
+        }
+        *p++ = '\n';
+        *p++ = '\n';
+    }
+    *p++ = '\0';
+
+    return ret;
+}
+
+static void debug_state(const char *desc, game_state *state)
+{
+#ifdef DEBUGGING
+    char *dbg;
+    if (state->n >= 100) {
+        debug(("[ no game_text_format for this size ]"));
+        return;
+    }
+    dbg = game_text_format(state);
+    debug(("%s\n%s", desc, dbg));
+    sfree(dbg);
+#endif
+}
+
+
+static void strip_nums(game_state *state) {
+    int i;
+    for (i = 0; i < state->n; i++) {
+        if (!(state->flags[i] & FLAG_IMMUTABLE))
+            state->nums[i] = 0;
+    }
+    memset(state->next, -1, state->n*sizeof(int));
+    memset(state->prev, -1, state->n*sizeof(int));
+    memset(state->numsi, -1, (state->n+1)*sizeof(int));
+    dsf_init(state->dsf, state->n);
+}
+
+static int check_nums(game_state *orig, game_state *copy, int only_immutable)
+{
+    int i, ret = 1;
+    assert(copy->n == orig->n);
+    for (i = 0; i < copy->n; i++) {
+        if (only_immutable && !copy->flags[i] & FLAG_IMMUTABLE) continue;
+        assert(copy->nums[i] >= 0);
+        assert(copy->nums[i] <= copy->n);
+        if (copy->nums[i] != orig->nums[i]) {
+            debug(("check_nums: (%d,%d) copy=%d, orig=%d.",
+                   i%orig->w, i/orig->w, copy->nums[i], orig->nums[i]));
+            ret = 0;
+        }
+    }
+    return ret;
+}
+
+/* --- Game parameter/presets functions --- */
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+    ret->w = ret->h = 4;
+    ret->force_corner_start = 1;
+
+    return ret;
+}
+
+static const struct game_params signpost_presets[] = {
+  { 4, 4, 1 },
+  { 4, 4, 0 },
+  { 5, 5, 1 },
+  { 5, 5, 0 },
+  { 6, 6, 1 },
+  { 7, 7, 1 }
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(signpost_presets))
+        return FALSE;
+
+    ret = default_params();
+    *ret = signpost_presets[i];
+    *params = ret;
+
+    sprintf(buf, "%dx%d%s", ret->w, ret->h,
+            ret->force_corner_start ? "" : ", free ends");
+    *name = dupstr(buf);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        ret->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    ret->force_corner_start = 0;
+    if (*string == 'c') {
+        string++;
+        ret->force_corner_start = 1;
+    }
+
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    if (full)
+        sprintf(data, "%dx%d%s", params->w, params->h,
+                params->force_corner_start ? "c" : "");
+    else
+        sprintf(data, "%dx%d", params->w, params->h);
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Start and end in corners";
+    ret[2].type = C_BOOLEAN;
+    ret[2].sval = NULL;
+    ret[2].ival = params->force_corner_start;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->force_corner_start = cfg[2].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 1) return "Width must be at least one";
+    if (params->h < 1) return "Height must be at least one";
+    if (full && params->w == 1 && params->h == 1)
+        /* The UI doesn't let us move these from unsolved to solved,
+         * so we disallow generating (but not playing) them. */
+        return "Width and height cannot both be one";
+    return NULL;
+}
+
+/* --- Game description string generation and unpicking --- */
+
+static void blank_game_into(game_state *state)
+{
+    memset(state->dirs, 0, state->n*sizeof(int));
+    memset(state->nums, 0, state->n*sizeof(int));
+    memset(state->flags, 0, state->n*sizeof(unsigned int));
+    memset(state->next, -1, state->n*sizeof(int));
+    memset(state->prev, -1, state->n*sizeof(int));
+    memset(state->numsi, -1, (state->n+1)*sizeof(int));
+}
+
+static game_state *blank_game(int w, int h)
+{
+    game_state *state = snew(game_state);
+
+    memset(state, 0, sizeof(game_state));
+    state->w = w;
+    state->h = h;
+    state->n = w*h;
+
+    state->dirs  = snewn(state->n, int);
+    state->nums  = snewn(state->n, int);
+    state->flags = snewn(state->n, unsigned int);
+    state->next  = snewn(state->n, int);
+    state->prev  = snewn(state->n, int);
+    state->dsf = snew_dsf(state->n);
+    state->numsi  = snewn(state->n+1, int);
+
+    blank_game_into(state);
+
+    return state;
+}
+
+static void dup_game_to(game_state *to, const game_state *from)
+{
+    to->completed = from->completed;
+    to->used_solve = from->used_solve;
+    to->impossible = from->impossible;
+
+    memcpy(to->dirs, from->dirs, to->n*sizeof(int));
+    memcpy(to->flags, from->flags, to->n*sizeof(unsigned int));
+    memcpy(to->nums, from->nums, to->n*sizeof(int));
+
+    memcpy(to->next, from->next, to->n*sizeof(int));
+    memcpy(to->prev, from->prev, to->n*sizeof(int));
+
+    memcpy(to->dsf, from->dsf, to->n*sizeof(int));
+    memcpy(to->numsi, from->numsi, (to->n+1)*sizeof(int));
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = blank_game(state->w, state->h);
+    dup_game_to(ret, state);
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->dirs);
+    sfree(state->nums);
+    sfree(state->flags);
+    sfree(state->next);
+    sfree(state->prev);
+    sfree(state->dsf);
+    sfree(state->numsi);
+    sfree(state);
+}
+
+static void unpick_desc(const game_params *params, const char *desc,
+                        game_state **sout, char **mout)
+{
+    game_state *state = blank_game(params->w, params->h);
+    char *msg = NULL, c;
+    int num = 0, i = 0;
+
+    while (*desc) {
+        if (i >= state->n) {
+            msg = "Game description longer than expected";
+            goto done;
+        }
+
+        c = *desc;
+        if (isdigit((unsigned char)c)) {
+            num = (num*10) + (int)(c-'0');
+            if (num > state->n) {
+                msg = "Number too large";
+                goto done;
+            }
+        } else if ((c-'a') >= 0 && (c-'a') < DIR_MAX) {
+            state->nums[i] = num;
+            state->flags[i] = num ? FLAG_IMMUTABLE : 0;
+            num = 0;
+
+            state->dirs[i] = c - 'a';
+            i++;
+        } else if (!*desc) {
+            msg = "Game description shorter than expected";
+            goto done;
+        } else {
+            msg = "Game description contains unexpected characters";
+            goto done;
+        }
+        desc++;
+    }
+    if (i < state->n) {
+        msg = "Game description shorter than expected";
+        goto done;
+    }
+
+done:
+    if (msg) { /* sth went wrong. */
+        if (mout) *mout = msg;
+        free_game(state);
+    } else {
+        if (mout) *mout = NULL;
+        if (sout) *sout = state;
+        else free_game(state);
+    }
+}
+
+static char *generate_desc(game_state *state, int issolve)
+{
+    char *ret, buf[80];
+    int retlen, i, k;
+
+    ret = NULL; retlen = 0;
+    if (issolve) {
+        ret = sresize(ret, 2, char);
+        ret[0] = 'S'; ret[1] = '\0';
+        retlen += 1;
+    }
+    for (i = 0; i < state->n; i++) {
+        if (state->nums[i])
+            k = sprintf(buf, "%d%c", state->nums[i], (int)(state->dirs[i]+'a'));
+        else
+            k = sprintf(buf, "%c", (int)(state->dirs[i]+'a'));
+        ret = sresize(ret, retlen + k + 1, char);
+        strcpy(ret + retlen, buf);
+        retlen += k;
+    }
+    return ret;
+}
+
+/* --- Game generation --- */
+
+/* Fills in preallocated arrays ai (indices) and ad (directions)
+ * showing all non-numbered cells adjacent to index i, returns length */
+/* This function has been somewhat optimised... */
+static int cell_adj(game_state *state, int i, int *ai, int *ad)
+{
+    int n = 0, a, x, y, sx, sy, dx, dy, newi;
+    int w = state->w, h = state->h;
+
+    sx = i % w; sy = i / w;
+
+    for (a = 0; a < DIR_MAX; a++) {
+        x = sx; y = sy;
+        dx = dxs[a]; dy = dys[a];
+        while (1) {
+            x += dx; y += dy;
+            if (x < 0 || y < 0 || x >= w || y >= h) break;
+
+            newi = y*w + x;
+            if (state->nums[newi] == 0) {
+                ai[n] = newi;
+                ad[n] = a;
+                n++;
+            }
+        }
+    }
+    return n;
+}
+
+static int new_game_fill(game_state *state, random_state *rs,
+                         int headi, int taili)
+{
+    int nfilled, an, ret = 0, j;
+    int *aidx, *adir;
+
+    aidx = snewn(state->n, int);
+    adir = snewn(state->n, int);
+
+    debug(("new_game_fill: headi=%d, taili=%d.", headi, taili));
+
+    memset(state->nums, 0, state->n*sizeof(int));
+
+    state->nums[headi] = 1;
+    state->nums[taili] = state->n;
+
+    state->dirs[taili] = 0;
+    nfilled = 2;
+    assert(state->n > 1);
+
+    while (nfilled < state->n) {
+        /* Try and expand _from_ headi; keep going if there's only one
+         * place to go to. */
+        an = cell_adj(state, headi, aidx, adir);
+        do {
+            if (an == 0) goto done;
+            j = random_upto(rs, an);
+            state->dirs[headi] = adir[j];
+            state->nums[aidx[j]] = state->nums[headi] + 1;
+            nfilled++;
+            headi = aidx[j];
+            an = cell_adj(state, headi, aidx, adir);
+        } while (an == 1);
+
+        if (nfilled == state->n) break;
+
+        /* Try and expand _to_ taili; keep going if there's only one
+         * place to go to. */
+        an = cell_adj(state, taili, aidx, adir);
+        do {
+            if (an == 0) goto done;
+            j = random_upto(rs, an);
+            state->dirs[aidx[j]] = DIR_OPPOSITE(adir[j]);
+            state->nums[aidx[j]] = state->nums[taili] - 1;
+            nfilled++;
+            taili = aidx[j];
+            an = cell_adj(state, taili, aidx, adir);
+        } while (an == 1);
+    }
+    /* If we get here we have headi and taili set but unconnected
+     * by direction: we need to set headi's direction so as to point
+     * at taili. */
+    state->dirs[headi] = whichdiri(state, headi, taili);
+
+    /* it could happen that our last two weren't in line; if that's the
+     * case, we have to start again. */
+    if (state->dirs[headi] != -1) ret = 1;
+
+done:
+    sfree(aidx);
+    sfree(adir);
+    return ret;
+}
+
+/* Better generator: with the 'generate, sprinkle numbers, solve,
+ * repeat' algorithm we're _never_ generating anything greater than
+ * 6x6, and spending all of our time in new_game_fill (and very little
+ * in solve_state).
+ *
+ * So, new generator steps:
+   * generate the grid, at random (same as now). Numbers 1 and N get
+      immutable flag immediately.
+   * squirrel that away for the solved state.
+   *
+   * (solve:) Try and solve it.
+   * If we solved it, we're done:
+     * generate the description from current immutable numbers,
+     * free stuff that needs freeing,
+     * return description + solved state.
+   * If we didn't solve it:
+     * count #tiles in state we've made deductions about.
+     * while (1):
+       * randomise a scratch array.
+       * for each index in scratch (in turn):
+         * if the cell isn't empty, continue (through scratch array)
+         * set number + immutable in state.
+         * try and solve state.
+         * if we've solved it, we're done.
+         * otherwise, count #tiles. If it's more than we had before:
+           * good, break from this loop and re-randomise.
+         * otherwise (number didn't help):
+           * remove number and try next in scratch array.
+       * if we've got to the end of the scratch array, no luck:
+          free everything we need to, and go back to regenerate the grid.
+   */
+
+static int solve_state(game_state *state);
+
+static void debug_desc(const char *what, game_state *state)
+{
+#if DEBUGGING
+    {
+        char *desc = generate_desc(state, 0);
+        debug(("%s game state: %dx%d:%s", what, state->w, state->h, desc));
+        sfree(desc);
+    }
+#endif
+}
+
+/* Expects a fully-numbered game_state on input, and makes sure
+ * FLAG_IMMUTABLE is only set on those numbers we need to solve
+ * (as for a real new-game); returns 1 if it managed
+ * this (such that it could solve it), or 0 if not. */
+static int new_game_strip(game_state *state, random_state *rs)
+{
+    int *scratch, i, j, ret = 1;
+    game_state *copy = dup_game(state);
+
+    debug(("new_game_strip."));
+
+    strip_nums(copy);
+    debug_desc("Stripped", copy);
+
+    if (solve_state(copy) > 0) {
+        debug(("new_game_strip: soluble immediately after strip."));
+        free_game(copy);
+        return 1;
+    }
+
+    scratch = snewn(state->n, int);
+    for (i = 0; i < state->n; i++) scratch[i] = i;
+    shuffle(scratch, state->n, sizeof(int), rs);
+
+    /* This is scungy. It might just be quick enough.
+     * It goes through, adding set numbers in empty squares
+     * until either we run out of empty squares (in the one
+     * we're half-solving) or else we solve it properly.
+     * NB that we run the entire solver each time, which
+     * strips the grid beforehand; we will save time if we
+     * avoid that. */
+    for (i = 0; i < state->n; i++) {
+        j = scratch[i];
+        if (copy->nums[j] > 0 && copy->nums[j] <= state->n)
+            continue; /* already solved to a real number here. */
+        assert(state->nums[j] <= state->n);
+        debug(("new_game_strip: testing add IMMUTABLE number %d at square (%d,%d).",
+               state->nums[j], j%state->w, j/state->w));
+        copy->nums[j] = state->nums[j];
+        copy->flags[j] |= FLAG_IMMUTABLE;
+        state->flags[j] |= FLAG_IMMUTABLE;
+        debug_state("Copy of state: ", copy);
+        strip_nums(copy);
+        if (solve_state(copy) > 0) goto solved;
+        assert(check_nums(state, copy, 1));
+    }
+    ret = 0;
+    goto done;
+
+solved:
+    debug(("new_game_strip: now solved."));
+    /* Since we added basically at random, try now to remove numbers
+     * and see if we can still solve it; if we can (still), really
+     * remove the number. Make sure we don't remove the anchor numbers
+     * 1 and N. */
+    for (i = 0; i < state->n; i++) {
+        j = scratch[i];
+        if ((state->flags[j] & FLAG_IMMUTABLE) &&
+            (state->nums[j] != 1 && state->nums[j] != state->n)) {
+            debug(("new_game_strip: testing remove IMMUTABLE number %d at square (%d,%d).",
+                  state->nums[j], j%state->w, j/state->w));
+            state->flags[j] &= ~FLAG_IMMUTABLE;
+            dup_game_to(copy, state);
+            strip_nums(copy);
+            if (solve_state(copy) > 0) {
+                assert(check_nums(state, copy, 0));
+                debug(("new_game_strip: OK, removing number"));
+            } else {
+                assert(state->nums[j] <= state->n);
+                debug(("new_game_strip: cannot solve, putting IMMUTABLE back."));
+                copy->nums[j] = state->nums[j];
+                state->flags[j] |= FLAG_IMMUTABLE;
+            }
+        }
+    }
+
+done:
+    debug(("new_game_strip: %ssuccessful.", ret ? "" : "not "));
+    sfree(scratch);
+    free_game(copy);
+    return ret;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    game_state *state = blank_game(params->w, params->h);
+    char *ret;
+    int headi, taili;
+
+    /* this shouldn't happen (validate_params), but let's play it safe */
+    if (params->w == 1 && params->h == 1) return dupstr("1a");
+
+generate:
+    blank_game_into(state);
+
+    /* keep trying until we fill successfully. */
+    do {
+        if (params->force_corner_start) {
+            headi = 0;
+            taili = state->n-1;
+        } else {
+            do {
+                headi = random_upto(rs, state->n);
+                taili = random_upto(rs, state->n);
+            } while (headi == taili);
+        }
+    } while (!new_game_fill(state, rs, headi, taili));
+
+    debug_state("Filled game:", state);
+
+    assert(state->nums[headi] <= state->n);
+    assert(state->nums[taili] <= state->n);
+
+    state->flags[headi] |= FLAG_IMMUTABLE;
+    state->flags[taili] |= FLAG_IMMUTABLE;
+
+    /* This will have filled in directions and _all_ numbers.
+     * Store the game definition for this, as the solved-state. */
+    if (!new_game_strip(state, rs)) {
+        goto generate;
+    }
+    strip_nums(state);
+    {
+        game_state *tosolve = dup_game(state);
+        assert(solve_state(tosolve) > 0);
+        free_game(tosolve);
+    }
+    ret = generate_desc(state, 0);
+    free_game(state);
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    char *ret = NULL;
+
+    unpick_desc(params, desc, NULL, &ret);
+    return ret;
+}
+
+/* --- Linked-list and numbers array --- */
+
+/* Assuming numbers are always up-to-date, there are only four possibilities
+ * for regions changing after a single valid move:
+ *
+ * 1) two differently-coloured regions being combined (the resulting colouring
+ *     should be based on the larger of the two regions)
+ * 2) a numbered region having a single number added to the start (the
+ *     region's colour will remain, and the numbers will shift by 1)
+ * 3) a numbered region having a single number added to the end (the
+ *     region's colour and numbering remains as-is)
+ * 4) two unnumbered squares being joined (will pick the smallest unused set
+ *     of colours to use for the new region).
+ *
+ * There should never be any complications with regions containing 3 colours
+ * being combined, since two of those colours should have been merged on a
+ * previous move.
+ *
+ * Most of the complications are in ensuring we don't accidentally set two
+ * regions with the same colour (e.g. if a region was split). If this happens
+ * we always try and give the largest original portion the original colour.
+ */
+
+#define COLOUR(a) ((a) / (state->n+1))
+#define START(c) ((c) * (state->n+1))
+
+struct head_meta {
+    int i;      /* position */
+    int sz;     /* size of region */
+    int start;  /* region start number preferred, or 0 if !preference */
+    int preference; /* 0 if we have no preference (and should just pick one) */
+    const char *why;
+};
+
+static void head_number(game_state *state, int i, struct head_meta *head)
+{
+    int off = 0, ss, j = i, c, n, sz;
+
+    /* Insist we really were passed the head of a chain. */
+    assert(state->prev[i] == -1 && state->next[i] != -1);
+
+    head->i = i;
+    head->sz = dsf_size(state->dsf, i);
+    head->why = NULL;
+
+    /* Search through this chain looking for real numbers, checking that
+     * they match up (if there are more than one). */
+    head->preference = 0;
+    while (j != -1) {
+        if (state->flags[j] & FLAG_IMMUTABLE) {
+            ss = state->nums[j] - off;
+            if (!head->preference) {
+                head->start = ss;
+                head->preference = 1;
+                head->why = "contains cell with immutable number";
+            } else if (head->start != ss) {
+                debug(("head_number: chain with non-sequential numbers!"));
+                state->impossible = 1;
+            }
+        }
+        off++;
+        j = state->next[j];
+        assert(j != i); /* we have created a loop, obviously wrong */
+    }
+    if (head->preference) goto done;
+
+    if (state->nums[i] == 0 && state->nums[state->next[i]] > state->n) {
+        /* (probably) empty cell onto the head of a coloured region:
+         * make sure we start at a 0 offset. */
+        head->start = START(COLOUR(state->nums[state->next[i]]));
+        head->preference = 1;
+        head->why = "adding blank cell to head of numbered region";
+    } else if (state->nums[i] <= state->n) {
+        /* if we're 0 we're probably just blank -- but even if we're a
+         * (real) numbered region, we don't have an immutable number
+         * in it (any more) otherwise it'd have been caught above, so
+         * reassign the colour. */
+        head->start = 0;
+        head->preference = 0;
+        head->why = "lowest available colour group";
+    } else {
+        c = COLOUR(state->nums[i]);
+        n = 1;
+        sz = dsf_size(state->dsf, i);
+        j = i;
+        while (state->next[j] != -1) {
+            j = state->next[j];
+            if (state->nums[j] == 0 && state->next[j] == -1) {
+                head->start = START(c);
+                head->preference = 1;
+                head->why = "adding blank cell to end of numbered region";
+                goto done;
+            }
+            if (COLOUR(state->nums[j]) == c)
+                n++;
+            else {
+                int start_alternate = START(COLOUR(state->nums[j]));
+                if (n < (sz - n)) {
+                    head->start = start_alternate;
+                    head->preference = 1;
+                    head->why = "joining two coloured regions, swapping to larger colour";
+                } else {
+                    head->start = START(c);
+                    head->preference = 1;
+                    head->why = "joining two coloured regions, taking largest";
+                }
+                goto done;
+            }
+        }
+        /* If we got here then we may have split a region into
+         * two; make sure we don't assign a colour we've already used. */
+        if (c == 0) {
+            /* not convinced this shouldn't be an assertion failure here. */
+            head->start = 0;
+            head->preference = 0;
+        } else {
+            head->start = START(c);
+            head->preference = 1;
+        }
+        head->why = "got to end of coloured region";
+    }
+
+done:
+    assert(head->why != NULL);
+    if (head->preference)
+        debug(("Chain at (%d,%d) numbered for preference at %d (colour %d): %s.",
+               head->i%state->w, head->i/state->w,
+               head->start, COLOUR(head->start), head->why));
+    else
+        debug(("Chain at (%d,%d) using next available colour: %s.",
+               head->i%state->w, head->i/state->w,
+               head->why));
+}
+
+#if 0
+static void debug_numbers(game_state *state)
+{
+    int i, w=state->w;
+
+    for (i = 0; i < state->n; i++) {
+        debug(("(%d,%d) --> (%d,%d) --> (%d,%d)",
+               state->prev[i]==-1 ? -1 : state->prev[i]%w,
+               state->prev[i]==-1 ? -1 : state->prev[i]/w,
+               i%w, i/w,
+               state->next[i]==-1 ? -1 : state->next[i]%w,
+               state->next[i]==-1 ? -1 : state->next[i]/w));
+    }
+    w = w+1;
+}
+#endif
+
+static void connect_numbers(game_state *state)
+{
+    int i, di, dni;
+
+    dsf_init(state->dsf, state->n);
+    for (i = 0; i < state->n; i++) {
+        if (state->next[i] != -1) {
+            assert(state->prev[state->next[i]] == i);
+            di = dsf_canonify(state->dsf, i);
+            dni = dsf_canonify(state->dsf, state->next[i]);
+            if (di == dni) {
+                debug(("connect_numbers: chain forms a loop."));
+                state->impossible = 1;
+            }
+            dsf_merge(state->dsf, di, dni);
+        }
+    }
+}
+
+static int compare_heads(const void *a, const void *b)
+{
+    struct head_meta *ha = (struct head_meta *)a;
+    struct head_meta *hb = (struct head_meta *)b;
+
+    /* Heads with preferred colours first... */
+    if (ha->preference && !hb->preference) return -1;
+    if (hb->preference && !ha->preference) return 1;
+
+    /* ...then heads with low colours first... */
+    if (ha->start < hb->start) return -1;
+    if (ha->start > hb->start) return 1;
+
+    /* ... then large regions first... */
+    if (ha->sz > hb->sz) return -1;
+    if (ha->sz < hb->sz) return 1;
+
+    /* ... then position. */
+    if (ha->i > hb->i) return -1;
+    if (ha->i < hb->i) return 1;
+
+    return 0;
+}
+
+static int lowest_start(game_state *state, struct head_meta *heads, int nheads)
+{
+    int n, c;
+
+    /* NB start at 1: colour 0 is real numbers */
+    for (c = 1; c < state->n; c++) {
+        for (n = 0; n < nheads; n++) {
+            if (COLOUR(heads[n].start) == c)
+                goto used;
+        }
+        return c;
+used:
+        ;
+    }
+    assert(!"No available colours!");
+    return 0;
+}
+
+static void update_numbers(game_state *state)
+{
+    int i, j, n, nnum, nheads;
+    struct head_meta *heads = snewn(state->n, struct head_meta);
+
+    for (n = 0; n < state->n; n++)
+        state->numsi[n] = -1;
+
+    for (i = 0; i < state->n; i++) {
+        if (state->flags[i] & FLAG_IMMUTABLE) {
+            assert(state->nums[i] > 0);
+            assert(state->nums[i] <= state->n);
+            state->numsi[state->nums[i]] = i;
+        }
+        else if (state->prev[i] == -1 && state->next[i] == -1)
+            state->nums[i] = 0;
+    }
+    connect_numbers(state);
+
+    /* Construct an array of the heads of all current regions, together
+     * with their preferred colours. */
+    nheads = 0;
+    for (i = 0; i < state->n; i++) {
+        /* Look for a cell that is the start of a chain
+         * (has a next but no prev). */
+        if (state->prev[i] != -1 || state->next[i] == -1) continue;
+
+        head_number(state, i, &heads[nheads++]);
+    }
+
+    /* Sort that array:
+     * - heads with preferred colours first, then
+     * - heads with low colours first, then
+     * - large regions first
+     */
+    qsort(heads, nheads, sizeof(struct head_meta), compare_heads);
+
+    /* Remove duplicate-coloured regions. */
+    for (n = nheads-1; n >= 0; n--) { /* order is important! */
+        if ((n != 0) && (heads[n].start == heads[n-1].start)) {
+            /* We have a duplicate-coloured region: since we're
+             * sorted in size order and this is not the first
+             * of its colour it's not the largest: recolour it. */
+            heads[n].start = START(lowest_start(state, heads, nheads));
+            heads[n].preference = -1; /* '-1' means 'was duplicate' */
+        }
+        else if (!heads[n].preference) {
+            assert(heads[n].start == 0);
+            heads[n].start = START(lowest_start(state, heads, nheads));
+        }
+    }
+
+    debug(("Region colouring after duplicate removal:"));
+
+    for (n = 0; n < nheads; n++) {
+        debug(("  Chain at (%d,%d) sz %d numbered at %d (colour %d): %s%s",
+               heads[n].i % state->w, heads[n].i / state->w, heads[n].sz,
+               heads[n].start, COLOUR(heads[n].start), heads[n].why,
+               heads[n].preference == 0 ? " (next available)" :
+               heads[n].preference < 0 ? " (duplicate, next available)" : ""));
+
+        nnum = heads[n].start;
+        j = heads[n].i;
+        while (j != -1) {
+            if (!(state->flags[j] & FLAG_IMMUTABLE)) {
+                if (nnum > 0 && nnum <= state->n)
+                    state->numsi[nnum] = j;
+                state->nums[j] = nnum;
+            }
+            nnum++;
+            j = state->next[j];
+            assert(j != heads[n].i); /* loop?! */
+        }
+    }
+    /*debug_numbers(state);*/
+    sfree(heads);
+}
+
+static int check_completion(game_state *state, int mark_errors)
+{
+    int n, j, k, error = 0, complete;
+
+    /* NB This only marks errors that are possible to perpetrate with
+     * the current UI in interpret_move. Things like forming loops in
+     * linked sections and having numbers not add up should be forbidden
+     * by the code elsewhere, so we don't bother marking those (because
+     * it would add lots of tricky drawing code for very little gain). */
+    if (mark_errors) {
+        for (j = 0; j < state->n; j++)
+            state->flags[j] &= ~FLAG_ERROR;
+    }
+
+    /* Search for repeated numbers. */
+    for (j = 0; j < state->n; j++) {
+        if (state->nums[j] > 0 && state->nums[j] <= state->n) {
+            for (k = j+1; k < state->n; k++) {
+                if (state->nums[k] == state->nums[j]) {
+                    if (mark_errors) {
+                        state->flags[j] |= FLAG_ERROR;
+                        state->flags[k] |= FLAG_ERROR;
+                    }
+                    error = 1;
+                }
+            }
+        }
+    }
+
+    /* Search and mark numbers n not pointing to n+1; if any numbers
+     * are missing we know we've not completed. */
+    complete = 1;
+    for (n = 1; n < state->n; n++) {
+        if (state->numsi[n] == -1 || state->numsi[n+1] == -1)
+            complete = 0;
+        else if (!ispointingi(state, state->numsi[n], state->numsi[n+1])) {
+            if (mark_errors) {
+                state->flags[state->numsi[n]] |= FLAG_ERROR;
+                state->flags[state->numsi[n+1]] |= FLAG_ERROR;
+            }
+            error = 1;
+        } else {
+            /* make sure the link is explicitly made here; for instance, this
+             * is nice if the user drags from 2 out (making 3) and a 4 is also
+             * visible; this ensures that the link from 3 to 4 is also made. */
+            if (mark_errors)
+                makelink(state, state->numsi[n], state->numsi[n+1]);
+        }
+    }
+
+    /* Search and mark numbers less than 0, or 0 with links. */
+    for (n = 1; n < state->n; n++) {
+        if ((state->nums[n] < 0) ||
+            (state->nums[n] == 0 &&
+             (state->next[n] != -1 || state->prev[n] != -1))) {
+            error = 1;
+            if (mark_errors)
+                state->flags[n] |= FLAG_ERROR;
+        }
+    }
+
+    if (error) return 0;
+    return complete;
+}
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = NULL;
+
+    unpick_desc(params, desc, &state, NULL);
+    if (!state) assert(!"new_game failed to unpick");
+
+    update_numbers(state);
+    check_completion(state, 1); /* update any auto-links */
+
+    return state;
+}
+
+/* --- Solver --- */
+
+/* If a tile has a single tile it can link _to_, or there's only a single
+ * location that can link to a given tile, fill that link in. */
+static int solve_single(game_state *state, game_state *copy, int *from)
+{
+    int i, j, sx, sy, x, y, d, poss, w=state->w, nlinks = 0;
+
+    /* The from array is a list of 'which square can link _to_ us';
+     * we start off with from as '-1' (meaning 'not found'); if we find
+     * something that can link to us it is set to that index, and then if
+     * we find another we set it to -2. */
+
+    memset(from, -1, state->n*sizeof(int));
+
+    /* poss is 'can I link to anything' with the same meanings. */
+
+    for (i = 0; i < state->n; i++) {
+        if (state->next[i] != -1) continue;
+        if (state->nums[i] == state->n) continue; /* no next from last no. */
+
+        d = state->dirs[i];
+        poss = -1;
+        sx = x = i%w; sy = y = i/w;
+        while (1) {
+            x += dxs[d]; y += dys[d];
+            if (!INGRID(state, x, y)) break;
+            if (!isvalidmove(state, 1, sx, sy, x, y)) continue;
+
+            /* can't link to somewhere with a back-link we would have to
+             * break (the solver just doesn't work like this). */
+            j = y*w+x;
+            if (state->prev[j] != -1) continue;
+
+            if (state->nums[i] > 0 && state->nums[j] > 0 &&
+                state->nums[i] <= state->n && state->nums[j] <= state->n &&
+                state->nums[j] == state->nums[i]+1) {
+                debug(("Solver: forcing link through existing consecutive numbers."));
+                poss = j;
+                from[j] = i;
+                break;
+            }
+
+            /* if there's been a valid move already, we have to move on;
+             * we can't make any deductions here. */
+            poss = (poss == -1) ? j : -2;
+
+            /* Modify the from array as described above (which is enumerating
+             * what points to 'j' in a similar way). */
+            from[j] = (from[j] == -1) ? i : -2;
+        }
+        if (poss == -2) {
+            /*debug(("Solver: (%d,%d) has multiple possible next squares.", sx, sy));*/
+            ;
+        } else if (poss == -1) {
+            debug(("Solver: nowhere possible for (%d,%d) to link to.", sx, sy));
+            copy->impossible = 1;
+            return -1;
+        } else {
+            debug(("Solver: linking (%d,%d) to only possible next (%d,%d).",
+                   sx, sy, poss%w, poss/w));
+            makelink(copy, i, poss);
+            nlinks++;
+        }
+    }
+
+    for (i = 0; i < state->n; i++) {
+        if (state->prev[i] != -1) continue;
+        if (state->nums[i] == 1) continue; /* no prev from 1st no. */
+
+        x = i%w; y = i/w;
+        if (from[i] == -1) {
+            debug(("Solver: nowhere possible to link to (%d,%d)", x, y));
+            copy->impossible = 1;
+            return -1;
+        } else if (from[i] == -2) {
+            /*debug(("Solver: (%d,%d) has multiple possible prev squares.", x, y));*/
+            ;
+        } else {
+            debug(("Solver: linking only possible prev (%d,%d) to (%d,%d).",
+                   from[i]%w, from[i]/w, x, y));
+            makelink(copy, from[i], i);
+            nlinks++;
+        }
+    }
+
+    return nlinks;
+}
+
+/* Returns 1 if we managed to solve it, 0 otherwise. */
+static int solve_state(game_state *state)
+{
+    game_state *copy = dup_game(state);
+    int *scratch = snewn(state->n, int), ret;
+
+    debug_state("Before solver: ", state);
+
+    while (1) {
+        update_numbers(state);
+
+        if (solve_single(state, copy, scratch)) {
+            dup_game_to(state, copy);
+            if (state->impossible) break; else continue;
+        }
+        break;
+    }
+    free_game(copy);
+    sfree(scratch);
+
+    update_numbers(state);
+    ret = state->impossible ? -1 : check_completion(state, 0);
+    debug(("Solver finished: %s",
+           ret < 0 ? "impossible" : ret > 0 ? "solved" : "not solved"));
+    debug_state("After solver: ", state);
+    return ret;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    game_state *tosolve;
+    char *ret = NULL;
+    int result;
+
+    tosolve = dup_game(currstate);
+    result = solve_state(tosolve);
+    if (result > 0)
+        ret = generate_desc(tosolve, 1);
+    free_game(tosolve);
+    if (ret) return ret;
+
+    tosolve = dup_game(state);
+    result = solve_state(tosolve);
+    if (result < 0)
+        *error = "Puzzle is impossible.";
+    else if (result == 0)
+        *error = "Unable to solve puzzle.";
+    else
+        ret = generate_desc(tosolve, 1);
+
+    free_game(tosolve);
+
+    return ret;
+}
+
+/* --- UI and move routines. --- */
+
+
+struct game_ui {
+    int cx, cy, cshow;
+
+    int dragging, drag_is_from;
+    int sx, sy;         /* grid coords of start cell */
+    int dx, dy;         /* pixel coords of drag posn */
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    /* NB: if this is ever changed to as to require more than a structure
+     * copy to clone, there's code that needs fixing in game_redraw too. */
+
+    ui->cx = ui->cy = ui->cshow = 0;
+
+    ui->dragging = 0;
+    ui->sx = ui->sy = ui->dx = ui->dy = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    if (!oldstate->completed && newstate->completed)
+        ui->cshow = ui->dragging = 0;
+}
+
+struct game_drawstate {
+    int tilesize, started, solved;
+    int w, h, n;
+    int *nums, *dirp;
+    unsigned int *f;
+    double angle_offset;
+
+    int dragging, dx, dy;
+    blitter *dragb;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int mx, int my, int button)
+{
+    int x = FROMCOORD(mx), y = FROMCOORD(my), w = state->w;
+    char buf[80];
+
+    if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->cx, &ui->cy, state->w, state->h, 0);
+        ui->cshow = 1;
+        if (ui->dragging) {
+            ui->dx = COORD(ui->cx) + TILE_SIZE/2;
+            ui->dy = COORD(ui->cy) + TILE_SIZE/2;
+        }
+        return "";
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (!ui->cshow)
+            ui->cshow = 1;
+        else if (ui->dragging) {
+            ui->dragging = FALSE;
+            if (ui->sx == ui->cx && ui->sy == ui->cy) return "";
+            if (ui->drag_is_from) {
+                if (!isvalidmove(state, 0, ui->sx, ui->sy, ui->cx, ui->cy)) return "";
+                sprintf(buf, "L%d,%d-%d,%d", ui->sx, ui->sy, ui->cx, ui->cy);
+            } else {
+                if (!isvalidmove(state, 0, ui->cx, ui->cy, ui->sx, ui->sy)) return "";
+                sprintf(buf, "L%d,%d-%d,%d", ui->cx, ui->cy, ui->sx, ui->sy);
+            }
+            return dupstr(buf);
+        } else {
+            ui->dragging = TRUE;
+            ui->sx = ui->cx;
+            ui->sy = ui->cy;
+            ui->dx = COORD(ui->cx) + TILE_SIZE/2;
+            ui->dy = COORD(ui->cy) + TILE_SIZE/2;
+            ui->drag_is_from = (button == CURSOR_SELECT) ? 1 : 0;
+        }
+        return "";
+    }
+    if (IS_MOUSE_DOWN(button)) {
+        if (ui->cshow) {
+            ui->cshow = ui->dragging = 0;
+        }
+        assert(!ui->dragging);
+        if (!INGRID(state, x, y)) return NULL;
+
+        if (button == LEFT_BUTTON) {
+            /* disallow dragging from the final number. */
+            if ((state->nums[y*w+x] == state->n) &&
+                (state->flags[y*w+x] & FLAG_IMMUTABLE))
+                return NULL;
+        } else if (button == RIGHT_BUTTON) {
+            /* disallow dragging to the first number. */
+            if ((state->nums[y*w+x] == 1) &&
+                (state->flags[y*w+x] & FLAG_IMMUTABLE))
+                return NULL;
+        }
+
+        ui->dragging = TRUE;
+        ui->drag_is_from = (button == LEFT_BUTTON) ? 1 : 0;
+        ui->sx = x;
+        ui->sy = y;
+        ui->dx = mx;
+        ui->dy = my;
+        ui->cshow = 0;
+        return "";
+    } else if (IS_MOUSE_DRAG(button) && ui->dragging) {
+        ui->dx = mx;
+        ui->dy = my;
+        return "";
+    } else if (IS_MOUSE_RELEASE(button) && ui->dragging) {
+        ui->dragging = FALSE;
+        if (ui->sx == x && ui->sy == y) return ""; /* single click */
+
+        if (!INGRID(state, x, y)) {
+            int si = ui->sy*w+ui->sx;
+            if (state->prev[si] == -1 && state->next[si] == -1)
+                return "";
+            sprintf(buf, "%c%d,%d",
+                    (int)(ui->drag_is_from ? 'C' : 'X'), ui->sx, ui->sy);
+            return dupstr(buf);
+        }
+
+        if (ui->drag_is_from) {
+            if (!isvalidmove(state, 0, ui->sx, ui->sy, x, y)) return "";
+            sprintf(buf, "L%d,%d-%d,%d", ui->sx, ui->sy, x, y);
+        } else {
+            if (!isvalidmove(state, 0, x, y, ui->sx, ui->sy)) return "";
+            sprintf(buf, "L%d,%d-%d,%d", x, y, ui->sx, ui->sy);
+        }
+        return dupstr(buf);
+    } /* else if (button == 'H' || button == 'h')
+        return dupstr("H"); */
+    else if ((button == 'x' || button == 'X') && ui->cshow) {
+        int si = ui->cy*w + ui->cx;
+        if (state->prev[si] == -1 && state->next[si] == -1)
+            return "";
+        sprintf(buf, "%c%d,%d",
+                (int)((button == 'x') ? 'C' : 'X'), ui->cx, ui->cy);
+        return dupstr(buf);
+    }
+
+    return NULL;
+}
+
+static void unlink_cell(game_state *state, int si)
+{
+    debug(("Unlinking (%d,%d).", si%state->w, si/state->w));
+    if (state->prev[si] != -1) {
+        debug((" ... removing prev link from (%d,%d).",
+               state->prev[si]%state->w, state->prev[si]/state->w));
+        state->next[state->prev[si]] = -1;
+        state->prev[si] = -1;
+    }
+    if (state->next[si] != -1) {
+        debug((" ... removing next link to (%d,%d).",
+               state->next[si]%state->w, state->next[si]/state->w));
+        state->prev[state->next[si]] = -1;
+        state->next[si] = -1;
+    }
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    game_state *ret = NULL;
+    int sx, sy, ex, ey, si, ei, w = state->w;
+    char c;
+
+    debug(("move: %s", move));
+
+    if (move[0] == 'S') {
+        game_params p;
+        game_state *tmp;
+        char *valid;
+        int i;
+
+        p.w = state->w; p.h = state->h;
+        valid = validate_desc(&p, move+1);
+        if (valid) {
+            debug(("execute_move: move not valid: %s", valid));
+            return NULL;
+        }
+        ret = dup_game(state);
+        tmp = new_game(NULL, &p, move+1);
+        for (i = 0; i < state->n; i++) {
+            ret->prev[i] = tmp->prev[i];
+            ret->next[i] = tmp->next[i];
+        }
+        free_game(tmp);
+        ret->used_solve = 1;
+    } else if (sscanf(move, "L%d,%d-%d,%d", &sx, &sy, &ex, &ey) == 4) {
+        if (!isvalidmove(state, 0, sx, sy, ex, ey)) return NULL;
+
+        ret = dup_game(state);
+
+        si = sy*w+sx; ei = ey*w+ex;
+        makelink(ret, si, ei);
+    } else if (sscanf(move, "%c%d,%d", &c, &sx, &sy) == 3) {
+        int sset;
+
+        if (c != 'C' && c != 'X') return NULL;
+        if (!INGRID(state, sx, sy)) return NULL;
+        si = sy*w+sx;
+        if (state->prev[si] == -1 && state->next[si] == -1)
+            return NULL;
+
+        ret = dup_game(state);
+
+        sset = state->nums[si] / (state->n+1);
+        if (c == 'C' || (c == 'X' && sset == 0)) {
+            /* Unlink the single cell we dragged from the board. */
+            unlink_cell(ret, si);
+        } else {
+            int i, set;
+            for (i = 0; i < state->n; i++) {
+                /* Unlink all cells in the same set as the one we dragged
+                 * from the board. */
+
+                if (state->nums[i] == 0) continue;
+                set = state->nums[i] / (state->n+1);
+                if (set != sset) continue;
+
+                unlink_cell(ret, i);
+            }
+        }
+    } else if (strcmp(move, "H") == 0) {
+        ret = dup_game(state);
+        solve_state(ret);
+    }
+    if (ret) {
+        update_numbers(ret);
+        if (check_completion(ret, 1)) ret->completed = 1;
+    }
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize, order; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = TILE_SIZE * params->w + 2 * BORDER;
+    *y = TILE_SIZE * params->h + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+    assert(TILE_SIZE > 0);
+
+    assert(!ds->dragb);
+    ds->dragb = blitter_new(dr, BLITTER_SIZE, BLITTER_SIZE);
+}
+
+/* Colours chosen from the webby palette to work as a background to black text,
+ * W then some plausible approximation to pastelly ROYGBIV; we then interpolate
+ * between consecutive pairs to give another 8 (and then the drawing routine
+ * will reuse backgrounds). */
+static const unsigned long bgcols[8] = {
+    0xffffff, /* white */
+    0xffa07a, /* lightsalmon */
+    0x98fb98, /* green */
+    0x7fffd4, /* aquamarine */
+    0x9370db, /* medium purple */
+    0xffa500, /* orange */
+    0x87cefa, /* lightskyblue */
+    0xffff00, /* yellow */
+};
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int c, i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_NUMBER * 3 + i] = 0.0F;
+        ret[COL_ARROW * 3 + i] = 0.0F;
+        ret[COL_CURSOR * 3 + i] = ret[COL_BACKGROUND * 3 + i] / 2.0F;
+        ret[COL_GRID * 3 + i] = ret[COL_BACKGROUND * 3 + i] / 1.3F;
+    }
+    ret[COL_NUMBER_SET * 3 + 0] = 0.0F;
+    ret[COL_NUMBER_SET * 3 + 1] = 0.0F;
+    ret[COL_NUMBER_SET * 3 + 2] = 0.9F;
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_DRAG_ORIGIN * 3 + 0] = 0.2F;
+    ret[COL_DRAG_ORIGIN * 3 + 1] = 1.0F;
+    ret[COL_DRAG_ORIGIN * 3 + 2] = 0.2F;
+
+    for (c = 0; c < 8; c++) {
+         ret[(COL_B0 + c) * 3 + 0] = (float)((bgcols[c] & 0xff0000) >> 16) / 256.0F;
+         ret[(COL_B0 + c) * 3 + 1] = (float)((bgcols[c] & 0xff00) >> 8) / 256.0F;
+         ret[(COL_B0 + c) * 3 + 2] = (float)((bgcols[c] & 0xff)) / 256.0F;
+    }
+    for (c = 0; c < 8; c++) {
+        for (i = 0; i < 3; i++) {
+           ret[(COL_B0 + 8 + c) * 3 + i] =
+               (ret[(COL_B0 + c) * 3 + i] + ret[(COL_B0 + c + 1) * 3 + i]) / 2.0F;
+        }
+    }
+
+#define average(r,a,b,w) do { \
+    for (i = 0; i < 3; i++) \
+        ret[(r)*3+i] = ret[(a)*3+i] + w * (ret[(b)*3+i] - ret[(a)*3+i]); \
+} while (0)
+    average(COL_ARROW_BG_DIM, COL_BACKGROUND, COL_ARROW, 0.1F);
+    average(COL_NUMBER_SET_MID, COL_B0, COL_NUMBER_SET, 0.3F);
+    for (c = 0; c < NBACKGROUNDS; c++) {
+        /* I assume here that COL_ARROW and COL_NUMBER are the same.
+         * Otherwise I'd need two sets of COL_M*. */
+        average(COL_M0 + c, COL_B0 + c, COL_NUMBER, 0.3F);
+        average(COL_D0 + c, COL_B0 + c, COL_NUMBER, 0.1F);
+        average(COL_X0 + c, COL_BACKGROUND, COL_B0 + c, 0.5F);
+    }
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = ds->started = ds->solved = 0;
+    ds->w = state->w;
+    ds->h = state->h;
+    ds->n = state->n;
+
+    ds->nums = snewn(state->n, int);
+    ds->dirp = snewn(state->n, int);
+    ds->f = snewn(state->n, unsigned int);
+    for (i = 0; i < state->n; i++) {
+        ds->nums[i] = 0;
+        ds->dirp[i] = -1;
+        ds->f[i] = 0;
+    }
+
+    ds->angle_offset = 0.0F;
+
+    ds->dragging = ds->dx = ds->dy = 0;
+    ds->dragb = NULL;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->nums);
+    sfree(ds->dirp);
+    sfree(ds->f);
+    if (ds->dragb) blitter_free(dr, ds->dragb);
+
+    sfree(ds);
+}
+
+/* cx, cy are top-left corner. sz is the 'radius' of the arrow.
+ * ang is in radians, clockwise from 0 == straight up. */
+static void draw_arrow(drawing *dr, int cx, int cy, int sz, double ang,
+                       int cfill, int cout)
+{
+    int coords[14];
+    int xdx, ydx, xdy, ydy, xdx3, xdy3;
+    double s = sin(ang), c = cos(ang);
+
+    xdx3 = (int)(sz * (c/3 + 1) + 0.5) - sz;
+    xdy3 = (int)(sz * (s/3 + 1) + 0.5) - sz;
+    xdx = (int)(sz * (c + 1) + 0.5) - sz;
+    xdy = (int)(sz * (s + 1) + 0.5) - sz;
+    ydx = -xdy;
+    ydy = xdx;
+
+
+    coords[2*0 + 0] = cx - ydx;
+    coords[2*0 + 1] = cy - ydy;
+    coords[2*1 + 0] = cx + xdx;
+    coords[2*1 + 1] = cy + xdy;
+    coords[2*2 + 0] = cx + xdx3;
+    coords[2*2 + 1] = cy + xdy3;
+    coords[2*3 + 0] = cx + xdx3 + ydx;
+    coords[2*3 + 1] = cy + xdy3 + ydy;
+    coords[2*4 + 0] = cx - xdx3 + ydx;
+    coords[2*4 + 1] = cy - xdy3 + ydy;
+    coords[2*5 + 0] = cx - xdx3;
+    coords[2*5 + 1] = cy - xdy3;
+    coords[2*6 + 0] = cx - xdx;
+    coords[2*6 + 1] = cy - xdy;
+
+    draw_polygon(dr, coords, 7, cfill, cout);
+}
+
+static void draw_arrow_dir(drawing *dr, int cx, int cy, int sz, int dir,
+                           int cfill, int cout, double angle_offset)
+{
+    double ang = 2.0 * PI * (double)dir / 8.0 + angle_offset;
+    draw_arrow(dr, cx, cy, sz, ang, cfill, cout);
+}
+
+/* cx, cy are centre coordinates.. */
+static void draw_star(drawing *dr, int cx, int cy, int rad, int npoints,
+                      int cfill, int cout, double angle_offset)
+{
+    int *coords, n;
+    double a, r;
+
+    assert(npoints > 0);
+
+    coords = snewn(npoints * 2 * 2, int);
+
+    for (n = 0; n < npoints * 2; n++) {
+        a = 2.0 * PI * ((double)n / ((double)npoints * 2.0)) + angle_offset;
+        r = (n % 2) ? (double)rad/2.0 : (double)rad;
+
+        /* We're rotating the point at (0, -r) by a degrees */
+        coords[2*n+0] = cx + (int)( r * sin(a));
+        coords[2*n+1] = cy + (int)(-r * cos(a));
+    }
+    draw_polygon(dr, coords, npoints*2, cfill, cout);
+    sfree(coords);
+}
+
+static int num2col(game_drawstate *ds, int num)
+{
+    int set = num / (ds->n+1);
+
+    if (num <= 0 || set == 0) return COL_B0;
+    return COL_B0 + 1 + ((set-1) % 15);
+}
+
+#define ARROW_HALFSZ (7 * TILE_SIZE / 32)
+
+#define F_CUR           0x001   /* Cursor on this tile. */
+#define F_DRAG_SRC      0x002   /* Tile is source of a drag. */
+#define F_ERROR         0x004   /* Tile marked in error. */
+#define F_IMMUTABLE     0x008   /* Tile (number) is immutable. */
+#define F_ARROW_POINT   0x010   /* Tile points to other tile */
+#define F_ARROW_INPOINT 0x020   /* Other tile points in here. */
+#define F_DIM           0x040   /* Tile is dim */
+
+static void tile_redraw(drawing *dr, game_drawstate *ds, int tx, int ty,
+                        int dir, int dirp, int num, unsigned int f,
+                        double angle_offset, int print_ink)
+{
+    int cb = TILE_SIZE / 16, textsz;
+    char buf[20];
+    int arrowcol, sarrowcol, setcol, textcol;
+    int acx, acy, asz, empty = 0;
+
+    if (num == 0 && !(f & F_ARROW_POINT) && !(f & F_ARROW_INPOINT)) {
+        empty = 1;
+        /*
+         * We don't display text in empty cells: typically these are
+         * signified by num=0. However, in some cases a cell could
+         * have had the number 0 assigned to it if the user made an
+         * error (e.g. tried to connect a chain of length 5 to the
+         * immutable number 4) so we _do_ display the 0 if the cell
+         * has a link in or a link out.
+         */
+    }
+
+    /* Calculate colours. */
+
+    if (print_ink >= 0) {
+        /*
+         * We're printing, so just do everything in black.
+         */
+        arrowcol = textcol = print_ink;
+        setcol = sarrowcol = -1;       /* placate optimiser */
+    } else {
+
+        setcol = empty ? COL_BACKGROUND : num2col(ds, num);
+
+#define dim(fg,bg) ( \
+      (bg)==COL_BACKGROUND ? COL_ARROW_BG_DIM : \
+      (bg) + COL_D0 - COL_B0 \
+    )
+
+#define mid(fg,bg) ( \
+      (fg)==COL_NUMBER_SET ? COL_NUMBER_SET_MID : \
+      (bg) + COL_M0 - COL_B0 \
+    )
+
+#define dimbg(bg) ( \
+      (bg)==COL_BACKGROUND ? COL_BACKGROUND : \
+      (bg) + COL_X0 - COL_B0 \
+    )
+
+        if (f & F_DRAG_SRC) arrowcol = COL_DRAG_ORIGIN;
+        else if (f & F_DIM) arrowcol = dim(COL_ARROW, setcol);
+        else if (f & F_ARROW_POINT) arrowcol = mid(COL_ARROW, setcol);
+        else arrowcol = COL_ARROW;
+
+        if ((f & F_ERROR) && !(f & F_IMMUTABLE)) textcol = COL_ERROR;
+        else {
+            if (f & F_IMMUTABLE) textcol = COL_NUMBER_SET;
+            else textcol = COL_NUMBER;
+
+            if (f & F_DIM) textcol = dim(textcol, setcol);
+            else if (((f & F_ARROW_POINT) || num==ds->n) &&
+                     ((f & F_ARROW_INPOINT) || num==1))
+                textcol = mid(textcol, setcol);
+        }
+
+        if (f & F_DIM) sarrowcol = dim(COL_ARROW, setcol);
+        else sarrowcol = COL_ARROW;
+    }
+
+    /* Clear tile background */
+
+    if (print_ink < 0) {
+        draw_rect(dr, tx, ty, TILE_SIZE, TILE_SIZE,
+                  (f & F_DIM) ? dimbg(setcol) : setcol);
+    }
+
+    /* Draw large (outwards-pointing) arrow. */
+
+    asz = ARROW_HALFSZ;         /* 'radius' of arrow/star. */
+    acx = tx+TILE_SIZE/2+asz;   /* centre x */
+    acy = ty+TILE_SIZE/2+asz;   /* centre y */
+
+    if (num == ds->n && (f & F_IMMUTABLE))
+        draw_star(dr, acx, acy, asz, 5, arrowcol, arrowcol, angle_offset);
+    else
+        draw_arrow_dir(dr, acx, acy, asz, dir, arrowcol, arrowcol, angle_offset);
+    if (print_ink < 0 && (f & F_CUR))
+        draw_rect_corners(dr, acx, acy, asz+1, COL_CURSOR);
+
+    /* Draw dot iff this tile requires a predecessor and doesn't have one. */
+
+    if (print_ink < 0) {
+        acx = tx+TILE_SIZE/2-asz;
+        acy = ty+TILE_SIZE/2+asz;
+
+        if (!(f & F_ARROW_INPOINT) && num != 1) {
+            draw_circle(dr, acx, acy, asz / 4, sarrowcol, sarrowcol);
+        }
+    }
+
+    /* Draw text (number or set). */
+
+    if (!empty) {
+        int set = (num <= 0) ? 0 : num / (ds->n+1);
+
+        char *p = buf;
+        if (set == 0 || num <= 0) {
+            sprintf(buf, "%d", num);
+        } else {
+            int n = num % (ds->n+1);
+            p += sizeof(buf) - 1;
+
+            if (n != 0) {
+                sprintf(buf, "+%d", n);  /* Just to get the length... */
+                p -= strlen(buf);
+                sprintf(p, "+%d", n);
+            } else {
+                *p = '\0';
+            }
+            do {
+                set--;
+                p--;
+                *p = (char)((set % 26)+'a');
+                set /= 26;
+            } while (set);
+        }
+        textsz = min(2*asz, (TILE_SIZE - 2 * cb) / (int)strlen(p));
+        draw_text(dr, tx + cb, ty + TILE_SIZE/4, FONT_VARIABLE, textsz,
+                  ALIGN_VCENTRE | ALIGN_HLEFT, textcol, p);
+    }
+
+    if (print_ink < 0) {
+        draw_rect_outline(dr, tx, ty, TILE_SIZE, TILE_SIZE, COL_GRID);
+        draw_update(dr, tx, ty, TILE_SIZE, TILE_SIZE);
+    }
+}
+
+static void draw_drag_indicator(drawing *dr, game_drawstate *ds,
+                                const game_state *state, const game_ui *ui,
+                                int validdrag)
+{
+    int dir, w = ds->w, acol = COL_ARROW;
+    int fx = FROMCOORD(ui->dx), fy = FROMCOORD(ui->dy);
+    double ang;
+
+    if (validdrag) {
+        /* If we could move here, lock the arrow to the appropriate direction. */
+        dir = ui->drag_is_from ? state->dirs[ui->sy*w+ui->sx] : state->dirs[fy*w+fx];
+
+        ang = (2.0 * PI * dir) / 8.0; /* similar to calculation in draw_arrow_dir. */
+    } else {
+        /* Draw an arrow pointing away from/towards the origin cell. */
+        int ox = COORD(ui->sx) + TILE_SIZE/2, oy = COORD(ui->sy) + TILE_SIZE/2;
+        double tana, offset;
+        double xdiff = abs(ox - ui->dx), ydiff = abs(oy - ui->dy);
+
+        if (xdiff == 0) {
+            ang = (oy > ui->dy) ? 0.0F : PI;
+        } else if (ydiff == 0) {
+            ang = (ox > ui->dx) ? 3.0F*PI/2.0F : PI/2.0F;
+        } else {
+            if (ui->dx > ox && ui->dy < oy) {
+                tana = xdiff / ydiff;
+                offset = 0.0F;
+            } else if (ui->dx > ox && ui->dy > oy) {
+                tana = ydiff / xdiff;
+                offset = PI/2.0F;
+            } else if (ui->dx < ox && ui->dy > oy) {
+                tana = xdiff / ydiff;
+                offset = PI;
+            } else {
+                tana = ydiff / xdiff;
+                offset = 3.0F * PI / 2.0F;
+            }
+            ang = atan(tana) + offset;
+        }
+
+        if (!ui->drag_is_from) ang += PI; /* point to origin, not away from. */
+
+    }
+    draw_arrow(dr, ui->dx, ui->dy, ARROW_HALFSZ, ang, acol, acol);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int x, y, i, w = ds->w, dirp, force = 0;
+    unsigned int f;
+    double angle_offset = 0.0;
+    game_state *postdrop = NULL;
+
+    if (flashtime > 0.0F)
+        angle_offset = 2.0 * PI * (flashtime / FLASH_SPIN);
+    if (angle_offset != ds->angle_offset) {
+        ds->angle_offset = angle_offset;
+        force = 1;
+    }
+
+    if (ds->dragging) {
+        assert(ds->dragb);
+        blitter_load(dr, ds->dragb, ds->dx, ds->dy);
+        draw_update(dr, ds->dx, ds->dy, BLITTER_SIZE, BLITTER_SIZE);
+        ds->dragging = FALSE;
+    }
+
+    /* If an in-progress drag would make a valid move if finished, we
+     * reflect that move in the board display. We let interpret_move do
+     * most of the heavy lifting for us: we have to copy the game_ui so
+     * as not to stomp on the real UI's drag state. */
+    if (ui->dragging) {
+        game_ui uicopy = *ui;
+        char *movestr = interpret_move(state, &uicopy, ds, ui->dx, ui->dy, LEFT_RELEASE);
+
+        if (movestr != NULL && strcmp(movestr, "") != 0) {
+            postdrop = execute_move(state, movestr);
+            sfree(movestr);
+
+            state = postdrop;
+        }
+    }
+
+    if (!ds->started) {
+        int aw = TILE_SIZE * state->w;
+        int ah = TILE_SIZE * state->h;
+        draw_rect(dr, 0, 0, aw + 2 * BORDER, ah + 2 * BORDER, COL_BACKGROUND);
+        draw_rect_outline(dr, BORDER - 1, BORDER - 1, aw + 2, ah + 2, COL_GRID);
+        draw_update(dr, 0, 0, aw + 2 * BORDER, ah + 2 * BORDER);
+    }
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            i = y*w + x;
+            f = 0;
+            dirp = -1;
+
+            if (ui->cshow && x == ui->cx && y == ui->cy)
+                f |= F_CUR;
+
+            if (ui->dragging) {
+                if (x == ui->sx && y == ui->sy)
+                    f |= F_DRAG_SRC;
+                else if (ui->drag_is_from) {
+                    if (!ispointing(state, ui->sx, ui->sy, x, y))
+                        f |= F_DIM;
+                } else {
+                    if (!ispointing(state, x, y, ui->sx, ui->sy))
+                        f |= F_DIM;
+                }
+            }
+
+            if (state->impossible ||
+                state->nums[i] < 0 || state->flags[i] & FLAG_ERROR)
+                f |= F_ERROR;
+            if (state->flags[i] & FLAG_IMMUTABLE)
+                f |= F_IMMUTABLE;
+
+            if (state->next[i] != -1)
+                f |= F_ARROW_POINT;
+
+            if (state->prev[i] != -1) {
+                /* Currently the direction here is from our square _back_
+                 * to its previous. We could change this to give the opposite
+                 * sense to the direction. */
+                f |= F_ARROW_INPOINT;
+                dirp = whichdir(x, y, state->prev[i]%w, state->prev[i]/w);
+            }
+
+            if (state->nums[i] != ds->nums[i] ||
+                f != ds->f[i] || dirp != ds->dirp[i] ||
+                force || !ds->started) {
+                int sign;
+                {
+                    /*
+                     * Trivial and foolish configurable option done on
+                     * purest whim. With this option enabled, the
+                     * victory flash is done by rotating each square
+                     * in the opposite direction from its immediate
+                     * neighbours, so that they behave like a field of
+                     * interlocking gears. With it disabled, they all
+                     * rotate in the same direction. Choose for
+                     * yourself which is more brain-twisting :-)
+                     */
+                    static int gear_mode = -1;
+                    if (gear_mode < 0) {
+                        char *env = getenv("SIGNPOST_GEARS");
+                        gear_mode = (env && (env[0] == 'y' || env[0] == 'Y'));
+                    }
+                    if (gear_mode)
+                        sign = 1 - 2 * ((x ^ y) & 1);
+                    else
+                        sign = 1;
+                }
+                tile_redraw(dr, ds,
+                            BORDER + x * TILE_SIZE,
+                            BORDER + y * TILE_SIZE,
+                            state->dirs[i], dirp, state->nums[i], f,
+                            sign * angle_offset, -1);
+                ds->nums[i] = state->nums[i];
+                ds->f[i] = f;
+                ds->dirp[i] = dirp;
+            }
+        }
+    }
+    if (ui->dragging) {
+        ds->dragging = TRUE;
+        ds->dx = ui->dx - BLITTER_SIZE/2;
+        ds->dy = ui->dy - BLITTER_SIZE/2;
+        blitter_save(dr, ds->dragb, ds->dx, ds->dy);
+
+        draw_drag_indicator(dr, ds, state, ui, postdrop ? 1 : 0);
+    }
+    if (postdrop) free_game(postdrop);
+    if (!ds->started) ds->started = TRUE;
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed &&
+        newstate->completed && !newstate->used_solve)
+        return FLASH_SPIN;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    game_compute_size(params, 1300, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int ink = print_mono_colour(dr, 0);
+    int x, y;
+
+    /* Fake up just enough of a drawstate */
+    game_drawstate ads, *ds = &ads;
+    ds->tilesize = tilesize;
+    ds->n = state->n;
+
+    /*
+     * Border and grid.
+     */
+    print_line_width(dr, TILE_SIZE / 40);
+    for (x = 1; x < state->w; x++)
+        draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(state->h), ink);
+    for (y = 1; y < state->h; y++)
+        draw_line(dr, COORD(0), COORD(y), COORD(state->w), COORD(y), ink);
+    print_line_width(dr, 2*TILE_SIZE / 40);
+    draw_rect_outline(dr, COORD(0), COORD(0), TILE_SIZE*state->w,
+                      TILE_SIZE*state->h, ink);
+
+    /*
+     * Arrows and numbers.
+     */
+    print_line_width(dr, 0);
+    for (y = 0; y < state->h; y++)
+        for (x = 0; x < state->w; x++)
+            tile_redraw(dr, ds, COORD(x), COORD(y), state->dirs[y*state->w+x],
+                        0, state->nums[y*state->w+x], 0, 0.0, ink);
+}
+
+#ifdef COMBINED
+#define thegame signpost
+#endif
+
+const struct game thegame = {
+    "Signpost", "games.signpost", "signpost",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON,                   /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+#include <time.h>
+#include <stdarg.h>
+
+const char *quis = NULL;
+int verbose = 0;
+
+void usage(FILE *out) {
+    fprintf(out, "usage: %s [--stdin] [--soak] [--seed SEED] <params>|<game id>\n", quis);
+}
+
+static void cycle_seed(char **seedstr, random_state *rs)
+{
+    char newseed[16];
+    int j;
+
+    newseed[15] = '\0';
+    newseed[0] = '1' + (char)random_upto(rs, 9);
+    for (j = 1; j < 15; j++)
+        newseed[j] = '0' + (char)random_upto(rs, 10);
+    sfree(*seedstr);
+    *seedstr = dupstr(newseed);
+}
+
+static void start_soak(game_params *p, char *seedstr)
+{
+    time_t tt_start, tt_now, tt_last;
+    char *desc, *aux;
+    random_state *rs;
+    long n = 0, nnums = 0, i;
+    game_state *state;
+
+    tt_start = tt_now = time(NULL);
+    printf("Soak-generating a %dx%d grid.\n", p->w, p->h);
+
+    while (1) {
+       rs = random_new(seedstr, strlen(seedstr));
+       desc = thegame.new_desc(p, rs, &aux, 0);
+
+       state = thegame.new_game(NULL, p, desc);
+       for (i = 0; i < state->n; i++) {
+           if (state->flags[i] & FLAG_IMMUTABLE)
+               nnums++;
+       }
+       thegame.free_game(state);
+
+       sfree(desc);
+       cycle_seed(&seedstr, rs);
+       random_free(rs);
+
+       n++;
+       tt_last = time(NULL);
+       if (tt_last > tt_now) {
+           tt_now = tt_last;
+           printf("%ld total, %3.1f/s, %3.1f nums/grid (%3.1f%%).\n",
+                  n,
+                  (double)n / ((double)tt_now - tt_start),
+                  (double)nnums / (double)n,
+                  ((double)nnums * 100.0) / ((double)n * (double)p->w * (double)p->h) );
+       }
+    }
+}
+
+static void process_desc(char *id)
+{
+    char *desc, *err, *solvestr;
+    game_params *p;
+    game_state *s;
+
+    printf("%s\n  ", id);
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: expecting game description.", quis);
+        exit(1);
+    }
+
+    *desc++ = '\0';
+
+    p = thegame.default_params();
+    thegame.decode_params(p, id);
+    err = thegame.validate_params(p, 1);
+    if (err) {
+        fprintf(stderr, "%s: %s", quis, err);
+        thegame.free_params(p);
+        return;
+    }
+
+    err = thegame.validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\nDescription: %s\n", quis, err, desc);
+        thegame.free_params(p);
+        return;
+    }
+
+    s = thegame.new_game(NULL, p, desc);
+
+    solvestr = thegame.solve(s, s, NULL, &err);
+    if (!solvestr)
+        fprintf(stderr, "%s\n", err);
+    else
+        printf("Puzzle is soluble.\n");
+
+    thegame.free_game(s);
+    thegame.free_params(p);
+}
+
+int main(int argc, const char *argv[])
+{
+    char *id = NULL, *desc, *err, *aux = NULL;
+    int soak = 0, verbose = 0, stdin_desc = 0, n = 1, i;
+    char *seedstr = NULL, newseed[16];
+
+    setvbuf(stdout, NULL, _IONBF, 0);
+
+    quis = argv[0];
+    while (--argc > 0) {
+        char *p = (char*)(*++argv);
+        if (!strcmp(p, "-v") || !strcmp(p, "--verbose"))
+            verbose = 1;
+        else if (!strcmp(p, "--stdin"))
+            stdin_desc = 1;
+        else if (!strcmp(p, "-e") || !strcmp(p, "--seed")) {
+            seedstr = dupstr(*++argv);
+            argc--;
+        } else if (!strcmp(p, "-n") || !strcmp(p, "--number")) {
+            n = atoi(*++argv);
+            argc--;
+        } else if (!strcmp(p, "-s") || !strcmp(p, "--soak")) {
+            soak = 1;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            usage(stderr);
+            exit(1);
+        } else {
+            id = p;
+        }
+    }
+
+    sprintf(newseed, "%lu", (unsigned long) time(NULL));
+    seedstr = dupstr(newseed);
+
+    if (id || !stdin_desc) {
+        if (id && strchr(id, ':')) {
+            /* Parameters and description passed on cmd-line:
+             * try and solve it. */
+            process_desc(id);
+        } else {
+            /* No description passed on cmd-line: decode parameters
+             * (with optional seed too) */
+
+            game_params *p = thegame.default_params();
+
+            if (id) {
+                char *cmdseed = strchr(id, '#');
+                if (cmdseed) {
+                    *cmdseed++ = '\0';
+                    sfree(seedstr);
+                    seedstr = dupstr(cmdseed);
+                }
+
+                thegame.decode_params(p, id);
+            }
+
+            err = thegame.validate_params(p, 1);
+            if (err) {
+                fprintf(stderr, "%s: %s", quis, err);
+                thegame.free_params(p);
+                exit(1);
+            }
+
+            /* We have a set of valid parameters; either soak with it
+             * or generate a single game description and print to stdout. */
+            if (soak)
+                start_soak(p, seedstr);
+            else {
+                char *pstring = thegame.encode_params(p, 0);
+
+                for (i = 0; i < n; i++) {
+                    random_state *rs = random_new(seedstr, strlen(seedstr));
+
+                    if (verbose) printf("%s#%s\n", pstring, seedstr);
+                    desc = thegame.new_desc(p, rs, &aux, 0);
+                    printf("%s:%s\n", pstring, desc);
+                    sfree(desc);
+
+                    cycle_seed(&seedstr, rs);
+
+                    random_free(rs);
+                }
+
+                sfree(pstring);
+            }
+            thegame.free_params(p);
+        }
+    }
+
+    if (stdin_desc) {
+        char buf[4096];
+
+        while (fgets(buf, sizeof(buf), stdin)) {
+            buf[strcspn(buf, "\r\n")] = '\0';
+            process_desc(buf);
+        }
+    }
+    sfree(seedstr);
+
+    return 0;
+}
+
+#endif
+
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/singles.R b/apps/plugins/puzzles/singles.R
new file mode 100644
index 0000000000..2d10c4b388
--- /dev/null
+++ b/apps/plugins/puzzles/singles.R
@@ -0,0 +1,23 @@
+# -*- makefile -*-
+
+SINGLES_EXTRA = dsf latin maxflow tree234
+
+singles : [X] GTK COMMON singles SINGLES_EXTRA singles-icon|no-icon
+singles : [G] WINDOWS COMMON singles SINGLES_EXTRA singles.res|noicon.res
+
+ALL += singles[COMBINED] SINGLES_EXTRA
+
+singlessolver : [U] singles[STANDALONE_SOLVER] SINGLES_EXTRA STANDALONE
+singlessolver : [C] singles[STANDALONE_SOLVER] SINGLES_EXTRA STANDALONE
+
+!begin am gtk
+GAMES += singles
+!end
+
+!begin >list.c
+    A(singles) \
+!end
+
+!begin >gamedesc.txt
+singles:singles.exe:Singles:Number-removing puzzle:Black out the right set of duplicate numbers.
+!end
diff --git a/apps/plugins/puzzles/singles.c b/apps/plugins/puzzles/singles.c
new file mode 100644
index 0000000000..119be29122
--- /dev/null
+++ b/apps/plugins/puzzles/singles.c
@@ -0,0 +1,2004 @@
+/*
+ * singles.c: implementation of Hitori ('let me alone') from Nikoli.
+ *
+ * Make single-get able to fetch a specific puzzle ID from menneske.no?
+ *
+ * www.menneske.no solving methods:
+ *
+ * Done:
+ * SC: if you circle a cell, any cells in same row/col with same no --> black
+ *  -- solver_op_circle
+ * SB: if you make a cell black, any cells around it --> white
+ *  -- solver_op_blacken
+ * ST: 3 identical cells in row, centre is white and outer two black.
+ * SP: 2 identical cells with single-cell gap, middle cell is white.
+ *  -- solver_singlesep (both ST and SP)
+ * PI: if you have a pair of same number in row/col, any other
+ *      cells of same number must be black.
+ *  -- solve_doubles
+ * CC: if you have a black on edge one cell away from corner, cell
+ *       on edge diag. adjacent must be white.
+ * CE: if you have 2 black cells of triangle on edge, third cell must
+ *      be white.
+ * QM: if you have 3 black cells of diagonal square in middle, fourth
+ *      cell must be white.
+ *  -- solve_allblackbutone (CC, CE, and QM).
+ * QC: a corner with 4 identical numbers (or 2 and 2) must have the
+ *      corner cell (and cell diagonal to that) black.
+ * TC: a corner with 3 identical numbers (with the L either way)
+ *      must have the apex of L black, and other two white.
+ * DC: a corner with 2 identical numbers in domino can set a white
+ *      cell along wall.
+ *  -- solve_corners (QC, TC, DC)
+ * IP: pair with one-offset-pair force whites by offset pair
+ *  -- solve_offsetpair
+ * MC: any cells diag. adjacent to black cells that would split board
+ *      into separate white regions must be white.
+ *  -- solve_removesplits
+ *
+ * Still to do:
+ *
+ * TEP: 3 pairs of dominos parallel to side, can mark 4 white cells
+ *       alongside.
+ * DEP: 2 pairs of dominos parallel to side, can mark 2 white cells.
+ * FI: if you have two sets of double-cells packed together, singles
+ *      in that row/col must be white (qv. PI)
+ * QuM: four identical cells (or 2 and 2) in middle of grid only have
+ *       two possible solutions each.
+ * FDE: doubles one row/column away from edge can force a white cell.
+ * FDM: doubles in centre (next to bits of diag. square) can force a white cell.
+ * MP: two pairs with same number between force number to black.
+ * CnC: if circling a cell leads to impossible board, cell is black.
+ * MC: if we have two possiblilities, can we force a white circle?
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "latin.h"
+
+#ifdef STANDALONE_SOLVER
+int verbose = 0;
+#endif
+
+#define PREFERRED_TILE_SIZE 32
+#define TILE_SIZE (ds->tilesize)
+#define BORDER    (TILE_SIZE / 2)
+
+#define CRAD      ((TILE_SIZE / 2) - 1)
+#define TEXTSZ    ((14*CRAD/10) - 1) /* 2 * sqrt(2) of CRAD */
+
+#define COORD(x)  ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
+
+#define INGRID(s,x,y) ((x) >= 0 && (x) < (s)->w && (y) >= 0 && (y) < (s)->h)
+
+#define FLASH_TIME 0.7F
+
+enum {
+    COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT,
+    COL_BLACK, COL_WHITE, COL_BLACKNUM, COL_GRID,
+    COL_CURSOR, COL_ERROR,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h, diff;
+};
+
+#define F_BLACK         0x1
+#define F_CIRCLE        0x2
+#define F_ERROR         0x4
+#define F_SCRATCH       0x8
+
+struct game_state {
+    int w, h, n, o;             /* n = w*h; o = max(w, h) */
+    int completed, used_solve, impossible;
+    int *nums;                  /* size w*h */
+    unsigned int *flags;        /* size w*h */
+};
+
+/* top, right, bottom, left */
+static const int dxs[4] = { 0, 1, 0, -1 };
+static const int dys[4] = { -1, 0, 1, 0 };
+
+/* --- Game parameters and preset functions --- */
+
+#define DIFFLIST(A)             \
+    A(EASY,Easy,e)              \
+    A(TRICKY,Tricky,k)
+
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+
+enum { DIFFLIST(ENUM) DIFF_MAX, DIFF_ANY };
+static char const *const singles_diffnames[] = { DIFFLIST(TITLE) };
+static char const singles_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCOUNT lenof(singles_diffchars)
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+    ret->w = ret->h = 5;
+    ret->diff = DIFF_EASY;
+
+    return ret;
+}
+
+static const struct game_params singles_presets[] = {
+  {  5,  5, DIFF_EASY },
+  {  5,  5, DIFF_TRICKY },
+  {  6,  6, DIFF_EASY },
+  {  6,  6, DIFF_TRICKY },
+  {  8,  8, DIFF_EASY },
+  {  8,  8, DIFF_TRICKY },
+  { 10, 10, DIFF_EASY },
+  { 10, 10, DIFF_TRICKY },
+  { 12, 12, DIFF_EASY },
+  { 12, 12, DIFF_TRICKY }
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(singles_presets))
+        return FALSE;
+
+    ret = default_params();
+    *ret = singles_presets[i];
+    *params = ret;
+
+    sprintf(buf, "%dx%d %s", ret->w, ret->h, singles_diffnames[ret->diff]);
+    *name = dupstr(buf);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    char const *p = string;
+    int i;
+
+    ret->w = ret->h = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+    if (*p == 'x') {
+        p++;
+        ret->h = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+    }
+    if (*p == 'd') {
+        ret->diff = DIFF_MAX; /* which is invalid */
+        p++;
+        for (i = 0; i < DIFFCOUNT; i++) {
+            if (*p == singles_diffchars[i])
+                ret->diff = i;
+        }
+        p++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    if (full)
+        sprintf(data, "%dx%dd%c", params->w, params->h, singles_diffchars[params->diff]);
+    else
+        sprintf(data, "%dx%d", params->w, params->h);
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Difficulty";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = DIFFCONFIG;
+    ret[2].ival = params->diff;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->diff = cfg[2].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 2 || params->h < 2)
+        return "Width and neight must be at least two";
+    if (params->w > 10+26+26 || params->h > 10+26+26)
+        return "Puzzle is too large";
+    if (full) {
+        if (params->diff < 0 || params->diff >= DIFF_MAX)
+            return "Unknown difficulty rating";
+    }
+
+    return NULL;
+}
+
+/* --- Game description string generation and unpicking --- */
+
+static game_state *blank_game(int w, int h)
+{
+    game_state *state = snew(game_state);
+
+    memset(state, 0, sizeof(game_state));
+    state->w = w;
+    state->h = h;
+    state->n = w*h;
+    state->o = max(w,h);
+
+    state->completed = state->used_solve = state->impossible = 0;
+
+    state->nums  = snewn(state->n, int);
+    state->flags = snewn(state->n, unsigned int);
+
+    memset(state->nums, 0, state->n*sizeof(int));
+    memset(state->flags, 0, state->n*sizeof(unsigned int));
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = blank_game(state->w, state->h);
+
+    ret->completed = state->completed;
+    ret->used_solve = state->used_solve;
+    ret->impossible = state->impossible;
+
+    memcpy(ret->nums, state->nums, state->n*sizeof(int));
+    memcpy(ret->flags, state->flags, state->n*sizeof(unsigned int));
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->nums);
+    sfree(state->flags);
+    sfree(state);
+}
+
+static char n2c(int num) {
+    if (num < 10)
+        return '0' + num;
+    else if (num < 10+26)
+        return 'a' + num - 10;
+    else
+        return 'A' + num - 10 - 26;
+    return '?';
+}
+
+static int c2n(char c) {
+    if (isdigit((unsigned char)c))
+        return (int)(c - '0');
+    else if (c >= 'a' && c <= 'z')
+        return (int)(c - 'a' + 10);
+    else if (c >= 'A' && c <= 'Z')
+        return (int)(c - 'A' + 10 + 26);
+    return -1;
+}
+
+static void unpick_desc(const game_params *params, const char *desc,
+                        game_state **sout, char **mout)
+{
+    game_state *state = blank_game(params->w, params->h);
+    char *msg = NULL;
+    int num = 0, i = 0;
+
+    if (strlen(desc) != state->n) {
+        msg = "Game description is wrong length";
+        goto done;
+    }
+    for (i = 0; i < state->n; i++) {
+        num = c2n(desc[i]);
+        if (num <= 0 || num > state->o) {
+            msg = "Game description contains unexpected characters";
+            goto done;
+        }
+        state->nums[i] = num;
+    }
+done:
+    if (msg) { /* sth went wrong. */
+        if (mout) *mout = msg;
+        free_game(state);
+    } else {
+        if (mout) *mout = NULL;
+        if (sout) *sout = state;
+        else free_game(state);
+    }
+}
+
+static char *generate_desc(game_state *state, int issolve)
+{
+    char *ret = snewn(state->n+1+(issolve?1:0), char);
+    int i, p=0;
+
+    if (issolve)
+        ret[p++] = 'S';
+    for (i = 0; i < state->n; i++)
+        ret[p++] = n2c(state->nums[i]);
+    ret[p] = '\0';
+    return ret;
+}
+
+/* --- Useful game functions (completion, etc.) --- */
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int len, x, y, i;
+    char *ret, *p;
+
+    len = (state->w)*2;       /* one row ... */
+    len = len * (state->h*2); /* ... h rows, including gaps ... */
+    len += 1;              /* ... final NL */
+    p = ret = snewn(len, char);
+
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            i = y*state->w + x;
+            if (x > 0) *p++ = ' ';
+            *p++ = (state->flags[i] & F_BLACK) ? '*' : n2c(state->nums[i]);
+        }
+        *p++ = '\n';
+        for (x = 0; x < state->w; x++) {
+            i = y*state->w + x;
+            if (x > 0) *p++ = ' ';
+            *p++ = (state->flags[i] & F_CIRCLE) ? '~' : ' ';
+        }
+        *p++ = '\n';
+    }
+    *p++ = '\0';
+    assert(p - ret == len);
+
+    return ret;
+}
+
+static void debug_state(const char *desc, game_state *state) {
+    char *dbg = game_text_format(state);
+    debug(("%s:\n%s", desc, dbg));
+    sfree(dbg);
+}
+
+static void connect_if_same(game_state *state, int *dsf, int i1, int i2)
+{
+    int c1, c2;
+
+    if ((state->flags[i1] & F_BLACK) != (state->flags[i2] & F_BLACK))
+        return;
+
+    c1 = dsf_canonify(dsf, i1);
+    c2 = dsf_canonify(dsf, i2);
+    dsf_merge(dsf, c1, c2);
+}
+
+static void connect_dsf(game_state *state, int *dsf)
+{
+    int x, y, i;
+
+    /* Construct a dsf array for connected blocks; connections
+     * tracked to right and down. */
+    dsf_init(dsf, state->n);
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            i = y*state->w + x;
+
+            if (x < state->w-1)
+                connect_if_same(state, dsf, i, i+1); /* right */
+            if (y < state->h-1)
+                connect_if_same(state, dsf, i, i+state->w); /* down */
+        }
+    }
+}
+
+#define CC_MARK_ERRORS  1
+#define CC_MUST_FILL    2
+
+static int check_rowcol(game_state *state, int starti, int di, int sz, unsigned flags)
+{
+    int nerr = 0, n, m, i, j;
+
+    /* if any circled numbers have identical non-circled numbers on
+     *     same row/column, error (non-circled)
+     * if any circled numbers in same column are same number, highlight them.
+     * if any rows/columns have >1 of same number, not complete. */
+
+    for (n = 0, i = starti; n < sz; n++, i += di) {
+        if (state->flags[i] & F_BLACK) continue;
+        for (m = n+1, j = i+di; m < sz; m++, j += di) {
+            if (state->flags[j] & F_BLACK) continue;
+            if (state->nums[i] != state->nums[j]) continue;
+
+            nerr++; /* ok, we have two numbers the same in a row. */
+            if (!(flags & CC_MARK_ERRORS)) continue;
+
+            /* If we have two circles in the same row around
+             * two identical numbers, they are _both_ wrong. */
+            if ((state->flags[i] & F_CIRCLE) &&
+                (state->flags[j] & F_CIRCLE)) {
+                state->flags[i] |= F_ERROR;
+                state->flags[j] |= F_ERROR;
+            }
+            /* Otherwise, if we have a circle, any other identical
+             * numbers in that row are obviously wrong. We don't
+             * highlight this, however, since it makes the process
+             * of solving the puzzle too easy (you circle a number
+             * and it promptly tells you which numbers to blacken! */
+#if 0
+            else if (state->flags[i] & F_CIRCLE)
+                state->flags[j] |= F_ERROR;
+            else if (state->flags[j] & F_CIRCLE)
+                state->flags[i] |= F_ERROR;
+#endif
+        }
+    }
+    return nerr;
+}
+
+static int check_complete(game_state *state, unsigned flags)
+{
+    int *dsf = snewn(state->n, int);
+    int x, y, i, error = 0, nwhite, w = state->w, h = state->h;
+
+    if (flags & CC_MARK_ERRORS) {
+        for (i = 0; i < state->n; i++)
+            state->flags[i] &= ~F_ERROR;
+    }
+    connect_dsf(state, dsf);
+
+    /* If we're the solver we need the grid all to be definitively
+     * black or definitively white (i.e. circled) otherwise the solver
+     * has found an ambiguous grid. */
+    if (flags & CC_MUST_FILL) {
+        for (i = 0; i < state->n; i++) {
+            if (!(state->flags[i] & F_BLACK) && !(state->flags[i] & F_CIRCLE))
+                error += 1;
+        }
+    }
+
+    /* Mark any black squares in groups of >1 as errors.
+     * Count number of white squares. */
+    nwhite = 0;
+    for (i = 0; i < state->n; i++) {
+        if (state->flags[i] & F_BLACK) {
+            if (dsf_size(dsf, i) > 1) {
+                error += 1;
+                if (flags & CC_MARK_ERRORS)
+                    state->flags[i] |= F_ERROR;
+            }
+        } else
+            nwhite += 1;
+    }
+
+    /* Check attributes of white squares, row- and column-wise. */
+    for (x = 0; x < w; x++) /* check cols from (x,0) */
+        error += check_rowcol(state, x,   w, h, flags);
+    for (y = 0; y < h; y++) /* check rows from (0,y) */
+        error += check_rowcol(state, y*w, 1, w, flags);
+
+    /* If there's more than one white region, pick the largest one to
+     * be the canonical one (arbitrarily tie-breaking towards lower
+     * array indices), and mark all the others as erroneous. */
+    {
+        int largest = 0, canonical = -1;
+        for (i = 0; i < state->n; i++)
+            if (!(state->flags[i] & F_BLACK)) {
+                int size = dsf_size(dsf, i);
+                if (largest < size) {
+                    largest = size;
+                    canonical = i;
+                }
+            }
+
+        if (largest < nwhite) {
+            for (i = 0; i < state->n; i++)
+                if (!(state->flags[i] & F_BLACK) &&
+                    dsf_canonify(dsf, i) != canonical) {
+                    error += 1;
+                    if (flags & CC_MARK_ERRORS)
+                        state->flags[i] |= F_ERROR;
+                }
+        }
+    }
+
+    sfree(dsf);
+    return (error > 0) ? 0 : 1;
+}
+
+static char *game_state_diff(const game_state *src, const game_state *dst,
+                             int issolve)
+{
+    char *ret = NULL, buf[80], c;
+    int retlen = 0, x, y, i, k;
+    unsigned int fmask = F_BLACK | F_CIRCLE;
+
+    assert(src->n == dst->n);
+
+    if (issolve) {
+        ret = sresize(ret, 3, char);
+        ret[0] = 'S'; ret[1] = ';'; ret[2] = '\0';
+        retlen += 2;
+    }
+
+    for (x = 0; x < dst->w; x++) {
+        for (y = 0; y < dst->h; y++) {
+            i = y*dst->w + x;
+            if ((src->flags[i] & fmask) != (dst->flags[i] & fmask)) {
+                assert((dst->flags[i] & fmask) != fmask);
+                if (dst->flags[i] & F_BLACK)
+                    c = 'B';
+                else if (dst->flags[i] & F_CIRCLE)
+                    c = 'C';
+                else
+                    c = 'E';
+                k = sprintf(buf, "%c%d,%d;", (int)c, x, y);
+                ret = sresize(ret, retlen + k + 1, char);
+                strcpy(ret + retlen, buf);
+                retlen += k;
+            }
+        }
+    }
+    return ret;
+}
+
+/* --- Solver --- */
+
+enum { BLACK, CIRCLE };
+
+struct solver_op {
+    int x, y, op; /* op one of BLACK or CIRCLE. */
+    const char *desc; /* must be non-malloced. */
+};
+
+struct solver_state {
+    struct solver_op *ops;
+    int n_ops, n_alloc;
+    int *scratch;
+};
+
+static struct solver_state *solver_state_new(game_state *state)
+{
+    struct solver_state *ss = snew(struct solver_state);
+
+    ss->ops = NULL;
+    ss->n_ops = ss->n_alloc = 0;
+    ss->scratch = snewn(state->n, int);
+
+    return ss;
+}
+
+static void solver_state_free(struct solver_state *ss)
+{
+    sfree(ss->scratch);
+    if (ss->ops) sfree(ss->ops);
+    sfree(ss);
+}
+
+static void solver_op_add(struct solver_state *ss, int x, int y, int op, const char *desc)
+{
+    struct solver_op *sop;
+
+    if (ss->n_alloc < ss->n_ops + 1) {
+        ss->n_alloc = (ss->n_alloc + 1) * 2;
+        ss->ops = sresize(ss->ops, ss->n_alloc, struct solver_op);
+    }
+    sop = &(ss->ops[ss->n_ops++]);
+    sop->x = x; sop->y = y; sop->op = op; sop->desc = desc;
+    debug(("added solver op %s ('%s') at (%d,%d)\n",
+           op == BLACK ? "BLACK" : "CIRCLE", desc, x, y));
+}
+
+static void solver_op_circle(game_state *state, struct solver_state *ss,
+                             int x, int y)
+{
+    int i = y*state->w + x;
+
+    if (!INGRID(state, x, y)) return;
+    if (state->flags[i] & F_BLACK) {
+        debug(("... solver wants to add auto-circle on black (%d,%d)\n", x, y));
+        state->impossible = 1;
+        return;
+    }
+    /* Only add circle op if it's not already circled. */
+    if (!(state->flags[i] & F_CIRCLE)) {
+        solver_op_add(ss, x, y, CIRCLE, "SB - adjacent to black square");
+    }
+}
+
+static void solver_op_blacken(game_state *state, struct solver_state *ss,
+                              int x, int y, int num)
+{
+    int i = y*state->w + x;
+
+    if (!INGRID(state, x, y)) return;
+    if (state->nums[i] != num) return;
+    if (state->flags[i] & F_CIRCLE) {
+        debug(("... solver wants to add auto-black on circled(%d,%d)\n", x, y));
+        state->impossible = 1;
+        return;
+    }
+    /* Only add black op if it's not already black. */
+    if (!(state->flags[i] & F_BLACK)) {
+        solver_op_add(ss, x, y, BLACK, "SC - number on same row/col as circled");
+    }
+}
+
+static int solver_ops_do(game_state *state, struct solver_state *ss)
+{
+    int next_op = 0, i, x, y, n_ops = 0;
+    struct solver_op op;
+
+    /* Care here: solver_op_* may call solver_op_add which may extend the
+     * ss->n_ops. */
+
+    while (next_op < ss->n_ops) {
+        op = ss->ops[next_op++]; /* copy this away, it may get reallocated. */
+        i = op.y*state->w + op.x;
+
+        if (op.op == BLACK) {
+            if (state->flags[i] & F_CIRCLE) {
+                debug(("Solver wants to blacken circled square (%d,%d)!\n", op.x, op.y));
+                state->impossible = 1;
+                return n_ops;
+            }
+            if (!(state->flags[i] & F_BLACK)) {
+                debug(("... solver adding black at (%d,%d): %s\n", op.x, op.y, op.desc));
+#ifdef STANDALONE_SOLVER
+                if (verbose)
+                    printf("Adding black at (%d,%d): %s\n", op.x, op.y, op.desc);
+#endif
+                state->flags[i] |= F_BLACK;
+                /*debug_state("State after adding black", state);*/
+                n_ops++;
+                solver_op_circle(state, ss, op.x-1, op.y);
+                solver_op_circle(state, ss, op.x+1, op.y);
+                solver_op_circle(state, ss, op.x,   op.y-1);
+                solver_op_circle(state, ss, op.x,   op.y+1);
+                }
+        } else {
+            if (state->flags[i] & F_BLACK) {
+                debug(("Solver wants to circle blackened square (%d,%d)!\n", op.x, op.y));
+                state->impossible = 1;
+                return n_ops;
+            }
+            if (!(state->flags[i] & F_CIRCLE)) {
+                debug(("... solver adding circle at (%d,%d): %s\n", op.x, op.y, op.desc));
+#ifdef STANDALONE_SOLVER
+                if (verbose)
+                    printf("Adding circle at (%d,%d): %s\n", op.x, op.y, op.desc);
+#endif
+                state->flags[i] |= F_CIRCLE;
+                /*debug_state("State after adding circle", state);*/
+                n_ops++;
+                for (x = 0; x < state->w; x++) {
+                    if (x != op.x)
+                        solver_op_blacken(state, ss, x, op.y, state->nums[i]);
+                }
+                for (y = 0; y < state->h; y++) {
+                    if (y != op.y)
+                        solver_op_blacken(state, ss, op.x, y, state->nums[i]);
+                }
+            }
+        }
+    }
+    ss->n_ops = 0;
+    return n_ops;
+}
+
+/* If the grid has two identical numbers with one cell between them, the inner
+ * cell _must_ be white (and thus circled); (at least) one of the two must be
+ * black (since they're in the same column or row) and thus the middle cell is
+ * next to a black cell. */
+static int solve_singlesep(game_state *state, struct solver_state *ss)
+{
+    int x, y, i, ir, irr, id, idd, n_ops = ss->n_ops;
+
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            i = y*state->w + x;
+
+            /* Cell two to our right? */
+            ir = i + 1; irr = ir + 1;
+            if (x < (state->w-2) &&
+                state->nums[i] == state->nums[irr] &&
+                !(state->flags[ir] & F_CIRCLE)) {
+                solver_op_add(ss, x+1, y, CIRCLE, "SP/ST - between identical nums");
+            }
+            /* Cell two below us? */
+            id = i + state->w; idd = id + state->w;
+            if (y < (state->h-2) &&
+                state->nums[i] == state->nums[idd] &&
+                !(state->flags[id] & F_CIRCLE)) {
+                solver_op_add(ss, x, y+1, CIRCLE, "SP/ST - between identical nums");
+            }
+        }
+    }
+    return ss->n_ops - n_ops;
+}
+
+/* If we have two identical numbers next to each other (in a row or column),
+ * any other identical numbers in that column must be black. */
+static int solve_doubles(game_state *state, struct solver_state *ss)
+{
+    int x, y, i, ii, n_ops = ss->n_ops, xy;
+
+    for (y = 0, i = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++, i++) {
+            assert(i == y*state->w+x);
+            if (state->flags[i] & F_BLACK) continue;
+
+            ii = i+1; /* check cell to our right. */
+            if (x < (state->w-1) &&
+                !(state->flags[ii] & F_BLACK) &&
+                state->nums[i] == state->nums[ii]) {
+                for (xy = 0; xy < state->w; xy++) {
+                    if (xy == x || xy == (x+1)) continue;
+                    if (state->nums[y*state->w + xy] == state->nums[i] &&
+                        !(state->flags[y*state->w + xy] & F_BLACK))
+                        solver_op_add(ss, xy, y, BLACK, "PI - same row as pair");
+                }
+            }
+
+            ii = i+state->w; /* check cell below us */
+            if (y < (state->h-1) &&
+                !(state->flags[ii] & F_BLACK) &&
+                state->nums[i] == state->nums[ii]) {
+                for (xy = 0; xy < state->h; xy++) {
+                    if (xy == y || xy == (y+1)) continue;
+                    if (state->nums[xy*state->w + x] == state->nums[i] &&
+                        !(state->flags[xy*state->w + x] & F_BLACK))
+                        solver_op_add(ss, x, xy, BLACK, "PI - same col as pair");
+                }
+            }
+        }
+    }
+    return ss->n_ops - n_ops;
+}
+
+/* If a white square has all-but-one possible adjacent squares black, the
+ * one square left over must be white. */
+static int solve_allblackbutone(game_state *state, struct solver_state *ss)
+{
+    int x, y, i, n_ops = ss->n_ops, xd, yd, id, ifree;
+    int dis[4], d;
+
+    dis[0] = -state->w;
+    dis[1] = 1;
+    dis[2] = state->w;
+    dis[3] = -1;
+
+    for (y = 0, i = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++, i++) {
+            assert(i == y*state->w+x);
+            if (state->flags[i] & F_BLACK) continue;
+
+            ifree = -1;
+            for (d = 0; d < 4; d++) {
+                xd = x + dxs[d]; yd = y + dys[d]; id = i + dis[d];
+                if (!INGRID(state, xd, yd)) continue;
+
+                if (state->flags[id] & F_CIRCLE)
+                    goto skip; /* this cell already has a way out */
+                if (!(state->flags[id] & F_BLACK)) {
+                    if (ifree != -1)
+                        goto skip; /* this cell has >1 white cell around it. */
+                    ifree = id;
+                }
+            }
+            if (ifree != -1)
+                solver_op_add(ss, ifree%state->w, ifree/state->w, CIRCLE,
+                              "CC/CE/QM: white cell with single non-black around it");
+            else {
+                debug(("White cell with no escape at (%d,%d)\n", x, y));
+                state->impossible = 1;
+                return 0;
+            }
+skip: ;
+        }
+    }
+    return ss->n_ops - n_ops;
+}
+
+/* If we have 4 numbers the same in a 2x2 corner, the far corner and the
+ * diagonally-adjacent square must both be black.
+ * If we have 3 numbers the same in a 2x2 corner, the apex of the L
+ * thus formed must be black.
+ * If we have 2 numbers the same in a 2x2 corner, the non-same cell
+ * one away from the corner must be white. */
+static void solve_corner(game_state *state, struct solver_state *ss,
+                        int x, int y, int dx, int dy)
+{
+    int is[4], ns[4], xx, yy, w = state->w;
+
+    for (yy = 0; yy < 2; yy++) {
+        for (xx = 0; xx < 2; xx++) {
+            is[yy*2+xx] = (y + dy*yy) * w + (x + dx*xx);
+            ns[yy*2+xx] = state->nums[is[yy*2+xx]];
+        }
+    } /* order is now (corner, side 1, side 2, inner) */
+
+    if (ns[0] == ns[1] && ns[0] == ns[2] && ns[0] == ns[3]) {
+        solver_op_add(ss, is[0]%w, is[0]/w, BLACK, "QC: corner with 4 matching");
+        solver_op_add(ss, is[3]%w, is[3]/w, BLACK, "QC: corner with 4 matching");
+    } else if (ns[0] == ns[1] && ns[0] == ns[2]) {
+        /* corner and 2 sides: apex is corner. */
+        solver_op_add(ss, is[0]%w, is[0]/w, BLACK, "TC: corner apex from 3 matching");
+    } else if (ns[1] == ns[2] && ns[1] == ns[3]) {
+        /* side, side, fourth: apex is fourth. */
+        solver_op_add(ss, is[3]%w, is[3]/w, BLACK, "TC: inside apex from 3 matching");
+    } else if (ns[0] == ns[1] || ns[1] == ns[3]) {
+        /* either way here we match the non-identical side. */
+        solver_op_add(ss, is[2]%w, is[2]/w, CIRCLE, "DC: corner with 2 matching");
+    } else if (ns[0] == ns[2] || ns[2] == ns[3]) {
+        /* ditto */
+        solver_op_add(ss, is[1]%w, is[1]/w, CIRCLE, "DC: corner with 2 matching");
+    }
+}
+
+static int solve_corners(game_state *state, struct solver_state *ss)
+{
+    int n_ops = ss->n_ops;
+
+    solve_corner(state, ss, 0,          0,           1,  1);
+    solve_corner(state, ss, state->w-1, 0,          -1,  1);
+    solve_corner(state, ss, state->w-1, state->h-1, -1, -1);
+    solve_corner(state, ss, 0,          state->h-1,  1, -1);
+
+    return ss->n_ops - n_ops;
+}
+
+/* If you have the following situation:
+ * ...
+ * ...x A x x y A x...
+ * ...x B x x B y x...
+ * ...
+ * then both squares marked 'y' must be white. One of the left-most A or B must
+ * be white (since two side-by-side black cells are disallowed), which means
+ * that the corresponding right-most A or B must be black (since you can't
+ * have two of the same number on one line); thus, the adjacent squares
+ * to that right-most A or B must be white, which include the two marked 'y'
+ * in either case.
+ * Obviously this works in any row or column. It also works if A == B.
+ * It doesn't work for the degenerate case:
+ * ...x A A x x
+ * ...x B y x x
+ * where the square marked 'y' isn't necessarily white (consider the left-most A
+ * is black).
+ *
+ * */
+static void solve_offsetpair_pair(game_state *state, struct solver_state *ss,
+                                  int x1, int y1, int x2, int y2)
+{
+    int ox, oy, w = state->w, ax, ay, an, d, dx[2], dy[2], dn, xd, yd;
+
+    if (x1 == x2) { /* same column */
+        ox = 1; oy = 0;
+    } else {
+        assert(y1 == y2);
+        ox = 0; oy = 1;
+    }
+
+    /* We try adjacent to (x1,y1) and the two diag. adjacent to (x2, y2).
+     * We expect to be called twice, once each way around. */
+    ax = x1+ox; ay = y1+oy;
+    assert(INGRID(state, ax, ay));
+    an = state->nums[ay*w + ax];
+
+    dx[0] = x2 + ox + oy; dx[1] = x2 + ox - oy;
+    dy[0] = y2 + oy + ox; dy[1] = y2 + oy - ox;
+
+    for (d = 0; d < 2; d++) {
+        if (INGRID(state, dx[d], dy[d]) && (dx[d] != ax || dy[d] != ay)) {
+            /* The 'dx != ax || dy != ay' removes the degenerate case,
+             * mentioned above. */
+            dn = state->nums[dy[d]*w + dx[d]];
+            if (an == dn) {
+                /* We have a match; so (WLOG) the 'A' marked above are at
+                 * (x1,y1) and (x2,y2), and the 'B' are at (ax,ay) and (dx,dy). */
+                debug(("Found offset-pair: %d at (%d,%d) and (%d,%d)\n",
+                       state->nums[y1*w + x1], x1, y1, x2, y2));
+                debug(("              and: %d at (%d,%d) and (%d,%d)\n",
+                       an, ax, ay, dx[d], dy[d]));
+
+                xd = dx[d] - x2; yd = dy[d] - y2;
+                solver_op_add(ss, x2 + xd, y2, CIRCLE, "IP: next to offset-pair");
+                solver_op_add(ss, x2, y2 + yd, CIRCLE, "IP: next to offset-pair");
+            }
+        }
+    }
+}
+
+static int solve_offsetpair(game_state *state, struct solver_state *ss)
+{
+    int n_ops = ss->n_ops, x, xx, y, yy, n1, n2;
+
+    for (x = 0; x < state->w-1; x++) {
+        for (y = 0; y < state->h; y++) {
+            n1 = state->nums[y*state->w + x];
+            for (yy = y+1; yy < state->h; yy++) {
+                n2 = state->nums[yy*state->w + x];
+                if (n1 == n2) {
+                    solve_offsetpair_pair(state, ss, x,  y, x, yy);
+                    solve_offsetpair_pair(state, ss, x, yy, x,  y);
+                }
+            }
+        }
+    }
+    for (y = 0; y < state->h-1; y++) {
+        for (x = 0; x < state->w; x++) {
+            n1 = state->nums[y*state->w + x];
+            for (xx = x+1; xx < state->w; xx++) {
+                n2 = state->nums[y*state->w + xx];
+                if (n1 == n2) {
+                    solve_offsetpair_pair(state, ss, x,  y, xx, y);
+                    solve_offsetpair_pair(state, ss, xx, y,  x, y);
+                }
+            }
+        }
+    }
+    return ss->n_ops - n_ops;
+}
+
+static int solve_hassinglewhiteregion(game_state *state, struct solver_state *ss)
+{
+    int i, j, nwhite = 0, lwhite = -1, szwhite, start, end, next, a, d, x, y;
+
+    for (i = 0; i < state->n; i++) {
+        if (!(state->flags[i] & F_BLACK)) {
+            nwhite++;
+            lwhite = i;
+        }
+        state->flags[i] &= ~F_SCRATCH;
+    }
+    if (lwhite == -1) {
+        debug(("solve_hassinglewhite: no white squares found!\n"));
+        state->impossible = 1;
+        return 0;
+    }
+    /* We don't use connect_dsf here; it's too slow, and there's a quicker
+     * algorithm if all we want is the size of one region. */
+    /* Having written this, this algorithm is only about 5% faster than
+     * using a dsf. */
+    memset(ss->scratch, -1, state->n * sizeof(int));
+    ss->scratch[0] = lwhite;
+    state->flags[lwhite] |= F_SCRATCH;
+    start = 0; end = next = 1;
+    while (start < end) {
+        for (a = start; a < end; a++) {
+            i = ss->scratch[a]; assert(i != -1);
+            for (d = 0; d < 4; d++) {
+                x = (i % state->w) + dxs[d];
+                y = (i / state->w) + dys[d];
+                j = y*state->w + x;
+                if (!INGRID(state, x, y)) continue;
+                if (state->flags[j] & (F_BLACK | F_SCRATCH)) continue;
+                ss->scratch[next++] = j;
+                state->flags[j] |= F_SCRATCH;
+            }
+        }
+        start = end; end = next;
+    }
+    szwhite = next;
+    return (szwhite == nwhite) ? 1 : 0;
+}
+
+static void solve_removesplits_check(game_state *state, struct solver_state *ss,
+                                     int x, int y)
+{
+    int i = y*state->w + x, issingle;
+
+    if (!INGRID(state, x, y)) return;
+    if ((state->flags[i] & F_CIRCLE) || (state->flags[i] & F_BLACK))
+        return;
+
+    /* If putting a black square at (x,y) would make the white region
+     * non-contiguous, it must be circled. */
+    state->flags[i] |= F_BLACK;
+    issingle = solve_hassinglewhiteregion(state, ss);
+    state->flags[i] &= ~F_BLACK;
+
+    if (!issingle)
+        solver_op_add(ss, x, y, CIRCLE, "MC: black square here would split white region");
+}
+
+/* For all black squares, search in squares diagonally adjacent to see if
+ * we can rule out putting a black square there (because it would make the
+ * white region non-contiguous). */
+/* This function is likely to be somewhat slow. */
+static int solve_removesplits(game_state *state, struct solver_state *ss)
+{
+    int i, x, y, n_ops = ss->n_ops;
+
+    if (!solve_hassinglewhiteregion(state, ss)) {
+        debug(("solve_removesplits: white region is not contiguous at start!\n"));
+        state->impossible = 1;
+        return 0;
+    }
+
+    for (i = 0; i < state->n; i++) {
+        if (!(state->flags[i] & F_BLACK)) continue;
+
+        x = i%state->w; y = i/state->w;
+        solve_removesplits_check(state, ss, x-1, y-1);
+        solve_removesplits_check(state, ss, x+1, y-1);
+        solve_removesplits_check(state, ss, x+1, y+1);
+        solve_removesplits_check(state, ss, x-1, y+1);
+    }
+    return ss->n_ops - n_ops;
+}
+
+/*
+ * This function performs a solver step that isn't implicit in the rules
+ * of the game and is thus treated somewhat differently.
+ *
+ * It marks cells whose number does not exist elsewhere in its row/column
+ * with circles. As it happens the game generator here does mean that this
+ * is always correct, but it's a solving method that people should not have
+ * to rely upon (except in the hidden 'sneaky' difficulty setting) and so
+ * all grids at 'tricky' and above are checked to make sure that the grid
+ * is no easier if this solving step is performed beforehand.
+ *
+ * Calling with ss=NULL just returns the number of sneaky deductions that
+ * would have been made.
+ */
+static int solve_sneaky(game_state *state, struct solver_state *ss)
+{
+    int i, ii, x, xx, y, yy, nunique = 0;
+
+    /* Clear SCRATCH flags. */
+    for (i = 0; i < state->n; i++) state->flags[i] &= ~F_SCRATCH;
+
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            i = y*state->w + x;
+
+            /* Check for duplicate numbers on our row, mark (both) if so */
+            for (xx = x; xx < state->w; xx++) {
+                ii = y*state->w + xx;
+                if (i == ii) continue;
+
+                if (state->nums[i] == state->nums[ii]) {
+                    state->flags[i] |= F_SCRATCH;
+                    state->flags[ii] |= F_SCRATCH;
+                }
+            }
+
+            /* Check for duplicate numbers on our col, mark (both) if so */
+            for (yy = y; yy < state->h; yy++) {
+                ii = yy*state->w + x;
+                if (i == ii) continue;
+
+                if (state->nums[i] == state->nums[ii]) {
+                    state->flags[i] |= F_SCRATCH;
+                    state->flags[ii] |= F_SCRATCH;
+                }
+            }
+        }
+    }
+
+    /* Any cell with no marking has no duplicates on its row or column:
+     * set its CIRCLE. */
+    for (i = 0; i < state->n; i++) {
+        if (!(state->flags[i] & F_SCRATCH)) {
+            if (ss) solver_op_add(ss, i%state->w, i/state->w, CIRCLE,
+                                  "SNEAKY: only one of its number in row and col");
+            nunique += 1;
+        } else
+            state->flags[i] &= ~F_SCRATCH;
+    }
+    return nunique;
+}
+
+static int solve_specific(game_state *state, int diff, int sneaky)
+{
+    struct solver_state *ss = solver_state_new(state);
+
+    if (sneaky) solve_sneaky(state, ss);
+
+    /* Some solver operations we only have to perform once --
+     * they're only based on the numbers available, and not black
+     * squares or circles which may be added later. */
+
+    solve_singlesep(state, ss);        /* never sets impossible */
+    solve_doubles(state, ss);          /* ditto */
+    solve_corners(state, ss);          /* ditto */
+
+    if (diff >= DIFF_TRICKY)
+        solve_offsetpair(state, ss);       /* ditto */
+
+    while (1) {
+        if (ss->n_ops > 0) solver_ops_do(state, ss);
+        if (state->impossible) break;
+
+        if (solve_allblackbutone(state, ss) > 0) continue;
+        if (state->impossible) break;
+
+        if (diff >= DIFF_TRICKY) {
+            if (solve_removesplits(state, ss) > 0) continue;
+            if (state->impossible) break;
+        }
+
+        break;
+    }
+
+    solver_state_free(ss);
+    return state->impossible ? -1 : check_complete(state, CC_MUST_FILL);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    game_state *solved = dup_game(currstate);
+    char *move = NULL;
+
+    if (solve_specific(solved, DIFF_ANY, 0) > 0) goto solved;
+    free_game(solved);
+
+    solved = dup_game(state);
+    if (solve_specific(solved, DIFF_ANY, 0) > 0) goto solved;
+    free_game(solved);
+
+    *error = "Unable to solve puzzle.";
+    return NULL;
+
+solved:
+    move = game_state_diff(currstate, solved, 1);
+    free_game(solved);
+    return move;
+}
+
+/* --- Game generation --- */
+
+/* A correctly completed Hitori board is essentially a latin square
+ * (no duplicated numbers in any row or column) with black squares
+ * added such that no black square touches another, and the white
+ * squares make a contiguous region.
+ *
+ * So we can generate it by:
+   * constructing a latin square
+   * adding black squares at random (minding the constraints)
+   * altering the numbers under the new black squares such that
+      the solver gets a headstart working out where they are.
+ */
+
+static int new_game_is_good(const game_params *params,
+                            game_state *state, game_state *tosolve)
+{
+    int sret, sret_easy = 0;
+
+    memcpy(tosolve->nums, state->nums, state->n * sizeof(int));
+    memset(tosolve->flags, 0, state->n * sizeof(unsigned int));
+    tosolve->completed = tosolve->impossible = 0;
+
+    /*
+     * We try and solve it twice, once at our requested difficulty level
+     * (ensuring it's soluble at all) and once at the level below (if
+     * it exists), which we hope to fail: if you can also solve it at
+     * the level below then it's too easy and we have to try again.
+     *
+     * With this puzzle in particular there's an extra finesse, which is
+     * that we check that the generated puzzle isn't too easy _with
+     * an extra solver step first_, which is the 'sneaky' mode of deductions
+     * (asserting that any number which fulfils the latin-square rules
+     * on its row/column must be white). This is an artefact of the
+     * generation process and not implicit in the rules, so we don't want
+     * people to be able to use it to make the puzzle easier.
+     */
+
+    assert(params->diff < DIFF_MAX);
+    sret = solve_specific(tosolve, params->diff, 0);
+    if (params->diff > DIFF_EASY) {
+        memset(tosolve->flags, 0, state->n * sizeof(unsigned int));
+        tosolve->completed = tosolve->impossible = 0;
+
+        /* this is the only time the 'sneaky' flag is set to 1. */
+        sret_easy = solve_specific(tosolve, params->diff-1, 1);
+    }
+
+    if (sret <= 0 || sret_easy > 0) {
+        debug(("Generated puzzle %s at chosen difficulty %s\n",
+               sret <= 0 ? "insoluble" : "too easy",
+               singles_diffnames[params->diff]));
+        return 0;
+    }
+    return 1;
+}
+
+#define MAXTRIES 20
+
+static int best_black_col(game_state *state, random_state *rs, int *scratch,
+                          int i, int *rownums, int *colnums)
+{
+    int w = state->w, x = i%w, y = i/w, j, o = state->o;
+
+    /* Randomise the list of numbers to try. */
+    for (i = 0; i < o; i++) scratch[i] = i;
+    shuffle(scratch, o, sizeof(int), rs);
+
+    /* Try each number in turn, first giving preference to removing
+     * latin-square characteristics (i.e. those numbers which only
+     * occur once in a row/column). The '&&' here, although intuitively
+     * wrong, results in a smaller number of 'sneaky' deductions on
+     * solvable boards. */
+    for (i = 0; i < o; i++) {
+        j = scratch[i] + 1;
+        if (rownums[y*o + j-1] == 1 && colnums[x*o + j-1] == 1)
+            goto found;
+    }
+
+    /* Then try each number in turn returning the first one that's
+     * not actually unique in its row/column (see comment below) */
+    for (i = 0; i < o; i++) {
+        j = scratch[i] + 1;
+        if (rownums[y*o + j-1] != 0 || colnums[x*o + j-1] != 0)
+            goto found;
+    }
+    assert(!"unable to place number under black cell.");
+    return 0;
+
+found:
+    /* Update column and row counts assuming this number will be placed. */
+    rownums[y*o + j-1] += 1;
+    colnums[x*o + j-1] += 1;
+    return j;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    game_state *state = blank_game(params->w, params->h);
+    game_state *tosolve = blank_game(params->w, params->h);
+    int i, j, *scratch, *rownums, *colnums, x, y, ntries;
+    int w = state->w, h = state->h, o = state->o;
+    char *ret;
+    digit *latin;
+    struct solver_state *ss = solver_state_new(state);
+
+    scratch = snewn(state->n, int);
+    rownums = snewn(h*o, int);
+    colnums = snewn(w*o, int);
+
+generate:
+    ss->n_ops = 0;
+    debug(("Starting game generation, size %dx%d\n", w, h));
+
+    memset(state->flags, 0, state->n*sizeof(unsigned int));
+
+    /* First, generate the latin rectangle.
+     * The order of this, o, is max(w,h). */
+    latin = latin_generate_rect(w, h, rs);
+    for (i = 0; i < state->n; i++)
+        state->nums[i] = (int)latin[i];
+    sfree(latin);
+    debug_state("State after latin square", state);
+
+    /* Add black squares at random, using bits of solver as we go (to lay
+     * white squares), until we can lay no more blacks. */
+    for (i = 0; i < state->n; i++)
+        scratch[i] = i;
+    shuffle(scratch, state->n, sizeof(int), rs);
+    for (j = 0; j < state->n; j++) {
+        i = scratch[j];
+        if ((state->flags[i] & F_CIRCLE) || (state->flags[i] & F_BLACK)) {
+            debug(("generator skipping (%d,%d): %s\n", i%w, i/w,
+                   (state->flags[i] & F_CIRCLE) ? "CIRCLE" : "BLACK"));
+            continue; /* solver knows this must be one or the other already. */
+        }
+
+        /* Add a random black cell... */
+        solver_op_add(ss, i%w, i/w, BLACK, "Generator: adding random black cell");
+        solver_ops_do(state, ss);
+
+        /* ... and do as well as we know how to lay down whites that are now forced. */
+        solve_allblackbutone(state, ss);
+        solver_ops_do(state, ss);
+
+        solve_removesplits(state, ss);
+        solver_ops_do(state, ss);
+
+        if (state->impossible) {
+            debug(("generator made impossible, restarting...\n"));
+            goto generate;
+        }
+    }
+    debug_state("State after adding blacks", state);
+
+    /* Now we know which squares are white and which are black, we lay numbers
+     * under black squares at random, except that the number must appear in
+     * white cells at least once more in the same column or row as that [black]
+     * square. That's necessary to avoid multiple solutions, where blackening
+     * squares in the finished puzzle becomes optional. We use two arrays:
+     *
+     * rownums[ROW * o + NUM-1] is the no. of white cells containing NUM in y=ROW
+     * colnums[COL * o + NUM-1] is the no. of white cells containing NUM in x=COL
+     */
+
+    memset(rownums, 0, h*o * sizeof(int));
+    memset(colnums, 0, w*o * sizeof(int));
+    for (i = 0; i < state->n; i++) {
+        if (state->flags[i] & F_BLACK) continue;
+        j = state->nums[i];
+        x = i%w; y = i/w;
+        rownums[y * o + j-1] += 1;
+        colnums[x * o + j-1] += 1;
+    }
+
+    ntries = 0;
+randomise:
+    for (i = 0; i < state->n; i++) {
+        if (!(state->flags[i] & F_BLACK)) continue;
+        state->nums[i] = best_black_col(state, rs, scratch, i, rownums, colnums);
+    }
+    debug_state("State after adding numbers", state);
+
+    /* DIFF_ANY just returns whatever we first generated, for testing purposes. */
+    if (params->diff != DIFF_ANY &&
+        !new_game_is_good(params, state, tosolve)) {
+        ntries++;
+        if (ntries > MAXTRIES) {
+            debug(("Ran out of randomisation attempts, re-generating.\n"));
+            goto generate;
+        }
+        debug(("Re-randomising numbers under black squares.\n"));
+        goto randomise;
+    }
+
+    ret = generate_desc(state, 0);
+
+    free_game(tosolve);
+    free_game(state);
+    solver_state_free(ss);
+    sfree(scratch);
+    sfree(rownums);
+    sfree(colnums);
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    char *ret = NULL;
+
+    unpick_desc(params, desc, NULL, &ret);
+    return ret;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = NULL;
+
+    unpick_desc(params, desc, &state, NULL);
+    if (!state) assert(!"new_game failed to unpick");
+    return state;
+}
+
+/* --- Game UI and move routines --- */
+
+struct game_ui {
+    int cx, cy, cshow;
+    int show_black_nums;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->cx = ui->cy = ui->cshow = 0;
+    ui->show_black_nums = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    if (!oldstate->completed && newstate->completed)
+        ui->cshow = 0;
+}
+
+#define DS_BLACK        0x1
+#define DS_CIRCLE       0x2
+#define DS_CURSOR       0x4
+#define DS_BLACK_NUM    0x8
+#define DS_ERROR        0x10
+#define DS_FLASH        0x20
+#define DS_IMPOSSIBLE   0x40
+
+struct game_drawstate {
+    int tilesize, started, solved;
+    int w, h, n;
+
+    unsigned int *flags;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int mx, int my, int button)
+{
+    char buf[80], c;
+    int i, x = FROMCOORD(mx), y = FROMCOORD(my);
+    enum { NONE, TOGGLE_BLACK, TOGGLE_CIRCLE, UI } action = NONE;
+
+    if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->cx, &ui->cy, state->w, state->h, 1);
+        ui->cshow = 1;
+        action = UI;
+    } else if (IS_CURSOR_SELECT(button)) {
+        x = ui->cx; y = ui->cy;
+        if (!ui->cshow) {
+            action = UI;
+            ui->cshow = 1;
+        }
+        if (button == CURSOR_SELECT) {
+            action = TOGGLE_BLACK;
+        } else if (button == CURSOR_SELECT2) {
+            action = TOGGLE_CIRCLE;
+        }
+    } else if (IS_MOUSE_DOWN(button)) {
+        if (ui->cshow) {
+            ui->cshow = 0;
+            action = UI;
+        }
+        if (!INGRID(state, x, y)) {
+            ui->show_black_nums = 1 - ui->show_black_nums;
+            action = UI; /* this wants to be a per-game option. */
+        } else if (button == LEFT_BUTTON) {
+            action = TOGGLE_BLACK;
+        } else if (button == RIGHT_BUTTON) {
+            action = TOGGLE_CIRCLE;
+        }
+    }
+    if (action == UI) return "";
+
+    if (action == TOGGLE_BLACK || action == TOGGLE_CIRCLE) {
+        i = y * state->w + x;
+        if (state->flags[i] & (F_BLACK | F_CIRCLE))
+            c = 'E';
+        else
+            c = (action == TOGGLE_BLACK) ? 'B' : 'C';
+        sprintf(buf, "%c%d,%d", (int)c, x, y);
+        return dupstr(buf);
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    game_state *ret = dup_game(state);
+    int x, y, i, n;
+
+    debug(("move: %s\n", move));
+
+    while (*move) {
+        char c = *move;
+        if (c == 'B' || c == 'C' || c == 'E') {
+            move++;
+            if (sscanf(move, "%d,%d%n", &x, &y, &n) != 2 ||
+                !INGRID(state, x, y))
+                goto badmove;
+
+            i = y*ret->w + x;
+            ret->flags[i] &= ~(F_CIRCLE | F_BLACK); /* empty first, always. */
+            if (c == 'B')
+                ret->flags[i] |= F_BLACK;
+            else if (c == 'C')
+                ret->flags[i] |= F_CIRCLE;
+            move += n;
+        } else if (c == 'S') {
+            move++;
+            ret->used_solve = 1;
+        } else
+            goto badmove;
+
+        if (*move == ';')
+            move++;
+        else if (*move)
+            goto badmove;
+    }
+    if (check_complete(ret, CC_MARK_ERRORS)) ret->completed = 1;
+    return ret;
+
+badmove:
+    free_game(ret);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = TILE_SIZE * params->w + 2 * BORDER;
+    *y = TILE_SIZE * params->h + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+    for (i = 0; i < 3; i++) {
+        ret[COL_BLACK * 3 + i] = 0.0F;
+        ret[COL_BLACKNUM * 3 + i] = 0.4F;
+        ret[COL_WHITE * 3 + i] = 1.0F;
+        ret[COL_GRID * 3 + i] = ret[COL_LOWLIGHT * 3 + i];
+    }
+    ret[COL_CURSOR * 3 + 0] = 0.2F;
+    ret[COL_CURSOR * 3 + 1] = 0.8F;
+    ret[COL_CURSOR * 3 + 2] = 0.0F;
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->tilesize = ds->started = ds->solved = 0;
+    ds->w = state->w;
+    ds->h = state->h;
+    ds->n = state->n;
+
+    ds->flags = snewn(state->n, unsigned int);
+
+    memset(ds->flags, 0, state->n*sizeof(unsigned int));
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->flags);
+    sfree(ds);
+}
+
+static void tile_redraw(drawing *dr, game_drawstate *ds, int x, int y,
+                        int num, unsigned int f)
+{
+    int tcol, bg, dnum, cx, cy, tsz;
+    char buf[32];
+
+    if (f & DS_BLACK) {
+        bg = (f & DS_ERROR) ? COL_ERROR : COL_BLACK;
+        tcol = COL_BLACKNUM;
+        dnum = (f & DS_BLACK_NUM) ? 1 : 0;
+    } else {
+        bg = (f & DS_FLASH) ? COL_LOWLIGHT : COL_BACKGROUND;
+        tcol = (f & DS_ERROR) ? COL_ERROR : COL_BLACK;
+        dnum = 1;
+    }
+
+    cx = x + TILE_SIZE/2; cy = y + TILE_SIZE/2;
+
+    draw_rect(dr, x,    y, TILE_SIZE, TILE_SIZE, bg);
+    draw_rect_outline(dr, x, y, TILE_SIZE, TILE_SIZE,
+                      (f & DS_IMPOSSIBLE) ? COL_ERROR : COL_GRID);
+
+    if (f & DS_CIRCLE) {
+        draw_circle(dr, cx, cy, CRAD, tcol, tcol);
+        draw_circle(dr, cx, cy, CRAD-1, bg, tcol);
+    }
+
+    if (dnum) {
+        sprintf(buf, "%d", num);
+        if (strlen(buf) == 1)
+            tsz = TEXTSZ;
+        else
+            tsz = (CRAD*2 - 1) / strlen(buf);
+        draw_text(dr, cx, cy, FONT_VARIABLE, tsz,
+                  ALIGN_VCENTRE | ALIGN_HCENTRE, tcol, buf);
+    }
+
+    if (f & DS_CURSOR)
+        draw_rect_corners(dr, cx, cy, TEXTSZ/2, COL_CURSOR);
+
+    draw_update(dr, x, y, TILE_SIZE, TILE_SIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int x, y, i, flash;
+    unsigned int f;
+
+    flash = (int)(flashtime * 5 / FLASH_TIME) % 2;
+
+    if (!ds->started) {
+        int wsz = TILE_SIZE * state->w + 2 * BORDER;
+        int hsz = TILE_SIZE * state->h + 2 * BORDER;
+        draw_rect(dr, 0, 0, wsz, hsz, COL_BACKGROUND);
+        draw_rect_outline(dr, COORD(0)-1, COORD(0)-1,
+                          TILE_SIZE * state->w + 2, TILE_SIZE * state->h + 2,
+                          COL_GRID);
+        draw_update(dr, 0, 0, wsz, hsz);
+    }
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            i = y*state->w + x;
+            f = 0;
+
+            if (flash) f |= DS_FLASH;
+            if (state->impossible) f |= DS_IMPOSSIBLE;
+
+            if (ui->cshow && x == ui->cx && y == ui->cy)
+                f |= DS_CURSOR;
+            if (state->flags[i] & F_BLACK) {
+                f |= DS_BLACK;
+                if (ui->show_black_nums) f |= DS_BLACK_NUM;
+            }
+            if (state->flags[i] & F_CIRCLE)
+                f |= DS_CIRCLE;
+            if (state->flags[i] & F_ERROR)
+                f |= DS_ERROR;
+
+            if (!ds->started || ds->flags[i] != f) {
+                tile_redraw(dr, ds, COORD(x), COORD(y),
+                            state->nums[i], f);
+                ds->flags[i] = f;
+            }
+        }
+    }
+    ds->started = 1;
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed &&
+        newstate->completed && !newstate->used_solve)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /* 8mm squares by default. */
+    game_compute_size(params, 800, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int ink = print_mono_colour(dr, 0);
+    int paper = print_mono_colour(dr, 1);
+    int x, y, ox, oy, i;
+    char buf[32];
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    print_line_width(dr, 2 * TILE_SIZE / 40);
+
+    for (x = 0; x < state->w; x++) {
+        for (y = 0; y < state->h; y++) {
+            ox = COORD(x); oy = COORD(y);
+            i = y*state->w+x;
+
+            if (state->flags[i] & F_BLACK) {
+                draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE, ink);
+            } else {
+                draw_rect_outline(dr, ox, oy, TILE_SIZE, TILE_SIZE, ink);
+
+                if (state->flags[i] & DS_CIRCLE)
+                    draw_circle(dr, ox+TILE_SIZE/2, oy+TILE_SIZE/2, CRAD,
+                                paper, ink);
+
+                sprintf(buf, "%d", state->nums[i]);
+                draw_text(dr, ox+TILE_SIZE/2, oy+TILE_SIZE/2, FONT_VARIABLE,
+                          TEXTSZ/strlen(buf), ALIGN_VCENTRE | ALIGN_HCENTRE,
+                          ink, buf);
+            }
+        }
+    }
+}
+
+#ifdef COMBINED
+#define thegame singles
+#endif
+
+const struct game thegame = {
+    "Singles", "games.singles", "singles",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON,                   /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+#include <time.h>
+#include <stdarg.h>
+
+static void start_soak(game_params *p, random_state *rs)
+{
+    time_t tt_start, tt_now, tt_last;
+    char *desc, *aux;
+    game_state *s;
+    int i, n = 0, ndiff[DIFF_MAX], diff, sret, nblack = 0, nsneaky = 0;
+
+    tt_start = tt_now = time(NULL);
+
+    printf("Soak-testing a %dx%d grid.\n", p->w, p->h);
+    p->diff = DIFF_ANY;
+
+    memset(ndiff, 0, DIFF_MAX * sizeof(int));
+
+    while (1) {
+        n++;
+        desc = new_game_desc(p, rs, &aux, 0);
+        s = new_game(NULL, p, desc);
+        nsneaky += solve_sneaky(s, NULL);
+
+        for (diff = 0; diff < DIFF_MAX; diff++) {
+            memset(s->flags, 0, s->n * sizeof(unsigned int));
+            s->completed = s->impossible = 0;
+            sret = solve_specific(s, diff, 0);
+            if (sret > 0) {
+                ndiff[diff]++;
+                break;
+            } else if (sret < 0)
+                fprintf(stderr, "Impossible! %s\n", desc);
+        }
+        for (i = 0; i < s->n; i++) {
+            if (s->flags[i] & F_BLACK) nblack++;
+        }
+        free_game(s);
+        sfree(desc);
+
+        tt_last = time(NULL);
+        if (tt_last > tt_now) {
+            tt_now = tt_last;
+            printf("%d total, %3.1f/s, bl/sn %3.1f%%/%3.1f%%: ",
+                   n, (double)n / ((double)tt_now - tt_start),
+                   ((double)nblack * 100.0) / (double)(n * p->w * p->h),
+                   ((double)nsneaky * 100.0) / (double)(n * p->w * p->h));
+            for (diff = 0; diff < DIFF_MAX; diff++) {
+                if (diff > 0) printf(", ");
+                printf("%d (%3.1f%%) %s",
+                       ndiff[diff], (double)ndiff[diff] * 100.0 / (double)n,
+                       singles_diffnames[diff]);
+            }
+            printf("\n");
+        }
+    }
+}
+
+int main(int argc, char **argv)
+{
+    char *id = NULL, *desc, *desc_gen = NULL, *tgame, *err, *aux;
+    game_state *s = NULL;
+    game_params *p = NULL;
+    int soln, soak = 0, ret = 1;
+    time_t seed = time(NULL);
+    random_state *rs = NULL;
+
+    setvbuf(stdout, NULL, _IONBF, 0);
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            verbose = 1;
+        } else if (!strcmp(p, "--soak")) {
+            soak = 1;
+        } else if (!strcmp(p, "--seed")) {
+            if (argc == 0) {
+                fprintf(stderr, "%s: --seed needs an argument", argv[0]);
+                goto done;
+            }
+            seed = (time_t)atoi(*++argv);
+            argc--;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    rs = random_new((void*)&seed, sizeof(time_t));
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-v] [--soak] <params> | <game_id>\n", argv[0]);
+        goto done;
+    }
+    desc = strchr(id, ':');
+    if (desc) *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_params(p, 1);
+    if (err) {
+        fprintf(stderr, "%s: %s", argv[0], err);
+        goto done;
+    }
+
+    if (soak) {
+        if (desc) {
+            fprintf(stderr, "%s: --soak only needs params, not game desc.\n", argv[0]);
+            goto done;
+        }
+        start_soak(p, rs);
+    } else {
+        if (!desc) desc = desc_gen = new_game_desc(p, rs, &aux, 0);
+
+        err = validate_desc(p, desc);
+        if (err) {
+            fprintf(stderr, "%s: %s\n", argv[0], err);
+            free_params(p);
+            goto done;
+        }
+        s = new_game(NULL, p, desc);
+
+        if (verbose) {
+            tgame = game_text_format(s);
+            fputs(tgame, stdout);
+            sfree(tgame);
+        }
+
+        soln = solve_specific(s, DIFF_ANY, 0);
+        tgame = game_text_format(s);
+        fputs(tgame, stdout);
+        sfree(tgame);
+        printf("Game was %s.\n\n",
+               soln < 0 ? "impossible" : soln > 0 ? "solved" : "not solved");
+    }
+    ret = 0;
+
+done:
+    if (desc_gen) sfree(desc_gen);
+    if (p) free_params(p);
+    if (s) free_game(s);
+    if (rs) random_free(rs);
+
+    return ret;
+}
+
+#endif
+
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/sixteen.R b/apps/plugins/puzzles/sixteen.R
new file mode 100644
index 0000000000..c63a27cef8
--- /dev/null
+++ b/apps/plugins/puzzles/sixteen.R
@@ -0,0 +1,19 @@
+# -*- makefile -*-
+
+sixteen  : [X] GTK COMMON sixteen sixteen-icon|no-icon
+
+sixteen  : [G] WINDOWS COMMON sixteen sixteen.res|noicon.res
+
+ALL += sixteen[COMBINED]
+
+!begin am gtk
+GAMES += sixteen
+!end
+
+!begin >list.c
+    A(sixteen) \
+!end
+
+!begin >gamedesc.txt
+sixteen:sixteen.exe:Sixteen:Toroidal sliding block puzzle:Slide a row at a time to arrange the tiles into order.
+!end
diff --git a/apps/plugins/puzzles/sixteen.c b/apps/plugins/puzzles/sixteen.c
new file mode 100644
index 0000000000..1dd1d6b017
--- /dev/null
+++ b/apps/plugins/puzzles/sixteen.c
@@ -0,0 +1,1214 @@
+/*
+ * sixteen.c: `16-puzzle', a sliding-tiles jigsaw which differs
+ * from the 15-puzzle in that you toroidally rotate a row or column
+ * at a time.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#define PREFERRED_TILE_SIZE 48
+#define TILE_SIZE (ds->tilesize)
+#define BORDER TILE_SIZE
+#define HIGHLIGHT_WIDTH (TILE_SIZE / 20)
+#define COORD(x)  ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + 2*TILE_SIZE) / TILE_SIZE - 2 )
+
+#define ANIM_TIME 0.13F
+#define FLASH_FRAME 0.13F
+
+#define X(state, i) ( (i) % (state)->w )
+#define Y(state, i) ( (i) / (state)->w )
+#define C(state, x, y) ( (y) * (state)->w + (x) )
+
+#define TILE_CURSOR(i, state, x, y) ((i) == C((state), (x), (y)) &&     \
+                                     0 <= (x) && (x) < (state)->w &&    \
+                                     0 <= (y) && (y) < (state)->h)
+enum {
+    COL_BACKGROUND,
+    COL_TEXT,
+    COL_HIGHLIGHT,
+    COL_LOWLIGHT,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h;
+    int movetarget;
+};
+
+struct game_state {
+    int w, h, n;
+    int *tiles;
+    int completed;
+    int used_solve;                    /* used to suppress completion flash */
+    int movecount, movetarget;
+    int last_movement_sense;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 4;
+    ret->movetarget = 0;
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    int w, h;
+    char buf[80];
+
+    switch (i) {
+      case 0: w = 3, h = 3; break;
+      case 1: w = 4, h = 3; break;
+      case 2: w = 4, h = 4; break;
+      case 3: w = 5, h = 4; break;
+      case 4: w = 5, h = 5; break;
+      default: return FALSE;
+    }
+
+    sprintf(buf, "%dx%d", w, h);
+    *name = dupstr(buf);
+    *params = ret = snew(game_params);
+    ret->w = w;
+    ret->h = h;
+    ret->movetarget = 0;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    ret->movetarget = 0;
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        ret->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string))
+            string++;
+    }
+    if (*string == 'm') {
+        string++;
+        ret->movetarget = atoi(string);
+        while (*string && isdigit((unsigned char)*string))
+            string++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    sprintf(data, "%dx%d", params->w, params->h);
+    /* Shuffle limit is part of the limited parameters, because we have to
+     * supply the target move count. */
+    if (params->movetarget)
+        sprintf(data + strlen(data), "m%d", params->movetarget);
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Number of shuffling moves";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->movetarget);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->movetarget = atoi(cfg[2].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 2 || params->h < 2)
+        return "Width and height must both be at least two";
+
+    return NULL;
+}
+
+static int perm_parity(int *perm, int n)
+{
+    int i, j, ret;
+
+    ret = 0;
+
+    for (i = 0; i < n-1; i++)
+        for (j = i+1; j < n; j++)
+            if (perm[i] > perm[j])
+                ret = !ret;
+
+    return ret;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int stop, n, i, x;
+    int x1, x2, p1, p2;
+    int *tiles, *used;
+    char *ret;
+    int retlen;
+
+    n = params->w * params->h;
+
+    tiles = snewn(n, int);
+
+    if (params->movetarget) {
+        int prevoffset = -1;
+        int max = (params->w > params->h ? params->w : params->h);
+        int *prevmoves = snewn(max, int);
+
+        /*
+         * Shuffle the old-fashioned way, by making a series of
+         * single moves on the grid.
+         */
+
+        for (i = 0; i < n; i++)
+            tiles[i] = i;
+
+        for (i = 0; i < params->movetarget; i++) {
+            int start, offset, len, direction, index;
+            int j, tmp;
+
+            /*
+             * Choose a move to make. We can choose from any row
+             * or any column.
+             */
+            while (1) {
+                j = random_upto(rs, params->w + params->h);
+
+                if (j < params->w) {
+                    /* Column. */
+                    index = j;
+                    start = j;
+                    offset = params->w;
+                    len = params->h;
+                } else {
+                    /* Row. */
+                    index = j - params->w;
+                    start = index * params->w;
+                    offset = 1;
+                    len = params->w;
+                }
+
+                direction = -1 + 2 * random_upto(rs, 2);
+
+                /*
+                 * To at least _try_ to avoid boring cases, check
+                 * that this move doesn't directly undo a previous
+                 * one, or repeat it so many times as to turn it
+                 * into fewer moves in the opposite direction. (For
+                 * example, in a row of length 4, we're allowed to
+                 * move it the same way twice, but not three
+                 * times.)
+                 * 
+                 * We track this for each individual row/column,
+                 * and clear all the counters as soon as a
+                 * perpendicular move is made. This isn't perfect
+                 * (it _can't_ guaranteeably be perfect - there
+                 * will always come a move count beyond which a
+                 * shorter solution will be possible than the one
+                 * which constructed the position) but it should
+                 * sort out all the obvious cases.
+                 */
+                if (offset == prevoffset) {
+                    tmp = prevmoves[index] + direction;
+                    if (abs(2*tmp) > len || abs(tmp) < abs(prevmoves[index]))
+                        continue;
+                }
+
+                /* If we didn't `continue', we've found an OK move to make. */
+                if (offset != prevoffset) {
+                    int i;
+                    for (i = 0; i < max; i++)
+                        prevmoves[i] = 0;
+                    prevoffset = offset;
+                }
+                prevmoves[index] += direction;
+                break;
+            }
+
+            /*
+             * Make the move.
+             */
+            if (direction < 0) {
+                start += (len-1) * offset;
+                offset = -offset;
+            }
+            tmp = tiles[start];
+            for (j = 0; j+1 < len; j++)
+                tiles[start + j*offset] = tiles[start + (j+1)*offset];
+            tiles[start + (len-1) * offset] = tmp;
+        }
+
+        sfree(prevmoves);
+
+    } else {
+
+        used = snewn(n, int);
+
+        for (i = 0; i < n; i++) {
+            tiles[i] = -1;
+            used[i] = FALSE;
+        }
+
+        /*
+         * If both dimensions are odd, there is a parity
+         * constraint.
+         */
+        if (params->w & params->h & 1)
+            stop = 2;
+        else
+            stop = 0;
+
+        /*
+         * Place everything except (possibly) the last two tiles.
+         */
+        for (x = 0, i = n; i > stop; i--) {
+            int k = i > 1 ? random_upto(rs, i) : 0;
+            int j;
+
+            for (j = 0; j < n; j++)
+                if (!used[j] && (k-- == 0))
+                    break;
+
+            assert(j < n && !used[j]);
+            used[j] = TRUE;
+
+            while (tiles[x] >= 0)
+                x++;
+            assert(x < n);
+            tiles[x] = j;
+        }
+
+        if (stop) {
+            /*
+             * Find the last two locations, and the last two
+             * pieces.
+             */
+            while (tiles[x] >= 0)
+                x++;
+            assert(x < n);
+            x1 = x;
+            x++;
+            while (tiles[x] >= 0)
+                x++;
+            assert(x < n);
+            x2 = x;
+
+            for (i = 0; i < n; i++)
+                if (!used[i])
+                    break;
+            p1 = i;
+            for (i = p1+1; i < n; i++)
+                if (!used[i])
+                    break;
+            p2 = i;
+
+            /*
+             * Try the last two tiles one way round. If that fails,
+             * swap them.
+             */
+            tiles[x1] = p1;
+            tiles[x2] = p2;
+            if (perm_parity(tiles, n) != 0) {
+                tiles[x1] = p2;
+                tiles[x2] = p1;
+                assert(perm_parity(tiles, n) == 0);
+            }
+        }
+
+        sfree(used);
+    }
+
+    /*
+     * Now construct the game description, by describing the tile
+     * array as a simple sequence of comma-separated integers.
+     */
+    ret = NULL;
+    retlen = 0;
+    for (i = 0; i < n; i++) {
+        char buf[80];
+        int k;
+
+        k = sprintf(buf, "%d,", tiles[i]+1);
+
+        ret = sresize(ret, retlen + k + 1, char);
+        strcpy(ret + retlen, buf);
+        retlen += k;
+    }
+    ret[retlen-1] = '\0';              /* delete last comma */
+
+    sfree(tiles);
+
+    return ret;
+}
+
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    const char *p;
+    char *err;
+    int i, area;
+    int *used;
+
+    area = params->w * params->h;
+    p = desc;
+    err = NULL;
+
+    used = snewn(area, int);
+    for (i = 0; i < area; i++)
+        used[i] = FALSE;
+
+    for (i = 0; i < area; i++) {
+        const char *q = p;
+        int n;
+
+        if (*p < '0' || *p > '9') {
+            err = "Not enough numbers in string";
+            goto leave;
+        }
+        while (*p >= '0' && *p <= '9')
+            p++;
+        if (i < area-1 && *p != ',') {
+            err = "Expected comma after number";
+            goto leave;
+        }
+        else if (i == area-1 && *p) {
+            err = "Excess junk at end of string";
+            goto leave;
+        }
+        n = atoi(q);
+        if (n < 1 || n > area) {
+            err = "Number out of range";
+            goto leave;
+        }
+        if (used[n-1]) {
+            err = "Number used twice";
+            goto leave;
+        }
+        used[n-1] = TRUE;
+
+        if (*p) p++;                   /* eat comma */
+    }
+
+    leave:
+    sfree(used);
+    return err;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    int i;
+    const char *p;
+
+    state->w = params->w;
+    state->h = params->h;
+    state->n = params->w * params->h;
+    state->tiles = snewn(state->n, int);
+
+    p = desc;
+    i = 0;
+    for (i = 0; i < state->n; i++) {
+        assert(*p);
+        state->tiles[i] = atoi(p);
+        while (*p && *p != ',')
+            p++;
+        if (*p) p++;                   /* eat comma */
+    }
+    assert(!*p);
+
+    state->completed = state->movecount = 0;
+    state->movetarget = params->movetarget;
+    state->used_solve = FALSE;
+    state->last_movement_sense = 0;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->n = state->n;
+    ret->tiles = snewn(state->w * state->h, int);
+    memcpy(ret->tiles, state->tiles, state->w * state->h * sizeof(int));
+    ret->completed = state->completed;
+    ret->movecount = state->movecount;
+    ret->movetarget = state->movetarget;
+    ret->used_solve = state->used_solve;
+    ret->last_movement_sense = state->last_movement_sense;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->tiles);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return dupstr("S");
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    char *ret, *p, buf[80];
+    int x, y, col, maxlen;
+
+    /*
+     * First work out how many characters we need to display each
+     * number.
+     */
+    col = sprintf(buf, "%d", state->n);
+
+    /*
+     * Now we know the exact total size of the grid we're going to
+     * produce: it's got h rows, each containing w lots of col, w-1
+     * spaces and a trailing newline.
+     */
+    maxlen = state->h * state->w * (col+1);
+
+    ret = snewn(maxlen+1, char);
+    p = ret;
+
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            int v = state->tiles[state->w*y+x];
+            sprintf(buf, "%*d", col, v);
+            memcpy(p, buf, col);
+            p += col;
+            if (x+1 == state->w)
+                *p++ = '\n';
+            else
+                *p++ = ' ';
+        }
+    }
+
+    assert(p - ret == maxlen);
+    *p = '\0';
+    return ret;
+}
+
+enum cursor_mode { unlocked, lock_tile, lock_position };
+
+struct game_ui {
+    int cur_x, cur_y;
+    int cur_visible;
+    enum cursor_mode cur_mode;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->cur_x = 0;
+    ui->cur_y = 0;
+    ui->cur_visible = FALSE;
+    ui->cur_mode = unlocked;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int started;
+    int w, h, bgcolour;
+    int *tiles;
+    int tilesize;
+    int cur_x, cur_y;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int cx = -1, cy = -1, dx, dy;
+    char buf[80];
+    int shift = button & MOD_SHFT, control = button & MOD_CTRL,
+        pad = button & MOD_NUM_KEYPAD;
+
+    button &= ~MOD_MASK;
+
+    if (IS_CURSOR_MOVE(button) || pad) {
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+
+        if (control || shift || ui->cur_mode) {
+            int x = ui->cur_x, y = ui->cur_y, xwrap = x, ywrap = y;
+            if (x < 0 || x >= state->w || y < 0 || y >= state->h)
+                return NULL;
+            move_cursor(button | pad, &x, &y,
+                        state->w, state->h, FALSE);
+            move_cursor(button | pad, &xwrap, &ywrap,
+                        state->w, state->h, TRUE);
+
+            if (x != xwrap) {
+                sprintf(buf, "R%d,%c1", y, x ? '+' : '-');
+            } else if (y != ywrap) {
+                sprintf(buf, "C%d,%c1", x, y ? '+' : '-');
+            } else if (x == ui->cur_x)
+                sprintf(buf, "C%d,%d", x, y - ui->cur_y);
+            else
+                sprintf(buf, "R%d,%d", y, x - ui->cur_x);
+
+            if (control || (!shift && ui->cur_mode == lock_tile)) {
+                ui->cur_x = xwrap;
+                ui->cur_y = ywrap;
+            }
+
+            return dupstr(buf);
+        } else {
+            int x = ui->cur_x + 1, y = ui->cur_y + 1;
+
+            move_cursor(button | pad, &x, &y,
+                        state->w + 2, state->h + 2, FALSE);
+
+            if (x == 0 && y == 0) {
+                int t = ui->cur_x;
+                ui->cur_x = ui->cur_y;
+                ui->cur_y = t;
+            } else if (x == 0 && y == state->h + 1) {
+                int t = ui->cur_x;
+                ui->cur_x = (state->h - 1) - ui->cur_y;
+                ui->cur_y = (state->h - 1) - t;
+            } else if (x == state->w + 1 && y == 0) {
+                int t = ui->cur_x;
+                ui->cur_x = (state->w - 1) - ui->cur_y;
+                ui->cur_y = (state->w - 1) - t;
+            } else if (x == state->w + 1 && y == state->h + 1) {
+                int t = ui->cur_x;
+                ui->cur_x = state->w - state->h + ui->cur_y;
+                ui->cur_y = state->h - state->w + t;
+            } else {
+                ui->cur_x = x - 1;
+                ui->cur_y = y - 1;
+            }
+
+            ui->cur_visible = 1;
+            return "";
+        }
+    }
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        cx = FROMCOORD(x);
+        cy = FROMCOORD(y);
+        ui->cur_visible = 0;
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (ui->cur_visible) {
+            if (ui->cur_x == -1 || ui->cur_x == state->w ||
+                ui->cur_y == -1 || ui->cur_y == state->h) {
+                cx = ui->cur_x;
+                cy = ui->cur_y;
+            } else {
+                const enum cursor_mode m = (button == CURSOR_SELECT2 ?
+                                            lock_position : lock_tile);
+                ui->cur_mode = (ui->cur_mode == m ? unlocked : m);
+                return "";
+            }
+        } else {
+            ui->cur_visible = 1;
+            return "";
+        }
+    } else {
+        return NULL;
+    }
+
+    if (cx == -1 && cy >= 0 && cy < state->h)
+        dx = -1, dy = 0;
+    else if (cx == state->w && cy >= 0 && cy < state->h)
+        dx = +1, dy = 0;
+    else if (cy == -1 && cx >= 0 && cx < state->w)
+        dy = -1, dx = 0;
+    else if (cy == state->h && cx >= 0 && cx < state->w)
+        dy = +1, dx = 0;
+    else
+        return "";                   /* invalid click location */
+
+    /* reverse direction if right hand button is pressed */
+    if (button == RIGHT_BUTTON || button == CURSOR_SELECT2) {
+        dx = -dx;
+        dy = -dy;
+    }
+
+    if (dx)
+        sprintf(buf, "R%d,%d", cy, dx);
+    else
+        sprintf(buf, "C%d,%d", cx, dy);
+    return dupstr(buf);
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    int cx, cy, dx, dy;
+    int tx, ty, n;
+    game_state *ret;
+
+    if (!strcmp(move, "S")) {
+        int i;
+
+        ret = dup_game(from);
+
+        /*
+         * Simply replace the grid with a solved one. For this game,
+         * this isn't a useful operation for actually telling the user
+         * what they should have done, but it is useful for
+         * conveniently being able to get hold of a clean state from
+         * which to practise manoeuvres.
+         */
+        for (i = 0; i < ret->n; i++)
+            ret->tiles[i] = i+1;
+        ret->used_solve = TRUE;
+        ret->completed = ret->movecount = 1;
+
+        return ret;
+    }
+
+    if (move[0] == 'R' && sscanf(move+1, "%d,%d", &cy, &dx) == 2 &&
+        cy >= 0 && cy < from->h) {
+        cx = dy = 0;
+        n = from->w;
+    } else if (move[0] == 'C' && sscanf(move+1, "%d,%d", &cx, &dy) == 2 &&
+               cx >= 0 && cx < from->w) {
+        cy = dx = 0;
+        n = from->h;
+    } else
+        return NULL;
+
+    ret = dup_game(from);
+
+    do {
+        tx = (cx - dx + from->w) % from->w;
+        ty = (cy - dy + from->h) % from->h;
+        ret->tiles[C(ret, cx, cy)] = from->tiles[C(from, tx, ty)];
+        cx = tx;
+        cy = ty;
+    } while (--n > 0);
+
+    ret->movecount++;
+
+    ret->last_movement_sense = dx+dy;
+
+    /*
+     * See if the game has been completed.
+     */
+    if (!ret->completed) {
+        ret->completed = ret->movecount;
+        for (n = 0; n < ret->n; n++)
+            if (ret->tiles[n] != n+1)
+                ret->completed = FALSE;
+    }
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = TILE_SIZE * params->w + 2 * BORDER;
+    *y = TILE_SIZE * params->h + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    for (i = 0; i < 3; i++)
+        ret[COL_TEXT * 3 + i] = 0.0;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->started = FALSE;
+    ds->w = state->w;
+    ds->h = state->h;
+    ds->bgcolour = COL_BACKGROUND;
+    ds->tiles = snewn(ds->w*ds->h, int);
+    ds->tilesize = 0;                  /* haven't decided yet */
+    for (i = 0; i < ds->w*ds->h; i++)
+        ds->tiles[i] = -1;
+    ds->cur_x = ds->cur_y = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->tiles);
+    sfree(ds);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds,
+                      const game_state *state, int x, int y,
+                      int tile, int flash_colour)
+{
+    if (tile == 0) {
+        draw_rect(dr, x, y, TILE_SIZE, TILE_SIZE,
+                  flash_colour);
+    } else {
+        int coords[6];
+        char str[40];
+
+        coords[0] = x + TILE_SIZE - 1;
+        coords[1] = y + TILE_SIZE - 1;
+        coords[2] = x + TILE_SIZE - 1;
+        coords[3] = y;
+        coords[4] = x;
+        coords[5] = y + TILE_SIZE - 1;
+        draw_polygon(dr, coords, 3, COL_LOWLIGHT, COL_LOWLIGHT);
+
+        coords[0] = x;
+        coords[1] = y;
+        draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+
+        draw_rect(dr, x + HIGHLIGHT_WIDTH, y + HIGHLIGHT_WIDTH,
+                  TILE_SIZE - 2*HIGHLIGHT_WIDTH, TILE_SIZE - 2*HIGHLIGHT_WIDTH,
+                  flash_colour);
+
+        sprintf(str, "%d", tile);
+        draw_text(dr, x + TILE_SIZE/2, y + TILE_SIZE/2,
+                  FONT_VARIABLE, TILE_SIZE/3, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                  COL_TEXT, str);
+    }
+    draw_update(dr, x, y, TILE_SIZE, TILE_SIZE);
+}
+
+static void draw_arrow(drawing *dr, game_drawstate *ds,
+                       int x, int y, int xdx, int xdy, int cur)
+{
+    int coords[14];
+    int ydy = -xdx, ydx = xdy;
+
+#define POINT(n, xx, yy) ( \
+    coords[2*(n)+0] = x + (xx)*xdx + (yy)*ydx, \
+    coords[2*(n)+1] = y + (xx)*xdy + (yy)*ydy)
+
+    POINT(0, TILE_SIZE / 2, 3 * TILE_SIZE / 4);   /* top of arrow */
+    POINT(1, 3 * TILE_SIZE / 4, TILE_SIZE / 2);   /* right corner */
+    POINT(2, 5 * TILE_SIZE / 8, TILE_SIZE / 2);   /* right concave */
+    POINT(3, 5 * TILE_SIZE / 8, TILE_SIZE / 4);   /* bottom right */
+    POINT(4, 3 * TILE_SIZE / 8, TILE_SIZE / 4);   /* bottom left */
+    POINT(5, 3 * TILE_SIZE / 8, TILE_SIZE / 2);   /* left concave */
+    POINT(6,     TILE_SIZE / 4, TILE_SIZE / 2);   /* left corner */
+
+    draw_polygon(dr, coords, 7, cur ? COL_HIGHLIGHT : COL_LOWLIGHT, COL_TEXT);
+}
+
+static void draw_arrow_for_cursor(drawing *dr, game_drawstate *ds,
+                                  int cur_x, int cur_y, int cur)
+{
+    if (cur_x == -1 && cur_y == -1)
+        return; /* 'no cursur here */
+    else if (cur_x == -1) /* LH column. */
+        draw_arrow(dr, ds, COORD(0), COORD(cur_y+1), 0, -1, cur);
+    else if (cur_x == ds->w) /* RH column */
+        draw_arrow(dr, ds, COORD(ds->w), COORD(cur_y), 0, +1, cur);
+    else if (cur_y == -1) /* Top row */
+        draw_arrow(dr, ds, COORD(cur_x), COORD(0), +1, 0, cur);
+    else if (cur_y == ds->h) /* Bottom row */
+        draw_arrow(dr, ds, COORD(cur_x+1), COORD(ds->h), -1, 0, cur);
+    else
+        return;
+
+    draw_update(dr, COORD(cur_x), COORD(cur_y),
+                TILE_SIZE, TILE_SIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int i, bgcolour;
+    int cur_x = -1, cur_y = -1;
+
+    if (flashtime > 0) {
+        int frame = (int)(flashtime / FLASH_FRAME);
+        bgcolour = (frame % 2 ? COL_LOWLIGHT : COL_HIGHLIGHT);
+    } else
+        bgcolour = COL_BACKGROUND;
+
+    if (!ds->started) {
+        int coords[10];
+
+        draw_rect(dr, 0, 0,
+                  TILE_SIZE * state->w + 2 * BORDER,
+                  TILE_SIZE * state->h + 2 * BORDER, COL_BACKGROUND);
+        draw_update(dr, 0, 0,
+                    TILE_SIZE * state->w + 2 * BORDER,
+                    TILE_SIZE * state->h + 2 * BORDER);
+
+        /*
+         * Recessed area containing the whole puzzle.
+         */
+        coords[0] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
+        coords[1] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
+        coords[2] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
+        coords[3] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[4] = coords[2] - TILE_SIZE;
+        coords[5] = coords[3] + TILE_SIZE;
+        coords[8] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[9] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
+        coords[6] = coords[8] + TILE_SIZE;
+        coords[7] = coords[9] - TILE_SIZE;
+        draw_polygon(dr, coords, 5, COL_HIGHLIGHT, COL_HIGHLIGHT);
+
+        coords[1] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
+        draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
+
+        /*
+         * Arrows for making moves.
+         */
+        for (i = 0; i < state->w; i++) {
+            draw_arrow(dr, ds, COORD(i), COORD(0), +1, 0, 0);
+            draw_arrow(dr, ds, COORD(i+1), COORD(state->h), -1, 0, 0);
+        }
+        for (i = 0; i < state->h; i++) {
+            draw_arrow(dr, ds, COORD(state->w), COORD(i), 0, +1, 0);
+            draw_arrow(dr, ds, COORD(0), COORD(i+1), 0, -1, 0);
+        }
+
+        ds->started = TRUE;
+    }
+    /*
+     * Cursor (highlighted arrow around edge)
+     */
+    if (ui->cur_visible) {
+        cur_x = ui->cur_x; cur_y = ui->cur_y;
+    }
+
+    if (cur_x != ds->cur_x || cur_y != ds->cur_y) {
+        /* Cursor has changed; redraw two (prev and curr) arrows. */
+        draw_arrow_for_cursor(dr, ds, cur_x, cur_y, 1);
+        draw_arrow_for_cursor(dr, ds, ds->cur_x, ds->cur_y, 0);
+    }
+
+    /*
+     * Now draw each tile.
+     */
+
+    clip(dr, COORD(0), COORD(0), TILE_SIZE*state->w, TILE_SIZE*state->h);
+
+    for (i = 0; i < state->n; i++) {
+        int t, t0;
+        /*
+         * Figure out what should be displayed at this
+         * location. It's either a simple tile, or it's a
+         * transition between two tiles (in which case we say
+         * -1 because it must always be drawn).
+         */
+
+        if (oldstate && oldstate->tiles[i] != state->tiles[i])
+            t = -1;
+        else
+            t = state->tiles[i];
+
+        t0 = t;
+
+        if (ds->bgcolour != bgcolour ||   /* always redraw when flashing */
+            ds->tiles[i] != t || ds->tiles[i] == -1 || t == -1 ||
+            ((ds->cur_x != cur_x || ds->cur_y != cur_y) && /* cursor moved */
+             (TILE_CURSOR(i, state, ds->cur_x, ds->cur_y) ||
+              TILE_CURSOR(i, state, cur_x, cur_y)))) {
+            int x, y, x2, y2;
+
+            /*
+             * Figure out what to _actually_ draw, and where to
+             * draw it.
+             */
+            if (t == -1) {
+                int x0, y0, x1, y1, dx, dy;
+                int j;
+                float c;
+                int sense;
+
+                if (dir < 0) {
+                    assert(oldstate);
+                    sense = -oldstate->last_movement_sense;
+                } else {
+                    sense = state->last_movement_sense;
+                }
+
+                t = state->tiles[i];
+
+                /*
+                 * FIXME: must be prepared to draw a double
+                 * tile in some situations.
+                 */
+
+                /*
+                 * Find the coordinates of this tile in the old and
+                 * new states.
+                 */
+                x1 = COORD(X(state, i));
+                y1 = COORD(Y(state, i));
+                for (j = 0; j < oldstate->n; j++)
+                    if (oldstate->tiles[j] == state->tiles[i])
+                        break;
+                assert(j < oldstate->n);
+                x0 = COORD(X(state, j));
+                y0 = COORD(Y(state, j));
+
+                dx = (x1 - x0);
+                if (dx != 0 &&
+                    dx != TILE_SIZE * sense) {
+                    dx = (dx < 0 ? dx + TILE_SIZE * state->w :
+                          dx - TILE_SIZE * state->w);
+                    assert(abs(dx) == TILE_SIZE);
+                }
+                dy = (y1 - y0);
+                if (dy != 0 &&
+                    dy != TILE_SIZE * sense) {
+                    dy = (dy < 0 ? dy + TILE_SIZE * state->h :
+                          dy - TILE_SIZE * state->h);
+                    assert(abs(dy) == TILE_SIZE);
+                }
+
+                c = (animtime / ANIM_TIME);
+                if (c < 0.0F) c = 0.0F;
+                if (c > 1.0F) c = 1.0F;
+
+                x = x0 + (int)(c * dx);
+                y = y0 + (int)(c * dy);
+                x2 = x1 - dx + (int)(c * dx);
+                y2 = y1 - dy + (int)(c * dy);
+            } else {
+                x = COORD(X(state, i));
+                y = COORD(Y(state, i));
+                x2 = y2 = -1;
+            }
+
+            draw_tile(dr, ds, state, x, y, t,
+                      (x2 == -1 && TILE_CURSOR(i, state, cur_x, cur_y)) ?
+                      COL_LOWLIGHT : bgcolour);
+
+            if (x2 != -1 || y2 != -1)
+                draw_tile(dr, ds, state, x2, y2, t, bgcolour);
+        }
+        ds->tiles[i] = t0;
+    }
+
+    ds->cur_x = cur_x;
+    ds->cur_y = cur_y;
+
+    unclip(dr);
+
+    ds->bgcolour = bgcolour;
+
+    /*
+     * Update the status bar.
+     */
+    {
+        char statusbuf[256];
+
+        /*
+         * Don't show the new status until we're also showing the
+         * new _state_ - after the game animation is complete.
+         */
+        if (oldstate)
+            state = oldstate;
+
+        if (state->used_solve)
+            sprintf(statusbuf, "Moves since auto-solve: %d",
+                    state->movecount - state->completed);
+        else {
+            sprintf(statusbuf, "%sMoves: %d",
+                    (state->completed ? "COMPLETED! " : ""),
+                    (state->completed ? state->completed : state->movecount));
+            if (state->movetarget)
+                sprintf(statusbuf+strlen(statusbuf), " (target %d)",
+                        state->movetarget);
+        }
+
+        status_bar(dr, statusbuf);
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return ANIM_TIME;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->used_solve && !newstate->used_solve)
+        return 2 * FLASH_FRAME;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame sixteen
+#endif
+
+const struct game thegame = {
+    "Sixteen", "games.sixteen", "sixteen",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/slant.R b/apps/plugins/puzzles/slant.R
new file mode 100644
index 0000000000..ff0d21f1eb
--- /dev/null
+++ b/apps/plugins/puzzles/slant.R
@@ -0,0 +1,24 @@
+# -*- makefile -*-
+
+SLANT_EXTRA = dsf findloop
+
+slant    : [X] GTK COMMON slant SLANT_EXTRA slant-icon|no-icon
+
+slant    : [G] WINDOWS COMMON slant SLANT_EXTRA slant.res|noicon.res
+
+slantsolver :   [U] slant[STANDALONE_SOLVER] SLANT_EXTRA STANDALONE
+slantsolver :   [C] slant[STANDALONE_SOLVER] SLANT_EXTRA STANDALONE
+
+ALL += slant[COMBINED] SLANT_EXTRA
+
+!begin am gtk
+GAMES += slant
+!end
+
+!begin >list.c
+    A(slant) \
+!end
+
+!begin >gamedesc.txt
+slant:slant.exe:Slant:Maze-drawing puzzle:Draw a maze of slanting lines that matches the clues.
+!end
diff --git a/apps/plugins/puzzles/slant.c b/apps/plugins/puzzles/slant.c
new file mode 100644
index 0000000000..3ab4d306ef
--- /dev/null
+++ b/apps/plugins/puzzles/slant.c
@@ -0,0 +1,2278 @@
+/*
+ * slant.c: Puzzle from nikoli.co.jp involving drawing a diagonal
+ * line through each square of a grid.
+ */
+
+/*
+ * In this puzzle you have a grid of squares, each of which must
+ * contain a diagonal line; you also have clue numbers placed at
+ * _points_ of that grid, which means there's a (w+1) x (h+1) array
+ * of possible clue positions.
+ * 
+ * I'm therefore going to adopt a rigid convention throughout this
+ * source file of using w and h for the dimensions of the grid of
+ * squares, and W and H for the dimensions of the grid of points.
+ * Thus, W == w+1 and H == h+1 always.
+ * 
+ * Clue arrays will be W*H `signed char's, and the clue at each
+ * point will be a number from 0 to 4, or -1 if there's no clue.
+ * 
+ * Solution arrays will be W*H `signed char's, and the number at
+ * each point will be +1 for a forward slash (/), -1 for a
+ * backslash (\), and 0 for unknown.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_INK,
+    COL_SLANT1,
+    COL_SLANT2,
+    COL_ERROR,
+    COL_CURSOR,
+    COL_FILLEDSQUARE,
+    NCOLOURS
+};
+
+/*
+ * In standalone solver mode, `verbose' is a variable which can be
+ * set by command-line option; in debugging mode it's simply always
+ * true.
+ */
+#if defined STANDALONE_SOLVER
+#define SOLVER_DIAGNOSTICS
+int verbose = FALSE;
+#elif defined SOLVER_DIAGNOSTICS
+#define verbose TRUE
+#endif
+
+/*
+ * Difficulty levels. I do some macro ickery here to ensure that my
+ * enum and the various forms of my name list always match up.
+ */
+#define DIFFLIST(A) \
+    A(EASY,Easy,e) \
+    A(HARD,Hard,h)
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const slant_diffnames[] = { DIFFLIST(TITLE) };
+static char const slant_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+struct game_params {
+    int w, h, diff;
+};
+
+typedef struct game_clues {
+    int w, h;
+    signed char *clues;
+    int *tmpdsf;
+    int refcount;
+} game_clues;
+
+#define ERR_VERTEX 1
+#define ERR_SQUARE 2
+
+struct game_state {
+    struct game_params p;
+    game_clues *clues;
+    signed char *soln;
+    unsigned char *errors;
+    int completed;
+    int used_solve;                    /* used to suppress completion flash */
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 8;
+    ret->diff = DIFF_EASY;
+
+    return ret;
+}
+
+static const struct game_params slant_presets[] = {
+    {5, 5, DIFF_EASY},
+    {5, 5, DIFF_HARD},
+    {8, 8, DIFF_EASY},
+    {8, 8, DIFF_HARD},
+    {12, 10, DIFF_EASY},
+    {12, 10, DIFF_HARD},
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(slant_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = slant_presets[i];
+
+    sprintf(str, "%dx%d %s", ret->w, ret->h, slant_diffnames[ret->diff]);
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        ret->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 'd') {
+        int i;
+        string++;
+        for (i = 0; i < DIFFCOUNT; i++)
+            if (*string == slant_diffchars[i])
+                ret->diff = i;
+        if (*string) string++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    sprintf(data, "%dx%d", params->w, params->h);
+    if (full)
+        sprintf(data + strlen(data), "d%c", slant_diffchars[params->diff]);
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Difficulty";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = DIFFCONFIG;
+    ret[2].ival = params->diff;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->diff = cfg[2].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    /*
+     * (At least at the time of writing this comment) The grid
+     * generator is actually capable of handling even zero grid
+     * dimensions without crashing. Puzzles with a zero-area grid
+     * are a bit boring, though, because they're already solved :-)
+     * And puzzles with a dimension of 1 can't be made Hard, which
+     * means the simplest thing is to forbid them altogether.
+     */
+
+    if (params->w < 2 || params->h < 2)
+        return "Width and height must both be at least two";
+
+    return NULL;
+}
+
+/*
+ * Scratch space for solver.
+ */
+struct solver_scratch {
+    /*
+     * Disjoint set forest which tracks the connected sets of
+     * points.
+     */
+    int *connected;
+
+    /*
+     * Counts the number of possible exits from each connected set
+     * of points. (That is, the number of possible _simultaneous_
+     * exits: an unconnected point labelled 2 has an exit count of
+     * 2 even if all four possible edges are still under
+     * consideration.)
+     */
+    int *exits;
+
+    /*
+     * Tracks whether each connected set of points includes a
+     * border point.
+     */
+    unsigned char *border;
+
+    /*
+     * Another disjoint set forest. This one tracks _squares_ which
+     * are known to slant in the same direction.
+     */
+    int *equiv;
+
+    /*
+     * Stores slash values which we know for an equivalence class.
+     * When we fill in a square, we set slashval[canonify(x)] to
+     * the same value as soln[x], so that we can then spot other
+     * squares equivalent to it and fill them in immediately via
+     * their known equivalence.
+     */
+    signed char *slashval;
+
+    /*
+     * Stores possible v-shapes. This array is w by h in size, but
+     * not every bit of every entry is meaningful. The bits mean:
+     * 
+     *  - bit 0 for a square means that that square and the one to
+     *    its right might form a v-shape between them
+     *  - bit 1 for a square means that that square and the one to
+     *    its right might form a ^-shape between them
+     *  - bit 2 for a square means that that square and the one
+     *    below it might form a >-shape between them
+     *  - bit 3 for a square means that that square and the one
+     *    below it might form a <-shape between them
+     * 
+     * Any starting 1 or 3 clue rules out four bits in this array
+     * immediately; a 2 clue propagates any ruled-out bit past it
+     * (if the two squares on one side of a 2 cannot be a v-shape,
+     * then neither can the two on the other side be the same
+     * v-shape); we can rule out further bits during play using
+     * partially filled 2 clues; whenever a pair of squares is
+     * known not to be _either_ kind of v-shape, we can mark them
+     * as equivalent.
+     */
+    unsigned char *vbitmap;
+
+    /*
+     * Useful to have this information automatically passed to
+     * solver subroutines. (This pointer is not dynamically
+     * allocated by new_scratch and free_scratch.)
+     */
+    const signed char *clues;
+};
+
+static struct solver_scratch *new_scratch(int w, int h)
+{
+    int W = w+1, H = h+1;
+    struct solver_scratch *ret = snew(struct solver_scratch);
+    ret->connected = snewn(W*H, int);
+    ret->exits = snewn(W*H, int);
+    ret->border = snewn(W*H, unsigned char);
+    ret->equiv = snewn(w*h, int);
+    ret->slashval = snewn(w*h, signed char);
+    ret->vbitmap = snewn(w*h, unsigned char);
+    return ret;
+}
+
+static void free_scratch(struct solver_scratch *sc)
+{
+    sfree(sc->vbitmap);
+    sfree(sc->slashval);
+    sfree(sc->equiv);
+    sfree(sc->border);
+    sfree(sc->exits);
+    sfree(sc->connected);
+    sfree(sc);
+}
+
+/*
+ * Wrapper on dsf_merge() which updates the `exits' and `border'
+ * arrays.
+ */
+static void merge_vertices(int *connected,
+                           struct solver_scratch *sc, int i, int j)
+{
+    int exits = -1, border = FALSE;    /* initialise to placate optimiser */
+
+    if (sc) {
+        i = dsf_canonify(connected, i);
+        j = dsf_canonify(connected, j);
+
+        /*
+         * We have used one possible exit from each of the two
+         * classes. Thus, the viable exit count of the new class is
+         * the sum of the old exit counts minus two.
+         */
+        exits = sc->exits[i] + sc->exits[j] - 2;
+
+        border = sc->border[i] || sc->border[j];
+    }
+
+    dsf_merge(connected, i, j);
+
+    if (sc) {
+        i = dsf_canonify(connected, i);
+        sc->exits[i] = exits;
+        sc->border[i] = border;
+    }
+}
+
+/*
+ * Called when we have just blocked one way out of a particular
+ * point. If that point is a non-clue point (thus has a variable
+ * number of exits), we have therefore decreased its potential exit
+ * count, so we must decrement the exit count for the group as a
+ * whole.
+ */
+static void decr_exits(struct solver_scratch *sc, int i)
+{
+    if (sc->clues[i] < 0) {
+        i = dsf_canonify(sc->connected, i);
+        sc->exits[i]--;
+    }
+}
+
+static void fill_square(int w, int h, int x, int y, int v,
+                        signed char *soln,
+                        int *connected, struct solver_scratch *sc)
+{
+    int W = w+1 /*, H = h+1 */;
+
+    assert(x >= 0 && x < w && y >= 0 && y < h);
+
+    if (soln[y*w+x] != 0) {
+        return;                        /* do nothing */
+    }
+
+#ifdef SOLVER_DIAGNOSTICS
+    if (verbose)
+        printf("  placing %c in %d,%d\n", v == -1 ? '\\' : '/', x, y);
+#endif
+
+    soln[y*w+x] = v;
+
+    if (sc) {
+        int c = dsf_canonify(sc->equiv, y*w+x);
+        sc->slashval[c] = v;
+    }
+
+    if (v < 0) {
+        merge_vertices(connected, sc, y*W+x, (y+1)*W+(x+1));
+        if (sc) {
+            decr_exits(sc, y*W+(x+1));
+            decr_exits(sc, (y+1)*W+x);
+        }
+    } else {
+        merge_vertices(connected, sc, y*W+(x+1), (y+1)*W+x);
+        if (sc) {
+            decr_exits(sc, y*W+x);
+            decr_exits(sc, (y+1)*W+(x+1));
+        }
+    }
+}
+
+static int vbitmap_clear(int w, int h, struct solver_scratch *sc,
+                         int x, int y, int vbits, char *reason, ...)
+{
+    int done_something = FALSE;
+    int vbit;
+
+    for (vbit = 1; vbit <= 8; vbit <<= 1)
+        if (vbits & sc->vbitmap[y*w+x] & vbit) {
+            done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+            if (verbose) {
+                va_list ap;
+
+                printf("ruling out %c shape at (%d,%d)-(%d,%d) (",
+                       "!v^!>!!!<"[vbit], x, y,
+                       x+((vbit&0x3)!=0), y+((vbit&0xC)!=0));
+
+                va_start(ap, reason);
+                vprintf(reason, ap);
+                va_end(ap);
+
+                printf(")\n");
+            }
+#endif
+            sc->vbitmap[y*w+x] &= ~vbit;
+        }
+
+    return done_something;
+}
+
+/*
+ * Solver. Returns 0 for impossibility, 1 for success, 2 for
+ * ambiguity or failure to converge.
+ */
+static int slant_solve(int w, int h, const signed char *clues,
+                       signed char *soln, struct solver_scratch *sc,
+                       int difficulty)
+{
+    int W = w+1, H = h+1;
+    int x, y, i, j;
+    int done_something;
+
+    /*
+     * Clear the output.
+     */
+    memset(soln, 0, w*h);
+
+    sc->clues = clues;
+
+    /*
+     * Establish a disjoint set forest for tracking connectedness
+     * between grid points.
+     */
+    dsf_init(sc->connected, W*H);
+
+    /*
+     * Establish a disjoint set forest for tracking which squares
+     * are known to slant in the same direction.
+     */
+    dsf_init(sc->equiv, w*h);
+
+    /*
+     * Clear the slashval array.
+     */
+    memset(sc->slashval, 0, w*h);
+
+    /*
+     * Set up the vbitmap array. Initially all types of v are possible.
+     */
+    memset(sc->vbitmap, 0xF, w*h);
+
+    /*
+     * Initialise the `exits' and `border' arrays. These are used
+     * to do second-order loop avoidance: the dual of the no loops
+     * constraint is that every point must be somehow connected to
+     * the border of the grid (otherwise there would be a solid
+     * loop around it which prevented this).
+     * 
+     * I define a `dead end' to be a connected group of points
+     * which contains no border point, and which can form at most
+     * one new connection outside itself. Then I forbid placing an
+     * edge so that it connects together two dead-end groups, since
+     * this would yield a non-border-connected isolated subgraph
+     * with no further scope to extend it.
+     */
+    for (y = 0; y < H; y++)
+        for (x = 0; x < W; x++) {
+            if (y == 0 || y == H-1 || x == 0 || x == W-1)
+                sc->border[y*W+x] = TRUE;
+            else
+                sc->border[y*W+x] = FALSE;
+
+            if (clues[y*W+x] < 0)
+                sc->exits[y*W+x] = 4;
+            else
+                sc->exits[y*W+x] = clues[y*W+x];
+        }
+
+    /*
+     * Repeatedly try to deduce something until we can't.
+     */
+    do {
+        done_something = FALSE;
+
+        /*
+         * Any clue point with the number of remaining lines equal
+         * to zero or to the number of remaining undecided
+         * neighbouring squares can be filled in completely.
+         */
+        for (y = 0; y < H; y++)
+            for (x = 0; x < W; x++) {
+                struct {
+                    int pos, slash;
+                } neighbours[4];
+                int nneighbours;
+                int nu, nl, c, s, eq, eq2, last, meq, mj1, mj2;
+
+                if ((c = clues[y*W+x]) < 0)
+                    continue;
+
+                /*
+                 * We have a clue point. Start by listing its
+                 * neighbouring squares, in order around the point,
+                 * together with the type of slash that would be
+                 * required in that square to connect to the point.
+                 */
+                nneighbours = 0;
+                if (x > 0 && y > 0) {
+                    neighbours[nneighbours].pos = (y-1)*w+(x-1);
+                    neighbours[nneighbours].slash = -1;
+                    nneighbours++;
+                }
+                if (x > 0 && y < h) {
+                    neighbours[nneighbours].pos = y*w+(x-1);
+                    neighbours[nneighbours].slash = +1;
+                    nneighbours++;
+                }
+                if (x < w && y < h) {
+                    neighbours[nneighbours].pos = y*w+x;
+                    neighbours[nneighbours].slash = -1;
+                    nneighbours++;
+                }
+                if (x < w && y > 0) {
+                    neighbours[nneighbours].pos = (y-1)*w+x;
+                    neighbours[nneighbours].slash = +1;
+                    nneighbours++;
+                }
+
+                /*
+                 * Count up the number of undecided neighbours, and
+                 * also the number of lines already present.
+                 *
+                 * If we're not on DIFF_EASY, then in this loop we
+                 * also track whether we've seen two adjacent empty
+                 * squares belonging to the same equivalence class
+                 * (meaning they have the same type of slash). If
+                 * so, we count them jointly as one line.
+                 */
+                nu = 0;
+                nl = c;
+                last = neighbours[nneighbours-1].pos;
+                if (soln[last] == 0)
+                    eq = dsf_canonify(sc->equiv, last);
+                else
+                    eq = -1;
+                meq = mj1 = mj2 = -1;
+                for (i = 0; i < nneighbours; i++) {
+                    j = neighbours[i].pos;
+                    s = neighbours[i].slash;
+                    if (soln[j] == 0) {
+                        nu++;          /* undecided */
+                        if (meq < 0 && difficulty > DIFF_EASY) {
+                            eq2 = dsf_canonify(sc->equiv, j);
+                            if (eq == eq2 && last != j) {
+                                /*
+                                 * We've found an equivalent pair.
+                                 * Mark it. This also inhibits any
+                                 * further equivalence tracking
+                                 * around this square, since we can
+                                 * only handle one pair (and in
+                                 * particular we want to avoid
+                                 * being misled by two overlapping
+                                 * equivalence pairs).
+                                 */
+                                meq = eq;
+                                mj1 = last;
+                                mj2 = j;
+                                nl--;   /* count one line */
+                                nu -= 2;   /* and lose two undecideds */
+                            } else
+                                eq = eq2;
+                        }
+                    } else {
+                        eq = -1;
+                        if (soln[j] == s)
+                            nl--;      /* here's a line */
+                    }
+                    last = j;
+                }
+
+                /*
+                 * Check the counts.
+                 */
+                if (nl < 0 || nl > nu) {
+                    /*
+                     * No consistent value for this at all!
+                     */
+#ifdef SOLVER_DIAGNOSTICS
+                    if (verbose)
+                        printf("need %d / %d lines around clue point at %d,%d!\n",
+                               nl, nu, x, y);
+#endif
+                    return 0;          /* impossible */
+                }
+
+                if (nu > 0 && (nl == 0 || nl == nu)) {
+#ifdef SOLVER_DIAGNOSTICS
+                    if (verbose) {
+                        if (meq >= 0)
+                            printf("partially (since %d,%d == %d,%d) ",
+                                   mj1%w, mj1/w, mj2%w, mj2/w);
+                        printf("%s around clue point at %d,%d\n",
+                               nl ? "filling" : "emptying", x, y);
+                    }
+#endif
+                    for (i = 0; i < nneighbours; i++) {
+                        j = neighbours[i].pos;
+                        s = neighbours[i].slash;
+                        if (soln[j] == 0 && j != mj1 && j != mj2)
+                            fill_square(w, h, j%w, j/w, (nl ? s : -s), soln,
+                                        sc->connected, sc);
+                    }
+
+                    done_something = TRUE;
+                } else if (nu == 2 && nl == 1 && difficulty > DIFF_EASY) {
+                    /*
+                     * If we have precisely two undecided squares
+                     * and precisely one line to place between
+                     * them, _and_ those squares are adjacent, then
+                     * we can mark them as equivalent to one
+                     * another.
+                     * 
+                     * This even applies if meq >= 0: if we have a
+                     * 2 clue point and two of its neighbours are
+                     * already marked equivalent, we can indeed
+                     * mark the other two as equivalent.
+                     * 
+                     * We don't bother with this on DIFF_EASY,
+                     * since we wouldn't have used the results
+                     * anyway.
+                     */
+                    last = -1;
+                    for (i = 0; i < nneighbours; i++) {
+                        j = neighbours[i].pos;
+                        if (soln[j] == 0 && j != mj1 && j != mj2) {
+                            if (last < 0)
+                                last = i;
+                            else if (last == i-1 || (last == 0 && i == 3))
+                                break; /* found a pair */
+                        }
+                    }
+                    if (i < nneighbours) {
+                        int sv1, sv2;
+
+                        assert(last >= 0);
+                        /*
+                         * neighbours[last] and neighbours[i] are
+                         * the pair. Mark them equivalent.
+                         */
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose) {
+                            if (meq >= 0)
+                                printf("since %d,%d == %d,%d, ",
+                                       mj1%w, mj1/w, mj2%w, mj2/w);
+                        }
+#endif
+                        mj1 = neighbours[last].pos;
+                        mj2 = neighbours[i].pos;
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose)
+                            printf("clue point at %d,%d implies %d,%d == %d,"
+                                   "%d\n", x, y, mj1%w, mj1/w, mj2%w, mj2/w);
+#endif
+                        mj1 = dsf_canonify(sc->equiv, mj1);
+                        sv1 = sc->slashval[mj1];
+                        mj2 = dsf_canonify(sc->equiv, mj2);
+                        sv2 = sc->slashval[mj2];
+                        if (sv1 != 0 && sv2 != 0 && sv1 != sv2) {
+#ifdef SOLVER_DIAGNOSTICS
+                            if (verbose)
+                                printf("merged two equivalence classes with"
+                                       " different slash values!\n");
+#endif
+                            return 0;
+                        }
+                        sv1 = sv1 ? sv1 : sv2;
+                        dsf_merge(sc->equiv, mj1, mj2);
+                        mj1 = dsf_canonify(sc->equiv, mj1);
+                        sc->slashval[mj1] = sv1;
+                    }
+                }
+            }
+
+        if (done_something)
+            continue;
+
+        /*
+         * Failing that, we now apply the second condition, which
+         * is that no square may be filled in such a way as to form
+         * a loop. Also in this loop (since it's over squares
+         * rather than points), we check slashval to see if we've
+         * already filled in another square in the same equivalence
+         * class.
+         * 
+         * The slashval check is disabled on DIFF_EASY, as is dead
+         * end avoidance. Only _immediate_ loop avoidance remains.
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++) {
+                int fs, bs, v;
+                int c1, c2;
+#ifdef SOLVER_DIAGNOSTICS
+                char *reason = "<internal error>";
+#endif
+
+                if (soln[y*w+x])
+                    continue;          /* got this one already */
+
+                fs = FALSE;
+                bs = FALSE;
+
+                if (difficulty > DIFF_EASY)
+                    v = sc->slashval[dsf_canonify(sc->equiv, y*w+x)];
+                else
+                    v = 0;
+
+                /*
+                 * Try to rule out connectivity between (x,y) and
+                 * (x+1,y+1); if successful, we will deduce that we
+                 * must have a forward slash.
+                 */
+                c1 = dsf_canonify(sc->connected, y*W+x);
+                c2 = dsf_canonify(sc->connected, (y+1)*W+(x+1));
+                if (c1 == c2) {
+                    fs = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                    reason = "simple loop avoidance";
+#endif
+                }
+                if (difficulty > DIFF_EASY &&
+                    !sc->border[c1] && !sc->border[c2] &&
+                    sc->exits[c1] <= 1 && sc->exits[c2] <= 1) {
+                    fs = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                    reason = "dead end avoidance";
+#endif
+                }
+                if (v == +1) {
+                    fs = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                    reason = "equivalence to an already filled square";
+#endif
+                }
+
+                /*
+                 * Now do the same between (x+1,y) and (x,y+1), to
+                 * see if we are required to have a backslash.
+                 */
+                c1 = dsf_canonify(sc->connected, y*W+(x+1));
+                c2 = dsf_canonify(sc->connected, (y+1)*W+x);
+                if (c1 == c2) {
+                    bs = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                    reason = "simple loop avoidance";
+#endif
+                }
+                if (difficulty > DIFF_EASY &&
+                    !sc->border[c1] && !sc->border[c2] &&
+                    sc->exits[c1] <= 1 && sc->exits[c2] <= 1) {
+                    bs = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                    reason = "dead end avoidance";
+#endif
+                }
+                if (v == -1) {
+                    bs = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                    reason = "equivalence to an already filled square";
+#endif
+                }
+
+                if (fs && bs) {
+                    /*
+                     * No consistent value for this at all!
+                     */
+#ifdef SOLVER_DIAGNOSTICS
+                    if (verbose)
+                        printf("%d,%d has no consistent slash!\n", x, y);
+#endif
+                    return 0;          /* impossible */
+                }
+
+                if (fs) {
+#ifdef SOLVER_DIAGNOSTICS
+                    if (verbose)
+                        printf("employing %s\n", reason);
+#endif
+                    fill_square(w, h, x, y, +1, soln, sc->connected, sc);
+                    done_something = TRUE;
+                } else if (bs) {
+#ifdef SOLVER_DIAGNOSTICS
+                    if (verbose)
+                        printf("employing %s\n", reason);
+#endif
+                    fill_square(w, h, x, y, -1, soln, sc->connected, sc);
+                    done_something = TRUE;
+                }
+            }
+
+        if (done_something)
+            continue;
+
+        /*
+         * Now see what we can do with the vbitmap array. All
+         * vbitmap deductions are disabled at Easy level.
+         */
+        if (difficulty <= DIFF_EASY)
+            continue;
+
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++) {
+                int s, c;
+
+                /*
+                 * Any line already placed in a square must rule
+                 * out any type of v which contradicts it.
+                 */
+                if ((s = soln[y*w+x]) != 0) {
+                    if (x > 0)
+                        done_something |=
+                        vbitmap_clear(w, h, sc, x-1, y, (s < 0 ? 0x1 : 0x2),
+                                      "contradicts known edge at (%d,%d)",x,y);
+                    if (x+1 < w)
+                        done_something |=
+                        vbitmap_clear(w, h, sc, x, y, (s < 0 ? 0x2 : 0x1),
+                                      "contradicts known edge at (%d,%d)",x,y);
+                    if (y > 0)
+                        done_something |=
+                        vbitmap_clear(w, h, sc, x, y-1, (s < 0 ? 0x4 : 0x8),
+                                      "contradicts known edge at (%d,%d)",x,y);
+                    if (y+1 < h)
+                        done_something |=
+                        vbitmap_clear(w, h, sc, x, y, (s < 0 ? 0x8 : 0x4),
+                                      "contradicts known edge at (%d,%d)",x,y);
+                }
+
+                /*
+                 * If both types of v are ruled out for a pair of
+                 * adjacent squares, mark them as equivalent.
+                 */
+                if (x+1 < w && !(sc->vbitmap[y*w+x] & 0x3)) {
+                    int n1 = y*w+x, n2 = y*w+(x+1);
+                    if (dsf_canonify(sc->equiv, n1) !=
+                        dsf_canonify(sc->equiv, n2)) {
+                        dsf_merge(sc->equiv, n1, n2);
+                        done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose)
+                            printf("(%d,%d) and (%d,%d) must be equivalent"
+                                   " because both v-shapes are ruled out\n",
+                                   x, y, x+1, y);
+#endif
+                    }
+                }
+                if (y+1 < h && !(sc->vbitmap[y*w+x] & 0xC)) {
+                    int n1 = y*w+x, n2 = (y+1)*w+x;
+                    if (dsf_canonify(sc->equiv, n1) !=
+                        dsf_canonify(sc->equiv, n2)) {
+                        dsf_merge(sc->equiv, n1, n2);
+                        done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose)
+                            printf("(%d,%d) and (%d,%d) must be equivalent"
+                                   " because both v-shapes are ruled out\n",
+                                   x, y, x, y+1);
+#endif
+                    }
+                }
+
+                /*
+                 * The remaining work in this loop only works
+                 * around non-edge clue points.
+                 */
+                if (y == 0 || x == 0)
+                    continue;
+                if ((c = clues[y*W+x]) < 0)
+                    continue;
+
+                /*
+                 * x,y marks a clue point not on the grid edge. See
+                 * if this clue point allows us to rule out any v
+                 * shapes.
+                 */
+
+                if (c == 1) {
+                    /*
+                     * A 1 clue can never have any v shape pointing
+                     * at it.
+                     */
+                    done_something |=
+                        vbitmap_clear(w, h, sc, x-1, y-1, 0x5,
+                                      "points at 1 clue at (%d,%d)", x, y);
+                    done_something |=
+                        vbitmap_clear(w, h, sc, x-1, y, 0x2,
+                                      "points at 1 clue at (%d,%d)", x, y);
+                    done_something |=
+                        vbitmap_clear(w, h, sc, x, y-1, 0x8,
+                                      "points at 1 clue at (%d,%d)", x, y);
+                } else if (c == 3) {
+                    /*
+                     * A 3 clue can never have any v shape pointing
+                     * away from it.
+                     */
+                    done_something |=
+                        vbitmap_clear(w, h, sc, x-1, y-1, 0xA,
+                                      "points away from 3 clue at (%d,%d)", x, y);
+                    done_something |=
+                        vbitmap_clear(w, h, sc, x-1, y, 0x1,
+                                      "points away from 3 clue at (%d,%d)", x, y);
+                    done_something |=
+                        vbitmap_clear(w, h, sc, x, y-1, 0x4,
+                                      "points away from 3 clue at (%d,%d)", x, y);
+                } else if (c == 2) {
+                    /*
+                     * If a 2 clue has any kind of v ruled out on
+                     * one side of it, the same v is ruled out on
+                     * the other side.
+                     */
+                    done_something |=
+                        vbitmap_clear(w, h, sc, x-1, y-1,
+                                      (sc->vbitmap[(y  )*w+(x-1)] & 0x3) ^ 0x3,
+                                      "propagated by 2 clue at (%d,%d)", x, y);
+                    done_something |=
+                        vbitmap_clear(w, h, sc, x-1, y-1,
+                                      (sc->vbitmap[(y-1)*w+(x  )] & 0xC) ^ 0xC,
+                                      "propagated by 2 clue at (%d,%d)", x, y);
+                    done_something |=
+                        vbitmap_clear(w, h, sc, x-1, y,
+                                      (sc->vbitmap[(y-1)*w+(x-1)] & 0x3) ^ 0x3,
+                                      "propagated by 2 clue at (%d,%d)", x, y);
+                    done_something |=
+                        vbitmap_clear(w, h, sc, x, y-1,
+                                      (sc->vbitmap[(y-1)*w+(x-1)] & 0xC) ^ 0xC,
+                                      "propagated by 2 clue at (%d,%d)", x, y);
+                }
+
+#undef CLEARBITS
+
+            }
+
+    } while (done_something);
+
+    /*
+     * Solver can make no more progress. See if the grid is full.
+     */
+    for (i = 0; i < w*h; i++)
+        if (!soln[i])
+            return 2;                  /* failed to converge */
+    return 1;                          /* success */
+}
+
+/*
+ * Filled-grid generator.
+ */
+static void slant_generate(int w, int h, signed char *soln, random_state *rs)
+{
+    int W = w+1, H = h+1;
+    int x, y, i;
+    int *connected, *indices;
+
+    /*
+     * Clear the output.
+     */
+    memset(soln, 0, w*h);
+
+    /*
+     * Establish a disjoint set forest for tracking connectedness
+     * between grid points.
+     */
+    connected = snew_dsf(W*H);
+
+    /*
+     * Prepare a list of the squares in the grid, and fill them in
+     * in a random order.
+     */
+    indices = snewn(w*h, int);
+    for (i = 0; i < w*h; i++)
+        indices[i] = i;
+    shuffle(indices, w*h, sizeof(*indices), rs);
+
+    /*
+     * Fill in each one in turn.
+     */
+    for (i = 0; i < w*h; i++) {
+        int fs, bs, v;
+
+        y = indices[i] / w;
+        x = indices[i] % w;
+
+        fs = (dsf_canonify(connected, y*W+x) ==
+              dsf_canonify(connected, (y+1)*W+(x+1)));
+        bs = (dsf_canonify(connected, (y+1)*W+x) ==
+              dsf_canonify(connected, y*W+(x+1)));
+
+        /*
+         * It isn't possible to get into a situation where we
+         * aren't allowed to place _either_ type of slash in a
+         * square. Thus, filled-grid generation never has to
+         * backtrack.
+         * 
+         * Proof (thanks to Gareth Taylor):
+         * 
+         * If it were possible, it would have to be because there
+         * was an existing path (not using this square) between the
+         * top-left and bottom-right corners of this square, and
+         * another between the other two. These two paths would
+         * have to cross at some point.
+         * 
+         * Obviously they can't cross in the middle of a square, so
+         * they must cross by sharing a point in common. But this
+         * isn't possible either: if you chessboard-colour all the
+         * points on the grid, you find that any continuous
+         * diagonal path is entirely composed of points of the same
+         * colour. And one of our two hypothetical paths is between
+         * two black points, and the other is between two white
+         * points - therefore they can have no point in common. []
+         */
+        assert(!(fs && bs));
+
+        v = fs ? +1 : bs ? -1 : 2 * random_upto(rs, 2) - 1;
+        fill_square(w, h, x, y, v, soln, connected, NULL);
+    }
+
+    sfree(indices);
+    sfree(connected);
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, h = params->h, W = w+1, H = h+1;
+    signed char *soln, *tmpsoln, *clues;
+    int *clueindices;
+    struct solver_scratch *sc;
+    int x, y, v, i, j;
+    char *desc;
+
+    soln = snewn(w*h, signed char);
+    tmpsoln = snewn(w*h, signed char);
+    clues = snewn(W*H, signed char);
+    clueindices = snewn(W*H, int);
+    sc = new_scratch(w, h);
+
+    do {
+        /*
+         * Create the filled grid.
+         */
+        slant_generate(w, h, soln, rs);
+
+        /*
+         * Fill in the complete set of clues.
+         */
+        for (y = 0; y < H; y++)
+            for (x = 0; x < W; x++) {
+                v = 0;
+
+                if (x > 0 && y > 0 && soln[(y-1)*w+(x-1)] == -1) v++;
+                if (x > 0 && y < h && soln[y*w+(x-1)] == +1) v++;
+                if (x < w && y > 0 && soln[(y-1)*w+x] == +1) v++;
+                if (x < w && y < h && soln[y*w+x] == -1) v++;
+
+                clues[y*W+x] = v;
+            }
+
+        /*
+         * With all clue points filled in, all puzzles are easy: we can
+         * simply process the clue points in lexicographic order, and
+         * at each clue point we will always have at most one square
+         * undecided, which we can then fill in uniquely.
+         */
+        assert(slant_solve(w, h, clues, tmpsoln, sc, DIFF_EASY) == 1);
+
+        /*
+         * Remove as many clues as possible while retaining solubility.
+         *
+         * In DIFF_HARD mode, we prioritise the removal of obvious
+         * starting points (4s, 0s, border 2s and corner 1s), on
+         * the grounds that having as few of these as possible
+         * seems like a good thing. In particular, we can often get
+         * away without _any_ completely obvious starting points,
+         * which is even better.
+         */
+        for (i = 0; i < W*H; i++)
+            clueindices[i] = i;
+        shuffle(clueindices, W*H, sizeof(*clueindices), rs);
+        for (j = 0; j < 2; j++) {
+            for (i = 0; i < W*H; i++) {
+                int pass, yb, xb;
+
+                y = clueindices[i] / W;
+                x = clueindices[i] % W;
+                v = clues[y*W+x];
+
+                /*
+                 * Identify which pass we should process this point
+                 * in. If it's an obvious start point, _or_ we're
+                 * in DIFF_EASY, then it goes in pass 0; otherwise
+                 * pass 1.
+                 */
+                xb = (x == 0 || x == W-1);
+                yb = (y == 0 || y == H-1);
+                if (params->diff == DIFF_EASY || v == 4 || v == 0 ||
+                    (v == 2 && (xb||yb)) || (v == 1 && xb && yb))
+                    pass = 0;
+                else
+                    pass = 1;
+
+                if (pass == j) {
+                    clues[y*W+x] = -1;
+                    if (slant_solve(w, h, clues, tmpsoln, sc,
+                                    params->diff) != 1)
+                        clues[y*W+x] = v;              /* put it back */
+                }
+            }
+        }
+
+        /*
+         * And finally, verify that the grid is of _at least_ the
+         * requested difficulty, by running the solver one level
+         * down and verifying that it can't manage it.
+         */
+    } while (params->diff > 0 &&
+             slant_solve(w, h, clues, tmpsoln, sc, params->diff - 1) <= 1);
+
+    /*
+     * Now we have the clue set as it will be presented to the
+     * user. Encode it in a game desc.
+     */
+    {
+        char *p;
+        int run, i;
+
+        desc = snewn(W*H+1, char);
+        p = desc;
+        run = 0;
+        for (i = 0; i <= W*H; i++) {
+            int n = (i < W*H ? clues[i] : -2);
+
+            if (n == -1)
+                run++;
+            else {
+                if (run) {
+                    while (run > 0) {
+                        int c = 'a' - 1 + run;
+                        if (run > 26)
+                            c = 'z';
+                        *p++ = c;
+                        run -= c - ('a' - 1);
+                    }
+                }
+                if (n >= 0)
+                    *p++ = '0' + n;
+                run = 0;
+            }
+        }
+        assert(p - desc <= W*H);
+        *p++ = '\0';
+        desc = sresize(desc, p - desc, char);
+    }
+
+    /*
+     * Encode the solution as an aux_info.
+     */
+    {
+        char *auxbuf;
+        *aux = auxbuf = snewn(w*h+1, char);
+        for (i = 0; i < w*h; i++)
+            auxbuf[i] = soln[i] < 0 ? '\\' : '/';
+        auxbuf[w*h] = '\0';
+    }
+
+    free_scratch(sc);
+    sfree(clueindices);
+    sfree(clues);
+    sfree(tmpsoln);
+    sfree(soln);
+
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, h = params->h, W = w+1, H = h+1;
+    int area = W*H;
+    int squares = 0;
+
+    while (*desc) {
+        int n = *desc++;
+        if (n >= 'a' && n <= 'z') {
+            squares += n - 'a' + 1;
+        } else if (n >= '0' && n <= '4') {
+            squares++;
+        } else
+            return "Invalid character in game description";
+    }
+
+    if (squares < area)
+        return "Not enough data to fill grid";
+
+    if (squares > area)
+        return "Too much data to fit in grid";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, h = params->h, W = w+1, H = h+1;
+    game_state *state = snew(game_state);
+    int area = W*H;
+    int squares = 0;
+
+    state->p = *params;
+    state->soln = snewn(w*h, signed char);
+    memset(state->soln, 0, w*h);
+    state->completed = state->used_solve = FALSE;
+    state->errors = snewn(W*H, unsigned char);
+    memset(state->errors, 0, W*H);
+
+    state->clues = snew(game_clues);
+    state->clues->w = w;
+    state->clues->h = h;
+    state->clues->clues = snewn(W*H, signed char);
+    state->clues->refcount = 1;
+    state->clues->tmpdsf = snewn(W*H*2+W+H, int);
+    memset(state->clues->clues, -1, W*H);
+    while (*desc) {
+        int n = *desc++;
+        if (n >= 'a' && n <= 'z') {
+            squares += n - 'a' + 1;
+        } else if (n >= '0' && n <= '4') {
+            state->clues->clues[squares++] = n - '0';
+        } else
+            assert(!"can't get here");
+    }
+    assert(squares == area);
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
+    game_state *ret = snew(game_state);
+
+    ret->p = state->p;
+    ret->clues = state->clues;
+    ret->clues->refcount++;
+    ret->completed = state->completed;
+    ret->used_solve = state->used_solve;
+
+    ret->soln = snewn(w*h, signed char);
+    memcpy(ret->soln, state->soln, w*h);
+
+    ret->errors = snewn(W*H, unsigned char);
+    memcpy(ret->errors, state->errors, W*H);
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->errors);
+    sfree(state->soln);
+    assert(state->clues);
+    if (--state->clues->refcount <= 0) {
+        sfree(state->clues->clues);
+        sfree(state->clues->tmpdsf);
+        sfree(state->clues);
+    }
+    sfree(state);
+}
+
+/*
+ * Utility function to return the current degree of a vertex. If
+ * `anti' is set, it returns the number of filled-in edges
+ * surrounding the point which _don't_ connect to it; thus 4 minus
+ * its anti-degree is the maximum degree it could have if all the
+ * empty spaces around it were filled in.
+ * 
+ * (Yes, _4_ minus its anti-degree even if it's a border vertex.)
+ * 
+ * If ret > 0, *sx and *sy are set to the coordinates of one of the
+ * squares that contributed to it.
+ */
+static int vertex_degree(int w, int h, signed char *soln, int x, int y,
+                         int anti, int *sx, int *sy)
+{
+    int ret = 0;
+
+    assert(x >= 0 && x <= w && y >= 0 && y <= h);
+    if (x > 0 && y > 0 && soln[(y-1)*w+(x-1)] - anti < 0) {
+        if (sx) *sx = x-1;
+        if (sy) *sy = y-1;
+        ret++;
+    }
+    if (x > 0 && y < h && soln[y*w+(x-1)] + anti > 0) {
+        if (sx) *sx = x-1;
+        if (sy) *sy = y;
+        ret++;
+    }
+    if (x < w && y > 0 && soln[(y-1)*w+x] + anti > 0) {
+        if (sx) *sx = x;
+        if (sy) *sy = y-1;
+        ret++;
+    }
+    if (x < w && y < h && soln[y*w+x] - anti < 0) {
+        if (sx) *sx = x;
+        if (sy) *sy = y;
+        ret++;
+    }
+
+    return anti ? 4 - ret : ret;
+}
+
+struct slant_neighbour_ctx {
+    const game_state *state;
+    int i, n, neighbours[4];
+};
+static int slant_neighbour(int vertex, void *vctx)
+{
+    struct slant_neighbour_ctx *ctx = (struct slant_neighbour_ctx *)vctx;
+
+    if (vertex >= 0) {
+        int w = ctx->state->p.w, h = ctx->state->p.h, W = w+1;
+        int x = vertex % W, y = vertex / W;
+        ctx->n = ctx->i = 0;
+        if (x < w && y < h && ctx->state->soln[y*w+x] < 0)
+            ctx->neighbours[ctx->n++] = (y+1)*W+(x+1);
+        if (x > 0 && y > 0 && ctx->state->soln[(y-1)*w+(x-1)] < 0)
+            ctx->neighbours[ctx->n++] = (y-1)*W+(x-1);
+        if (x > 0 && y < h && ctx->state->soln[y*w+(x-1)] > 0)
+            ctx->neighbours[ctx->n++] = (y+1)*W+(x-1);
+        if (x < w && y > 0 && ctx->state->soln[(y-1)*w+x] > 0)
+            ctx->neighbours[ctx->n++] = (y-1)*W+(x+1);
+    }
+
+    if (ctx->i < ctx->n)
+        return ctx->neighbours[ctx->i++];
+    else
+        return -1;
+}
+
+static int check_completion(game_state *state)
+{
+    int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
+    int x, y, err = FALSE;
+
+    memset(state->errors, 0, W*H);
+
+    /*
+     * Detect and error-highlight loops in the grid.
+     */
+    {
+        struct findloopstate *fls = findloop_new_state(W*H);
+        struct slant_neighbour_ctx ctx;
+        ctx.state = state;
+
+        if (findloop_run(fls, W*H, slant_neighbour, &ctx))
+            err = TRUE;
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                int u, v;
+                if (state->soln[y*w+x] == 0) {
+                    continue;
+                } else if (state->soln[y*w+x] > 0) {
+                    u = y*W+(x+1);
+                    v = (y+1)*W+x;
+                } else {
+                    u = (y+1)*W+(x+1);
+                    v = y*W+x;
+                }
+                if (findloop_is_loop_edge(fls, u, v))
+                    state->errors[y*W+x] |= ERR_SQUARE;
+            }
+        }
+
+        findloop_free_state(fls);
+    }
+
+    /*
+     * Now go through and check the degree of each clue vertex, and
+     * mark it with ERR_VERTEX if it cannot be fulfilled.
+     */
+    for (y = 0; y < H; y++)
+        for (x = 0; x < W; x++) {
+            int c;
+
+            if ((c = state->clues->clues[y*W+x]) < 0)
+                continue;
+
+            /*
+             * Check to see if there are too many connections to
+             * this vertex _or_ too many non-connections. Either is
+             * grounds for marking the vertex as erroneous.
+             */
+            if (vertex_degree(w, h, state->soln, x, y,
+                              FALSE, NULL, NULL) > c ||
+                vertex_degree(w, h, state->soln, x, y,
+                              TRUE, NULL, NULL) > 4-c) {
+                state->errors[y*W+x] |= ERR_VERTEX;
+                err = TRUE;
+            }
+        }
+
+    /*
+     * Now our actual victory condition is that (a) none of the
+     * above code marked anything as erroneous, and (b) every
+     * square has an edge in it.
+     */
+
+    if (err)
+        return FALSE;
+
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            if (state->soln[y*w+x] == 0)
+                return FALSE;
+
+    return TRUE;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int w = state->p.w, h = state->p.h;
+    signed char *soln;
+    int bs, ret;
+    int free_soln = FALSE;
+    char *move, buf[80];
+    int movelen, movesize;
+    int x, y;
+
+    if (aux) {
+        /*
+         * If we already have the solution, save ourselves some
+         * time.
+         */
+        soln = (signed char *)aux;
+        bs = (signed char)'\\';
+        free_soln = FALSE;
+    } else {
+        struct solver_scratch *sc = new_scratch(w, h);
+        soln = snewn(w*h, signed char);
+        bs = -1;
+        ret = slant_solve(w, h, state->clues->clues, soln, sc, DIFF_HARD);
+        free_scratch(sc);
+        if (ret != 1) {
+            sfree(soln);
+            if (ret == 0)
+                *error = "This puzzle is not self-consistent";
+            else
+                *error = "Unable to find a unique solution for this puzzle";
+            return NULL;
+        }
+        free_soln = TRUE;
+    }
+
+    /*
+     * Construct a move string which turns the current state into
+     * the solved state.
+     */
+    movesize = 256;
+    move = snewn(movesize, char);
+    movelen = 0;
+    move[movelen++] = 'S';
+    move[movelen] = '\0';
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int v = (soln[y*w+x] == bs ? -1 : +1);
+            if (state->soln[y*w+x] != v) {
+                int len = sprintf(buf, ";%c%d,%d", (int)(v < 0 ? '\\' : '/'), x, y);
+                if (movelen + len >= movesize) {
+                    movesize = movelen + len + 256;
+                    move = sresize(move, movesize, char);
+                }
+                strcpy(move + movelen, buf);
+                movelen += len;
+            }
+        }
+
+    if (free_soln)
+        sfree(soln);
+
+    return move;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
+    int x, y, len;
+    char *ret, *p;
+
+    /*
+     * There are h+H rows of w+W columns.
+     */
+    len = (h+H) * (w+W+1) + 1;
+    ret = snewn(len, char);
+    p = ret;
+
+    for (y = 0; y < H; y++) {
+        for (x = 0; x < W; x++) {
+            if (state->clues->clues[y*W+x] >= 0)
+                *p++ = state->clues->clues[y*W+x] + '0';
+            else
+                *p++ = '+';
+            if (x < w)
+                *p++ = '-';
+        }
+        *p++ = '\n';
+        if (y < h) {
+            for (x = 0; x < W; x++) {
+                *p++ = '|';
+                if (x < w) {
+                    if (state->soln[y*w+x] != 0)
+                        *p++ = (state->soln[y*w+x] < 0 ? '\\' : '/');
+                    else
+                        *p++ = ' ';
+                }
+            }
+            *p++ = '\n';
+        }
+    }
+    *p++ = '\0';
+
+    assert(p - ret == len);
+    return ret;
+}
+
+struct game_ui {
+    int cur_x, cur_y, cur_visible;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->cur_x = ui->cur_y = ui->cur_visible = 0;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+#define PREFERRED_TILESIZE 32
+#define TILESIZE (ds->tilesize)
+#define BORDER TILESIZE
+#define CLUE_RADIUS (TILESIZE / 3)
+#define CLUE_TEXTSIZE (TILESIZE / 2)
+#define COORD(x)  ( (x) * TILESIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILESIZE) / TILESIZE - 1 )
+
+#define FLASH_TIME 0.30F
+
+/*
+ * Bit fields in the `grid' and `todraw' elements of the drawstate.
+ */
+#define BACKSLASH 0x00000001L
+#define FORWSLASH 0x00000002L
+#define L_T       0x00000004L
+#define ERR_L_T   0x00000008L
+#define L_B       0x00000010L
+#define ERR_L_B   0x00000020L
+#define T_L       0x00000040L
+#define ERR_T_L   0x00000080L
+#define T_R       0x00000100L
+#define ERR_T_R   0x00000200L
+#define C_TL      0x00000400L
+#define ERR_C_TL  0x00000800L
+#define FLASH     0x00001000L
+#define ERRSLASH  0x00002000L
+#define ERR_TL    0x00004000L
+#define ERR_TR    0x00008000L
+#define ERR_BL    0x00010000L
+#define ERR_BR    0x00020000L
+#define CURSOR    0x00040000L
+
+struct game_drawstate {
+    int tilesize;
+    int started;
+    long *grid;
+    long *todraw;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->p.w, h = state->p.h;
+    int v;
+    char buf[80];
+    enum { CLOCKWISE, ANTICLOCKWISE, NONE } action = NONE;
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        /*
+         * This is an utterly awful hack which I should really sort out
+         * by means of a proper configuration mechanism. One Slant
+         * player has observed that they prefer the mouse buttons to
+         * function exactly the opposite way round, so here's a
+         * mechanism for environment-based configuration. I cache the
+         * result in a global variable - yuck! - to avoid repeated
+         * lookups.
+         */
+        {
+            static int swap_buttons = -1;
+            if (swap_buttons < 0) {
+                char *env = getenv("SLANT_SWAP_BUTTONS");
+                swap_buttons = (env && (env[0] == 'y' || env[0] == 'Y'));
+            }
+            if (swap_buttons) {
+                if (button == LEFT_BUTTON)
+                    button = RIGHT_BUTTON;
+                else
+                    button = LEFT_BUTTON;
+            }
+        }
+        action = (button == LEFT_BUTTON) ? CLOCKWISE : ANTICLOCKWISE;
+
+        x = FROMCOORD(x);
+        y = FROMCOORD(y);
+        if (x < 0 || y < 0 || x >= w || y >= h)
+            return NULL;
+        ui->cur_visible = 0;
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (!ui->cur_visible) {
+            ui->cur_visible = 1;
+            return "";
+        }
+        x = ui->cur_x;
+        y = ui->cur_y;
+
+        action = (button == CURSOR_SELECT2) ? ANTICLOCKWISE : CLOCKWISE;
+    } else if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->cur_x, &ui->cur_y, w, h, 0);
+        ui->cur_visible = 1;
+        return "";
+    } else if (button == '\\' || button == '\b' || button == '/') {
+        int x = ui->cur_x, y = ui->cur_y;
+        if (button == ("\\" "\b" "/")[state->soln[y*w + x] + 1]) return NULL;
+        sprintf(buf, "%c%d,%d", button == '\b' ? 'C' : button, x, y);
+        return dupstr(buf);
+    }
+
+    if (action != NONE) {
+        if (action == CLOCKWISE) {
+            /*
+             * Left-clicking cycles blank -> \ -> / -> blank.
+             */
+            v = state->soln[y*w+x] - 1;
+            if (v == -2)
+                v = +1;
+        } else {
+            /*
+             * Right-clicking cycles blank -> / -> \ -> blank.
+             */
+            v = state->soln[y*w+x] + 1;
+            if (v == +2)
+                v = -1;
+        }
+
+        sprintf(buf, "%c%d,%d", (int)(v==-1 ? '\\' : v==+1 ? '/' : 'C'), x, y);
+        return dupstr(buf);
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int w = state->p.w, h = state->p.h;
+    char c;
+    int x, y, n;
+    game_state *ret = dup_game(state);
+
+    while (*move) {
+        c = *move;
+        if (c == 'S') {
+            ret->used_solve = TRUE;
+            move++;
+        } else if (c == '\\' || c == '/' || c == 'C') {
+            move++;
+            if (sscanf(move, "%d,%d%n", &x, &y, &n) != 2 ||
+                x < 0 || y < 0 || x >= w || y >= h) {
+                free_game(ret);
+                return NULL;
+            }
+            ret->soln[y*w+x] = (c == '\\' ? -1 : c == '/' ? +1 : 0);
+            move += n;
+        } else {
+            free_game(ret);
+            return NULL;
+        }
+        if (*move == ';')
+            move++;
+        else if (*move) {
+            free_game(ret);
+            return NULL;
+        }
+    }
+
+    /*
+     * We never clear the `completed' flag, but we must always
+     * re-run the completion check because it also highlights
+     * errors in the grid.
+     */
+    ret->completed = check_completion(ret) || ret->completed;
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* fool the macros */
+    struct dummy { int tilesize; } dummy, *ds = &dummy;
+    dummy.tilesize = tilesize;
+
+    *x = 2 * BORDER + params->w * TILESIZE + 1;
+    *y = 2 * BORDER + params->h * TILESIZE + 1;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    /* CURSOR colour is a background highlight. */
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_CURSOR, -1);
+
+    ret[COL_FILLEDSQUARE * 3 + 0] = ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_FILLEDSQUARE * 3 + 1] = ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_FILLEDSQUARE * 3 + 2] = ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_GRID * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.7F;
+    ret[COL_GRID * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 0.7F;
+    ret[COL_GRID * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 0.7F;
+
+    ret[COL_INK * 3 + 0] = 0.0F;
+    ret[COL_INK * 3 + 1] = 0.0F;
+    ret[COL_INK * 3 + 2] = 0.0F;
+
+    ret[COL_SLANT1 * 3 + 0] = 0.0F;
+    ret[COL_SLANT1 * 3 + 1] = 0.0F;
+    ret[COL_SLANT1 * 3 + 2] = 0.0F;
+
+    ret[COL_SLANT2 * 3 + 0] = 0.0F;
+    ret[COL_SLANT2 * 3 + 1] = 0.0F;
+    ret[COL_SLANT2 * 3 + 2] = 0.0F;
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int w = state->p.w, h = state->p.h;
+    int i;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->tilesize = 0;
+    ds->started = FALSE;
+    ds->grid = snewn((w+2)*(h+2), long);
+    ds->todraw = snewn((w+2)*(h+2), long);
+    for (i = 0; i < (w+2)*(h+2); i++)
+        ds->grid[i] = ds->todraw[i] = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->todraw);
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+static void draw_clue(drawing *dr, game_drawstate *ds,
+                      int x, int y, long v, long err, int bg, int colour)
+{
+    char p[2];
+    int ccol = colour >= 0 ? colour : ((x ^ y) & 1) ? COL_SLANT1 : COL_SLANT2;
+    int tcol = colour >= 0 ? colour : err ? COL_ERROR : COL_INK;
+
+    if (v < 0)
+        return;
+
+    p[0] = (char)v + '0';
+    p[1] = '\0';
+    draw_circle(dr, COORD(x), COORD(y), CLUE_RADIUS,
+                bg >= 0 ? bg : COL_BACKGROUND, ccol);
+    draw_text(dr, COORD(x), COORD(y), FONT_VARIABLE,
+              CLUE_TEXTSIZE, ALIGN_VCENTRE|ALIGN_HCENTRE, tcol, p);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds, game_clues *clues,
+                      int x, int y, long v)
+{
+    int w = clues->w, h = clues->h, W = w+1 /*, H = h+1 */;
+    int chesscolour = (x ^ y) & 1;
+    int fscol = chesscolour ? COL_SLANT2 : COL_SLANT1;
+    int bscol = chesscolour ? COL_SLANT1 : COL_SLANT2;
+
+    clip(dr, COORD(x), COORD(y), TILESIZE, TILESIZE);
+
+    draw_rect(dr, COORD(x), COORD(y), TILESIZE, TILESIZE,
+              (v & FLASH) ? COL_GRID :
+              (v & CURSOR) ? COL_CURSOR :
+              (v & (BACKSLASH | FORWSLASH)) ? COL_FILLEDSQUARE :
+              COL_BACKGROUND);
+
+    /*
+     * Draw the grid lines.
+     */
+    if (x >= 0 && x < w && y >= 0)
+        draw_rect(dr, COORD(x), COORD(y), TILESIZE+1, 1, COL_GRID);
+    if (x >= 0 && x < w && y < h)
+        draw_rect(dr, COORD(x), COORD(y+1), TILESIZE+1, 1, COL_GRID);
+    if (y >= 0 && y < h && x >= 0)
+        draw_rect(dr, COORD(x), COORD(y), 1, TILESIZE+1, COL_GRID);
+    if (y >= 0 && y < h && x < w)
+        draw_rect(dr, COORD(x+1), COORD(y), 1, TILESIZE+1, COL_GRID);
+    if (x == -1 && y == -1)
+        draw_rect(dr, COORD(x+1), COORD(y+1), 1, 1, COL_GRID);
+    if (x == -1 && y == h)
+        draw_rect(dr, COORD(x+1), COORD(y), 1, 1, COL_GRID);
+    if (x == w && y == -1)
+        draw_rect(dr, COORD(x), COORD(y+1), 1, 1, COL_GRID);
+    if (x == w && y == h)
+        draw_rect(dr, COORD(x), COORD(y), 1, 1, COL_GRID);
+
+    /*
+     * Draw the slash.
+     */
+    if (v & BACKSLASH) {
+        int scol = (v & ERRSLASH) ? COL_ERROR : bscol;
+        draw_line(dr, COORD(x), COORD(y), COORD(x+1), COORD(y+1), scol);
+        draw_line(dr, COORD(x)+1, COORD(y), COORD(x+1), COORD(y+1)-1,
+                  scol);
+        draw_line(dr, COORD(x), COORD(y)+1, COORD(x+1)-1, COORD(y+1),
+                  scol);
+    } else if (v & FORWSLASH) {
+        int scol = (v & ERRSLASH) ? COL_ERROR : fscol;
+        draw_line(dr, COORD(x+1), COORD(y), COORD(x), COORD(y+1), scol);
+        draw_line(dr, COORD(x+1)-1, COORD(y), COORD(x), COORD(y+1)-1,
+                  scol);
+        draw_line(dr, COORD(x+1), COORD(y)+1, COORD(x)+1, COORD(y+1),
+                  scol);
+    }
+
+    /*
+     * Draw dots on the grid corners that appear if a slash is in a
+     * neighbouring cell.
+     */
+    if (v & (L_T | BACKSLASH))
+        draw_rect(dr, COORD(x), COORD(y)+1, 1, 1,
+                  (v & ERR_L_T ? COL_ERROR : bscol));
+    if (v & (L_B | FORWSLASH))
+        draw_rect(dr, COORD(x), COORD(y+1)-1, 1, 1,
+                  (v & ERR_L_B ? COL_ERROR : fscol));
+    if (v & (T_L | BACKSLASH))
+        draw_rect(dr, COORD(x)+1, COORD(y), 1, 1,
+                  (v & ERR_T_L ? COL_ERROR : bscol));
+    if (v & (T_R | FORWSLASH))
+        draw_rect(dr, COORD(x+1)-1, COORD(y), 1, 1,
+                  (v & ERR_T_R ? COL_ERROR : fscol));
+    if (v & (C_TL | BACKSLASH))
+        draw_rect(dr, COORD(x), COORD(y), 1, 1,
+                  (v & ERR_C_TL ? COL_ERROR : bscol));
+
+    /*
+     * And finally the clues at the corners.
+     */
+    if (x >= 0 && y >= 0)
+        draw_clue(dr, ds, x, y, clues->clues[y*W+x], v & ERR_TL, -1, -1);
+    if (x < w && y >= 0)
+        draw_clue(dr, ds, x+1, y, clues->clues[y*W+(x+1)], v & ERR_TR, -1, -1);
+    if (x >= 0 && y < h)
+        draw_clue(dr, ds, x, y+1, clues->clues[(y+1)*W+x], v & ERR_BL, -1, -1);
+    if (x < w && y < h)
+        draw_clue(dr, ds, x+1, y+1, clues->clues[(y+1)*W+(x+1)], v & ERR_BR,
+                  -1, -1);
+
+    unclip(dr);
+    draw_update(dr, COORD(x), COORD(y), TILESIZE, TILESIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
+    int x, y;
+    int flashing;
+
+    if (flashtime > 0)
+        flashing = (int)(flashtime * 3 / FLASH_TIME) != 1;
+    else
+        flashing = FALSE;
+
+    if (!ds->started) {
+        int ww, wh;
+        game_compute_size(&state->p, TILESIZE, &ww, &wh);
+        draw_rect(dr, 0, 0, ww, wh, COL_BACKGROUND);
+        draw_update(dr, 0, 0, ww, wh);
+        ds->started = TRUE;
+    }
+
+    /*
+     * Loop over the grid and work out where all the slashes are.
+     * We need to do this because a slash in one square affects the
+     * drawing of the next one along.
+     */
+    for (y = -1; y <= h; y++)
+        for (x = -1; x <= w; x++) {
+            if (x >= 0 && x < w && y >= 0 && y < h)
+                ds->todraw[(y+1)*(w+2)+(x+1)] = flashing ? FLASH : 0;
+            else
+                ds->todraw[(y+1)*(w+2)+(x+1)] = 0;
+        }
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            int err = state->errors[y*W+x] & ERR_SQUARE;
+
+            if (state->soln[y*w+x] < 0) {
+                ds->todraw[(y+1)*(w+2)+(x+1)] |= BACKSLASH;
+                ds->todraw[(y+2)*(w+2)+(x+1)] |= T_R;
+                ds->todraw[(y+1)*(w+2)+(x+2)] |= L_B;
+                ds->todraw[(y+2)*(w+2)+(x+2)] |= C_TL;
+                if (err) {
+                    ds->todraw[(y+1)*(w+2)+(x+1)] |= ERRSLASH | 
+                        ERR_T_L | ERR_L_T | ERR_C_TL;
+                    ds->todraw[(y+2)*(w+2)+(x+1)] |= ERR_T_R;
+                    ds->todraw[(y+1)*(w+2)+(x+2)] |= ERR_L_B;
+                    ds->todraw[(y+2)*(w+2)+(x+2)] |= ERR_C_TL;
+                }
+            } else if (state->soln[y*w+x] > 0) {
+                ds->todraw[(y+1)*(w+2)+(x+1)] |= FORWSLASH;
+                ds->todraw[(y+1)*(w+2)+(x+2)] |= L_T | C_TL;
+                ds->todraw[(y+2)*(w+2)+(x+1)] |= T_L | C_TL;
+                if (err) {
+                    ds->todraw[(y+1)*(w+2)+(x+1)] |= ERRSLASH |
+                        ERR_L_B | ERR_T_R;
+                    ds->todraw[(y+1)*(w+2)+(x+2)] |= ERR_L_T | ERR_C_TL;
+                    ds->todraw[(y+2)*(w+2)+(x+1)] |= ERR_T_L | ERR_C_TL;
+                }
+            }
+            if (ui->cur_visible && ui->cur_x == x && ui->cur_y == y)
+                ds->todraw[(y+1)*(w+2)+(x+1)] |= CURSOR;
+        }
+    }
+
+    for (y = 0; y < H; y++)
+        for (x = 0; x < W; x++)
+            if (state->errors[y*W+x] & ERR_VERTEX) {
+                ds->todraw[y*(w+2)+x] |= ERR_BR;
+                ds->todraw[y*(w+2)+(x+1)] |= ERR_BL;
+                ds->todraw[(y+1)*(w+2)+x] |= ERR_TR;
+                ds->todraw[(y+1)*(w+2)+(x+1)] |= ERR_TL;
+            }
+
+    /*
+     * Now go through and draw the grid squares.
+     */
+    for (y = -1; y <= h; y++) {
+        for (x = -1; x <= w; x++) {
+            if (ds->todraw[(y+1)*(w+2)+(x+1)] != ds->grid[(y+1)*(w+2)+(x+1)]) {
+                draw_tile(dr, ds, state->clues, x, y,
+                          ds->todraw[(y+1)*(w+2)+(x+1)]);
+                ds->grid[(y+1)*(w+2)+(x+1)] = ds->todraw[(y+1)*(w+2)+(x+1)];
+            }
+        }
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->used_solve && !newstate->used_solve)
+        return FLASH_TIME;
+
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 6mm squares by default.
+     */
+    game_compute_size(params, 600, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->p.w, h = state->p.h, W = w+1;
+    int ink = print_mono_colour(dr, 0);
+    int paper = print_mono_colour(dr, 1);
+    int x, y;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    /*
+     * Border.
+     */
+    print_line_width(dr, TILESIZE / 16);
+    draw_rect_outline(dr, COORD(0), COORD(0), w*TILESIZE, h*TILESIZE, ink);
+
+    /*
+     * Grid.
+     */
+    print_line_width(dr, TILESIZE / 24);
+    for (x = 1; x < w; x++)
+        draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h), ink);
+    for (y = 1; y < h; y++)
+        draw_line(dr, COORD(0), COORD(y), COORD(w), COORD(y), ink);
+
+    /*
+     * Solution.
+     */
+    print_line_width(dr, TILESIZE / 12);
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            if (state->soln[y*w+x]) {
+                int ly, ry;
+                /*
+                 * To prevent nasty line-ending artefacts at
+                 * corners, I'll do something slightly cunning
+                 * here.
+                 */
+                clip(dr, COORD(x), COORD(y), TILESIZE, TILESIZE);
+                if (state->soln[y*w+x] < 0)
+                    ly = y-1, ry = y+2;
+                else
+                    ry = y-1, ly = y+2;
+                draw_line(dr, COORD(x-1), COORD(ly), COORD(x+2), COORD(ry),
+                          ink);
+                unclip(dr);
+            }
+
+    /*
+     * Clues.
+     */
+    print_line_width(dr, TILESIZE / 24);
+    for (y = 0; y <= h; y++)
+        for (x = 0; x <= w; x++)
+            draw_clue(dr, ds, x, y, state->clues->clues[y*W+x],
+                      FALSE, paper, ink);
+}
+
+#ifdef COMBINED
+#define thegame slant
+#endif
+
+const struct game thegame = {
+    "Slant", "games.slant", "slant",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+#include <stdarg.h>
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err;
+    int grade = FALSE;
+    int ret, diff, really_verbose = FALSE;
+    struct solver_scratch *sc;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            really_verbose = TRUE;
+        } else if (!strcmp(p, "-g")) {
+            grade = TRUE;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-g | -v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    sc = new_scratch(p->w, p->h);
+
+    /*
+     * When solving an Easy puzzle, we don't want to bother the
+     * user with Hard-level deductions. For this reason, we grade
+     * the puzzle internally before doing anything else.
+     */
+    ret = -1;                          /* placate optimiser */
+    for (diff = 0; diff < DIFFCOUNT; diff++) {
+        ret = slant_solve(p->w, p->h, s->clues->clues,
+                          s->soln, sc, diff);
+        if (ret < 2)
+            break;
+    }
+
+    if (diff == DIFFCOUNT) {
+        if (grade)
+            printf("Difficulty rating: harder than Hard, or ambiguous\n");
+        else
+            printf("Unable to find a unique solution\n");
+    } else {
+        if (grade) {
+            if (ret == 0)
+                printf("Difficulty rating: impossible (no solution exists)\n");
+            else if (ret == 1)
+                printf("Difficulty rating: %s\n", slant_diffnames[diff]);
+        } else {
+            verbose = really_verbose;
+            ret = slant_solve(p->w, p->h, s->clues->clues,
+                              s->soln, sc, diff);
+            if (ret == 0)
+                printf("Puzzle is inconsistent\n");
+            else
+                fputs(game_text_format(s), stdout);
+        }
+    }
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/solo.R b/apps/plugins/puzzles/solo.R
new file mode 100644
index 0000000000..081a76147e
--- /dev/null
+++ b/apps/plugins/puzzles/solo.R
@@ -0,0 +1,24 @@
+# -*- makefile -*-
+
+SOLO_EXTRA = divvy dsf
+
+solo     : [X] GTK COMMON solo SOLO_EXTRA solo-icon|no-icon
+
+solo     : [G] WINDOWS COMMON solo SOLO_EXTRA solo.res|noicon.res
+
+solosolver :    [U] solo[STANDALONE_SOLVER] SOLO_EXTRA STANDALONE
+solosolver :    [C] solo[STANDALONE_SOLVER] SOLO_EXTRA STANDALONE
+
+ALL += solo[COMBINED] SOLO_EXTRA
+
+!begin am gtk
+GAMES += solo
+!end
+
+!begin >list.c
+    A(solo) \
+!end
+
+!begin >gamedesc.txt
+solo:solo.exe:Solo:Number placement puzzle:Fill in the grid so that each row, column and square block contains one of every digit.
+!end
diff --git a/apps/plugins/puzzles/solo.c b/apps/plugins/puzzles/solo.c
new file mode 100644
index 0000000000..26f0eddd1a
--- /dev/null
+++ b/apps/plugins/puzzles/solo.c
@@ -0,0 +1,5656 @@
+/*
+ * solo.c: the number-placing puzzle most popularly known as `Sudoku'.
+ *
+ * TODO:
+ *
+ *  - reports from users are that `Trivial'-mode puzzles are still
+ *    rather hard compared to newspapers' easy ones, so some better
+ *    low-end difficulty grading would be nice
+ *     + it's possible that really easy puzzles always have
+ *       _several_ things you can do, so don't make you hunt too
+ *       hard for the one deduction you can currently make
+ *     + it's also possible that easy puzzles require fewer
+ *       cross-eliminations: perhaps there's a higher incidence of
+ *       things you can deduce by looking only at (say) rows,
+ *       rather than things you have to check both rows and columns
+ *       for
+ *     + but really, what I need to do is find some really easy
+ *       puzzles and _play_ them, to see what's actually easy about
+ *       them
+ *     + while I'm revamping this area, filling in the _last_
+ *       number in a nearly-full row or column should certainly be
+ *       permitted even at the lowest difficulty level.
+ *     + also Owen noticed that `Basic' grids requiring numeric
+ *       elimination are actually very hard, so I wonder if a
+ *       difficulty gradation between that and positional-
+ *       elimination-only might be in order
+ *     + but it's not good to have _too_ many difficulty levels, or
+ *       it'll take too long to randomly generate a given level.
+ * 
+ *  - it might still be nice to do some prioritisation on the
+ *    removal of numbers from the grid
+ *     + one possibility is to try to minimise the maximum number
+ *       of filled squares in any block, which in particular ought
+ *       to enforce never leaving a completely filled block in the
+ *       puzzle as presented.
+ *
+ *  - alternative interface modes
+ *     + sudoku.com's Windows program has a palette of possible
+ *       entries; you select a palette entry first and then click
+ *       on the square you want it to go in, thus enabling
+ *       mouse-only play. Useful for PDAs! I don't think it's
+ *       actually incompatible with the current highlight-then-type
+ *       approach: you _either_ highlight a palette entry and then
+ *       click, _or_ you highlight a square and then type. At most
+ *       one thing is ever highlighted at a time, so there's no way
+ *       to confuse the two.
+ *     + then again, I don't actually like sudoku.com's interface;
+ *       it's too much like a paint package whereas I prefer to
+ *       think of Solo as a text editor.
+ *     + another PDA-friendly possibility is a drag interface:
+ *       _drag_ numbers from the palette into the grid squares.
+ *       Thought experiments suggest I'd prefer that to the
+ *       sudoku.com approach, but I haven't actually tried it.
+ */
+
+/*
+ * Solo puzzles need to be square overall (since each row and each
+ * column must contain one of every digit), but they need not be
+ * subdivided the same way internally. I am going to adopt a
+ * convention whereby I _always_ refer to `r' as the number of rows
+ * of _big_ divisions, and `c' as the number of columns of _big_
+ * divisions. Thus, a 2c by 3r puzzle looks something like this:
+ *
+ *   4 5 1 | 2 6 3
+ *   6 3 2 | 5 4 1
+ *   ------+------     (Of course, you can't subdivide it the other way
+ *   1 4 5 | 6 3 2     or you'll get clashes; observe that the 4 in the
+ *   3 2 6 | 4 1 5     top left would conflict with the 4 in the second
+ *   ------+------     box down on the left-hand side.)
+ *   5 1 4 | 3 2 6
+ *   2 6 3 | 1 5 4
+ *
+ * The need for a strong naming convention should now be clear:
+ * each small box is two rows of digits by three columns, while the
+ * overall puzzle has three rows of small boxes by two columns. So
+ * I will (hopefully) consistently use `r' to denote the number of
+ * rows _of small boxes_ (here 3), which is also the number of
+ * columns of digits in each small box; and `c' vice versa (here
+ * 2).
+ *
+ * I'm also going to choose arbitrarily to list c first wherever
+ * possible: the above is a 2x3 puzzle, not a 3x2 one.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#ifdef STANDALONE_SOLVER
+#include <stdarg.h>
+int solver_show_working, solver_recurse_depth;
+#endif
+
+#include "puzzles.h"
+
+/*
+ * To save space, I store digits internally as unsigned char. This
+ * imposes a hard limit of 255 on the order of the puzzle. Since
+ * even a 5x5 takes unacceptably long to generate, I don't see this
+ * as a serious limitation unless something _really_ impressive
+ * happens in computing technology; but here's a typedef anyway for
+ * general good practice.
+ */
+typedef unsigned char digit;
+#define ORDER_MAX 255
+
+#define PREFERRED_TILE_SIZE 48
+#define TILE_SIZE (ds->tilesize)
+#define BORDER (TILE_SIZE / 2)
+#define GRIDEXTRA max((TILE_SIZE / 32),1)
+
+#define FLASH_TIME 0.4F
+
+enum { SYMM_NONE, SYMM_ROT2, SYMM_ROT4, SYMM_REF2, SYMM_REF2D, SYMM_REF4,
+       SYMM_REF4D, SYMM_REF8 };
+
+enum { DIFF_BLOCK,
+       DIFF_SIMPLE, DIFF_INTERSECT, DIFF_SET, DIFF_EXTREME, DIFF_RECURSIVE,
+       DIFF_AMBIGUOUS, DIFF_IMPOSSIBLE };
+
+enum { DIFF_KSINGLE, DIFF_KMINMAX, DIFF_KSUMS, DIFF_KINTERSECT };
+
+enum {
+    COL_BACKGROUND,
+    COL_XDIAGONALS,
+    COL_GRID,
+    COL_CLUE,
+    COL_USER,
+    COL_HIGHLIGHT,
+    COL_ERROR,
+    COL_PENCIL,
+    COL_KILLER,
+    NCOLOURS
+};
+
+/*
+ * To determine all possible ways to reach a given sum by adding two or
+ * three numbers from 1..9, each of which occurs exactly once in the sum,
+ * these arrays contain a list of bitmasks for each sum value, where if
+ * bit N is set, it means that N occurs in the sum.  Each list is
+ * terminated by a zero if it is shorter than the size of the array.
+ */
+#define MAX_2SUMS 5
+#define MAX_3SUMS 8
+#define MAX_4SUMS 12
+unsigned long sum_bits2[18][MAX_2SUMS];
+unsigned long sum_bits3[25][MAX_3SUMS];
+unsigned long sum_bits4[31][MAX_4SUMS];
+
+static int find_sum_bits(unsigned long *array, int idx, int value_left,
+                         int addends_left, int min_addend,
+                         unsigned long bitmask_so_far)
+{
+    int i;
+    assert(addends_left >= 2);
+
+    for (i = min_addend; i < value_left; i++) {
+        unsigned long new_bitmask = bitmask_so_far | (1L << i);
+        assert(bitmask_so_far != new_bitmask);
+
+        if (addends_left == 2) {
+            int j = value_left - i;
+            if (j <= i)
+                break;
+            if (j > 9)
+                continue;
+            array[idx++] = new_bitmask | (1L << j);
+        } else
+            idx = find_sum_bits(array, idx, value_left - i,
+                                addends_left - 1, i + 1,
+                                new_bitmask);
+    }
+    return idx;
+}
+
+static void precompute_sum_bits(void)
+{
+    int i;
+    for (i = 3; i < 31; i++) {
+        int j;
+        if (i < 18) {
+            j = find_sum_bits(sum_bits2[i], 0, i, 2, 1, 0);
+            assert (j <= MAX_2SUMS);
+            if (j < MAX_2SUMS)
+                sum_bits2[i][j] = 0;
+        }
+        if (i < 25) {
+            j = find_sum_bits(sum_bits3[i], 0, i, 3, 1, 0);
+            assert (j <= MAX_3SUMS);
+            if (j < MAX_3SUMS)
+                sum_bits3[i][j] = 0;
+        }
+        j = find_sum_bits(sum_bits4[i], 0, i, 4, 1, 0);
+        assert (j <= MAX_4SUMS);
+        if (j < MAX_4SUMS)
+            sum_bits4[i][j] = 0;
+    }
+}
+
+struct game_params {
+    /*
+     * For a square puzzle, `c' and `r' indicate the puzzle
+     * parameters as described above.
+     * 
+     * A jigsaw-style puzzle is indicated by r==1, in which case c
+     * can be whatever it likes (there is no constraint on
+     * compositeness - a 7x7 jigsaw sudoku makes perfect sense).
+     */
+    int c, r, symm, diff, kdiff;
+    int xtype;                         /* require all digits in X-diagonals */
+    int killer;
+};
+
+struct block_structure {
+    int refcount;
+
+    /*
+     * For text formatting, we do need c and r here.
+     */
+    int c, r, area;
+
+    /*
+     * For any square index, whichblock[i] gives its block index.
+     *
+     * For 0 <= b,i < cr, blocks[b][i] gives the index of the ith
+     * square in block b.  nr_squares[b] gives the number of squares
+     * in block b (also the number of valid elements in blocks[b]).
+     *
+     * blocks_data holds the data pointed to by blocks.
+     *
+     * nr_squares may be NULL for block structures where all blocks are
+     * the same size.
+     */
+    int *whichblock, **blocks, *nr_squares, *blocks_data;
+    int nr_blocks, max_nr_squares;
+
+#ifdef STANDALONE_SOLVER
+    /*
+     * Textual descriptions of each block. For normal Sudoku these
+     * are of the form "(1,3)"; for jigsaw they are "starting at
+     * (5,7)". So the sensible usage in both cases is to say
+     * "elimination within block %s" with one of these strings.
+     * 
+     * Only blocknames itself needs individually freeing; it's all
+     * one block.
+     */
+    char **blocknames;
+#endif
+};
+
+struct game_state {
+    /*
+     * For historical reasons, I use `cr' to denote the overall
+     * width/height of the puzzle. It was a natural notation when
+     * all puzzles were divided into blocks in a grid, but doesn't
+     * really make much sense given jigsaw puzzles. However, the
+     * obvious `n' is heavily used in the solver to describe the
+     * index of a number being placed, so `cr' will have to stay.
+     */
+    int cr;
+    struct block_structure *blocks;
+    struct block_structure *kblocks;   /* Blocks for killer puzzles.  */
+    int xtype, killer;
+    digit *grid, *kgrid;
+    unsigned char *pencil;             /* c*r*c*r elements */
+    unsigned char *immutable;          /* marks which digits are clues */
+    int completed, cheated;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->c = ret->r = 3;
+    ret->xtype = FALSE;
+    ret->killer = FALSE;
+    ret->symm = SYMM_ROT2;             /* a plausible default */
+    ret->diff = DIFF_BLOCK;            /* so is this */
+    ret->kdiff = DIFF_KINTERSECT;      /* so is this */
+
+    return ret;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    static struct {
+        char *title;
+        game_params params;
+    } presets[] = {
+        { "2x2 Trivial", { 2, 2, SYMM_ROT2, DIFF_BLOCK, DIFF_KMINMAX, FALSE, FALSE } },
+        { "2x3 Basic", { 2, 3, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, FALSE, FALSE } },
+        { "3x3 Trivial", { 3, 3, SYMM_ROT2, DIFF_BLOCK, DIFF_KMINMAX, FALSE, FALSE } },
+        { "3x3 Basic", { 3, 3, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, FALSE, FALSE } },
+        { "3x3 Basic X", { 3, 3, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, TRUE } },
+        { "3x3 Intermediate", { 3, 3, SYMM_ROT2, DIFF_INTERSECT, DIFF_KMINMAX, FALSE, FALSE } },
+        { "3x3 Advanced", { 3, 3, SYMM_ROT2, DIFF_SET, DIFF_KMINMAX, FALSE, FALSE } },
+        { "3x3 Advanced X", { 3, 3, SYMM_ROT2, DIFF_SET, DIFF_KMINMAX, TRUE } },
+        { "3x3 Extreme", { 3, 3, SYMM_ROT2, DIFF_EXTREME, DIFF_KMINMAX, FALSE, FALSE } },
+        { "3x3 Unreasonable", { 3, 3, SYMM_ROT2, DIFF_RECURSIVE, DIFF_KMINMAX, FALSE, FALSE } },
+        { "3x3 Killer", { 3, 3, SYMM_NONE, DIFF_BLOCK, DIFF_KINTERSECT, FALSE, TRUE } },
+        { "9 Jigsaw Basic", { 9, 1, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, FALSE, FALSE } },
+        { "9 Jigsaw Basic X", { 9, 1, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, TRUE } },
+        { "9 Jigsaw Advanced", { 9, 1, SYMM_ROT2, DIFF_SET, DIFF_KMINMAX, FALSE, FALSE } },
+#ifndef SLOW_SYSTEM
+        { "3x4 Basic", { 3, 4, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, FALSE, FALSE } },
+        { "4x4 Basic", { 4, 4, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, FALSE, FALSE } },
+#endif
+    };
+
+    if (i < 0 || i >= lenof(presets))
+        return FALSE;
+
+    *name = dupstr(presets[i].title);
+    *params = dup_params(&presets[i].params);
+
+    return TRUE;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    int seen_r = FALSE;
+
+    ret->c = ret->r = atoi(string);
+    ret->xtype = FALSE;
+    ret->killer = FALSE;
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        ret->r = atoi(string);
+        seen_r = TRUE;
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    while (*string) {
+        if (*string == 'j') {
+            string++;
+            if (seen_r)
+                ret->c *= ret->r;
+            ret->r = 1;
+        } else if (*string == 'x') {
+            string++;
+            ret->xtype = TRUE;
+        } else if (*string == 'k') {
+            string++;
+            ret->killer = TRUE;
+        } else if (*string == 'r' || *string == 'm' || *string == 'a') {
+            int sn, sc, sd;
+            sc = *string++;
+            if (sc == 'm' && *string == 'd') {
+                sd = TRUE;
+                string++;
+            } else {
+                sd = FALSE;
+            }
+            sn = atoi(string);
+            while (*string && isdigit((unsigned char)*string)) string++;
+            if (sc == 'm' && sn == 8)
+                ret->symm = SYMM_REF8;
+            if (sc == 'm' && sn == 4)
+                ret->symm = sd ? SYMM_REF4D : SYMM_REF4;
+            if (sc == 'm' && sn == 2)
+                ret->symm = sd ? SYMM_REF2D : SYMM_REF2;
+            if (sc == 'r' && sn == 4)
+                ret->symm = SYMM_ROT4;
+            if (sc == 'r' && sn == 2)
+                ret->symm = SYMM_ROT2;
+            if (sc == 'a')
+                ret->symm = SYMM_NONE;
+        } else if (*string == 'd') {
+            string++;
+            if (*string == 't')        /* trivial */
+                string++, ret->diff = DIFF_BLOCK;
+            else if (*string == 'b')   /* basic */
+                string++, ret->diff = DIFF_SIMPLE;
+            else if (*string == 'i')   /* intermediate */
+                string++, ret->diff = DIFF_INTERSECT;
+            else if (*string == 'a')   /* advanced */
+                string++, ret->diff = DIFF_SET;
+            else if (*string == 'e')   /* extreme */
+                string++, ret->diff = DIFF_EXTREME;
+            else if (*string == 'u')   /* unreasonable */
+                string++, ret->diff = DIFF_RECURSIVE;
+        } else
+            string++;                  /* eat unknown character */
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char str[80];
+
+    if (params->r > 1)
+        sprintf(str, "%dx%d", params->c, params->r);
+    else
+        sprintf(str, "%dj", params->c);
+    if (params->xtype)
+        strcat(str, "x");
+    if (params->killer)
+        strcat(str, "k");
+
+    if (full) {
+        switch (params->symm) {
+          case SYMM_REF8: strcat(str, "m8"); break;
+          case SYMM_REF4: strcat(str, "m4"); break;
+          case SYMM_REF4D: strcat(str, "md4"); break;
+          case SYMM_REF2: strcat(str, "m2"); break;
+          case SYMM_REF2D: strcat(str, "md2"); break;
+          case SYMM_ROT4: strcat(str, "r4"); break;
+          /* case SYMM_ROT2: strcat(str, "r2"); break; [default] */
+          case SYMM_NONE: strcat(str, "a"); break;
+        }
+        switch (params->diff) {
+          /* case DIFF_BLOCK: strcat(str, "dt"); break; [default] */
+          case DIFF_SIMPLE: strcat(str, "db"); break;
+          case DIFF_INTERSECT: strcat(str, "di"); break;
+          case DIFF_SET: strcat(str, "da"); break;
+          case DIFF_EXTREME: strcat(str, "de"); break;
+          case DIFF_RECURSIVE: strcat(str, "du"); break;
+        }
+    }
+    return dupstr(str);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(8, config_item);
+
+    ret[0].name = "Columns of sub-blocks";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->c);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Rows of sub-blocks";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->r);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "\"X\" (require every number in each main diagonal)";
+    ret[2].type = C_BOOLEAN;
+    ret[2].sval = NULL;
+    ret[2].ival = params->xtype;
+
+    ret[3].name = "Jigsaw (irregularly shaped sub-blocks)";
+    ret[3].type = C_BOOLEAN;
+    ret[3].sval = NULL;
+    ret[3].ival = (params->r == 1);
+
+    ret[4].name = "Killer (digit sums)";
+    ret[4].type = C_BOOLEAN;
+    ret[4].sval = NULL;
+    ret[4].ival = params->killer;
+
+    ret[5].name = "Symmetry";
+    ret[5].type = C_CHOICES;
+    ret[5].sval = ":None:2-way rotation:4-way rotation:2-way mirror:"
+        "2-way diagonal mirror:4-way mirror:4-way diagonal mirror:"
+        "8-way mirror";
+    ret[5].ival = params->symm;
+
+    ret[6].name = "Difficulty";
+    ret[6].type = C_CHOICES;
+    ret[6].sval = ":Trivial:Basic:Intermediate:Advanced:Extreme:Unreasonable";
+    ret[6].ival = params->diff;
+
+    ret[7].name = NULL;
+    ret[7].type = C_END;
+    ret[7].sval = NULL;
+    ret[7].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->c = atoi(cfg[0].sval);
+    ret->r = atoi(cfg[1].sval);
+    ret->xtype = cfg[2].ival;
+    if (cfg[3].ival) {
+        ret->c *= ret->r;
+        ret->r = 1;
+    }
+    ret->killer = cfg[4].ival;
+    ret->symm = cfg[5].ival;
+    ret->diff = cfg[6].ival;
+    ret->kdiff = DIFF_KINTERSECT;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->c < 2)
+        return "Both dimensions must be at least 2";
+    if (params->c > ORDER_MAX || params->r > ORDER_MAX)
+        return "Dimensions greater than "STR(ORDER_MAX)" are not supported";
+    if ((params->c * params->r) > 31)
+        return "Unable to support more than 31 distinct symbols in a puzzle";
+    if (params->killer && params->c * params->r > 9)
+        return "Killer puzzle dimensions must be smaller than 10.";
+    return NULL;
+}
+
+/*
+ * ----------------------------------------------------------------------
+ * Block structure functions.
+ */
+
+static struct block_structure *alloc_block_structure(int c, int r, int area,
+                                                     int max_nr_squares,
+                                                     int nr_blocks)
+{
+    int i;
+    struct block_structure *b = snew(struct block_structure);
+
+    b->refcount = 1;
+    b->nr_blocks = nr_blocks;
+    b->max_nr_squares = max_nr_squares;
+    b->c = c; b->r = r; b->area = area;
+    b->whichblock = snewn(area, int);
+    b->blocks_data = snewn(nr_blocks * max_nr_squares, int);
+    b->blocks = snewn(nr_blocks, int *);
+    b->nr_squares = snewn(nr_blocks, int);
+
+    for (i = 0; i < nr_blocks; i++)
+        b->blocks[i] = b->blocks_data + i*max_nr_squares;
+
+#ifdef STANDALONE_SOLVER
+    b->blocknames = (char **)smalloc(c*r*(sizeof(char *)+80));
+    for (i = 0; i < c * r; i++)
+        b->blocknames[i] = NULL;
+#endif
+    return b;
+}
+
+static void free_block_structure(struct block_structure *b)
+{
+    if (--b->refcount == 0) {
+        sfree(b->whichblock);
+        sfree(b->blocks);
+        sfree(b->blocks_data);
+#ifdef STANDALONE_SOLVER
+        sfree(b->blocknames);
+#endif
+        sfree(b->nr_squares);
+        sfree(b);
+    }
+}
+
+static struct block_structure *dup_block_structure(struct block_structure *b)
+{
+    struct block_structure *nb;
+    int i;
+
+    nb = alloc_block_structure(b->c, b->r, b->area, b->max_nr_squares,
+                               b->nr_blocks);
+    memcpy(nb->nr_squares, b->nr_squares, b->nr_blocks * sizeof *b->nr_squares);
+    memcpy(nb->whichblock, b->whichblock, b->area * sizeof *b->whichblock);
+    memcpy(nb->blocks_data, b->blocks_data,
+           b->nr_blocks * b->max_nr_squares * sizeof *b->blocks_data);
+    for (i = 0; i < b->nr_blocks; i++)
+        nb->blocks[i] = nb->blocks_data + i*nb->max_nr_squares;
+
+#ifdef STANDALONE_SOLVER
+    memcpy(nb->blocknames, b->blocknames, b->c * b->r *(sizeof(char *)+80));
+    {
+        int i;
+        for (i = 0; i < b->c * b->r; i++)
+            if (b->blocknames[i] == NULL)
+                nb->blocknames[i] = NULL;
+            else
+                nb->blocknames[i] = ((char *)nb->blocknames) + (b->blocknames[i] - (char *)b->blocknames);
+    }
+#endif
+    return nb;
+}
+
+static void split_block(struct block_structure *b, int *squares, int nr_squares)
+{
+    int i, j;
+    int previous_block = b->whichblock[squares[0]];
+    int newblock = b->nr_blocks;
+
+    assert(b->max_nr_squares >= nr_squares);
+    assert(b->nr_squares[previous_block] > nr_squares);
+
+    b->nr_blocks++;
+    b->blocks_data = sresize(b->blocks_data,
+                             b->nr_blocks * b->max_nr_squares, int);
+    b->nr_squares = sresize(b->nr_squares, b->nr_blocks, int);
+    sfree(b->blocks);
+    b->blocks = snewn(b->nr_blocks, int *);
+    for (i = 0; i < b->nr_blocks; i++)
+        b->blocks[i] = b->blocks_data + i*b->max_nr_squares;
+    for (i = 0; i < nr_squares; i++) {
+        assert(b->whichblock[squares[i]] == previous_block);
+        b->whichblock[squares[i]] = newblock;
+        b->blocks[newblock][i] = squares[i];
+    }
+    for (i = j = 0; i < b->nr_squares[previous_block]; i++) {
+        int k;
+        int sq = b->blocks[previous_block][i];
+        for (k = 0; k < nr_squares; k++)
+            if (squares[k] == sq)
+                break;
+        if (k == nr_squares)
+            b->blocks[previous_block][j++] = sq;
+    }
+    b->nr_squares[previous_block] -= nr_squares;
+    b->nr_squares[newblock] = nr_squares;
+}
+
+static void remove_from_block(struct block_structure *blocks, int b, int n)
+{
+    int i, j;
+    blocks->whichblock[n] = -1;
+    for (i = j = 0; i < blocks->nr_squares[b]; i++)
+        if (blocks->blocks[b][i] != n)
+            blocks->blocks[b][j++] = blocks->blocks[b][i];
+    assert(j+1 == i);
+    blocks->nr_squares[b]--;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver.
+ * 
+ * This solver is used for two purposes:
+ *  + to check solubility of a grid as we gradually remove numbers
+ *    from it
+ *  + to solve an externally generated puzzle when the user selects
+ *    `Solve'.
+ * 
+ * It supports a variety of specific modes of reasoning. By
+ * enabling or disabling subsets of these modes we can arrange a
+ * range of difficulty levels.
+ */
+
+/*
+ * Modes of reasoning currently supported:
+ *
+ *  - Positional elimination: a number must go in a particular
+ *    square because all the other empty squares in a given
+ *    row/col/blk are ruled out.
+ *
+ *  - Killer minmax elimination: for killer-type puzzles, a number
+ *    is impossible if choosing it would cause the sum in a killer
+ *    region to be guaranteed to be too large or too small.
+ *
+ *  - Numeric elimination: a square must have a particular number
+ *    in because all the other numbers that could go in it are
+ *    ruled out.
+ *
+ *  - Intersectional analysis: given two domains which overlap
+ *    (hence one must be a block, and the other can be a row or
+ *    col), if the possible locations for a particular number in
+ *    one of the domains can be narrowed down to the overlap, then
+ *    that number can be ruled out everywhere but the overlap in
+ *    the other domain too.
+ *
+ *  - Set elimination: if there is a subset of the empty squares
+ *    within a domain such that the union of the possible numbers
+ *    in that subset has the same size as the subset itself, then
+ *    those numbers can be ruled out everywhere else in the domain.
+ *    (For example, if there are five empty squares and the
+ *    possible numbers in each are 12, 23, 13, 134 and 1345, then
+ *    the first three empty squares form such a subset: the numbers
+ *    1, 2 and 3 _must_ be in those three squares in some
+ *    permutation, and hence we can deduce none of them can be in
+ *    the fourth or fifth squares.)
+ *     + You can also see this the other way round, concentrating
+ *       on numbers rather than squares: if there is a subset of
+ *       the unplaced numbers within a domain such that the union
+ *       of all their possible positions has the same size as the
+ *       subset itself, then all other numbers can be ruled out for
+ *       those positions. However, it turns out that this is
+ *       exactly equivalent to the first formulation at all times:
+ *       there is a 1-1 correspondence between suitable subsets of
+ *       the unplaced numbers and suitable subsets of the unfilled
+ *       places, found by taking the _complement_ of the union of
+ *       the numbers' possible positions (or the spaces' possible
+ *       contents).
+ * 
+ *  - Forcing chains (see comment for solver_forcing().)
+ * 
+ *  - Recursion. If all else fails, we pick one of the currently
+ *    most constrained empty squares and take a random guess at its
+ *    contents, then continue solving on that basis and see if we
+ *    get any further.
+ */
+
+struct solver_usage {
+    int cr;
+    struct block_structure *blocks, *kblocks, *extra_cages;
+    /*
+     * We set up a cubic array, indexed by x, y and digit; each
+     * element of this array is TRUE or FALSE according to whether
+     * or not that digit _could_ in principle go in that position.
+     *
+     * The way to index this array is cube[(y*cr+x)*cr+n-1]; there
+     * are macros below to help with this.
+     */
+    unsigned char *cube;
+    /*
+     * This is the grid in which we write down our final
+     * deductions. y-coordinates in here are _not_ transformed.
+     */
+    digit *grid;
+    /*
+     * For killer-type puzzles, kclues holds the secondary clue for
+     * each cage.  For derived cages, the clue is in extra_clues.
+     */
+    digit *kclues, *extra_clues;
+    /*
+     * Now we keep track, at a slightly higher level, of what we
+     * have yet to work out, to prevent doing the same deduction
+     * many times.
+     */
+    /* row[y*cr+n-1] TRUE if digit n has been placed in row y */
+    unsigned char *row;
+    /* col[x*cr+n-1] TRUE if digit n has been placed in row x */
+    unsigned char *col;
+    /* blk[i*cr+n-1] TRUE if digit n has been placed in block i */
+    unsigned char *blk;
+    /* diag[i*cr+n-1] TRUE if digit n has been placed in diagonal i */
+    unsigned char *diag;               /* diag 0 is \, 1 is / */
+
+    int *regions;
+    int nr_regions;
+    int **sq2region;
+};
+#define cubepos2(xy,n) ((xy)*usage->cr+(n)-1)
+#define cubepos(x,y,n) cubepos2((y)*usage->cr+(x),n)
+#define cube(x,y,n) (usage->cube[cubepos(x,y,n)])
+#define cube2(xy,n) (usage->cube[cubepos2(xy,n)])
+
+#define ondiag0(xy) ((xy) % (cr+1) == 0)
+#define ondiag1(xy) ((xy) % (cr-1) == 0 && (xy) > 0 && (xy) < cr*cr-1)
+#define diag0(i) ((i) * (cr+1))
+#define diag1(i) ((i+1) * (cr-1))
+
+/*
+ * Function called when we are certain that a particular square has
+ * a particular number in it. The y-coordinate passed in here is
+ * transformed.
+ */
+static void solver_place(struct solver_usage *usage, int x, int y, int n)
+{
+    int cr = usage->cr;
+    int sqindex = y*cr+x;
+    int i, bi;
+
+    assert(cube(x,y,n));
+
+    /*
+     * Rule out all other numbers in this square.
+     */
+    for (i = 1; i <= cr; i++)
+        if (i != n)
+            cube(x,y,i) = FALSE;
+
+    /*
+     * Rule out this number in all other positions in the row.
+     */
+    for (i = 0; i < cr; i++)
+        if (i != y)
+            cube(x,i,n) = FALSE;
+
+    /*
+     * Rule out this number in all other positions in the column.
+     */
+    for (i = 0; i < cr; i++)
+        if (i != x)
+            cube(i,y,n) = FALSE;
+
+    /*
+     * Rule out this number in all other positions in the block.
+     */
+    bi = usage->blocks->whichblock[sqindex];
+    for (i = 0; i < cr; i++) {
+        int bp = usage->blocks->blocks[bi][i];
+        if (bp != sqindex)
+            cube2(bp,n) = FALSE;
+    }
+
+    /*
+     * Enter the number in the result grid.
+     */
+    usage->grid[sqindex] = n;
+
+    /*
+     * Cross out this number from the list of numbers left to place
+     * in its row, its column and its block.
+     */
+    usage->row[y*cr+n-1] = usage->col[x*cr+n-1] =
+        usage->blk[bi*cr+n-1] = TRUE;
+
+    if (usage->diag) {
+        if (ondiag0(sqindex)) {
+            for (i = 0; i < cr; i++)
+                if (diag0(i) != sqindex)
+                    cube2(diag0(i),n) = FALSE;
+            usage->diag[n-1] = TRUE;
+        }
+        if (ondiag1(sqindex)) {
+            for (i = 0; i < cr; i++)
+                if (diag1(i) != sqindex)
+                    cube2(diag1(i),n) = FALSE;
+            usage->diag[cr+n-1] = TRUE;
+        }
+    }
+}
+
+#if defined STANDALONE_SOLVER && defined __GNUC__
+/*
+ * Forward-declare the functions taking printf-like format arguments
+ * with __attribute__((format)) so as to ensure the argument syntax
+ * gets debugged.
+ */
+struct solver_scratch;
+static int solver_elim(struct solver_usage *usage, int *indices,
+                       char *fmt, ...) __attribute__((format(printf,3,4)));
+static int solver_intersect(struct solver_usage *usage,
+                            int *indices1, int *indices2, char *fmt, ...)
+    __attribute__((format(printf,4,5)));
+static int solver_set(struct solver_usage *usage,
+                      struct solver_scratch *scratch,
+                      int *indices, char *fmt, ...)
+    __attribute__((format(printf,4,5)));
+#endif
+
+static int solver_elim(struct solver_usage *usage, int *indices
+#ifdef STANDALONE_SOLVER
+                       , char *fmt, ...
+#endif
+                       )
+{
+    int cr = usage->cr;
+    int fpos, m, i;
+
+    /*
+     * Count the number of set bits within this section of the
+     * cube.
+     */
+    m = 0;
+    fpos = -1;
+    for (i = 0; i < cr; i++)
+        if (usage->cube[indices[i]]) {
+            fpos = indices[i];
+            m++;
+        }
+
+    if (m == 1) {
+        int x, y, n;
+        assert(fpos >= 0);
+
+        n = 1 + fpos % cr;
+        x = fpos / cr;
+        y = x / cr;
+        x %= cr;
+
+        if (!usage->grid[y*cr+x]) {
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working) {
+                va_list ap;
+                printf("%*s", solver_recurse_depth*4, "");
+                va_start(ap, fmt);
+                vprintf(fmt, ap);
+                va_end(ap);
+                printf(":\n%*s  placing %d at (%d,%d)\n",
+                       solver_recurse_depth*4, "", n, 1+x, 1+y);
+            }
+#endif
+            solver_place(usage, x, y, n);
+            return +1;
+        }
+    } else if (m == 0) {
+#ifdef STANDALONE_SOLVER
+        if (solver_show_working) {
+            va_list ap;
+            printf("%*s", solver_recurse_depth*4, "");
+            va_start(ap, fmt);
+            vprintf(fmt, ap);
+            va_end(ap);
+            printf(":\n%*s  no possibilities available\n",
+                   solver_recurse_depth*4, "");
+        }
+#endif
+        return -1;
+    }
+
+    return 0;
+}
+
+static int solver_intersect(struct solver_usage *usage,
+                            int *indices1, int *indices2
+#ifdef STANDALONE_SOLVER
+                            , char *fmt, ...
+#endif
+                            )
+{
+    int cr = usage->cr;
+    int ret, i, j;
+
+    /*
+     * Loop over the first domain and see if there's any set bit
+     * not also in the second.
+     */
+    for (i = j = 0; i < cr; i++) {
+        int p = indices1[i];
+        while (j < cr && indices2[j] < p)
+            j++;
+        if (usage->cube[p]) {
+            if (j < cr && indices2[j] == p)
+                continue;              /* both domains contain this index */
+            else
+                return 0;              /* there is, so we can't deduce */
+        }
+    }
+
+    /*
+     * We have determined that all set bits in the first domain are
+     * within its overlap with the second. So loop over the second
+     * domain and remove all set bits that aren't also in that
+     * overlap; return +1 iff we actually _did_ anything.
+     */
+    ret = 0;
+    for (i = j = 0; i < cr; i++) {
+        int p = indices2[i];
+        while (j < cr && indices1[j] < p)
+            j++;
+        if (usage->cube[p] && (j >= cr || indices1[j] != p)) {
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working) {
+                int px, py, pn;
+
+                if (!ret) {
+                    va_list ap;
+                    printf("%*s", solver_recurse_depth*4, "");
+                    va_start(ap, fmt);
+                    vprintf(fmt, ap);
+                    va_end(ap);
+                    printf(":\n");
+                }
+
+                pn = 1 + p % cr;
+                px = p / cr;
+                py = px / cr;
+                px %= cr;
+
+                printf("%*s  ruling out %d at (%d,%d)\n",
+                       solver_recurse_depth*4, "", pn, 1+px, 1+py);
+            }
+#endif
+            ret = +1;                  /* we did something */
+            usage->cube[p] = 0;
+        }
+    }
+
+    return ret;
+}
+
+struct solver_scratch {
+    unsigned char *grid, *rowidx, *colidx, *set;
+    int *neighbours, *bfsqueue;
+    int *indexlist, *indexlist2;
+#ifdef STANDALONE_SOLVER
+    int *bfsprev;
+#endif
+};
+
+static int solver_set(struct solver_usage *usage,
+                      struct solver_scratch *scratch,
+                      int *indices
+#ifdef STANDALONE_SOLVER
+                      , char *fmt, ...
+#endif
+                      )
+{
+    int cr = usage->cr;
+    int i, j, n, count;
+    unsigned char *grid = scratch->grid;
+    unsigned char *rowidx = scratch->rowidx;
+    unsigned char *colidx = scratch->colidx;
+    unsigned char *set = scratch->set;
+
+    /*
+     * We are passed a cr-by-cr matrix of booleans. Our first job
+     * is to winnow it by finding any definite placements - i.e.
+     * any row with a solitary 1 - and discarding that row and the
+     * column containing the 1.
+     */
+    memset(rowidx, TRUE, cr);
+    memset(colidx, TRUE, cr);
+    for (i = 0; i < cr; i++) {
+        int count = 0, first = -1;
+        for (j = 0; j < cr; j++)
+            if (usage->cube[indices[i*cr+j]])
+                first = j, count++;
+
+        /*
+         * If count == 0, then there's a row with no 1s at all and
+         * the puzzle is internally inconsistent. However, we ought
+         * to have caught this already during the simpler reasoning
+         * methods, so we can safely fail an assertion if we reach
+         * this point here.
+         */
+        assert(count > 0);
+        if (count == 1)
+            rowidx[i] = colidx[first] = FALSE;
+    }
+
+    /*
+     * Convert each of rowidx/colidx from a list of 0s and 1s to a
+     * list of the indices of the 1s.
+     */
+    for (i = j = 0; i < cr; i++)
+        if (rowidx[i])
+            rowidx[j++] = i;
+    n = j;
+    for (i = j = 0; i < cr; i++)
+        if (colidx[i])
+            colidx[j++] = i;
+    assert(n == j);
+
+    /*
+     * And create the smaller matrix.
+     */
+    for (i = 0; i < n; i++)
+        for (j = 0; j < n; j++)
+            grid[i*cr+j] = usage->cube[indices[rowidx[i]*cr+colidx[j]]];
+
+    /*
+     * Having done that, we now have a matrix in which every row
+     * has at least two 1s in. Now we search to see if we can find
+     * a rectangle of zeroes (in the set-theoretic sense of
+     * `rectangle', i.e. a subset of rows crossed with a subset of
+     * columns) whose width and height add up to n.
+     */
+
+    memset(set, 0, n);
+    count = 0;
+    while (1) {
+        /*
+         * We have a candidate set. If its size is <=1 or >=n-1
+         * then we move on immediately.
+         */
+        if (count > 1 && count < n-1) {
+            /*
+             * The number of rows we need is n-count. See if we can
+             * find that many rows which each have a zero in all
+             * the positions listed in `set'.
+             */
+            int rows = 0;
+            for (i = 0; i < n; i++) {
+                int ok = TRUE;
+                for (j = 0; j < n; j++)
+                    if (set[j] && grid[i*cr+j]) {
+                        ok = FALSE;
+                        break;
+                    }
+                if (ok)
+                    rows++;
+            }
+
+            /*
+             * We expect never to be able to get _more_ than
+             * n-count suitable rows: this would imply that (for
+             * example) there are four numbers which between them
+             * have at most three possible positions, and hence it
+             * indicates a faulty deduction before this point or
+             * even a bogus clue.
+             */
+            if (rows > n - count) {
+#ifdef STANDALONE_SOLVER
+                if (solver_show_working) {
+                    va_list ap;
+                    printf("%*s", solver_recurse_depth*4,
+                           "");
+                    va_start(ap, fmt);
+                    vprintf(fmt, ap);
+                    va_end(ap);
+                    printf(":\n%*s  contradiction reached\n",
+                           solver_recurse_depth*4, "");
+                }
+#endif
+                return -1;
+            }
+
+            if (rows >= n - count) {
+                int progress = FALSE;
+
+                /*
+                 * We've got one! Now, for each row which _doesn't_
+                 * satisfy the criterion, eliminate all its set
+                 * bits in the positions _not_ listed in `set'.
+                 * Return +1 (meaning progress has been made) if we
+                 * successfully eliminated anything at all.
+                 * 
+                 * This involves referring back through
+                 * rowidx/colidx in order to work out which actual
+                 * positions in the cube to meddle with.
+                 */
+                for (i = 0; i < n; i++) {
+                    int ok = TRUE;
+                    for (j = 0; j < n; j++)
+                        if (set[j] && grid[i*cr+j]) {
+                            ok = FALSE;
+                            break;
+                        }
+                    if (!ok) {
+                        for (j = 0; j < n; j++)
+                            if (!set[j] && grid[i*cr+j]) {
+                                int fpos = indices[rowidx[i]*cr+colidx[j]];
+#ifdef STANDALONE_SOLVER
+                                if (solver_show_working) {
+                                    int px, py, pn;
+
+                                    if (!progress) {
+                                        va_list ap;
+                                        printf("%*s", solver_recurse_depth*4,
+                                               "");
+                                        va_start(ap, fmt);
+                                        vprintf(fmt, ap);
+                                        va_end(ap);
+                                        printf(":\n");
+                                    }
+
+                                    pn = 1 + fpos % cr;
+                                    px = fpos / cr;
+                                    py = px / cr;
+                                    px %= cr;
+
+                                    printf("%*s  ruling out %d at (%d,%d)\n",
+                                           solver_recurse_depth*4, "",
+                                           pn, 1+px, 1+py);
+                                }
+#endif
+                                progress = TRUE;
+                                usage->cube[fpos] = FALSE;
+                            }
+                    }
+                }
+
+                if (progress) {
+                    return +1;
+                }
+            }
+        }
+
+        /*
+         * Binary increment: change the rightmost 0 to a 1, and
+         * change all 1s to the right of it to 0s.
+         */
+        i = n;
+        while (i > 0 && set[i-1])
+            set[--i] = 0, count--;
+        if (i > 0)
+            set[--i] = 1, count++;
+        else
+            break;                     /* done */
+    }
+
+    return 0;
+}
+
+/*
+ * Look for forcing chains. A forcing chain is a path of
+ * pairwise-exclusive squares (i.e. each pair of adjacent squares
+ * in the path are in the same row, column or block) with the
+ * following properties:
+ *
+ *  (a) Each square on the path has precisely two possible numbers.
+ *
+ *  (b) Each pair of squares which are adjacent on the path share
+ *      at least one possible number in common.
+ *
+ *  (c) Each square in the middle of the path shares _both_ of its
+ *      numbers with at least one of its neighbours (not the same
+ *      one with both neighbours).
+ *
+ * These together imply that at least one of the possible number
+ * choices at one end of the path forces _all_ the rest of the
+ * numbers along the path. In order to make real use of this, we
+ * need further properties:
+ *
+ *  (c) Ruling out some number N from the square at one end of the
+ *      path forces the square at the other end to take the same
+ *      number N.
+ *
+ *  (d) The two end squares are both in line with some third
+ *      square.
+ *
+ *  (e) That third square currently has N as a possibility.
+ *
+ * If we can find all of that lot, we can deduce that at least one
+ * of the two ends of the forcing chain has number N, and that
+ * therefore the mutually adjacent third square does not.
+ *
+ * To find forcing chains, we're going to start a bfs at each
+ * suitable square, once for each of its two possible numbers.
+ */
+static int solver_forcing(struct solver_usage *usage,
+                          struct solver_scratch *scratch)
+{
+    int cr = usage->cr;
+    int *bfsqueue = scratch->bfsqueue;
+#ifdef STANDALONE_SOLVER
+    int *bfsprev = scratch->bfsprev;
+#endif
+    unsigned char *number = scratch->grid;
+    int *neighbours = scratch->neighbours;
+    int x, y;
+
+    for (y = 0; y < cr; y++)
+        for (x = 0; x < cr; x++) {
+            int count, t, n;
+
+            /*
+             * If this square doesn't have exactly two candidate
+             * numbers, don't try it.
+             * 
+             * In this loop we also sum the candidate numbers,
+             * which is a nasty hack to allow us to quickly find
+             * `the other one' (since we will shortly know there
+             * are exactly two).
+             */
+            for (count = t = 0, n = 1; n <= cr; n++)
+                if (cube(x, y, n))
+                    count++, t += n;
+            if (count != 2)
+                continue;
+
+            /*
+             * Now attempt a bfs for each candidate.
+             */
+            for (n = 1; n <= cr; n++)
+                if (cube(x, y, n)) {
+                    int orign, currn, head, tail;
+
+                    /*
+                     * Begin a bfs.
+                     */
+                    orign = n;
+
+                    memset(number, cr+1, cr*cr);
+                    head = tail = 0;
+                    bfsqueue[tail++] = y*cr+x;
+#ifdef STANDALONE_SOLVER
+                    bfsprev[y*cr+x] = -1;
+#endif
+                    number[y*cr+x] = t - n;
+
+                    while (head < tail) {
+                        int xx, yy, nneighbours, xt, yt, i;
+
+                        xx = bfsqueue[head++];
+                        yy = xx / cr;
+                        xx %= cr;
+
+                        currn = number[yy*cr+xx];
+
+                        /*
+                         * Find neighbours of yy,xx.
+                         */
+                        nneighbours = 0;
+                        for (yt = 0; yt < cr; yt++)
+                            neighbours[nneighbours++] = yt*cr+xx;
+                        for (xt = 0; xt < cr; xt++)
+                            neighbours[nneighbours++] = yy*cr+xt;
+                        xt = usage->blocks->whichblock[yy*cr+xx];
+                        for (yt = 0; yt < cr; yt++)
+                            neighbours[nneighbours++] = usage->blocks->blocks[xt][yt];
+                        if (usage->diag) {
+                            int sqindex = yy*cr+xx;
+                            if (ondiag0(sqindex)) {
+                                for (i = 0; i < cr; i++)
+                                    neighbours[nneighbours++] = diag0(i);
+                            }
+                            if (ondiag1(sqindex)) {
+                                for (i = 0; i < cr; i++)
+                                    neighbours[nneighbours++] = diag1(i);
+                            }
+                        }
+
+                        /*
+                         * Try visiting each of those neighbours.
+                         */
+                        for (i = 0; i < nneighbours; i++) {
+                            int cc, tt, nn;
+
+                            xt = neighbours[i] % cr;
+                            yt = neighbours[i] / cr;
+
+                            /*
+                             * We need this square to not be
+                             * already visited, and to include
+                             * currn as a possible number.
+                             */
+                            if (number[yt*cr+xt] <= cr)
+                                continue;
+                            if (!cube(xt, yt, currn))
+                                continue;
+
+                            /*
+                             * Don't visit _this_ square a second
+                             * time!
+                             */
+                            if (xt == xx && yt == yy)
+                                continue;
+
+                            /*
+                             * To continue with the bfs, we need
+                             * this square to have exactly two
+                             * possible numbers.
+                             */
+                            for (cc = tt = 0, nn = 1; nn <= cr; nn++)
+                                if (cube(xt, yt, nn))
+                                    cc++, tt += nn;
+                            if (cc == 2) {
+                                bfsqueue[tail++] = yt*cr+xt;
+#ifdef STANDALONE_SOLVER
+                                bfsprev[yt*cr+xt] = yy*cr+xx;
+#endif
+                                number[yt*cr+xt] = tt - currn;
+                            }
+
+                            /*
+                             * One other possibility is that this
+                             * might be the square in which we can
+                             * make a real deduction: if it's
+                             * adjacent to x,y, and currn is equal
+                             * to the original number we ruled out.
+                             */
+                            if (currn == orign &&
+                                (xt == x || yt == y ||
+                                 (usage->blocks->whichblock[yt*cr+xt] == usage->blocks->whichblock[y*cr+x]) ||
+                                 (usage->diag && ((ondiag0(yt*cr+xt) && ondiag0(y*cr+x)) ||
+                                                  (ondiag1(yt*cr+xt) && ondiag1(y*cr+x)))))) {
+#ifdef STANDALONE_SOLVER
+                                if (solver_show_working) {
+                                    char *sep = "";
+                                    int xl, yl;
+                                    printf("%*sforcing chain, %d at ends of ",
+                                           solver_recurse_depth*4, "", orign);
+                                    xl = xx;
+                                    yl = yy;
+                                    while (1) {
+                                        printf("%s(%d,%d)", sep, 1+xl,
+                                               1+yl);
+                                        xl = bfsprev[yl*cr+xl];
+                                        if (xl < 0)
+                                            break;
+                                        yl = xl / cr;
+                                        xl %= cr;
+                                        sep = "-";
+                                    }
+                                    printf("\n%*s  ruling out %d at (%d,%d)\n",
+                                           solver_recurse_depth*4, "",
+                                           orign, 1+xt, 1+yt);
+                                }
+#endif
+                                cube(xt, yt, orign) = FALSE;
+                                return 1;
+                            }
+                        }
+                    }
+                }
+        }
+
+    return 0;
+}
+
+static int solver_killer_minmax(struct solver_usage *usage,
+                                struct block_structure *cages, digit *clues,
+                                int b
+#ifdef STANDALONE_SOLVER
+                                , const char *extra
+#endif
+                                )
+{
+    int cr = usage->cr;
+    int i;
+    int ret = 0;
+    int nsquares = cages->nr_squares[b];
+
+    if (clues[b] == 0)
+        return 0;
+
+    for (i = 0; i < nsquares; i++) {
+        int n, x = cages->blocks[b][i];
+
+        for (n = 1; n <= cr; n++)
+            if (cube2(x, n)) {
+                int maxval = 0, minval = 0;
+                int j;
+                for (j = 0; j < nsquares; j++) {
+                    int m;
+                    int y = cages->blocks[b][j];
+                    if (i == j)
+                        continue;
+                    for (m = 1; m <= cr; m++)
+                        if (cube2(y, m)) {
+                            minval += m;
+                            break;
+                        }
+                    for (m = cr; m > 0; m--)
+                        if (cube2(y, m)) {
+                            maxval += m;
+                            break;
+                        }
+                }
+                if (maxval + n < clues[b]) {
+                    cube2(x, n) = FALSE;
+                    ret = 1;
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working)
+                        printf("%*s  ruling out %d at (%d,%d) as too low %s\n",
+                               solver_recurse_depth*4, "killer minmax analysis",
+                               n, 1 + x%cr, 1 + x/cr, extra);
+#endif
+                }
+                if (minval + n > clues[b]) {
+                    cube2(x, n) = FALSE;
+                    ret = 1;
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working)
+                        printf("%*s  ruling out %d at (%d,%d) as too high %s\n",
+                               solver_recurse_depth*4, "killer minmax analysis",
+                               n, 1 + x%cr, 1 + x/cr, extra);
+#endif
+                }
+            }
+    }
+    return ret;
+}
+
+static int solver_killer_sums(struct solver_usage *usage, int b,
+                              struct block_structure *cages, int clue,
+                              int cage_is_region
+#ifdef STANDALONE_SOLVER
+                              , const char *cage_type
+#endif
+                              )
+{
+    int cr = usage->cr;
+    int i, ret, max_sums;
+    int nsquares = cages->nr_squares[b];
+    unsigned long *sumbits, possible_addends;
+
+    if (clue == 0) {
+        assert(nsquares == 0);
+        return 0;
+    }
+    assert(nsquares > 0);
+
+    if (nsquares < 2 || nsquares > 4)
+        return 0;
+
+    if (!cage_is_region) {
+        int known_row = -1, known_col = -1, known_block = -1;
+        /*
+         * Verify that the cage lies entirely within one region,
+         * so that using the precomputed sums is valid.
+         */
+        for (i = 0; i < nsquares; i++) {
+            int x = cages->blocks[b][i];
+
+            assert(usage->grid[x] == 0);
+
+            if (i == 0) {
+                known_row = x/cr;
+                known_col = x%cr;
+                known_block = usage->blocks->whichblock[x];
+            } else {
+                if (known_row != x/cr)
+                    known_row = -1;
+                if (known_col != x%cr)
+                    known_col = -1;
+                if (known_block != usage->blocks->whichblock[x])
+                    known_block = -1;
+            }
+        }
+        if (known_block == -1 && known_col == -1 && known_row == -1)
+            return 0;
+    }
+    if (nsquares == 2) {
+        if (clue < 3 || clue > 17)
+            return -1;
+
+        sumbits = sum_bits2[clue];
+        max_sums = MAX_2SUMS;
+    } else if (nsquares == 3) {
+        if (clue < 6 || clue > 24)
+            return -1;
+
+        sumbits = sum_bits3[clue];
+        max_sums = MAX_3SUMS;
+    } else {
+        if (clue < 10 || clue > 30)
+            return -1;
+
+        sumbits = sum_bits4[clue];
+        max_sums = MAX_4SUMS;
+    }
+    /*
+     * For every possible way to get the sum, see if there is
+     * one square in the cage that disallows all the required
+     * addends.  If we find one such square, this way to compute
+     * the sum is impossible.
+     */
+    possible_addends = 0;
+    for (i = 0; i < max_sums; i++) {
+        int j;
+        unsigned long bits = sumbits[i];
+
+        if (bits == 0)
+            break;
+
+        for (j = 0; j < nsquares; j++) {
+            int n;
+            unsigned long square_bits = bits;
+            int x = cages->blocks[b][j];
+            for (n = 1; n <= cr; n++)
+                if (!cube2(x, n))
+                    square_bits &= ~(1L << n);
+            if (square_bits == 0) {
+                break;
+            }
+        }
+        if (j == nsquares)
+            possible_addends |= bits;
+    }
+    /*
+     * Now we know which addends can possibly be used to
+     * compute the sum.  Remove all other digits from the
+     * set of possibilities.
+     */
+    if (possible_addends == 0)
+        return -1;
+
+    ret = 0;
+    for (i = 0; i < nsquares; i++) {
+        int n;
+        int x = cages->blocks[b][i];
+        for (n = 1; n <= cr; n++) {
+            if (!cube2(x, n))
+                continue;
+            if ((possible_addends & (1 << n)) == 0) {
+                cube2(x, n) = FALSE;
+                ret = 1;
+#ifdef STANDALONE_SOLVER
+                if (solver_show_working) {
+                    printf("%*s  using %s\n",
+                           solver_recurse_depth*4, "killer sums analysis",
+                           cage_type);
+                    printf("%*s  ruling out %d at (%d,%d) due to impossible %d-sum\n",
+                           solver_recurse_depth*4, "",
+                           n, 1 + x%cr, 1 + x/cr, nsquares);
+                }
+#endif
+            }
+        }
+    }
+    return ret;
+}
+
+static int filter_whole_cages(struct solver_usage *usage, int *squares, int n,
+                              int *filtered_sum)
+{
+    int b, i, j, off;
+    *filtered_sum = 0;
+
+    /* First, filter squares with a clue.  */
+    for (i = j = 0; i < n; i++)
+        if (usage->grid[squares[i]])
+            *filtered_sum += usage->grid[squares[i]];
+        else
+            squares[j++] = squares[i];
+    n = j;
+
+    /*
+     * Filter all cages that are covered entirely by the list of
+     * squares.
+     */
+    off = 0;
+    for (b = 0; b < usage->kblocks->nr_blocks && off < n; b++) {
+        int b_squares = usage->kblocks->nr_squares[b];
+        int matched = 0;
+
+        if (b_squares == 0)
+            continue;
+
+        /*
+         * Find all squares of block b that lie in our list,
+         * and make them contiguous at off, which is the current position
+         * in the output list.
+         */
+        for (i = 0; i < b_squares; i++) {
+            for (j = off; j < n; j++)
+                if (squares[j] == usage->kblocks->blocks[b][i]) {
+                    int t = squares[off + matched];
+                    squares[off + matched] = squares[j];
+                    squares[j] = t;
+                    matched++;
+                    break;
+                }
+        }
+        /* If so, filter out all squares of b from the list.  */
+        if (matched != usage->kblocks->nr_squares[b]) {
+            off += matched;
+            continue;
+        }
+        memmove(squares + off, squares + off + matched,
+                (n - off - matched) * sizeof *squares);
+        n -= matched;
+
+        *filtered_sum += usage->kclues[b];
+    }
+    assert(off == n);
+    return off;
+}
+
+static struct solver_scratch *solver_new_scratch(struct solver_usage *usage)
+{
+    struct solver_scratch *scratch = snew(struct solver_scratch);
+    int cr = usage->cr;
+    scratch->grid = snewn(cr*cr, unsigned char);
+    scratch->rowidx = snewn(cr, unsigned char);
+    scratch->colidx = snewn(cr, unsigned char);
+    scratch->set = snewn(cr, unsigned char);
+    scratch->neighbours = snewn(5*cr, int);
+    scratch->bfsqueue = snewn(cr*cr, int);
+#ifdef STANDALONE_SOLVER
+    scratch->bfsprev = snewn(cr*cr, int);
+#endif
+    scratch->indexlist = snewn(cr*cr, int);   /* used for set elimination */
+    scratch->indexlist2 = snewn(cr, int);   /* only used for intersect() */
+    return scratch;
+}
+
+static void solver_free_scratch(struct solver_scratch *scratch)
+{
+#ifdef STANDALONE_SOLVER
+    sfree(scratch->bfsprev);
+#endif
+    sfree(scratch->bfsqueue);
+    sfree(scratch->neighbours);
+    sfree(scratch->set);
+    sfree(scratch->colidx);
+    sfree(scratch->rowidx);
+    sfree(scratch->grid);
+    sfree(scratch->indexlist);
+    sfree(scratch->indexlist2);
+    sfree(scratch);
+}
+
+/*
+ * Used for passing information about difficulty levels between the solver
+ * and its callers.
+ */
+struct difficulty {
+    /* Maximum levels allowed.  */
+    int maxdiff, maxkdiff;
+    /* Levels reached by the solver.  */
+    int diff, kdiff;
+};
+
+static void solver(int cr, struct block_structure *blocks,
+                  struct block_structure *kblocks, int xtype,
+                  digit *grid, digit *kgrid, struct difficulty *dlev)
+{
+    struct solver_usage *usage;
+    struct solver_scratch *scratch;
+    int x, y, b, i, n, ret;
+    int diff = DIFF_BLOCK;
+    int kdiff = DIFF_KSINGLE;
+
+    /*
+     * Set up a usage structure as a clean slate (everything
+     * possible).
+     */
+    usage = snew(struct solver_usage);
+    usage->cr = cr;
+    usage->blocks = blocks;
+    if (kblocks) {
+        usage->kblocks = dup_block_structure(kblocks);
+        usage->extra_cages = alloc_block_structure (kblocks->c, kblocks->r,
+                                                    cr * cr, cr, cr * cr);
+        usage->extra_clues = snewn(cr*cr, digit);
+    } else {
+        usage->kblocks = usage->extra_cages = NULL;
+        usage->extra_clues = NULL;
+    }
+    usage->cube = snewn(cr*cr*cr, unsigned char);
+    usage->grid = grid;                /* write straight back to the input */
+    if (kgrid) {
+        int nclues;
+
+        assert(kblocks);
+        nclues = kblocks->nr_blocks;
+        /*
+         * Allow for expansion of the killer regions, the absolute
+         * limit is obviously one region per square.
+         */
+        usage->kclues = snewn(cr*cr, digit);
+        for (i = 0; i < nclues; i++) {
+            for (n = 0; n < kblocks->nr_squares[i]; n++)
+                if (kgrid[kblocks->blocks[i][n]] != 0)
+                    usage->kclues[i] = kgrid[kblocks->blocks[i][n]];
+            assert(usage->kclues[i] > 0);
+        }
+        memset(usage->kclues + nclues, 0, cr*cr - nclues);
+    } else {
+        usage->kclues = NULL;
+    }
+
+    memset(usage->cube, TRUE, cr*cr*cr);
+
+    usage->row = snewn(cr * cr, unsigned char);
+    usage->col = snewn(cr * cr, unsigned char);
+    usage->blk = snewn(cr * cr, unsigned char);
+    memset(usage->row, FALSE, cr * cr);
+    memset(usage->col, FALSE, cr * cr);
+    memset(usage->blk, FALSE, cr * cr);
+
+    if (xtype) {
+        usage->diag = snewn(cr * 2, unsigned char);
+        memset(usage->diag, FALSE, cr * 2);
+    } else
+        usage->diag = NULL; 
+
+    usage->nr_regions = cr * 3 + (xtype ? 2 : 0);
+    usage->regions = snewn(cr * usage->nr_regions, int);
+    usage->sq2region = snewn(cr * cr * 3, int *);
+
+    for (n = 0; n < cr; n++) {
+        for (i = 0; i < cr; i++) {
+            x = n*cr+i;
+            y = i*cr+n;
+            b = usage->blocks->blocks[n][i];
+            usage->regions[cr*n*3 + i] = x;
+            usage->regions[cr*n*3 + cr + i] = y;
+            usage->regions[cr*n*3 + 2*cr + i] = b;
+            usage->sq2region[x*3] = usage->regions + cr*n*3;
+            usage->sq2region[y*3 + 1] = usage->regions + cr*n*3 + cr;
+            usage->sq2region[b*3 + 2] = usage->regions + cr*n*3 + 2*cr;
+        }
+    }
+
+    scratch = solver_new_scratch(usage);
+
+    /*
+     * Place all the clue numbers we are given.
+     */
+    for (x = 0; x < cr; x++)
+        for (y = 0; y < cr; y++) {
+            int n = grid[y*cr+x];
+            if (n) {
+                if (!cube(x,y,n)) {
+                    diff = DIFF_IMPOSSIBLE;
+                    goto got_result;
+                }
+                solver_place(usage, x, y, grid[y*cr+x]);
+            }
+        }
+
+    /*
+     * Now loop over the grid repeatedly trying all permitted modes
+     * of reasoning. The loop terminates if we complete an
+     * iteration without making any progress; we then return
+     * failure or success depending on whether the grid is full or
+     * not.
+     */
+    while (1) {
+        /*
+         * I'd like to write `continue;' inside each of the
+         * following loops, so that the solver returns here after
+         * making some progress. However, I can't specify that I
+         * want to continue an outer loop rather than the innermost
+         * one, so I'm apologetically resorting to a goto.
+         */
+        cont:
+
+        /*
+         * Blockwise positional elimination.
+         */
+        for (b = 0; b < cr; b++)
+            for (n = 1; n <= cr; n++)
+                if (!usage->blk[b*cr+n-1]) {
+                    for (i = 0; i < cr; i++)
+                        scratch->indexlist[i] = cubepos2(usage->blocks->blocks[b][i],n);
+                    ret = solver_elim(usage, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                                      , "positional elimination,"
+                                      " %d in block %s", n,
+                                      usage->blocks->blocknames[b]
+#endif
+                                      );
+                    if (ret < 0) {
+                        diff = DIFF_IMPOSSIBLE;
+                        goto got_result;
+                    } else if (ret > 0) {
+                        diff = max(diff, DIFF_BLOCK);
+                        goto cont;
+                    }
+                }
+
+        if (usage->kclues != NULL) {
+            int changed = FALSE;
+
+            /*
+             * First, bring the kblocks into a more useful form: remove
+             * all filled-in squares, and reduce the sum by their values.
+             * Walk in reverse order, since otherwise remove_from_block
+             * can move element past our loop counter.
+             */
+            for (b = 0; b < usage->kblocks->nr_blocks; b++)
+                for (i = usage->kblocks->nr_squares[b] -1; i >= 0; i--) {
+                    int x = usage->kblocks->blocks[b][i];
+                    int t = usage->grid[x];
+
+                    if (t == 0)
+                        continue;
+                    remove_from_block(usage->kblocks, b, x);
+                    if (t > usage->kclues[b]) {
+                        diff = DIFF_IMPOSSIBLE;
+                        goto got_result;
+                    }
+                    usage->kclues[b] -= t;
+                    /*
+                     * Since cages are regions, this tells us something
+                     * about the other squares in the cage.
+                     */
+                    for (n = 0; n < usage->kblocks->nr_squares[b]; n++) {
+                        cube2(usage->kblocks->blocks[b][n], t) = FALSE;
+                    }
+                }
+
+            /*
+             * The most trivial kind of solver for killer puzzles: fill
+             * single-square cages.
+             */
+            for (b = 0; b < usage->kblocks->nr_blocks; b++) {
+                int squares = usage->kblocks->nr_squares[b];
+                if (squares == 1) {
+                    int v = usage->kclues[b];
+                    if (v < 1 || v > cr) {
+                        diff = DIFF_IMPOSSIBLE;
+                        goto got_result;
+                    }
+                    x = usage->kblocks->blocks[b][0] % cr;
+                    y = usage->kblocks->blocks[b][0] / cr;
+                    if (!cube(x, y, v)) {
+                        diff = DIFF_IMPOSSIBLE;
+                        goto got_result;
+                    }
+                    solver_place(usage, x, y, v);
+
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*s  placing %d at (%d,%d)\n",
+                               solver_recurse_depth*4, "killer single-square cage",
+                               v, 1 + x%cr, 1 + x/cr);
+                    }
+#endif
+                    changed = TRUE;
+                }
+            }
+
+            if (changed) {
+                kdiff = max(kdiff, DIFF_KSINGLE);
+                goto cont;
+            }
+        }
+        if (dlev->maxkdiff >= DIFF_KINTERSECT && usage->kclues != NULL) {
+            int changed = FALSE;
+            /*
+             * Now, create the extra_cages information.  Every full region
+             * (row, column, or block) has the same sum total (45 for 3x3
+             * puzzles.  After we try to cover these regions with cages that
+             * lie entirely within them, any squares that remain must bring
+             * the total to this known value, and so they form additional
+             * cages which aren't immediately evident in the displayed form
+             * of the puzzle.
+             */
+            usage->extra_cages->nr_blocks = 0;
+            for (i = 0; i < 3; i++) {
+                for (n = 0; n < cr; n++) {
+                    int *region = usage->regions + cr*n*3 + i*cr;
+                    int sum = cr * (cr + 1) / 2;
+                    int nsquares = cr;
+                    int filtered;
+                    int n_extra = usage->extra_cages->nr_blocks;
+                    int *extra_list = usage->extra_cages->blocks[n_extra];
+                    memcpy(extra_list, region, cr * sizeof *extra_list);
+
+                    nsquares = filter_whole_cages(usage, extra_list, nsquares, &filtered);
+                    sum -= filtered;
+                    if (nsquares == cr || nsquares == 0)
+                        continue;
+                    if (dlev->maxdiff >= DIFF_RECURSIVE) {
+                        if (sum <= 0) {
+                            dlev->diff = DIFF_IMPOSSIBLE;
+                            goto got_result;
+                        }
+                    }
+                    assert(sum > 0);
+
+                    if (nsquares == 1) {
+                        if (sum > cr) {
+                            diff = DIFF_IMPOSSIBLE;
+                            goto got_result;
+                        }
+                        x = extra_list[0] % cr;
+                        y = extra_list[0] / cr;
+                        if (!cube(x, y, sum)) {
+                            diff = DIFF_IMPOSSIBLE;
+                            goto got_result;
+                        }
+                        solver_place(usage, x, y, sum);
+                        changed = TRUE;
+#ifdef STANDALONE_SOLVER
+                        if (solver_show_working) {
+                            printf("%*s  placing %d at (%d,%d)\n",
+                                   solver_recurse_depth*4, "killer single-square deduced cage",
+                                   sum, 1 + x, 1 + y);
+                        }
+#endif
+                    }
+
+                    b = usage->kblocks->whichblock[extra_list[0]];
+                    for (x = 1; x < nsquares; x++)
+                        if (usage->kblocks->whichblock[extra_list[x]] != b)
+                            break;
+                    if (x == nsquares) {
+                        assert(usage->kblocks->nr_squares[b] > nsquares);
+                        split_block(usage->kblocks, extra_list, nsquares);
+                        assert(usage->kblocks->nr_squares[usage->kblocks->nr_blocks - 1] == nsquares);
+                        usage->kclues[usage->kblocks->nr_blocks - 1] = sum;
+                        usage->kclues[b] -= sum;
+                    } else {
+                        usage->extra_cages->nr_squares[n_extra] = nsquares;
+                        usage->extra_cages->nr_blocks++;
+                        usage->extra_clues[n_extra] = sum;
+                    }
+                }
+            }
+            if (changed) {
+                kdiff = max(kdiff, DIFF_KINTERSECT);
+                goto cont;
+            }
+        }
+
+        /*
+         * Another simple killer-type elimination.  For every square in a
+         * cage, find the minimum and maximum possible sums of all the
+         * other squares in the same cage, and rule out possibilities
+         * for the given square based on whether they are guaranteed to
+         * cause the sum to be either too high or too low.
+         * This is a special case of trying all possible sums across a
+         * region, which is a recursive algorithm.  We should probably
+         * implement it for a higher difficulty level.
+         */
+        if (dlev->maxkdiff >= DIFF_KMINMAX && usage->kclues != NULL) {
+            int changed = FALSE;
+            for (b = 0; b < usage->kblocks->nr_blocks; b++) {
+                int ret = solver_killer_minmax(usage, usage->kblocks,
+                                               usage->kclues, b
+#ifdef STANDALONE_SOLVER
+                                             , ""
+#endif
+                                               );
+                if (ret < 0) {
+                    diff = DIFF_IMPOSSIBLE;
+                    goto got_result;
+                } else if (ret > 0)
+                    changed = TRUE;
+            }
+            for (b = 0; b < usage->extra_cages->nr_blocks; b++) {
+                int ret = solver_killer_minmax(usage, usage->extra_cages,
+                                               usage->extra_clues, b
+#ifdef STANDALONE_SOLVER
+                                               , "using deduced cages"
+#endif
+                                               );
+                if (ret < 0) {
+                    diff = DIFF_IMPOSSIBLE;
+                    goto got_result;
+                } else if (ret > 0)
+                    changed = TRUE;
+            }
+            if (changed) {
+                kdiff = max(kdiff, DIFF_KMINMAX);
+                goto cont;
+            }
+        }
+
+        /*
+         * Try to use knowledge of which numbers can be used to generate
+         * a given sum.
+         * This can only be used if a cage lies entirely within a region.
+         */
+        if (dlev->maxkdiff >= DIFF_KSUMS && usage->kclues != NULL) {
+            int changed = FALSE;
+
+            for (b = 0; b < usage->kblocks->nr_blocks; b++) {
+                int ret = solver_killer_sums(usage, b, usage->kblocks,
+                                             usage->kclues[b], TRUE
+#ifdef STANDALONE_SOLVER
+                                             , "regular clues"
+#endif
+                                             );
+                if (ret > 0) {
+                    changed = TRUE;
+                    kdiff = max(kdiff, DIFF_KSUMS);
+                } else if (ret < 0) {
+                    diff = DIFF_IMPOSSIBLE;
+                    goto got_result;
+                }
+            }
+
+            for (b = 0; b < usage->extra_cages->nr_blocks; b++) {
+                int ret = solver_killer_sums(usage, b, usage->extra_cages,
+                                             usage->extra_clues[b], FALSE
+#ifdef STANDALONE_SOLVER
+                                             , "deduced clues"
+#endif
+                                             );
+                if (ret > 0) {
+                    changed = TRUE;
+                    kdiff = max(kdiff, DIFF_KSUMS);
+                } else if (ret < 0) {
+                    diff = DIFF_IMPOSSIBLE;
+                    goto got_result;
+                }
+            }
+
+            if (changed)
+                goto cont;
+        }
+
+        if (dlev->maxdiff <= DIFF_BLOCK)
+            break;
+
+        /*
+         * Row-wise positional elimination.
+         */
+        for (y = 0; y < cr; y++)
+            for (n = 1; n <= cr; n++)
+                if (!usage->row[y*cr+n-1]) {
+                    for (x = 0; x < cr; x++)
+                        scratch->indexlist[x] = cubepos(x, y, n);
+                    ret = solver_elim(usage, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                                      , "positional elimination,"
+                                      " %d in row %d", n, 1+y
+#endif
+                                      );
+                    if (ret < 0) {
+                        diff = DIFF_IMPOSSIBLE;
+                        goto got_result;
+                    } else if (ret > 0) {
+                        diff = max(diff, DIFF_SIMPLE);
+                        goto cont;
+                    }
+                }
+        /*
+         * Column-wise positional elimination.
+         */
+        for (x = 0; x < cr; x++)
+            for (n = 1; n <= cr; n++)
+                if (!usage->col[x*cr+n-1]) {
+                    for (y = 0; y < cr; y++)
+                        scratch->indexlist[y] = cubepos(x, y, n);
+                    ret = solver_elim(usage, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                                      , "positional elimination,"
+                                      " %d in column %d", n, 1+x
+#endif
+                                      );
+                    if (ret < 0) {
+                        diff = DIFF_IMPOSSIBLE;
+                        goto got_result;
+                    } else if (ret > 0) {
+                        diff = max(diff, DIFF_SIMPLE);
+                        goto cont;
+                    }
+                }
+
+        /*
+         * X-diagonal positional elimination.
+         */
+        if (usage->diag) {
+            for (n = 1; n <= cr; n++)
+                if (!usage->diag[n-1]) {
+                    for (i = 0; i < cr; i++)
+                        scratch->indexlist[i] = cubepos2(diag0(i), n);
+                    ret = solver_elim(usage, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                                      , "positional elimination,"
+                                      " %d in \\-diagonal", n
+#endif
+                                      );
+                    if (ret < 0) {
+                        diff = DIFF_IMPOSSIBLE;
+                        goto got_result;
+                    } else if (ret > 0) {
+                        diff = max(diff, DIFF_SIMPLE);
+                        goto cont;
+                    }
+                }
+            for (n = 1; n <= cr; n++)
+                if (!usage->diag[cr+n-1]) {
+                    for (i = 0; i < cr; i++)
+                        scratch->indexlist[i] = cubepos2(diag1(i), n);
+                    ret = solver_elim(usage, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                                      , "positional elimination,"
+                                      " %d in /-diagonal", n
+#endif
+                                      );
+                    if (ret < 0) {
+                        diff = DIFF_IMPOSSIBLE;
+                        goto got_result;
+                    } else if (ret > 0) {
+                        diff = max(diff, DIFF_SIMPLE);
+                        goto cont;
+                    }
+                }
+        }
+
+        /*
+         * Numeric elimination.
+         */
+        for (x = 0; x < cr; x++)
+            for (y = 0; y < cr; y++)
+                if (!usage->grid[y*cr+x]) {
+                    for (n = 1; n <= cr; n++)
+                        scratch->indexlist[n-1] = cubepos(x, y, n);
+                    ret = solver_elim(usage, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                                      , "numeric elimination at (%d,%d)",
+                                      1+x, 1+y
+#endif
+                                      );
+                    if (ret < 0) {
+                        diff = DIFF_IMPOSSIBLE;
+                        goto got_result;
+                    } else if (ret > 0) {
+                        diff = max(diff, DIFF_SIMPLE);
+                        goto cont;
+                    }
+                }
+
+        if (dlev->maxdiff <= DIFF_SIMPLE)
+            break;
+
+        /*
+         * Intersectional analysis, rows vs blocks.
+         */
+        for (y = 0; y < cr; y++)
+            for (b = 0; b < cr; b++)
+                for (n = 1; n <= cr; n++) {
+                    if (usage->row[y*cr+n-1] ||
+                        usage->blk[b*cr+n-1])
+                        continue;
+                    for (i = 0; i < cr; i++) {
+                        scratch->indexlist[i] = cubepos(i, y, n);
+                        scratch->indexlist2[i] = cubepos2(usage->blocks->blocks[b][i], n);
+                    }
+                    /*
+                     * solver_intersect() never returns -1.
+                     */
+                    if (solver_intersect(usage, scratch->indexlist,
+                                         scratch->indexlist2
+#ifdef STANDALONE_SOLVER
+                                          , "intersectional analysis,"
+                                          " %d in row %d vs block %s",
+                                          n, 1+y, usage->blocks->blocknames[b]
+#endif
+                                          ) ||
+                         solver_intersect(usage, scratch->indexlist2,
+                                         scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                                          , "intersectional analysis,"
+                                          " %d in block %s vs row %d",
+                                          n, usage->blocks->blocknames[b], 1+y
+#endif
+                                          )) {
+                        diff = max(diff, DIFF_INTERSECT);
+                        goto cont;
+                    }
+                }
+
+        /*
+         * Intersectional analysis, columns vs blocks.
+         */
+        for (x = 0; x < cr; x++)
+            for (b = 0; b < cr; b++)
+                for (n = 1; n <= cr; n++) {
+                    if (usage->col[x*cr+n-1] ||
+                        usage->blk[b*cr+n-1])
+                        continue;
+                    for (i = 0; i < cr; i++) {
+                        scratch->indexlist[i] = cubepos(x, i, n);
+                        scratch->indexlist2[i] = cubepos2(usage->blocks->blocks[b][i], n);
+                    }
+                    if (solver_intersect(usage, scratch->indexlist,
+                                         scratch->indexlist2
+#ifdef STANDALONE_SOLVER
+                                          , "intersectional analysis,"
+                                          " %d in column %d vs block %s",
+                                          n, 1+x, usage->blocks->blocknames[b]
+#endif
+                                          ) ||
+                         solver_intersect(usage, scratch->indexlist2,
+                                         scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                                          , "intersectional analysis,"
+                                          " %d in block %s vs column %d",
+                                          n, usage->blocks->blocknames[b], 1+x
+#endif
+                                          )) {
+                        diff = max(diff, DIFF_INTERSECT);
+                        goto cont;
+                    }
+                }
+
+        if (usage->diag) {
+            /*
+             * Intersectional analysis, \-diagonal vs blocks.
+             */
+            for (b = 0; b < cr; b++)
+                for (n = 1; n <= cr; n++) {
+                    if (usage->diag[n-1] ||
+                        usage->blk[b*cr+n-1])
+                        continue;
+                    for (i = 0; i < cr; i++) {
+                        scratch->indexlist[i] = cubepos2(diag0(i), n);
+                        scratch->indexlist2[i] = cubepos2(usage->blocks->blocks[b][i], n);
+                    }
+                    if (solver_intersect(usage, scratch->indexlist,
+                                         scratch->indexlist2
+#ifdef STANDALONE_SOLVER
+                                          , "intersectional analysis,"
+                                          " %d in \\-diagonal vs block %s",
+                                          n, usage->blocks->blocknames[b]
+#endif
+                                          ) ||
+                         solver_intersect(usage, scratch->indexlist2,
+                                         scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                                          , "intersectional analysis,"
+                                          " %d in block %s vs \\-diagonal",
+                                          n, usage->blocks->blocknames[b]
+#endif
+                                          )) {
+                        diff = max(diff, DIFF_INTERSECT);
+                        goto cont;
+                    }
+                }
+
+            /*
+             * Intersectional analysis, /-diagonal vs blocks.
+             */
+            for (b = 0; b < cr; b++)
+                for (n = 1; n <= cr; n++) {
+                    if (usage->diag[cr+n-1] ||
+                        usage->blk[b*cr+n-1])
+                        continue;
+                    for (i = 0; i < cr; i++) {
+                        scratch->indexlist[i] = cubepos2(diag1(i), n);
+                        scratch->indexlist2[i] = cubepos2(usage->blocks->blocks[b][i], n);
+                    }
+                    if (solver_intersect(usage, scratch->indexlist,
+                                         scratch->indexlist2
+#ifdef STANDALONE_SOLVER
+                                          , "intersectional analysis,"
+                                          " %d in /-diagonal vs block %s",
+                                          n, usage->blocks->blocknames[b]
+#endif
+                                          ) ||
+                         solver_intersect(usage, scratch->indexlist2,
+                                         scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                                          , "intersectional analysis,"
+                                          " %d in block %s vs /-diagonal",
+                                          n, usage->blocks->blocknames[b]
+#endif
+                                          )) {
+                        diff = max(diff, DIFF_INTERSECT);
+                        goto cont;
+                    }
+                }
+        }
+
+        if (dlev->maxdiff <= DIFF_INTERSECT)
+            break;
+
+        /*
+         * Blockwise set elimination.
+         */
+        for (b = 0; b < cr; b++) {
+            for (i = 0; i < cr; i++)
+                for (n = 1; n <= cr; n++)
+                    scratch->indexlist[i*cr+n-1] = cubepos2(usage->blocks->blocks[b][i], n);
+            ret = solver_set(usage, scratch, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                             , "set elimination, block %s",
+                             usage->blocks->blocknames[b]
+#endif
+                                 );
+            if (ret < 0) {
+                diff = DIFF_IMPOSSIBLE;
+                goto got_result;
+            } else if (ret > 0) {
+                diff = max(diff, DIFF_SET);
+                goto cont;
+            }
+        }
+
+        /*
+         * Row-wise set elimination.
+         */
+        for (y = 0; y < cr; y++) {
+            for (x = 0; x < cr; x++)
+                for (n = 1; n <= cr; n++)
+                    scratch->indexlist[x*cr+n-1] = cubepos(x, y, n);
+            ret = solver_set(usage, scratch, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                             , "set elimination, row %d", 1+y
+#endif
+                             );
+            if (ret < 0) {
+                diff = DIFF_IMPOSSIBLE;
+                goto got_result;
+            } else if (ret > 0) {
+                diff = max(diff, DIFF_SET);
+                goto cont;
+            }
+        }
+
+        /*
+         * Column-wise set elimination.
+         */
+        for (x = 0; x < cr; x++) {
+            for (y = 0; y < cr; y++)
+                for (n = 1; n <= cr; n++)
+                    scratch->indexlist[y*cr+n-1] = cubepos(x, y, n);
+            ret = solver_set(usage, scratch, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                             , "set elimination, column %d", 1+x
+#endif
+                             );
+            if (ret < 0) {
+                diff = DIFF_IMPOSSIBLE;
+                goto got_result;
+            } else if (ret > 0) {
+                diff = max(diff, DIFF_SET);
+                goto cont;
+            }
+        }
+
+        if (usage->diag) {
+            /*
+             * \-diagonal set elimination.
+             */
+            for (i = 0; i < cr; i++)
+                for (n = 1; n <= cr; n++)
+                    scratch->indexlist[i*cr+n-1] = cubepos2(diag0(i), n);
+            ret = solver_set(usage, scratch, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                             , "set elimination, \\-diagonal"
+#endif
+                             );
+            if (ret < 0) {
+                diff = DIFF_IMPOSSIBLE;
+                goto got_result;
+            } else if (ret > 0) {
+                diff = max(diff, DIFF_SET);
+                goto cont;
+            }
+
+            /*
+             * /-diagonal set elimination.
+             */
+            for (i = 0; i < cr; i++)
+                for (n = 1; n <= cr; n++)
+                    scratch->indexlist[i*cr+n-1] = cubepos2(diag1(i), n);
+            ret = solver_set(usage, scratch, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                             , "set elimination, /-diagonal"
+#endif
+                             );
+            if (ret < 0) {
+                diff = DIFF_IMPOSSIBLE;
+                goto got_result;
+            } else if (ret > 0) {
+                diff = max(diff, DIFF_SET);
+                goto cont;
+            }
+        }
+
+        if (dlev->maxdiff <= DIFF_SET)
+            break;
+
+        /*
+         * Row-vs-column set elimination on a single number.
+         */
+        for (n = 1; n <= cr; n++) {
+            for (y = 0; y < cr; y++)
+                for (x = 0; x < cr; x++)
+                    scratch->indexlist[y*cr+x] = cubepos(x, y, n);
+            ret = solver_set(usage, scratch, scratch->indexlist
+#ifdef STANDALONE_SOLVER
+                             , "positional set elimination, number %d", n
+#endif
+                             );
+            if (ret < 0) {
+                diff = DIFF_IMPOSSIBLE;
+                goto got_result;
+            } else if (ret > 0) {
+                diff = max(diff, DIFF_EXTREME);
+                goto cont;
+            }
+        }
+
+        /*
+         * Forcing chains.
+         */
+        if (solver_forcing(usage, scratch)) {
+            diff = max(diff, DIFF_EXTREME);
+            goto cont;
+        }
+
+        /*
+         * If we reach here, we have made no deductions in this
+         * iteration, so the algorithm terminates.
+         */
+        break;
+    }
+
+    /*
+     * Last chance: if we haven't fully solved the puzzle yet, try
+     * recursing based on guesses for a particular square. We pick
+     * one of the most constrained empty squares we can find, which
+     * has the effect of pruning the search tree as much as
+     * possible.
+     */
+    if (dlev->maxdiff >= DIFF_RECURSIVE) {
+        int best, bestcount;
+
+        best = -1;
+        bestcount = cr+1;
+
+        for (y = 0; y < cr; y++)
+            for (x = 0; x < cr; x++)
+                if (!grid[y*cr+x]) {
+                    int count;
+
+                    /*
+                     * An unfilled square. Count the number of
+                     * possible digits in it.
+                     */
+                    count = 0;
+                    for (n = 1; n <= cr; n++)
+                        if (cube(x,y,n))
+                            count++;
+
+                    /*
+                     * We should have found any impossibilities
+                     * already, so this can safely be an assert.
+                     */
+                    assert(count > 1);
+
+                    if (count < bestcount) {
+                        bestcount = count;
+                        best = y*cr+x;
+                    }
+                }
+
+        if (best != -1) {
+            int i, j;
+            digit *list, *ingrid, *outgrid;
+
+            diff = DIFF_IMPOSSIBLE;    /* no solution found yet */
+
+            /*
+             * Attempt recursion.
+             */
+            y = best / cr;
+            x = best % cr;
+
+            list = snewn(cr, digit);
+            ingrid = snewn(cr * cr, digit);
+            outgrid = snewn(cr * cr, digit);
+            memcpy(ingrid, grid, cr * cr);
+
+            /* Make a list of the possible digits. */
+            for (j = 0, n = 1; n <= cr; n++)
+                if (cube(x,y,n))
+                    list[j++] = n;
+
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working) {
+                char *sep = "";
+                printf("%*srecursing on (%d,%d) [",
+                       solver_recurse_depth*4, "", x + 1, y + 1);
+                for (i = 0; i < j; i++) {
+                    printf("%s%d", sep, list[i]);
+                    sep = " or ";
+                }
+                printf("]\n");
+            }
+#endif
+
+            /*
+             * And step along the list, recursing back into the
+             * main solver at every stage.
+             */
+            for (i = 0; i < j; i++) {
+                memcpy(outgrid, ingrid, cr * cr);
+                outgrid[y*cr+x] = list[i];
+
+#ifdef STANDALONE_SOLVER
+                if (solver_show_working)
+                    printf("%*sguessing %d at (%d,%d)\n",
+                           solver_recurse_depth*4, "", list[i], x + 1, y + 1);
+                solver_recurse_depth++;
+#endif
+
+                solver(cr, blocks, kblocks, xtype, outgrid, kgrid, dlev);
+
+#ifdef STANDALONE_SOLVER
+                solver_recurse_depth--;
+                if (solver_show_working) {
+                    printf("%*sretracting %d at (%d,%d)\n",
+                           solver_recurse_depth*4, "", list[i], x + 1, y + 1);
+                }
+#endif
+
+                /*
+                 * If we have our first solution, copy it into the
+                 * grid we will return.
+                 */
+                if (diff == DIFF_IMPOSSIBLE && dlev->diff != DIFF_IMPOSSIBLE)
+                    memcpy(grid, outgrid, cr*cr);
+
+                if (dlev->diff == DIFF_AMBIGUOUS)
+                    diff = DIFF_AMBIGUOUS;
+                else if (dlev->diff == DIFF_IMPOSSIBLE)
+                    /* do not change our return value */;
+                else {
+                    /* the recursion turned up exactly one solution */
+                    if (diff == DIFF_IMPOSSIBLE)
+                        diff = DIFF_RECURSIVE;
+                    else
+                        diff = DIFF_AMBIGUOUS;
+                }
+
+                /*
+                 * As soon as we've found more than one solution,
+                 * give up immediately.
+                 */
+                if (diff == DIFF_AMBIGUOUS)
+                    break;
+            }
+
+            sfree(outgrid);
+            sfree(ingrid);
+            sfree(list);
+        }
+
+    } else {
+        /*
+         * We're forbidden to use recursion, so we just see whether
+         * our grid is fully solved, and return DIFF_IMPOSSIBLE
+         * otherwise.
+         */
+        for (y = 0; y < cr; y++)
+            for (x = 0; x < cr; x++)
+                if (!grid[y*cr+x])
+                    diff = DIFF_IMPOSSIBLE;
+    }
+
+    got_result:
+    dlev->diff = diff;
+    dlev->kdiff = kdiff;
+
+#ifdef STANDALONE_SOLVER
+    if (solver_show_working)
+        printf("%*s%s found\n",
+               solver_recurse_depth*4, "",
+               diff == DIFF_IMPOSSIBLE ? "no solution" :
+               diff == DIFF_AMBIGUOUS ? "multiple solutions" :
+               "one solution");
+#endif
+
+    sfree(usage->sq2region);
+    sfree(usage->regions);
+    sfree(usage->cube);
+    sfree(usage->row);
+    sfree(usage->col);
+    sfree(usage->blk);
+    if (usage->kblocks) {
+        free_block_structure(usage->kblocks);
+        free_block_structure(usage->extra_cages);
+        sfree(usage->extra_clues);
+    }
+    if (usage->kclues) sfree(usage->kclues);
+    sfree(usage);
+
+    solver_free_scratch(scratch);
+}
+
+/* ----------------------------------------------------------------------
+ * End of solver code.
+ */
+
+/* ----------------------------------------------------------------------
+ * Killer set generator.
+ */
+
+/* ----------------------------------------------------------------------
+ * Solo filled-grid generator.
+ *
+ * This grid generator works by essentially trying to solve a grid
+ * starting from no clues, and not worrying that there's more than
+ * one possible solution. Unfortunately, it isn't computationally
+ * feasible to do this by calling the above solver with an empty
+ * grid, because that one needs to allocate a lot of scratch space
+ * at every recursion level. Instead, I have a much simpler
+ * algorithm which I shamelessly copied from a Python solver
+ * written by Andrew Wilkinson (which is GPLed, but I've reused
+ * only ideas and no code). It mostly just does the obvious
+ * recursive thing: pick an empty square, put one of the possible
+ * digits in it, recurse until all squares are filled, backtrack
+ * and change some choices if necessary.
+ *
+ * The clever bit is that every time it chooses which square to
+ * fill in next, it does so by counting the number of _possible_
+ * numbers that can go in each square, and it prioritises so that
+ * it picks a square with the _lowest_ number of possibilities. The
+ * idea is that filling in lots of the obvious bits (particularly
+ * any squares with only one possibility) will cut down on the list
+ * of possibilities for other squares and hence reduce the enormous
+ * search space as much as possible as early as possible.
+ *
+ * The use of bit sets implies that we support puzzles up to a size of
+ * 32x32 (less if anyone finds a 16-bit machine to compile this on).
+ */
+
+/*
+ * Internal data structure used in gridgen to keep track of
+ * progress.
+ */
+struct gridgen_coord { int x, y, r; };
+struct gridgen_usage {
+    int cr;
+    struct block_structure *blocks, *kblocks;
+    /* grid is a copy of the input grid, modified as we go along */
+    digit *grid;
+    /*
+     * Bitsets.  In each of them, bit n is set if digit n has been placed
+     * in the corresponding region.  row, col and blk are used for all
+     * puzzles.  cge is used only for killer puzzles, and diag is used
+     * only for x-type puzzles.
+     * All of these have cr entries, except diag which only has 2,
+     * and cge, which has as many entries as kblocks.
+     */
+    unsigned int *row, *col, *blk, *cge, *diag;
+    /* This lists all the empty spaces remaining in the grid. */
+    struct gridgen_coord *spaces;
+    int nspaces;
+    /* If we need randomisation in the solve, this is our random state. */
+    random_state *rs;
+};
+
+static void gridgen_place(struct gridgen_usage *usage, int x, int y, digit n)
+{
+    unsigned int bit = 1 << n;
+    int cr = usage->cr;
+    usage->row[y] |= bit;
+    usage->col[x] |= bit;
+    usage->blk[usage->blocks->whichblock[y*cr+x]] |= bit;
+    if (usage->cge)
+        usage->cge[usage->kblocks->whichblock[y*cr+x]] |= bit;
+    if (usage->diag) {
+        if (ondiag0(y*cr+x))
+            usage->diag[0] |= bit;
+        if (ondiag1(y*cr+x))
+            usage->diag[1] |= bit;
+    }
+    usage->grid[y*cr+x] = n;
+}
+
+static void gridgen_remove(struct gridgen_usage *usage, int x, int y, digit n)
+{
+    unsigned int mask = ~(1 << n);
+    int cr = usage->cr;
+    usage->row[y] &= mask;
+    usage->col[x] &= mask;
+    usage->blk[usage->blocks->whichblock[y*cr+x]] &= mask;
+    if (usage->cge)
+        usage->cge[usage->kblocks->whichblock[y*cr+x]] &= mask;
+    if (usage->diag) {
+        if (ondiag0(y*cr+x))
+            usage->diag[0] &= mask;
+        if (ondiag1(y*cr+x))
+            usage->diag[1] &= mask;
+    }
+    usage->grid[y*cr+x] = 0;
+}
+
+#define N_SINGLE 32
+
+/*
+ * The real recursive step in the generating function.
+ *
+ * Return values: 1 means solution found, 0 means no solution
+ * found on this branch.
+ */
+static int gridgen_real(struct gridgen_usage *usage, digit *grid, int *steps)
+{
+    int cr = usage->cr;
+    int i, j, n, sx, sy, bestm, bestr, ret;
+    int *digits;
+    unsigned int used;
+
+    /*
+     * Firstly, check for completion! If there are no spaces left
+     * in the grid, we have a solution.
+     */
+    if (usage->nspaces == 0)
+        return TRUE;
+
+    /*
+     * Next, abandon generation if we went over our steps limit.
+     */
+    if (*steps <= 0)
+        return FALSE;
+    (*steps)--;
+
+    /*
+     * Otherwise, there must be at least one space. Find the most
+     * constrained space, using the `r' field as a tie-breaker.
+     */
+    bestm = cr+1;                      /* so that any space will beat it */
+    bestr = 0;
+    used = ~0;
+    i = sx = sy = -1;
+    for (j = 0; j < usage->nspaces; j++) {
+        int x = usage->spaces[j].x, y = usage->spaces[j].y;
+        unsigned int used_xy;
+        int m;
+
+        m = usage->blocks->whichblock[y*cr+x];
+        used_xy = usage->row[y] | usage->col[x] | usage->blk[m];
+        if (usage->cge != NULL)
+            used_xy |= usage->cge[usage->kblocks->whichblock[y*cr+x]];
+        if (usage->cge != NULL)
+            used_xy |= usage->cge[usage->kblocks->whichblock[y*cr+x]];
+        if (usage->diag != NULL) {
+            if (ondiag0(y*cr+x))
+                used_xy |= usage->diag[0];
+            if (ondiag1(y*cr+x))
+                used_xy |= usage->diag[1];
+        }
+
+        /*
+         * Find the number of digits that could go in this space.
+         */
+        m = 0;
+        for (n = 1; n <= cr; n++) {
+            unsigned int bit = 1 << n;
+            if ((used_xy & bit) == 0)
+                m++;
+        }
+        if (m < bestm || (m == bestm && usage->spaces[j].r < bestr)) {
+            bestm = m;
+            bestr = usage->spaces[j].r;
+            sx = x;
+            sy = y;
+            i = j;
+            used = used_xy;
+        }
+    }
+
+    /*
+     * Swap that square into the final place in the spaces array,
+     * so that decrementing nspaces will remove it from the list.
+     */
+    if (i != usage->nspaces-1) {
+        struct gridgen_coord t;
+        t = usage->spaces[usage->nspaces-1];
+        usage->spaces[usage->nspaces-1] = usage->spaces[i];
+        usage->spaces[i] = t;
+    }
+
+    /*
+     * Now we've decided which square to start our recursion at,
+     * simply go through all possible values, shuffling them
+     * randomly first if necessary.
+     */
+    digits = snewn(bestm, int);
+
+    j = 0;
+    for (n = 1; n <= cr; n++) {
+        unsigned int bit = 1 << n;
+
+        if ((used & bit) == 0)
+            digits[j++] = n;
+    }
+
+    if (usage->rs)
+        shuffle(digits, j, sizeof(*digits), usage->rs);
+
+    /* And finally, go through the digit list and actually recurse. */
+    ret = FALSE;
+    for (i = 0; i < j; i++) {
+        n = digits[i];
+
+        /* Update the usage structure to reflect the placing of this digit. */
+        gridgen_place(usage, sx, sy, n);
+        usage->nspaces--;
+
+        /* Call the solver recursively. Stop when we find a solution. */
+        if (gridgen_real(usage, grid, steps)) {
+            ret = TRUE;
+            break;
+        }
+
+        /* Revert the usage structure. */
+        gridgen_remove(usage, sx, sy, n);
+        usage->nspaces++;
+    }
+
+    sfree(digits);
+    return ret;
+}
+
+/*
+ * Entry point to generator. You give it parameters and a starting
+ * grid, which is simply an array of cr*cr digits.
+ */
+static int gridgen(int cr, struct block_structure *blocks,
+                   struct block_structure *kblocks, int xtype,
+                   digit *grid, random_state *rs, int maxsteps)
+{
+    struct gridgen_usage *usage;
+    int x, y, ret;
+
+    /*
+     * Clear the grid to start with.
+     */
+    memset(grid, 0, cr*cr);
+
+    /*
+     * Create a gridgen_usage structure.
+     */
+    usage = snew(struct gridgen_usage);
+
+    usage->cr = cr;
+    usage->blocks = blocks;
+
+    usage->grid = grid;
+
+    usage->row = snewn(cr, unsigned int);
+    usage->col = snewn(cr, unsigned int);
+    usage->blk = snewn(cr, unsigned int);
+    if (kblocks != NULL) {
+        usage->kblocks = kblocks;
+        usage->cge = snewn(usage->kblocks->nr_blocks, unsigned int);
+        memset(usage->cge, FALSE, kblocks->nr_blocks * sizeof *usage->cge);
+    } else {
+        usage->cge = NULL;
+    }
+
+    memset(usage->row, 0, cr * sizeof *usage->row);
+    memset(usage->col, 0, cr * sizeof *usage->col);
+    memset(usage->blk, 0, cr * sizeof *usage->blk);
+
+    if (xtype) {
+        usage->diag = snewn(2, unsigned int);
+        memset(usage->diag, 0, 2 * sizeof *usage->diag);
+    } else {
+        usage->diag = NULL;
+    }
+
+    /*
+     * Begin by filling in the whole top row with randomly chosen
+     * numbers. This cannot introduce any bias or restriction on
+     * the available grids, since we already know those numbers
+     * are all distinct so all we're doing is choosing their
+     * labels.
+     */
+    for (x = 0; x < cr; x++)
+        grid[x] = x+1;
+    shuffle(grid, cr, sizeof(*grid), rs);
+    for (x = 0; x < cr; x++)
+        gridgen_place(usage, x, 0, grid[x]);
+
+    usage->spaces = snewn(cr * cr, struct gridgen_coord);
+    usage->nspaces = 0;
+
+    usage->rs = rs;
+
+    /*
+     * Initialise the list of grid spaces, taking care to leave
+     * out the row I've already filled in above.
+     */
+    for (y = 1; y < cr; y++) {
+        for (x = 0; x < cr; x++) {
+            usage->spaces[usage->nspaces].x = x;
+            usage->spaces[usage->nspaces].y = y;
+            usage->spaces[usage->nspaces].r = random_bits(rs, 31);
+            usage->nspaces++;
+        }
+    }
+
+    /*
+     * Run the real generator function.
+     */
+    ret = gridgen_real(usage, grid, &maxsteps);
+
+    /*
+     * Clean up the usage structure now we have our answer.
+     */
+    sfree(usage->spaces);
+    sfree(usage->cge);
+    sfree(usage->blk);
+    sfree(usage->col);
+    sfree(usage->row);
+    sfree(usage);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * End of grid generator code.
+ */
+
+static int check_killer_cage_sum(struct block_structure *kblocks,
+                                 digit *kgrid, digit *grid, int blk)
+{
+    /*
+     * Returns: -1 if the cage has any empty square; 0 if all squares
+     * are full but the sum is wrong; +1 if all squares are full and
+     * they have the right sum.
+     *
+     * Does not check uniqueness of numbers within the cage; that's
+     * done elsewhere (because in error highlighting it needs to be
+     * detected separately so as to flag the error in a visually
+     * different way).
+     */
+    int n_squares = kblocks->nr_squares[blk];
+    int sum = 0, clue = 0;
+    int i;
+
+    for (i = 0; i < n_squares; i++) {
+        int xy = kblocks->blocks[blk][i];
+
+        if (grid[xy] == 0)
+            return -1;
+        sum += grid[xy];
+
+        if (kgrid[xy]) {
+            assert(clue == 0);
+            clue = kgrid[xy];
+        }
+    }
+
+    assert(clue != 0);
+    return sum == clue;
+}
+
+/*
+ * Check whether a grid contains a valid complete puzzle.
+ */
+static int check_valid(int cr, struct block_structure *blocks,
+                       struct block_structure *kblocks,
+                       digit *kgrid, int xtype, digit *grid)
+{
+    unsigned char *used;
+    int x, y, i, j, n;
+
+    used = snewn(cr, unsigned char);
+
+    /*
+     * Check that each row contains precisely one of everything.
+     */
+    for (y = 0; y < cr; y++) {
+        memset(used, FALSE, cr);
+        for (x = 0; x < cr; x++)
+            if (grid[y*cr+x] > 0 && grid[y*cr+x] <= cr)
+                used[grid[y*cr+x]-1] = TRUE;
+        for (n = 0; n < cr; n++)
+            if (!used[n]) {
+                sfree(used);
+                return FALSE;
+            }
+    }
+
+    /*
+     * Check that each column contains precisely one of everything.
+     */
+    for (x = 0; x < cr; x++) {
+        memset(used, FALSE, cr);
+        for (y = 0; y < cr; y++)
+            if (grid[y*cr+x] > 0 && grid[y*cr+x] <= cr)
+                used[grid[y*cr+x]-1] = TRUE;
+        for (n = 0; n < cr; n++)
+            if (!used[n]) {
+                sfree(used);
+                return FALSE;
+            }
+    }
+
+    /*
+     * Check that each block contains precisely one of everything.
+     */
+    for (i = 0; i < cr; i++) {
+        memset(used, FALSE, cr);
+        for (j = 0; j < cr; j++)
+            if (grid[blocks->blocks[i][j]] > 0 &&
+                grid[blocks->blocks[i][j]] <= cr)
+                used[grid[blocks->blocks[i][j]]-1] = TRUE;
+        for (n = 0; n < cr; n++)
+            if (!used[n]) {
+                sfree(used);
+                return FALSE;
+            }
+    }
+
+    /*
+     * Check that each Killer cage, if any, contains at most one of
+     * everything. If we also know the clues for those cages (which we
+     * might not, when this function is called early in puzzle
+     * generation), we also check that they all have the right sum.
+     */
+    if (kblocks) {
+        for (i = 0; i < kblocks->nr_blocks; i++) {
+            memset(used, FALSE, cr);
+            for (j = 0; j < kblocks->nr_squares[i]; j++)
+                if (grid[kblocks->blocks[i][j]] > 0 &&
+                    grid[kblocks->blocks[i][j]] <= cr) {
+                    if (used[grid[kblocks->blocks[i][j]]-1]) {
+                        sfree(used);
+                        return FALSE;
+                    }
+                    used[grid[kblocks->blocks[i][j]]-1] = TRUE;
+                }
+
+            if (kgrid && check_killer_cage_sum(kblocks, kgrid, grid, i) != 1) {
+                sfree(used);
+                return FALSE;
+            }
+        }
+    }
+
+    /*
+     * Check that each diagonal contains precisely one of everything.
+     */
+    if (xtype) {
+        memset(used, FALSE, cr);
+        for (i = 0; i < cr; i++)
+            if (grid[diag0(i)] > 0 && grid[diag0(i)] <= cr)
+                used[grid[diag0(i)]-1] = TRUE;
+        for (n = 0; n < cr; n++)
+            if (!used[n]) {
+                sfree(used);
+                return FALSE;
+            }
+        for (i = 0; i < cr; i++)
+            if (grid[diag1(i)] > 0 && grid[diag1(i)] <= cr)
+                used[grid[diag1(i)]-1] = TRUE;
+        for (n = 0; n < cr; n++)
+            if (!used[n]) {
+                sfree(used);
+                return FALSE;
+            }
+    }
+
+    sfree(used);
+    return TRUE;
+}
+
+static int symmetries(const game_params *params, int x, int y,
+                      int *output, int s)
+{
+    int c = params->c, r = params->r, cr = c*r;
+    int i = 0;
+
+#define ADD(x,y) (*output++ = (x), *output++ = (y), i++)
+
+    ADD(x, y);
+
+    switch (s) {
+      case SYMM_NONE:
+        break;                         /* just x,y is all we need */
+      case SYMM_ROT2:
+        ADD(cr - 1 - x, cr - 1 - y);
+        break;
+      case SYMM_ROT4:
+        ADD(cr - 1 - y, x);
+        ADD(y, cr - 1 - x);
+        ADD(cr - 1 - x, cr - 1 - y);
+        break;
+      case SYMM_REF2:
+        ADD(cr - 1 - x, y);
+        break;
+      case SYMM_REF2D:
+        ADD(y, x);
+        break;
+      case SYMM_REF4:
+        ADD(cr - 1 - x, y);
+        ADD(x, cr - 1 - y);
+        ADD(cr - 1 - x, cr - 1 - y);
+        break;
+      case SYMM_REF4D:
+        ADD(y, x);
+        ADD(cr - 1 - x, cr - 1 - y);
+        ADD(cr - 1 - y, cr - 1 - x);
+        break;
+      case SYMM_REF8:
+        ADD(cr - 1 - x, y);
+        ADD(x, cr - 1 - y);
+        ADD(cr - 1 - x, cr - 1 - y);
+        ADD(y, x);
+        ADD(y, cr - 1 - x);
+        ADD(cr - 1 - y, x);
+        ADD(cr - 1 - y, cr - 1 - x);
+        break;
+    }
+
+#undef ADD
+
+    return i;
+}
+
+static char *encode_solve_move(int cr, digit *grid)
+{
+    int i, len;
+    char *ret, *p, *sep;
+
+    /*
+     * It's surprisingly easy to work out _exactly_ how long this
+     * string needs to be. To decimal-encode all the numbers from 1
+     * to n:
+     * 
+     *  - every number has a units digit; total is n.
+     *  - all numbers above 9 have a tens digit; total is max(n-9,0).
+     *  - all numbers above 99 have a hundreds digit; total is max(n-99,0).
+     *  - and so on.
+     */
+    len = 0;
+    for (i = 1; i <= cr; i *= 10)
+        len += max(cr - i + 1, 0);
+    len += cr;                 /* don't forget the commas */
+    len *= cr;                 /* there are cr rows of these */
+
+    /*
+     * Now len is one bigger than the total size of the
+     * comma-separated numbers (because we counted an
+     * additional leading comma). We need to have a leading S
+     * and a trailing NUL, so we're off by one in total.
+     */
+    len++;
+
+    ret = snewn(len, char);
+    p = ret;
+    *p++ = 'S';
+    sep = "";
+    for (i = 0; i < cr*cr; i++) {
+        p += sprintf(p, "%s%d", sep, grid[i]);
+        sep = ",";
+    }
+    *p++ = '\0';
+    assert(p - ret == len);
+
+    return ret;
+}
+
+static void dsf_to_blocks(int *dsf, struct block_structure *blocks,
+                          int min_expected, int max_expected)
+{
+    int cr = blocks->c * blocks->r, area = cr * cr;
+    int i, nb = 0;
+
+    for (i = 0; i < area; i++)
+        blocks->whichblock[i] = -1;
+    for (i = 0; i < area; i++) {
+        int j = dsf_canonify(dsf, i);
+        if (blocks->whichblock[j] < 0)
+            blocks->whichblock[j] = nb++;
+        blocks->whichblock[i] = blocks->whichblock[j];
+    }
+    assert(nb >= min_expected && nb <= max_expected);
+    blocks->nr_blocks = nb;
+}
+
+static void make_blocks_from_whichblock(struct block_structure *blocks)
+{
+    int i;
+
+    for (i = 0; i < blocks->nr_blocks; i++) {
+        blocks->blocks[i][blocks->max_nr_squares-1] = 0;
+        blocks->nr_squares[i] = 0;
+    }
+    for (i = 0; i < blocks->area; i++) {
+        int b = blocks->whichblock[i];
+        int j = blocks->blocks[b][blocks->max_nr_squares-1]++;
+        assert(j < blocks->max_nr_squares);
+        blocks->blocks[b][j] = i;
+        blocks->nr_squares[b]++;
+    }
+}
+
+static char *encode_block_structure_desc(char *p, struct block_structure *blocks)
+{
+    int i, currrun = 0;
+    int c = blocks->c, r = blocks->r, cr = c * r;
+
+    /*
+     * Encode the block structure. We do this by encoding
+     * the pattern of dividing lines: first we iterate
+     * over the cr*(cr-1) internal vertical grid lines in
+     * ordinary reading order, then over the cr*(cr-1)
+     * internal horizontal ones in transposed reading
+     * order.
+     * 
+     * We encode the number of non-lines between the
+     * lines; _ means zero (two adjacent divisions), a
+     * means 1, ..., y means 25, and z means 25 non-lines
+     * _and no following line_ (so that za means 26, zb 27
+     * etc).
+     */
+    for (i = 0; i <= 2*cr*(cr-1); i++) {
+        int x, y, p0, p1, edge;
+
+        if (i == 2*cr*(cr-1)) {
+            edge = TRUE;       /* terminating virtual edge */
+        } else {
+            if (i < cr*(cr-1)) {
+                y = i/(cr-1);
+                x = i%(cr-1);
+                p0 = y*cr+x;
+                p1 = y*cr+x+1;
+            } else {
+                x = i/(cr-1) - cr;
+                y = i%(cr-1);
+                p0 = y*cr+x;
+                p1 = (y+1)*cr+x;
+            }
+            edge = (blocks->whichblock[p0] != blocks->whichblock[p1]);
+        }
+
+        if (edge) {
+            while (currrun > 25)
+                *p++ = 'z', currrun -= 25;
+            if (currrun)
+                *p++ = 'a'-1 + currrun;
+            else
+                *p++ = '_';
+            currrun = 0;
+        } else
+            currrun++;
+    }
+    return p;
+}
+
+static char *encode_grid(char *desc, digit *grid, int area)
+{
+    int run, i;
+    char *p = desc;
+
+    run = 0;
+    for (i = 0; i <= area; i++) {
+        int n = (i < area ? grid[i] : -1);
+
+        if (!n)
+            run++;
+        else {
+            if (run) {
+                while (run > 0) {
+                    int c = 'a' - 1 + run;
+                    if (run > 26)
+                        c = 'z';
+                    *p++ = c;
+                    run -= c - ('a' - 1);
+                }
+            } else {
+                /*
+                 * If there's a number in the very top left or
+                 * bottom right, there's no point putting an
+                 * unnecessary _ before or after it.
+                 */
+                if (p > desc && n > 0)
+                    *p++ = '_';
+            }
+            if (n > 0)
+                p += sprintf(p, "%d", n);
+            run = 0;
+        }
+    }
+    return p;
+}
+
+/*
+ * Conservatively stimate the number of characters required for
+ * encoding a grid of a certain area.
+ */
+static int grid_encode_space (int area)
+{
+    int t, count;
+    for (count = 1, t = area; t > 26; t -= 26)
+        count++;
+    return count * area;
+}
+
+/*
+ * Conservatively stimate the number of characters required for
+ * encoding a given blocks structure.
+ */
+static int blocks_encode_space(struct block_structure *blocks)
+{
+    int cr = blocks->c * blocks->r, area = cr * cr;
+    return grid_encode_space(area);
+}
+
+static char *encode_puzzle_desc(const game_params *params, digit *grid,
+                                struct block_structure *blocks,
+                                digit *kgrid,
+                                struct block_structure *kblocks)
+{
+    int c = params->c, r = params->r, cr = c*r;
+    int area = cr*cr;
+    char *p, *desc;
+    int space;
+
+    space = grid_encode_space(area) + 1;
+    if (r == 1)
+        space += blocks_encode_space(blocks) + 1;
+    if (params->killer) {
+        space += blocks_encode_space(kblocks) + 1;
+        space += grid_encode_space(area) + 1;
+    }
+    desc = snewn(space, char);
+    p = encode_grid(desc, grid, area);
+
+    if (r == 1) {
+        *p++ = ',';
+        p = encode_block_structure_desc(p, blocks);
+    }
+    if (params->killer) {
+        *p++ = ',';
+        p = encode_block_structure_desc(p, kblocks);
+        *p++ = ',';
+        p = encode_grid(p, kgrid, area);
+    }
+    assert(p - desc < space);
+    *p++ = '\0';
+    desc = sresize(desc, p - desc, char);
+
+    return desc;
+}
+
+static void merge_blocks(struct block_structure *b, int n1, int n2)
+{
+    int i;
+    /* Move data towards the lower block number.  */
+    if (n2 < n1) {
+        int t = n2;
+        n2 = n1;
+        n1 = t;
+    }
+
+    /* Merge n2 into n1, and move the last block into n2's position.  */
+    for (i = 0; i < b->nr_squares[n2]; i++)
+        b->whichblock[b->blocks[n2][i]] = n1;
+    memcpy(b->blocks[n1] + b->nr_squares[n1], b->blocks[n2],
+           b->nr_squares[n2] * sizeof **b->blocks);
+    b->nr_squares[n1] += b->nr_squares[n2];
+
+    n1 = b->nr_blocks - 1;
+    if (n2 != n1) {
+        memcpy(b->blocks[n2], b->blocks[n1],
+               b->nr_squares[n1] * sizeof **b->blocks);
+        for (i = 0; i < b->nr_squares[n1]; i++)
+            b->whichblock[b->blocks[n1][i]] = n2;
+        b->nr_squares[n2] = b->nr_squares[n1];
+    }
+    b->nr_blocks = n1;
+}
+
+static int merge_some_cages(struct block_structure *b, int cr, int area,
+                             digit *grid, random_state *rs)
+{
+    /*
+     * Make a list of all the pairs of adjacent blocks.
+     */
+    int i, j, k;
+    struct pair {
+        int b1, b2;
+    } *pairs;
+    int npairs;
+
+    pairs = snewn(b->nr_blocks * b->nr_blocks, struct pair);
+    npairs = 0;
+
+    for (i = 0; i < b->nr_blocks; i++) {
+        for (j = i+1; j < b->nr_blocks; j++) {
+
+            /*
+             * Rule the merger out of consideration if it's
+             * obviously not viable.
+             */
+            if (b->nr_squares[i] + b->nr_squares[j] > b->max_nr_squares)
+                continue;              /* we couldn't merge these anyway */
+
+            /*
+             * See if these two blocks have a pair of squares
+             * adjacent to each other.
+             */
+            for (k = 0; k < b->nr_squares[i]; k++) {
+                int xy = b->blocks[i][k];
+                int y = xy / cr, x = xy % cr;
+                if ((y   > 0  && b->whichblock[xy - cr] == j) ||
+                    (y+1 < cr && b->whichblock[xy + cr] == j) ||
+                    (x   > 0  && b->whichblock[xy -  1] == j) ||
+                    (x+1 < cr && b->whichblock[xy +  1] == j)) {
+                    /*
+                     * Yes! Add this pair to our list.
+                     */
+                    pairs[npairs].b1 = i;
+                    pairs[npairs].b2 = j;
+                    break;
+                }
+            }
+        }
+    }
+
+    /*
+     * Now go through that list in random order until we find a pair
+     * of blocks we can merge.
+     */
+    while (npairs > 0) {
+        int n1, n2;
+        unsigned int digits_found;
+
+        /*
+         * Pick a random pair, and remove it from the list.
+         */
+        i = random_upto(rs, npairs);
+        n1 = pairs[i].b1;
+        n2 = pairs[i].b2;
+        if (i != npairs-1)
+            pairs[i] = pairs[npairs-1];
+        npairs--;
+
+        /* Guarantee that the merged cage would still be a region.  */
+        digits_found = 0;
+        for (i = 0; i < b->nr_squares[n1]; i++)
+            digits_found |= 1 << grid[b->blocks[n1][i]];
+        for (i = 0; i < b->nr_squares[n2]; i++)
+            if (digits_found & (1 << grid[b->blocks[n2][i]]))
+                break;
+        if (i != b->nr_squares[n2])
+            continue;
+
+        /*
+         * Got one! Do the merge.
+         */
+        merge_blocks(b, n1, n2);
+        sfree(pairs);
+        return TRUE;
+    }
+
+    sfree(pairs);
+    return FALSE;
+}
+
+static void compute_kclues(struct block_structure *cages, digit *kclues,
+                           digit *grid, int area)
+{
+    int i;
+    memset(kclues, 0, area * sizeof *kclues);
+    for (i = 0; i < cages->nr_blocks; i++) {
+        int j, sum = 0;
+        for (j = 0; j < area; j++)
+            if (cages->whichblock[j] == i)
+                sum += grid[j];
+        for (j = 0; j < area; j++)
+            if (cages->whichblock[j] == i)
+                break;
+        assert (j != area);
+        kclues[j] = sum;
+    }
+}
+
+static struct block_structure *gen_killer_cages(int cr, random_state *rs,
+                                                int remove_singletons)
+{
+    int nr;
+    int x, y, area = cr * cr;
+    int n_singletons = 0;
+    struct block_structure *b = alloc_block_structure (1, cr, area, cr, area);
+
+    for (x = 0; x < area; x++)
+        b->whichblock[x] = -1;
+    nr = 0;
+    for (y = 0; y < cr; y++)
+        for (x = 0; x < cr; x++) {
+            int rnd;
+            int xy = y*cr+x;
+            if (b->whichblock[xy] != -1)
+                continue;
+            b->whichblock[xy] = nr;
+
+            rnd = random_bits(rs, 4);
+            if (xy + 1 < area && (rnd >= 4 || (!remove_singletons && rnd >= 1))) {
+                int xy2 = xy + 1;
+                if (x + 1 == cr || b->whichblock[xy2] != -1 ||
+                    (xy + cr < area && random_bits(rs, 1) == 0))
+                    xy2 = xy + cr;
+                if (xy2 >= area)
+                    n_singletons++;
+                else
+                    b->whichblock[xy2] = nr;
+            } else
+                n_singletons++;
+            nr++;
+        }
+
+    b->nr_blocks = nr;
+    make_blocks_from_whichblock(b);
+
+    for (x = y = 0; x < b->nr_blocks; x++)
+        if (b->nr_squares[x] == 1)
+            y++;
+    assert(y == n_singletons);
+
+    if (n_singletons > 0 && remove_singletons) {
+        int n;
+        for (n = 0; n < b->nr_blocks;) {
+            int xy, x, y, xy2, other;
+            if (b->nr_squares[n] > 1) {
+                n++;
+                continue;
+            }
+            xy = b->blocks[n][0];
+            x = xy % cr;
+            y = xy / cr;
+            if (xy + 1 == area)
+                xy2 = xy - 1;
+            else if (x + 1 < cr && (y + 1 == cr || random_bits(rs, 1) == 0))
+                xy2 = xy + 1;
+            else
+                xy2 = xy + cr;
+            other = b->whichblock[xy2];
+
+            if (b->nr_squares[other] == 1)
+                n_singletons--;
+            n_singletons--;
+            merge_blocks(b, n, other);
+            if (n < other)
+                n++;
+        }
+        assert(n_singletons == 0);
+    }
+    return b;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int c = params->c, r = params->r, cr = c*r;
+    int area = cr*cr;
+    struct block_structure *blocks, *kblocks;
+    digit *grid, *grid2, *kgrid;
+    struct xy { int x, y; } *locs;
+    int nlocs;
+    char *desc;
+    int coords[16], ncoords;
+    int x, y, i, j;
+    struct difficulty dlev;
+
+    precompute_sum_bits();
+
+    /*
+     * Adjust the maximum difficulty level to be consistent with
+     * the puzzle size: all 2x2 puzzles appear to be Trivial
+     * (DIFF_BLOCK) so we cannot hold out for even a Basic
+     * (DIFF_SIMPLE) one.
+     */
+    dlev.maxdiff = params->diff;
+    dlev.maxkdiff = params->kdiff;
+    if (c == 2 && r == 2)
+        dlev.maxdiff = DIFF_BLOCK;
+
+    grid = snewn(area, digit);
+    locs = snewn(area, struct xy);
+    grid2 = snewn(area, digit);
+
+    blocks = alloc_block_structure (c, r, area, cr, cr);
+
+    kblocks = NULL;
+    kgrid = (params->killer) ? snewn(area, digit) : NULL;
+
+#ifdef STANDALONE_SOLVER
+    assert(!"This should never happen, so we don't need to create blocknames");
+#endif
+
+    /*
+     * Loop until we get a grid of the required difficulty. This is
+     * nasty, but it seems to be unpleasantly hard to generate
+     * difficult grids otherwise.
+     */
+    while (1) {
+        /*
+         * Generate a random solved state, starting by
+         * constructing the block structure.
+         */
+        if (r == 1) {                  /* jigsaw mode */
+            int *dsf = divvy_rectangle(cr, cr, cr, rs);
+
+            dsf_to_blocks (dsf, blocks, cr, cr);
+
+            sfree(dsf);
+        } else {                       /* basic Sudoku mode */
+            for (y = 0; y < cr; y++)
+                for (x = 0; x < cr; x++)
+                    blocks->whichblock[y*cr+x] = (y/c) * c + (x/r);
+        }
+        make_blocks_from_whichblock(blocks);
+
+        if (params->killer) {
+            if (kblocks) free_block_structure(kblocks);
+            kblocks = gen_killer_cages(cr, rs, params->kdiff > DIFF_KSINGLE);
+        }
+
+        if (!gridgen(cr, blocks, kblocks, params->xtype, grid, rs, area*area))
+            continue;
+        assert(check_valid(cr, blocks, kblocks, NULL, params->xtype, grid));
+
+        /*
+         * Save the solved grid in aux.
+         */
+        {
+            /*
+             * We might already have written *aux the last time we
+             * went round this loop, in which case we should free
+             * the old aux before overwriting it with the new one.
+             */
+            if (*aux) {
+                sfree(*aux);
+            }
+
+            *aux = encode_solve_move(cr, grid);
+        }
+
+        /*
+         * Now we have a solved grid. For normal puzzles, we start removing
+         * things from it while preserving solubility.  Killer puzzles are
+         * different: we just pass the empty grid to the solver, and use
+         * the puzzle if it comes back solved.
+         */
+
+        if (params->killer) {
+            struct block_structure *good_cages = NULL;
+            struct block_structure *last_cages = NULL;
+            int ntries = 0;
+
+            memcpy(grid2, grid, area);
+
+            for (;;) {
+                compute_kclues(kblocks, kgrid, grid2, area);
+
+                memset(grid, 0, area * sizeof *grid);
+                solver(cr, blocks, kblocks, params->xtype, grid, kgrid, &dlev);
+                if (dlev.diff == dlev.maxdiff && dlev.kdiff == dlev.maxkdiff) {
+                    /*
+                     * We have one that matches our difficulty.  Store it for
+                     * later, but keep going.
+                     */
+                    if (good_cages)
+                        free_block_structure(good_cages);
+                    ntries = 0;
+                    good_cages = dup_block_structure(kblocks);
+                    if (!merge_some_cages(kblocks, cr, area, grid2, rs))
+                        break;
+                } else if (dlev.diff > dlev.maxdiff || dlev.kdiff > dlev.maxkdiff) {
+                    /*
+                     * Give up after too many tries and either use the good one we
+                     * found, or generate a new grid.
+                     */
+                    if (++ntries > 50)
+                        break;
+                    /*
+                     * The difficulty level got too high.  If we have a good
+                     * one, use it, otherwise go back to the last one that
+                     * was at a lower difficulty and restart the process from
+                     * there.
+                     */
+                    if (good_cages != NULL) {
+                        free_block_structure(kblocks);
+                        kblocks = dup_block_structure(good_cages);
+                        if (!merge_some_cages(kblocks, cr, area, grid2, rs))
+                            break;
+                    } else {
+                        if (last_cages == NULL)
+                            break;
+                        free_block_structure(kblocks);
+                        kblocks = last_cages;
+                        last_cages = NULL;
+                    }
+                } else {
+                    if (last_cages)
+                        free_block_structure(last_cages);
+                    last_cages = dup_block_structure(kblocks);
+                    if (!merge_some_cages(kblocks, cr, area, grid2, rs))
+                        break;
+                }
+            }
+            if (last_cages)
+                free_block_structure(last_cages);
+            if (good_cages != NULL) {
+                free_block_structure(kblocks);
+                kblocks = good_cages;
+                compute_kclues(kblocks, kgrid, grid2, area);
+                memset(grid, 0, area * sizeof *grid);
+                break;
+            }
+            continue;
+        }
+
+        /*
+         * Find the set of equivalence classes of squares permitted
+         * by the selected symmetry. We do this by enumerating all
+         * the grid squares which have no symmetric companion
+         * sorting lower than themselves.
+         */
+        nlocs = 0;
+        for (y = 0; y < cr; y++)
+            for (x = 0; x < cr; x++) {
+                int i = y*cr+x;
+                int j;
+
+                ncoords = symmetries(params, x, y, coords, params->symm);
+                for (j = 0; j < ncoords; j++)
+                    if (coords[2*j+1]*cr+coords[2*j] < i)
+                        break;
+                if (j == ncoords) {
+                    locs[nlocs].x = x;
+                    locs[nlocs].y = y;
+                    nlocs++;
+                }
+            }
+
+        /*
+         * Now shuffle that list.
+         */
+        shuffle(locs, nlocs, sizeof(*locs), rs);
+
+        /*
+         * Now loop over the shuffled list and, for each element,
+         * see whether removing that element (and its reflections)
+         * from the grid will still leave the grid soluble.
+         */
+        for (i = 0; i < nlocs; i++) {
+            x = locs[i].x;
+            y = locs[i].y;
+
+            memcpy(grid2, grid, area);
+            ncoords = symmetries(params, x, y, coords, params->symm);
+            for (j = 0; j < ncoords; j++)
+                grid2[coords[2*j+1]*cr+coords[2*j]] = 0;
+
+            solver(cr, blocks, kblocks, params->xtype, grid2, kgrid, &dlev);
+            if (dlev.diff <= dlev.maxdiff &&
+                (!params->killer || dlev.kdiff <= dlev.maxkdiff)) {
+                for (j = 0; j < ncoords; j++)
+                    grid[coords[2*j+1]*cr+coords[2*j]] = 0;
+            }
+        }
+
+        memcpy(grid2, grid, area);
+
+        solver(cr, blocks, kblocks, params->xtype, grid2, kgrid, &dlev);
+        if (dlev.diff == dlev.maxdiff &&
+            (!params->killer || dlev.kdiff == dlev.maxkdiff))
+            break;                     /* found one! */
+    }
+
+    sfree(grid2);
+    sfree(locs);
+
+    /*
+     * Now we have the grid as it will be presented to the user.
+     * Encode it in a game desc.
+     */
+    desc = encode_puzzle_desc(params, grid, blocks, kgrid, kblocks);
+
+    sfree(grid);
+    free_block_structure(blocks);
+    if (params->killer) {
+        free_block_structure(kblocks);
+        sfree(kgrid);
+    }
+
+    return desc;
+}
+
+static const char *spec_to_grid(const char *desc, digit *grid, int area)
+{
+    int i = 0;
+    while (*desc && *desc != ',') {
+        int n = *desc++;
+        if (n >= 'a' && n <= 'z') {
+            int run = n - 'a' + 1;
+            assert(i + run <= area);
+            while (run-- > 0)
+                grid[i++] = 0;
+        } else if (n == '_') {
+            /* do nothing */;
+        } else if (n > '0' && n <= '9') {
+            assert(i < area);
+            grid[i++] = atoi(desc-1);
+            while (*desc >= '0' && *desc <= '9')
+                desc++;
+        } else {
+            assert(!"We can't get here");
+        }
+    }
+    assert(i == area);
+    return desc;
+}
+
+/*
+ * Create a DSF from a spec found in *pdesc. Update this to point past the
+ * end of the block spec, and return an error string or NULL if everything
+ * is OK. The DSF is stored in *PDSF.
+ */
+static char *spec_to_dsf(const char **pdesc, int **pdsf, int cr, int area)
+{
+    const char *desc = *pdesc;
+    int pos = 0;
+    int *dsf;
+
+    *pdsf = dsf = snew_dsf(area);
+
+    while (*desc && *desc != ',') {
+        int c, adv;
+
+        if (*desc == '_')
+            c = 0;
+        else if (*desc >= 'a' && *desc <= 'z')
+            c = *desc - 'a' + 1;
+        else {
+            sfree(dsf);
+            return "Invalid character in game description";
+        }
+        desc++;
+
+        adv = (c != 26);               /* 'z' is a special case */
+
+        while (c-- > 0) {
+            int p0, p1;
+
+            /*
+             * Non-edge; merge the two dsf classes on either
+             * side of it.
+             */
+            if (pos >= 2*cr*(cr-1)) {
+                sfree(dsf);
+                return "Too much data in block structure specification";
+            }
+
+            if (pos < cr*(cr-1)) {
+                int y = pos/(cr-1);
+                int x = pos%(cr-1);
+                p0 = y*cr+x;
+                p1 = y*cr+x+1;
+            } else {
+                int x = pos/(cr-1) - cr;
+                int y = pos%(cr-1);
+                p0 = y*cr+x;
+                p1 = (y+1)*cr+x;
+            }
+            dsf_merge(dsf, p0, p1);
+
+            pos++;
+        }
+        if (adv)
+            pos++;
+    }
+    *pdesc = desc;
+
+    /*
+     * When desc is exhausted, we expect to have gone exactly
+     * one space _past_ the end of the grid, due to the dummy
+     * edge at the end.
+     */
+    if (pos != 2*cr*(cr-1)+1) {
+        sfree(dsf);
+        return "Not enough data in block structure specification";
+    }
+
+    return NULL;
+}
+
+static char *validate_grid_desc(const char **pdesc, int range, int area)
+{
+    const char *desc = *pdesc;
+    int squares = 0;
+    while (*desc && *desc != ',') {
+        int n = *desc++;
+        if (n >= 'a' && n <= 'z') {
+            squares += n - 'a' + 1;
+        } else if (n == '_') {
+            /* do nothing */;
+        } else if (n > '0' && n <= '9') {
+            int val = atoi(desc-1);
+            if (val < 1 || val > range)
+                return "Out-of-range number in game description";
+            squares++;
+            while (*desc >= '0' && *desc <= '9')
+                desc++;
+        } else
+            return "Invalid character in game description";
+    }
+
+    if (squares < area)
+        return "Not enough data to fill grid";
+
+    if (squares > area)
+        return "Too much data to fit in grid";
+    *pdesc = desc;
+    return NULL;
+}
+
+static char *validate_block_desc(const char **pdesc, int cr, int area,
+                                 int min_nr_blocks, int max_nr_blocks,
+                                 int min_nr_squares, int max_nr_squares)
+{
+    char *err;
+    int *dsf;
+
+    err = spec_to_dsf(pdesc, &dsf, cr, area);
+    if (err) {
+        return err;
+    }
+
+    if (min_nr_squares == max_nr_squares) {
+        assert(min_nr_blocks == max_nr_blocks);
+        assert(min_nr_blocks * min_nr_squares == area);
+    }
+    /*
+     * Now we've got our dsf. Verify that it matches
+     * expectations.
+     */
+    {
+        int *canons, *counts;
+        int i, j, c, ncanons = 0;
+
+        canons = snewn(max_nr_blocks, int);
+        counts = snewn(max_nr_blocks, int);
+
+        for (i = 0; i < area; i++) {
+            j = dsf_canonify(dsf, i);
+
+            for (c = 0; c < ncanons; c++)
+                if (canons[c] == j) {
+                    counts[c]++;
+                    if (counts[c] > max_nr_squares) {
+                        sfree(dsf);
+                        sfree(canons);
+                        sfree(counts);
+                        return "A jigsaw block is too big";
+                    }
+                    break;
+                }
+
+            if (c == ncanons) {
+                if (ncanons >= max_nr_blocks) {
+                    sfree(dsf);
+                    sfree(canons);
+                    sfree(counts);
+                    return "Too many distinct jigsaw blocks";
+                }
+                canons[ncanons] = j;
+                counts[ncanons] = 1;
+                ncanons++;
+            }
+        }
+
+        if (ncanons < min_nr_blocks) {
+            sfree(dsf);
+            sfree(canons);
+            sfree(counts);
+            return "Not enough distinct jigsaw blocks";
+        }
+        for (c = 0; c < ncanons; c++) {
+            if (counts[c] < min_nr_squares) {
+                sfree(dsf);
+                sfree(canons);
+                sfree(counts);
+                return "A jigsaw block is too small";
+            }
+        }
+        sfree(canons);
+        sfree(counts);
+    }
+
+    sfree(dsf);
+    return NULL;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int cr = params->c * params->r, area = cr*cr;
+    char *err;
+
+    err = validate_grid_desc(&desc, cr, area);
+    if (err)
+        return err;
+
+    if (params->r == 1) {
+        /*
+         * Now we expect a suffix giving the jigsaw block
+         * structure. Parse it and validate that it divides the
+         * grid into the right number of regions which are the
+         * right size.
+         */
+        if (*desc != ',')
+            return "Expected jigsaw block structure in game description";
+        desc++;
+        err = validate_block_desc(&desc, cr, area, cr, cr, cr, cr);
+        if (err)
+            return err;
+
+    }
+    if (params->killer) {
+        if (*desc != ',')
+            return "Expected killer block structure in game description";
+        desc++;
+        err = validate_block_desc(&desc, cr, area, cr, area, 2, cr);
+        if (err)
+            return err;
+        if (*desc != ',')
+            return "Expected killer clue grid in game description";
+        desc++;
+        err = validate_grid_desc(&desc, cr * area, area);
+        if (err)
+            return err;
+    }
+    if (*desc)
+        return "Unexpected data at end of game description";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    int c = params->c, r = params->r, cr = c*r, area = cr * cr;
+    int i;
+
+    precompute_sum_bits();
+
+    state->cr = cr;
+    state->xtype = params->xtype;
+    state->killer = params->killer;
+
+    state->grid = snewn(area, digit);
+    state->pencil = snewn(area * cr, unsigned char);
+    memset(state->pencil, 0, area * cr);
+    state->immutable = snewn(area, unsigned char);
+    memset(state->immutable, FALSE, area);
+
+    state->blocks = alloc_block_structure (c, r, area, cr, cr);
+
+    if (params->killer) {
+        state->kblocks = alloc_block_structure (c, r, area, cr, area);
+        state->kgrid = snewn(area, digit);
+    } else {
+        state->kblocks = NULL;
+        state->kgrid = NULL;
+    }
+    state->completed = state->cheated = FALSE;
+
+    desc = spec_to_grid(desc, state->grid, area);
+    for (i = 0; i < area; i++)
+        if (state->grid[i] != 0)
+            state->immutable[i] = TRUE;
+
+    if (r == 1) {
+        char *err;
+        int *dsf;
+        assert(*desc == ',');
+        desc++;
+        err = spec_to_dsf(&desc, &dsf, cr, area);
+        assert(err == NULL);
+        dsf_to_blocks(dsf, state->blocks, cr, cr);
+        sfree(dsf);
+    } else {
+        int x, y;
+
+        for (y = 0; y < cr; y++)
+            for (x = 0; x < cr; x++)
+                state->blocks->whichblock[y*cr+x] = (y/c) * c + (x/r);
+    }
+    make_blocks_from_whichblock(state->blocks);
+
+    if (params->killer) {
+        char *err;
+        int *dsf;
+        assert(*desc == ',');
+        desc++;
+        err = spec_to_dsf(&desc, &dsf, cr, area);
+        assert(err == NULL);
+        dsf_to_blocks(dsf, state->kblocks, cr, area);
+        sfree(dsf);
+        make_blocks_from_whichblock(state->kblocks);
+
+        assert(*desc == ',');
+        desc++;
+        desc = spec_to_grid(desc, state->kgrid, area);
+    }
+    assert(!*desc);
+
+#ifdef STANDALONE_SOLVER
+    /*
+     * Set up the block names for solver diagnostic output.
+     */
+    {
+        char *p = (char *)(state->blocks->blocknames + cr);
+
+        if (r == 1) {
+            for (i = 0; i < area; i++) {
+                int j = state->blocks->whichblock[i];
+                if (!state->blocks->blocknames[j]) {
+                    state->blocks->blocknames[j] = p;
+                    p += 1 + sprintf(p, "starting at (%d,%d)",
+                                     1 + i%cr, 1 + i/cr);
+                }
+            }
+        } else {
+            int bx, by;
+            for (by = 0; by < r; by++)
+                for (bx = 0; bx < c; bx++) {
+                    state->blocks->blocknames[by*c+bx] = p;
+                    p += 1 + sprintf(p, "(%d,%d)", bx+1, by+1);
+                }
+        }
+        assert(p - (char *)state->blocks->blocknames < (int)(cr*(sizeof(char *)+80)));
+        for (i = 0; i < cr; i++)
+            assert(state->blocks->blocknames[i]);
+    }
+#endif
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+    int cr = state->cr, area = cr * cr;
+
+    ret->cr = state->cr;
+    ret->xtype = state->xtype;
+    ret->killer = state->killer;
+
+    ret->blocks = state->blocks;
+    ret->blocks->refcount++;
+
+    ret->kblocks = state->kblocks;
+    if (ret->kblocks)
+        ret->kblocks->refcount++;
+
+    ret->grid = snewn(area, digit);
+    memcpy(ret->grid, state->grid, area);
+
+    if (state->killer) {
+        ret->kgrid = snewn(area, digit);
+        memcpy(ret->kgrid, state->kgrid, area);
+    } else
+        ret->kgrid = NULL;
+
+    ret->pencil = snewn(area * cr, unsigned char);
+    memcpy(ret->pencil, state->pencil, area * cr);
+
+    ret->immutable = snewn(area, unsigned char);
+    memcpy(ret->immutable, state->immutable, area);
+
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    free_block_structure(state->blocks);
+    if (state->kblocks)
+        free_block_structure(state->kblocks);
+
+    sfree(state->immutable);
+    sfree(state->pencil);
+    sfree(state->grid);
+    if (state->kgrid) sfree(state->kgrid);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *ai, char **error)
+{
+    int cr = state->cr;
+    char *ret;
+    digit *grid;
+    struct difficulty dlev;
+
+    /*
+     * If we already have the solution in ai, save ourselves some
+     * time.
+     */
+    if (ai)
+        return dupstr(ai);
+
+    grid = snewn(cr*cr, digit);
+    memcpy(grid, state->grid, cr*cr);
+    dlev.maxdiff = DIFF_RECURSIVE;
+    dlev.maxkdiff = DIFF_KINTERSECT;
+    solver(cr, state->blocks, state->kblocks, state->xtype, grid,
+           state->kgrid, &dlev);
+
+    *error = NULL;
+
+    if (dlev.diff == DIFF_IMPOSSIBLE)
+        *error = "No solution exists for this puzzle";
+    else if (dlev.diff == DIFF_AMBIGUOUS)
+        *error = "Multiple solutions exist for this puzzle";
+
+    if (*error) {
+        sfree(grid);
+        return NULL;
+    }
+
+    ret = encode_solve_move(cr, grid);
+
+    sfree(grid);
+
+    return ret;
+}
+
+static char *grid_text_format(int cr, struct block_structure *blocks,
+                              int xtype, digit *grid)
+{
+    int vmod, hmod;
+    int x, y;
+    int totallen, linelen, nlines;
+    char *ret, *p, ch;
+
+    /*
+     * For non-jigsaw Sudoku, we format in the way we always have,
+     * by having the digits unevenly spaced so that the dividing
+     * lines can fit in:
+     *
+     * . . | . .
+     * . . | . .
+     * ----+----
+     * . . | . .
+     * . . | . .
+     *
+     * For jigsaw puzzles, however, we must leave space between
+     * _all_ pairs of digits for an optional dividing line, so we
+     * have to move to the rather ugly
+     * 
+     * .   .   .   .
+     * ------+------
+     * .   . | .   .
+     *       +---+  
+     * .   . | . | .
+     * ------+   |  
+     * .   .   . | .
+     * 
+     * We deal with both cases using the same formatting code; we
+     * simply invent a vmod value such that there's a vertical
+     * dividing line before column i iff i is divisible by vmod
+     * (so it's r in the first case and 1 in the second), and hmod
+     * likewise for horizontal dividing lines.
+     */
+
+    if (blocks->r != 1) {
+        vmod = blocks->r;
+        hmod = blocks->c;
+    } else {
+        vmod = hmod = 1;
+    }
+
+    /*
+     * Line length: we have cr digits, each with a space after it,
+     * and (cr-1)/vmod dividing lines, each with a space after it.
+     * The final space is replaced by a newline, but that doesn't
+     * affect the length.
+     */
+    linelen = 2*(cr + (cr-1)/vmod);
+
+    /*
+     * Number of lines: we have cr rows of digits, and (cr-1)/hmod
+     * dividing rows.
+     */
+    nlines = cr + (cr-1)/hmod;
+
+    /*
+     * Allocate the space.
+     */
+    totallen = linelen * nlines;
+    ret = snewn(totallen+1, char);     /* leave room for terminating NUL */
+
+    /*
+     * Write the text.
+     */
+    p = ret;
+    for (y = 0; y < cr; y++) {
+        /*
+         * Row of digits.
+         */
+        for (x = 0; x < cr; x++) {
+            /*
+             * Digit.
+             */
+            digit d = grid[y*cr+x];
+
+            if (d == 0) {
+                /*
+                 * Empty space: we usually write a dot, but we'll
+                 * highlight spaces on the X-diagonals (in X mode)
+                 * by using underscores instead.
+                 */
+                if (xtype && (ondiag0(y*cr+x) || ondiag1(y*cr+x)))
+                    ch = '_';
+                else
+                    ch = '.';
+            } else if (d <= 9) {
+                ch = '0' + d;
+            } else {
+                ch = 'a' + d-10;
+            }
+
+            *p++ = ch;
+            if (x == cr-1) {
+                *p++ = '\n';
+                continue;
+            }
+            *p++ = ' ';
+
+            if ((x+1) % vmod)
+                continue;
+
+            /*
+             * Optional dividing line.
+             */
+            if (blocks->whichblock[y*cr+x] != blocks->whichblock[y*cr+x+1])
+                ch = '|';
+            else
+                ch = ' ';
+            *p++ = ch;
+            *p++ = ' ';
+        }
+        if (y == cr-1 || (y+1) % hmod)
+            continue;
+
+        /*
+         * Dividing row.
+         */
+        for (x = 0; x < cr; x++) {
+            int dwid;
+            int tl, tr, bl, br;
+
+            /*
+             * Division between two squares. This varies
+             * complicatedly in length.
+             */
+            dwid = 2;                  /* digit and its following space */
+            if (x == cr-1)
+                dwid--;                /* no following space at end of line */
+            if (x > 0 && x % vmod == 0)
+                dwid++;                /* preceding space after a divider */
+
+            if (blocks->whichblock[y*cr+x] != blocks->whichblock[(y+1)*cr+x])
+                ch = '-';
+            else
+                ch = ' ';
+
+            while (dwid-- > 0)
+                *p++ = ch;
+
+            if (x == cr-1) {
+                *p++ = '\n';
+                break;
+            }
+
+            if ((x+1) % vmod)
+                continue;
+
+            /*
+             * Corner square. This is:
+             *  - a space if all four surrounding squares are in
+             *    the same block
+             *  - a vertical line if the two left ones are in one
+             *    block and the two right in another
+             *  - a horizontal line if the two top ones are in one
+             *    block and the two bottom in another
+             *  - a plus sign in all other cases. (If we had a
+             *    richer character set available we could break
+             *    this case up further by doing fun things with
+             *    line-drawing T-pieces.)
+             */
+            tl = blocks->whichblock[y*cr+x];
+            tr = blocks->whichblock[y*cr+x+1];
+            bl = blocks->whichblock[(y+1)*cr+x];
+            br = blocks->whichblock[(y+1)*cr+x+1];
+
+            if (tl == tr && tr == bl && bl == br)
+                ch = ' ';
+            else if (tl == bl && tr == br)
+                ch = '|';
+            else if (tl == tr && bl == br)
+                ch = '-';
+            else
+                ch = '+';
+
+            *p++ = ch;
+        }
+    }
+
+    assert(p - ret == totallen);
+    *p = '\0';
+    return ret;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    /*
+     * Formatting Killer puzzles as text is currently unsupported. I
+     * can't think of any sensible way of doing it which doesn't
+     * involve expanding the puzzle to such a large scale as to make
+     * it unusable.
+     */
+    if (params->killer)
+        return FALSE;
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    assert(!state->kblocks);
+    return grid_text_format(state->cr, state->blocks, state->xtype,
+                            state->grid);
+}
+
+struct game_ui {
+    /*
+     * These are the coordinates of the currently highlighted
+     * square on the grid, if hshow = 1.
+     */
+    int hx, hy;
+    /*
+     * This indicates whether the current highlight is a
+     * pencil-mark one or a real one.
+     */
+    int hpencil;
+    /*
+     * This indicates whether or not we're showing the highlight
+     * (used to be hx = hy = -1); important so that when we're
+     * using the cursor keys it doesn't keep coming back at a
+     * fixed position. When hshow = 1, pressing a valid number
+     * or letter key or Space will enter that number or letter in the grid.
+     */
+    int hshow;
+    /*
+     * This indicates whether we're using the highlight as a cursor;
+     * it means that it doesn't vanish on a keypress, and that it is
+     * allowed on immutable squares.
+     */
+    int hcursor;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->hx = ui->hy = 0;
+    ui->hpencil = ui->hshow = ui->hcursor = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    int cr = newstate->cr;
+    /*
+     * We prevent pencil-mode highlighting of a filled square, unless
+     * we're using the cursor keys. So if the user has just filled in
+     * a square which we had a pencil-mode highlight in (by Undo, or
+     * by Redo, or by Solve), then we cancel the highlight.
+     */
+    if (ui->hshow && ui->hpencil && !ui->hcursor &&
+        newstate->grid[ui->hy * cr + ui->hx] != 0) {
+        ui->hshow = 0;
+    }
+}
+
+struct game_drawstate {
+    int started;
+    int cr, xtype;
+    int tilesize;
+    digit *grid;
+    unsigned char *pencil;
+    unsigned char *hl;
+    /* This is scratch space used within a single call to game_redraw. */
+    int nregions, *entered_items;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int cr = state->cr;
+    int tx, ty;
+    char buf[80];
+
+    button &= ~MOD_MASK;
+
+    tx = (x + TILE_SIZE - BORDER) / TILE_SIZE - 1;
+    ty = (y + TILE_SIZE - BORDER) / TILE_SIZE - 1;
+
+    if (tx >= 0 && tx < cr && ty >= 0 && ty < cr) {
+        if (button == LEFT_BUTTON) {
+            if (state->immutable[ty*cr+tx]) {
+                ui->hshow = 0;
+            } else if (tx == ui->hx && ty == ui->hy &&
+                       ui->hshow && ui->hpencil == 0) {
+                ui->hshow = 0;
+            } else {
+                ui->hx = tx;
+                ui->hy = ty;
+                ui->hshow = 1;
+                ui->hpencil = 0;
+            }
+            ui->hcursor = 0;
+            return "";                 /* UI activity occurred */
+        }
+        if (button == RIGHT_BUTTON) {
+            /*
+             * Pencil-mode highlighting for non filled squares.
+             */
+            if (state->grid[ty*cr+tx] == 0) {
+                if (tx == ui->hx && ty == ui->hy &&
+                    ui->hshow && ui->hpencil) {
+                    ui->hshow = 0;
+                } else {
+                    ui->hpencil = 1;
+                    ui->hx = tx;
+                    ui->hy = ty;
+                    ui->hshow = 1;
+                }
+            } else {
+                ui->hshow = 0;
+            }
+            ui->hcursor = 0;
+            return "";                 /* UI activity occurred */
+        }
+    }
+    if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->hx, &ui->hy, cr, cr, 0);
+        ui->hshow = ui->hcursor = 1;
+        return "";
+    }
+    if (ui->hshow &&
+        (button == CURSOR_SELECT)) {
+        ui->hpencil = 1 - ui->hpencil;
+        ui->hcursor = 1;
+        return "";
+    }
+
+    if (ui->hshow &&
+        ((button >= '0' && button <= '9' && button - '0' <= cr) ||
+         (button >= 'a' && button <= 'z' && button - 'a' + 10 <= cr) ||
+         (button >= 'A' && button <= 'Z' && button - 'A' + 10 <= cr) ||
+         button == CURSOR_SELECT2 || button == '\b')) {
+        int n = button - '0';
+        if (button >= 'A' && button <= 'Z')
+            n = button - 'A' + 10;
+        if (button >= 'a' && button <= 'z')
+            n = button - 'a' + 10;
+        if (button == CURSOR_SELECT2 || button == '\b')
+            n = 0;
+
+        /*
+         * Can't overwrite this square. This can only happen here
+         * if we're using the cursor keys.
+         */
+        if (state->immutable[ui->hy*cr+ui->hx])
+            return NULL;
+
+        /*
+         * Can't make pencil marks in a filled square. Again, this
+         * can only become highlighted if we're using cursor keys.
+         */
+        if (ui->hpencil && state->grid[ui->hy*cr+ui->hx])
+            return NULL;
+
+        sprintf(buf, "%c%d,%d,%d",
+                (char)(ui->hpencil && n > 0 ? 'P' : 'R'), ui->hx, ui->hy, n);
+
+        if (!ui->hcursor) ui->hshow = 0;
+
+        return dupstr(buf);
+    }
+
+    if (button == 'M' || button == 'm')
+        return dupstr("M");
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    int cr = from->cr;
+    game_state *ret;
+    int x, y, n;
+
+    if (move[0] == 'S') {
+        const char *p;
+
+        ret = dup_game(from);
+        ret->completed = ret->cheated = TRUE;
+
+        p = move+1;
+        for (n = 0; n < cr*cr; n++) {
+            ret->grid[n] = atoi(p);
+
+            if (!*p || ret->grid[n] < 1 || ret->grid[n] > cr) {
+                free_game(ret);
+                return NULL;
+            }
+
+            while (*p && isdigit((unsigned char)*p)) p++;
+            if (*p == ',') p++;
+        }
+
+        return ret;
+    } else if ((move[0] == 'P' || move[0] == 'R') &&
+        sscanf(move+1, "%d,%d,%d", &x, &y, &n) == 3 &&
+        x >= 0 && x < cr && y >= 0 && y < cr && n >= 0 && n <= cr) {
+
+        ret = dup_game(from);
+        if (move[0] == 'P' && n > 0) {
+            int index = (y*cr+x) * cr + (n-1);
+            ret->pencil[index] = !ret->pencil[index];
+        } else {
+            ret->grid[y*cr+x] = n;
+            memset(ret->pencil + (y*cr+x)*cr, 0, cr);
+
+            /*
+             * We've made a real change to the grid. Check to see
+             * if the game has been completed.
+             */
+            if (!ret->completed && check_valid(
+                    cr, ret->blocks, ret->kblocks, ret->kgrid,
+                    ret->xtype, ret->grid)) {
+                ret->completed = TRUE;
+            }
+        }
+        return ret;
+    } else if (move[0] == 'M') {
+        /*
+         * Fill in absolutely all pencil marks in unfilled squares,
+         * for those who like to play by the rigorous approach of
+         * starting off in that state and eliminating things.
+         */
+        ret = dup_game(from);
+        for (y = 0; y < cr; y++) {
+            for (x = 0; x < cr; x++) {
+                if (!ret->grid[y*cr+x]) {
+                    memset(ret->pencil + (y*cr+x)*cr, 1, cr);
+                }
+            }
+        }
+        return ret;
+    } else
+        return NULL;                   /* couldn't parse move string */
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define SIZE(cr) ((cr) * TILE_SIZE + 2*BORDER + 1)
+#define GETTILESIZE(cr, w) ( (double)(w-1) / (double)(cr+1) )
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = SIZE(params->c * params->r);
+    *y = SIZE(params->c * params->r);
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_XDIAGONALS * 3 + 0] = 0.9F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_XDIAGONALS * 3 + 1] = 0.9F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_XDIAGONALS * 3 + 2] = 0.9F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_GRID * 3 + 0] = 0.0F;
+    ret[COL_GRID * 3 + 1] = 0.0F;
+    ret[COL_GRID * 3 + 2] = 0.0F;
+
+    ret[COL_CLUE * 3 + 0] = 0.0F;
+    ret[COL_CLUE * 3 + 1] = 0.0F;
+    ret[COL_CLUE * 3 + 2] = 0.0F;
+
+    ret[COL_USER * 3 + 0] = 0.0F;
+    ret[COL_USER * 3 + 1] = 0.6F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_USER * 3 + 2] = 0.0F;
+
+    ret[COL_HIGHLIGHT * 3 + 0] = 0.78F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_HIGHLIGHT * 3 + 1] = 0.78F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_HIGHLIGHT * 3 + 2] = 0.78F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_PENCIL * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_PENCIL * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_PENCIL * 3 + 2] = ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_KILLER * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_KILLER * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_KILLER * 3 + 2] = 0.1F * ret[COL_BACKGROUND * 3 + 2];
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int cr = state->cr;
+
+    ds->started = FALSE;
+    ds->cr = cr;
+    ds->xtype = state->xtype;
+    ds->grid = snewn(cr*cr, digit);
+    memset(ds->grid, cr+2, cr*cr);
+    ds->pencil = snewn(cr*cr*cr, digit);
+    memset(ds->pencil, 0, cr*cr*cr);
+    ds->hl = snewn(cr*cr, unsigned char);
+    memset(ds->hl, 0, cr*cr);
+    /*
+     * ds->entered_items needs one row of cr entries per entity in
+     * which digits may not be duplicated. That's one for each row,
+     * each column, each block, each diagonal, and each Killer cage.
+     */
+    ds->nregions = cr*3 + 2;
+    if (state->kblocks)
+        ds->nregions += state->kblocks->nr_blocks;
+    ds->entered_items = snewn(cr * ds->nregions, int);
+    ds->tilesize = 0;                  /* not decided yet */
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->hl);
+    sfree(ds->pencil);
+    sfree(ds->grid);
+    sfree(ds->entered_items);
+    sfree(ds);
+}
+
+static void draw_number(drawing *dr, game_drawstate *ds,
+                        const game_state *state, int x, int y, int hl)
+{
+    int cr = state->cr;
+    int tx, ty, tw, th;
+    int cx, cy, cw, ch;
+    int col_killer = (hl & 32 ? COL_ERROR : COL_KILLER);
+    char str[20];
+
+    if (ds->grid[y*cr+x] == state->grid[y*cr+x] &&
+        ds->hl[y*cr+x] == hl &&
+        !memcmp(ds->pencil+(y*cr+x)*cr, state->pencil+(y*cr+x)*cr, cr))
+        return;                        /* no change required */
+
+    tx = BORDER + x * TILE_SIZE + 1 + GRIDEXTRA;
+    ty = BORDER + y * TILE_SIZE + 1 + GRIDEXTRA;
+
+    cx = tx;
+    cy = ty;
+    cw = tw = TILE_SIZE-1-2*GRIDEXTRA;
+    ch = th = TILE_SIZE-1-2*GRIDEXTRA;
+
+    if (x > 0 && state->blocks->whichblock[y*cr+x] == state->blocks->whichblock[y*cr+x-1])
+        cx -= GRIDEXTRA, cw += GRIDEXTRA;
+    if (x+1 < cr && state->blocks->whichblock[y*cr+x] == state->blocks->whichblock[y*cr+x+1])
+        cw += GRIDEXTRA;
+    if (y > 0 && state->blocks->whichblock[y*cr+x] == state->blocks->whichblock[(y-1)*cr+x])
+        cy -= GRIDEXTRA, ch += GRIDEXTRA;
+    if (y+1 < cr && state->blocks->whichblock[y*cr+x] == state->blocks->whichblock[(y+1)*cr+x])
+        ch += GRIDEXTRA;
+
+    clip(dr, cx, cy, cw, ch);
+
+    /* background needs erasing */
+    draw_rect(dr, cx, cy, cw, ch,
+              ((hl & 15) == 1 ? COL_HIGHLIGHT :
+               (ds->xtype && (ondiag0(y*cr+x) || ondiag1(y*cr+x))) ? COL_XDIAGONALS :
+               COL_BACKGROUND));
+
+    /*
+     * Draw the corners of thick lines in corner-adjacent squares,
+     * which jut into this square by one pixel.
+     */
+    if (x > 0 && y > 0 && state->blocks->whichblock[y*cr+x] != state->blocks->whichblock[(y-1)*cr+x-1])
+        draw_rect(dr, tx-GRIDEXTRA, ty-GRIDEXTRA, GRIDEXTRA, GRIDEXTRA, COL_GRID);
+    if (x+1 < cr && y > 0 && state->blocks->whichblock[y*cr+x] != state->blocks->whichblock[(y-1)*cr+x+1])
+        draw_rect(dr, tx+TILE_SIZE-1-2*GRIDEXTRA, ty-GRIDEXTRA, GRIDEXTRA, GRIDEXTRA, COL_GRID);
+    if (x > 0 && y+1 < cr && state->blocks->whichblock[y*cr+x] != state->blocks->whichblock[(y+1)*cr+x-1])
+        draw_rect(dr, tx-GRIDEXTRA, ty+TILE_SIZE-1-2*GRIDEXTRA, GRIDEXTRA, GRIDEXTRA, COL_GRID);
+    if (x+1 < cr && y+1 < cr && state->blocks->whichblock[y*cr+x] != state->blocks->whichblock[(y+1)*cr+x+1])
+        draw_rect(dr, tx+TILE_SIZE-1-2*GRIDEXTRA, ty+TILE_SIZE-1-2*GRIDEXTRA, GRIDEXTRA, GRIDEXTRA, COL_GRID);
+
+    /* pencil-mode highlight */
+    if ((hl & 15) == 2) {
+        int coords[6];
+        coords[0] = cx;
+        coords[1] = cy;
+        coords[2] = cx+cw/2;
+        coords[3] = cy;
+        coords[4] = cx;
+        coords[5] = cy+ch/2;
+        draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+    }
+
+    if (state->kblocks) {
+        int t = GRIDEXTRA * 3;
+        int kcx, kcy, kcw, kch;
+        int kl, kt, kr, kb;
+        int has_left = 0, has_right = 0, has_top = 0, has_bottom = 0;
+
+        /*
+         * In non-jigsaw mode, the Killer cages are placed at a
+         * fixed offset from the outer edge of the cell dividing
+         * lines, so that they look right whether those lines are
+         * thick or thin. In jigsaw mode, however, doing this will
+         * sometimes cause the cage outlines in adjacent squares to
+         * fail to match up with each other, so we must offset a
+         * fixed amount from the _centre_ of the cell dividing
+         * lines.
+         */
+        if (state->blocks->r == 1) {
+            kcx = tx;
+            kcy = ty;
+            kcw = tw;
+            kch = th;
+        } else {
+            kcx = cx;
+            kcy = cy;
+            kcw = cw;
+            kch = ch;
+        }
+        kl = kcx - 1;
+        kt = kcy - 1;
+        kr = kcx + kcw;
+        kb = kcy + kch;
+
+        /*
+         * First, draw the lines dividing this area from neighbouring
+         * different areas.
+         */
+        if (x == 0 || state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[y*cr+x-1])
+            has_left = 1, kl += t;
+        if (x+1 >= cr || state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[y*cr+x+1])
+            has_right = 1, kr -= t;
+        if (y == 0 || state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[(y-1)*cr+x])
+            has_top = 1, kt += t;
+        if (y+1 >= cr || state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[(y+1)*cr+x])
+            has_bottom = 1, kb -= t;
+        if (has_top)
+            draw_line(dr, kl, kt, kr, kt, col_killer);
+        if (has_bottom)
+            draw_line(dr, kl, kb, kr, kb, col_killer);
+        if (has_left)
+            draw_line(dr, kl, kt, kl, kb, col_killer);
+        if (has_right)
+            draw_line(dr, kr, kt, kr, kb, col_killer);
+        /*
+         * Now, take care of the corners (just as for the normal borders).
+         * We only need a corner if there wasn't a full edge.
+         */
+        if (x > 0 && y > 0 && !has_left && !has_top
+            && state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[(y-1)*cr+x-1])
+        {
+            draw_line(dr, kl, kt + t, kl + t, kt + t, col_killer);
+            draw_line(dr, kl + t, kt, kl + t, kt + t, col_killer);
+        }
+        if (x+1 < cr && y > 0 && !has_right && !has_top
+            && state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[(y-1)*cr+x+1])
+        {
+            draw_line(dr, kcx + kcw - t, kt + t, kcx + kcw, kt + t, col_killer);
+            draw_line(dr, kcx + kcw - t, kt, kcx + kcw - t, kt + t, col_killer);
+        }
+        if (x > 0 && y+1 < cr && !has_left && !has_bottom
+            && state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[(y+1)*cr+x-1])
+        {
+            draw_line(dr, kl, kcy + kch - t, kl + t, kcy + kch - t, col_killer);
+            draw_line(dr, kl + t, kcy + kch - t, kl + t, kcy + kch, col_killer);
+        }
+        if (x+1 < cr && y+1 < cr && !has_right && !has_bottom
+            && state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[(y+1)*cr+x+1])
+        {
+            draw_line(dr, kcx + kcw - t, kcy + kch - t, kcx + kcw - t, kcy + kch, col_killer);
+            draw_line(dr, kcx + kcw - t, kcy + kch - t, kcx + kcw, kcy + kch - t, col_killer);
+        }
+
+    }
+
+    if (state->killer && state->kgrid[y*cr+x]) {
+        sprintf (str, "%d", state->kgrid[y*cr+x]);
+        draw_text(dr, tx + GRIDEXTRA * 4, ty + GRIDEXTRA * 4 + TILE_SIZE/4,
+                  FONT_VARIABLE, TILE_SIZE/4, ALIGN_VNORMAL | ALIGN_HLEFT,
+                  col_killer, str);
+    }
+
+    /* new number needs drawing? */
+    if (state->grid[y*cr+x]) {
+        str[1] = '\0';
+        str[0] = state->grid[y*cr+x] + '0';
+        if (str[0] > '9')
+            str[0] += 'a' - ('9'+1);
+        draw_text(dr, tx + TILE_SIZE/2, ty + TILE_SIZE/2,
+                  FONT_VARIABLE, TILE_SIZE/2, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                  state->immutable[y*cr+x] ? COL_CLUE : (hl & 16) ? COL_ERROR : COL_USER, str);
+    } else {
+        int i, j, npencil;
+        int pl, pr, pt, pb;
+        float bestsize;
+        int pw, ph, minph, pbest, fontsize;
+
+        /* Count the pencil marks required. */
+        for (i = npencil = 0; i < cr; i++)
+            if (state->pencil[(y*cr+x)*cr+i])
+                npencil++;
+        if (npencil) {
+
+            minph = 2;
+
+            /*
+             * Determine the bounding rectangle within which we're going
+             * to put the pencil marks.
+             */
+            /* Start with the whole square */
+            pl = tx + GRIDEXTRA;
+            pr = pl + TILE_SIZE - GRIDEXTRA;
+            pt = ty + GRIDEXTRA;
+            pb = pt + TILE_SIZE - GRIDEXTRA;
+            if (state->killer) {
+                /*
+                 * Make space for the Killer cages. We do this
+                 * unconditionally, for uniformity between squares,
+                 * rather than making it depend on whether a Killer
+                 * cage edge is actually present on any given side.
+                 */
+                pl += GRIDEXTRA * 3;
+                pr -= GRIDEXTRA * 3;
+                pt += GRIDEXTRA * 3;
+                pb -= GRIDEXTRA * 3;
+                if (state->kgrid[y*cr+x] != 0) {
+                    /* Make further space for the Killer number. */
+                    pt += TILE_SIZE/4;
+                    /* minph--; */
+                }
+            }
+
+            /*
+             * We arrange our pencil marks in a grid layout, with
+             * the number of rows and columns adjusted to allow the
+             * maximum font size.
+             *
+             * So now we work out what the grid size ought to be.
+             */
+            bestsize = 0.0;
+            pbest = 0;
+            /* Minimum */
+            for (pw = 3; pw < max(npencil,4); pw++) {
+                float fw, fh, fs;
+
+                ph = (npencil + pw - 1) / pw;
+                ph = max(ph, minph);
+                fw = (pr - pl) / (float)pw;
+                fh = (pb - pt) / (float)ph;
+                fs = min(fw, fh);
+                if (fs > bestsize) {
+                    bestsize = fs;
+                    pbest = pw;
+                }
+            }
+            assert(pbest > 0);
+            pw = pbest;
+            ph = (npencil + pw - 1) / pw;
+            ph = max(ph, minph);
+
+            /*
+             * Now we've got our grid dimensions, work out the pixel
+             * size of a grid element, and round it to the nearest
+             * pixel. (We don't want rounding errors to make the
+             * grid look uneven at low pixel sizes.)
+             */
+            fontsize = min((pr - pl) / pw, (pb - pt) / ph);
+
+            /*
+             * Centre the resulting figure in the square.
+             */
+            pl = tx + (TILE_SIZE - fontsize * pw) / 2;
+            pt = ty + (TILE_SIZE - fontsize * ph) / 2;
+
+            /*
+             * And move it down a bit if it's collided with the
+             * Killer cage number.
+             */
+            if (state->killer && state->kgrid[y*cr+x] != 0) {
+                pt = max(pt, ty + GRIDEXTRA * 3 + TILE_SIZE/4);
+            }
+
+            /*
+             * Now actually draw the pencil marks.
+             */
+            for (i = j = 0; i < cr; i++)
+                if (state->pencil[(y*cr+x)*cr+i]) {
+                    int dx = j % pw, dy = j / pw;
+
+                    str[1] = '\0';
+                    str[0] = i + '1';
+                    if (str[0] > '9')
+                        str[0] += 'a' - ('9'+1);
+                    draw_text(dr, pl + fontsize * (2*dx+1) / 2,
+                              pt + fontsize * (2*dy+1) / 2,
+                              FONT_VARIABLE, fontsize,
+                              ALIGN_VCENTRE | ALIGN_HCENTRE, COL_PENCIL, str);
+                    j++;
+                }
+        }
+    }
+
+    unclip(dr);
+
+    draw_update(dr, cx, cy, cw, ch);
+
+    ds->grid[y*cr+x] = state->grid[y*cr+x];
+    memcpy(ds->pencil+(y*cr+x)*cr, state->pencil+(y*cr+x)*cr, cr);
+    ds->hl[y*cr+x] = hl;
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int cr = state->cr;
+    int x, y;
+
+    if (!ds->started) {
+        /*
+         * The initial contents of the window are not guaranteed
+         * and can vary with front ends. To be on the safe side,
+         * all games should start by drawing a big
+         * background-colour rectangle covering the whole window.
+         */
+        draw_rect(dr, 0, 0, SIZE(cr), SIZE(cr), COL_BACKGROUND);
+
+        /*
+         * Draw the grid. We draw it as a big thick rectangle of
+         * COL_GRID initially; individual calls to draw_number()
+         * will poke the right-shaped holes in it.
+         */
+        draw_rect(dr, BORDER-GRIDEXTRA, BORDER-GRIDEXTRA,
+                  cr*TILE_SIZE+1+2*GRIDEXTRA, cr*TILE_SIZE+1+2*GRIDEXTRA,
+                  COL_GRID);
+    }
+
+    /*
+     * This array is used to keep track of rows, columns and boxes
+     * which contain a number more than once.
+     */
+    for (x = 0; x < cr * ds->nregions; x++)
+        ds->entered_items[x] = 0;
+    for (x = 0; x < cr; x++)
+        for (y = 0; y < cr; y++) {
+            digit d = state->grid[y*cr+x];
+            if (d) {
+                int box, kbox;
+
+                /* Rows */
+                ds->entered_items[x*cr+d-1]++;
+
+                /* Columns */
+                ds->entered_items[(y+cr)*cr+d-1]++;
+
+                /* Blocks */
+                box = state->blocks->whichblock[y*cr+x];
+                ds->entered_items[(box+2*cr)*cr+d-1]++;
+
+                /* Diagonals */
+                if (ds->xtype) {
+                    if (ondiag0(y*cr+x))
+                        ds->entered_items[(3*cr)*cr+d-1]++;
+                    if (ondiag1(y*cr+x))
+                        ds->entered_items[(3*cr+1)*cr+d-1]++;
+                }
+
+                /* Killer cages */
+                if (state->kblocks) {
+                    kbox = state->kblocks->whichblock[y*cr+x];
+                    ds->entered_items[(kbox+3*cr+2)*cr+d-1]++;
+                }
+            }
+        }
+
+    /*
+     * Draw any numbers which need redrawing.
+     */
+    for (x = 0; x < cr; x++) {
+        for (y = 0; y < cr; y++) {
+            int highlight = 0;
+            digit d = state->grid[y*cr+x];
+
+            if (flashtime > 0 &&
+                (flashtime <= FLASH_TIME/3 ||
+                 flashtime >= FLASH_TIME*2/3))
+                highlight = 1;
+
+            /* Highlight active input areas. */
+            if (x == ui->hx && y == ui->hy && ui->hshow)
+                highlight = ui->hpencil ? 2 : 1;
+
+            /* Mark obvious errors (ie, numbers which occur more than once
+             * in a single row, column, or box). */
+            if (d && (ds->entered_items[x*cr+d-1] > 1 ||
+                      ds->entered_items[(y+cr)*cr+d-1] > 1 ||
+                      ds->entered_items[(state->blocks->whichblock[y*cr+x]
+                                         +2*cr)*cr+d-1] > 1 ||
+                      (ds->xtype && ((ondiag0(y*cr+x) &&
+                                      ds->entered_items[(3*cr)*cr+d-1] > 1) ||
+                                     (ondiag1(y*cr+x) &&
+                                      ds->entered_items[(3*cr+1)*cr+d-1]>1)))||
+                      (state->kblocks &&
+                       ds->entered_items[(state->kblocks->whichblock[y*cr+x]
+                                          +3*cr+2)*cr+d-1] > 1)))
+                highlight |= 16;
+
+            if (d && state->kblocks) {
+                if (check_killer_cage_sum(
+                        state->kblocks, state->kgrid, state->grid,
+                        state->kblocks->whichblock[y*cr+x]) == 0)
+                    highlight |= 32;
+            }
+
+            draw_number(dr, ds, state, x, y, highlight);
+        }
+    }
+
+    /*
+     * Update the _entire_ grid if necessary.
+     */
+    if (!ds->started) {
+        draw_update(dr, 0, 0, SIZE(cr), SIZE(cr));
+        ds->started = TRUE;
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    if (state->completed)
+        return FALSE;
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 9mm squares by default. They should be quite big
+     * for this game, because players will want to jot down no end
+     * of pencil marks in the squares.
+     */
+    game_compute_size(params, 900, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+/*
+ * Subfunction to draw the thick lines between cells. In order to do
+ * this using the line-drawing rather than rectangle-drawing API (so
+ * as to get line thicknesses to scale correctly) and yet have
+ * correctly mitred joins between lines, we must do this by tracing
+ * the boundary of each sub-block and drawing it in one go as a
+ * single polygon.
+ *
+ * This subfunction is also reused with thinner dotted lines to
+ * outline the Killer cages, this time offsetting the outline toward
+ * the interior of the affected squares.
+ */
+static void outline_block_structure(drawing *dr, game_drawstate *ds,
+                                    const game_state *state,
+                                    struct block_structure *blocks,
+                                    int ink, int inset)
+{
+    int cr = state->cr;
+    int *coords;
+    int bi, i, n;
+    int x, y, dx, dy, sx, sy, sdx, sdy;
+
+    /*
+     * Maximum perimeter of a k-omino is 2k+2. (Proof: start
+     * with k unconnected squares, with total perimeter 4k.
+     * Now repeatedly join two disconnected components
+     * together into a larger one; every time you do so you
+     * remove at least two unit edges, and you require k-1 of
+     * these operations to create a single connected piece, so
+     * you must have at most 4k-2(k-1) = 2k+2 unit edges left
+     * afterwards.)
+     */
+    coords = snewn(4*cr+4, int);   /* 2k+2 points, 2 coords per point */
+
+    /*
+     * Iterate over all the blocks.
+     */
+    for (bi = 0; bi < blocks->nr_blocks; bi++) {
+        if (blocks->nr_squares[bi] == 0)
+            continue;
+
+        /*
+         * For each block, find a starting square within it
+         * which has a boundary at the left.
+         */
+        for (i = 0; i < cr; i++) {
+            int j = blocks->blocks[bi][i];
+            if (j % cr == 0 || blocks->whichblock[j-1] != bi)
+                break;
+        }
+        assert(i < cr); /* every block must have _some_ leftmost square */
+        x = blocks->blocks[bi][i] % cr;
+        y = blocks->blocks[bi][i] / cr;
+        dx = -1;
+        dy = 0;
+
+        /*
+         * Now begin tracing round the perimeter. At all
+         * times, (x,y) describes some square within the
+         * block, and (x+dx,y+dy) is some adjacent square
+         * outside it; so the edge between those two squares
+         * is always an edge of the block.
+         */
+        sx = x, sy = y, sdx = dx, sdy = dy;   /* save starting position */
+        n = 0;
+        do {
+            int cx, cy, tx, ty, nin;
+
+            /*
+             * Advance to the next edge, by looking at the two
+             * squares beyond it. If they're both outside the block,
+             * we turn right (by leaving x,y the same and rotating
+             * dx,dy clockwise); if they're both inside, we turn
+             * left (by rotating dx,dy anticlockwise and contriving
+             * to leave x+dx,y+dy unchanged); if one of each, we go
+             * straight on (and may enforce by assertion that
+             * they're one of each the _right_ way round).
+             */
+            nin = 0;
+            tx = x - dy + dx;
+            ty = y + dx + dy;
+            nin += (tx >= 0 && tx < cr && ty >= 0 && ty < cr &&
+                    blocks->whichblock[ty*cr+tx] == bi);
+            tx = x - dy;
+            ty = y + dx;
+            nin += (tx >= 0 && tx < cr && ty >= 0 && ty < cr &&
+                    blocks->whichblock[ty*cr+tx] == bi);
+            if (nin == 0) {
+                /*
+                 * Turn right.
+                 */
+                int tmp;
+                tmp = dx;
+                dx = -dy;
+                dy = tmp;
+            } else if (nin == 2) {
+                /*
+                 * Turn left.
+                 */
+                int tmp;
+
+                x += dx;
+                y += dy;
+
+                tmp = dx;
+                dx = dy;
+                dy = -tmp;
+
+                x -= dx;
+                y -= dy;
+            } else {
+                /*
+                 * Go straight on.
+                 */
+                x -= dy;
+                y += dx;
+            }
+
+            /*
+             * Now enforce by assertion that we ended up
+             * somewhere sensible.
+             */
+            assert(x >= 0 && x < cr && y >= 0 && y < cr &&
+                   blocks->whichblock[y*cr+x] == bi);
+            assert(x+dx < 0 || x+dx >= cr || y+dy < 0 || y+dy >= cr ||
+                   blocks->whichblock[(y+dy)*cr+(x+dx)] != bi);
+
+            /*
+             * Record the point we just went past at one end of the
+             * edge. To do this, we translate (x,y) down and right
+             * by half a unit (so they're describing a point in the
+             * _centre_ of the square) and then translate back again
+             * in a manner rotated by dy and dx.
+             */
+            assert(n < 2*cr+2);
+            cx = ((2*x+1) + dy + dx) / 2;
+            cy = ((2*y+1) - dx + dy) / 2;
+            coords[2*n+0] = BORDER + cx * TILE_SIZE;
+            coords[2*n+1] = BORDER + cy * TILE_SIZE;
+            coords[2*n+0] -= dx * inset;
+            coords[2*n+1] -= dy * inset;
+            if (nin == 0) {
+                /*
+                 * We turned right, so inset this corner back along
+                 * the edge towards the centre of the square.
+                 */
+                coords[2*n+0] -= dy * inset;
+                coords[2*n+1] += dx * inset;
+            } else if (nin == 2) {
+                /*
+                 * We turned left, so inset this corner further
+                 * _out_ along the edge into the next square.
+                 */
+                coords[2*n+0] += dy * inset;
+                coords[2*n+1] -= dx * inset;
+            }
+            n++;
+
+        } while (x != sx || y != sy || dx != sdx || dy != sdy);
+
+        /*
+         * That's our polygon; now draw it.
+         */
+        draw_polygon(dr, coords, n, -1, ink);
+    }
+
+    sfree(coords);
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int cr = state->cr;
+    int ink = print_mono_colour(dr, 0);
+    int x, y;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    /*
+     * Border.
+     */
+    print_line_width(dr, 3 * TILE_SIZE / 40);
+    draw_rect_outline(dr, BORDER, BORDER, cr*TILE_SIZE, cr*TILE_SIZE, ink);
+
+    /*
+     * Highlight X-diagonal squares.
+     */
+    if (state->xtype) {
+        int i;
+        int xhighlight = print_grey_colour(dr, 0.90F);
+
+        for (i = 0; i < cr; i++)
+            draw_rect(dr, BORDER + i*TILE_SIZE, BORDER + i*TILE_SIZE,
+                      TILE_SIZE, TILE_SIZE, xhighlight);
+        for (i = 0; i < cr; i++)
+            if (i*2 != cr-1)  /* avoid redoing centre square, just for fun */
+                draw_rect(dr, BORDER + i*TILE_SIZE,
+                          BORDER + (cr-1-i)*TILE_SIZE,
+                          TILE_SIZE, TILE_SIZE, xhighlight);
+    }
+
+    /*
+     * Main grid.
+     */
+    for (x = 1; x < cr; x++) {
+        print_line_width(dr, TILE_SIZE / 40);
+        draw_line(dr, BORDER+x*TILE_SIZE, BORDER,
+                  BORDER+x*TILE_SIZE, BORDER+cr*TILE_SIZE, ink);
+    }
+    for (y = 1; y < cr; y++) {
+        print_line_width(dr, TILE_SIZE / 40);
+        draw_line(dr, BORDER, BORDER+y*TILE_SIZE,
+                  BORDER+cr*TILE_SIZE, BORDER+y*TILE_SIZE, ink);
+    }
+
+    /*
+     * Thick lines between cells.
+     */
+    print_line_width(dr, 3 * TILE_SIZE / 40);
+    outline_block_structure(dr, ds, state, state->blocks, ink, 0);
+
+    /*
+     * Killer cages and their totals.
+     */
+    if (state->kblocks) {
+        print_line_width(dr, TILE_SIZE / 40);
+        print_line_dotted(dr, TRUE);
+        outline_block_structure(dr, ds, state, state->kblocks, ink,
+                                5 * TILE_SIZE / 40);
+        print_line_dotted(dr, FALSE);
+        for (y = 0; y < cr; y++)
+            for (x = 0; x < cr; x++)
+                if (state->kgrid[y*cr+x]) {
+                    char str[20];
+                    sprintf(str, "%d", state->kgrid[y*cr+x]);
+                    draw_text(dr,
+                              BORDER+x*TILE_SIZE + 7*TILE_SIZE/40,
+                              BORDER+y*TILE_SIZE + 16*TILE_SIZE/40,
+                              FONT_VARIABLE, TILE_SIZE/4,
+                              ALIGN_VNORMAL | ALIGN_HLEFT,
+                              ink, str);
+                }
+    }
+
+    /*
+     * Standard (non-Killer) clue numbers.
+     */
+    for (y = 0; y < cr; y++)
+        for (x = 0; x < cr; x++)
+            if (state->grid[y*cr+x]) {
+                char str[2];
+                str[1] = '\0';
+                str[0] = state->grid[y*cr+x] + '0';
+                if (str[0] > '9')
+                    str[0] += 'a' - ('9'+1);
+                draw_text(dr, BORDER + x*TILE_SIZE + TILE_SIZE/2,
+                          BORDER + y*TILE_SIZE + TILE_SIZE/2,
+                          FONT_VARIABLE, TILE_SIZE/2,
+                          ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str);
+            }
+}
+
+#ifdef COMBINED
+#define thegame solo
+#endif
+
+const struct game thegame = {
+    "Solo", "games.solo", "solo",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON | REQUIRE_NUMPAD,  /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err;
+    int grade = FALSE;
+    struct difficulty dlev;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            solver_show_working = TRUE;
+        } else if (!strcmp(p, "-g")) {
+            grade = TRUE;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-g | -v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    dlev.maxdiff = DIFF_RECURSIVE;
+    dlev.maxkdiff = DIFF_KINTERSECT;
+    solver(s->cr, s->blocks, s->kblocks, s->xtype, s->grid, s->kgrid, &dlev);
+    if (grade) {
+        printf("Difficulty rating: %s\n",
+               dlev.diff==DIFF_BLOCK ? "Trivial (blockwise positional elimination only)":
+               dlev.diff==DIFF_SIMPLE ? "Basic (row/column/number elimination required)":
+               dlev.diff==DIFF_INTERSECT ? "Intermediate (intersectional analysis required)":
+               dlev.diff==DIFF_SET ? "Advanced (set elimination required)":
+               dlev.diff==DIFF_EXTREME ? "Extreme (complex non-recursive techniques required)":
+               dlev.diff==DIFF_RECURSIVE ? "Unreasonable (guesswork and backtracking required)":
+               dlev.diff==DIFF_AMBIGUOUS ? "Ambiguous (multiple solutions exist)":
+               dlev.diff==DIFF_IMPOSSIBLE ? "Impossible (no solution exists)":
+               "INTERNAL ERROR: unrecognised difficulty code");
+        if (p->killer)
+            printf("Killer difficulty: %s\n",
+                   dlev.kdiff==DIFF_KSINGLE ? "Trivial (single square cages only)":
+                   dlev.kdiff==DIFF_KMINMAX ? "Simple (maximum sum analysis required)":
+                   dlev.kdiff==DIFF_KSUMS ? "Intermediate (sum possibilities)":
+                   dlev.kdiff==DIFF_KINTERSECT ? "Advanced (sum region intersections)":
+                   "INTERNAL ERROR: unrecognised difficulty code");
+    } else {
+        printf("%s\n", grid_text_format(s->cr, s->blocks, s->xtype, s->grid));
+    }
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/tdq.c b/apps/plugins/puzzles/tdq.c
new file mode 100644
index 0000000000..43c9c35de5
--- /dev/null
+++ b/apps/plugins/puzzles/tdq.c
@@ -0,0 +1,88 @@
+/*
+ * tdq.c: implement a 'to-do queue', a simple de-duplicating to-do
+ * list mechanism.
+ */
+
+#include "rbassert.h"
+
+#include "puzzles.h"
+
+/*
+ * Implementation: a tdq consists of a circular buffer of size n
+ * storing the integers currently in the queue, plus an array of n
+ * booleans indicating whether each integer is already there.
+ *
+ * Using a circular buffer of size n to store between 0 and n items
+ * inclusive has an obvious failure mode: if the input and output
+ * pointers are the same, how do you know whether that means the
+ * buffer is full or empty?
+ *
+ * In this application we have a simple way to tell: in the former
+ * case, the flags array is all 1s, and in the latter case it's all
+ * 0s. So we could spot that case and check, say, flags[0].
+ *
+ * However, it's even easier to simply determine whether the queue is
+ * non-empty by testing flags[buffer[op]] - that way we don't even
+ * _have_ to compare ip against op.
+ */
+
+struct tdq {
+    int n;
+    int *queue;
+    int ip, op;                        /* in pointer, out pointer */
+    char *flags;
+};
+
+tdq *tdq_new(int n)
+{
+    int i;
+    tdq *tdq = snew(struct tdq);
+    tdq->queue = snewn(n, int);
+    tdq->flags = snewn(n, char);
+    for (i = 0; i < n; i++) {
+        tdq->queue[i] = 0;
+        tdq->flags[i] = 0;
+    }
+    tdq->n = n;
+    tdq->ip = tdq->op = 0;
+    return tdq;
+}
+
+void tdq_free(tdq *tdq)
+{
+    sfree(tdq->queue);
+    sfree(tdq->flags);
+    sfree(tdq);
+}
+
+void tdq_add(tdq *tdq, int k)
+{
+    assert((unsigned)k < (unsigned)tdq->n);
+    if (!tdq->flags[k]) {
+        tdq->queue[tdq->ip] = k;
+        tdq->flags[k] = 1;
+        if (++tdq->ip == tdq->n)
+            tdq->ip = 0;
+    }
+}
+
+int tdq_remove(tdq *tdq)
+{
+    int ret = tdq->queue[tdq->op];
+
+    if (!tdq->flags[ret])
+        return -1;
+
+    tdq->flags[ret] = 0;
+    if (++tdq->op == tdq->n)
+        tdq->op = 0;
+
+    return ret;
+}
+
+void tdq_fill(tdq *tdq)
+{
+    int i;
+    for (i = 0; i < tdq->n; i++)
+        tdq_add(tdq, i);
+}
diff --git a/apps/plugins/puzzles/tents.R b/apps/plugins/puzzles/tents.R
new file mode 100644
index 0000000000..557f929840
--- /dev/null
+++ b/apps/plugins/puzzles/tents.R
@@ -0,0 +1,24 @@
+# -*- makefile -*-
+
+TENTS_EXTRA = maxflow dsf
+
+tents    : [X] GTK COMMON tents TENTS_EXTRA tents-icon|no-icon
+
+tents    : [G] WINDOWS COMMON tents TENTS_EXTRA tents.res|noicon.res
+
+ALL += tents[COMBINED] TENTS_EXTRA
+
+tentssolver :   [U] tents[STANDALONE_SOLVER] TENTS_EXTRA STANDALONE
+tentssolver :   [C] tents[STANDALONE_SOLVER] TENTS_EXTRA STANDALONE
+
+!begin am gtk
+GAMES += tents
+!end
+
+!begin >list.c
+    A(tents) \
+!end
+
+!begin >gamedesc.txt
+tents:tents.exe:Tents:Tent-placing puzzle:Place a tent next to each tree.
+!end
diff --git a/apps/plugins/puzzles/tents.c b/apps/plugins/puzzles/tents.c
new file mode 100644
index 0000000000..1bc7a85188
--- /dev/null
+++ b/apps/plugins/puzzles/tents.c
@@ -0,0 +1,2740 @@
+/*
+ * tents.c: Puzzle involving placing tents next to trees subject to
+ * some confusing conditions.
+ * 
+ * TODO:
+ *
+ *  - it might be nice to make setter-provided tent/nontent clues
+ *    inviolable?
+ *     * on the other hand, this would introduce considerable extra
+ *       complexity and size into the game state; also inviolable
+ *       clues would have to be marked as such somehow, in an
+ *       intrusive and annoying manner. Since they're never
+ *       generated by _my_ generator, I'm currently more inclined
+ *       not to bother.
+ * 
+ *  - more difficult levels at the top end?
+ *     * for example, sometimes we can deduce that two BLANKs in
+ *       the same row are each adjacent to the same unattached tree
+ *       and to nothing else, implying that they can't both be
+ *       tents; this enables us to rule out some extra combinations
+ *       in the row-based deduction loop, and hence deduce more
+ *       from the number in that row than we could otherwise do.
+ *     * that by itself doesn't seem worth implementing a new
+ *       difficulty level for, but if I can find a few more things
+ *       like that then it might become worthwhile.
+ *     * I wonder if there's a sensible heuristic for where to
+ *       guess which would make a recursive solver viable?
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "maxflow.h"
+
+/*
+ * Design discussion
+ * -----------------
+ * 
+ * The rules of this puzzle as available on the WWW are poorly
+ * specified. The bits about tents having to be orthogonally
+ * adjacent to trees, tents not being even diagonally adjacent to
+ * one another, and the number of tents in each row and column
+ * being given are simple enough; the difficult bit is the
+ * tent-to-tree matching.
+ * 
+ * Some sources use simplistic wordings such as `each tree is
+ * exactly connected to only one tent', which is extremely unclear:
+ * it's easy to read erroneously as `each tree is _orthogonally
+ * adjacent_ to exactly one tent', which is definitely incorrect.
+ * Even the most coherent sources I've found don't do a much better
+ * job of stating the rule.
+ * 
+ * A more precise statement of the rule is that it must be possible
+ * to find a bijection f between tents and trees such that each
+ * tree T is orthogonally adjacent to the tent f(T), but that a
+ * tent is permitted to be adjacent to other trees in addition to
+ * its own. This slightly non-obvious criterion is what gives this
+ * puzzle most of its subtlety.
+ * 
+ * However, there's a particularly subtle ambiguity left over. Is
+ * the bijection between tents and trees required to be _unique_?
+ * In other words, is that bijection conceptually something the
+ * player should be able to exhibit as part of the solution (even
+ * if they aren't actually required to do so)? Or is it sufficient
+ * to have a unique _placement_ of the tents which gives rise to at
+ * least one suitable bijection?
+ * 
+ * The puzzle shown to the right of this       .T. 2      *T* 2
+ * paragraph illustrates the problem. There    T.T 0  ->  T-T 0
+ * are two distinct bijections available.      .T. 2      *T* 2
+ * The answer to the above question will
+ * determine whether it's a valid puzzle.      202        202
+ * 
+ * This is an important question, because it affects both the
+ * player and the generator. Eventually I found all the instances
+ * of this puzzle I could Google up, solved them all by hand, and
+ * verified that in all cases the tree/tent matching was uniquely
+ * determined given the tree and tent positions. Therefore, the
+ * puzzle as implemented in this source file takes the following
+ * policy:
+ * 
+ *  - When checking a user-supplied solution for correctness, only
+ *    verify that there exists _at least_ one matching.
+ *  - When generating a puzzle, enforce that there must be
+ *    _exactly_ one.
+ * 
+ * Algorithmic implications
+ * ------------------------
+ * 
+ * Another way of phrasing the tree/tent matching criterion is to
+ * say that the bipartite adjacency graph between trees and tents
+ * has a perfect matching. That is, if you construct a graph which
+ * has a vertex per tree and a vertex per tent, and an edge between
+ * any tree and tent which are orthogonally adjacent, it is
+ * possible to find a set of N edges of that graph (where N is the
+ * number of trees and also the number of tents) which between them
+ * connect every tree to every tent.
+ * 
+ * The most efficient known algorithms for finding such a matching
+ * given a graph, as far as I'm aware, are the Munkres assignment
+ * algorithm (also known as the Hungarian algorithm) and the
+ * Ford-Fulkerson algorithm (for finding optimal flows in
+ * networks). Each of these takes O(N^3) running time; so we're
+ * talking O(N^3) time to verify any candidate solution to this
+ * puzzle. That's just about OK if you're doing it once per mouse
+ * click (and in fact not even that, since the sensible thing to do
+ * is check all the _other_ puzzle criteria and only wade into this
+ * quagmire if none are violated); but if the solver had to keep
+ * doing N^3 work internally, then it would probably end up with
+ * more like N^5 or N^6 running time, and grid generation would
+ * become very clunky.
+ * 
+ * Fortunately, I've been able to prove a very useful property of
+ * _unique_ perfect matchings, by adapting the proof of Hall's
+ * Marriage Theorem. For those unaware of Hall's Theorem, I'll
+ * recap it and its proof: it states that a bipartite graph
+ * contains a perfect matching iff every set of vertices on the
+ * left side of the graph have a neighbourhood _at least_ as big on
+ * the right.
+ * 
+ * This condition is obviously satisfied if a perfect matching does
+ * exist; each left-side node has a distinct right-side node which
+ * is the one assigned to it by the matching, and thus any set of n
+ * left vertices must have a combined neighbourhood containing at
+ * least the n corresponding right vertices, and possibly others
+ * too. Alternatively, imagine if you had (say) three left-side
+ * nodes all of which were connected to only two right-side nodes
+ * between them: any perfect matching would have to assign one of
+ * those two right nodes to each of the three left nodes, and still
+ * give the three left nodes a different right node each. This is
+ * of course impossible.
+ *
+ * To prove the converse (that if every subset of left vertices
+ * satisfies the Hall condition then a perfect matching exists),
+ * consider trying to find a proper subset of the left vertices
+ * which _exactly_ satisfies the Hall condition: that is, its right
+ * neighbourhood is precisely the same size as it. If we can find
+ * such a subset, then we can split the bipartite graph into two
+ * smaller ones: one consisting of the left subset and its right
+ * neighbourhood, the other consisting of everything else. Edges
+ * from the left side of the former graph to the right side of the
+ * latter do not exist, by construction; edges from the right side
+ * of the former to the left of the latter cannot be part of any
+ * perfect matching because otherwise the left subset would not be
+ * left with enough distinct right vertices to connect to (this is
+ * exactly the same deduction used in Solo's set analysis). You can
+ * then prove (left as an exercise) that both these smaller graphs
+ * still satisfy the Hall condition, and therefore the proof will
+ * follow by induction.
+ * 
+ * There's one other possibility, which is the case where _no_
+ * proper subset of the left vertices has a right neighbourhood of
+ * exactly the same size. That is, every left subset has a strictly
+ * _larger_ right neighbourhood. In this situation, we can simply
+ * remove an _arbitrary_ edge from the graph. This cannot reduce
+ * the size of any left subset's right neighbourhood by more than
+ * one, so if all neighbourhoods were strictly bigger than they
+ * needed to be initially, they must now still be _at least as big_
+ * as they need to be. So we can keep throwing out arbitrary edges
+ * until we find a set which exactly satisfies the Hall condition,
+ * and then proceed as above. []
+ * 
+ * That's Hall's theorem. I now build on this by examining the
+ * circumstances in which a bipartite graph can have a _unique_
+ * perfect matching. It is clear that in the second case, where no
+ * left subset exactly satisfies the Hall condition and so we can
+ * remove an arbitrary edge, there cannot be a unique perfect
+ * matching: given one perfect matching, we choose our arbitrary
+ * removed edge to be one of those contained in it, and then we can
+ * still find a perfect matching in the remaining graph, which will
+ * be a distinct perfect matching in the original.
+ * 
+ * So it is a necessary condition for a unique perfect matching
+ * that there must be at least one proper left subset which
+ * _exactly_ satisfies the Hall condition. But now consider the
+ * smaller graph constructed by taking that left subset and its
+ * neighbourhood: if the graph as a whole had a unique perfect
+ * matching, then so must this smaller one, which means we can find
+ * a proper left subset _again_, and so on. Repeating this process
+ * must eventually reduce us to a graph with only one left-side
+ * vertex (so there are no proper subsets at all); this vertex must
+ * be connected to only one right-side vertex, and hence must be so
+ * in the original graph as well (by construction). So we can
+ * discard this vertex pair from the graph, and any other edges
+ * that involved it (which will by construction be from other left
+ * vertices only), and the resulting smaller graph still has a
+ * unique perfect matching which means we can do the same thing
+ * again.
+ * 
+ * In other words, given any bipartite graph with a unique perfect
+ * matching, we can find that matching by the following extremely
+ * simple algorithm:
+ * 
+ *  - Find a left-side vertex which is only connected to one
+ *    right-side vertex.
+ *  - Assign those vertices to one another, and therefore discard
+ *    any other edges connecting to that right vertex.
+ *  - Repeat until all vertices have been matched.
+ * 
+ * This algorithm can be run in O(V+E) time (where V is the number
+ * of vertices and E is the number of edges in the graph), and the
+ * only way it can fail is if there is not a unique perfect
+ * matching (either because there is no matching at all, or because
+ * it isn't unique; but it can't distinguish those cases).
+ * 
+ * Thus, the internal solver in this source file can be confident
+ * that if the tree/tent matching is uniquely determined by the
+ * tree and tent positions, it can find it using only this kind of
+ * obvious and simple operation: assign a tree to a tent if it
+ * cannot possibly belong to any other tent, and vice versa. If the
+ * solver were _only_ trying to determine the matching, even that
+ * `vice versa' wouldn't be required; but it can come in handy when
+ * not all the tents have been placed yet. I can therefore be
+ * reasonably confident that as long as my solver doesn't need to
+ * cope with grids that have a non-unique matching, it will also
+ * not need to do anything complicated like set analysis between
+ * trees and tents.
+ */
+
+/*
+ * In standalone solver mode, `verbose' is a variable which can be
+ * set by command-line option; in debugging mode it's simply always
+ * true.
+ */
+#if defined STANDALONE_SOLVER
+#define SOLVER_DIAGNOSTICS
+int verbose = FALSE;
+#elif defined SOLVER_DIAGNOSTICS
+#define verbose TRUE
+#endif
+
+/*
+ * Difficulty levels. I do some macro ickery here to ensure that my
+ * enum and the various forms of my name list always match up.
+ */
+#define DIFFLIST(A) \
+    A(EASY,Easy,e) \
+    A(TRICKY,Tricky,t)
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const tents_diffnames[] = { DIFFLIST(TITLE) };
+static char const tents_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_GRASS,
+    COL_TREETRUNK,
+    COL_TREELEAF,
+    COL_TENT,
+    COL_ERROR,
+    COL_ERRTEXT,
+    COL_ERRTRUNK,
+    NCOLOURS
+};
+
+enum { BLANK, TREE, TENT, NONTENT, MAGIC };
+
+struct game_params {
+    int w, h;
+    int diff;
+};
+
+struct numbers {
+    int refcount;
+    int *numbers;
+};
+
+struct game_state {
+    game_params p;
+    char *grid;
+    struct numbers *numbers;
+    int completed, used_solve;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 8;
+    ret->diff = DIFF_EASY;
+
+    return ret;
+}
+
+static const struct game_params tents_presets[] = {
+    {8, 8, DIFF_EASY},
+    {8, 8, DIFF_TRICKY},
+    {10, 10, DIFF_EASY},
+    {10, 10, DIFF_TRICKY},
+    {15, 15, DIFF_EASY},
+    {15, 15, DIFF_TRICKY},
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(tents_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = tents_presets[i];
+
+    sprintf(str, "%dx%d %s", ret->w, ret->h, tents_diffnames[ret->diff]);
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->w = params->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        params->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 'd') {
+        int i;
+        string++;
+        for (i = 0; i < DIFFCOUNT; i++)
+            if (*string == tents_diffchars[i])
+                params->diff = i;
+        if (*string) string++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[120];
+
+    sprintf(buf, "%dx%d", params->w, params->h);
+    if (full)
+        sprintf(buf + strlen(buf), "d%c",
+                tents_diffchars[params->diff]);
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Difficulty";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = DIFFCONFIG;
+    ret[2].ival = params->diff;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->diff = cfg[2].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    /*
+     * Generating anything under 4x4 runs into trouble of one kind
+     * or another.
+     */
+    if (params->w < 4 || params->h < 4)
+        return "Width and height must both be at least four";
+    return NULL;
+}
+
+/*
+ * Scratch space for solver.
+ */
+enum { N, U, L, R, D, MAXDIR };        /* link directions */
+#define dx(d) ( ((d)==R) - ((d)==L) )
+#define dy(d) ( ((d)==D) - ((d)==U) )
+#define F(d) ( U + D - (d) )
+struct solver_scratch {
+    char *links;                       /* mapping between trees and tents */
+    int *locs;
+    char *place, *mrows, *trows;
+};
+
+static struct solver_scratch *new_scratch(int w, int h)
+{
+    struct solver_scratch *ret = snew(struct solver_scratch);
+
+    ret->links = snewn(w*h, char);
+    ret->locs = snewn(max(w, h), int);
+    ret->place = snewn(max(w, h), char);
+    ret->mrows = snewn(3 * max(w, h), char);
+    ret->trows = snewn(3 * max(w, h), char);
+
+    return ret;
+}
+
+static void free_scratch(struct solver_scratch *sc)
+{
+    sfree(sc->trows);
+    sfree(sc->mrows);
+    sfree(sc->place);
+    sfree(sc->locs);
+    sfree(sc->links);
+    sfree(sc);
+}
+
+/*
+ * Solver. Returns 0 for impossibility, 1 for success, 2 for
+ * ambiguity or failure to converge.
+ */
+static int tents_solve(int w, int h, const char *grid, int *numbers,
+                       char *soln, struct solver_scratch *sc, int diff)
+{
+    int x, y, d, i, j;
+    char *mrow, *trow, *trow1, *trow2;
+
+    /*
+     * Set up solver data.
+     */
+    memset(sc->links, N, w*h);
+
+    /*
+     * Set up solution array.
+     */
+    memcpy(soln, grid, w*h);
+
+    /*
+     * Main solver loop.
+     */
+    while (1) {
+        int done_something = FALSE;
+
+        /*
+         * Any tent which has only one unattached tree adjacent to
+         * it can be tied to that tree.
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                if (soln[y*w+x] == TENT && !sc->links[y*w+x]) {
+                    int linkd = 0;
+
+                    for (d = 1; d < MAXDIR; d++) {
+                        int x2 = x + dx(d), y2 = y + dy(d);
+                        if (x2 >= 0 && x2 < w && y2 >= 0 && y2 < h &&
+                            soln[y2*w+x2] == TREE &&
+                            !sc->links[y2*w+x2]) {
+                            if (linkd)
+                                break; /* found more than one */
+                            else
+                                linkd = d;
+                        }
+                    }
+
+                    if (d == MAXDIR && linkd == 0) {
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose)
+                            printf("tent at %d,%d cannot link to anything\n",
+                                   x, y);
+#endif
+                        return 0;      /* no solution exists */
+                    } else if (d == MAXDIR) {
+                        int x2 = x + dx(linkd), y2 = y + dy(linkd);
+
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose)
+                            printf("tent at %d,%d can only link to tree at"
+                                   " %d,%d\n", x, y, x2, y2);
+#endif
+
+                        sc->links[y*w+x] = linkd;
+                        sc->links[y2*w+x2] = F(linkd);
+                        done_something = TRUE;
+                    }
+                }
+
+        if (done_something)
+            continue;
+        if (diff < 0)
+            break;                     /* don't do anything else! */
+
+        /*
+         * Mark a blank square as NONTENT if it is not orthogonally
+         * adjacent to any unmatched tree.
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                if (soln[y*w+x] == BLANK) {
+                    int can_be_tent = FALSE;
+
+                    for (d = 1; d < MAXDIR; d++) {
+                        int x2 = x + dx(d), y2 = y + dy(d);
+                        if (x2 >= 0 && x2 < w && y2 >= 0 && y2 < h &&
+                            soln[y2*w+x2] == TREE &&
+                            !sc->links[y2*w+x2])
+                            can_be_tent = TRUE;
+                    }
+
+                    if (!can_be_tent) {
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose)
+                            printf("%d,%d cannot be a tent (no adjacent"
+                                   " unmatched tree)\n", x, y);
+#endif
+                        soln[y*w+x] = NONTENT;
+                        done_something = TRUE;
+                    }
+                }
+
+        if (done_something)
+            continue;
+
+        /*
+         * Mark a blank square as NONTENT if it is (perhaps
+         * diagonally) adjacent to any other tent.
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                if (soln[y*w+x] == BLANK) {
+                    int dx, dy, imposs = FALSE;
+
+                    for (dy = -1; dy <= +1; dy++)
+                        for (dx = -1; dx <= +1; dx++)
+                            if (dy || dx) {
+                                int x2 = x + dx, y2 = y + dy;
+                                if (x2 >= 0 && x2 < w && y2 >= 0 && y2 < h &&
+                                    soln[y2*w+x2] == TENT)
+                                    imposs = TRUE;
+                            }
+
+                    if (imposs) {
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose)
+                            printf("%d,%d cannot be a tent (adjacent tent)\n",
+                                   x, y);
+#endif
+                        soln[y*w+x] = NONTENT;
+                        done_something = TRUE;
+                    }
+                }
+
+        if (done_something)
+            continue;
+
+        /*
+         * Any tree which has exactly one {unattached tent, BLANK}
+         * adjacent to it must have its tent in that square.
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                if (soln[y*w+x] == TREE && !sc->links[y*w+x]) {
+                    int linkd = 0, linkd2 = 0, nd = 0;
+
+                    for (d = 1; d < MAXDIR; d++) {
+                        int x2 = x + dx(d), y2 = y + dy(d);
+                        if (!(x2 >= 0 && x2 < w && y2 >= 0 && y2 < h))
+                            continue;
+                        if (soln[y2*w+x2] == BLANK ||
+                            (soln[y2*w+x2] == TENT && !sc->links[y2*w+x2])) {
+                            if (linkd)
+                                linkd2 = d;
+                            else
+                                linkd = d;
+                            nd++;
+                        }
+                    }
+
+                    if (nd == 0) {
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose)
+                            printf("tree at %d,%d cannot link to anything\n",
+                                   x, y);
+#endif
+                        return 0;      /* no solution exists */
+                    } else if (nd == 1) {
+                        int x2 = x + dx(linkd), y2 = y + dy(linkd);
+
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose)
+                            printf("tree at %d,%d can only link to tent at"
+                                   " %d,%d\n", x, y, x2, y2);
+#endif
+                        soln[y2*w+x2] = TENT;
+                        sc->links[y*w+x] = linkd;
+                        sc->links[y2*w+x2] = F(linkd);
+                        done_something = TRUE;
+                    } else if (nd == 2 && (!dx(linkd) != !dx(linkd2)) &&
+                               diff >= DIFF_TRICKY) {
+                        /*
+                         * If there are two possible places where
+                         * this tree's tent can go, and they are
+                         * diagonally separated rather than being
+                         * on opposite sides of the tree, then the
+                         * square (other than the tree square)
+                         * which is adjacent to both of them must
+                         * be a non-tent.
+                         */
+                        int x2 = x + dx(linkd) + dx(linkd2);
+                        int y2 = y + dy(linkd) + dy(linkd2);
+                        assert(x2 >= 0 && x2 < w && y2 >= 0 && y2 < h);
+                        if (soln[y2*w+x2] == BLANK) {
+#ifdef SOLVER_DIAGNOSTICS
+                            if (verbose)
+                                printf("possible tent locations for tree at"
+                                       " %d,%d rule out tent at %d,%d\n",
+                                       x, y, x2, y2);
+#endif
+                            soln[y2*w+x2] = NONTENT;
+                            done_something = TRUE;
+                        }
+                    }
+                }
+
+        if (done_something)
+            continue;
+
+        /*
+         * If localised deductions about the trees and tents
+         * themselves haven't helped us, it's time to resort to the
+         * numbers round the grid edge. For each row and column, we
+         * go through all possible combinations of locations for
+         * the unplaced tents, rule out any which have adjacent
+         * tents, and spot any square which is given the same state
+         * by all remaining combinations.
+         */
+        for (i = 0; i < w+h; i++) {
+            int start, step, len, start1, start2, n, k;
+
+            if (i < w) {
+                /*
+                 * This is the number for a column.
+                 */
+                start = i;
+                step = w;
+                len = h;
+                if (i > 0)
+                    start1 = start - 1;
+                else
+                    start1 = -1;
+                if (i+1 < w)
+                    start2 = start + 1;
+                else
+                    start2 = -1;
+            } else {
+                /*
+                 * This is the number for a row.
+                 */
+                start = (i-w)*w;
+                step = 1;
+                len = w;
+                if (i > w)
+                    start1 = start - w;
+                else
+                    start1 = -1;
+                if (i+1 < w+h)
+                    start2 = start + w;
+                else
+                    start2 = -1;
+            }
+
+            if (diff < DIFF_TRICKY) {
+                /*
+                 * In Easy mode, we don't look at the effect of one
+                 * row on the next (i.e. ruling out a square if all
+                 * possibilities for an adjacent row place a tent
+                 * next to it).
+                 */
+                start1 = start2 = -1;
+            }
+
+            k = numbers[i];
+
+            /*
+             * Count and store the locations of the free squares,
+             * and also count the number of tents already placed.
+             */
+            n = 0;
+            for (j = 0; j < len; j++) {
+                if (soln[start+j*step] == TENT)
+                    k--;               /* one fewer tent to place */
+                else if (soln[start+j*step] == BLANK)
+                    sc->locs[n++] = j;
+            }
+
+            if (n == 0)
+                continue;              /* nothing left to do here */
+
+            /*
+             * Now we know we're placing k tents in n squares. Set
+             * up the first possibility.
+             */
+            for (j = 0; j < n; j++)
+                sc->place[j] = (j < k ? TENT : NONTENT);
+
+            /*
+             * We're aiming to find squares in this row which are
+             * invariant over all valid possibilities. Thus, we
+             * maintain the current state of that invariance. We
+             * start everything off at MAGIC to indicate that it
+             * hasn't been set up yet.
+             */
+            mrow = sc->mrows;
+            trow = sc->trows;
+            trow1 = sc->trows + len;
+            trow2 = sc->trows + 2*len;
+            memset(mrow, MAGIC, 3*len);
+
+            /*
+             * And iterate over all possibilities.
+             */
+            while (1) {
+                int p, valid;
+
+                /*
+                 * See if this possibility is valid. The only way
+                 * it can fail to be valid is if it contains two
+                 * adjacent tents. (Other forms of invalidity, such
+                 * as containing a tent adjacent to one already
+                 * placed, will have been dealt with already by
+                 * other parts of the solver.)
+                 */
+                valid = TRUE;
+                for (j = 0; j+1 < n; j++)
+                    if (sc->place[j] == TENT &&
+                        sc->place[j+1] == TENT &&
+                        sc->locs[j+1] == sc->locs[j]+1) {
+                        valid = FALSE;
+                        break;
+                    }
+
+                if (valid) {
+                    /*
+                     * Merge this valid combination into mrow.
+                     */
+                    memset(trow, MAGIC, len);
+                    memset(trow+len, BLANK, 2*len);
+                    for (j = 0; j < n; j++) {
+                        trow[sc->locs[j]] = sc->place[j];
+                        if (sc->place[j] == TENT) {
+                            int jj;
+                            for (jj = sc->locs[j]-1; jj <= sc->locs[j]+1; jj++)
+                                if (jj >= 0 && jj < len)
+                                    trow1[jj] = trow2[jj] = NONTENT;
+                        }
+                    }
+
+                    for (j = 0; j < 3*len; j++) {
+                        if (trow[j] == MAGIC)
+                            continue;
+                        if (mrow[j] == MAGIC || mrow[j] == trow[j]) {
+                            /*
+                             * Either this is the first valid
+                             * placement we've found at all, or
+                             * this square's contents are
+                             * consistent with every previous valid
+                             * combination.
+                             */
+                            mrow[j] = trow[j];
+                        } else {
+                            /*
+                             * This square's contents fail to match
+                             * what they were in a different
+                             * combination, so we cannot deduce
+                             * anything about this square.
+                             */
+                            mrow[j] = BLANK;
+                        }
+                    }
+                }
+
+                /*
+                 * Find the next combination of k choices from n.
+                 * We do this by finding the rightmost tent which
+                 * can be moved one place right, doing so, and
+                 * shunting all tents to the right of that as far
+                 * left as they can go.
+                 */
+                p = 0;
+                for (j = n-1; j > 0; j--) {
+                    if (sc->place[j] == TENT)
+                        p++;
+                    if (sc->place[j] == NONTENT && sc->place[j-1] == TENT) {
+                        sc->place[j-1] = NONTENT;
+                        sc->place[j] = TENT;
+                        while (p--)
+                            sc->place[++j] = TENT;
+                        while (++j < n)
+                            sc->place[j] = NONTENT;
+                        break;
+                    }
+                }
+                if (j <= 0)
+                    break;             /* we've finished */
+            }
+
+            /*
+             * It's just possible that _no_ placement was valid, in
+             * which case we have an internally inconsistent
+             * puzzle.
+             */
+            if (mrow[sc->locs[0]] == MAGIC)
+                return 0;              /* inconsistent */
+
+            /*
+             * Now go through mrow and see if there's anything
+             * we've deduced which wasn't already mentioned in soln.
+             */
+            for (j = 0; j < len; j++) {
+                int whichrow;
+
+                for (whichrow = 0; whichrow < 3; whichrow++) {
+                    char *mthis = mrow + whichrow * len;
+                    int tstart = (whichrow == 0 ? start :
+                                  whichrow == 1 ? start1 : start2);
+                    if (tstart >= 0 &&
+                        mthis[j] != MAGIC && mthis[j] != BLANK &&
+                        soln[tstart+j*step] == BLANK) {
+                        int pos = tstart+j*step;
+
+#ifdef SOLVER_DIAGNOSTICS
+                        if (verbose)
+                            printf("%s %d forces %s at %d,%d\n",
+                                   step==1 ? "row" : "column",
+                                   step==1 ? start/w : start,
+                                   mthis[j] == TENT ? "tent" : "non-tent",
+                                   pos % w, pos / w);
+#endif
+                        soln[pos] = mthis[j];
+                        done_something = TRUE;
+                    }
+                }
+            }
+        }
+
+        if (done_something)
+            continue;
+
+        if (!done_something)
+            break;
+    }
+
+    /*
+     * The solver has nothing further it can do. Return 1 if both
+     * soln and sc->links are completely filled in, or 2 otherwise.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            if (soln[y*w+x] == BLANK)
+                return 2;
+            if (soln[y*w+x] != NONTENT && sc->links[y*w+x] == 0)
+                return 2;
+        }
+
+    return 1;
+}
+
+static char *new_game_desc(const game_params *params_in, random_state *rs,
+                           char **aux, int interactive)
+{
+    game_params params_copy = *params_in; /* structure copy */
+    game_params *params = &params_copy;
+    int w = params->w, h = params->h;
+    int ntrees = w * h / 5;
+    char *grid = snewn(w*h, char);
+    char *puzzle = snewn(w*h, char);
+    int *numbers = snewn(w+h, int);
+    char *soln = snewn(w*h, char);
+    int *temp = snewn(2*w*h, int);
+    int maxedges = ntrees*4 + w*h;
+    int *edges = snewn(2*maxedges, int);
+    int *capacity = snewn(maxedges, int);
+    int *flow = snewn(maxedges, int);
+    struct solver_scratch *sc = new_scratch(w, h);
+    char *ret, *p;
+    int i, j, nedges;
+
+    /*
+     * Since this puzzle has many global deductions and doesn't
+     * permit limited clue sets, generating grids for this puzzle
+     * is hard enough that I see no better option than to simply
+     * generate a solution and see if it's unique and has the
+     * required difficulty. This turns out to be computationally
+     * plausible as well.
+     * 
+     * We chose our tree count (hence also tent count) by dividing
+     * the total grid area by five above. Why five? Well, w*h/4 is
+     * the maximum number of tents you can _possibly_ fit into the
+     * grid without violating the separation criterion, and to
+     * achieve that you are constrained to a very small set of
+     * possible layouts (the obvious one with a tent at every
+     * (even,even) coordinate, and trivial variations thereon). So
+     * if we reduce the tent count a bit more, we enable more
+     * random-looking placement; 5 turns out to be a plausible
+     * figure which yields sensible puzzles. Increasing the tent
+     * count would give puzzles whose solutions were too regimented
+     * and could be solved by the use of that knowledge (and would
+     * also take longer to find a viable placement); decreasing it
+     * would make the grids emptier and more boring.
+     * 
+     * Actually generating a grid is a matter of first placing the
+     * tents, and then placing the trees by the use of maxflow
+     * (finding a distinct square adjacent to every tent). We do it
+     * this way round because otherwise satisfying the tent
+     * separation condition would become onerous: most randomly
+     * chosen tent layouts do not satisfy this condition, so we'd
+     * have gone to a lot of work before finding that a candidate
+     * layout was unusable. Instead, we place the tents first and
+     * ensure they meet the separation criterion _before_ doing
+     * lots of computation; this works much better.
+     * 
+     * The maxflow algorithm is not randomised, so employed naively
+     * it would give rise to grids with clear structure and
+     * directional bias. Hence, I assign the network nodes as seen
+     * by maxflow to be a _random_ permutation of the squares of
+     * the grid, so that any bias shown by maxflow towards
+     * low-numbered nodes is turned into a random bias.
+     * 
+     * This generation strategy can fail at many points, including
+     * as early as tent placement (if you get a bad random order in
+     * which to greedily try the grid squares, you won't even
+     * manage to find enough mutually non-adjacent squares to put
+     * the tents in). Then it can fail if maxflow doesn't manage to
+     * find a good enough matching (i.e. the tent placements don't
+     * admit any adequate tree placements); and finally it can fail
+     * if the solver finds that the problem has the wrong
+     * difficulty (including being actually non-unique). All of
+     * these, however, are insufficiently frequent to cause
+     * trouble.
+     */
+
+    if (params->diff > DIFF_EASY && params->w <= 4 && params->h <= 4)
+        params->diff = DIFF_EASY;      /* downgrade to prevent tight loop */
+
+    while (1) {
+        /*
+         * Arrange the grid squares into a random order.
+         */
+        for (i = 0; i < w*h; i++)
+            temp[i] = i;
+        shuffle(temp, w*h, sizeof(*temp), rs);
+
+        /*
+         * The first `ntrees' entries in temp which we can get
+         * without making two tents adjacent will be the tent
+         * locations.
+         */
+        memset(grid, BLANK, w*h);
+        j = ntrees;
+        for (i = 0; i < w*h && j > 0; i++) {
+            int x = temp[i] % w, y = temp[i] / w;
+            int dy, dx, ok = TRUE;
+
+            for (dy = -1; dy <= +1; dy++)
+                for (dx = -1; dx <= +1; dx++)
+                    if (x+dx >= 0 && x+dx < w &&
+                        y+dy >= 0 && y+dy < h &&
+                        grid[(y+dy)*w+(x+dx)] == TENT)
+                        ok = FALSE;
+
+            if (ok) {
+                grid[temp[i]] = TENT;
+                j--;
+            }
+        }
+        if (j > 0)
+            continue;                  /* couldn't place all the tents */
+
+        /*
+         * Now we build up the list of graph edges.
+         */
+        nedges = 0;
+        for (i = 0; i < w*h; i++) {
+            if (grid[temp[i]] == TENT) {
+                for (j = 0; j < w*h; j++) {
+                    if (grid[temp[j]] != TENT) {
+                        int xi = temp[i] % w, yi = temp[i] / w;
+                        int xj = temp[j] % w, yj = temp[j] / w;
+                        if (abs(xi-xj) + abs(yi-yj) == 1) {
+                            edges[nedges*2] = i;
+                            edges[nedges*2+1] = j;
+                            capacity[nedges] = 1;
+                            nedges++;
+                        }
+                    }
+                }
+            } else {
+                /*
+                 * Special node w*h is the sink node; any non-tent node
+                 * has an edge going to it.
+                 */
+                edges[nedges*2] = i;
+                edges[nedges*2+1] = w*h;
+                capacity[nedges] = 1;
+                nedges++;
+            }
+        }
+
+        /*
+         * Special node w*h+1 is the source node, with an edge going to
+         * every tent.
+         */
+        for (i = 0; i < w*h; i++) {
+            if (grid[temp[i]] == TENT) {
+                edges[nedges*2] = w*h+1;
+                edges[nedges*2+1] = i;
+                capacity[nedges] = 1;
+                nedges++;
+            }
+        }
+
+        assert(nedges <= maxedges);
+
+        /*
+         * Now we're ready to call the maxflow algorithm to place the
+         * trees.
+         */
+        j = maxflow(w*h+2, w*h+1, w*h, nedges, edges, capacity, flow, NULL);
+
+        if (j < ntrees)
+            continue;                  /* couldn't place all the trees */
+
+        /*
+         * We've placed the trees. Now we need to work out _where_
+         * we've placed them, which is a matter of reading back out
+         * from the `flow' array.
+         */
+        for (i = 0; i < nedges; i++) {
+            if (edges[2*i] < w*h && edges[2*i+1] < w*h && flow[i] > 0)
+                grid[temp[edges[2*i+1]]] = TREE;
+        }
+
+        /*
+         * I think it looks ugly if there isn't at least one of
+         * _something_ (tent or tree) in each row and each column
+         * of the grid. This doesn't give any information away
+         * since a completely empty row/column is instantly obvious
+         * from the clues (it has no trees and a zero).
+         */
+        for (i = 0; i < w; i++) {
+            for (j = 0; j < h; j++) {
+                if (grid[j*w+i] != BLANK)
+                    break;             /* found something in this column */
+            }
+            if (j == h)
+                break;                 /* found empty column */
+        }
+        if (i < w)
+            continue;                  /* a column was empty */
+
+        for (j = 0; j < h; j++) {
+            for (i = 0; i < w; i++) {
+                if (grid[j*w+i] != BLANK)
+                    break;             /* found something in this row */
+            }
+            if (i == w)
+                break;                 /* found empty row */
+        }
+        if (j < h)
+            continue;                  /* a row was empty */
+
+        /*
+         * Now set up the numbers round the edge.
+         */
+        for (i = 0; i < w; i++) {
+            int n = 0;
+            for (j = 0; j < h; j++)
+                if (grid[j*w+i] == TENT)
+                    n++;
+            numbers[i] = n;
+        }
+        for (i = 0; i < h; i++) {
+            int n = 0;
+            for (j = 0; j < w; j++)
+                if (grid[i*w+j] == TENT)
+                    n++;
+            numbers[w+i] = n;
+        }
+
+        /*
+         * And now actually solve the puzzle, to see whether it's
+         * unique and has the required difficulty.
+         */
+        for (i = 0; i < w*h; i++)
+            puzzle[i] = grid[i] == TREE ? TREE : BLANK;
+        i = tents_solve(w, h, puzzle, numbers, soln, sc, params->diff-1);
+        j = tents_solve(w, h, puzzle, numbers, soln, sc, params->diff);
+
+        /*
+         * We expect solving with difficulty params->diff to have
+         * succeeded (otherwise the problem is too hard), and
+         * solving with diff-1 to have failed (otherwise it's too
+         * easy).
+         */
+        if (i == 2 && j == 1)
+            break;
+    }
+
+    /*
+     * That's it. Encode as a game ID.
+     */
+    ret = snewn((w+h)*40 + ntrees + (w*h)/26 + 1, char);
+    p = ret;
+    j = 0;
+    for (i = 0; i <= w*h; i++) {
+        int c = (i < w*h ? grid[i] == TREE : 1);
+        if (c) {
+            *p++ = (j == 0 ? '_' : j-1 + 'a');
+            j = 0;
+        } else {
+            j++;
+            while (j > 25) {
+                *p++ = 'z';
+                j -= 25;
+            }
+        }
+    }
+    for (i = 0; i < w+h; i++)
+        p += sprintf(p, ",%d", numbers[i]);
+    *p++ = '\0';
+    ret = sresize(ret, p - ret, char);
+
+    /*
+     * And encode the solution as an aux_info.
+     */
+    *aux = snewn(ntrees * 40, char);
+    p = *aux;
+    *p++ = 'S';
+    for (i = 0; i < w*h; i++)
+        if (grid[i] == TENT)
+            p += sprintf(p, ";T%d,%d", i%w, i/w);
+    *p++ = '\0';
+    *aux = sresize(*aux, p - *aux, char);
+
+    free_scratch(sc);
+    sfree(flow);
+    sfree(capacity);
+    sfree(edges);
+    sfree(temp);
+    sfree(soln);
+    sfree(numbers);
+    sfree(puzzle);
+    sfree(grid);
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, h = params->h;
+    int area, i;
+
+    area = 0;
+    while (*desc && *desc != ',') {
+        if (*desc == '_')
+            area++;
+        else if (*desc >= 'a' && *desc < 'z')
+            area += *desc - 'a' + 2;
+        else if (*desc == 'z')
+            area += 25;
+        else if (*desc == '!' || *desc == '-')
+            /* do nothing */;
+        else
+            return "Invalid character in grid specification";
+
+        desc++;
+    }
+    if (area < w * h + 1)
+        return "Not enough data to fill grid";
+    else if (area > w * h + 1)
+        return "Too much data to fill grid";
+
+    for (i = 0; i < w+h; i++) {
+        if (!*desc)
+            return "Not enough numbers given after grid specification";
+        else if (*desc != ',')
+            return "Invalid character in number list";
+        desc++;
+        while (*desc && isdigit((unsigned char)*desc)) desc++;
+    }
+
+    if (*desc)
+        return "Unexpected additional data at end of game description";
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, h = params->h;
+    game_state *state = snew(game_state);
+    int i;
+
+    state->p = *params;                /* structure copy */
+    state->grid = snewn(w*h, char);
+    state->numbers = snew(struct numbers);
+    state->numbers->refcount = 1;
+    state->numbers->numbers = snewn(w+h, int);
+    state->completed = state->used_solve = FALSE;
+
+    i = 0;
+    memset(state->grid, BLANK, w*h);
+
+    while (*desc) {
+        int run, type;
+
+        type = TREE;
+
+        if (*desc == '_')
+            run = 0;
+        else if (*desc >= 'a' && *desc < 'z')
+            run = *desc - ('a'-1);
+        else if (*desc == 'z') {
+            run = 25;
+            type = BLANK;
+        } else {
+            assert(*desc == '!' || *desc == '-');
+            run = -1;
+            type = (*desc == '!' ? TENT : NONTENT);
+        }
+
+        desc++;
+
+        i += run;
+        assert(i >= 0 && i <= w*h);
+        if (i == w*h) {
+            assert(type == TREE);
+            break;
+        } else {
+            if (type != BLANK)
+                state->grid[i++] = type;
+        }
+    }
+
+    for (i = 0; i < w+h; i++) {
+        assert(*desc == ',');
+        desc++;
+        state->numbers->numbers[i] = atoi(desc);
+        while (*desc && isdigit((unsigned char)*desc)) desc++;
+    }
+
+    assert(!*desc);
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w = state->p.w, h = state->p.h;
+    game_state *ret = snew(game_state);
+
+    ret->p = state->p;                 /* structure copy */
+    ret->grid = snewn(w*h, char);
+    memcpy(ret->grid, state->grid, w*h);
+    ret->numbers = state->numbers;
+    state->numbers->refcount++;
+    ret->completed = state->completed;
+    ret->used_solve = state->used_solve;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (--state->numbers->refcount <= 0) {
+        sfree(state->numbers->numbers);
+        sfree(state->numbers);
+    }
+    sfree(state->grid);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int w = state->p.w, h = state->p.h;
+
+    if (aux) {
+        /*
+         * If we already have the solution, save ourselves some
+         * time.
+         */
+        return dupstr(aux);
+    } else {
+        struct solver_scratch *sc = new_scratch(w, h);
+        char *soln;
+        int ret;
+        char *move, *p;
+        int i;
+
+        soln = snewn(w*h, char);
+        ret = tents_solve(w, h, state->grid, state->numbers->numbers,
+                          soln, sc, DIFFCOUNT-1);
+        free_scratch(sc);
+        if (ret != 1) {
+            sfree(soln);
+            if (ret == 0)
+                *error = "This puzzle is not self-consistent";
+            else
+                *error = "Unable to find a unique solution for this puzzle";
+            return NULL;
+        }
+
+        /*
+         * Construct a move string which turns the current state
+         * into the solved state.
+         */
+        move = snewn(w*h * 40, char);
+        p = move;
+        *p++ = 'S';
+        for (i = 0; i < w*h; i++)
+            if (soln[i] == TENT)
+                p += sprintf(p, ";T%d,%d", i%w, i/w);
+        *p++ = '\0';
+        move = sresize(move, p - move, char);
+
+        sfree(soln);
+
+        return move;
+    }
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return params->w <= 1998 && params->h <= 1998; /* 999 tents */
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->p.w, h = state->p.h, r, c;
+    int cw = 4, ch = 2, gw = (w+1)*cw + 2, gh = (h+1)*ch + 1, len = gw * gh;
+    char *board = snewn(len + 1, char);
+
+    sprintf(board, "%*s\n", len - 2, "");
+    for (r = 0; r <= h; ++r) {
+        for (c = 0; c <= w; ++c) {
+            int cell = r*ch*gw + cw*c, center = cell + gw*ch/2 + cw/2;
+            int i = r*w + c, n = 1000;
+
+            if (r == h && c == w) /* NOP */;
+            else if (c == w) n = state->numbers->numbers[w + r];
+            else if (r == h) n = state->numbers->numbers[c];
+            else switch (state->grid[i]) {
+                case BLANK: board[center] = '.'; break;
+                case TREE: board[center] = 'T'; break;
+                case TENT: memcpy(board + center - 1, "//\\", 3); break;
+                case NONTENT: break;
+                default: memcpy(board + center - 1, "wtf", 3);
+                }
+
+            if (n < 100) {
+                board[center] = '0' + n % 10;
+                if (n >= 10) board[center - 1] = '0' + n / 10;
+            } else if (n < 1000) {
+                board[center + 1] = '0' + n % 10;
+                board[center] = '0' + n / 10 % 10;
+                board[center - 1] = '0' + n / 100;
+            }
+
+            board[cell] = '+';
+            memset(board + cell + 1, '-', cw - 1);
+            for (i = 1; i < ch; ++i) board[cell + i*gw] = '|';
+        }
+
+        for (c = 0; c < ch; ++c) {
+            board[(r*ch+c)*gw + gw - 2] =
+                c == 0 ? '+' : r < h ? '|' : ' ';
+            board[(r*ch+c)*gw + gw - 1] = '\n';
+        }
+    }
+
+    memset(board + len - gw, '-', gw - 2 - cw);
+    for (c = 0; c <= w; ++c) board[len - gw + cw*c] = '+';
+
+    return board;
+}
+
+struct game_ui {
+    int dsx, dsy;                      /* coords of drag start */
+    int dex, dey;                      /* coords of drag end */
+    int drag_button;                   /* -1 for none, or a button code */
+    int drag_ok;                       /* dragged off the window, to cancel */
+
+    int cx, cy, cdisp;                 /* cursor position, and ?display. */
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->dsx = ui->dsy = -1;
+    ui->dex = ui->dey = -1;
+    ui->drag_button = -1;
+    ui->drag_ok = FALSE;
+    ui->cx = ui->cy = ui->cdisp = 0;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int tilesize;
+    int started;
+    game_params p;
+    int *drawn, *numbersdrawn;
+    int cx, cy;         /* last-drawn cursor pos, or (-1,-1) if absent. */
+};
+
+#define PREFERRED_TILESIZE 32
+#define TILESIZE (ds->tilesize)
+#define TLBORDER (TILESIZE/2)
+#define BRBORDER (TILESIZE*3/2)
+#define COORD(x)  ( (x) * TILESIZE + TLBORDER )
+#define FROMCOORD(x)  ( ((x) - TLBORDER + TILESIZE) / TILESIZE - 1 )
+
+#define FLASH_TIME 0.30F
+
+static int drag_xform(const game_ui *ui, int x, int y, int v)
+{
+    int xmin, ymin, xmax, ymax;
+
+    xmin = min(ui->dsx, ui->dex);
+    xmax = max(ui->dsx, ui->dex);
+    ymin = min(ui->dsy, ui->dey);
+    ymax = max(ui->dsy, ui->dey);
+
+#ifndef STYLUS_BASED
+    /*
+     * Left-dragging has no effect, so we treat a left-drag as a
+     * single click on dsx,dsy.
+     */
+    if (ui->drag_button == LEFT_BUTTON) {
+        xmin = xmax = ui->dsx;
+        ymin = ymax = ui->dsy;
+    }
+#endif
+
+    if (x < xmin || x > xmax || y < ymin || y > ymax)
+        return v;                      /* no change outside drag area */
+
+    if (v == TREE)
+        return v;                      /* trees are inviolate always */
+
+    if (xmin == xmax && ymin == ymax) {
+        /*
+         * Results of a simple click. Left button sets blanks to
+         * tents; right button sets blanks to non-tents; either
+         * button clears a non-blank square.
+         * If stylus-based however, it loops instead.
+         */
+        if (ui->drag_button == LEFT_BUTTON)
+#ifdef STYLUS_BASED
+            v = (v == BLANK ? TENT : (v == TENT ? NONTENT : BLANK));
+        else
+            v = (v == BLANK ? NONTENT : (v == NONTENT ? TENT : BLANK));
+#else
+            v = (v == BLANK ? TENT : BLANK);
+        else
+            v = (v == BLANK ? NONTENT : BLANK);
+#endif
+    } else {
+        /*
+         * Results of a drag. Left-dragging has no effect.
+         * Right-dragging sets all blank squares to non-tents and
+         * has no effect on anything else.
+         */
+        if (ui->drag_button == RIGHT_BUTTON)
+            v = (v == BLANK ? NONTENT : v);
+        else
+#ifdef STYLUS_BASED
+            v = (v == BLANK ? NONTENT : v);
+#else
+            /* do nothing */;
+#endif
+    }
+
+    return v;
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->p.w, h = state->p.h;
+    char tmpbuf[80];
+    int shift = button & MOD_SHFT, control = button & MOD_CTRL;
+
+    button &= ~MOD_MASK;
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        x = FROMCOORD(x);
+        y = FROMCOORD(y);
+        if (x < 0 || y < 0 || x >= w || y >= h)
+            return NULL;
+
+        ui->drag_button = button;
+        ui->dsx = ui->dex = x;
+        ui->dsy = ui->dey = y;
+        ui->drag_ok = TRUE;
+        ui->cdisp = 0;
+        return "";             /* ui updated */
+    }
+
+    if ((IS_MOUSE_DRAG(button) || IS_MOUSE_RELEASE(button)) &&
+        ui->drag_button > 0) {
+        int xmin, ymin, xmax, ymax;
+        char *buf, *sep;
+        int buflen, bufsize, tmplen;
+
+        x = FROMCOORD(x);
+        y = FROMCOORD(y);
+        if (x < 0 || y < 0 || x >= w || y >= h) {
+            ui->drag_ok = FALSE;
+        } else {
+            /*
+             * Drags are limited to one row or column. Hence, we
+             * work out which coordinate is closer to the drag
+             * start, and move it _to_ the drag start.
+             */
+            if (abs(x - ui->dsx) < abs(y - ui->dsy))
+                x = ui->dsx;
+            else
+                y = ui->dsy;
+
+            ui->dex = x;
+            ui->dey = y;
+
+            ui->drag_ok = TRUE;
+        }
+
+        if (IS_MOUSE_DRAG(button))
+            return "";                 /* ui updated */
+
+        /*
+         * The drag has been released. Enact it.
+         */
+        if (!ui->drag_ok) {
+            ui->drag_button = -1;
+            return "";                 /* drag was just cancelled */
+        }
+
+        xmin = min(ui->dsx, ui->dex);
+        xmax = max(ui->dsx, ui->dex);
+        ymin = min(ui->dsy, ui->dey);
+        ymax = max(ui->dsy, ui->dey);
+        assert(0 <= xmin && xmin <= xmax && xmax < w);
+        assert(0 <= ymin && ymin <= ymax && ymax < h);
+
+        buflen = 0;
+        bufsize = 256;
+        buf = snewn(bufsize, char);
+        sep = "";
+        for (y = ymin; y <= ymax; y++)
+            for (x = xmin; x <= xmax; x++) {
+                int v = drag_xform(ui, x, y, state->grid[y*w+x]);
+                if (state->grid[y*w+x] != v) {
+                    tmplen = sprintf(tmpbuf, "%s%c%d,%d", sep,
+                                     (int)(v == BLANK ? 'B' :
+                                           v == TENT ? 'T' : 'N'),
+                                     x, y);
+                    sep = ";";
+
+                    if (buflen + tmplen >= bufsize) {
+                        bufsize = buflen + tmplen + 256;
+                        buf = sresize(buf, bufsize, char);
+                    }
+
+                    strcpy(buf+buflen, tmpbuf);
+                    buflen += tmplen;
+                }
+            }
+
+        ui->drag_button = -1;          /* drag is terminated */
+
+        if (buflen == 0) {
+            sfree(buf);
+            return "";                 /* ui updated (drag was terminated) */
+        } else {
+            buf[buflen] = '\0';
+            return buf;
+        }
+    }
+
+    if (IS_CURSOR_MOVE(button)) {
+        ui->cdisp = 1;
+        if (shift || control) {
+            int len = 0, i, indices[2];
+            indices[0] = ui->cx + w * ui->cy;
+            move_cursor(button, &ui->cx, &ui->cy, w, h, 0);
+            indices[1] = ui->cx + w * ui->cy;
+
+            /* NONTENTify all unique traversed eligible squares */
+            for (i = 0; i <= (indices[0] != indices[1]); ++i)
+                if (state->grid[indices[i]] == BLANK ||
+                    (control && state->grid[indices[i]] == TENT)) {
+                    len += sprintf(tmpbuf + len, "%sN%d,%d", len ? ";" : "",
+                                   indices[i] % w, indices[i] / w);
+                    assert(len < lenof(tmpbuf));
+                }
+
+            tmpbuf[len] = '\0';
+            if (len) return dupstr(tmpbuf);
+        } else
+            move_cursor(button, &ui->cx, &ui->cy, w, h, 0);
+        return "";
+    }
+    if (ui->cdisp) {
+        char rep = 0;
+        int v = state->grid[ui->cy*w+ui->cx];
+
+        if (v != TREE) {
+#ifdef SINGLE_CURSOR_SELECT
+            if (button == CURSOR_SELECT)
+                /* SELECT cycles T, N, B */
+                rep = v == BLANK ? 'T' : v == TENT ? 'N' : 'B';
+#else
+            if (button == CURSOR_SELECT)
+                rep = v == BLANK ? 'T' : 'B';
+            else if (button == CURSOR_SELECT2)
+                rep = v == BLANK ? 'N' : 'B';
+            else if (button == 'T' || button == 'N' || button == 'B')
+                rep = (char)button;
+#endif
+        }
+
+        if (rep) {
+            sprintf(tmpbuf, "%c%d,%d", (int)rep, ui->cx, ui->cy);
+            return dupstr(tmpbuf);
+        }
+    } else if (IS_CURSOR_SELECT(button)) {
+        ui->cdisp = 1;
+        return "";
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int w = state->p.w, h = state->p.h;
+    char c;
+    int x, y, m, n, i, j;
+    game_state *ret = dup_game(state);
+
+    while (*move) {
+        c = *move;
+        if (c == 'S') {
+            int i;
+            ret->used_solve = TRUE;
+            /*
+             * Set all non-tree squares to NONTENT. The rest of the
+             * solve move will fill the tents in over the top.
+             */
+            for (i = 0; i < w*h; i++)
+                if (ret->grid[i] != TREE)
+                    ret->grid[i] = NONTENT;
+            move++;
+        } else if (c == 'B' || c == 'T' || c == 'N') {
+            move++;
+            if (sscanf(move, "%d,%d%n", &x, &y, &n) != 2 ||
+                x < 0 || y < 0 || x >= w || y >= h) {
+                free_game(ret);
+                return NULL;
+            }
+            if (ret->grid[y*w+x] == TREE) {
+                free_game(ret);
+                return NULL;
+            }
+            ret->grid[y*w+x] = (c == 'B' ? BLANK : c == 'T' ? TENT : NONTENT);
+            move += n;
+        } else {
+            free_game(ret);
+            return NULL;
+        }
+        if (*move == ';')
+            move++;
+        else if (*move) {
+            free_game(ret);
+            return NULL;
+        }
+    }
+
+    /*
+     * Check for completion.
+     */
+    for (i = n = m = 0; i < w*h; i++) {
+        if (ret->grid[i] == TENT)
+            n++;
+        else if (ret->grid[i] == TREE)
+            m++;
+    }
+    if (n == m) {
+        int nedges, maxedges, *edges, *capacity, *flow;
+
+        /*
+         * We have the right number of tents, which is a
+         * precondition for the game being complete. Now check that
+         * the numbers add up.
+         */
+        for (i = 0; i < w; i++) {
+            n = 0;
+            for (j = 0; j < h; j++)
+                if (ret->grid[j*w+i] == TENT)
+                    n++;
+            if (ret->numbers->numbers[i] != n)
+                goto completion_check_done;
+        }
+        for (i = 0; i < h; i++) {
+            n = 0;
+            for (j = 0; j < w; j++)
+                if (ret->grid[i*w+j] == TENT)
+                    n++;
+            if (ret->numbers->numbers[w+i] != n)
+                goto completion_check_done;
+        }
+        /*
+         * Also, check that no two tents are adjacent.
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++) {
+                if (x+1 < w &&
+                    ret->grid[y*w+x] == TENT && ret->grid[y*w+x+1] == TENT)
+                    goto completion_check_done;
+                if (y+1 < h &&
+                    ret->grid[y*w+x] == TENT && ret->grid[(y+1)*w+x] == TENT)
+                    goto completion_check_done;
+                if (x+1 < w && y+1 < h) {
+                    if (ret->grid[y*w+x] == TENT &&
+                        ret->grid[(y+1)*w+(x+1)] == TENT)
+                        goto completion_check_done;
+                    if (ret->grid[(y+1)*w+x] == TENT &&
+                        ret->grid[y*w+(x+1)] == TENT)
+                        goto completion_check_done;
+                }
+            }
+
+        /*
+         * OK; we have the right number of tents, they match the
+         * numeric clues, and they satisfy the non-adjacency
+         * criterion. Finally, we need to verify that they can be
+         * placed in a one-to-one matching with the trees such that
+         * every tent is orthogonally adjacent to its tree.
+         * 
+         * This bit is where the hard work comes in: we have to do
+         * it by finding such a matching using maxflow.
+         * 
+         * So we construct a network with one special source node,
+         * one special sink node, one node per tent, and one node
+         * per tree.
+         */
+        maxedges = 6 * m;
+        edges = snewn(2 * maxedges, int);
+        capacity = snewn(maxedges, int);
+        flow = snewn(maxedges, int);
+        nedges = 0;
+        /*
+         * Node numbering:
+         * 
+         * 0..w*h   trees/tents
+         * w*h      source
+         * w*h+1    sink
+         */
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                if (ret->grid[y*w+x] == TREE) {
+                    int d;
+
+                    /*
+                     * Here we use the direction enum declared for
+                     * the solver. We make use of the fact that the
+                     * directions are declared in the order
+                     * U,L,R,D, meaning that we go through the four
+                     * neighbours of any square in numerically
+                     * increasing order.
+                     */
+                    for (d = 1; d < MAXDIR; d++) {
+                        int x2 = x + dx(d), y2 = y + dy(d);
+                        if (x2 >= 0 && x2 < w && y2 >= 0 && y2 < h &&
+                            ret->grid[y2*w+x2] == TENT) {
+                            assert(nedges < maxedges);
+                            edges[nedges*2] = y*w+x;
+                            edges[nedges*2+1] = y2*w+x2;
+                            capacity[nedges] = 1;
+                            nedges++;
+                        }
+                    }
+                } else if (ret->grid[y*w+x] == TENT) {
+                    assert(nedges < maxedges);
+                    edges[nedges*2] = y*w+x;
+                    edges[nedges*2+1] = w*h+1;   /* edge going to sink */
+                    capacity[nedges] = 1;
+                    nedges++;
+                }
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                if (ret->grid[y*w+x] == TREE) {
+                    assert(nedges < maxedges);
+                    edges[nedges*2] = w*h;   /* edge coming from source */
+                    edges[nedges*2+1] = y*w+x;
+                    capacity[nedges] = 1;
+                    nedges++;
+                }
+        n = maxflow(w*h+2, w*h, w*h+1, nedges, edges, capacity, flow, NULL);
+
+        sfree(flow);
+        sfree(capacity);
+        sfree(edges);
+
+        if (n != m)
+            goto completion_check_done;
+
+        /*
+         * We haven't managed to fault the grid on any count. Score!
+         */
+        ret->completed = TRUE;
+    }
+    completion_check_done:
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* fool the macros */
+    struct dummy { int tilesize; } dummy, *ds = &dummy;
+    dummy.tilesize = tilesize;
+
+    *x = TLBORDER + BRBORDER + TILESIZE * params->w;
+    *y = TLBORDER + BRBORDER + TILESIZE * params->h;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_GRID * 3 + 0] = 0.0F;
+    ret[COL_GRID * 3 + 1] = 0.0F;
+    ret[COL_GRID * 3 + 2] = 0.0F;
+
+    ret[COL_GRASS * 3 + 0] = 0.7F;
+    ret[COL_GRASS * 3 + 1] = 1.0F;
+    ret[COL_GRASS * 3 + 2] = 0.5F;
+
+    ret[COL_TREETRUNK * 3 + 0] = 0.6F;
+    ret[COL_TREETRUNK * 3 + 1] = 0.4F;
+    ret[COL_TREETRUNK * 3 + 2] = 0.0F;
+
+    ret[COL_TREELEAF * 3 + 0] = 0.0F;
+    ret[COL_TREELEAF * 3 + 1] = 0.7F;
+    ret[COL_TREELEAF * 3 + 2] = 0.0F;
+
+    ret[COL_TENT * 3 + 0] = 0.8F;
+    ret[COL_TENT * 3 + 1] = 0.7F;
+    ret[COL_TENT * 3 + 2] = 0.0F;
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_ERRTEXT * 3 + 0] = 1.0F;
+    ret[COL_ERRTEXT * 3 + 1] = 1.0F;
+    ret[COL_ERRTEXT * 3 + 2] = 1.0F;
+
+    ret[COL_ERRTRUNK * 3 + 0] = 0.6F;
+    ret[COL_ERRTRUNK * 3 + 1] = 0.0F;
+    ret[COL_ERRTRUNK * 3 + 2] = 0.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int w = state->p.w, h = state->p.h;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = 0;
+    ds->started = FALSE;
+    ds->p = state->p;                  /* structure copy */
+    ds->drawn = snewn(w*h, int);
+    for (i = 0; i < w*h; i++)
+        ds->drawn[i] = MAGIC;
+    ds->numbersdrawn = snewn(w+h, int);
+    for (i = 0; i < w+h; i++)
+        ds->numbersdrawn[i] = 2;
+    ds->cx = ds->cy = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->drawn);
+    sfree(ds->numbersdrawn);
+    sfree(ds);
+}
+
+enum {
+    ERR_ADJ_TOPLEFT = 4,
+    ERR_ADJ_TOP,
+    ERR_ADJ_TOPRIGHT,
+    ERR_ADJ_LEFT,
+    ERR_ADJ_RIGHT,
+    ERR_ADJ_BOTLEFT,
+    ERR_ADJ_BOT,
+    ERR_ADJ_BOTRIGHT,
+    ERR_OVERCOMMITTED
+};
+
+static int *find_errors(const game_state *state, char *grid)
+{
+    int w = state->p.w, h = state->p.h;
+    int *ret = snewn(w*h + w + h, int);
+    int *tmp = snewn(w*h*2, int), *dsf = tmp + w*h;
+    int x, y;
+
+    /*
+     * This function goes through a grid and works out where to
+     * highlight play errors in red. The aim is that it should
+     * produce at least one error highlight for any complete grid
+     * (or complete piece of grid) violating a puzzle constraint, so
+     * that a grid containing no BLANK squares is either a win or is
+     * marked up in some way that indicates why not.
+     *
+     * So it's easy enough to highlight errors in the numeric clues
+     * - just light up any row or column number which is not
+     * fulfilled - and it's just as easy to highlight adjacent
+     * tents. The difficult bit is highlighting failures in the
+     * tent/tree matching criterion.
+     *
+     * A natural approach would seem to be to apply the maxflow
+     * algorithm to find the tent/tree matching; if this fails, it
+     * must necessarily terminate with a min-cut which can be
+     * reinterpreted as some set of trees which have too few tents
+     * between them (or vice versa). However, it's bad for
+     * localising errors, because it's not easy to make the
+     * algorithm narrow down to the _smallest_ such set of trees: if
+     * trees A and B have only one tent between them, for instance,
+     * it might perfectly well highlight not only A and B but also
+     * trees C and D which are correctly matched on the far side of
+     * the grid, on the grounds that those four trees between them
+     * have only three tents.
+     *
+     * Also, that approach fares badly when you introduce the
+     * additional requirement that incomplete grids should have
+     * errors highlighted only when they can be proved to be errors
+     * - so that trees should not be marked as having too few tents
+     * if there are enough BLANK squares remaining around them that
+     * could be turned into the missing tents (to do so would be
+     * patronising, since the overwhelming likelihood is not that
+     * the player has forgotten to put a tree there but that they
+     * have merely not put one there _yet_). However, tents with too
+     * few trees can be marked immediately, since those are
+     * definitely player error.
+     *
+     * So I adopt an alternative approach, which is to consider the
+     * bipartite adjacency graph between trees and tents
+     * ('bipartite' in the sense that for these purposes I
+     * deliberately ignore two adjacent trees or two adjacent
+     * tents), divide that graph up into its connected components
+     * using a dsf, and look for components which contain different
+     * numbers of trees and tents. This allows me to highlight
+     * groups of tents with too few trees between them immediately,
+     * and then in order to find groups of trees with too few tents
+     * I redo the same process but counting BLANKs as potential
+     * tents (so that the only trees highlighted are those
+     * surrounded by enough NONTENTs to make it impossible to give
+     * them enough tents).
+     *
+     * However, this technique is incomplete: it is not a sufficient
+     * condition for the existence of a perfect matching that every
+     * connected component of the graph has the same number of tents
+     * and trees. An example of a graph which satisfies the latter
+     * condition but still has no perfect matching is
+     * 
+     *     A    B    C
+     *     |   /   ,/|
+     *     |  /  ,'/ |
+     *     | / ,' /  |
+     *     |/,'  /   |
+     *     1    2    3
+     *
+     * which can be realised in Tents as
+     * 
+     *       B
+     *     A 1 C 2
+     *         3
+     *
+     * The matching-error highlighter described above will not mark
+     * this construction as erroneous. However, something else will:
+     * the three tents in the above diagram (let us suppose A,B,C
+     * are the tents, though it doesn't matter which) contain two
+     * diagonally adjacent pairs. So there will be _an_ error
+     * highlighted for the above layout, even though not all types
+     * of error will be highlighted.
+     *
+     * And in fact we can prove that this will always be the case:
+     * that the shortcomings of the matching-error highlighter will
+     * always be made up for by the easy tent adjacency highlighter.
+     *
+     * Lemma: Let G be a bipartite graph between n trees and n
+     * tents, which is connected, and in which no tree has degree
+     * more than two (but a tent may). Then G has a perfect matching.
+     * 
+     * (Note: in the statement and proof of the Lemma I will
+     * consistently use 'tree' to indicate a type of graph vertex as
+     * opposed to a tent, and not to indicate a tree in the graph-
+     * theoretic sense.)
+     *
+     * Proof:
+     * 
+     * If we can find a tent of degree 1 joined to a tree of degree
+     * 2, then any perfect matching must pair that tent with that
+     * tree. Hence, we can remove both, leaving a smaller graph G'
+     * which still satisfies all the conditions of the Lemma, and
+     * which has a perfect matching iff G does.
+     *
+     * So, wlog, we may assume G contains no tent of degree 1 joined
+     * to a tree of degree 2; if it does, we can reduce it as above.
+     *
+     * If G has no tent of degree 1 at all, then every tent has
+     * degree at least two, so there are at least 2n edges in the
+     * graph. But every tree has degree at most two, so there are at
+     * most 2n edges. Hence there must be exactly 2n edges, so every
+     * tree and every tent must have degree exactly two, which means
+     * that the whole graph consists of a single loop (by
+     * connectedness), and therefore certainly has a perfect
+     * matching.
+     *
+     * Alternatively, if G does have a tent of degree 1 but it is
+     * not connected to a tree of degree 2, then the tree it is
+     * connected to must have degree 1 - and, by connectedness, that
+     * must mean that that tent and that tree between them form the
+     * entire graph. This trivial graph has a trivial perfect
+     * matching. []
+     *
+     * That proves the lemma. Hence, in any case where the matching-
+     * error highlighter fails to highlight an erroneous component
+     * (because it has the same number of tents as trees, but they
+     * cannot be matched up), the above lemma tells us that there
+     * must be a tree with degree more than 2, i.e. a tree
+     * orthogonally adjacent to at least three tents. But in that
+     * case, there must be some pair of those three tents which are
+     * diagonally adjacent to each other, so the tent-adjacency
+     * highlighter will necessarily show an error. So any filled
+     * layout in Tents which is not a correct solution to the puzzle
+     * must have _some_ error highlighted by the subroutine below.
+     *
+     * (Of course it would be nicer if we could highlight all
+     * errors: in the above example layout, we would like to
+     * highlight tents A,B as having too few trees between them, and
+     * trees 2,3 as having too few tents, in addition to marking the
+     * adjacency problems. But I can't immediately think of any way
+     * to find the smallest sets of such tents and trees without an
+     * O(2^N) loop over all subsets of a given component.)
+     */
+
+    /*
+     * ret[0] through to ret[w*h-1] give error markers for the grid
+     * squares. After that, ret[w*h] to ret[w*h+w-1] give error
+     * markers for the column numbers, and ret[w*h+w] to
+     * ret[w*h+w+h-1] for the row numbers.
+     */
+
+    /*
+     * Spot tent-adjacency violations.
+     */
+    for (x = 0; x < w*h; x++)
+        ret[x] = 0;
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            if (y+1 < h && x+1 < w &&
+                ((grid[y*w+x] == TENT &&
+                  grid[(y+1)*w+(x+1)] == TENT) ||
+                 (grid[(y+1)*w+x] == TENT &&
+                  grid[y*w+(x+1)] == TENT))) {
+                ret[y*w+x] |= 1 << ERR_ADJ_BOTRIGHT;
+                ret[(y+1)*w+x] |= 1 << ERR_ADJ_TOPRIGHT;
+                ret[y*w+(x+1)] |= 1 << ERR_ADJ_BOTLEFT;
+                ret[(y+1)*w+(x+1)] |= 1 << ERR_ADJ_TOPLEFT;
+            }
+            if (y+1 < h &&
+                grid[y*w+x] == TENT &&
+                grid[(y+1)*w+x] == TENT) {
+                ret[y*w+x] |= 1 << ERR_ADJ_BOT;
+                ret[(y+1)*w+x] |= 1 << ERR_ADJ_TOP;
+            }
+            if (x+1 < w &&
+                grid[y*w+x] == TENT &&
+                grid[y*w+(x+1)] == TENT) {
+                ret[y*w+x] |= 1 << ERR_ADJ_RIGHT;
+                ret[y*w+(x+1)] |= 1 << ERR_ADJ_LEFT;
+            }
+        }
+    }
+
+    /*
+     * Spot numeric clue violations.
+     */
+    for (x = 0; x < w; x++) {
+        int tents = 0, maybetents = 0;
+        for (y = 0; y < h; y++) {
+            if (grid[y*w+x] == TENT)
+                tents++;
+            else if (grid[y*w+x] == BLANK)
+                maybetents++;
+        }
+        ret[w*h+x] = (tents > state->numbers->numbers[x] ||
+                      tents + maybetents < state->numbers->numbers[x]);
+    }
+    for (y = 0; y < h; y++) {
+        int tents = 0, maybetents = 0;
+        for (x = 0; x < w; x++) {
+            if (grid[y*w+x] == TENT)
+                tents++;
+            else if (grid[y*w+x] == BLANK)
+                maybetents++;
+        }
+        ret[w*h+w+y] = (tents > state->numbers->numbers[w+y] ||
+                        tents + maybetents < state->numbers->numbers[w+y]);
+    }
+
+    /*
+     * Identify groups of tents with too few trees between them,
+     * which we do by constructing the connected components of the
+     * bipartite adjacency graph between tents and trees
+     * ('bipartite' in the sense that we deliberately ignore
+     * adjacency between tents or between trees), and highlighting
+     * all the tents in any component which has a smaller tree
+     * count.
+     */
+    dsf_init(dsf, w*h);
+    /* Construct the equivalence classes. */
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w-1; x++) {
+            if ((grid[y*w+x] == TREE && grid[y*w+x+1] == TENT) ||
+                (grid[y*w+x] == TENT && grid[y*w+x+1] == TREE))
+                dsf_merge(dsf, y*w+x, y*w+x+1);
+        }
+    }
+    for (y = 0; y < h-1; y++) {
+        for (x = 0; x < w; x++) {
+            if ((grid[y*w+x] == TREE && grid[(y+1)*w+x] == TENT) ||
+                (grid[y*w+x] == TENT && grid[(y+1)*w+x] == TREE))
+                dsf_merge(dsf, y*w+x, (y+1)*w+x);
+        }
+    }
+    /* Count up the tent/tree difference in each one. */
+    for (x = 0; x < w*h; x++)
+        tmp[x] = 0;
+    for (x = 0; x < w*h; x++) {
+        y = dsf_canonify(dsf, x);
+        if (grid[x] == TREE)
+            tmp[y]++;
+        else if (grid[x] == TENT)
+            tmp[y]--;
+    }
+    /* And highlight any tent belonging to an equivalence class with
+     * a score less than zero. */
+    for (x = 0; x < w*h; x++) {
+        y = dsf_canonify(dsf, x);
+        if (grid[x] == TENT && tmp[y] < 0)
+            ret[x] |= 1 << ERR_OVERCOMMITTED;
+    }
+
+    /*
+     * Identify groups of trees with too few tents between them.
+     * This is done similarly, except that we now count BLANK as
+     * equivalent to TENT, i.e. we only highlight such trees when
+     * the user hasn't even left _room_ to provide tents for them
+     * all. (Otherwise, we'd highlight all trees red right at the
+     * start of the game, before the user had done anything wrong!)
+     */
+#define TENT(x) ((x)==TENT || (x)==BLANK)
+    dsf_init(dsf, w*h);
+    /* Construct the equivalence classes. */
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w-1; x++) {
+            if ((grid[y*w+x] == TREE && TENT(grid[y*w+x+1])) ||
+                (TENT(grid[y*w+x]) && grid[y*w+x+1] == TREE))
+                dsf_merge(dsf, y*w+x, y*w+x+1);
+        }
+    }
+    for (y = 0; y < h-1; y++) {
+        for (x = 0; x < w; x++) {
+            if ((grid[y*w+x] == TREE && TENT(grid[(y+1)*w+x])) ||
+                (TENT(grid[y*w+x]) && grid[(y+1)*w+x] == TREE))
+                dsf_merge(dsf, y*w+x, (y+1)*w+x);
+        }
+    }
+    /* Count up the tent/tree difference in each one. */
+    for (x = 0; x < w*h; x++)
+        tmp[x] = 0;
+    for (x = 0; x < w*h; x++) {
+        y = dsf_canonify(dsf, x);
+        if (grid[x] == TREE)
+            tmp[y]++;
+        else if (TENT(grid[x]))
+            tmp[y]--;
+    }
+    /* And highlight any tree belonging to an equivalence class with
+     * a score more than zero. */
+    for (x = 0; x < w*h; x++) {
+        y = dsf_canonify(dsf, x);
+        if (grid[x] == TREE && tmp[y] > 0)
+            ret[x] |= 1 << ERR_OVERCOMMITTED;
+    }
+#undef TENT
+
+    sfree(tmp);
+    return ret;
+}
+
+static void draw_err_adj(drawing *dr, game_drawstate *ds, int x, int y)
+{
+    int coords[8];
+    int yext, xext;
+
+    /*
+     * Draw a diamond.
+     */
+    coords[0] = x - TILESIZE*2/5;
+    coords[1] = y;
+    coords[2] = x;
+    coords[3] = y - TILESIZE*2/5;
+    coords[4] = x + TILESIZE*2/5;
+    coords[5] = y;
+    coords[6] = x;
+    coords[7] = y + TILESIZE*2/5;
+    draw_polygon(dr, coords, 4, COL_ERROR, COL_GRID);
+
+    /*
+     * Draw an exclamation mark in the diamond. This turns out to
+     * look unpleasantly off-centre if done via draw_text, so I do
+     * it by hand on the basis that exclamation marks aren't that
+     * difficult to draw...
+     */
+    xext = TILESIZE/16;
+    yext = TILESIZE*2/5 - (xext*2+2);
+    draw_rect(dr, x-xext, y-yext, xext*2+1, yext*2+1 - (xext*3),
+              COL_ERRTEXT);
+    draw_rect(dr, x-xext, y+yext-xext*2+1, xext*2+1, xext*2, COL_ERRTEXT);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds,
+                      int x, int y, int v, int cur, int printing)
+{
+    int err;
+    int tx = COORD(x), ty = COORD(y);
+    int cx = tx + TILESIZE/2, cy = ty + TILESIZE/2;
+
+    err = v & ~15;
+    v &= 15;
+
+    clip(dr, tx, ty, TILESIZE, TILESIZE);
+
+    if (!printing) {
+        draw_rect(dr, tx, ty, TILESIZE, TILESIZE, COL_GRID);
+        draw_rect(dr, tx+1, ty+1, TILESIZE-1, TILESIZE-1,
+                  (v == BLANK ? COL_BACKGROUND : COL_GRASS));
+    }
+
+    if (v == TREE) {
+        int i;
+
+        (printing ? draw_rect_outline : draw_rect)
+        (dr, cx-TILESIZE/15, ty+TILESIZE*3/10,
+         2*(TILESIZE/15)+1, (TILESIZE*9/10 - TILESIZE*3/10),
+         (err & (1<<ERR_OVERCOMMITTED) ? COL_ERRTRUNK : COL_TREETRUNK));
+
+        for (i = 0; i < (printing ? 2 : 1); i++) {
+            int col = (i == 1 ? COL_BACKGROUND :
+                       (err & (1<<ERR_OVERCOMMITTED) ? COL_ERROR : 
+                        COL_TREELEAF));
+            int sub = i * (TILESIZE/32);
+            draw_circle(dr, cx, ty+TILESIZE*4/10, TILESIZE/4 - sub,
+                        col, col);
+            draw_circle(dr, cx+TILESIZE/5, ty+TILESIZE/4, TILESIZE/8 - sub,
+                        col, col);
+            draw_circle(dr, cx-TILESIZE/5, ty+TILESIZE/4, TILESIZE/8 - sub,
+                        col, col);
+            draw_circle(dr, cx+TILESIZE/4, ty+TILESIZE*6/13, TILESIZE/8 - sub,
+                        col, col);
+            draw_circle(dr, cx-TILESIZE/4, ty+TILESIZE*6/13, TILESIZE/8 - sub,
+                        col, col);
+        }
+    } else if (v == TENT) {
+        int coords[6];
+        int col;
+        coords[0] = cx - TILESIZE/3;
+        coords[1] = cy + TILESIZE/3;
+        coords[2] = cx + TILESIZE/3;
+        coords[3] = cy + TILESIZE/3;
+        coords[4] = cx;
+        coords[5] = cy - TILESIZE/3;
+        col = (err & (1<<ERR_OVERCOMMITTED) ? COL_ERROR : COL_TENT);
+        draw_polygon(dr, coords, 3, (printing ? -1 : col), col);
+    }
+
+    if (err & (1 << ERR_ADJ_TOPLEFT))
+        draw_err_adj(dr, ds, tx, ty);
+    if (err & (1 << ERR_ADJ_TOP))
+        draw_err_adj(dr, ds, tx+TILESIZE/2, ty);
+    if (err & (1 << ERR_ADJ_TOPRIGHT))
+        draw_err_adj(dr, ds, tx+TILESIZE, ty);
+    if (err & (1 << ERR_ADJ_LEFT))
+        draw_err_adj(dr, ds, tx, ty+TILESIZE/2);
+    if (err & (1 << ERR_ADJ_RIGHT))
+        draw_err_adj(dr, ds, tx+TILESIZE, ty+TILESIZE/2);
+    if (err & (1 << ERR_ADJ_BOTLEFT))
+        draw_err_adj(dr, ds, tx, ty+TILESIZE);
+    if (err & (1 << ERR_ADJ_BOT))
+        draw_err_adj(dr, ds, tx+TILESIZE/2, ty+TILESIZE);
+    if (err & (1 << ERR_ADJ_BOTRIGHT))
+        draw_err_adj(dr, ds, tx+TILESIZE, ty+TILESIZE);
+
+    if (cur) {
+      int coff = TILESIZE/8;
+      draw_rect_outline(dr, tx + coff, ty + coff,
+                        TILESIZE - coff*2 + 1, TILESIZE - coff*2 + 1,
+                        COL_GRID);
+    }
+
+    unclip(dr);
+    draw_update(dr, tx+1, ty+1, TILESIZE-1, TILESIZE-1);
+}
+
+/*
+ * Internal redraw function, used for printing as well as drawing.
+ */
+static void int_redraw(drawing *dr, game_drawstate *ds,
+                       const game_state *oldstate, const game_state *state,
+                       int dir, const game_ui *ui,
+                       float animtime, float flashtime, int printing)
+{
+    int w = state->p.w, h = state->p.h;
+    int x, y, flashing;
+    int cx = -1, cy = -1;
+    int cmoved = 0;
+    char *tmpgrid;
+    int *errors;
+
+    if (ui) {
+      if (ui->cdisp) { cx = ui->cx; cy = ui->cy; }
+      if (cx != ds->cx || cy != ds->cy) cmoved = 1;
+    }
+
+    if (printing || !ds->started) {
+        if (!printing) {
+            int ww, wh;
+            game_compute_size(&state->p, TILESIZE, &ww, &wh);
+            draw_rect(dr, 0, 0, ww, wh, COL_BACKGROUND);
+            draw_update(dr, 0, 0, ww, wh);
+            ds->started = TRUE;
+        }
+
+        if (printing)
+            print_line_width(dr, TILESIZE/64);
+
+        /*
+         * Draw the grid.
+         */
+        for (y = 0; y <= h; y++)
+            draw_line(dr, COORD(0), COORD(y), COORD(w), COORD(y), COL_GRID);
+        for (x = 0; x <= w; x++)
+            draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h), COL_GRID);
+    }
+
+    if (flashtime > 0)
+        flashing = (int)(flashtime * 3 / FLASH_TIME) != 1;
+    else
+        flashing = FALSE;
+
+    /*
+     * Find errors. For this we use _part_ of the information from a
+     * currently active drag: we transform dsx,dsy but not anything
+     * else. (This seems to strike a good compromise between having
+     * the error highlights respond instantly to single clicks, but
+     * not giving constant feedback during a right-drag.)
+     */
+    if (ui && ui->drag_button >= 0) {
+        tmpgrid = snewn(w*h, char);
+        memcpy(tmpgrid, state->grid, w*h);
+        tmpgrid[ui->dsy * w + ui->dsx] =
+            drag_xform(ui, ui->dsx, ui->dsy, tmpgrid[ui->dsy * w + ui->dsx]);
+        errors = find_errors(state, tmpgrid);
+        sfree(tmpgrid);
+    } else {
+        errors = find_errors(state, state->grid);
+    }
+
+    /*
+     * Draw the grid.
+     */
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            int v = state->grid[y*w+x];
+            int credraw = 0;
+
+            /*
+             * We deliberately do not take drag_ok into account
+             * here, because user feedback suggests that it's
+             * marginally nicer not to have the drag effects
+             * flickering on and off disconcertingly.
+             */
+            if (ui && ui->drag_button >= 0)
+                v = drag_xform(ui, x, y, v);
+
+            if (flashing && (v == TREE || v == TENT))
+                v = NONTENT;
+
+            if (cmoved) {
+              if ((x == cx && y == cy) ||
+                  (x == ds->cx && y == ds->cy)) credraw = 1;
+            }
+
+            v |= errors[y*w+x];
+
+            if (printing || ds->drawn[y*w+x] != v || credraw) {
+                draw_tile(dr, ds, x, y, v, (x == cx && y == cy), printing);
+                if (!printing)
+                    ds->drawn[y*w+x] = v;
+            }
+        }
+    }
+
+    /*
+     * Draw (or redraw, if their error-highlighted state has
+     * changed) the numbers.
+     */
+    for (x = 0; x < w; x++) {
+        if (printing || ds->numbersdrawn[x] != errors[w*h+x]) {
+            char buf[80];
+            draw_rect(dr, COORD(x), COORD(h)+1, TILESIZE, BRBORDER-1,
+                      COL_BACKGROUND);
+            sprintf(buf, "%d", state->numbers->numbers[x]);
+            draw_text(dr, COORD(x) + TILESIZE/2, COORD(h+1),
+                      FONT_VARIABLE, TILESIZE/2, ALIGN_HCENTRE|ALIGN_VNORMAL,
+                      (errors[w*h+x] ? COL_ERROR : COL_GRID), buf);
+            draw_update(dr, COORD(x), COORD(h)+1, TILESIZE, BRBORDER-1);
+            if (!printing)
+                ds->numbersdrawn[x] = errors[w*h+x];
+        }
+    }
+    for (y = 0; y < h; y++) {
+        if (printing || ds->numbersdrawn[w+y] != errors[w*h+w+y]) {
+            char buf[80];
+            draw_rect(dr, COORD(w)+1, COORD(y), BRBORDER-1, TILESIZE,
+                      COL_BACKGROUND);
+            sprintf(buf, "%d", state->numbers->numbers[w+y]);
+            draw_text(dr, COORD(w+1), COORD(y) + TILESIZE/2,
+                      FONT_VARIABLE, TILESIZE/2, ALIGN_HRIGHT|ALIGN_VCENTRE,
+                      (errors[w*h+w+y] ? COL_ERROR : COL_GRID), buf);
+            draw_update(dr, COORD(w)+1, COORD(y), BRBORDER-1, TILESIZE);
+            if (!printing)
+                ds->numbersdrawn[w+y] = errors[w*h+w+y];
+        }
+    }
+
+    if (cmoved) {
+        ds->cx = cx;
+        ds->cy = cy;
+    }
+
+    sfree(errors);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int_redraw(dr, ds, oldstate, state, dir, ui, animtime, flashtime, FALSE);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->used_solve && !newstate->used_solve)
+        return FLASH_TIME;
+
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * I'll use 6mm squares by default.
+     */
+    game_compute_size(params, 600, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int c;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    c = print_mono_colour(dr, 1); assert(c == COL_BACKGROUND);
+    c = print_mono_colour(dr, 0); assert(c == COL_GRID);
+    c = print_mono_colour(dr, 1); assert(c == COL_GRASS);
+    c = print_mono_colour(dr, 0); assert(c == COL_TREETRUNK);
+    c = print_mono_colour(dr, 0); assert(c == COL_TREELEAF);
+    c = print_mono_colour(dr, 0); assert(c == COL_TENT);
+
+    int_redraw(dr, ds, NULL, state, +1, NULL, 0.0F, 0.0F, TRUE);
+}
+
+#ifdef COMBINED
+#define thegame tents
+#endif
+
+const struct game thegame = {
+    "Tents", "games.tents", "tents",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON,                   /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+#include <stdarg.h>
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s, *s2;
+    char *id = NULL, *desc, *err;
+    int grade = FALSE;
+    int ret, diff, really_verbose = FALSE;
+    struct solver_scratch *sc;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            really_verbose = TRUE;
+        } else if (!strcmp(p, "-g")) {
+            grade = TRUE;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-g | -v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+    s2 = new_game(NULL, p, desc);
+
+    sc = new_scratch(p->w, p->h);
+
+    /*
+     * When solving an Easy puzzle, we don't want to bother the
+     * user with Hard-level deductions. For this reason, we grade
+     * the puzzle internally before doing anything else.
+     */
+    ret = -1;                          /* placate optimiser */
+    for (diff = 0; diff < DIFFCOUNT; diff++) {
+        ret = tents_solve(p->w, p->h, s->grid, s->numbers->numbers,
+                          s2->grid, sc, diff);
+        if (ret < 2)
+            break;
+    }
+
+    if (diff == DIFFCOUNT) {
+        if (grade)
+            printf("Difficulty rating: too hard to solve internally\n");
+        else
+            printf("Unable to find a unique solution\n");
+    } else {
+        if (grade) {
+            if (ret == 0)
+                printf("Difficulty rating: impossible (no solution exists)\n");
+            else if (ret == 1)
+                printf("Difficulty rating: %s\n", tents_diffnames[diff]);
+        } else {
+            verbose = really_verbose;
+            ret = tents_solve(p->w, p->h, s->grid, s->numbers->numbers,
+                              s2->grid, sc, diff);
+            if (ret == 0)
+                printf("Puzzle is inconsistent\n");
+            else
+                fputs(game_text_format(s2), stdout);
+        }
+    }
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/towers.R b/apps/plugins/puzzles/towers.R
new file mode 100644
index 0000000000..c060c697a7
--- /dev/null
+++ b/apps/plugins/puzzles/towers.R
@@ -0,0 +1,25 @@
+# -*- makefile -*-
+
+TOWERS_LATIN_EXTRA = tree234 maxflow
+TOWERS_EXTRA = latin TOWERS_LATIN_EXTRA
+
+towers    : [X] GTK COMMON towers TOWERS_EXTRA towers-icon|no-icon
+
+towers    : [G] WINDOWS COMMON towers TOWERS_EXTRA towers.res|noicon.res
+
+towerssolver : [U] towers[STANDALONE_SOLVER] latin[STANDALONE_SOLVER] TOWERS_LATIN_EXTRA STANDALONE
+towerssolver : [C] towers[STANDALONE_SOLVER] latin[STANDALONE_SOLVER] TOWERS_LATIN_EXTRA STANDALONE
+
+ALL += towers[COMBINED] TOWERS_EXTRA
+
+!begin am gtk
+GAMES += towers
+!end
+
+!begin >list.c
+    A(towers) \
+!end
+
+!begin >gamedesc.txt
+towers:towers.exe:Towers:Tower-placing Latin square puzzle:Complete the latin square of towers in accordance with the clues.
+!end
diff --git a/apps/plugins/puzzles/towers.c b/apps/plugins/puzzles/towers.c
new file mode 100644
index 0000000000..d8e087a4bc
--- /dev/null
+++ b/apps/plugins/puzzles/towers.c
@@ -0,0 +1,2104 @@
+/*
+ * towers.c: the puzzle also known as 'Skyscrapers'.
+ *
+ * Possible future work:
+ *
+ *  - Relax the upper bound on grid size at 9?
+ *     + I'd need TOCHAR and FROMCHAR macros a bit like group's, to
+ *       be used wherever this code has +'0' or -'0'
+ *     + the pencil marks in the drawstate would need a separate
+ *       word to live in
+ *     + the clues outside the grid would have to cope with being
+ *       multi-digit, meaning in particular that the text formatting
+ *       would become more unpleasant
+ *     + most importantly, though, the solver just isn't fast
+ *       enough. Even at size 9 it can't really do the solver_hard
+ *       factorial-time enumeration at a sensible rate. Easy puzzles
+ *       higher than that would be possible, but more latin-squarey
+ *       than skyscrapery, as it were.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "latin.h"
+
+/*
+ * Difficulty levels. I do some macro ickery here to ensure that my
+ * enum and the various forms of my name list always match up.
+ */
+#define DIFFLIST(A) \
+    A(EASY,Easy,solver_easy,e) \
+    A(HARD,Hard,solver_hard,h) \
+    A(EXTREME,Extreme,NULL,x) \
+    A(UNREASONABLE,Unreasonable,NULL,u)
+#define ENUM(upper,title,func,lower) DIFF_ ## upper,
+#define TITLE(upper,title,func,lower) #title,
+#define ENCODE(upper,title,func,lower) #lower
+#define CONFIG(upper,title,func,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const towers_diffnames[] = { DIFFLIST(TITLE) };
+static char const towers_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_USER,
+    COL_HIGHLIGHT,
+    COL_ERROR,
+    COL_PENCIL,
+    COL_DONE,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, diff;
+};
+
+struct clues {
+    int refcount;
+    int w;
+    /*
+     * An array of 4w integers, of which:
+     *  - the first w run across the top
+     *  - the next w across the bottom
+     *  - the third w down the left
+     *  - the last w down the right.
+     */
+    int *clues;
+
+    /*
+     * An array of w*w digits.
+     */
+    digit *immutable;
+};
+
+/*
+ * Macros to compute clue indices and coordinates.
+ */
+#define STARTSTEP(start, step, index, w) do { \
+    if (index < w) \
+        start = index, step = w; \
+    else if (index < 2*w) \
+        start = (w-1)*w+(index-w), step = -w; \
+    else if (index < 3*w) \
+        start = w*(index-2*w), step = 1; \
+    else \
+        start = w*(index-3*w)+(w-1), step = -1; \
+} while (0)
+#define CSTARTSTEP(start, step, index, w) \
+    STARTSTEP(start, step, (((index)+2*w)%(4*w)), w)
+#define CLUEPOS(x, y, index, w) do { \
+    if (index < w) \
+        x = index, y = -1; \
+    else if (index < 2*w) \
+        x = index-w, y = w; \
+    else if (index < 3*w) \
+        x = -1, y = index-2*w; \
+    else \
+        x = w, y = index-3*w; \
+} while (0)
+
+#ifdef STANDALONE_SOLVER
+static const char *const cluepos[] = {
+    "above column", "below column", "left of row", "right of row"
+};
+#endif
+
+struct game_state {
+    game_params par;
+    struct clues *clues;
+    unsigned char *clues_done;
+    digit *grid;
+    int *pencil;                       /* bitmaps using bits 1<<1..1<<n */
+    int completed, cheated;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = 5;
+    ret->diff = DIFF_EASY;
+
+    return ret;
+}
+
+const static struct game_params towers_presets[] = {
+    {  4, DIFF_EASY         },
+    {  5, DIFF_EASY         },
+    {  5, DIFF_HARD         },
+    {  6, DIFF_EASY         },
+    {  6, DIFF_HARD         },
+    {  6, DIFF_EXTREME      },
+    {  6, DIFF_UNREASONABLE },
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(towers_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = towers_presets[i]; /* structure copy */
+
+    sprintf(buf, "%dx%d %s", ret->w, ret->w, towers_diffnames[ret->diff]);
+
+    *name = dupstr(buf);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    char const *p = string;
+
+    params->w = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+
+    if (*p == 'd') {
+        int i;
+        p++;
+        params->diff = DIFFCOUNT+1; /* ...which is invalid */
+        if (*p) {
+            for (i = 0; i < DIFFCOUNT; i++) {
+                if (*p == towers_diffchars[i])
+                    params->diff = i;
+            }
+            p++;
+        }
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char ret[80];
+
+    sprintf(ret, "%d", params->w);
+    if (full)
+        sprintf(ret + strlen(ret), "d%c", towers_diffchars[params->diff]);
+
+    return dupstr(ret);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(3, config_item);
+
+    ret[0].name = "Grid size";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Difficulty";
+    ret[1].type = C_CHOICES;
+    ret[1].sval = DIFFCONFIG;
+    ret[1].ival = params->diff;
+
+    ret[2].name = NULL;
+    ret[2].type = C_END;
+    ret[2].sval = NULL;
+    ret[2].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->diff = cfg[1].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 3 || params->w > 9)
+        return "Grid size must be between 3 and 9";
+    if (params->diff >= DIFFCOUNT)
+        return "Unknown difficulty rating";
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver.
+ */
+
+struct solver_ctx {
+    int w, diff;
+    int started;
+    int *clues;
+    long *iscratch;
+    int *dscratch;
+};
+
+static int solver_easy(struct latin_solver *solver, void *vctx)
+{
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    int w = ctx->w;
+    int c, i, j, n, m, furthest;
+    int start, step, cstart, cstep, clue, pos, cpos;
+    int ret = 0;
+#ifdef STANDALONE_SOLVER
+    char prefix[256];
+#endif
+
+    if (!ctx->started) {
+        ctx->started = TRUE;
+        /*
+         * One-off loop to help get started: when a pair of facing
+         * clues sum to w+1, it must mean that the row consists of
+         * two increasing sequences back to back, so we can
+         * immediately place the highest digit by knowing the
+         * lengths of those two sequences.
+         */
+        for (c = 0; c < 3*w; c = (c == w-1 ? 2*w : c+1)) {
+            int c2 = c + w;
+
+            if (ctx->clues[c] && ctx->clues[c2] &&
+                ctx->clues[c] + ctx->clues[c2] == w+1) {
+                STARTSTEP(start, step, c, w);
+                CSTARTSTEP(cstart, cstep, c, w);
+                pos = start + (ctx->clues[c]-1)*step;
+                cpos = cstart + (ctx->clues[c]-1)*cstep;
+                if (solver->cube[cpos*w+w-1]) {
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*sfacing clues on %s %d are maximal:\n",
+                               solver_recurse_depth*4, "",
+                               c>=2*w ? "row" : "column", c % w + 1);
+                        printf("%*s  placing %d at (%d,%d)\n",
+                               solver_recurse_depth*4, "",
+                               w, pos%w+1, pos/w+1);
+                    }
+#endif
+                    latin_solver_place(solver, pos%w, pos/w, w);
+                    ret = 1;
+                } else {
+                    ret = -1;
+                }
+            }
+        }
+
+        if (ret)
+            return ret;
+    }
+
+    /*
+     * Go over every clue doing reasonably simple heuristic
+     * deductions.
+     */
+    for (c = 0; c < 4*w; c++) {
+        clue = ctx->clues[c];
+        if (!clue)
+            continue;
+        STARTSTEP(start, step, c, w);
+        CSTARTSTEP(cstart, cstep, c, w);
+
+        /* Find the location of each number in the row. */
+        for (i = 0; i < w; i++)
+            ctx->dscratch[i] = w;
+        for (i = 0; i < w; i++)
+            if (solver->grid[start+i*step])
+                ctx->dscratch[solver->grid[start+i*step]-1] = i;
+
+        n = m = 0;
+        furthest = w;
+        for (i = w; i >= 1; i--) {
+            if (ctx->dscratch[i-1] == w) {
+                break;
+            } else if (ctx->dscratch[i-1] < furthest) {
+                furthest = ctx->dscratch[i-1];
+                m = i;
+                n++;
+            }
+        }
+        if (clue == n+1 && furthest > 1) {
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working)
+                sprintf(prefix, "%*sclue %s %d is nearly filled:\n",
+                        solver_recurse_depth*4, "",
+                        cluepos[c/w], c%w+1);
+            else
+                prefix[0] = '\0';              /* placate optimiser */
+#endif
+            /*
+             * We can already see an increasing sequence of the very
+             * highest numbers, of length one less than that
+             * specified in the clue. All of those numbers _must_ be
+             * part of the clue sequence, so the number right next
+             * to the clue must be the final one - i.e. it must be
+             * bigger than any of the numbers between it and m. This
+             * allows us to rule out small numbers in that square.
+             *
+             * (This is a generalisation of the obvious deduction
+             * that when you see a clue saying 1, it must be right
+             * next to the largest possible number; and similarly,
+             * when you see a clue saying 2 opposite that, it must
+             * be right next to the second-largest.)
+             */
+            j = furthest-1;  /* number of small numbers we can rule out */
+            for (i = 1; i <= w && j > 0; i++) {
+                if (ctx->dscratch[i-1] < w && ctx->dscratch[i-1] >= furthest)
+                    continue;          /* skip this number, it's elsewhere */
+                j--;
+                if (solver->cube[cstart*w+i-1]) {
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%s%*s  ruling out %d at (%d,%d)\n",
+                               prefix, solver_recurse_depth*4, "",
+                               i, start%w+1, start/w+1);
+                        prefix[0] = '\0';
+                    }
+#endif
+                    solver->cube[cstart*w+i-1] = 0;
+                    ret = 1;
+                }
+            }
+        }
+
+        if (ret)
+            return ret;
+
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working)
+                sprintf(prefix, "%*slower bounds for clue %s %d:\n",
+                        solver_recurse_depth*4, "",
+                        cluepos[c/w], c%w+1);
+            else
+                prefix[0] = '\0';              /* placate optimiser */
+#endif
+
+        i = 0;
+        for (n = w; n > 0; n--) {
+            /*
+             * The largest number cannot occur in the first (clue-1)
+             * squares of the row, or else there wouldn't be space
+             * for a sufficiently long increasing sequence which it
+             * terminated. The second-largest number (not counting
+             * any that are known to be on the far side of a larger
+             * number and hence excluded from this sequence) cannot
+             * occur in the first (clue-2) squares, similarly, and
+             * so on.
+             */
+
+            if (ctx->dscratch[n-1] < w) {
+                for (m = n+1; m < w; m++)
+                    if (ctx->dscratch[m] < ctx->dscratch[n-1])
+                        break;
+                if (m < w)
+                    continue;          /* this number doesn't count */
+            }
+
+            for (j = 0; j < clue - i - 1; j++)
+                if (solver->cube[(cstart + j*cstep)*w+n-1]) {
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        int pos = start+j*step;
+                        printf("%s%*s  ruling out %d at (%d,%d)\n",
+                               prefix, solver_recurse_depth*4, "",
+                               n, pos%w+1, pos/w+1);
+                        prefix[0] = '\0';
+                    }
+#endif
+                    solver->cube[(cstart + j*cstep)*w+n-1] = 0;
+                    ret = 1;
+                }
+            i++;
+        }
+    }
+
+    if (ret)
+        return ret;
+
+    return 0;
+}
+
+static int solver_hard(struct latin_solver *solver, void *vctx)
+{
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    int w = ctx->w;
+    int c, i, j, n, best, clue, start, step, ret;
+    long bitmap;
+#ifdef STANDALONE_SOLVER
+    char prefix[256];
+#endif
+
+    /*
+     * Go over every clue analysing all possibilities.
+     */
+    for (c = 0; c < 4*w; c++) {
+        clue = ctx->clues[c];
+        if (!clue)
+            continue;
+        CSTARTSTEP(start, step, c, w);
+
+        for (i = 0; i < w; i++)
+            ctx->iscratch[i] = 0;
+
+        /*
+         * Instead of a tedious physical recursion, I iterate in the
+         * scratch array through all possibilities. At any given
+         * moment, i indexes the element of the box that will next
+         * be incremented.
+         */
+        i = 0;
+        ctx->dscratch[i] = 0;
+        best = n = 0;
+        bitmap = 0;
+
+        while (1) {
+            if (i < w) {
+                /*
+                 * Find the next valid value for cell i.
+                 */
+                int limit = (n == clue ? best : w);
+                int pos = start + step * i;
+                for (j = ctx->dscratch[i] + 1; j <= limit; j++) {
+                    if (bitmap & (1L << j))
+                        continue;      /* used this one already */
+                    if (!solver->cube[pos*w+j-1])
+                        continue;      /* ruled out already */
+
+                    /* Found one. */
+                    break;
+                }
+
+                if (j > limit) {
+                    /* No valid values left; drop back. */
+                    i--;
+                    if (i < 0)
+                        break;         /* overall iteration is finished */
+                    bitmap &= ~(1L << ctx->dscratch[i]);
+                    if (ctx->dscratch[i] == best) {
+                        n--;
+                        best = 0;
+                        for (j = 0; j < i; j++)
+                            if (best < ctx->dscratch[j])
+                                best = ctx->dscratch[j];
+                    }
+                } else {
+                    /* Got a valid value; store it and move on. */
+                    bitmap |= 1L << j;
+                    ctx->dscratch[i++] = j;
+                    if (j > best) {
+                        best = j;
+                        n++;
+                    }
+                    ctx->dscratch[i] = 0;
+                }
+            } else {
+                if (n == clue) {
+                    for (j = 0; j < w; j++)
+                        ctx->iscratch[j] |= 1L << ctx->dscratch[j];
+                }
+                i--;
+                bitmap &= ~(1L << ctx->dscratch[i]);
+                if (ctx->dscratch[i] == best) {
+                    n--;
+                    best = 0;
+                    for (j = 0; j < i; j++)
+                        if (best < ctx->dscratch[j])
+                            best = ctx->dscratch[j];
+                }
+            }
+        }
+
+#ifdef STANDALONE_SOLVER
+        if (solver_show_working)
+            sprintf(prefix, "%*sexhaustive analysis of clue %s %d:\n",
+                    solver_recurse_depth*4, "",
+                    cluepos[c/w], c%w+1);
+        else
+            prefix[0] = '\0';          /* placate optimiser */
+#endif
+
+        ret = 0;
+
+        for (i = 0; i < w; i++) {
+            int pos = start + step * i;
+            for (j = 1; j <= w; j++) {
+                if (solver->cube[pos*w+j-1] &&
+                    !(ctx->iscratch[i] & (1L << j))) {
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%s%*s  ruling out %d at (%d,%d)\n",
+                               prefix, solver_recurse_depth*4, "",
+                               j, pos/w+1, pos%w+1);
+                        prefix[0] = '\0';
+                    }
+#endif
+                    solver->cube[pos*w+j-1] = 0;
+                    ret = 1;
+                }
+            }
+
+            /*
+             * Once we find one clue we can do something with in
+             * this way, revert to trying easier deductions, so as
+             * not to generate solver diagnostics that make the
+             * problem look harder than it is.
+             */
+            if (ret)
+                return ret;
+        }
+    }
+
+    return 0;
+}
+
+#define SOLVER(upper,title,func,lower) func,
+static usersolver_t const towers_solvers[] = { DIFFLIST(SOLVER) };
+
+static int solver(int w, int *clues, digit *soln, int maxdiff)
+{
+    int ret;
+    struct solver_ctx ctx;
+
+    ctx.w = w;
+    ctx.diff = maxdiff;
+    ctx.clues = clues;
+    ctx.started = FALSE;
+    ctx.iscratch = snewn(w, long);
+    ctx.dscratch = snewn(w+1, int);
+
+    ret = latin_solver(soln, w, maxdiff,
+                       DIFF_EASY, DIFF_HARD, DIFF_EXTREME,
+                       DIFF_EXTREME, DIFF_UNREASONABLE,
+                       towers_solvers, &ctx, NULL, NULL);
+
+    sfree(ctx.iscratch);
+    sfree(ctx.dscratch);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Grid generation.
+ */
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, a = w*w;
+    digit *grid, *soln, *soln2;
+    int *clues, *order;
+    int i, ret;
+    int diff = params->diff;
+    char *desc, *p;
+
+    /*
+     * Difficulty exceptions: some combinations of size and
+     * difficulty cannot be satisfied, because all puzzles of at
+     * most that difficulty are actually even easier.
+     *
+     * Remember to re-test this whenever a change is made to the
+     * solver logic!
+     *
+     * I tested it using the following shell command:
+
+for d in e h x u; do
+  for i in {3..9}; do
+    echo -n "./towers --generate 1 ${i}d${d}: "
+    perl -e 'alarm 30; exec @ARGV' ./towers --generate 1 ${i}d${d} >/dev/null \
+      && echo ok
+  done
+done
+
+     * Of course, it's better to do that after taking the exceptions
+     * _out_, so as to detect exceptions that should be removed as
+     * well as those which should be added.
+     */
+    if (diff > DIFF_HARD && w <= 3)
+        diff = DIFF_HARD;
+
+    grid = NULL;
+    clues = snewn(4*w, int);
+    soln = snewn(a, digit);
+    soln2 = snewn(a, digit);
+    order = snewn(max(4*w,a), int);
+
+    while (1) {
+        /*
+         * Construct a latin square to be the solution.
+         */
+        sfree(grid);
+        grid = latin_generate(w, rs);
+
+        /*
+         * Fill in the clues.
+         */
+        for (i = 0; i < 4*w; i++) {
+            int start, step, j, k, best;
+            STARTSTEP(start, step, i, w);
+            k = best = 0;
+            for (j = 0; j < w; j++) {
+                if (grid[start+j*step] > best) {
+                    best = grid[start+j*step];
+                    k++;
+                }
+            }
+            clues[i] = k;
+        }
+
+        /*
+         * Remove the grid numbers and then the clues, one by one,
+         * for as long as the game remains soluble at the given
+         * difficulty.
+         */
+        memcpy(soln, grid, a);
+
+        if (diff == DIFF_EASY && w <= 5) {
+            /*
+             * Special case: for Easy-mode grids that are small
+             * enough, it's nice to be able to find completely empty
+             * grids.
+             */
+            memset(soln2, 0, a);
+            ret = solver(w, clues, soln2, diff);
+            if (ret > diff)
+                continue;
+        }
+
+        for (i = 0; i < a; i++)
+            order[i] = i;
+        shuffle(order, a, sizeof(*order), rs);
+        for (i = 0; i < a; i++) {
+            int j = order[i];
+
+            memcpy(soln2, grid, a);
+            soln2[j] = 0;
+            ret = solver(w, clues, soln2, diff);
+            if (ret <= diff)
+                grid[j] = 0;
+        }
+
+        if (diff > DIFF_EASY) {        /* leave all clues on Easy mode */
+            for (i = 0; i < 4*w; i++)
+                order[i] = i;
+            shuffle(order, 4*w, sizeof(*order), rs);
+            for (i = 0; i < 4*w; i++) {
+                int j = order[i];
+                int clue = clues[j];
+
+                memcpy(soln2, grid, a);
+                clues[j] = 0;
+                ret = solver(w, clues, soln2, diff);
+                if (ret > diff)
+                    clues[j] = clue;
+            }
+        }
+
+        /*
+         * See if the game can be solved at the specified difficulty
+         * level, but not at the one below.
+         */
+        memcpy(soln2, grid, a);
+        ret = solver(w, clues, soln2, diff);
+        if (ret != diff)
+            continue;                  /* go round again */
+
+        /*
+         * We've got a usable puzzle!
+         */
+        break;
+    }
+
+    /*
+     * Encode the puzzle description.
+     */
+    desc = snewn(40*a, char);
+    p = desc;
+    for (i = 0; i < 4*w; i++) {
+        if (i)
+            *p++ = '/';
+        if (clues[i])
+            p += sprintf(p, "%d", clues[i]);
+    }
+    for (i = 0; i < a; i++)
+        if (grid[i])
+            break;
+    if (i < a) {
+        int run = 0;
+
+        *p++ = ',';
+
+        for (i = 0; i <= a; i++) {
+            int n = (i < a ? grid[i] : -1);
+
+            if (!n)
+                run++;
+            else {
+                if (run) {
+                    while (run > 0) {
+                        int thisrun = min(run, 26);
+                        *p++ = thisrun - 1 + 'a';
+                        run -= thisrun;
+                    }
+                } else {
+                    /*
+                     * If there's a number in the very top left or
+                     * bottom right, there's no point putting an
+                     * unnecessary _ before or after it.
+                     */
+                    if (i > 0 && n > 0)
+                        *p++ = '_';
+                }
+                if (n > 0)
+                    p += sprintf(p, "%d", n);
+                run = 0;
+            }
+        }
+    }
+    *p++ = '\0';
+    desc = sresize(desc, p - desc, char);
+
+    /*
+     * Encode the solution.
+     */
+    *aux = snewn(a+2, char);
+    (*aux)[0] = 'S';
+    for (i = 0; i < a; i++)
+        (*aux)[i+1] = '0' + soln[i];
+    (*aux)[a+1] = '\0';
+
+    sfree(grid);
+    sfree(clues);
+    sfree(soln);
+    sfree(soln2);
+    sfree(order);
+
+    return desc;
+}
+
+/* ----------------------------------------------------------------------
+ * Gameplay.
+ */
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, a = w*w;
+    const char *p = desc;
+    int i, clue;
+
+    /*
+     * Verify that the right number of clues are given, and that
+     * they're in range.
+     */
+    for (i = 0; i < 4*w; i++) {
+        if (!*p)
+            return "Too few clues for grid size";
+
+        if (i > 0) {
+            if (*p != '/')
+                return "Expected commas between clues";
+            p++;
+        }
+
+        if (isdigit((unsigned char)*p)) {
+            clue = atoi(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+
+            if (clue <= 0 || clue > w)
+                return "Clue number out of range";
+        }
+    }
+    if (*p == '/')
+        return "Too many clues for grid size";
+
+    if (*p == ',') {
+        /*
+         * Verify that the right amount of grid data is given, and
+         * that any grid elements provided are in range.
+         */
+        int squares = 0;
+
+        p++;
+        while (*p) {
+            int c = *p++;
+            if (c >= 'a' && c <= 'z') {
+                squares += c - 'a' + 1;
+            } else if (c == '_') {
+                /* do nothing */;
+            } else if (c > '0' && c <= '9') {
+                int val = atoi(p-1);
+                if (val < 1 || val > w)
+                    return "Out-of-range number in grid description";
+                squares++;
+                while (*p && isdigit((unsigned char)*p)) p++;
+            } else
+                return "Invalid character in game description";
+        }
+
+        if (squares < a)
+            return "Not enough data to fill grid";
+
+        if (squares > a)
+            return "Too much data to fit in grid";
+    }
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, a = w*w;
+    game_state *state = snew(game_state);
+    const char *p = desc;
+    int i;
+
+    state->par = *params;              /* structure copy */
+    state->clues = snew(struct clues);
+    state->clues->refcount = 1;
+    state->clues->w = w;
+    state->clues->clues = snewn(4*w, int);
+    state->clues->immutable = snewn(a, digit);
+    state->grid = snewn(a, digit);
+    state->clues_done = snewn(4*w, unsigned char);
+    state->pencil = snewn(a, int);
+
+    for (i = 0; i < a; i++) {
+        state->grid[i] = 0;
+        state->pencil[i] = 0;
+    }
+
+    memset(state->clues->immutable, 0, a);
+    memset(state->clues_done, 0, 4*w*sizeof(unsigned char));
+
+    for (i = 0; i < 4*w; i++) {
+        if (i > 0) {
+            assert(*p == '/');
+            p++;
+        }
+        if (*p && isdigit((unsigned char)*p)) {
+            state->clues->clues[i] = atoi(p);
+            while (*p && isdigit((unsigned char)*p)) p++;
+        } else
+            state->clues->clues[i] = 0;
+    }
+
+    if (*p == ',') {
+        int pos = 0;
+        p++;
+        while (*p) {
+            int c = *p++;
+            if (c >= 'a' && c <= 'z') {
+                pos += c - 'a' + 1;
+            } else if (c == '_') {
+                /* do nothing */;
+            } else if (c > '0' && c <= '9') {
+                int val = atoi(p-1);
+                assert(val >= 1 && val <= w);
+                assert(pos < a);
+                state->grid[pos] = state->clues->immutable[pos] = val;
+                pos++;
+                while (*p && isdigit((unsigned char)*p)) p++;
+            } else
+                assert(!"Corrupt game description");
+        }
+        assert(pos == a);
+    }
+    assert(!*p);
+
+    state->completed = state->cheated = FALSE;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w = state->par.w, a = w*w;
+    game_state *ret = snew(game_state);
+
+    ret->par = state->par;             /* structure copy */
+
+    ret->clues = state->clues;
+    ret->clues->refcount++;
+
+    ret->grid = snewn(a, digit);
+    ret->pencil = snewn(a, int);
+    ret->clues_done = snewn(4*w, unsigned char);
+    memcpy(ret->grid, state->grid, a*sizeof(digit));
+    memcpy(ret->pencil, state->pencil, a*sizeof(int));
+    memcpy(ret->clues_done, state->clues_done, 4*w*sizeof(unsigned char));
+
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    sfree(state->pencil);
+    sfree(state->clues_done);
+    if (--state->clues->refcount <= 0) {
+        sfree(state->clues->immutable);
+        sfree(state->clues->clues);
+        sfree(state->clues);
+    }
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int w = state->par.w, a = w*w;
+    int i, ret;
+    digit *soln;
+    char *out;
+
+    if (aux)
+        return dupstr(aux);
+
+    soln = snewn(a, digit);
+    memcpy(soln, state->clues->immutable, a);
+
+    ret = solver(w, state->clues->clues, soln, DIFFCOUNT-1);
+
+    if (ret == diff_impossible) {
+        *error = "No solution exists for this puzzle";
+        out = NULL;
+    } else if (ret == diff_ambiguous) {
+        *error = "Multiple solutions exist for this puzzle";
+        out = NULL;
+    } else {
+        out = snewn(a+2, char);
+        out[0] = 'S';
+        for (i = 0; i < a; i++)
+            out[i+1] = '0' + soln[i];
+        out[a+1] = '\0';
+    }
+
+    sfree(soln);
+    return out;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->par.w /* , a = w*w */;
+    char *ret;
+    char *p;
+    int x, y;
+    int total;
+
+    /*
+     * We have:
+     *  - a top clue row, consisting of three spaces, then w clue
+     *    digits with spaces between (total 2*w+3 chars including
+     *    newline)
+     *  - a blank line (one newline)
+     *  - w main rows, consisting of a left clue digit, two spaces,
+     *    w grid digits with spaces between, two spaces and a right
+     *    clue digit (total 2*w+6 chars each including newline)
+     *  - a blank line (one newline)
+     *  - a bottom clue row (same as top clue row)
+     *  - terminating NUL.
+     *
+     * Total size is therefore 2*(2*w+3) + 2 + w*(2*w+6) + 1
+     * = 2w^2+10w+9.
+     */
+    total = 2*w*w + 10*w + 9;
+    ret = snewn(total, char);
+    p = ret;
+
+    /* Top clue row. */
+    *p++ = ' '; *p++ = ' ';
+    for (x = 0; x < w; x++) {
+        *p++ = ' ';
+        *p++ = (state->clues->clues[x] ? '0' + state->clues->clues[x] : ' ');
+    }
+    *p++ = '\n';
+
+    /* Blank line. */
+    *p++ = '\n';
+
+    /* Main grid. */
+    for (y = 0; y < w; y++) {
+        *p++ = (state->clues->clues[y+2*w] ? '0' + state->clues->clues[y+2*w] :
+                ' ');
+        *p++ = ' ';
+        for (x = 0; x < w; x++) {
+            *p++ = ' ';
+            *p++ = (state->grid[y*w+x] ? '0' + state->grid[y*w+x] : ' ');
+        }
+        *p++ = ' '; *p++ = ' ';
+        *p++ = (state->clues->clues[y+3*w] ? '0' + state->clues->clues[y+3*w] :
+                ' ');
+        *p++ = '\n';
+    }
+
+    /* Blank line. */
+    *p++ = '\n';
+
+    /* Bottom clue row. */
+    *p++ = ' '; *p++ = ' ';
+    for (x = 0; x < w; x++) {
+        *p++ = ' ';
+        *p++ = (state->clues->clues[x+w] ? '0' + state->clues->clues[x+w] :
+                ' ');
+    }
+    *p++ = '\n';
+
+    *p++ = '\0';
+    assert(p == ret + total);
+
+    return ret;
+}
+
+struct game_ui {
+    /*
+     * These are the coordinates of the currently highlighted
+     * square on the grid, if hshow = 1.
+     */
+    int hx, hy;
+    /*
+     * This indicates whether the current highlight is a
+     * pencil-mark one or a real one.
+     */
+    int hpencil;
+    /*
+     * This indicates whether or not we're showing the highlight
+     * (used to be hx = hy = -1); important so that when we're
+     * using the cursor keys it doesn't keep coming back at a
+     * fixed position. When hshow = 1, pressing a valid number
+     * or letter key or Space will enter that number or letter in the grid.
+     */
+    int hshow;
+    /*
+     * This indicates whether we're using the highlight as a cursor;
+     * it means that it doesn't vanish on a keypress, and that it is
+     * allowed on immutable squares.
+     */
+    int hcursor;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->hx = ui->hy = 0;
+    ui->hpencil = ui->hshow = ui->hcursor = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    int w = newstate->par.w;
+    /*
+     * We prevent pencil-mode highlighting of a filled square, unless
+     * we're using the cursor keys. So if the user has just filled in
+     * a square which we had a pencil-mode highlight in (by Undo, or
+     * by Redo, or by Solve), then we cancel the highlight.
+     */
+    if (ui->hshow && ui->hpencil && !ui->hcursor &&
+        newstate->grid[ui->hy * w + ui->hx] != 0) {
+        ui->hshow = 0;
+    }
+}
+
+#define PREFERRED_TILESIZE 48
+#define TILESIZE (ds->tilesize)
+#define BORDER (TILESIZE * 9 / 8)
+#define COORD(x) ((x)*TILESIZE + BORDER)
+#define FROMCOORD(x) (((x)+(TILESIZE-BORDER)) / TILESIZE - 1)
+
+/* These always return positive values, though y offsets are actually -ve */
+#define X_3D_DISP(height, w) ((height) * TILESIZE / (8 * (w)))
+#define Y_3D_DISP(height, w) ((height) * TILESIZE / (4 * (w)))
+
+#define FLASH_TIME 0.4F
+
+#define DF_PENCIL_SHIFT 16
+#define DF_CLUE_DONE 0x10000
+#define DF_ERROR 0x8000
+#define DF_HIGHLIGHT 0x4000
+#define DF_HIGHLIGHT_PENCIL 0x2000
+#define DF_IMMUTABLE 0x1000
+#define DF_PLAYAREA 0x0800
+#define DF_DIGIT_MASK 0x00FF
+
+struct game_drawstate {
+    int tilesize;
+    int three_d;                /* default 3D graphics are user-disableable */
+    int started;
+    long *tiles;                       /* (w+2)*(w+2) temp space */
+    long *drawn;                       /* (w+2)*(w+2)*4: current drawn data */
+    int *errtmp;
+};
+
+static int check_errors(const game_state *state, int *errors)
+{
+    int w = state->par.w /*, a = w*w */;
+    int W = w+2, A = W*W;              /* the errors array is (w+2) square */
+    int *clues = state->clues->clues;
+    digit *grid = state->grid;
+    int i, x, y, errs = FALSE;
+    int tmp[32];
+
+    assert(w < lenof(tmp));
+
+    if (errors)
+        for (i = 0; i < A; i++)
+            errors[i] = 0;
+
+    for (y = 0; y < w; y++) {
+        unsigned long mask = 0, errmask = 0;
+        for (x = 0; x < w; x++) {
+            unsigned long bit = 1UL << grid[y*w+x];
+            errmask |= (mask & bit);
+            mask |= bit;
+        }
+
+        if (mask != (1L << (w+1)) - (1L << 1)) {
+            errs = TRUE;
+            errmask &= ~1UL;
+            if (errors) {
+                for (x = 0; x < w; x++)
+                    if (errmask & (1UL << grid[y*w+x]))
+                        errors[(y+1)*W+(x+1)] = TRUE;
+            }
+        }
+    }
+
+    for (x = 0; x < w; x++) {
+        unsigned long mask = 0, errmask = 0;
+        for (y = 0; y < w; y++) {
+            unsigned long bit = 1UL << grid[y*w+x];
+            errmask |= (mask & bit);
+            mask |= bit;
+        }
+
+        if (mask != (1 << (w+1)) - (1 << 1)) {
+            errs = TRUE;
+            errmask &= ~1UL;
+            if (errors) {
+                for (y = 0; y < w; y++)
+                    if (errmask & (1UL << grid[y*w+x]))
+                        errors[(y+1)*W+(x+1)] = TRUE;
+            }
+        }
+    }
+
+    for (i = 0; i < 4*w; i++) {
+        int start, step, j, n, best;
+        STARTSTEP(start, step, i, w);
+
+        if (!clues[i])
+            continue;
+
+        best = n = 0;
+        for (j = 0; j < w; j++) {
+            int number = grid[start+j*step];
+            if (!number)
+                break;                 /* can't tell what happens next */
+            if (number > best) {
+                best = number;
+                n++;
+            }
+        }
+
+        if (n > clues[i] || (best == w && n < clues[i]) ||
+            (best < w && n == clues[i])) {
+            if (errors) {
+                int x, y;
+                CLUEPOS(x, y, i, w);
+                errors[(y+1)*W+(x+1)] = TRUE;
+            }
+            errs = TRUE;
+        }
+    }
+
+    return errs;
+}
+
+static int clue_index(const game_state *state, int x, int y)
+{
+    int w = state->par.w;
+
+    if (x == -1 || x == w)
+        return w * (x == -1 ? 2 : 3) + y;
+    else if (y == -1 || y == w)
+        return (y == -1 ? 0 : w) + x;
+
+    return -1;
+}
+
+static int is_clue(const game_state *state, int x, int y)
+{
+    int w = state->par.w;
+
+    if (((x == -1 || x == w) && y >= 0 && y < w) ||
+        ((y == -1 || y == w) && x >= 0 && x < w))
+    {
+        if (state->clues->clues[clue_index(state, x, y)] & DF_DIGIT_MASK)
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->par.w;
+    int shift_or_control = button & (MOD_SHFT | MOD_CTRL);
+    int tx, ty;
+    char buf[80];
+
+    button &= ~MOD_MASK;
+
+    tx = FROMCOORD(x);
+    ty = FROMCOORD(y);
+
+    if (ds->three_d) {
+        /*
+         * In 3D mode, just locating the mouse click in the natural
+         * square grid may not be sufficient to tell which tower the
+         * user clicked on. Investigate the _tops_ of the nearby
+         * towers to see if a click on one grid square was actually
+         * a click on a tower protruding into that region from
+         * another.
+         */
+        int dx, dy;
+        for (dy = 0; dy <= 1; dy++)
+            for (dx = 0; dx >= -1; dx--) {
+                int cx = tx + dx, cy = ty + dy;
+                if (cx >= 0 && cx < w && cy >= 0 && cy < w) {
+                    int height = state->grid[cy*w+cx];
+                    int bx = COORD(cx), by = COORD(cy);
+                    int ox = bx + X_3D_DISP(height, w);
+                    int oy = by - Y_3D_DISP(height, w);
+                    if (/* on top face? */
+                        (x - ox >= 0 && x - ox < TILESIZE &&
+                         y - oy >= 0 && y - oy < TILESIZE) ||
+                        /* in triangle between top-left corners? */
+                        (ox > bx && x >= bx && x <= ox && y <= by &&
+                         (by-y) * (ox-bx) <= (by-oy) * (x-bx)) ||
+                        /* in triangle between bottom-right corners? */
+                        (ox > bx && x >= bx+TILESIZE && x <= ox+TILESIZE &&
+                         y >= oy+TILESIZE &&
+                         (by-y+TILESIZE)*(ox-bx) >= (by-oy)*(x-bx-TILESIZE))) {
+                        tx = cx;
+                        ty = cy;
+                    }
+                }
+            }
+    }
+
+    if (tx >= 0 && tx < w && ty >= 0 && ty < w) {
+        if (button == LEFT_BUTTON) {
+            if (tx == ui->hx && ty == ui->hy &&
+                ui->hshow && ui->hpencil == 0) {
+                ui->hshow = 0;
+            } else {
+                ui->hx = tx;
+                ui->hy = ty;
+                ui->hshow = !state->clues->immutable[ty*w+tx];
+                ui->hpencil = 0;
+            }
+            ui->hcursor = 0;
+            return "";                 /* UI activity occurred */
+        }
+        if (button == RIGHT_BUTTON) {
+            /*
+             * Pencil-mode highlighting for non filled squares.
+             */
+            if (state->grid[ty*w+tx] == 0) {
+                if (tx == ui->hx && ty == ui->hy &&
+                    ui->hshow && ui->hpencil) {
+                    ui->hshow = 0;
+                } else {
+                    ui->hpencil = 1;
+                    ui->hx = tx;
+                    ui->hy = ty;
+                    ui->hshow = 1;
+                }
+            } else {
+                ui->hshow = 0;
+            }
+            ui->hcursor = 0;
+            return "";                 /* UI activity occurred */
+        }
+    } else if (button == LEFT_BUTTON) {
+        if (is_clue(state, tx, ty)) {
+            sprintf(buf, "%c%d,%d", 'D', tx, ty);
+            return dupstr(buf);
+        }
+    }
+    if (IS_CURSOR_MOVE(button)) {
+        if (shift_or_control) {
+            int x = ui->hx, y = ui->hy;
+            switch (button) {
+            case CURSOR_LEFT:   x = -1; break;
+            case CURSOR_RIGHT:  x =  w; break;
+            case CURSOR_UP:     y = -1; break;
+            case CURSOR_DOWN:   y =  w; break;
+            }
+            if (is_clue(state, x, y)) {
+                sprintf(buf, "%c%d,%d", 'D', x, y);
+                return dupstr(buf);
+            }
+            return NULL;
+        }
+        move_cursor(button, &ui->hx, &ui->hy, w, w, 0);
+        ui->hshow = ui->hcursor = 1;
+        return "";
+    }
+    if (ui->hshow &&
+        (button == CURSOR_SELECT)) {
+        ui->hpencil = 1 - ui->hpencil;
+        ui->hcursor = 1;
+        return "";
+    }
+
+    if (ui->hshow &&
+        ((button >= '0' && button <= '9' && button - '0' <= w) ||
+         button == CURSOR_SELECT2 || button == '\b')) {
+        int n = button - '0';
+        if (button == CURSOR_SELECT2 || button == '\b')
+            n = 0;
+
+        /*
+         * Can't make pencil marks in a filled square. This can only
+         * become highlighted if we're using cursor keys.
+         */
+        if (ui->hpencil && state->grid[ui->hy*w+ui->hx])
+            return NULL;
+
+        /*
+         * Can't do anything to an immutable square.
+         */
+        if (state->clues->immutable[ui->hy*w+ui->hx])
+            return NULL;
+
+        sprintf(buf, "%c%d,%d,%d",
+                (char)(ui->hpencil && n > 0 ? 'P' : 'R'), ui->hx, ui->hy, n);
+
+        if (!ui->hcursor) ui->hshow = 0;
+
+        return dupstr(buf);
+    }
+
+    if (button == 'M' || button == 'm')
+        return dupstr("M");
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    int w = from->par.w, a = w*w;
+    game_state *ret = dup_game(from);
+    int x, y, i, n;
+
+    if (move[0] == 'S') {
+        ret->completed = ret->cheated = TRUE;
+
+        for (i = 0; i < a; i++) {
+            if (move[i+1] < '1' || move[i+1] > '0'+w)
+                goto badmove;
+            ret->grid[i] = move[i+1] - '0';
+            ret->pencil[i] = 0;
+        }
+
+        if (move[a+1] != '\0')
+            goto badmove;
+
+        return ret;
+    } else if ((move[0] == 'P' || move[0] == 'R') &&
+        sscanf(move+1, "%d,%d,%d", &x, &y, &n) == 3 &&
+        x >= 0 && x < w && y >= 0 && y < w && n >= 0 && n <= w) {
+        if (from->clues->immutable[y*w+x])
+            goto badmove;
+
+        if (move[0] == 'P' && n > 0) {
+            ret->pencil[y*w+x] ^= 1L << n;
+        } else {
+            ret->grid[y*w+x] = n;
+            ret->pencil[y*w+x] = 0;
+
+            if (!ret->completed && !check_errors(ret, NULL))
+                ret->completed = TRUE;
+        }
+        return ret;
+    } else if (move[0] == 'M') {
+        /*
+         * Fill in absolutely all pencil marks everywhere. (I
+         * wouldn't use this for actual play, but it's a handy
+         * starting point when following through a set of
+         * diagnostics output by the standalone solver.)
+         */
+        for (i = 0; i < a; i++) {
+            if (!ret->grid[i])
+                ret->pencil[i] = (1L << (w+1)) - (1L << 1);
+        }
+        return ret;
+    } else if (move[0] == 'D' && sscanf(move+1, "%d,%d", &x, &y) == 2 &&
+               is_clue(from, x, y)) {
+        int index = clue_index(from, x, y);
+        ret->clues_done[index] = !ret->clues_done[index];
+        return ret;
+    }
+
+  badmove:
+    /* couldn't parse move string */
+    free_game(ret);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define SIZE(w) ((w) * TILESIZE + 2*BORDER)
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = *y = SIZE(params->w);
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_GRID * 3 + 0] = 0.0F;
+    ret[COL_GRID * 3 + 1] = 0.0F;
+    ret[COL_GRID * 3 + 2] = 0.0F;
+
+    ret[COL_USER * 3 + 0] = 0.0F;
+    ret[COL_USER * 3 + 1] = 0.6F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_USER * 3 + 2] = 0.0F;
+
+    ret[COL_HIGHLIGHT * 3 + 0] = 0.78F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_HIGHLIGHT * 3 + 1] = 0.78F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_HIGHLIGHT * 3 + 2] = 0.78F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_PENCIL * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_PENCIL * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_PENCIL * 3 + 2] = ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_DONE * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] / 1.5F;
+    ret[COL_DONE * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] / 1.5F;
+    ret[COL_DONE * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] / 1.5F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int w = state->par.w /*, a = w*w */;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = 0;
+    ds->three_d = !getenv("TOWERS_2D");
+    ds->started = FALSE;
+    ds->tiles = snewn((w+2)*(w+2), long);
+    ds->drawn = snewn((w+2)*(w+2)*4, long);
+    for (i = 0; i < (w+2)*(w+2)*4; i++)
+        ds->drawn[i] = -1;
+    ds->errtmp = snewn((w+2)*(w+2), int);
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->errtmp);
+    sfree(ds->tiles);
+    sfree(ds->drawn);
+    sfree(ds);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds, struct clues *clues,
+                      int x, int y, long tile)
+{
+    int w = clues->w /* , a = w*w */;
+    int tx, ty, bg;
+    char str[64];
+
+    tx = COORD(x);
+    ty = COORD(y);
+
+    bg = (tile & DF_HIGHLIGHT) ? COL_HIGHLIGHT : COL_BACKGROUND;
+
+    /* draw tower */
+    if (ds->three_d && (tile & DF_PLAYAREA) && (tile & DF_DIGIT_MASK)) {
+        int coords[8];
+        int xoff = X_3D_DISP(tile & DF_DIGIT_MASK, w);
+        int yoff = Y_3D_DISP(tile & DF_DIGIT_MASK, w);
+
+        /* left face of tower */
+        coords[0] = tx;
+        coords[1] = ty - 1;
+        coords[2] = tx;
+        coords[3] = ty + TILESIZE - 1;
+        coords[4] = coords[2] + xoff;
+        coords[5] = coords[3] - yoff;
+        coords[6] = coords[0] + xoff;
+        coords[7] = coords[1] - yoff;
+        draw_polygon(dr, coords, 4, bg, COL_GRID);
+
+        /* bottom face of tower */
+        coords[0] = tx + TILESIZE;
+        coords[1] = ty + TILESIZE - 1;
+        coords[2] = tx;
+        coords[3] = ty + TILESIZE - 1;
+        coords[4] = coords[2] + xoff;
+        coords[5] = coords[3] - yoff;
+        coords[6] = coords[0] + xoff;
+        coords[7] = coords[1] - yoff;
+        draw_polygon(dr, coords, 4, bg, COL_GRID);
+
+        /* now offset all subsequent drawing to the top of the tower */
+        tx += xoff;
+        ty -= yoff;
+    }
+
+    /* erase background */
+    draw_rect(dr, tx, ty, TILESIZE, TILESIZE, bg);
+
+    /* pencil-mode highlight */
+    if (tile & DF_HIGHLIGHT_PENCIL) {
+        int coords[6];
+        coords[0] = tx;
+        coords[1] = ty;
+        coords[2] = tx+TILESIZE/2;
+        coords[3] = ty;
+        coords[4] = tx;
+        coords[5] = ty+TILESIZE/2;
+        draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+    }
+
+    /* draw box outline */
+    if (tile & DF_PLAYAREA) {
+        int coords[8];
+        coords[0] = tx;
+        coords[1] = ty - 1;
+        coords[2] = tx + TILESIZE;
+        coords[3] = ty - 1;
+        coords[4] = tx + TILESIZE;
+        coords[5] = ty + TILESIZE - 1;
+        coords[6] = tx;
+        coords[7] = ty + TILESIZE - 1;
+        draw_polygon(dr, coords, 4, -1, COL_GRID);
+    }
+
+    /* new number needs drawing? */
+    if (tile & DF_DIGIT_MASK) {
+        int color;
+
+        str[1] = '\0';
+        str[0] = (tile & DF_DIGIT_MASK) + '0';
+
+        if (tile & DF_ERROR)
+            color = COL_ERROR;
+        else if (tile & DF_CLUE_DONE)
+            color = COL_DONE;
+        else if (x < 0 || y < 0 || x >= w || y >= w)
+            color = COL_GRID;
+        else if (tile & DF_IMMUTABLE)
+            color = COL_GRID;
+        else
+            color = COL_USER;
+
+        draw_text(dr, tx + TILESIZE/2, ty + TILESIZE/2, FONT_VARIABLE,
+                  (tile & DF_PLAYAREA ? TILESIZE/2 : TILESIZE*2/5),
+                  ALIGN_VCENTRE | ALIGN_HCENTRE, color, str);
+    } else {
+        int i, j, npencil;
+        int pl, pr, pt, pb;
+        float bestsize;
+        int pw, ph, minph, pbest, fontsize;
+
+        /* Count the pencil marks required. */
+        for (i = 1, npencil = 0; i <= w; i++)
+            if (tile & (1L << (i + DF_PENCIL_SHIFT)))
+                npencil++;
+        if (npencil) {
+
+            minph = 2;
+
+            /*
+             * Determine the bounding rectangle within which we're going
+             * to put the pencil marks.
+             */
+            /* Start with the whole square, minus space for impinging towers */
+            pl = tx + (ds->three_d ? X_3D_DISP(w,w) : 0);
+            pr = tx + TILESIZE;
+            pt = ty;
+            pb = ty + TILESIZE - (ds->three_d ? Y_3D_DISP(w,w) : 0);
+
+            /*
+             * We arrange our pencil marks in a grid layout, with
+             * the number of rows and columns adjusted to allow the
+             * maximum font size.
+             *
+             * So now we work out what the grid size ought to be.
+             */
+            bestsize = 0.0;
+            pbest = 0;
+            /* Minimum */
+            for (pw = 3; pw < max(npencil,4); pw++) {
+                float fw, fh, fs;
+
+                ph = (npencil + pw - 1) / pw;
+                ph = max(ph, minph);
+                fw = (pr - pl) / (float)pw;
+                fh = (pb - pt) / (float)ph;
+                fs = min(fw, fh);
+                if (fs > bestsize) {
+                    bestsize = fs;
+                    pbest = pw;
+                }
+            }
+            assert(pbest > 0);
+            pw = pbest;
+            ph = (npencil + pw - 1) / pw;
+            ph = max(ph, minph);
+
+            /*
+             * Now we've got our grid dimensions, work out the pixel
+             * size of a grid element, and round it to the nearest
+             * pixel. (We don't want rounding errors to make the
+             * grid look uneven at low pixel sizes.)
+             */
+            fontsize = min((pr - pl) / pw, (pb - pt) / ph);
+
+            /*
+             * Centre the resulting figure in the square.
+             */
+            pl = pl + (pr - pl - fontsize * pw) / 2;
+            pt = pt + (pb - pt - fontsize * ph) / 2;
+
+            /*
+             * Now actually draw the pencil marks.
+             */
+            for (i = 1, j = 0; i <= w; i++)
+                if (tile & (1L << (i + DF_PENCIL_SHIFT))) {
+                    int dx = j % pw, dy = j / pw;
+
+                    str[1] = '\0';
+                    str[0] = i + '0';
+                    draw_text(dr, pl + fontsize * (2*dx+1) / 2,
+                              pt + fontsize * (2*dy+1) / 2,
+                              FONT_VARIABLE, fontsize,
+                              ALIGN_VCENTRE | ALIGN_HCENTRE, COL_PENCIL, str);
+                    j++;
+                }
+        }
+    }
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->par.w /*, a = w*w */;
+    int i, x, y;
+
+    if (!ds->started) {
+        /*
+         * The initial contents of the window are not guaranteed and
+         * can vary with front ends. To be on the safe side, all
+         * games should start by drawing a big background-colour
+         * rectangle covering the whole window.
+         */
+        draw_rect(dr, 0, 0, SIZE(w), SIZE(w), COL_BACKGROUND);
+
+        draw_update(dr, 0, 0, SIZE(w), SIZE(w));
+
+        ds->started = TRUE;
+    }
+
+    check_errors(state, ds->errtmp);
+
+    /*
+     * Work out what data each tile should contain.
+     */
+    for (i = 0; i < (w+2)*(w+2); i++)
+        ds->tiles[i] = 0;              /* completely blank square */
+    /* The clue squares... */
+    for (i = 0; i < 4*w; i++) {
+        long tile = state->clues->clues[i];
+
+        CLUEPOS(x, y, i, w);
+
+        if (ds->errtmp[(y+1)*(w+2)+(x+1)])
+            tile |= DF_ERROR;
+        else if (state->clues_done[i])
+            tile |= DF_CLUE_DONE;
+
+        ds->tiles[(y+1)*(w+2)+(x+1)] = tile;
+    }
+    /* ... and the main grid. */
+    for (y = 0; y < w; y++) {
+        for (x = 0; x < w; x++) {
+            long tile = DF_PLAYAREA;
+
+            if (state->grid[y*w+x])
+                tile |= state->grid[y*w+x];
+            else
+                tile |= (long)state->pencil[y*w+x] << DF_PENCIL_SHIFT;
+
+            if (ui->hshow && ui->hx == x && ui->hy == y)
+                tile |= (ui->hpencil ? DF_HIGHLIGHT_PENCIL : DF_HIGHLIGHT);
+
+            if (state->clues->immutable[y*w+x])
+                tile |= DF_IMMUTABLE;
+
+            if (flashtime > 0 &&
+                (flashtime <= FLASH_TIME/3 ||
+                 flashtime >= FLASH_TIME*2/3))
+                tile |= DF_HIGHLIGHT;  /* completion flash */
+
+            if (ds->errtmp[(y+1)*(w+2)+(x+1)])
+                tile |= DF_ERROR;
+
+            ds->tiles[(y+1)*(w+2)+(x+1)] = tile;
+        }
+    }
+
+    /*
+     * Now actually draw anything that needs to be changed.
+     */
+    for (y = 0; y < w+2; y++) {
+        for (x = 0; x < w+2; x++) {
+            long tl, tr, bl, br;
+            int i = y*(w+2)+x;
+
+            tr = ds->tiles[y*(w+2)+x];
+            tl = (x == 0 ? 0 : ds->tiles[y*(w+2)+(x-1)]);
+            br = (y == w+1 ? 0 : ds->tiles[(y+1)*(w+2)+x]);
+            bl = (x == 0 || y == w+1 ? 0 : ds->tiles[(y+1)*(w+2)+(x-1)]);
+
+            if (ds->drawn[i*4] != tl || ds->drawn[i*4+1] != tr ||
+                ds->drawn[i*4+2] != bl || ds->drawn[i*4+3] != br) {
+                clip(dr, COORD(x-1), COORD(y-1), TILESIZE, TILESIZE);
+
+                draw_tile(dr, ds, state->clues, x-1, y-1, tr);
+                if (x > 0)
+                    draw_tile(dr, ds, state->clues, x-2, y-1, tl);
+                if (y <= w)
+                    draw_tile(dr, ds, state->clues, x-1, y, br);
+                if (x > 0 && y <= w)
+                    draw_tile(dr, ds, state->clues, x-2, y, bl);
+
+                unclip(dr);
+                draw_update(dr, COORD(x-1), COORD(y-1), TILESIZE, TILESIZE);
+
+                ds->drawn[i*4] = tl;
+                ds->drawn[i*4+1] = tr;
+                ds->drawn[i*4+2] = bl;
+                ds->drawn[i*4+3] = br;
+            }
+        }
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    if (state->completed)
+        return FALSE;
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * We use 9mm squares by default, like Solo.
+     */
+    game_compute_size(params, 900, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->par.w;
+    int ink = print_mono_colour(dr, 0);
+    int i, x, y;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    /*
+     * Border.
+     */
+    print_line_width(dr, 3 * TILESIZE / 40);
+    draw_rect_outline(dr, BORDER, BORDER, w*TILESIZE, w*TILESIZE, ink);
+
+    /*
+     * Main grid.
+     */
+    for (x = 1; x < w; x++) {
+        print_line_width(dr, TILESIZE / 40);
+        draw_line(dr, BORDER+x*TILESIZE, BORDER,
+                  BORDER+x*TILESIZE, BORDER+w*TILESIZE, ink);
+    }
+    for (y = 1; y < w; y++) {
+        print_line_width(dr, TILESIZE / 40);
+        draw_line(dr, BORDER, BORDER+y*TILESIZE,
+                  BORDER+w*TILESIZE, BORDER+y*TILESIZE, ink);
+    }
+
+    /*
+     * Clues.
+     */
+    for (i = 0; i < 4*w; i++) {
+        char str[128];
+
+        if (!state->clues->clues[i])
+            continue;
+
+        CLUEPOS(x, y, i, w);
+
+        sprintf (str, "%d", state->clues->clues[i]);
+
+        draw_text(dr, BORDER + x*TILESIZE + TILESIZE/2,
+                  BORDER + y*TILESIZE + TILESIZE/2,
+                  FONT_VARIABLE, TILESIZE/2,
+                  ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str);
+    }
+
+    /*
+     * Numbers for the solution, if any.
+     */
+    for (y = 0; y < w; y++)
+        for (x = 0; x < w; x++)
+            if (state->grid[y*w+x]) {
+                char str[2];
+                str[1] = '\0';
+                str[0] = state->grid[y*w+x] + '0';
+                draw_text(dr, BORDER + x*TILESIZE + TILESIZE/2,
+                          BORDER + y*TILESIZE + TILESIZE/2,
+                          FONT_VARIABLE, TILESIZE/2,
+                          ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str);
+            }
+}
+
+#ifdef COMBINED
+#define thegame towers
+#endif
+
+const struct game thegame = {
+    "Towers", "games.towers", "towers",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON | REQUIRE_NUMPAD,  /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+#include <stdarg.h>
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err;
+    int grade = FALSE;
+    int ret, diff, really_show_working = FALSE;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            really_show_working = TRUE;
+        } else if (!strcmp(p, "-g")) {
+            grade = TRUE;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-g | -v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    /*
+     * When solving an Easy puzzle, we don't want to bother the
+     * user with Hard-level deductions. For this reason, we grade
+     * the puzzle internally before doing anything else.
+     */
+    ret = -1;                          /* placate optimiser */
+    solver_show_working = FALSE;
+    for (diff = 0; diff < DIFFCOUNT; diff++) {
+        memcpy(s->grid, s->clues->immutable, p->w * p->w);
+        ret = solver(p->w, s->clues->clues, s->grid, diff);
+        if (ret <= diff)
+            break;
+    }
+
+    if (diff == DIFFCOUNT) {
+        if (grade)
+            printf("Difficulty rating: ambiguous\n");
+        else
+            printf("Unable to find a unique solution\n");
+    } else {
+        if (grade) {
+            if (ret == diff_impossible)
+                printf("Difficulty rating: impossible (no solution exists)\n");
+            else
+                printf("Difficulty rating: %s\n", towers_diffnames[ret]);
+        } else {
+            solver_show_working = really_show_working;
+            memcpy(s->grid, s->clues->immutable, p->w * p->w);
+            ret = solver(p->w, s->clues->clues, s->grid, diff);
+            if (ret != diff)
+                printf("Puzzle is inconsistent\n");
+            else
+                fputs(game_text_format(s), stdout);
+        }
+    }
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/tracks.R b/apps/plugins/puzzles/tracks.R
new file mode 100644
index 0000000000..f88dfb03eb
--- /dev/null
+++ b/apps/plugins/puzzles/tracks.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+TRACKS_EXTRA = dsf findloop
+
+tracks  : [X] GTK COMMON tracks TRACKS_EXTRA tracks-icon|no-icon
+
+tracks  : [G] WINDOWS COMMON tracks TRACKS_EXTRA tracks.res|noicon.res
+
+ALL += tracks[COMBINED] TRACKS_EXTRA
+
+!begin am gtk
+GAMES += tracks
+!end
+
+!begin >list.c
+    A(tracks) \
+!end
+
+!begin >gamedesc.txt
+tracks:tracks.exe:Tracks:Path-finding railway track puzzle:Fill in the railway track according to the clues.
+!end
diff --git a/apps/plugins/puzzles/tracks.c b/apps/plugins/puzzles/tracks.c
new file mode 100644
index 0000000000..dd00e32b9a
--- /dev/null
+++ b/apps/plugins/puzzles/tracks.c
@@ -0,0 +1,2660 @@
+/*
+ * Implementation of 'Train Tracks', a puzzle from the Times on Saturday.
+ *
+ * "Lay tracks to enable the train to travel from village A to village B.
+ * The numbers indicate how many sections of rail go in each row and
+ * column. There are only straight rails and curved rails. The track
+ * cannot cross itself."
+ *
+ * Puzzles:
+ * #9     8x8:d9s5c6zgAa,1,4,1,4,4,3,S3,5,2,2,4,S5,3,3,5,1
+ * #112   8x8:w6x5mAa,1,3,1,4,6,4,S4,3,3,4,5,2,4,2,S5,1
+ * #113   8x8:gCx5xAf,1,S4,2,5,4,6,2,3,4,2,5,2,S4,4,5,1
+ * #114   8x8:p5fAzkAb,1,6,3,3,3,S6,2,3,5,4,S3,3,5,1,5,1
+ * #115   8x8:zi9d5tAb,1,3,4,5,3,S4,2,4,2,6,2,3,6,S3,3,1
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+/* --- Game parameters --- */
+
+/*
+ * Difficulty levels. I do some macro ickery here to ensure that my
+ * enum and the various forms of my name list always match up.
+ */
+#define DIFFLIST(A) \
+    A(EASY,Easy,e) \
+    A(TRICKY,Tricky,t)
+
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const tracks_diffnames[] = { DIFFLIST(TITLE) };
+static char const tracks_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+struct game_params {
+    int w, h, diff, single_ones;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 8;
+    ret->diff = DIFF_TRICKY;
+    ret->single_ones = TRUE;
+
+    return ret;
+}
+
+static const struct game_params tracks_presets[] = {
+    {8, 8, DIFF_EASY, 1},
+    {8, 8, DIFF_TRICKY, 1},
+    {10, 8, DIFF_EASY, 1},
+    {10, 8, DIFF_TRICKY, 1 },
+    {10, 10, DIFF_EASY, 1},
+    {10, 10, DIFF_TRICKY, 1},
+    {15, 10, DIFF_EASY, 1},
+    {15, 10, DIFF_TRICKY, 1},
+    {15, 15, DIFF_EASY, 1},
+    {15, 15, DIFF_TRICKY, 1},
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(tracks_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = tracks_presets[i];
+
+    sprintf(str, "%dx%d %s", ret->w, ret->h, tracks_diffnames[ret->diff]);
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->w = params->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        params->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 'd') {
+        int i;
+        string++;
+        params->diff = DIFF_TRICKY;
+        for (i = 0; i < DIFFCOUNT; i++)
+            if (*string == tracks_diffchars[i])
+                params->diff = i;
+        if (*string) string++;
+    }
+    params->single_ones = TRUE;
+    if (*string == 'o') {
+        params->single_ones = FALSE;
+        string++;
+    }
+
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[120];
+
+    sprintf(buf, "%dx%d", params->w, params->h);
+    if (full)
+        sprintf(buf + strlen(buf), "d%c%s",
+                tracks_diffchars[params->diff],
+                params->single_ones ? "" : "o");
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(5, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Difficulty";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = DIFFCONFIG;
+    ret[2].ival = params->diff;
+
+    ret[3].name = "Disallow consecutive 1 clues";
+    ret[3].type = C_BOOLEAN;
+    ret[3].ival = params->single_ones;
+
+    ret[4].name = NULL;
+    ret[4].type = C_END;
+    ret[4].sval = NULL;
+    ret[4].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->diff = cfg[2].ival;
+    ret->single_ones = cfg[3].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    /*
+     * Generating anything under 4x4 runs into trouble of one kind
+     * or another.
+     */
+    if (params->w < 4 || params->h < 4)
+        return "Width and height must both be at least four";
+    return NULL;
+}
+
+/* --- Game state --- */
+
+/* flag usage copied from pearl */
+
+#define R 1
+#define U 2
+#define L 4
+#define D 8
+
+#define MOVECHAR(m) ((m==R)?'R':(m==U)?'U':(m==L)?'L':(m==D)?'D':'?')
+
+#define DX(d) ( ((d)==R) - ((d)==L) )
+#define DY(d) ( ((d)==D) - ((d)==U) )
+
+#define F(d) (((d << 2) | (d >> 2)) & 0xF)
+#define C(d) (((d << 3) | (d >> 1)) & 0xF)
+#define A(d) (((d << 1) | (d >> 3)) & 0xF)
+
+#define LR (L | R)
+#define RL (R | L)
+#define UD (U | D)
+#define DU (D | U)
+#define LU (L | U)
+#define UL (U | L)
+#define LD (L | D)
+#define DL (D | L)
+#define RU (R | U)
+#define UR (U | R)
+#define RD (R | D)
+#define DR (D | R)
+#define ALLDIR 15
+#define BLANK 0
+#define UNKNOWN 15
+
+int nbits[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
+
+/* square grid flags */
+#define S_TRACK 1     /* a track passes through this square (--> 2 edges) */
+#define S_NOTRACK 2   /* no track passes through this square */
+#define S_ERROR 4
+#define S_CLUE 8
+#define S_MARK 16
+
+#define S_TRACK_SHIFT   16 /* U/D/L/R flags for edge track indicators */
+#define S_NOTRACK_SHIFT 20 /* U/D/L/R flags for edge no-track indicators */
+
+/* edge grid flags */
+#define E_TRACK 1     /* a track passes through this edge */
+#define E_NOTRACK 2   /* no track passes through this edge */
+
+struct numbers {
+    int refcount;
+    int *numbers;     /* sz w+h */
+    int row_s, col_s; /* stations: TODO think about multiple lines
+                         (for bigger grids)? */
+};
+
+#define INGRID(state, gx, gy) ((gx) >= 0 && (gx) < (state)->p.w && \
+                               (gy) >= 0 && (gy) < (state)->p.h)
+
+struct game_state {
+    game_params p;
+    unsigned int *sflags;       /* size w*h */
+    struct numbers *numbers;
+    int *num_errors;            /* size w+h */
+    int completed, used_solve, impossible;
+};
+
+/* Return the four directions in which a particular edge flag is set, around a square. */
+int S_E_DIRS(const game_state *state, int sx, int sy, unsigned int eflag) {
+    return (state->sflags[sy*state->p.w+sx] >>
+            ((eflag == E_TRACK) ? S_TRACK_SHIFT : S_NOTRACK_SHIFT)) & ALLDIR;
+}
+
+/* Count the number of a particular edge flag around a grid square. */
+int S_E_COUNT(const game_state *state, int sx, int sy, unsigned int eflag) {
+    return nbits[S_E_DIRS(state, sx, sy, eflag)];
+}
+
+/* Return the two flags (E_TRACK and/or E_NOTRACK) set on a specific
+ * edge of a square. */
+unsigned S_E_FLAGS(const game_state *state, int sx, int sy, int d) {
+    unsigned f = state->sflags[sy*state->p.w+sx];
+    int t = (f & (d << S_TRACK_SHIFT)), nt = (f & (d << S_NOTRACK_SHIFT));
+    return (t ? E_TRACK : 0) | (nt ? E_NOTRACK : 0);
+}
+
+int S_E_ADJ(const game_state *state, int sx, int sy, int d, int *ax, int *ay, unsigned int *ad) {
+    if (d == L && sx > 0)            { *ax = sx-1; *ay = sy;   *ad = R; return 1; }
+    if (d == R && sx < state->p.w-1) { *ax = sx+1; *ay = sy;   *ad = L; return 1; }
+    if (d == U && sy > 0)            { *ax = sx;   *ay = sy-1; *ad = D; return 1; }
+    if (d == D && sy < state->p.h-1) { *ax = sx;   *ay = sy+1; *ad = U; return 1; }
+
+    return 0;
+}
+
+/* Sets flag (E_TRACK or E_NOTRACK) on a given edge of a square. */
+void S_E_SET(game_state *state, int sx, int sy, int d, unsigned int eflag) {
+    unsigned shift = (eflag == E_TRACK) ? S_TRACK_SHIFT : S_NOTRACK_SHIFT, ad;
+    int ax, ay;
+
+    state->sflags[sy*state->p.w+sx] |= (d << shift);
+
+    if (S_E_ADJ(state, sx, sy, d, &ax, &ay, &ad)) {
+        state->sflags[ay*state->p.w+ax] |= (ad << shift);
+    }
+}
+
+/* Clears flag (E_TRACK or E_NOTRACK) on a given edge of a square. */
+void S_E_CLEAR(game_state *state, int sx, int sy, int d, unsigned int eflag) {
+    unsigned shift = (eflag == E_TRACK) ? S_TRACK_SHIFT : S_NOTRACK_SHIFT, ad;
+    int ax, ay;
+
+    state->sflags[sy*state->p.w+sx] &= ~(d << shift);
+
+    if (S_E_ADJ(state, sx, sy, d, &ax, &ay, &ad)) {
+        state->sflags[ay*state->p.w+ax] &= ~(ad << shift);
+    }
+}
+
+static void clear_game(game_state *state)
+{
+    int w = state->p.w, h = state->p.h;
+
+    memset(state->sflags, 0, w*h * sizeof(unsigned int));
+
+    memset(state->numbers->numbers, 0, (w+h) * sizeof(int));
+    state->numbers->col_s = state->numbers->row_s = -1;
+
+    memset(state->num_errors, 0, (w+h) * sizeof(int));
+
+    state->completed = state->used_solve = state->impossible = FALSE;
+}
+
+static game_state *blank_game(const game_params *params)
+{
+    game_state *state = snew(game_state);
+    int w = params->w, h = params->h;
+
+    state->p = *params;
+
+    state->sflags = snewn(w*h, unsigned int);
+
+    state->numbers = snew(struct numbers);
+    state->numbers->refcount = 1;
+    state->numbers->numbers = snewn(w+h, int);
+
+    state->num_errors = snewn(w+h, int);
+
+    clear_game(state);
+
+    return state;
+}
+
+static void copy_game_flags(const game_state *src, game_state *dest)
+{
+    int w = src->p.w, h = src->p.h;
+
+    memcpy(dest->sflags, src->sflags, w*h*sizeof(unsigned int));
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w = state->p.w, h = state->p.h;
+    game_state *ret = snew(game_state);
+
+    ret->p = state->p;                 /* structure copy */
+
+    ret->sflags = snewn(w*h, unsigned int);
+    copy_game_flags(state, ret);
+
+    ret->numbers = state->numbers;
+    state->numbers->refcount++;
+    ret->num_errors = snewn(w+h, int);
+    memcpy(ret->num_errors, state->num_errors, (w+h)*sizeof(int));
+
+    ret->completed = state->completed;
+    ret->used_solve = state->used_solve;
+    ret->impossible = state->impossible;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (--state->numbers->refcount <= 0) {
+        sfree(state->numbers->numbers);
+        sfree(state->numbers);
+    }
+    sfree(state->num_errors);
+    sfree(state->sflags);
+    sfree(state);
+}
+
+#define NDIRS 4
+const unsigned int dirs_const[] = { U, D, L, R };
+
+static unsigned int find_direction(game_state *state, random_state *rs,
+                                   int x, int y)
+{
+    int i, nx, ny, w=state->p.w, h=state->p.h;
+    unsigned int dirs[NDIRS];
+
+    memcpy(dirs, dirs_const, sizeof(dirs));
+    shuffle(dirs, NDIRS, sizeof(*dirs), rs);
+    for (i = 0; i < NDIRS; i++) {
+        nx = x + DX(dirs[i]);
+        ny = y + DY(dirs[i]);
+        if (nx >= 0 && nx < w && ny == h) {
+            /* off the bottom of the board: we've finished the path. */
+            return dirs[i];
+        } else if (!INGRID(state, nx, ny)) {
+            /* off the board: can't move here */
+            continue;
+        } else if (S_E_COUNT(state, nx, ny, E_TRACK) > 0) {
+            /* already tracks here: can't move */
+            continue;
+        }
+        return dirs[i];
+    }
+    return 0; /* no possible directions left. */
+}
+
+static int check_completion(game_state *state, int mark);
+
+static void lay_path(game_state *state, random_state *rs)
+{
+    int px, py, w=state->p.w, h=state->p.h;
+    unsigned int d;
+
+start:
+    clear_game(state);
+
+    /* pick a random entry point, lay its left edge */
+    state->numbers->row_s = py = random_upto(rs, h);
+    px = 0;
+    S_E_SET(state, px, py, L, E_TRACK);
+
+    while (INGRID(state, px, py)) {
+        d = find_direction(state, rs, px, py);
+        if (d == 0)
+            goto start; /* nowhere else to go, restart */
+
+        S_E_SET(state, px, py, d, E_TRACK);
+        px += DX(d);
+        py += DY(d);
+    }
+    /* double-check we got to the right place */
+    assert(px >= 0 && px < w && py == h);
+
+    state->numbers->col_s = px;
+}
+
+static int tracks_solve(game_state *state, int diff);
+static void debug_state(game_state *state, const char *what);
+
+/* Clue-setting algorithm:
+
+ - first lay clues randomly until it's soluble
+ - then remove clues randomly if removing them doesn't affect solubility
+
+ - We start with two clues, one at each path entrance.
+
+ More details:
+ - start with an array of all square i positions
+ - if the grid is already soluble by a level easier than we've requested,
+    go back and make a new grid
+ - if the grid is already soluble by our requested difficulty level, skip
+    the clue-laying step
+ - count the number of flags the solver managed to place, remember this.
+
+ - to lay clues:
+   - shuffle the i positions
+   - for each possible clue position:
+     - copy the solved board, strip it
+     - take the next position, add a clue there on the copy
+     - try and solve the copy
+     - if it's soluble by a level easier than we've requested, continue (on
+        to next clue position: putting a clue here makes it too easy)
+     - if it's soluble by our difficulty level, we're done:
+       - put the clue flag into the solved board
+       - go to strip-clues.
+     - if the solver didn't manage to place any more flags, continue (on to next
+        clue position: putting a clue here didn't help he solver)
+     - otherwise put the clue flag in the original board, and go on to the next
+        clue position
+   - if we get here and we've not solved it yet, we never will (did we really
+      fill _all_ the clues in?!). Go back and make a new grid.
+
+ - to strip clues:
+   - shuffle the i positions
+   - for each possible clue position:
+     - if the solved grid doesn't have a clue here, skip
+     - copy the solved board, remove this clue, strip it
+     - try and solve the copy
+     - assert that it is not soluble by a level easier than we've requested
+       - (because this should never happen)
+     - if this is (still) soluble by our difficulty level:
+       - remove this clue from the solved board, it's redundant (with the other
+          clues)
+
+  - that should be it.
+*/
+
+static game_state *copy_and_strip(const game_state *state, game_state *ret, int flipcluei)
+{
+    int i, j, w = state->p.w, h = state->p.h;
+
+    copy_game_flags(state, ret);
+
+    /* Add/remove a clue before stripping, if required */
+
+    if (flipcluei != -1)
+        ret->sflags[flipcluei] ^= S_CLUE;
+
+    /* All squares that are not clue squares have square track info erased, and some edge flags.. */
+
+    for (i = 0; i < w*h; i++) {
+        if (!(ret->sflags[i] & S_CLUE)) {
+            ret->sflags[i] &= ~(S_TRACK|S_NOTRACK|S_ERROR|S_MARK);
+            for (j = 0; j < 4; j++) {
+                unsigned f = 1<<j;
+                int xx = i%w + DX(f), yy = i/w + DY(f);
+                if (!INGRID(state, xx, yy) || !(ret->sflags[yy*w+xx] & S_CLUE)) {
+                    /* only erase an edge flag if neither side of the edge is S_CLUE. */
+                    S_E_CLEAR(ret, i%w, i/w, f, E_TRACK);
+                    S_E_CLEAR(ret, i%w, i/w, f, E_NOTRACK);
+                }
+            }
+        }
+    }
+    return ret;
+}
+
+static int solve_progress(const game_state *state) {
+    int i, w = state->p.w, h = state->p.h, progress = 0;
+
+    /* Work out how many flags the solver managed to set (either TRACK
+       or NOTRACK) and return this as a progress measure, to check whether
+       a partially-solved board gets any further than a previous partially-
+       solved board. */
+
+    for (i = 0; i < w*h; i++) {
+        if (state->sflags[i] & S_TRACK) progress++;
+        if (state->sflags[i] & S_NOTRACK) progress++;
+        progress += S_E_COUNT(state, i%w, i/w, E_TRACK);
+        progress += S_E_COUNT(state, i%w, i/w, E_NOTRACK);
+    }
+    return progress;
+}
+
+static int check_phantom_moves(const game_state *state) {
+    int x, y, i;
+
+    /* Check that this state won't show 'phantom moves' at the start of the
+     * game: squares which have multiple edge flags set but no clue flag
+     * cause a piece of track to appear that isn't on a clue square. */
+
+    for (x = 0; x < state->p.w; x++) {
+        for (y = 0; y < state->p.h; y++) {
+            i = y*state->p.w+x;
+            if (state->sflags[i] & S_CLUE)
+                continue;
+            if (S_E_COUNT(state, x, y, E_TRACK) > 1)
+                return 1; /* found one! */
+        }
+    }
+    return 0;
+}
+
+static int add_clues(game_state *state, random_state *rs, int diff)
+{
+    int i, j, pi, w = state->p.w, h = state->p.h, progress, ret = 0, sr;
+    int *positions = snewn(w*h, int), npositions = 0;
+    int *nedges_previous_solve = snewn(w*h, int);
+    game_state *scratch = dup_game(state);
+
+    debug_state(state, "gen: Initial board");
+
+    debug(("gen: Adding clues..."));
+
+    /* set up the shuffly-position grid for later, used for adding clues:
+     * we only bother adding clues where any edges are set. */
+    for (i = 0; i < w*h; i++) {
+        if (S_E_DIRS(state, i%w, i/w, E_TRACK) != 0) {
+            positions[npositions++] = i;
+        }
+        nedges_previous_solve[i] = 0;
+    }
+
+    /* First, check whether the puzzle is already either too easy, or just right */
+    scratch = copy_and_strip(state, scratch, -1);
+    if (diff > 0) {
+        sr = tracks_solve(scratch, diff-1);
+        if (sr < 0)
+            assert(!"Generator should not have created impossible puzzle");
+        if (sr > 0) {
+            ret = -1; /* already too easy, even without adding clues. */
+            debug(("gen:  ...already too easy, need new board."));
+            goto done;
+        }
+    }
+    sr = tracks_solve(scratch, diff);
+    if (sr < 0)
+        assert(!"Generator should not have created impossible puzzle");
+    if (sr > 0) {
+        ret = 1; /* already soluble without any extra clues. */
+        debug(("gen:  ...soluble without clues, nothing to do."));
+        goto done;
+    }
+    debug_state(scratch, "gen: Initial part-solved state: ");
+    progress = solve_progress(scratch);
+    debug(("gen: Initial solve progress is %d", progress));
+
+    /* First, lay clues until we're soluble. */
+    shuffle(positions, npositions, sizeof(int), rs);
+    for (pi = 0; pi < npositions; pi++) {
+        i = positions[pi]; /* pick a random position */
+        if (state->sflags[i] & S_CLUE)
+            continue; /* already a clue here (entrance location?) */
+        if (nedges_previous_solve[i] == 2)
+            continue; /* no point putting a clue here, we could solve both edges
+                         with the previous set of clues */
+
+        /* set a clue in that position (on a copy of the board) and test solubility */
+        scratch = copy_and_strip(state, scratch, i);
+
+        if (check_phantom_moves(scratch))
+            continue; /* adding a clue here would add phantom track */
+
+        if (diff > 0) {
+            if (tracks_solve(scratch, diff-1) > 0) {
+                continue; /* adding a clue here makes it too easy */
+            }
+        }
+        if (tracks_solve(scratch, diff) > 0) {
+            /* we're now soluble (and we weren't before): add this clue, and then
+               start stripping clues */
+            debug(("gen:  ...adding clue at (%d,%d), now soluble", i%w, i/w));
+            state->sflags[i] |= S_CLUE;
+            goto strip_clues;
+        }
+        if (solve_progress(scratch) > progress) {
+            /* We've made more progress solving: add this clue, then. */
+            progress = solve_progress(scratch);
+            debug(("gen:  ... adding clue at (%d,%d), new progress %d", i%w, i/w, progress));
+            state->sflags[i] |= S_CLUE;
+
+            for (j = 0; j < w*h; j++)
+                nedges_previous_solve[j] = S_E_COUNT(scratch, j%w, j/w, E_TRACK);
+        }
+    }
+    /* If we got here we didn't ever manage to make the puzzle soluble
+       (without making it too easily soluble, that is): give up. */
+
+    debug(("gen: Unable to make soluble with clues, need new board."));
+    ret = -1;
+    goto done;
+
+strip_clues:
+    debug(("gen: Stripping clues."));
+
+    /* Now, strip redundant clues (i.e. those without which the puzzle is still
+       soluble) */
+    shuffle(positions, npositions, sizeof(int), rs);
+    for (pi = 0; pi < npositions; pi++) {
+        i = positions[pi]; /* pick a random position */
+        if (!(state->sflags[i] & S_CLUE))
+            continue; /* no clue here to strip */
+        if ((i%w == 0 && i/w == state->numbers->row_s) ||
+                (i/w == (h-1) && i%w == state->numbers->col_s))
+            continue; /* don't strip clues at entrance/exit */
+
+        scratch = copy_and_strip(state, scratch, i);
+        if (check_phantom_moves(scratch))
+            continue; /* removing a clue here would add phantom track */
+
+        if (tracks_solve(scratch, diff) > 0) {
+            debug(("gen:  ... removing clue at (%d,%d), still soluble without it", i%w, i/w));
+            state->sflags[i] &= ~S_CLUE; /* still soluble without this clue. */
+        }
+    }
+    debug(("gen: Finished stripping clues."));
+    ret = 1;
+
+done:
+    sfree(positions);
+    free_game(scratch);
+    return ret;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int i, j, w = params->w, h = params->h, x, y, ret;
+    game_state *state;
+    char *desc, *p;
+    game_params adjusted_params;
+
+    /*
+     * 4x4 Tricky cannot be generated, so fall back to Easy.
+     */
+    if (w == 4 && h == 4 && params->diff > DIFF_EASY) {
+        adjusted_params = *params;     /* structure copy */
+        adjusted_params.diff = DIFF_EASY;
+        params = &adjusted_params;
+    }
+
+    state = blank_game(params);
+
+    /* --- lay the random path */
+
+newpath:
+    lay_path(state, rs);
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            if (S_E_COUNT(state, x, y, E_TRACK) > 0) {
+                state->sflags[y*w + x] |= S_TRACK;
+            }
+            if ((x == 0 && y == state->numbers->row_s) ||
+                    (y == (h-1) && x == state->numbers->col_s)) {
+                state->sflags[y*w + x] |= S_CLUE;
+            }
+        }
+    }
+
+    /* --- Update the clue numbers based on the tracks we have generated. */
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            if (state->sflags[y*w + x] & S_TRACK) {
+                state->numbers->numbers[x]++;
+                state->numbers->numbers[y+w]++;
+            }
+        }
+    }
+    for (i = 0; i < w+h; i++) {
+        if (state->numbers->numbers[i] == 0)
+            goto newpath; /* too boring */
+    }
+
+    if (params->single_ones) {
+        int last_was_one = 1, is_one; /* (disallow 1 clue at entry point) */
+        for (i = 0; i < w+h; i++) {
+            is_one = (state->numbers->numbers[i] == 1);
+            if (is_one && last_was_one)
+                goto newpath; /* disallow consecutive 1 clues. */
+            last_was_one = is_one;
+        }
+        if (state->numbers->numbers[w+h-1] == 1)
+            goto newpath; /* (disallow 1 clue at exit point) */
+    }
+
+    /* --- Add clues to make a soluble puzzle */
+    ret = add_clues(state, rs, params->diff);
+    if (ret != 1) goto newpath; /* couldn't make it soluble, or too easy */
+
+    /* --- Generate the game desc based on the generated grid. */
+    desc = snewn(w*h*3 + (w+h)*5, char);
+    for (i = j = 0; i < w*h; i++) {
+        if (!(state->sflags[i] & S_CLUE) && j > 0 &&
+                desc[j-1] >= 'a' && desc[j-1] < 'z')
+            desc[j-1]++;
+        else if (!(state->sflags[i] & S_CLUE))
+            desc[j++] = 'a';
+        else {
+            unsigned int f = S_E_DIRS(state, i%w, i/w, E_TRACK);
+            desc[j++] = (f < 10) ? ('0' + f) : ('A' + (f-10));
+        }
+    }
+
+    p = desc + j;
+    for (x = 0; x < w; x++) {
+        p += sprintf(p, ",%s%d", x == state->numbers->col_s ? "S" : "",
+                     state->numbers->numbers[x]);
+    }
+    for (y = 0; y < h; y++) {
+        p += sprintf(p, ",%s%d", y == state->numbers->row_s ? "S" : "",
+                     state->numbers->numbers[y+w]);
+    }
+    *p++ = '\0';
+
+    ret = tracks_solve(state, DIFFCOUNT);
+    assert(ret >= 0);
+    free_game(state);
+
+    debug(("new_game_desc: %s", desc));
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int i = 0, w = params->w, h = params->h, in = 0, out = 0;
+
+    while (*desc) {
+        unsigned int f = 0;
+        if (*desc >= '0' && *desc <= '9')
+            f = (*desc - '0');
+        else if (*desc >= 'A' && *desc <= 'F')
+            f = (*desc - 'A' + 10);
+        else if (*desc >= 'a' && *desc <= 'z')
+            i += *desc - 'a';
+        else
+            return "Game description contained unexpected characters";
+
+        if (f != 0) {
+            if (nbits[f] != 2)
+                return "Clue did not provide 2 direction flags";
+        }
+        i++;
+        desc++;
+        if (i == w*h) break;
+    }
+    for (i = 0; i < w+h; i++) {
+        if (!*desc)
+            return "Not enough numbers given after grid specification";
+        else if (*desc != ',')
+            return "Invalid character in number list";
+        desc++;
+        if (*desc == 'S') {
+            if (i < w)
+                out++;
+            else
+                in++;
+            desc++;
+        }
+        while (*desc && isdigit((unsigned char)*desc)) desc++;
+    }
+    if (in != 1 || out != 1)
+        return "Puzzle must have one entrance and one exit";
+    if (*desc)
+        return "Unexpected additional character at end of game description";
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params, const char *desc)
+{
+    game_state *state = blank_game(params);
+    int w = params->w, h = params->h, i = 0;
+
+    while (*desc) {
+        unsigned int f = 0;
+        if (*desc >= '0' && *desc <= '9')
+            f = (*desc - '0');
+        else if (*desc >= 'A' && *desc <= 'F')
+            f = (*desc - 'A' + 10);
+        else if (*desc >= 'a' && *desc <= 'z')
+            i += *desc - 'a';
+
+        if (f != 0) {
+            int x = i % w, y = i / w;
+            assert(f < 16);
+            assert(nbits[f] == 2);
+
+            state->sflags[i] |= (S_TRACK | S_CLUE);
+            if (f & U) S_E_SET(state, x, y, U, E_TRACK);
+            if (f & D) S_E_SET(state, x, y, D, E_TRACK);
+            if (f & L) S_E_SET(state, x, y, L, E_TRACK);
+            if (f & R) S_E_SET(state, x, y, R, E_TRACK);
+        }
+        i++;
+        desc++;
+        if (i == w*h) break;
+    }
+    for (i = 0; i < w+h; i++) {
+        assert(*desc == ',');
+        desc++;
+
+        if (*desc == 'S') {
+            if (i < w)
+                state->numbers->col_s = i;
+            else
+                state->numbers->row_s = i-w;
+            desc++;
+        }
+        state->numbers->numbers[i] = atoi(desc);
+        while (*desc && isdigit((unsigned char)*desc)) desc++;
+    }
+
+    assert(!*desc);
+
+    return state;
+}
+
+static int solve_set_sflag(game_state *state, int x, int y,
+                           unsigned int f, const char *why)
+{
+    int w = state->p.w, i = y*w + x;
+
+    if (state->sflags[i] & f)
+        return 0;
+    debug(("solve: square (%d,%d) -> %s: %s",
+           x, y, (f == S_TRACK ? "TRACK" : "NOTRACK"), why));
+    if (state->sflags[i] & (f == S_TRACK ? S_NOTRACK : S_TRACK)) {
+        debug(("solve: opposite flag already set there, marking IMPOSSIBLE"));
+        state->impossible = TRUE;
+    }
+    state->sflags[i] |= f;
+    return 1;
+}
+
+static int solve_set_eflag(game_state *state, int x, int y, int d,
+                           unsigned int f, const char *why)
+{
+    int sf = S_E_FLAGS(state, x, y, d);
+
+    if (sf & f)
+        return 0;
+    debug(("solve: edge (%d,%d)/%c -> %s: %s", x, y,
+           (d == U) ? 'U' : (d == D) ? 'D' : (d == L) ? 'L' : 'R',
+           (f == S_TRACK ? "TRACK" : "NOTRACK"), why));
+    if (sf & (f == E_TRACK ? E_NOTRACK : E_TRACK)) {
+        debug(("solve: opposite flag already set there, marking IMPOSSIBLE"));
+        state->impossible = TRUE;
+    }
+    S_E_SET(state, x, y, d, f);
+    return 1;
+}
+
+static int solve_update_flags(game_state *state)
+{
+    int x, y, i, w = state->p.w, h = state->p.h, did = 0;
+
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            /* If a square is NOTRACK, all four edges must be. */
+            if (state->sflags[y*w + x] & S_NOTRACK) {
+                for (i = 0; i < 4; i++) {
+                    unsigned int d = 1<<i;
+                    did += solve_set_eflag(state, x, y, d, E_NOTRACK, "edges around NOTRACK");
+                }
+            }
+
+            /* If 3 or more edges around a square are NOTRACK, the square is. */
+            if (S_E_COUNT(state, x, y, E_NOTRACK) >= 3) {
+                did += solve_set_sflag(state, x, y, S_NOTRACK, "square has >2 NOTRACK edges");
+            }
+
+            /* If any edge around a square is TRACK, the square is. */
+            if (S_E_COUNT(state, x, y, E_TRACK) > 0) {
+                did += solve_set_sflag(state, x, y, S_TRACK, "square has TRACK edge");
+            }
+
+            /* If a square is TRACK and 2 edges are NOTRACK,
+               the other two edges must be TRACK. */
+            if ((state->sflags[y*w + x] & S_TRACK) &&
+                    (S_E_COUNT(state, x, y, E_NOTRACK) == 2) &&
+                    (S_E_COUNT(state, x, y, E_TRACK) < 2)) {
+                for (i = 0; i < 4; i++) {
+                    unsigned int d = 1<<i;
+                    if (!(S_E_FLAGS(state, x, y, d) & (E_TRACK|E_NOTRACK))) {
+                        did += solve_set_eflag(state, x, y, d, E_TRACK,
+                                               "TRACK square/2 NOTRACK edges");
+                    }
+                }
+            }
+
+            /* If a square is TRACK and 2 edges are TRACK, the other two
+               must be NOTRACK. */
+            if ((state->sflags[y*w + x] & S_TRACK) &&
+                    (S_E_COUNT(state, x, y, E_TRACK) == 2) &&
+                    (S_E_COUNT(state, x, y, E_NOTRACK) < 2)) {
+                for (i = 0; i < 4; i++) {
+                    unsigned int d = 1<<i;
+                    if (!(S_E_FLAGS(state, x, y, d) & (E_TRACK|E_NOTRACK))) {
+                        did += solve_set_eflag(state, x, y, d, E_NOTRACK,
+                                               "TRACK square/2 TRACK edges");
+                    }
+                }
+            }
+        }
+    }
+    return did;
+}
+
+static int solve_count_col(game_state *state, int col, unsigned int f)
+{
+    int i, n, c = 0, h = state->p.h, w = state->p.w;
+    for (n = 0, i = col; n < h; n++, i += w) {
+        if (state->sflags[i] & f) c++;
+    }
+    return c;
+}
+
+static int solve_count_row(game_state *state, int row, unsigned int f)
+{
+    int i, n, c = 0, w = state->p.w;
+    for (n = 0, i = w*row; n < state->p.w; n++, i++) {
+        if (state->sflags[i] & f) c++;
+    }
+    return c;
+}
+
+static int solve_count_clues_sub(game_state *state, int si, int id, int n,
+                                 int target, const char *what)
+{
+    int ctrack = 0, cnotrack = 0, did = 0, j, i, w = state->p.w;
+
+    for (j = 0, i = si; j < n; j++, i += id) {
+        if (state->sflags[i] & S_TRACK)
+            ctrack++;
+        if (state->sflags[i] & S_NOTRACK)
+            cnotrack++;
+    }
+    if (ctrack == target) {
+        /* everything that's not S_TRACK must be S_NOTRACK. */
+        for (j = 0, i = si; j < n; j++, i += id) {
+            if (!(state->sflags[i] & S_TRACK))
+                did += solve_set_sflag(state, i%w, i/w, S_NOTRACK, what);
+        }
+    }
+    if (cnotrack == (n-target)) {
+        /* everything that's not S_NOTRACK must be S_TRACK. */
+        for (j = 0, i = si; j < n; j++, i += id) {
+            if (!(state->sflags[i] & S_NOTRACK))
+                did += solve_set_sflag(state, i%w, i/w, S_TRACK, what);
+        }
+    }
+    return did;
+}
+
+static int solve_count_clues(game_state *state)
+{
+    int w = state->p.w, h = state->p.h, x, y, target, did = 0;
+
+    for (x = 0; x < w; x++) {
+        target = state->numbers->numbers[x];
+        did += solve_count_clues_sub(state, x, w, h, target, "col count");
+    }
+    for (y = 0; y < h; y++) {
+        target = state->numbers->numbers[w+y];
+        did += solve_count_clues_sub(state, y*w, 1, w, target, "row count");
+    }
+    return did;
+}
+
+static int solve_check_single_sub(game_state *state, int si, int id, int n,
+                                  int target, unsigned int perpf,
+                                  const char *what)
+{
+    int ctrack = 0, nperp = 0, did = 0, j, i, w = state->p.w;
+    int n1edge = 0, i1edge = 0, ox, oy, x, y;
+    unsigned int impossible = 0;
+
+    /* For rows or columns which only have one more square to put a track in, we
+       know the only way a new track section could be there would be to run
+       perpendicular to the track (otherwise we'd need at least two free squares).
+       So, if there is nowhere we can run perpendicular to the track (e.g. because
+       we're on an edge) we know the extra track section much be on one end of an
+       existing section. */
+
+    for (j = 0, i = si; j < n; j++, i += id) {
+        if (state->sflags[i] & S_TRACK)
+            ctrack++;
+        impossible = S_E_DIRS(state, i%w, i/w, E_NOTRACK);
+        if ((perpf & impossible) == 0)
+            nperp++;
+        if (S_E_COUNT(state, i%w, i/w, E_TRACK) <= 1) {
+            n1edge++;
+            i1edge = i;
+        }
+    }
+    if (ctrack != (target-1)) return 0;
+    if (nperp > 0 || n1edge != 1) return 0;
+
+    debug(("check_single from (%d,%d): 1 match from (%d,%d)",
+           si%w, si/w, i1edge%w, i1edge/w));
+
+    /* We have a match: anything that's more than 1 away from this square
+       cannot now contain a track. */
+    ox = i1edge%w;
+    oy = i1edge/w;
+    for (j = 0, i = si; j < n; j++, i += id) {
+        x = i%w;
+        y = i/w;
+        if (abs(ox-x) > 1 || abs(oy-y) > 1) {
+            if (!state->sflags[i] & S_TRACK)
+                did += solve_set_sflag(state, x, y, S_NOTRACK, what);
+        }
+    }
+
+    return did;
+}
+
+static int solve_check_single(game_state *state)
+{
+    int w = state->p.w, h = state->p.h, x, y, target, did = 0;
+
+    for (x = 0; x < w; x++) {
+        target = state->numbers->numbers[x];
+        did += solve_check_single_sub(state, x, w, h, target, R|L, "single on col");
+    }
+    for (y = 0; y < h; y++) {
+        target = state->numbers->numbers[w+y];
+        did += solve_check_single_sub(state, y*w, 1, w, target, U|D, "single on row");
+    }
+    return did;
+}
+
+static int solve_check_loose_sub(game_state *state, int si, int id, int n,
+                                 int target, unsigned int perpf,
+                                 const char *what)
+{
+    int nperp = 0, nloose = 0, e2count = 0, did = 0, i, j, k;
+    int w = state->p.w;
+    unsigned int parf = ALLDIR & (~perpf);
+
+    for (j = 0, i = si; j < n; j++, i += id) {
+        int fcount = S_E_COUNT(state, i%w, i/w, E_TRACK);
+        if (fcount == 2)
+            e2count++; /* this cell has 2 definite edges */
+        state->sflags[i] &= ~S_MARK;
+        if (fcount == 1 && (parf & S_E_DIRS(state, i%w, i/w, E_TRACK))) {
+            nloose++; /* this cell has a loose end (single flag set parallel
+                    to the direction of this row/column) */
+            state->sflags[i] |= S_MARK; /* mark loose ends */
+        }
+        if (fcount != 2 && !(perpf & S_E_DIRS(state, i%w, i/w, E_NOTRACK)))
+            nperp++; /* we could lay perpendicular across this cell */
+    }
+
+    if (nloose > (target - e2count)) {
+        debug(("check %s from (%d,%d): more loose (%d) than empty (%d), IMPOSSIBLE",
+               what, si%w, si/w, nloose, target-e2count));
+        state->impossible = TRUE;
+    }
+    if (nloose > 0 && nloose == (target - e2count)) {
+        debug(("check %s from (%d,%d): nloose = empty (%d), forcing loners out.",
+               what, si%w, si/w, nloose));
+        for (j = 0, i = si; j < n; j++, i += id) {
+            if (!(state->sflags[i] & S_MARK))
+                continue; /* skip non-loose ends */
+            if (j > 0 && state->sflags[i-id] & S_MARK)
+                continue; /* next to other loose end, could join up */
+            if (j < (n-1) && state->sflags[i+id] & S_MARK)
+                continue; /* ditto */
+
+            for (k = 0; k < 4; k++) {
+                if ((parf & (1<<k)) &&
+                        !(S_E_DIRS(state, i%w, i/w, E_TRACK) & (1<<k))) {
+                    /* set as NOTRACK the edge parallel to the row/column that's
+                       not already set. */
+                    did += solve_set_eflag(state, i%w, i/w, 1<<k, E_NOTRACK, what);
+                }
+            }
+        }
+    }
+    if (nloose == 1 && (target - e2count) == 2 && nperp == 0) {
+        debug(("check %s from (%d,%d): 1 loose end, 2 empty squares, forcing parallel",
+               what, si%w, si/w));
+        for (j = 0, i = si; j < n; j++, i += id) {
+            if (!(state->sflags[i] & S_MARK))
+                continue; /* skip non-loose ends */
+            for (k = 0; k < 4; k++) {
+                if (parf & (1<<k))
+                    did += solve_set_eflag(state, i%w, i/w, 1<<k, E_TRACK, what);
+            }
+        }
+    }
+
+    return did;
+}
+
+static int solve_check_loose_ends(game_state *state)
+{
+    int w = state->p.w, h = state->p.h, x, y, target, did = 0;
+
+    for (x = 0; x < w; x++) {
+        target = state->numbers->numbers[x];
+        did += solve_check_loose_sub(state, x, w, h, target, R|L, "loose on col");
+    }
+    for (y = 0; y < h; y++) {
+        target = state->numbers->numbers[w+y];
+        did += solve_check_loose_sub(state, y*w, 1, w, target, U|D, "loose on row");
+    }
+    return did;
+}
+
+static int solve_check_loop_sub(game_state *state, int x, int y, int dir,
+                                int *dsf, int startc, int endc)
+{
+    int w = state->p.w, h = state->p.h, i = y*w+x, j, k, satisfied = 1;
+
+    j = (y+DY(dir))*w + (x+DX(dir));
+
+    assert(i < w*h && j < w*h);
+
+    if ((state->sflags[i] & S_TRACK) &&
+        (state->sflags[j] & S_TRACK) &&
+        !(S_E_DIRS(state, x, y, E_TRACK) & dir) &&
+        !(S_E_DIRS(state, x, y, E_NOTRACK) & dir)) {
+        int ic = dsf_canonify(dsf, i), jc = dsf_canonify(dsf, j);
+        if (ic == jc) {
+            return solve_set_eflag(state, x, y, dir, E_NOTRACK, "would close loop");
+        }
+        if ((ic == startc && jc == endc) || (ic == endc && jc == startc)) {
+            debug(("Adding link at (%d,%d) would join start to end", x, y));
+            /* We mustn't join the start to the end if:
+               - there are other bits of track that aren't attached to either end
+               - the clues are not fully satisfied yet
+             */
+            for (k = 0; k < w*h; k++) {
+                if (state->sflags[k] & S_TRACK &&
+                        dsf_canonify(dsf, k) != startc && dsf_canonify(dsf, k) != endc) {
+                    return solve_set_eflag(state, x, y, dir, E_NOTRACK,
+                                           "joins start to end but misses tracks");
+                }
+            }
+            for (k = 0; k < w; k++) {
+                int target = state->numbers->numbers[k];
+                int ntracks = solve_count_col(state, k, S_TRACK);
+                if (ntracks < target) satisfied = 0;
+            }
+            for (k = 0; k < h; k++) {
+                int target = state->numbers->numbers[w+k];
+                int ntracks = solve_count_row(state, k, S_TRACK);
+                if (ntracks < target) satisfied = 0;
+            }
+            if (!satisfied) {
+                return solve_set_eflag(state, x, y, dir, E_NOTRACK,
+                                       "joins start to end with incomplete clues");
+            }
+        }
+    }
+    return 0;
+}
+
+static int solve_check_loop(game_state *state)
+{
+    int w = state->p.w, h = state->p.h, x, y, i, j, did = 0;
+    int *dsf, startc, endc;
+
+    /* TODO eventually we should pull this out into a solver struct and keep it
+       updated as we connect squares. For now we recreate it every time we try
+       this particular solver step. */
+    dsf = snewn(w*h, int);
+    dsf_init(dsf, w*h);
+
+    /* Work out the connectedness of the current loop set. */
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            i = y*w + x;
+            if (x < (w-1) && S_E_DIRS(state, x, y, E_TRACK) & R) {
+                /* connection to the right... */
+                j = y*w + (x+1);
+                assert(i < w*h && j < w*h);
+                dsf_merge(dsf, i, j);
+            }
+            if (y < (h-1) && S_E_DIRS(state, x, y, E_TRACK) & D) {
+                /* connection down... */
+                j = (y+1)*w + x;
+                assert(i < w*h && j < w*h);
+                dsf_merge(dsf, i, j);
+            }
+            /* NB no need to check up and left because they'll have been checked
+               by the other side. */
+        }
+    }
+
+    startc = dsf_canonify(dsf, state->numbers->row_s*w);
+    endc = dsf_canonify(dsf, (h-1)*w+state->numbers->col_s);
+
+    /* Now look at all adjacent squares that are both S_TRACK: if connecting
+       any of them would complete a loop (i.e. they're both the same dsf class
+       already) then that edge must be NOTRACK. */
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            if (x < (w-1))
+              did += solve_check_loop_sub(state, x, y, R, dsf, startc, endc);
+            if (y < (h-1))
+              did += solve_check_loop_sub(state, x, y, D, dsf, startc, endc);
+        }
+    }
+
+    sfree(dsf);
+
+    return did;
+}
+
+static void solve_discount_edge(game_state *state, int x, int y, int d)
+{
+    if (S_E_DIRS(state, x, y, E_TRACK) & d) {
+        assert(state->sflags[y*state->p.w + x] & S_CLUE);
+        return; /* (only) clue squares can have outer edges set. */
+    }
+    solve_set_eflag(state, x, y, d, E_NOTRACK, "outer edge");
+}
+
+static int tracks_solve(game_state *state, int diff)
+{
+    int didsth, x, y, w = state->p.w, h = state->p.h;
+
+    debug(("solve..."));
+    state->impossible = FALSE;
+
+    /* Set all the outer border edges as no-track. */
+    for (x = 0; x < w; x++) {
+        solve_discount_edge(state, x, 0, U);
+        solve_discount_edge(state, x, h-1, D);
+    }
+    for (y = 0; y < h; y++) {
+        solve_discount_edge(state, 0, y, L);
+        solve_discount_edge(state, w-1, y, R);
+    }
+
+    while (1) {
+        didsth = 0;
+
+        didsth += solve_update_flags(state);
+        didsth += solve_count_clues(state);
+        didsth += solve_check_loop(state);
+
+        if (diff >= DIFF_TRICKY) {
+            didsth += solve_check_single(state);
+            didsth += solve_check_loose_ends(state);
+        }
+
+        if (!didsth || state->impossible) break;
+    }
+
+    return state->impossible ? -1 : check_completion(state, FALSE) ? 1 : 0;
+}
+
+static char *move_string_diff(const game_state *before, const game_state *after, int issolve)
+{
+    int w = after->p.w, h = after->p.h, i, j;
+    char *move = snewn(w*h*40, char), *p = move;
+    const char *sep = "";
+    unsigned int otf, ntf, onf, nnf;
+
+    if (issolve) {
+        *p++ = 'S';
+        sep = ";";
+    }
+    for (i = 0; i < w*h; i++) {
+        otf = S_E_DIRS(before, i%w, i/w, E_TRACK);
+        ntf = S_E_DIRS(after, i%w, i/w, E_TRACK);
+        onf = S_E_DIRS(before, i%w, i/w, E_NOTRACK);
+        nnf = S_E_DIRS(after, i%w, i/w, E_NOTRACK);
+
+        for (j = 0; j < 4; j++) {
+            unsigned df = 1<<j;
+            if ((otf & df) != (ntf & df)) {
+                p += sprintf(p, "%s%c%c%d,%d", sep,
+                             (ntf & df) ? 'T' : 't', MOVECHAR(df), i%w, i/w);
+                sep = ";";
+            }
+            if ((onf & df) != (nnf & df)) {
+                p += sprintf(p, "%s%c%c%d,%d", sep,
+                             (nnf & df) ? 'N' : 'n', MOVECHAR(df), i%w, i/w);
+                sep = ";";
+            }
+        }
+
+        if ((before->sflags[i] & S_NOTRACK) != (after->sflags[i] & S_NOTRACK)) {
+            p += sprintf(p, "%s%cS%d,%d", sep,
+                         (after->sflags[i] & S_NOTRACK) ? 'N' : 'n', i%w, i/w);
+            sep = ";";
+        }
+        if ((before->sflags[i] & S_TRACK) != (after->sflags[i] & S_TRACK)) {
+            p += sprintf(p, "%s%cS%d,%d", sep,
+                         (after->sflags[i] & S_TRACK) ? 'T' : 't', i%w, i/w);
+            sep = ";";
+        }
+    }
+    *p++ = '\0';
+    move = sresize(move, p - move, char);
+
+    return move;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    game_state *solved;
+    int ret;
+    char *move;
+
+    solved = dup_game(currstate);
+    ret = tracks_solve(solved, DIFFCOUNT);
+    if (ret < 1) {
+        free_game(solved);
+        solved = dup_game(state);
+        ret = tracks_solve(solved, DIFFCOUNT);
+    }
+
+    if (ret < 1) {
+        *error = "Unable to find solution";
+        move = NULL;
+    } else {
+        move = move_string_diff(currstate, solved, TRUE);
+    }
+
+    free_game(solved);
+    return move;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    char *ret, *p;
+    int x, y, len, w = state->p.w, h = state->p.h;
+
+    len = ((w*2) + 4) * ((h*2)+4) + 2;
+    ret = snewn(len+1, char);
+    p = ret;
+
+    /* top line: column clues */
+    *p++ = ' ';
+    *p++ = ' ';
+    for (x = 0; x < w; x++) {
+        *p++ = (state->numbers->numbers[x] < 10 ?
+                '0' + state->numbers->numbers[x] :
+                'A' + state->numbers->numbers[x] - 10);
+        *p++ = ' ';
+    }
+    *p++ = '\n';
+
+    /* second line: top edge */
+    *p++ = ' ';
+    *p++ = '+';
+    for (x = 0; x < w*2-1; x++)
+        *p++ = '-';
+    *p++ = '+';
+    *p++ = '\n';
+
+    /* grid rows: one line of squares, one line of edges. */
+    for (y = 0; y < h; y++) {
+        /* grid square line */
+        *p++ = (y == state->numbers->row_s) ? 'A' : ' ';
+        *p++ = (y == state->numbers->row_s) ? '-' : '|';
+
+        for (x = 0; x < w; x++) {
+            unsigned int f = S_E_DIRS(state, x, y, E_TRACK);
+            if (state->sflags[y*w+x] & S_CLUE) *p++ = 'C';
+            else if (f == LU || f == RD) *p++ = '/';
+            else if (f == LD || f == RU) *p++ = '\\';
+            else if (f == UD) *p++ = '|';
+            else if (f == RL) *p++ = '-';
+            else if (state->sflags[y*w+x] & S_NOTRACK) *p++ = 'x';
+            else *p++ = ' ';
+
+            if (x < w-1) {
+                *p++ = (f & R) ? '-' : ' ';
+            } else
+                *p++ = '|';
+        }
+        *p++ = (state->numbers->numbers[w+y] < 10 ?
+                '0' + state->numbers->numbers[w+y] :
+                'A' + state->numbers->numbers[w+y] - 10);
+        *p++ = '\n';
+
+        if (y == h-1) continue;
+
+        /* edges line */
+        *p++ = ' ';
+        *p++ = '|';
+        for (x = 0; x < w; x++) {
+            unsigned int f = S_E_DIRS(state, x, y, E_TRACK);
+            *p++ = (f & D) ? '|' : ' ';
+            *p++ = (x < w-1) ? ' ' : '|';
+        }
+        *p++ = '\n';
+    }
+
+    /* next line: bottom edge */
+    *p++ = ' ';
+    *p++ = '+';
+    for (x = 0; x < w*2-1; x++)
+        *p++ = (x == state->numbers->col_s*2) ? '|' : '-';
+    *p++ = '+';
+    *p++ = '\n';
+
+    /* final line: bottom clue */
+    *p++ = ' ';
+    *p++ = ' ';
+    for (x = 0; x < w*2-1; x++)
+        *p++ = (x == state->numbers->col_s*2) ? 'B' : ' ';
+    *p++ = '\n';
+
+    *p = '\0';
+    return ret;
+}
+
+static void debug_state(game_state *state, const char *what) {
+    char *sstring = game_text_format(state);
+    debug(("%s: %s", what, sstring));
+    sfree(sstring);
+}
+
+static void dsf_update_completion(game_state *state, int ax, int ay,
+                                  char dir, int *dsf)
+{
+    int w = state->p.w, ai = ay*w+ax, bx, by, bi;
+
+    if (!(S_E_DIRS(state, ax, ay, E_TRACK) & dir)) return;
+    bx = ax + DX(dir);
+    by = ay + DY(dir);
+
+    if (!INGRID(state, bx, by)) return;
+    bi = by*w+bx;
+
+    dsf_merge(dsf, ai, bi);
+}
+
+struct tracks_neighbour_ctx {
+    game_state *state;
+    int i, n, neighbours[4];
+};
+static int tracks_neighbour(int vertex, void *vctx)
+{
+    struct tracks_neighbour_ctx *ctx = (struct tracks_neighbour_ctx *)vctx;
+    if (vertex >= 0) {
+        game_state *state = ctx->state;
+        int w = state->p.w, x = vertex % w, y = vertex / w;
+        int dirs = S_E_DIRS(state, x, y, E_TRACK);
+        int j;
+
+        ctx->i = ctx->n = 0;
+
+        for (j = 0; j < 4; j++) {
+            int dir = 1<<j;
+            if (dirs & dir) {
+                int nx = x + DX(dir), ny = y + DY(dir);
+                if (INGRID(state, nx, ny))
+                    ctx->neighbours[ctx->n++] = ny * w + nx;
+            }
+        }
+    }
+
+    if (ctx->i < ctx->n)
+        return ctx->neighbours[ctx->i++];
+    else
+        return -1;
+}
+
+static int check_completion(game_state *state, int mark)
+{
+    int w = state->p.w, h = state->p.h, x, y, i, target, ret = TRUE;
+    int ntrack, nnotrack, ntrackcomplete;
+    int *dsf, pathclass;
+    struct findloopstate *fls;
+    struct tracks_neighbour_ctx ctx;
+
+    if (mark) {
+        for (i = 0; i < w+h; i++) {
+            state->num_errors[i] = 0;
+        }
+        for (i = 0; i < w*h; i++) {
+            state->sflags[i] &= ~S_ERROR;
+            if (S_E_COUNT(state, i%w, i/w, E_TRACK) > 0) {
+                if (S_E_COUNT(state, i%w, i/w, E_TRACK) > 2) {
+                    ret = FALSE;
+                    state->sflags[i] |= S_ERROR;
+                }
+            }
+        }
+    }
+
+    /* A cell is 'complete', for the purposes of marking the game as
+     * finished, if it has two edges marked as TRACK. But it only has
+     * to have one edge marked as TRACK, or be filled in as trackful
+     * without any specific edges known, to count towards checking
+     * row/column clue errors. */
+    for (x = 0; x < w; x++) {
+        target = state->numbers->numbers[x];
+        ntrack = nnotrack = ntrackcomplete = 0;
+        for (y = 0; y < h; y++) {
+            if (S_E_COUNT(state, x, y, E_TRACK) > 0 ||
+                state->sflags[y*w+x] & S_TRACK)
+                ntrack++;
+            if (S_E_COUNT(state, x, y, E_TRACK) == 2)
+                ntrackcomplete++;
+            if (state->sflags[y*w+x] & S_NOTRACK)
+                nnotrack++;
+        }
+        if (mark) {
+            if (ntrack > target || nnotrack > (h-target)) {
+                debug(("col %d error: target %d, track %d, notrack %d",
+                       x, target, ntrack, nnotrack));
+                state->num_errors[x] = 1;
+                ret = FALSE;
+            }
+        }
+        if (ntrackcomplete != target)
+            ret = FALSE;
+    }
+    for (y = 0; y < h; y++) {
+        target = state->numbers->numbers[w+y];
+        ntrack = nnotrack = ntrackcomplete = 0;
+        for (x = 0; x < w; x++) {
+            if (S_E_COUNT(state, x, y, E_TRACK) > 0 ||
+                state->sflags[y*w+x] & S_TRACK)
+                ntrack++;
+            if (S_E_COUNT(state, x, y, E_TRACK) == 2)
+                ntrackcomplete++;
+            if (state->sflags[y*w+x] & S_NOTRACK)
+                nnotrack++;
+        }
+        if (mark) {
+            if (ntrack > target || nnotrack > (w-target)) {
+                debug(("row %d error: target %d, track %d, notrack %d",
+                       y, target, ntrack, nnotrack));
+                state->num_errors[w+y] = 1;
+                ret = FALSE;
+            }
+        }
+        if (ntrackcomplete != target)
+            ret = FALSE;
+    }
+
+    dsf = snewn(w*h, int);
+    dsf_init(dsf, w*h);
+
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            dsf_update_completion(state, x, y, R, dsf);
+            dsf_update_completion(state, x, y, D, dsf);
+        }
+    }
+
+    fls = findloop_new_state(w*h);
+    ctx.state = state;
+    if (findloop_run(fls, w*h, tracks_neighbour, &ctx)) {
+        debug(("loop detected, not complete"));
+        ret = FALSE; /* no loop allowed */
+        if (mark) {
+            for (x = 0; x < w; x++) {
+                for (y = 0; y < h; y++) {
+                    int u, v;
+
+                    u = y*w + x;
+                    for (v = tracks_neighbour(u, &ctx); v >= 0;
+                         v = tracks_neighbour(-1, &ctx))
+                        if (findloop_is_loop_edge(fls, u, v))
+                            state->sflags[y*w+x] |= S_ERROR;
+                }
+            }
+        }
+    }
+    findloop_free_state(fls);
+
+    if (mark) {
+        pathclass = dsf_canonify(dsf, state->numbers->row_s*w);
+        if (pathclass == dsf_canonify(dsf, (h-1)*w + state->numbers->col_s)) {
+            /* We have a continuous path between the entrance and the exit: any
+               other path must be in error. */
+            for (i = 0; i < w*h; i++) {
+                if ((dsf_canonify(dsf, i) != pathclass) &&
+                    ((state->sflags[i] & S_TRACK) ||
+                     (S_E_COUNT(state, i%w, i/w, E_TRACK) > 0))) {
+                    ret = FALSE;
+                    state->sflags[i] |= S_ERROR;
+                }
+            }
+        } else {
+            /* If we _don't_ have such a path, then certainly the game
+             * can't be in a winning state. So even if we're not
+             * highlighting any _errors_, we certainly shouldn't
+             * return true. */
+            ret = FALSE;
+        }
+    }
+
+    if (mark)
+        state->completed = ret;
+    sfree(dsf);
+    return ret;
+}
+
+/* Code borrowed from Pearl. */
+
+struct game_ui {
+    int dragging, clearing, notrack;
+    int drag_sx, drag_sy, drag_ex, drag_ey; /* drag start and end grid coords */
+    int clickx, clicky;    /* pixel position of initial click */
+
+    int curx, cury;        /* grid position of keyboard cursor; uses half-size grid */
+    int cursor_active;     /* TRUE iff cursor is shown */
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->clearing = ui->notrack = ui->dragging = 0;
+    ui->drag_sx = ui->drag_sy = ui->drag_ex = ui->drag_ey = -1;
+    ui->cursor_active = FALSE;
+    ui->curx = ui->cury = 1;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+#define PREFERRED_TILE_SIZE 30
+#define HALFSZ (ds->sz6*3)
+#define THIRDSZ (ds->sz6*2)
+#define TILE_SIZE (ds->sz6*6)
+
+#define BORDER (TILE_SIZE/8)
+#define BORDER_WIDTH (max(TILE_SIZE / 32, 1))
+
+#define COORD(x) ( (x+1) * TILE_SIZE + BORDER )
+#define CENTERED_COORD(x) ( COORD(x) + TILE_SIZE/2 )
+#define FROMCOORD(x) ( ((x) < BORDER) ? -1 : ( ((x) - BORDER) / TILE_SIZE) - 1 )
+
+#define DS_DSHIFT 4     /* R/U/L/D shift, for drag-in-progress flags */
+
+#define DS_ERROR (1 << 8)
+#define DS_CLUE (1 << 9)
+#define DS_NOTRACK (1 << 10)
+#define DS_FLASH (1 << 11)
+#define DS_CURSOR (1 << 12) /* cursor in square (centre, or on edge) */
+#define DS_TRACK (1 << 13)
+#define DS_CLEARING (1 << 14)
+
+#define DS_NSHIFT 16    /* R/U/L/D shift, for no-track edge flags */
+#define DS_CSHIFT 20    /* R/U/L/D shift, for cursor-on-edge */
+
+struct game_drawstate {
+    int sz6;
+    int started;
+
+    int w, h, sz;
+    unsigned int *flags, *flags_drag;
+    int *num_errors;
+};
+
+static void update_ui_drag(const game_state *state, game_ui *ui, int gx, int gy)
+{
+    int w = state->p.w, h = state->p.h;
+    int dx = abs(ui->drag_sx - gx), dy = abs(ui->drag_sy - gy);
+
+    if (dy == 0) {
+        ui->drag_ex = gx < 0 ? 0 : gx >= w ? w-1 : gx;
+        ui->drag_ey = ui->drag_sy;
+        ui->dragging = TRUE;
+    } else if (dx == 0) {
+        ui->drag_ex = ui->drag_sx;
+        ui->drag_ey = gy < 0 ? 0 : gy >= h ? h-1 : gy;
+        ui->dragging = TRUE;
+    } else {
+        ui->drag_ex = ui->drag_sx;
+        ui->drag_ey = ui->drag_sy;
+        ui->dragging = FALSE;
+    }
+}
+
+static int ui_can_flip_edge(const game_state *state, int x, int y, int dir,
+                            int notrack)
+{
+    int w = state->p.w /*, h = state->shared->h, sz = state->shared->sz */;
+    int x2 = x + DX(dir);
+    int y2 = y + DY(dir);
+    unsigned int sf1, sf2, ef;
+
+    if (!INGRID(state, x, y) || !INGRID(state, x2, y2))
+        return FALSE;
+
+    sf1 = state->sflags[y*w + x];
+    sf2 = state->sflags[y2*w + x2];
+    if ( !notrack && ((sf1 & S_CLUE) || (sf2 & S_CLUE)) )
+        return FALSE;
+
+    ef = S_E_FLAGS(state, x, y, dir);
+    if (notrack) {
+      /* if we're going to _set_ NOTRACK (i.e. the flag is currently unset),
+         make sure the edge is not already set to TRACK. The adjacent squares
+         could be set to TRACK, because we don't know which edges the general
+         square setting refers to. */
+      if (!(ef & E_NOTRACK) && (ef & E_TRACK))
+          return FALSE;
+    } else {
+      if (!(ef & E_TRACK)) {
+          /* if we're going to _set_ TRACK, make sure neither adjacent square nor
+             the edge itself is already set to NOTRACK. */
+          if ((sf1 & S_NOTRACK) || (sf2 & S_NOTRACK) || (ef & E_NOTRACK))
+              return FALSE;
+          /* if we're going to _set_ TRACK, make sure neither adjacent square has
+             2 track flags already.  */
+          if ((S_E_COUNT(state, x, y, E_TRACK) >= 2) ||
+              (S_E_COUNT(state, x2, y2, E_TRACK) >= 2))
+              return FALSE;
+          }
+    }
+    return TRUE;
+}
+
+static int ui_can_flip_square(const game_state *state, int x, int y, int notrack)
+{
+    int w = state->p.w, trackc;
+    unsigned sf;
+
+    if (!INGRID(state, x, y)) return FALSE;
+    sf = state->sflags[y*w+x];
+    trackc = S_E_COUNT(state, x, y, E_TRACK);
+
+    if (sf & S_CLUE) return FALSE;
+
+    if (notrack) {
+        /* If we're setting S_NOTRACK, we cannot have either S_TRACK or any E_TRACK. */
+        if (!(sf & S_NOTRACK) && ((sf & S_TRACK) || (trackc > 0)))
+            return FALSE;
+    } else {
+        /* If we're setting S_TRACK, we cannot have any S_NOTRACK (we could have
+          E_NOTRACK, though, because one or two wouldn't rule out a track) */
+        if (!(sf & S_TRACK) && (sf & S_NOTRACK))
+            return FALSE;
+    }
+    return TRUE;
+}
+
+static char *edge_flip_str(const game_state *state, int x, int y, int dir, int notrack, char *buf) {
+    unsigned ef = S_E_FLAGS(state, x, y, dir);
+    char c;
+
+    if (notrack)
+        c = (ef & E_NOTRACK) ? 'n' : 'N';
+    else
+        c = (ef & E_TRACK) ? 't' : 'T';
+
+    sprintf(buf, "%c%c%d,%d", c, MOVECHAR(dir), x, y);
+    return dupstr(buf);
+}
+
+static char *square_flip_str(const game_state *state, int x, int y, int notrack, char *buf) {
+    unsigned f = state->sflags[y*state->p.w+x];
+    char c;
+
+    if (notrack)
+        c = (f & E_NOTRACK) ? 'n' : 'N';
+    else
+        c = (f & E_TRACK) ? 't' : 'T';
+
+    sprintf(buf, "%cS%d,%d", c, x, y);
+    return dupstr(buf);
+}
+
+#define SIGN(x) ((x<0) ? -1 : (x>0))
+
+static game_state *copy_and_apply_drag(const game_state *state, const game_ui *ui)
+{
+    game_state *after = dup_game(state);
+    int x1, y1, x2, y2, x, y, w = state->p.w;
+    unsigned f = ui->notrack ? S_NOTRACK : S_TRACK, ff;
+
+    x1 = min(ui->drag_sx, ui->drag_ex); x2 = max(ui->drag_sx, ui->drag_ex);
+    y1 = min(ui->drag_sy, ui->drag_ey); y2 = max(ui->drag_sy, ui->drag_ey);
+
+    /* actually either x1 == x2, or y1 == y2, but it's easier just to code
+       the nested loop. */
+    for (x = x1; x <= x2; x++) {
+        for (y = y1; y <= y2; y++) {
+            ff = state->sflags[y*w+x];
+            if (ui->clearing && !(ff & f))
+                continue; /* nothing to do, clearing and already clear */
+            else if (!ui->clearing && (ff & f))
+                continue; /* nothing to do, setting and already set */
+            else if (ui_can_flip_square(state, x, y, ui->notrack))
+                after->sflags[y*w+x] ^= f;
+        }
+    }
+    return after;
+}
+
+#define KEY_DIRECTION(btn) (\
+    (btn) == CURSOR_DOWN ? D : (btn) == CURSOR_UP ? U :\
+    (btn) == CURSOR_LEFT ? L : R)
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->p.w, h = state->p.h, direction;
+    int gx = FROMCOORD(x), gy = FROMCOORD(y);
+    char tmpbuf[80];
+
+    /* --- mouse operations --- */
+
+    if (IS_MOUSE_DOWN(button)) {
+        ui->cursor_active = FALSE;
+        ui->dragging = FALSE;
+
+        if (!INGRID(state, gx, gy)) {
+            /* can't drag from off grid */
+            return NULL;
+        }
+
+        if (button == RIGHT_BUTTON) {
+            ui->notrack = TRUE;
+            ui->clearing = state->sflags[gy*w+gx] & S_NOTRACK;
+        } else {
+            ui->notrack = FALSE;
+            ui->clearing = state->sflags[gy*w+gx] & S_TRACK;
+        }
+
+        ui->clickx = x;
+        ui->clicky = y;
+        ui->drag_sx = ui->drag_ex = gx;
+        ui->drag_sy = ui->drag_ey = gy;
+
+        return "";
+    }
+
+    if (IS_MOUSE_DRAG(button)) {
+        ui->cursor_active = FALSE;
+        update_ui_drag(state, ui, gx, gy);
+        return "";
+    }
+
+    if (IS_MOUSE_RELEASE(button)) {
+        ui->cursor_active = FALSE;
+        if (ui->dragging &&
+            (ui->drag_sx != ui->drag_ex || ui->drag_sy != ui->drag_ey)) {
+            game_state *dragged = copy_and_apply_drag(state, ui);
+            char *ret = move_string_diff(state, dragged, FALSE);
+
+            ui->dragging = 0;
+            free_game(dragged);
+
+            return ret;
+        } else {
+            int cx, cy;
+
+            /* We might still have been dragging (and just done a one-
+             * square drag): cancel drag, so undo doesn't make it like
+             * a drag-in-progress. */
+            ui->dragging = 0;
+
+            /* Click (or tiny drag). Work out which edge we were
+             * closest to. */
+
+            /*
+             * We process clicks based on the mouse-down location,
+             * because that's more natural for a user to carefully
+             * control than the mouse-up.
+             */
+            x = ui->clickx;
+            y = ui->clicky;
+
+            cx = CENTERED_COORD(gx);
+            cy = CENTERED_COORD(gy);
+
+            if (!INGRID(state, gx, gy) || FROMCOORD(x) != gx || FROMCOORD(y) != gy)
+                return "";
+
+            if (max(abs(x-cx),abs(y-cy)) < TILE_SIZE/4) {
+                if (ui_can_flip_square(state, gx, gy, button == RIGHT_RELEASE))
+                    return square_flip_str(state, gx, gy, button == RIGHT_RELEASE, tmpbuf);
+                return "";
+            } else {
+                if (abs(x-cx) < abs(y-cy)) {
+                    /* Closest to top/bottom edge. */
+                    direction = (y < cy) ? U : D;
+                } else {
+                    /* Closest to left/right edge. */
+                    direction = (x < cx) ? L : R;
+                }
+                if (ui_can_flip_edge(state, gx, gy, direction,
+                        button == RIGHT_RELEASE))
+                    return edge_flip_str(state, gx, gy, direction,
+                            button == RIGHT_RELEASE, tmpbuf);
+                else
+                    return "";
+            }
+        }
+    }
+
+    /* --- cursor/keyboard operations --- */
+
+    if (IS_CURSOR_MOVE(button)) {
+        int dx = (button == CURSOR_LEFT) ? -1 : ((button == CURSOR_RIGHT) ? +1 : 0);
+        int dy = (button == CURSOR_DOWN) ? +1 : ((button == CURSOR_UP)    ? -1 : 0);
+
+        if (!ui->cursor_active) {
+            ui->cursor_active = TRUE;
+            return "";
+        }
+
+        ui->curx = ui->curx + dx;
+        ui->cury = ui->cury + dy;
+        if ((ui->curx % 2 == 0) && (ui->cury % 2 == 0)) {
+            /* disallow cursor on square corners: centres and edges only */
+            ui->curx += dx; ui->cury += dy;
+        }
+        ui->curx = min(max(ui->curx, 1), 2*w-1);
+        ui->cury = min(max(ui->cury, 1), 2*h-1);
+        return "";
+    }
+
+    if (IS_CURSOR_SELECT(button)) {
+        if (!ui->cursor_active) {
+            ui->cursor_active = TRUE;
+            return "";
+        }
+        /* click on square corner does nothing (shouldn't get here) */
+        if ((ui->curx % 2) == 0 && (ui->cury % 2 == 0))
+            return "";
+
+        gx = ui->curx / 2;
+        gy = ui->cury / 2;
+        direction = ((ui->curx % 2) == 0) ? L : ((ui->cury % 2) == 0) ? U : 0;
+
+        if (direction &&
+            ui_can_flip_edge(state, gx, gy, direction, button == CURSOR_SELECT2))
+            return edge_flip_str(state, gx, gy, direction, button == CURSOR_SELECT2, tmpbuf);
+        else if (!direction &&
+                 ui_can_flip_square(state, gx, gy, button == CURSOR_SELECT2))
+            return square_flip_str(state, gx, gy, button == CURSOR_SELECT2, tmpbuf);
+        return "";
+    }
+
+#if 0
+    /* helps to debug the solver */
+    if (button == 'H' || button == 'h')
+        return dupstr("H");
+#endif
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int w = state->p.w, x, y, n, i;
+    char c, d;
+    unsigned f;
+    game_state *ret = dup_game(state);
+
+    /* this is breaking the bank on GTK, which vsprintf's into a fixed-size buffer
+     * which is 4096 bytes long. vsnprintf needs a feature-test macro to use, faff. */
+    /*debug(("move: %s\n", move));*/
+
+    while (*move) {
+        c = *move;
+        if (c == 'S') {
+            ret->used_solve = TRUE;
+            move++;
+        } else if (c == 'T' || c == 't' || c == 'N' || c == 'n') {
+            /* set track, clear track; set notrack, clear notrack */
+            move++;
+            if (sscanf(move, "%c%d,%d%n", &d, &x, &y, &n) != 3)
+                goto badmove;
+            if (!INGRID(state, x, y)) goto badmove;
+
+            f = (c == 'T' || c == 't') ? S_TRACK : S_NOTRACK;
+
+            if (d == 'S') {
+                if (c == 'T' || c == 'N')
+                    ret->sflags[y*w+x] |= f;
+                else
+                    ret->sflags[y*w+x] &= ~f;
+            } else if (d == 'U' || d == 'D' || d == 'L' || d == 'R') {
+                for (i = 0; i < 4; i++) {
+                    unsigned df = 1<<i;
+
+                    if (MOVECHAR(df) == d) {
+                        if (c == 'T' || c == 'N')
+                            S_E_SET(ret, x, y, df, f);
+                        else
+                            S_E_CLEAR(ret, x, y, df, f);
+                    }
+                }
+            } else
+                goto badmove;
+            move += n;
+        } else if (c == 'H') {
+            tracks_solve(ret, DIFFCOUNT);
+            move++;
+        } else {
+            goto badmove;
+        }
+        if (*move == ';')
+            move++;
+        else if (*move)
+            goto badmove;
+    }
+
+    check_completion(ret, TRUE);
+
+    return ret;
+
+    badmove:
+    free_game(ret);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define FLASH_TIME 0.5F
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct {
+        int sz6;
+    } ads, *ds = &ads;
+    ads.sz6 = tilesize/6;
+
+    *x = (params->w+2) * TILE_SIZE + 2 * BORDER;
+    *y = (params->h+2) * TILE_SIZE + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->sz6 = tilesize/6;
+}
+
+enum {
+    COL_BACKGROUND, COL_LOWLIGHT, COL_HIGHLIGHT,
+    COL_TRACK_BACKGROUND = COL_LOWLIGHT,
+    COL_GRID, COL_CLUE, COL_CURSOR,
+    COL_TRACK, COL_TRACK_CLUE, COL_SLEEPER,
+    COL_DRAGON, COL_DRAGOFF,
+    COL_ERROR, COL_FLASH,
+    NCOLOURS
+};
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_TRACK_CLUE * 3 + i] = 0.0F;
+        ret[COL_TRACK * 3 + i] = 0.5F;
+        ret[COL_CLUE * 3 + i] = 0.0F;
+        ret[COL_GRID * 3 + i] = 0.75F;
+        ret[COL_CURSOR * 3 + i] = 0.6F;
+    }
+
+    ret[COL_SLEEPER * 3 + 0] = 0.5F;
+    ret[COL_SLEEPER * 3 + 1] = 0.4F;
+    ret[COL_SLEEPER * 3 + 2] = 0.1F;
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_DRAGON * 3 + 0] = 0.0F;
+    ret[COL_DRAGON * 3 + 1] = 0.0F;
+    ret[COL_DRAGON * 3 + 2] = 1.0F;
+
+    ret[COL_DRAGOFF * 3 + 0] = 0.8F;
+    ret[COL_DRAGOFF * 3 + 1] = 0.8F;
+    ret[COL_DRAGOFF * 3 + 2] = 1.0F;
+
+    ret[COL_FLASH * 3 + 0] = 1.0F;
+    ret[COL_FLASH * 3 + 1] = 1.0F;
+    ret[COL_FLASH * 3 + 2] = 1.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->sz6 = 0;
+    ds->started = FALSE;
+
+    ds->w = state->p.w;
+    ds->h = state->p.h;
+    ds->sz = ds->w*ds->h;
+    ds->flags = snewn(ds->sz, unsigned int);
+    ds->flags_drag = snewn(ds->sz, unsigned int);
+    for (i = 0; i < ds->sz; i++)
+        ds->flags[i] = ds->flags_drag[i] = 0;
+
+    ds->num_errors = snewn(ds->w+ds->h, int);
+    for (i = 0; i < ds->w+ds->h; i++)
+        ds->num_errors[i] = 0;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->flags);
+    sfree(ds->flags_drag);
+    sfree(ds->num_errors);
+    sfree(ds);
+}
+
+static void draw_circle_sleepers(drawing *dr, game_drawstate *ds,
+                                 float cx, float cy, float r2, float thickness, int c)
+{
+    float qr6 = (float)PI/12, qr3 = (float)PI/6, th, x1, y1, x2, y2;
+    float t6 = THIRDSZ/2.0F, r1 = t6;
+    int i;
+
+    for (i = 0; i < 12; i++) {
+        th = qr6 + (i*qr3);
+        x1 = r1*(float)cos(th);
+        x2 = r2*(float)cos(th);
+        y1 = r1*(float)sin(th);
+        y2 = r2*(float)sin(th);
+        draw_thick_line(dr, thickness, cx+x1, cy+y1, cx+x2, cy+y2, c);
+    }
+}
+
+static void draw_thick_circle_outline(drawing *dr, float thickness,
+                                      float cx, float cy, float r,
+                                      int colour)
+{
+    float circ4 = 0.5F * (float)PI * r, ang, x1, y1, x2, y2;
+    int i, nseg;
+
+    nseg = (int)(circ4 / 4.0F)*4; /* ensure a quarter-circle has a whole #segs */
+    ang = 2.0F*(float)PI / nseg;
+
+    for (i = 0; i < nseg; i++) {
+        float th = ang * i, th2 = ang * (i+1);
+        x1 = cx + r*(float)cos(th);
+        x2 = cx + r*(float)cos(th2);
+        y1 = cy + r*(float)sin(th);
+        y2 = cy + r*(float)sin(th2);
+        debug(("circ outline: x=%.2f -> %.2f, thick=%.2f", x1, x2, thickness));
+        draw_thick_line(dr, thickness, x1, y1, x2, y2, colour);
+    }
+}
+
+static void draw_tracks_specific(drawing *dr, game_drawstate *ds,
+                                 int x, int y, unsigned int flags,
+                                 int ctrack, int csleeper)
+{
+    float ox = (float)COORD(x), oy = (float)COORD(y), cx, cy;
+    float t1 = (float)TILE_SIZE, t3 = TILE_SIZE/3.0F, t6 = TILE_SIZE/6.0F;
+    int d, i;
+    float thick_track = TILE_SIZE/8.0F, thick_sleeper = TILE_SIZE/12.0F;
+
+    if (flags == LR) {
+        for (i = 1; i <= 7; i+=2) {
+            cx = ox + TILE_SIZE/8.0F*i;
+            draw_thick_line(dr, thick_sleeper,
+                            cx, oy+t6, cx, oy+t6+2*t3, csleeper);
+        }
+        draw_thick_line(dr, thick_track, ox, oy + t3, ox + TILE_SIZE, oy + t3, ctrack);
+        draw_thick_line(dr, thick_track, ox, oy + 2*t3, ox + TILE_SIZE, oy + 2*t3, ctrack);
+        return;
+    }
+    if (flags == UD) {
+        for (i = 1; i <= 7; i+=2) {
+            cy = oy + TILE_SIZE/8.0F*i;
+            draw_thick_line(dr, thick_sleeper,
+                            ox+t6, cy, ox+t6+2*t3, cy, csleeper);
+        }
+        debug(("vert line: x=%.2f, thick=%.2f", ox + t3, thick_track));
+        draw_thick_line(dr, thick_track, ox + t3, oy, ox + t3, oy + TILE_SIZE, ctrack);
+        draw_thick_line(dr, thick_track, ox + 2*t3, oy, ox + 2*t3, oy + TILE_SIZE, ctrack);
+        return;
+    }
+    if (flags == UL || flags == DL || flags == UR || flags == DR) {
+        cx = (flags & L) ? ox : ox + TILE_SIZE;
+        cy = (flags & U) ? oy : oy + TILE_SIZE;
+
+        draw_circle_sleepers(dr, ds, cx, cy, (float)(5*t6), thick_sleeper, csleeper);
+
+        draw_thick_circle_outline(dr, thick_track, (float)cx, (float)cy,
+                                  2*t3, ctrack);
+        draw_thick_circle_outline(dr, thick_track, (float)cx, (float)cy,
+                                  t3, ctrack);
+
+        return;
+    }
+
+    for (d = 1; d < 16; d *= 2) {
+        float ox1 = 0, ox2 = 0, oy1 = 0, oy2 = 0;
+
+        if (!(flags & d)) continue;
+
+        for (i = 1; i <= 2; i++) {
+            if (d == L) {
+                ox1 = 0;
+                ox2 = thick_track;
+                oy1 = oy2 = i*t3;
+            } else if (d == R) {
+                ox1 = t1;
+                ox2 = t1 - thick_track;
+                oy1 = oy2 = i*t3;
+            } else if (d == U) {
+                ox1 = ox2 = i*t3;
+                oy1 = 0;
+                oy2 = thick_track;
+            } else if (d == D) {
+                ox1 = ox2 = i*t3;
+                oy1 = t1;
+                oy2 = t1 - thick_track;
+            }
+            draw_thick_line(dr, thick_track, ox+ox1, oy+oy1, ox+ox2, oy+oy2, ctrack);
+        }
+    }
+}
+
+static unsigned int best_bits(unsigned int flags, unsigned int flags_drag, int *col)
+{
+    int nb_orig = nbits[flags & ALLDIR], nb_drag = nbits[flags_drag & ALLDIR];
+
+    if (nb_orig > nb_drag) {
+        *col = COL_DRAGOFF;
+        return flags & ALLDIR;
+    } else if (nb_orig < nb_drag) {
+        *col = COL_DRAGON;
+        return flags_drag & ALLDIR;
+    }
+    return flags & ALLDIR; /* same number of bits: no special colour. */
+}
+
+static void draw_square(drawing *dr, game_drawstate *ds,
+                        int x, int y, unsigned int flags, unsigned int flags_drag)
+{
+    int t2 = HALFSZ, t16 = HALFSZ/4, off;
+    int ox = COORD(x), oy = COORD(y), cx = ox + t2, cy = oy + t2, d, c;
+    int bg = (flags & DS_TRACK) ? COL_TRACK_BACKGROUND : COL_BACKGROUND;
+    unsigned int flags_best;
+
+    assert(dr);
+
+    /* Clip to the grid square. */
+    clip(dr, ox, oy, TILE_SIZE, TILE_SIZE);
+
+    /* Clear the square. */
+    best_bits((flags & DS_TRACK) == DS_TRACK,
+              (flags_drag & DS_TRACK) == DS_TRACK, &bg);
+    draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE, bg);
+
+    /* Draw outline of grid square */
+    draw_line(dr, ox, oy, COORD(x+1), oy, COL_GRID);
+    draw_line(dr, ox, oy, ox, COORD(y+1), COL_GRID);
+
+    /* More outlines for clue squares. */
+    if (flags & DS_CURSOR) {
+        int curx, cury, curw, curh;
+
+        off = t16;
+        curx = ox + off; cury = oy + off;
+        curw = curh = TILE_SIZE - (2*off) + 1;
+
+        if (flags & (U << DS_CSHIFT)) {
+            cury = oy - off; curh = 2*off + 1;
+        } else if (flags & (D << DS_CSHIFT)) {
+            cury = oy + TILE_SIZE - off; curh = 2*off + 1;
+        } else if (flags & (L << DS_CSHIFT)) {
+            curx = ox - off; curw = 2*off + 1;
+        } else if (flags & (R << DS_CSHIFT)) {
+            curx = ox + TILE_SIZE - off; curw = 2*off + 1;
+        }
+
+        draw_rect_outline(dr, curx, cury, curw, curh, COL_GRID);
+    }
+
+    /* Draw tracks themselves */
+    c = (flags & DS_ERROR) ? COL_ERROR :
+      (flags & DS_FLASH) ? COL_FLASH :
+      (flags & DS_CLUE) ? COL_TRACK_CLUE : COL_TRACK;
+    flags_best = best_bits(flags, flags_drag, &c);
+    draw_tracks_specific(dr, ds, x, y, flags_best, c, COL_SLEEPER);
+
+    /* Draw no-track marks, if present, in square and on edges. */
+    c = COL_TRACK;
+    flags_best = best_bits((flags & DS_NOTRACK) == DS_NOTRACK,
+                           (flags_drag & DS_NOTRACK) == DS_NOTRACK, &c);
+    if (flags_best) {
+        off = HALFSZ/2;
+        draw_line(dr, cx - off, cy - off, cx + off, cy + off, c);
+        draw_line(dr, cx - off, cy + off, cx + off, cy - off, c);
+    }
+
+    c = COL_TRACK;
+    flags_best = best_bits(flags >> DS_NSHIFT, flags_drag >> DS_NSHIFT, &c);
+    for (d = 1; d < 16; d *= 2) {
+        off = t16;
+        cx = ox + t2;
+        cy = oy + t2;
+
+        if (flags_best & d) {
+            cx += (d == R) ? t2 : (d == L) ? -t2 : 0;
+            cy += (d == D) ? t2 : (d == U) ? -t2 : 0;
+
+            draw_line(dr, cx - off, cy - off, cx + off, cy + off, c);
+            draw_line(dr, cx - off, cy + off, cx + off, cy - off, c);
+        }
+    }
+
+    unclip(dr);
+    draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
+}
+
+static void draw_clue(drawing *dr, game_drawstate *ds, int w, int clue, int i, int col)
+{
+    int cx, cy, tsz = TILE_SIZE/2;
+    char buf[20];
+
+    if (i < w) {
+        cx = CENTERED_COORD(i);
+        cy = CENTERED_COORD(-1);
+    } else {
+        cx = CENTERED_COORD(w);
+        cy = CENTERED_COORD(i-w);
+    }
+
+    draw_rect(dr, cx - tsz + BORDER, cy - tsz + BORDER,
+              TILE_SIZE - BORDER, TILE_SIZE - BORDER, COL_BACKGROUND);
+    sprintf(buf, "%d", clue);
+    draw_text(dr, cx, cy, FONT_VARIABLE, tsz, ALIGN_VCENTRE|ALIGN_HCENTRE,
+              col, buf);
+    draw_update(dr, cx - tsz, cy - tsz, TILE_SIZE, TILE_SIZE);
+}
+
+static void draw_loop_ends(drawing *dr, game_drawstate *ds,
+                           const game_state *state, int c)
+{
+    int tsz = TILE_SIZE/2;
+
+    draw_text(dr, CENTERED_COORD(-1), CENTERED_COORD(state->numbers->row_s),
+              FONT_VARIABLE, tsz, ALIGN_VCENTRE|ALIGN_HCENTRE,
+              c, "A");
+
+    draw_text(dr, CENTERED_COORD(state->numbers->col_s), CENTERED_COORD(state->p.h),
+              FONT_VARIABLE, tsz, ALIGN_VCENTRE|ALIGN_HCENTRE,
+              c, "B");
+}
+
+static unsigned int s2d_flags(const game_state *state, int x, int y, const game_ui *ui)
+{
+    unsigned int f;
+    int w = state->p.w;
+
+    f = S_E_DIRS(state, x, y, E_TRACK);
+    f |= (S_E_DIRS(state, x, y, E_NOTRACK) << DS_NSHIFT);
+
+    if (state->sflags[y*w+x] & S_ERROR)
+        f |= DS_ERROR;
+    if (state->sflags[y*w+x] & S_CLUE)
+        f |= DS_CLUE;
+    if (state->sflags[y*w+x] & S_NOTRACK)
+        f |= DS_NOTRACK;
+    if ((state->sflags[y*w+x] & S_TRACK) || (S_E_COUNT(state, x, y, E_TRACK) > 0))
+        f |= DS_TRACK;
+
+    if (ui->cursor_active) {
+        if (ui->curx >= x*2 && ui->curx <= (x+1)*2 &&
+            ui->cury >= y*2 && ui->cury <= (y+1)*2) {
+            f |= DS_CURSOR;
+            if (ui->curx == x*2)        f |= (L << DS_CSHIFT);
+            if (ui->curx == (x+1)*2)    f |= (R << DS_CSHIFT);
+            if (ui->cury == y*2)        f |= (U << DS_CSHIFT);
+            if (ui->cury == (y+1)*2)    f |= (D << DS_CSHIFT);
+        }
+    }
+
+    return f;
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds, const game_state *oldstate,
+                        const game_state *state, int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int i, x, y, force = 0, flashing = 0, w = ds->w, h = ds->h;
+    game_state *drag_state = NULL;
+
+    if (!ds->started) {
+        /*
+         * The initial contents of the window are not guaranteed and
+         * can vary with front ends. To be on the safe side, all games
+         * should start by drawing a big background-colour rectangle
+         * covering the whole window.
+         */
+        draw_rect(dr, 0, 0, (w+2)*TILE_SIZE + 2*BORDER, (h+2)*TILE_SIZE + 2*BORDER,
+                  COL_BACKGROUND);
+
+        draw_loop_ends(dr, ds, state, COL_CLUE);
+
+        draw_line(dr, COORD(ds->w), COORD(0), COORD(ds->w), COORD(ds->h), COL_GRID);
+        draw_line(dr, COORD(0), COORD(ds->h), COORD(ds->w), COORD(ds->h), COL_GRID);
+
+        draw_update(dr, 0, 0, (w+2)*TILE_SIZE + 2*BORDER, (h+2)*TILE_SIZE + 2*BORDER);
+
+        ds->started = TRUE;
+        force = 1;
+    }
+
+    for (i = 0; i < w+h; i++) {
+        if (force || (state->num_errors[i] != ds->num_errors[i])) {
+            ds->num_errors[i] = state->num_errors[i];
+            draw_clue(dr, ds, w, state->numbers->numbers[i], i,
+                      ds->num_errors[i] ? COL_ERROR : COL_CLUE);
+        }
+    }
+
+    if (flashtime > 0 &&
+            (flashtime <= FLASH_TIME/3 ||
+             flashtime >= FLASH_TIME*2/3))
+        flashing = DS_FLASH;
+
+    if (ui->dragging)
+        drag_state = copy_and_apply_drag(state, ui);
+
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            unsigned int f, f_d;
+
+            f = s2d_flags(state, x, y, ui) | flashing;
+            f_d = drag_state ? s2d_flags(drag_state, x, y, ui) : f;
+
+            if (f != ds->flags[y*w+x] || f_d != ds->flags_drag[y*w+x] || force) {
+                ds->flags[y*w+x] = f;
+                ds->flags_drag[y*w+x] = f_d;
+                draw_square(dr, ds, x, y, f, f_d);
+            }
+        }
+    }
+
+    if (drag_state) free_game(drag_state);
+}
+
+static float game_anim_length(const game_state *oldstate, const game_state *newstate,
+                              int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate, const game_state *newstate,
+                               int dir, game_ui *ui)
+{
+    if (!oldstate->completed &&
+            newstate->completed && !newstate->used_solve)
+        return FLASH_TIME;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /* The Times uses 7mm squares */
+    game_compute_size(params, 700, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->p.w, h = state->p.h;
+    int black = print_mono_colour(dr, 0), grey = print_grey_colour(dr, 0.5F);
+    int x, y, i;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    /* Grid, then border (second so it is on top) */
+    print_line_width(dr, TILE_SIZE / 24);
+    for (x = 1; x < w; x++)
+        draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h), grey);
+    for (y = 1; y < h; y++)
+        draw_line(dr, COORD(0), COORD(y), COORD(w), COORD(y), grey);
+
+    print_line_width(dr, TILE_SIZE / 16);
+    draw_rect_outline(dr, COORD(0), COORD(0), w*TILE_SIZE, h*TILE_SIZE, black);
+
+    print_line_width(dr, TILE_SIZE / 24);
+
+    /* clue numbers, and loop ends */
+    for (i = 0; i < w+h; i++)
+        draw_clue(dr, ds, w, state->numbers->numbers[i], i, black);
+    draw_loop_ends(dr, ds, state, black);
+
+    /* clue tracks / solution */
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            clip(dr, COORD(x), COORD(y), TILE_SIZE, TILE_SIZE);
+            draw_tracks_specific(dr, ds, x, y, S_E_DIRS(state, x, y, E_TRACK),
+                                 black, grey);
+            unclip(dr);
+        }
+    }
+}
+
+#ifdef COMBINED
+#define thegame tracks
+#endif
+
+const struct game thegame = {
+    "Train Tracks", "games.tracks", "tracks",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/tree234.c b/apps/plugins/puzzles/tree234.c
new file mode 100644
index 0000000000..71c3be242a
--- /dev/null
+++ b/apps/plugins/puzzles/tree234.c
@@ -0,0 +1,2200 @@
+/*
+ * tree234.c: reasonably generic counted 2-3-4 tree routines.
+ * 
+ * This file is copyright 1999-2001 Simon Tatham.
+ * 
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL SIMON TATHAM BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "rbassert.h"
+
+#include "tree234.h"
+
+#include "puzzles.h"                   /* for smalloc/sfree */
+
+#ifdef TEST
+#define LOG(x) (printf x)
+#define smalloc malloc
+#define srealloc realloc
+#define sfree free
+#else
+#define LOG(x)
+#endif
+
+typedef struct node234_Tag node234;
+
+struct tree234_Tag {
+    node234 *root;
+    cmpfn234 cmp;
+};
+
+struct node234_Tag {
+    node234 *parent;
+    node234 *kids[4];
+    int counts[4];
+    void *elems[3];
+};
+
+/*
+ * Create a 2-3-4 tree.
+ */
+tree234 *newtree234(cmpfn234 cmp) {
+    tree234 *ret = snew(tree234);
+    LOG(("created tree %p\n", ret));
+    ret->root = NULL;
+    ret->cmp = cmp;
+    return ret;
+}
+
+/*
+ * Free a 2-3-4 tree (not including freeing the elements).
+ */
+static void freenode234(node234 *n) {
+    if (!n)
+        return;
+    freenode234(n->kids[0]);
+    freenode234(n->kids[1]);
+    freenode234(n->kids[2]);
+    freenode234(n->kids[3]);
+    sfree(n);
+}
+void freetree234(tree234 *t) {
+    freenode234(t->root);
+    sfree(t);
+}
+
+/*
+ * Internal function to count a node.
+ */
+static int countnode234(node234 *n) {
+    int count = 0;
+    int i;
+    if (!n)
+        return 0;
+    for (i = 0; i < 4; i++)
+        count += n->counts[i];
+    for (i = 0; i < 3; i++)
+        if (n->elems[i])
+            count++;
+    return count;
+}
+
+/*
+ * Count the elements in a tree.
+ */
+int count234(tree234 *t) {
+    if (t->root)
+        return countnode234(t->root);
+    else
+        return 0;
+}
+
+/*
+ * Propagate a node overflow up a tree until it stops. Returns 0 or
+ * 1, depending on whether the root had to be split or not.
+ */
+static int add234_insert(node234 *left, void *e, node234 *right,
+                         node234 **root, node234 *n, int ki) {
+    int lcount, rcount;
+    /*
+     * We need to insert the new left/element/right set in n at
+     * child position ki.
+     */
+    lcount = countnode234(left);
+    rcount = countnode234(right);
+    while (n) {
+        LOG(("  at %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+             n,
+             n->kids[0], n->counts[0], n->elems[0],
+             n->kids[1], n->counts[1], n->elems[1],
+             n->kids[2], n->counts[2], n->elems[2],
+             n->kids[3], n->counts[3]));
+        LOG(("  need to insert %p/%d \"%s\" %p/%d at position %d\n",
+             left, lcount, e, right, rcount, ki));
+        if (n->elems[1] == NULL) {
+            /*
+             * Insert in a 2-node; simple.
+             */
+            if (ki == 0) {
+                LOG(("  inserting on left of 2-node\n"));
+                n->kids[2] = n->kids[1];     n->counts[2] = n->counts[1];
+                n->elems[1] = n->elems[0];
+                n->kids[1] = right;          n->counts[1] = rcount;
+                n->elems[0] = e;
+                n->kids[0] = left;           n->counts[0] = lcount;
+            } else { /* ki == 1 */
+                LOG(("  inserting on right of 2-node\n"));
+                n->kids[2] = right;          n->counts[2] = rcount;
+                n->elems[1] = e;
+                n->kids[1] = left;           n->counts[1] = lcount;
+            }
+            if (n->kids[0]) n->kids[0]->parent = n;
+            if (n->kids[1]) n->kids[1]->parent = n;
+            if (n->kids[2]) n->kids[2]->parent = n;
+            LOG(("  done\n"));
+            break;
+        } else if (n->elems[2] == NULL) {
+            /*
+             * Insert in a 3-node; simple.
+             */
+            if (ki == 0) {
+                LOG(("  inserting on left of 3-node\n"));
+                n->kids[3] = n->kids[2];    n->counts[3] = n->counts[2];
+                n->elems[2] = n->elems[1];
+                n->kids[2] = n->kids[1];    n->counts[2] = n->counts[1];
+                n->elems[1] = n->elems[0];
+                n->kids[1] = right;         n->counts[1] = rcount;
+                n->elems[0] = e;
+                n->kids[0] = left;          n->counts[0] = lcount;
+            } else if (ki == 1) {
+                LOG(("  inserting in middle of 3-node\n"));
+                n->kids[3] = n->kids[2];    n->counts[3] = n->counts[2];
+                n->elems[2] = n->elems[1];
+                n->kids[2] = right;         n->counts[2] = rcount;
+                n->elems[1] = e;
+                n->kids[1] = left;          n->counts[1] = lcount;
+            } else { /* ki == 2 */
+                LOG(("  inserting on right of 3-node\n"));
+                n->kids[3] = right;         n->counts[3] = rcount;
+                n->elems[2] = e;
+                n->kids[2] = left;          n->counts[2] = lcount;
+            }
+            if (n->kids[0]) n->kids[0]->parent = n;
+            if (n->kids[1]) n->kids[1]->parent = n;
+            if (n->kids[2]) n->kids[2]->parent = n;
+            if (n->kids[3]) n->kids[3]->parent = n;
+            LOG(("  done\n"));
+            break;
+        } else {
+            node234 *m = snew(node234);
+            m->parent = n->parent;
+            LOG(("  splitting a 4-node; created new node %p\n", m));
+            /*
+             * Insert in a 4-node; split into a 2-node and a
+             * 3-node, and move focus up a level.
+             * 
+             * I don't think it matters which way round we put the
+             * 2 and the 3. For simplicity, we'll put the 3 first
+             * always.
+             */
+            if (ki == 0) {
+                m->kids[0] = left;          m->counts[0] = lcount;
+                m->elems[0] = e;
+                m->kids[1] = right;         m->counts[1] = rcount;
+                m->elems[1] = n->elems[0];
+                m->kids[2] = n->kids[1];    m->counts[2] = n->counts[1];
+                e = n->elems[1];
+                n->kids[0] = n->kids[2];    n->counts[0] = n->counts[2];
+                n->elems[0] = n->elems[2];
+                n->kids[1] = n->kids[3];    n->counts[1] = n->counts[3];
+            } else if (ki == 1) {
+                m->kids[0] = n->kids[0];    m->counts[0] = n->counts[0];
+                m->elems[0] = n->elems[0];
+                m->kids[1] = left;          m->counts[1] = lcount;
+                m->elems[1] = e;
+                m->kids[2] = right;         m->counts[2] = rcount;
+                e = n->elems[1];
+                n->kids[0] = n->kids[2];    n->counts[0] = n->counts[2];
+                n->elems[0] = n->elems[2];
+                n->kids[1] = n->kids[3];    n->counts[1] = n->counts[3];
+            } else if (ki == 2) {
+                m->kids[0] = n->kids[0];    m->counts[0] = n->counts[0];
+                m->elems[0] = n->elems[0];
+                m->kids[1] = n->kids[1];    m->counts[1] = n->counts[1];
+                m->elems[1] = n->elems[1];
+                m->kids[2] = left;          m->counts[2] = lcount;
+                /* e = e; */
+                n->kids[0] = right;         n->counts[0] = rcount;
+                n->elems[0] = n->elems[2];
+                n->kids[1] = n->kids[3];    n->counts[1] = n->counts[3];
+            } else { /* ki == 3 */
+                m->kids[0] = n->kids[0];    m->counts[0] = n->counts[0];
+                m->elems[0] = n->elems[0];
+                m->kids[1] = n->kids[1];    m->counts[1] = n->counts[1];
+                m->elems[1] = n->elems[1];
+                m->kids[2] = n->kids[2];    m->counts[2] = n->counts[2];
+                n->kids[0] = left;          n->counts[0] = lcount;
+                n->elems[0] = e;
+                n->kids[1] = right;         n->counts[1] = rcount;
+                e = n->elems[2];
+            }
+            m->kids[3] = n->kids[3] = n->kids[2] = NULL;
+            m->counts[3] = n->counts[3] = n->counts[2] = 0;
+            m->elems[2] = n->elems[2] = n->elems[1] = NULL;
+            if (m->kids[0]) m->kids[0]->parent = m;
+            if (m->kids[1]) m->kids[1]->parent = m;
+            if (m->kids[2]) m->kids[2]->parent = m;
+            if (n->kids[0]) n->kids[0]->parent = n;
+            if (n->kids[1]) n->kids[1]->parent = n;
+            LOG(("  left (%p): %p/%d \"%s\" %p/%d \"%s\" %p/%d\n", m,
+                 m->kids[0], m->counts[0], m->elems[0],
+                 m->kids[1], m->counts[1], m->elems[1],
+                 m->kids[2], m->counts[2]));
+            LOG(("  right (%p): %p/%d \"%s\" %p/%d\n", n,
+                 n->kids[0], n->counts[0], n->elems[0],
+                 n->kids[1], n->counts[1]));
+            left = m;  lcount = countnode234(left);
+            right = n; rcount = countnode234(right);
+        }
+        if (n->parent)
+            ki = (n->parent->kids[0] == n ? 0 :
+                  n->parent->kids[1] == n ? 1 :
+                  n->parent->kids[2] == n ? 2 : 3);
+        n = n->parent;
+    }
+
+    /*
+     * If we've come out of here by `break', n will still be
+     * non-NULL and all we need to do is go back up the tree
+     * updating counts. If we've come here because n is NULL, we
+     * need to create a new root for the tree because the old one
+     * has just split into two. */
+    if (n) {
+        while (n->parent) {
+            int count = countnode234(n);
+            int childnum;
+            childnum = (n->parent->kids[0] == n ? 0 :
+                        n->parent->kids[1] == n ? 1 :
+                        n->parent->kids[2] == n ? 2 : 3);
+            n->parent->counts[childnum] = count;
+            n = n->parent;
+        }
+        return 0;                      /* root unchanged */
+    } else {
+        LOG(("  root is overloaded, split into two\n"));
+        (*root) = snew(node234);
+        (*root)->kids[0] = left;     (*root)->counts[0] = lcount;
+        (*root)->elems[0] = e;
+        (*root)->kids[1] = right;    (*root)->counts[1] = rcount;
+        (*root)->elems[1] = NULL;
+        (*root)->kids[2] = NULL;     (*root)->counts[2] = 0;
+        (*root)->elems[2] = NULL;
+        (*root)->kids[3] = NULL;     (*root)->counts[3] = 0;
+        (*root)->parent = NULL;
+        if ((*root)->kids[0]) (*root)->kids[0]->parent = (*root);
+        if ((*root)->kids[1]) (*root)->kids[1]->parent = (*root);
+        LOG(("  new root is %p/%d \"%s\" %p/%d\n",
+             (*root)->kids[0], (*root)->counts[0],
+             (*root)->elems[0],
+             (*root)->kids[1], (*root)->counts[1]));
+        return 1;                      /* root moved */
+    }
+}
+
+/*
+ * Add an element e to a 2-3-4 tree t. Returns e on success, or if
+ * an existing element compares equal, returns that.
+ */
+static void *add234_internal(tree234 *t, void *e, int index) {
+    node234 *n;
+    int ki;
+    void *orig_e = e;
+    int c;
+
+    LOG(("adding element \"%s\" to tree %p\n", e, t));
+    if (t->root == NULL) {
+        t->root = snew(node234);
+        t->root->elems[1] = t->root->elems[2] = NULL;
+        t->root->kids[0] = t->root->kids[1] = NULL;
+        t->root->kids[2] = t->root->kids[3] = NULL;
+        t->root->counts[0] = t->root->counts[1] = 0;
+        t->root->counts[2] = t->root->counts[3] = 0;
+        t->root->parent = NULL;
+        t->root->elems[0] = e;
+        LOG(("  created root %p\n", t->root));
+        return orig_e;
+    }
+
+    n = t->root;
+    while (n) {
+        LOG(("  node %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+             n,
+             n->kids[0], n->counts[0], n->elems[0],
+             n->kids[1], n->counts[1], n->elems[1],
+             n->kids[2], n->counts[2], n->elems[2],
+             n->kids[3], n->counts[3]));
+        if (index >= 0) {
+            if (!n->kids[0]) {
+                /*
+                 * Leaf node. We want to insert at kid position
+                 * equal to the index:
+                 * 
+                 *   0 A 1 B 2 C 3
+                 */
+                ki = index;
+            } else {
+                /*
+                 * Internal node. We always descend through it (add
+                 * always starts at the bottom, never in the
+                 * middle).
+                 */
+                if (index <= n->counts[0]) {
+                    ki = 0;
+                } else if (index -= n->counts[0] + 1, index <= n->counts[1]) {
+                    ki = 1;
+                } else if (index -= n->counts[1] + 1, index <= n->counts[2]) {
+                    ki = 2;
+                } else if (index -= n->counts[2] + 1, index <= n->counts[3]) {
+                    ki = 3;
+                } else
+                    return NULL;       /* error: index out of range */
+            }
+        } else {
+            if ((c = t->cmp(e, n->elems[0])) < 0)
+                ki = 0;
+            else if (c == 0)
+                return n->elems[0];            /* already exists */
+            else if (n->elems[1] == NULL || (c = t->cmp(e, n->elems[1])) < 0)
+                ki = 1;
+            else if (c == 0)
+                return n->elems[1];            /* already exists */
+            else if (n->elems[2] == NULL || (c = t->cmp(e, n->elems[2])) < 0)
+                ki = 2;
+            else if (c == 0)
+                return n->elems[2];            /* already exists */
+            else
+                ki = 3;
+        }
+        LOG(("  moving to child %d (%p)\n", ki, n->kids[ki]));
+        if (!n->kids[ki])
+            break;
+        n = n->kids[ki];
+    }
+
+    add234_insert(NULL, e, NULL, &t->root, n, ki);
+
+    return orig_e;
+}
+
+void *add234(tree234 *t, void *e) {
+    if (!t->cmp)                       /* tree is unsorted */
+        return NULL;
+
+    return add234_internal(t, e, -1);
+}
+void *addpos234(tree234 *t, void *e, int index) {
+    if (index < 0 ||                   /* index out of range */
+        t->cmp)                        /* tree is sorted */
+        return NULL;                   /* return failure */
+
+    return add234_internal(t, e, index);  /* this checks the upper bound */
+}
+
+/*
+ * Look up the element at a given numeric index in a 2-3-4 tree.
+ * Returns NULL if the index is out of range.
+ */
+void *index234(tree234 *t, int index) {
+    node234 *n;
+
+    if (!t->root)
+        return NULL;                   /* tree is empty */
+
+    if (index < 0 || index >= countnode234(t->root))
+        return NULL;                   /* out of range */
+
+    n = t->root;
+    
+    while (n) {
+        if (index < n->counts[0])
+            n = n->kids[0];
+        else if (index -= n->counts[0] + 1, index < 0)
+            return n->elems[0];
+        else if (index < n->counts[1])
+            n = n->kids[1];
+        else if (index -= n->counts[1] + 1, index < 0)
+            return n->elems[1];
+        else if (index < n->counts[2])
+            n = n->kids[2];
+        else if (index -= n->counts[2] + 1, index < 0)
+            return n->elems[2];
+        else
+            n = n->kids[3];
+    }
+
+    /* We shouldn't ever get here. I wonder how we did. */
+    return NULL;
+}
+
+/*
+ * Find an element e in a sorted 2-3-4 tree t. Returns NULL if not
+ * found. e is always passed as the first argument to cmp, so cmp
+ * can be an asymmetric function if desired. cmp can also be passed
+ * as NULL, in which case the compare function from the tree proper
+ * will be used.
+ */
+void *findrelpos234(tree234 *t, void *e, cmpfn234 cmp,
+                    int relation, int *index) {
+    node234 *n;
+    void *ret;
+    int c;
+    int idx, ecount, kcount, cmpret;
+
+    if (t->root == NULL)
+        return NULL;
+
+    if (cmp == NULL)
+        cmp = t->cmp;
+
+    n = t->root;
+    /*
+     * Attempt to find the element itself.
+     */
+    idx = 0;
+    ecount = -1;
+    /*
+     * Prepare a fake `cmp' result if e is NULL.
+     */
+    cmpret = 0;
+    if (e == NULL) {
+        assert(relation == REL234_LT || relation == REL234_GT);
+        if (relation == REL234_LT)
+            cmpret = +1;               /* e is a max: always greater */
+        else if (relation == REL234_GT)
+            cmpret = -1;               /* e is a min: always smaller */
+    }
+    while (1) {
+        for (kcount = 0; kcount < 4; kcount++) {
+            if (kcount >= 3 || n->elems[kcount] == NULL ||
+                (c = cmpret ? cmpret : cmp(e, n->elems[kcount])) < 0) {
+                break;
+            }
+            if (n->kids[kcount]) idx += n->counts[kcount];
+            if (c == 0) {
+                ecount = kcount;
+                break;
+            }
+            idx++;
+        }
+        if (ecount >= 0)
+            break;
+        if (n->kids[kcount])
+            n = n->kids[kcount];
+        else
+            break;
+    }
+
+    if (ecount >= 0) {
+        /*
+         * We have found the element we're looking for. It's
+         * n->elems[ecount], at tree index idx. If our search
+         * relation is EQ, LE or GE we can now go home.
+         */
+        if (relation != REL234_LT && relation != REL234_GT) {
+            if (index) *index = idx;
+            return n->elems[ecount];
+        }
+
+        /*
+         * Otherwise, we'll do an indexed lookup for the previous
+         * or next element. (It would be perfectly possible to
+         * implement these search types in a non-counted tree by
+         * going back up from where we are, but far more fiddly.)
+         */
+        if (relation == REL234_LT)
+            idx--;
+        else
+            idx++;
+    } else {
+        /*
+         * We've found our way to the bottom of the tree and we
+         * know where we would insert this node if we wanted to:
+         * we'd put it in in place of the (empty) subtree
+         * n->kids[kcount], and it would have index idx
+         * 
+         * But the actual element isn't there. So if our search
+         * relation is EQ, we're doomed.
+         */
+        if (relation == REL234_EQ)
+            return NULL;
+
+        /*
+         * Otherwise, we must do an index lookup for index idx-1
+         * (if we're going left - LE or LT) or index idx (if we're
+         * going right - GE or GT).
+         */
+        if (relation == REL234_LT || relation == REL234_LE) {
+            idx--;
+        }
+    }
+
+    /*
+     * We know the index of the element we want; just call index234
+     * to do the rest. This will return NULL if the index is out of
+     * bounds, which is exactly what we want.
+     */
+    ret = index234(t, idx);
+    if (ret && index) *index = idx;
+    return ret;
+}
+void *find234(tree234 *t, void *e, cmpfn234 cmp) {
+    return findrelpos234(t, e, cmp, REL234_EQ, NULL);
+}
+void *findrel234(tree234 *t, void *e, cmpfn234 cmp, int relation) {
+    return findrelpos234(t, e, cmp, relation, NULL);
+}
+void *findpos234(tree234 *t, void *e, cmpfn234 cmp, int *index) {
+    return findrelpos234(t, e, cmp, REL234_EQ, index);
+}
+
+/*
+ * Tree transformation used in delete and split: move a subtree
+ * right, from child ki of a node to the next child. Update k and
+ * index so that they still point to the same place in the
+ * transformed tree. Assumes the destination child is not full, and
+ * that the source child does have a subtree to spare. Can cope if
+ * the destination child is undersized.
+ * 
+ *                . C .                     . B .
+ *               /     \     ->            /     \
+ * [more] a A b B c   d D e      [more] a A b   c C d D e
+ * 
+ *                 . C .                     . B .
+ *                /     \    ->             /     \
+ *  [more] a A b B c     d        [more] a A b   c C d
+ */
+static void trans234_subtree_right(node234 *n, int ki, int *k, int *index) {
+    node234 *src, *dest;
+    int i, srclen, adjust;
+
+    src = n->kids[ki];
+    dest = n->kids[ki+1];
+
+    LOG(("  trans234_subtree_right(%p, %d):\n", n, ki));
+    LOG(("    parent %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         n,
+         n->kids[0], n->counts[0], n->elems[0],
+         n->kids[1], n->counts[1], n->elems[1],
+         n->kids[2], n->counts[2], n->elems[2],
+         n->kids[3], n->counts[3]));
+    LOG(("    src %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         src,
+         src->kids[0], src->counts[0], src->elems[0],
+         src->kids[1], src->counts[1], src->elems[1],
+         src->kids[2], src->counts[2], src->elems[2],
+         src->kids[3], src->counts[3]));
+    LOG(("    dest %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         dest,
+         dest->kids[0], dest->counts[0], dest->elems[0],
+         dest->kids[1], dest->counts[1], dest->elems[1],
+         dest->kids[2], dest->counts[2], dest->elems[2],
+         dest->kids[3], dest->counts[3]));
+    /*
+     * Move over the rest of the destination node to make space.
+     */
+    dest->kids[3] = dest->kids[2];    dest->counts[3] = dest->counts[2];
+    dest->elems[2] = dest->elems[1];
+    dest->kids[2] = dest->kids[1];    dest->counts[2] = dest->counts[1];
+    dest->elems[1] = dest->elems[0];
+    dest->kids[1] = dest->kids[0];    dest->counts[1] = dest->counts[0];
+
+    /* which element to move over */
+    i = (src->elems[2] ? 2 : src->elems[1] ? 1 : 0);
+
+    dest->elems[0] = n->elems[ki];
+    n->elems[ki] = src->elems[i];
+    src->elems[i] = NULL;
+
+    dest->kids[0] = src->kids[i+1];   dest->counts[0] = src->counts[i+1];
+    src->kids[i+1] = NULL;            src->counts[i+1] = 0;
+
+    if (dest->kids[0]) dest->kids[0]->parent = dest;
+
+    adjust = dest->counts[0] + 1;
+
+    n->counts[ki] -= adjust;
+    n->counts[ki+1] += adjust;
+
+    srclen = n->counts[ki];
+
+    if (k) {
+        LOG(("    before: k,index = %d,%d\n", (*k), (*index)));
+        if ((*k) == ki && (*index) > srclen) {
+            (*index) -= srclen + 1;
+            (*k)++;
+        } else if ((*k) == ki+1) {
+            (*index) += adjust;
+        }
+        LOG(("    after: k,index = %d,%d\n", (*k), (*index)));
+    }
+
+    LOG(("    parent %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         n,
+         n->kids[0], n->counts[0], n->elems[0],
+         n->kids[1], n->counts[1], n->elems[1],
+         n->kids[2], n->counts[2], n->elems[2],
+         n->kids[3], n->counts[3]));
+    LOG(("    src %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         src,
+         src->kids[0], src->counts[0], src->elems[0],
+         src->kids[1], src->counts[1], src->elems[1],
+         src->kids[2], src->counts[2], src->elems[2],
+         src->kids[3], src->counts[3]));
+    LOG(("    dest %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         dest,
+         dest->kids[0], dest->counts[0], dest->elems[0],
+         dest->kids[1], dest->counts[1], dest->elems[1],
+         dest->kids[2], dest->counts[2], dest->elems[2],
+         dest->kids[3], dest->counts[3]));
+}
+
+/*
+ * Tree transformation used in delete and split: move a subtree
+ * left, from child ki of a node to the previous child. Update k
+ * and index so that they still point to the same place in the
+ * transformed tree. Assumes the destination child is not full, and
+ * that the source child does have a subtree to spare. Can cope if
+ * the destination child is undersized. 
+ *
+ *      . B .                             . C .
+ *     /     \                ->         /     \
+ *  a A b   c C d D e [more]      a A b B c   d D e [more]
+ *
+ *     . A .                             . B .
+ *    /     \                 ->        /     \
+ *   a   b B c C d [more]            a A b   c C d [more]
+ */
+static void trans234_subtree_left(node234 *n, int ki, int *k, int *index) {
+    node234 *src, *dest;
+    int i, adjust;
+
+    src = n->kids[ki];
+    dest = n->kids[ki-1];
+
+    LOG(("  trans234_subtree_left(%p, %d):\n", n, ki));
+    LOG(("    parent %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         n,
+         n->kids[0], n->counts[0], n->elems[0],
+         n->kids[1], n->counts[1], n->elems[1],
+         n->kids[2], n->counts[2], n->elems[2],
+         n->kids[3], n->counts[3]));
+    LOG(("    dest %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         dest,
+         dest->kids[0], dest->counts[0], dest->elems[0],
+         dest->kids[1], dest->counts[1], dest->elems[1],
+         dest->kids[2], dest->counts[2], dest->elems[2],
+         dest->kids[3], dest->counts[3]));
+    LOG(("    src %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         src,
+         src->kids[0], src->counts[0], src->elems[0],
+         src->kids[1], src->counts[1], src->elems[1],
+         src->kids[2], src->counts[2], src->elems[2],
+         src->kids[3], src->counts[3]));
+
+    /* where in dest to put it */
+    i = (dest->elems[1] ? 2 : dest->elems[0] ? 1 : 0);
+    dest->elems[i] = n->elems[ki-1];
+    n->elems[ki-1] = src->elems[0];
+
+    dest->kids[i+1] = src->kids[0];   dest->counts[i+1] = src->counts[0];
+
+    if (dest->kids[i+1]) dest->kids[i+1]->parent = dest;
+
+    /*
+     * Move over the rest of the source node.
+     */
+    src->kids[0] = src->kids[1];      src->counts[0] = src->counts[1];
+    src->elems[0] = src->elems[1];
+    src->kids[1] = src->kids[2];      src->counts[1] = src->counts[2];
+    src->elems[1] = src->elems[2];
+    src->kids[2] = src->kids[3];      src->counts[2] = src->counts[3];
+    src->elems[2] = NULL;
+    src->kids[3] = NULL;              src->counts[3] = 0;
+
+    adjust = dest->counts[i+1] + 1;
+
+    n->counts[ki] -= adjust;
+    n->counts[ki-1] += adjust;
+
+    if (k) {
+        LOG(("    before: k,index = %d,%d\n", (*k), (*index)));
+        if ((*k) == ki) {
+            (*index) -= adjust;
+            if ((*index) < 0) {
+                (*index) += n->counts[ki-1] + 1;
+                (*k)--;
+            }
+        }
+        LOG(("    after: k,index = %d,%d\n", (*k), (*index)));
+    }
+
+    LOG(("    parent %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         n,
+         n->kids[0], n->counts[0], n->elems[0],
+         n->kids[1], n->counts[1], n->elems[1],
+         n->kids[2], n->counts[2], n->elems[2],
+         n->kids[3], n->counts[3]));
+    LOG(("    dest %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         dest,
+         dest->kids[0], dest->counts[0], dest->elems[0],
+         dest->kids[1], dest->counts[1], dest->elems[1],
+         dest->kids[2], dest->counts[2], dest->elems[2],
+         dest->kids[3], dest->counts[3]));
+    LOG(("    src %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         src,
+         src->kids[0], src->counts[0], src->elems[0],
+         src->kids[1], src->counts[1], src->elems[1],
+         src->kids[2], src->counts[2], src->elems[2],
+         src->kids[3], src->counts[3]));
+}
+
+/*
+ * Tree transformation used in delete and split: merge child nodes
+ * ki and ki+1 of a node. Update k and index so that they still
+ * point to the same place in the transformed tree. Assumes both
+ * children _are_ sufficiently small.
+ *
+ *      . B .                .
+ *     /     \     ->        |
+ *  a A b   c C d      a A b B c C d
+ * 
+ * This routine can also cope with either child being undersized:
+ * 
+ *     . A .                 .
+ *    /     \      ->        |
+ *   a     b B c         a A b B c
+ *
+ *    . A .                  .
+ *   /     \       ->        |
+ *  a   b B c C d      a A b B c C d
+ */
+static void trans234_subtree_merge(node234 *n, int ki, int *k, int *index) {
+    node234 *left, *right;
+    int i, leftlen, rightlen, lsize, rsize;
+
+    left = n->kids[ki];               leftlen = n->counts[ki];
+    right = n->kids[ki+1];            rightlen = n->counts[ki+1];
+
+    LOG(("  trans234_subtree_merge(%p, %d):\n", n, ki));
+    LOG(("    parent %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         n,
+         n->kids[0], n->counts[0], n->elems[0],
+         n->kids[1], n->counts[1], n->elems[1],
+         n->kids[2], n->counts[2], n->elems[2],
+         n->kids[3], n->counts[3]));
+    LOG(("    left %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         left,
+         left->kids[0], left->counts[0], left->elems[0],
+         left->kids[1], left->counts[1], left->elems[1],
+         left->kids[2], left->counts[2], left->elems[2],
+         left->kids[3], left->counts[3]));
+    LOG(("    right %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         right,
+         right->kids[0], right->counts[0], right->elems[0],
+         right->kids[1], right->counts[1], right->elems[1],
+         right->kids[2], right->counts[2], right->elems[2],
+         right->kids[3], right->counts[3]));
+
+    assert(!left->elems[2] && !right->elems[2]);   /* neither is large! */
+    lsize = (left->elems[1] ? 2 : left->elems[0] ? 1 : 0);
+    rsize = (right->elems[1] ? 2 : right->elems[0] ? 1 : 0);
+
+    left->elems[lsize] = n->elems[ki];
+
+    for (i = 0; i < rsize+1; i++) {
+        left->kids[lsize+1+i] = right->kids[i];
+        left->counts[lsize+1+i] = right->counts[i];
+        if (left->kids[lsize+1+i])
+            left->kids[lsize+1+i]->parent = left;
+        if (i < rsize)
+            left->elems[lsize+1+i] = right->elems[i];
+    }
+
+    n->counts[ki] += rightlen + 1;
+
+    sfree(right);
+
+    /*
+     * Move the rest of n up by one.
+     */
+    for (i = ki+1; i < 3; i++) {
+        n->kids[i] = n->kids[i+1];
+        n->counts[i] = n->counts[i+1];
+    }
+    for (i = ki; i < 2; i++) {
+        n->elems[i] = n->elems[i+1];
+    }
+    n->kids[3] = NULL;
+    n->counts[3] = 0;
+    n->elems[2] = NULL;
+
+    if (k) {
+        LOG(("    before: k,index = %d,%d\n", (*k), (*index)));
+        if ((*k) == ki+1) {
+            (*k)--;
+            (*index) += leftlen + 1;
+        } else if ((*k) > ki+1) {
+            (*k)--;
+        }
+        LOG(("    after: k,index = %d,%d\n", (*k), (*index)));
+    }
+
+    LOG(("    parent %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         n,
+         n->kids[0], n->counts[0], n->elems[0],
+         n->kids[1], n->counts[1], n->elems[1],
+         n->kids[2], n->counts[2], n->elems[2],
+         n->kids[3], n->counts[3]));
+    LOG(("    merged %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+         left,
+         left->kids[0], left->counts[0], left->elems[0],
+         left->kids[1], left->counts[1], left->elems[1],
+         left->kids[2], left->counts[2], left->elems[2],
+         left->kids[3], left->counts[3]));
+
+}
+    
+/*
+ * Delete an element e in a 2-3-4 tree. Does not free the element,
+ * merely removes all links to it from the tree nodes.
+ */
+static void *delpos234_internal(tree234 *t, int index) {
+    node234 *n;
+    void *retval;
+    int ki, i;
+
+    retval = NULL;
+
+    n = t->root;                       /* by assumption this is non-NULL */
+    LOG(("deleting item %d from tree %p\n", index, t));
+    while (1) {
+        node234 *sub;
+
+        LOG(("  node %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d index=%d\n",
+             n,
+             n->kids[0], n->counts[0], n->elems[0],
+             n->kids[1], n->counts[1], n->elems[1],
+             n->kids[2], n->counts[2], n->elems[2],
+             n->kids[3], n->counts[3],
+             index));
+        if (index <= n->counts[0]) {
+            ki = 0;
+        } else if (index -= n->counts[0]+1, index <= n->counts[1]) {
+            ki = 1;
+        } else if (index -= n->counts[1]+1, index <= n->counts[2]) {
+            ki = 2;
+        } else if (index -= n->counts[2]+1, index <= n->counts[3]) {
+            ki = 3;
+        } else {
+            assert(0);                 /* can't happen */
+        }
+
+        if (!n->kids[0])
+            break;                     /* n is a leaf node; we're here! */
+
+        /*
+         * Check to see if we've found our target element. If so,
+         * we must choose a new target (we'll use the old target's
+         * successor, which will be in a leaf), move it into the
+         * place of the old one, continue down to the leaf and
+         * delete the old copy of the new target.
+         */
+        if (index == n->counts[ki]) {
+            node234 *m;
+            LOG(("  found element in internal node, index %d\n", ki));
+            assert(n->elems[ki]);      /* must be a kid _before_ an element */
+            ki++; index = 0;
+            for (m = n->kids[ki]; m->kids[0]; m = m->kids[0])
+                continue;
+            LOG(("  replacing with element \"%s\" from leaf node %p\n",
+                 m->elems[0], m));
+            retval = n->elems[ki-1];
+            n->elems[ki-1] = m->elems[0];
+        }
+
+        /*
+         * Recurse down to subtree ki. If it has only one element,
+         * we have to do some transformation to start with.
+         */
+        LOG(("  moving to subtree %d\n", ki));
+        sub = n->kids[ki];
+        if (!sub->elems[1]) {
+            LOG(("  subtree has only one element!\n"));
+            if (ki > 0 && n->kids[ki-1]->elems[1]) {
+                /*
+                 * Child ki has only one element, but child
+                 * ki-1 has two or more. So we need to move a
+                 * subtree from ki-1 to ki.
+                 */
+                trans234_subtree_right(n, ki-1, &ki, &index);
+            } else if (ki < 3 && n->kids[ki+1] &&
+                       n->kids[ki+1]->elems[1]) {
+                /*
+                 * Child ki has only one element, but ki+1 has
+                 * two or more. Move a subtree from ki+1 to ki.
+                 */
+                trans234_subtree_left(n, ki+1, &ki, &index);
+            } else {
+                /*
+                 * ki is small with only small neighbours. Pick a
+                 * neighbour and merge with it.
+                 */
+                trans234_subtree_merge(n, ki>0 ? ki-1 : ki, &ki, &index);
+                sub = n->kids[ki];
+
+                if (!n->elems[0]) {
+                    /*
+                     * The root is empty and needs to be
+                     * removed.
+                     */
+                    LOG(("  shifting root!\n"));
+                    t->root = sub;
+                    sub->parent = NULL;
+                    sfree(n);
+                    n = NULL;
+                }
+            }
+        }
+
+        if (n)
+            n->counts[ki]--;
+        n = sub;
+    }
+
+    /*
+     * Now n is a leaf node, and ki marks the element number we
+     * want to delete. We've already arranged for the leaf to be
+     * bigger than minimum size, so let's just go to it.
+     */
+    assert(!n->kids[0]);
+    if (!retval)
+        retval = n->elems[ki];
+
+    for (i = ki; i < 2 && n->elems[i+1]; i++)
+        n->elems[i] = n->elems[i+1];
+    n->elems[i] = NULL;
+
+    /*
+     * It's just possible that we have reduced the leaf to zero
+     * size. This can only happen if it was the root - so destroy
+     * it and make the tree empty.
+     */
+    if (!n->elems[0]) {
+        LOG(("  removed last element in tree, destroying empty root\n"));
+        assert(n == t->root);
+        sfree(n);
+        t->root = NULL;
+    }
+
+    return retval;                     /* finished! */
+}
+void *delpos234(tree234 *t, int index) {
+    if (index < 0 || index >= countnode234(t->root))
+        return NULL;
+    return delpos234_internal(t, index);
+}
+void *del234(tree234 *t, void *e) {
+    int index;
+    if (!findrelpos234(t, e, NULL, REL234_EQ, &index))
+        return NULL;                   /* it wasn't in there anyway */
+    return delpos234_internal(t, index); /* it's there; delete it. */
+}
+
+/*
+ * Join two subtrees together with a separator element between
+ * them, given their relative height.
+ * 
+ * (Height<0 means the left tree is shorter, >0 means the right
+ * tree is shorter, =0 means (duh) they're equal.)
+ * 
+ * It is assumed that any checks needed on the ordering criterion
+ * have _already_ been done.
+ * 
+ * The value returned in `height' is 0 or 1 depending on whether the
+ * resulting tree is the same height as the original larger one, or
+ * one higher.
+ */
+static node234 *join234_internal(node234 *left, void *sep,
+                                 node234 *right, int *height) {
+    node234 *root, *node;
+    int relht = *height;
+    int ki;
+
+    LOG(("  join: joining %p \"%s\" %p, relative height is %d\n",
+         left, sep, right, relht));
+    if (relht == 0) {
+        /*
+         * The trees are the same height. Create a new one-element
+         * root containing the separator and pointers to the two
+         * nodes.
+         */
+        node234 *newroot;
+        newroot = snew(node234);
+        newroot->kids[0] = left;     newroot->counts[0] = countnode234(left);
+        newroot->elems[0] = sep;
+        newroot->kids[1] = right;    newroot->counts[1] = countnode234(right);
+        newroot->elems[1] = NULL;
+        newroot->kids[2] = NULL;     newroot->counts[2] = 0;
+        newroot->elems[2] = NULL;
+        newroot->kids[3] = NULL;     newroot->counts[3] = 0;
+        newroot->parent = NULL;
+        if (left) left->parent = newroot;
+        if (right) right->parent = newroot;
+        *height = 1;
+        LOG(("  join: same height, brand new root\n"));
+        return newroot;
+    }
+
+    /*
+     * This now works like the addition algorithm on the larger
+     * tree. We're replacing a single kid pointer with two kid
+     * pointers separated by an element; if that causes the node to
+     * overload, we split it in two, move a separator element up to
+     * the next node, and repeat.
+     */
+    if (relht < 0) {
+        /*
+         * Left tree is shorter. Search down the right tree to find
+         * the pointer we're inserting at.
+         */
+        node = root = right;
+        while (++relht < 0) {
+            node = node->kids[0];
+        }
+        ki = 0;
+        right = node->kids[ki];
+    } else {
+        /*
+         * Right tree is shorter; search down the left to find the
+         * pointer we're inserting at.
+         */
+        node = root = left;
+        while (--relht > 0) {
+            if (node->elems[2])
+                node = node->kids[3];
+            else if (node->elems[1])
+                node = node->kids[2];
+            else
+                node = node->kids[1];
+        }
+        if (node->elems[2])
+            ki = 3;
+        else if (node->elems[1])
+            ki = 2;
+        else
+            ki = 1;
+        left = node->kids[ki];
+    }
+
+    /*
+     * Now proceed as for addition.
+     */
+    *height = add234_insert(left, sep, right, &root, node, ki);
+
+    return root;
+}
+static int height234(tree234 *t) {
+    int level = 0;
+    node234 *n = t->root;
+    while (n) {
+        level++;
+        n = n->kids[0];
+    }
+    return level;
+}
+tree234 *join234(tree234 *t1, tree234 *t2) {
+    int size2 = countnode234(t2->root);
+    if (size2 > 0) {
+        void *element;
+        int relht;
+
+        if (t1->cmp) {
+            element = index234(t2, 0);
+            element = findrelpos234(t1, element, NULL, REL234_GE, NULL);
+            if (element)
+                return NULL;
+        }
+
+        element = delpos234(t2, 0);
+        relht = height234(t1) - height234(t2);
+        t1->root = join234_internal(t1->root, element, t2->root, &relht);
+        t2->root = NULL;
+    }
+    return t1;
+}
+tree234 *join234r(tree234 *t1, tree234 *t2) {
+    int size1 = countnode234(t1->root);
+    if (size1 > 0) {
+        void *element;
+        int relht;
+
+        if (t2->cmp) {
+            element = index234(t1, size1-1);
+            element = findrelpos234(t2, element, NULL, REL234_LE, NULL);
+            if (element)
+                return NULL;
+        }
+
+        element = delpos234(t1, size1-1);
+        relht = height234(t1) - height234(t2);
+        t2->root = join234_internal(t1->root, element, t2->root, &relht);
+        t1->root = NULL;
+    }
+    return t2;
+}
+
+/*
+ * Split out the first <index> elements in a tree and return a
+ * pointer to the root node. Leave the root node of the remainder
+ * in t.
+ */
+static node234 *split234_internal(tree234 *t, int index) {
+    node234 *halves[2] = { NULL, NULL }, *n, *sib, *sub;
+    node234 *lparent, *rparent;
+    int ki, pki, i, half, lcount, rcount;
+
+    n = t->root;
+    LOG(("splitting tree %p at point %d\n", t, index));
+
+    /*
+     * Easy special cases. After this we have also dealt completely
+     * with the empty-tree case and we can assume the root exists.
+     */
+    if (index == 0)                    /* return nothing */
+        return NULL;
+    if (index == countnode234(t->root)) {   /* return the whole tree */
+        node234 *ret = t->root;
+        t->root = NULL;
+        return ret;
+    }
+
+    /*
+     * Search down the tree to find the split point.
+     */
+    halves[0] = halves[1] = NULL;
+    lparent = rparent = NULL;
+    pki = -1;
+    while (n) {
+        LOG(("  node %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d index=%d\n",
+             n,
+             n->kids[0], n->counts[0], n->elems[0],
+             n->kids[1], n->counts[1], n->elems[1],
+             n->kids[2], n->counts[2], n->elems[2],
+             n->kids[3], n->counts[3],
+             index));
+        lcount = index;
+        rcount = countnode234(n) - lcount;
+        if (index <= n->counts[0]) {
+            ki = 0;
+        } else if (index -= n->counts[0]+1, index <= n->counts[1]) {
+            ki = 1;
+        } else if (index -= n->counts[1]+1, index <= n->counts[2]) {
+            ki = 2;
+        } else {
+            index -= n->counts[2]+1;
+            ki = 3;
+        }
+
+        LOG(("  splitting at subtree %d\n", ki));
+        sub = n->kids[ki];
+
+        LOG(("  splitting at child index %d\n", ki));
+
+        /*
+         * Split the node, put halves[0] on the right of the left
+         * one and halves[1] on the left of the right one, put the
+         * new node pointers in halves[0] and halves[1], and go up
+         * a level.
+         */
+        sib = snew(node234);
+        for (i = 0; i < 3; i++) {
+            if (i+ki < 3 && n->elems[i+ki]) {
+                sib->elems[i] = n->elems[i+ki];
+                sib->kids[i+1] = n->kids[i+ki+1];
+                if (sib->kids[i+1]) sib->kids[i+1]->parent = sib;
+                sib->counts[i+1] = n->counts[i+ki+1];
+                n->elems[i+ki] = NULL;
+                n->kids[i+ki+1] = NULL;
+                n->counts[i+ki+1] = 0;
+            } else {
+                sib->elems[i] = NULL;
+                sib->kids[i+1] = NULL;
+                sib->counts[i+1] = 0;
+            }
+        }
+        if (lparent) {
+            lparent->kids[pki] = n;
+            lparent->counts[pki] = lcount;
+            n->parent = lparent;
+            rparent->kids[0] = sib;
+            rparent->counts[0] = rcount;
+            sib->parent = rparent;
+        } else {
+            halves[0] = n;
+            n->parent = NULL;
+            halves[1] = sib;
+            sib->parent = NULL;
+        }
+        lparent = n;
+        rparent = sib;
+        pki = ki;
+        LOG(("  left node %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+             n,
+             n->kids[0], n->counts[0], n->elems[0],
+             n->kids[1], n->counts[1], n->elems[1],
+             n->kids[2], n->counts[2], n->elems[2],
+             n->kids[3], n->counts[3]));
+        LOG(("  right node %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+             sib,
+             sib->kids[0], sib->counts[0], sib->elems[0],
+             sib->kids[1], sib->counts[1], sib->elems[1],
+             sib->kids[2], sib->counts[2], sib->elems[2],
+             sib->kids[3], sib->counts[3]));
+
+        n = sub;
+    }
+
+    /*
+     * We've come off the bottom here, so we've successfully split
+     * the tree into two equally high subtrees. The only problem is
+     * that some of the nodes down the fault line will be smaller
+     * than the minimum permitted size. (Since this is a 2-3-4
+     * tree, that means they'll be zero-element one-child nodes.)
+     */
+    LOG(("  fell off bottom, lroot is %p, rroot is %p\n",
+         halves[0], halves[1]));
+    assert(halves[0] != NULL);
+    assert(halves[1] != NULL);
+    lparent->counts[pki] = rparent->counts[0] = 0;
+    lparent->kids[pki] = rparent->kids[0] = NULL;
+
+    /*
+     * So now we go back down the tree from each of the two roots,
+     * fixing up undersize nodes.
+     */
+    for (half = 0; half < 2; half++) {
+        /*
+         * Remove the root if it's undersize (it will contain only
+         * one child pointer, so just throw it away and replace it
+         * with its child). This might happen several times.
+         */
+        while (halves[half] && !halves[half]->elems[0]) {
+            LOG(("  root %p is undersize, throwing away\n", halves[half]));
+            halves[half] = halves[half]->kids[0];
+            sfree(halves[half]->parent);
+            halves[half]->parent = NULL;
+            LOG(("  new root is %p\n", halves[half]));
+        }
+
+        n = halves[half];
+        while (n) {
+            void (*toward)(node234 *n, int ki, int *k, int *index);
+            int ni, merge;
+
+            /*
+             * Now we have a potentially undersize node on the
+             * right (if half==0) or left (if half==1). Sort it
+             * out, by merging with a neighbour or by transferring
+             * subtrees over. At this time we must also ensure that
+             * nodes are bigger than minimum, in case we need an
+             * element to merge two nodes below.
+             */
+            LOG(("  node %p: %p/%d \"%s\" %p/%d \"%s\" %p/%d \"%s\" %p/%d\n",
+                 n,
+                 n->kids[0], n->counts[0], n->elems[0],
+                 n->kids[1], n->counts[1], n->elems[1],
+                 n->kids[2], n->counts[2], n->elems[2],
+                 n->kids[3], n->counts[3]));
+            if (half == 1) {
+                ki = 0;                /* the kid we're interested in */
+                ni = 1;                /* the neighbour */
+                merge = 0;             /* for merge: leftmost of the two */
+                toward = trans234_subtree_left;
+            } else {
+                ki = (n->kids[3] ? 3 : n->kids[2] ? 2 : 1);
+                ni = ki-1;
+                merge = ni;
+                toward = trans234_subtree_right;
+            }
+
+            sub = n->kids[ki];
+            if (sub && !sub->elems[1]) {
+                /*
+                 * This node is undersized or minimum-size. If we
+                 * can merge it with its neighbour, we do so;
+                 * otherwise we must be able to transfer subtrees
+                 * over to it until it is greater than minimum
+                 * size.
+                 */
+                int undersized = (!sub->elems[0]);
+                LOG(("  child %d is %ssize\n", ki,
+                     undersized ? "under" : "minimum-"));
+                LOG(("  neighbour is %s\n",
+                     n->kids[ni]->elems[2] ? "large" :
+                     n->kids[ni]->elems[1] ? "medium" : "small"));
+                if (!n->kids[ni]->elems[1] ||
+                    (undersized && !n->kids[ni]->elems[2])) {
+                    /*
+                     * Neighbour is small, or possibly neighbour is
+                     * medium and we are undersize.
+                     */
+                    trans234_subtree_merge(n, merge, NULL, NULL);
+                    sub = n->kids[merge];
+                    if (!n->elems[0]) {
+                        /*
+                         * n is empty, and hence must have been the
+                         * root and needs to be removed.
+                         */
+                        assert(!n->parent);
+                        LOG(("  shifting root!\n"));
+                        halves[half] = sub;
+                        halves[half]->parent = NULL;
+                        sfree(n);
+                    }
+                } else {
+                    /* Neighbour is big enough to move trees over. */
+                    toward(n, ni, NULL, NULL);
+                    if (undersized)
+                        toward(n, ni, NULL, NULL);
+                }
+            }
+            n = sub;
+        }
+    }
+
+    t->root = halves[1];
+    return halves[0];
+}
+tree234 *splitpos234(tree234 *t, int index, int before) {
+    tree234 *ret;
+    node234 *n;
+    int count;
+
+    count = countnode234(t->root);
+    if (index < 0 || index > count)
+        return NULL;                   /* error */
+    ret = newtree234(t->cmp);
+    n = split234_internal(t, index);
+    if (before) {
+        /* We want to return the ones before the index. */
+        ret->root = n;
+    } else {
+        /*
+         * We want to keep the ones before the index and return the
+         * ones after.
+         */
+        ret->root = t->root;
+        t->root = n;
+    }
+    return ret;
+}
+tree234 *split234(tree234 *t, void *e, cmpfn234 cmp, int rel) {
+    int before;
+    int index;
+
+    assert(rel != REL234_EQ);
+
+    if (rel == REL234_GT || rel == REL234_GE) {
+        before = 1;
+        rel = (rel == REL234_GT ? REL234_LE : REL234_LT);
+    } else {
+        before = 0;
+    }
+    if (!findrelpos234(t, e, cmp, rel, &index))
+        index = 0;
+
+    return splitpos234(t, index+1, before);
+}
+
+static node234 *copynode234(node234 *n, copyfn234 copyfn, void *copyfnstate) {
+    int i;
+    node234 *n2 = snew(node234);
+
+    for (i = 0; i < 3; i++) {
+        if (n->elems[i] && copyfn)
+            n2->elems[i] = copyfn(copyfnstate, n->elems[i]);
+        else
+            n2->elems[i] = n->elems[i];
+    }
+
+    for (i = 0; i < 4; i++) {
+        if (n->kids[i]) {
+            n2->kids[i] = copynode234(n->kids[i], copyfn, copyfnstate);
+            n2->kids[i]->parent = n2;
+        } else {
+            n2->kids[i] = NULL;
+        }
+        n2->counts[i] = n->counts[i];
+    }
+
+    return n2;
+}
+tree234 *copytree234(tree234 *t, copyfn234 copyfn, void *copyfnstate) {
+    tree234 *t2;
+
+    t2 = newtree234(t->cmp);
+    if (t->root) {
+        t2->root = copynode234(t->root, copyfn, copyfnstate);
+        t2->root->parent = NULL;
+    } else
+        t2->root = NULL;
+
+    return t2;
+}
+
+#ifdef TEST
+
+/*
+ * Test code for the 2-3-4 tree. This code maintains an alternative
+ * representation of the data in the tree, in an array (using the
+ * obvious and slow insert and delete functions). After each tree
+ * operation, the verify() function is called, which ensures all
+ * the tree properties are preserved:
+ *  - node->child->parent always equals node
+ *  - tree->root->parent always equals NULL
+ *  - number of kids == 0 or number of elements + 1;
+ *  - tree has the same depth everywhere
+ *  - every node has at least one element
+ *  - subtree element counts are accurate
+ *  - any NULL kid pointer is accompanied by a zero count
+ *  - in a sorted tree: ordering property between elements of a
+ *    node and elements of its children is preserved
+ * and also ensures the list represented by the tree is the same
+ * list it should be. (This last check also doubly verifies the
+ * ordering properties, because the `same list it should be' is by
+ * definition correctly ordered. It also ensures all nodes are
+ * distinct, because the enum functions would get caught in a loop
+ * if not.)
+ */
+
+#include <string.h>
+#include <stdarg.h>
+
+#define srealloc realloc
+
+/*
+ * Error reporting function.
+ */
+void error(char *fmt, ...) {
+    va_list ap;
+    printf("ERROR: ");
+    va_start(ap, fmt);
+    vfprintf(stdout, fmt, ap);
+    va_end(ap);
+    printf("\n");
+}
+
+/* The array representation of the data. */
+void **array;
+int arraylen, arraysize;
+cmpfn234 cmp;
+
+/* The tree representation of the same data. */
+tree234 *tree;
+
+/*
+ * Routines to provide a diagnostic printout of a tree. Currently
+ * relies on every element in the tree being a one-character string
+ * :-)
+ */
+typedef struct {
+    char **levels;
+} dispctx;
+
+int dispnode(node234 *n, int level, dispctx *ctx) {
+    if (level == 0) {
+        int xpos = strlen(ctx->levels[0]);
+        int len;
+
+        if (n->elems[2])
+            len = sprintf(ctx->levels[0]+xpos, " %s%s%s",
+                          n->elems[0], n->elems[1], n->elems[2]);
+        else if (n->elems[1])
+            len = sprintf(ctx->levels[0]+xpos, " %s%s",
+                          n->elems[0], n->elems[1]);
+        else
+            len = sprintf(ctx->levels[0]+xpos, " %s",
+                          n->elems[0]);
+        return xpos + 1 + (len-1) / 2;
+    } else {
+        int xpos[4], nkids;
+        int nodelen, mypos, myleft, x, i;
+
+        xpos[0] = dispnode(n->kids[0], level-3, ctx);
+        xpos[1] = dispnode(n->kids[1], level-3, ctx);
+        nkids = 2;
+        if (n->kids[2]) {
+            xpos[2] = dispnode(n->kids[2], level-3, ctx);
+            nkids = 3;
+        }
+        if (n->kids[3]) {
+            xpos[3] = dispnode(n->kids[3], level-3, ctx);
+            nkids = 4;
+        }
+
+        if (nkids == 4)
+            mypos = (xpos[1] + xpos[2]) / 2;
+        else if (nkids == 3)
+            mypos = xpos[1];
+        else
+            mypos = (xpos[0] + xpos[1]) / 2;
+        nodelen = nkids * 2 - 1;
+        myleft = mypos - ((nodelen-1)/2);
+        assert(myleft >= xpos[0]);
+        assert(myleft + nodelen-1 <= xpos[nkids-1]);
+
+        x = strlen(ctx->levels[level]);
+        while (x <= xpos[0] && x < myleft)
+            ctx->levels[level][x++] = ' ';
+        while (x < myleft)
+            ctx->levels[level][x++] = '_';
+        if (nkids==4)
+            x += sprintf(ctx->levels[level]+x, ".%s.%s.%s.",
+                         n->elems[0], n->elems[1], n->elems[2]);
+        else if (nkids==3)
+            x += sprintf(ctx->levels[level]+x, ".%s.%s.",
+                         n->elems[0], n->elems[1]);
+        else
+            x += sprintf(ctx->levels[level]+x, ".%s.",
+                         n->elems[0]);
+        while (x < xpos[nkids-1])
+            ctx->levels[level][x++] = '_';
+        ctx->levels[level][x] = '\0';
+
+        x = strlen(ctx->levels[level-1]);
+        for (i = 0; i < nkids; i++) {
+            int rpos, pos;
+            rpos = xpos[i];
+            if (i > 0 && i < nkids-1)
+                pos = myleft + 2*i;
+            else
+                pos = rpos;
+            if (rpos < pos)
+                rpos++;
+            while (x < pos && x < rpos)
+                ctx->levels[level-1][x++] = ' ';
+            if (x == pos)
+                ctx->levels[level-1][x++] = '|';
+            while (x < pos || x < rpos)
+                ctx->levels[level-1][x++] = '_';
+            if (x == pos)
+                ctx->levels[level-1][x++] = '|';
+        }
+        ctx->levels[level-1][x] = '\0';
+
+        x = strlen(ctx->levels[level-2]);
+        for (i = 0; i < nkids; i++) {
+            int rpos = xpos[i];
+
+            while (x < rpos)
+                ctx->levels[level-2][x++] = ' ';
+            ctx->levels[level-2][x++] = '|';
+        }
+        ctx->levels[level-2][x] = '\0';
+
+        return mypos;
+    }
+}
+
+void disptree(tree234 *t) {
+    dispctx ctx;
+    char *leveldata;
+    int width = count234(t);
+    int ht = height234(t) * 3 - 2;
+    int i;
+
+    if (!t->root) {
+        printf("[empty tree]\n");
+    }
+
+    leveldata = smalloc(ht * (width+2));
+    ctx.levels = smalloc(ht * sizeof(char *));
+    for (i = 0; i < ht; i++) {
+        ctx.levels[i] = leveldata + i * (width+2);
+        ctx.levels[i][0] = '\0';
+    }
+
+    (void) dispnode(t->root, ht-1, &ctx);
+
+    for (i = ht; i-- ;)
+        printf("%s\n", ctx.levels[i]);
+
+    sfree(ctx.levels);
+    sfree(leveldata);
+}
+
+typedef struct {
+    int treedepth;
+    int elemcount;
+} chkctx;
+
+int chknode(chkctx *ctx, int level, node234 *node,
+            void *lowbound, void *highbound) {
+    int nkids, nelems;
+    int i;
+    int count;
+
+    /* Count the non-NULL kids. */
+    for (nkids = 0; nkids < 4 && node->kids[nkids]; nkids++);
+    /* Ensure no kids beyond the first NULL are non-NULL. */
+    for (i = nkids; i < 4; i++)
+        if (node->kids[i]) {
+            error("node %p: nkids=%d but kids[%d] non-NULL",
+                   node, nkids, i);
+        } else if (node->counts[i]) {
+            error("node %p: kids[%d] NULL but count[%d]=%d nonzero",
+                   node, i, i, node->counts[i]);
+        }
+
+    /* Count the non-NULL elements. */
+    for (nelems = 0; nelems < 3 && node->elems[nelems]; nelems++);
+    /* Ensure no elements beyond the first NULL are non-NULL. */
+    for (i = nelems; i < 3; i++)
+        if (node->elems[i]) {
+            error("node %p: nelems=%d but elems[%d] non-NULL",
+                   node, nelems, i);
+        }
+
+    if (nkids == 0) {
+        /*
+         * If nkids==0, this is a leaf node; verify that the tree
+         * depth is the same everywhere.
+         */
+        if (ctx->treedepth < 0)
+            ctx->treedepth = level;    /* we didn't know the depth yet */
+        else if (ctx->treedepth != level)
+            error("node %p: leaf at depth %d, previously seen depth %d",
+                   node, level, ctx->treedepth);
+    } else {
+        /*
+         * If nkids != 0, then it should be nelems+1, unless nelems
+         * is 0 in which case nkids should also be 0 (and so we
+         * shouldn't be in this condition at all).
+         */
+        int shouldkids = (nelems ? nelems+1 : 0);
+        if (nkids != shouldkids) {
+            error("node %p: %d elems should mean %d kids but has %d",
+                   node, nelems, shouldkids, nkids);
+        }
+    }
+
+    /*
+     * nelems should be at least 1.
+     */
+    if (nelems == 0) {
+        error("node %p: no elems", node, nkids);
+    }
+
+    /*
+     * Add nelems to the running element count of the whole tree.
+     */
+    ctx->elemcount += nelems;
+
+    /*
+     * Check ordering property: all elements should be strictly >
+     * lowbound, strictly < highbound, and strictly < each other in
+     * sequence. (lowbound and highbound are NULL at edges of tree
+     * - both NULL at root node - and NULL is considered to be <
+     * everything and > everything. IYSWIM.)
+     */
+    if (cmp) {
+        for (i = -1; i < nelems; i++) {
+            void *lower = (i == -1 ? lowbound : node->elems[i]);
+            void *higher = (i+1 == nelems ? highbound : node->elems[i+1]);
+            if (lower && higher && cmp(lower, higher) >= 0) {
+                error("node %p: kid comparison [%d=%s,%d=%s] failed",
+                      node, i, lower, i+1, higher);
+            }
+        }
+    }
+
+    /*
+     * Check parent pointers: all non-NULL kids should have a
+     * parent pointer coming back to this node.
+     */
+    for (i = 0; i < nkids; i++)
+        if (node->kids[i]->parent != node) {
+            error("node %p kid %d: parent ptr is %p not %p",
+                   node, i, node->kids[i]->parent, node);
+        }
+
+
+    /*
+     * Now (finally!) recurse into subtrees.
+     */
+    count = nelems;
+
+    for (i = 0; i < nkids; i++) {
+        void *lower = (i == 0 ? lowbound : node->elems[i-1]);
+        void *higher = (i >= nelems ? highbound : node->elems[i]);
+        int subcount = chknode(ctx, level+1, node->kids[i], lower, higher);
+        if (node->counts[i] != subcount) {
+            error("node %p kid %d: count says %d, subtree really has %d",
+                  node, i, node->counts[i], subcount);
+        }
+        count += subcount;
+    }
+
+    return count;
+}
+
+void verifytree(tree234 *tree, void **array, int arraylen) {
+    chkctx ctx;
+    int i;
+    void *p;
+
+    ctx.treedepth = -1;                /* depth unknown yet */
+    ctx.elemcount = 0;                 /* no elements seen yet */
+    /*
+     * Verify validity of tree properties.
+     */
+    if (tree->root) {
+        if (tree->root->parent != NULL)
+            error("root->parent is %p should be null", tree->root->parent);
+        chknode(&ctx, 0, tree->root, NULL, NULL);
+    }
+    printf("tree depth: %d\n", ctx.treedepth);
+    /*
+     * Enumerate the tree and ensure it matches up to the array.
+     */
+    for (i = 0; NULL != (p = index234(tree, i)); i++) {
+        if (i >= arraylen)
+            error("tree contains more than %d elements", arraylen);
+        if (array[i] != p)
+            error("enum at position %d: array says %s, tree says %s",
+                   i, array[i], p);
+    }
+    if (ctx.elemcount != i) {
+        error("tree really contains %d elements, enum gave %d",
+               ctx.elemcount, i);
+    }
+    if (i < arraylen) {
+        error("enum gave only %d elements, array has %d", i, arraylen);
+    }
+    i = count234(tree);
+    if (ctx.elemcount != i) {
+        error("tree really contains %d elements, count234 gave %d",
+              ctx.elemcount, i);
+    }
+}
+void verify(void) { verifytree(tree, array, arraylen); }
+
+void internal_addtest(void *elem, int index, void *realret) {
+    int i, j;
+    void *retval;
+
+    if (arraysize < arraylen+1) {
+        arraysize = arraylen+1+256;
+        array = (array == NULL ? smalloc(arraysize*sizeof(*array)) :
+                 srealloc(array, arraysize*sizeof(*array)));
+    }
+
+    i = index;
+    /* now i points to the first element >= elem */
+    retval = elem;                  /* expect elem returned (success) */
+    for (j = arraylen; j > i; j--)
+        array[j] = array[j-1];
+    array[i] = elem;                /* add elem to array */
+    arraylen++;
+
+    if (realret != retval) {
+        error("add: retval was %p expected %p", realret, retval);
+    }
+
+    verify();
+}
+
+void addtest(void *elem) {
+    int i;
+    void *realret;
+
+    realret = add234(tree, elem);
+
+    i = 0;
+    while (i < arraylen && cmp(elem, array[i]) > 0)
+        i++;
+    if (i < arraylen && !cmp(elem, array[i])) {
+        void *retval = array[i];       /* expect that returned not elem */
+        if (realret != retval) {
+            error("add: retval was %p expected %p", realret, retval);
+        }
+    } else
+        internal_addtest(elem, i, realret);
+}
+
+void addpostest(void *elem, int i) {
+    void *realret;
+
+    realret = addpos234(tree, elem, i);
+
+    internal_addtest(elem, i, realret);
+}
+
+void delpostest(int i) {
+    int index = i;
+    void *elem = array[i], *ret;
+
+    /* i points to the right element */
+    while (i < arraylen-1) {
+        array[i] = array[i+1];
+        i++;
+    }
+    arraylen--;                        /* delete elem from array */
+
+    if (tree->cmp)
+        ret = del234(tree, elem);
+    else
+        ret = delpos234(tree, index);
+
+    if (ret != elem) {
+        error("del returned %p, expected %p", ret, elem);
+    }
+
+    verify();
+}
+
+void deltest(void *elem) {
+    int i;
+
+    i = 0;
+    while (i < arraylen && cmp(elem, array[i]) > 0)
+        i++;
+    if (i >= arraylen || cmp(elem, array[i]) != 0)
+        return;                        /* don't do it! */
+    delpostest(i);
+}
+
+/* A sample data set and test utility. Designed for pseudo-randomness,
+ * and yet repeatability. */
+
+/*
+ * This random number generator uses the `portable implementation'
+ * given in ANSI C99 draft N869. It assumes `unsigned' is 32 bits;
+ * change it if not.
+ */
+int randomnumber(unsigned *seed) {
+    *seed *= 1103515245;
+    *seed += 12345;
+    return ((*seed) / 65536) % 32768;
+}
+
+int mycmp(void *av, void *bv) {
+    char const *a = (char const *)av;
+    char const *b = (char const *)bv;
+    return strcmp(a, b);
+}
+
+char *strings[] = {
+    "0", "2", "3", "I", "K", "d", "H", "J", "Q", "N", "n", "q", "j", "i",
+    "7", "G", "F", "D", "b", "x", "g", "B", "e", "v", "V", "T", "f", "E",
+    "S", "8", "A", "k", "X", "p", "C", "R", "a", "o", "r", "O", "Z", "u",
+    "6", "1", "w", "L", "P", "M", "c", "U", "h", "9", "t", "5", "W", "Y",
+    "m", "s", "l", "4",
+#if 0
+    "a", "ab", "absque", "coram", "de",
+    "palam", "clam", "cum", "ex", "e",
+    "sine", "tenus", "pro", "prae",
+    "banana", "carrot", "cabbage", "broccoli", "onion", "zebra",
+    "penguin", "blancmange", "pangolin", "whale", "hedgehog",
+    "giraffe", "peanut", "bungee", "foo", "bar", "baz", "quux",
+    "murfl", "spoo", "breen", "flarn", "octothorpe",
+    "snail", "tiger", "elephant", "octopus", "warthog", "armadillo",
+    "aardvark", "wyvern", "dragon", "elf", "dwarf", "orc", "goblin",
+    "pixie", "basilisk", "warg", "ape", "lizard", "newt", "shopkeeper",
+    "wand", "ring", "amulet"
+#endif
+};
+
+#define NSTR lenof(strings)
+
+void findtest(void) {
+    static const int rels[] = {
+        REL234_EQ, REL234_GE, REL234_LE, REL234_LT, REL234_GT
+    };
+    static const char *const relnames[] = {
+        "EQ", "GE", "LE", "LT", "GT"
+    };
+    int i, j, rel, index;
+    char *p, *ret, *realret, *realret2;
+    int lo, hi, mid, c;
+
+    for (i = 0; i < (int)NSTR; i++) {
+        p = strings[i];
+        for (j = 0; j < (int)(sizeof(rels)/sizeof(*rels)); j++) {
+            rel = rels[j];
+
+            lo = 0; hi = arraylen-1;
+            while (lo <= hi) {
+                mid = (lo + hi) / 2;
+                c = strcmp(p, array[mid]);
+                if (c < 0)
+                    hi = mid-1;
+                else if (c > 0)
+                    lo = mid+1;
+                else
+                    break;
+            }
+
+            if (c == 0) {
+                if (rel == REL234_LT)
+                    ret = (mid > 0 ? array[--mid] : NULL);
+                else if (rel == REL234_GT)
+                    ret = (mid < arraylen-1 ? array[++mid] : NULL);
+                else
+                    ret = array[mid];
+            } else {
+                assert(lo == hi+1);
+                if (rel == REL234_LT || rel == REL234_LE) {
+                    mid = hi;
+                    ret = (hi >= 0 ? array[hi] : NULL);
+                } else if (rel == REL234_GT || rel == REL234_GE) {
+                    mid = lo;
+                    ret = (lo < arraylen ? array[lo] : NULL);
+                } else
+                    ret = NULL;
+            }
+
+            realret = findrelpos234(tree, p, NULL, rel, &index);
+            if (realret != ret) {
+                error("find(\"%s\",%s) gave %s should be %s",
+                      p, relnames[j], realret, ret);
+            }
+            if (realret && index != mid) {
+                error("find(\"%s\",%s) gave %d should be %d",
+                      p, relnames[j], index, mid);
+            }
+            if (realret && rel == REL234_EQ) {
+                realret2 = index234(tree, index);
+                if (realret2 != realret) {
+                    error("find(\"%s\",%s) gave %s(%d) but %d -> %s",
+                          p, relnames[j], realret, index, index, realret2);
+                }
+            }
+#if 0
+            printf("find(\"%s\",%s) gave %s(%d)\n", p, relnames[j],
+                   realret, index);
+#endif
+        }
+    }
+
+    realret = findrelpos234(tree, NULL, NULL, REL234_GT, &index);
+    if (arraylen && (realret != array[0] || index != 0)) {
+        error("find(NULL,GT) gave %s(%d) should be %s(0)",
+              realret, index, array[0]);
+    } else if (!arraylen && (realret != NULL)) {
+        error("find(NULL,GT) gave %s(%d) should be NULL",
+              realret, index);
+    }
+
+    realret = findrelpos234(tree, NULL, NULL, REL234_LT, &index);
+    if (arraylen && (realret != array[arraylen-1] || index != arraylen-1)) {
+        error("find(NULL,LT) gave %s(%d) should be %s(0)",
+              realret, index, array[arraylen-1]);
+    } else if (!arraylen && (realret != NULL)) {
+        error("find(NULL,LT) gave %s(%d) should be NULL",
+              realret, index);
+    }
+}
+
+void splittest(tree234 *tree, void **array, int arraylen) {
+    int i;
+    tree234 *tree3, *tree4;
+    for (i = 0; i <= arraylen; i++) {
+        tree3 = copytree234(tree, NULL, NULL);
+        tree4 = splitpos234(tree3, i, 0);
+        verifytree(tree3, array, i);
+        verifytree(tree4, array+i, arraylen-i);
+        join234(tree3, tree4);
+        freetree234(tree4);            /* left empty by join */
+        verifytree(tree3, array, arraylen);
+        freetree234(tree3);
+    }
+}
+
+int main(void) {
+    int in[NSTR];
+    int i, j, k;
+    int tworoot, tmplen;
+    unsigned seed = 0;
+    tree234 *tree2, *tree3, *tree4;
+    int c;
+
+    setvbuf(stdout, NULL, _IOLBF, 0);
+
+    for (i = 0; i < (int)NSTR; i++) in[i] = 0;
+    array = NULL;
+    arraylen = arraysize = 0;
+    tree = newtree234(mycmp);
+    cmp = mycmp;
+
+    verify();
+    for (i = 0; i < 10000; i++) {
+        j = randomnumber(&seed);
+        j %= NSTR;
+        printf("trial: %d\n", i);
+        if (in[j]) {
+            printf("deleting %s (%d)\n", strings[j], j);
+            deltest(strings[j]);
+            in[j] = 0;
+        } else {
+            printf("adding %s (%d)\n", strings[j], j);
+            addtest(strings[j]);
+            in[j] = 1;
+        }
+        disptree(tree);
+        findtest();
+    }
+
+    while (arraylen > 0) {
+        j = randomnumber(&seed);
+        j %= arraylen;
+        deltest(array[j]);
+    }
+
+    freetree234(tree);
+
+    /*
+     * Now try an unsorted tree. We don't really need to test
+     * delpos234 because we know del234 is based on it, so it's
+     * already been tested in the above sorted-tree code; but for
+     * completeness we'll use it to tear down our unsorted tree
+     * once we've built it.
+     */
+    tree = newtree234(NULL);
+    cmp = NULL;
+    verify();
+    for (i = 0; i < 1000; i++) {
+        printf("trial: %d\n", i);
+        j = randomnumber(&seed);
+        j %= NSTR;
+        k = randomnumber(&seed);
+        k %= count234(tree)+1;
+        printf("adding string %s at index %d\n", strings[j], k);
+        addpostest(strings[j], k);
+    }
+
+    /*
+     * While we have this tree in its full form, we'll take a copy
+     * of it to use in split and join testing.
+     */
+    tree2 = copytree234(tree, NULL, NULL);
+    verifytree(tree2, array, arraylen);/* check the copy is accurate */
+    /*
+     * Split tests. Split the tree at every possible point and
+     * check the resulting subtrees.
+     */
+    tworoot = (!tree2->root->elems[1]);/* see if it has a 2-root */
+    splittest(tree2, array, arraylen);
+    /*
+     * Now do the split test again, but on a tree that has a 2-root
+     * (if the previous one didn't) or doesn't (if the previous one
+     * did).
+     */
+    tmplen = arraylen;
+    while ((!tree2->root->elems[1]) == tworoot) {
+        delpos234(tree2, --tmplen);
+    }
+    printf("now trying splits on second tree\n");
+    splittest(tree2, array, tmplen);
+    freetree234(tree2);
+
+    /*
+     * Back to the main testing of uncounted trees.
+     */
+    while (count234(tree) > 0) {
+        printf("cleanup: tree size %d\n", count234(tree));
+        j = randomnumber(&seed);
+        j %= count234(tree);
+        printf("deleting string %s from index %d\n", (char *)array[j], j);
+        delpostest(j);
+    }
+    freetree234(tree);
+
+    /*
+     * Finally, do some testing on split/join on _sorted_ trees. At
+     * the same time, we'll be testing split on very small trees.
+     */
+    tree = newtree234(mycmp);
+    cmp = mycmp;
+    arraylen = 0;
+    for (i = 0; i < 17; i++) {
+        tree2 = copytree234(tree, NULL, NULL);
+        splittest(tree2, array, arraylen);
+        freetree234(tree2);
+        if (i < 16)
+            addtest(strings[i]);
+    }
+    freetree234(tree);
+
+    /*
+     * Test silly cases of join: join(emptytree, emptytree), and
+     * also ensure join correctly spots when sorted trees fail the
+     * ordering constraint.
+     */
+    tree = newtree234(mycmp);
+    tree2 = newtree234(mycmp);
+    tree3 = newtree234(mycmp);
+    tree4 = newtree234(mycmp);
+    assert(mycmp(strings[0], strings[1]) < 0);   /* just in case :-) */
+    add234(tree2, strings[1]);
+    add234(tree4, strings[0]);
+    array[0] = strings[0];
+    array[1] = strings[1];
+    verifytree(tree, array, 0);
+    verifytree(tree2, array+1, 1);
+    verifytree(tree3, array, 0);
+    verifytree(tree4, array, 1);
+
+    /*
+     * So:
+     *  - join(tree,tree3) should leave both tree and tree3 unchanged.
+     *  - joinr(tree,tree2) should leave both tree and tree2 unchanged.
+     *  - join(tree4,tree3) should leave both tree3 and tree4 unchanged.
+     *  - join(tree, tree2) should move the element from tree2 to tree.
+     *  - joinr(tree4, tree3) should move the element from tree4 to tree3.
+     *  - join(tree,tree3) should return NULL and leave both unchanged.
+     *  - join(tree3,tree) should work and create a bigger tree in tree3.
+     */
+    assert(tree == join234(tree, tree3));
+    verifytree(tree, array, 0);
+    verifytree(tree3, array, 0);
+    assert(tree2 == join234r(tree, tree2));
+    verifytree(tree, array, 0);
+    verifytree(tree2, array+1, 1);
+    assert(tree4 == join234(tree4, tree3));
+    verifytree(tree3, array, 0);
+    verifytree(tree4, array, 1);
+    assert(tree == join234(tree, tree2));
+    verifytree(tree, array+1, 1);
+    verifytree(tree2, array, 0);
+    assert(tree3 == join234r(tree4, tree3));
+    verifytree(tree3, array, 1);
+    verifytree(tree4, array, 0);
+    assert(NULL == join234(tree, tree3));
+    verifytree(tree, array+1, 1);
+    verifytree(tree3, array, 1);
+    assert(tree3 == join234(tree3, tree));
+    verifytree(tree3, array, 2);
+    verifytree(tree, array, 0);
+
+    return 0;
+}
+
+#endif
+
+#if 0 /* sorted list of strings might be useful */
+{
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x",
+}
+#endif
diff --git a/apps/plugins/puzzles/tree234.h b/apps/plugins/puzzles/tree234.h
new file mode 100644
index 0000000000..f75c8f7fb3
--- /dev/null
+++ b/apps/plugins/puzzles/tree234.h
@@ -0,0 +1,202 @@
+/*
+ * tree234.h: header defining functions in tree234.c.
+ * 
+ * This file is copyright 1999-2001 Simon Tatham.
+ * 
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL SIMON TATHAM BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef TREE234_H
+#define TREE234_H
+
+/*
+ * This typedef is opaque outside tree234.c itself.
+ */
+typedef struct tree234_Tag tree234;
+
+typedef int (*cmpfn234)(void *, void *);
+
+typedef void *(*copyfn234)(void *state, void *element);
+
+/*
+ * Create a 2-3-4 tree. If `cmp' is NULL, the tree is unsorted, and
+ * lookups by key will fail: you can only look things up by numeric
+ * index, and you have to use addpos234() and delpos234().
+ */
+tree234 *newtree234(cmpfn234 cmp);
+
+/*
+ * Free a 2-3-4 tree (not including freeing the elements).
+ */
+void freetree234(tree234 *t);
+
+/*
+ * Add an element e to a sorted 2-3-4 tree t. Returns e on success,
+ * or if an existing element compares equal, returns that.
+ */
+void *add234(tree234 *t, void *e);
+
+/*
+ * Add an element e to an unsorted 2-3-4 tree t. Returns e on
+ * success, NULL on failure. (Failure should only occur if the
+ * index is out of range or the tree is sorted.)
+ * 
+ * Index range can be from 0 to the tree's current element count,
+ * inclusive.
+ */
+void *addpos234(tree234 *t, void *e, int index);
+
+/*
+ * Look up the element at a given numeric index in a 2-3-4 tree.
+ * Returns NULL if the index is out of range.
+ * 
+ * One obvious use for this function is in iterating over the whole
+ * of a tree (sorted or unsorted):
+ * 
+ *   for (i = 0; (p = index234(tree, i)) != NULL; i++) consume(p);
+ * 
+ * or
+ * 
+ *   int maxcount = count234(tree);
+ *   for (i = 0; i < maxcount; i++) {
+ *       p = index234(tree, i);
+ *       assert(p != NULL);
+ *       consume(p);
+ *   }
+ */
+void *index234(tree234 *t, int index);
+
+/*
+ * Find an element e in a sorted 2-3-4 tree t. Returns NULL if not
+ * found. e is always passed as the first argument to cmp, so cmp
+ * can be an asymmetric function if desired. cmp can also be passed
+ * as NULL, in which case the compare function from the tree proper
+ * will be used.
+ * 
+ * Three of these functions are special cases of findrelpos234. The
+ * non-`pos' variants lack the `index' parameter: if the parameter
+ * is present and non-NULL, it must point to an integer variable
+ * which will be filled with the numeric index of the returned
+ * element.
+ * 
+ * The non-`rel' variants lack the `relation' parameter. This
+ * parameter allows you to specify what relation the element you
+ * provide has to the element you're looking for. This parameter
+ * can be:
+ * 
+ *   REL234_EQ     - find only an element that compares equal to e
+ *   REL234_LT     - find the greatest element that compares < e
+ *   REL234_LE     - find the greatest element that compares <= e
+ *   REL234_GT     - find the smallest element that compares > e
+ *   REL234_GE     - find the smallest element that compares >= e
+ * 
+ * Non-`rel' variants assume REL234_EQ.
+ * 
+ * If `rel' is REL234_GT or REL234_LT, the `e' parameter may be
+ * NULL. In this case, REL234_GT will return the smallest element
+ * in the tree, and REL234_LT will return the greatest. This gives
+ * an alternative means of iterating over a sorted tree, instead of
+ * using index234:
+ * 
+ *   // to loop forwards
+ *   for (p = NULL; (p = findrel234(tree, p, NULL, REL234_GT)) != NULL ;)
+ *       consume(p);
+ * 
+ *   // to loop backwards
+ *   for (p = NULL; (p = findrel234(tree, p, NULL, REL234_LT)) != NULL ;)
+ *       consume(p);
+ */
+enum {
+    REL234_EQ, REL234_LT, REL234_LE, REL234_GT, REL234_GE
+};
+void *find234(tree234 *t, void *e, cmpfn234 cmp);
+void *findrel234(tree234 *t, void *e, cmpfn234 cmp, int relation);
+void *findpos234(tree234 *t, void *e, cmpfn234 cmp, int *index);
+void *findrelpos234(tree234 *t, void *e, cmpfn234 cmp, int relation,
+                    int *index);
+
+/*
+ * Delete an element e in a 2-3-4 tree. Does not free the element,
+ * merely removes all links to it from the tree nodes.
+ * 
+ * delpos234 deletes the element at a particular tree index: it
+ * works on both sorted and unsorted trees.
+ * 
+ * del234 deletes the element passed to it, so it only works on
+ * sorted trees. (It's equivalent to using findpos234 to determine
+ * the index of an element, and then passing that index to
+ * delpos234.)
+ * 
+ * Both functions return a pointer to the element they delete, for
+ * the user to free or pass on elsewhere or whatever. If the index
+ * is out of range (delpos234) or the element is already not in the
+ * tree (del234) then they return NULL.
+ */
+void *del234(tree234 *t, void *e);
+void *delpos234(tree234 *t, int index);
+
+/*
+ * Return the total element count of a tree234.
+ */
+int count234(tree234 *t);
+
+/*
+ * Split a tree234 into two valid tree234s.
+ * 
+ * splitpos234 splits at a given index. If `before' is TRUE, the
+ * items at and after that index are left in t and the ones before
+ * are returned; if `before' is FALSE, the items before that index
+ * are left in t and the rest are returned.
+ * 
+ * split234 splits at a given key. You can pass any of the
+ * relations used with findrel234, except for REL234_EQ. The items
+ * in the tree that satisfy the relation are returned; the
+ * remainder are left.
+ */
+tree234 *splitpos234(tree234 *t, int index, int before);
+tree234 *split234(tree234 *t, void *e, cmpfn234 cmp, int rel);
+
+/*
+ * Join two tree234s together into a single one.
+ * 
+ * All the elements in t1 are placed to the left of all the
+ * elements in t2. If the trees are sorted, there will be a test to
+ * ensure that this satisfies the ordering criterion, and NULL will
+ * be returned otherwise. If the trees are unsorted, there is no
+ * restriction on the use of join234.
+ * 
+ * The tree returned is t1 (join234) or t2 (join234r), if the
+ * operation is successful.
+ */
+tree234 *join234(tree234 *t1, tree234 *t2);
+tree234 *join234r(tree234 *t1, tree234 *t2);
+
+/*
+ * Make a complete copy of a tree234. Element pointers will be
+ * reused unless copyfn is non-NULL, in which case it will be used
+ * to copy each element. (copyfn takes two `void *' parameters; the
+ * first is private state and the second is the element. A simple
+ * copy routine probably won't need private state.)
+ */
+tree234 *copytree234(tree234 *t, copyfn234 copyfn, void *copyfnstate);
+
+#endif /* TREE234_H */
diff --git a/apps/plugins/puzzles/twiddle.R b/apps/plugins/puzzles/twiddle.R
new file mode 100644
index 0000000000..1495c33181
--- /dev/null
+++ b/apps/plugins/puzzles/twiddle.R
@@ -0,0 +1,19 @@
+# -*- makefile -*-
+
+twiddle  : [X] GTK COMMON twiddle twiddle-icon|no-icon
+
+twiddle  : [G] WINDOWS COMMON twiddle twiddle.res|noicon.res
+
+ALL += twiddle[COMBINED]
+
+!begin am gtk
+GAMES += twiddle
+!end
+
+!begin >list.c
+    A(twiddle) \
+!end
+
+!begin >gamedesc.txt
+twiddle:twiddle.exe:Twiddle:Rotational sliding block puzzle:Rotate the tiles around themselves to arrange them into order.
+!end
diff --git a/apps/plugins/puzzles/twiddle.c b/apps/plugins/puzzles/twiddle.c
new file mode 100644
index 0000000000..2a2ab668ca
--- /dev/null
+++ b/apps/plugins/puzzles/twiddle.c
@@ -0,0 +1,1319 @@
+/*
+ * twiddle.c: Puzzle involving rearranging a grid of squares by
+ * rotating subsquares. Adapted and generalised from a
+ * door-unlocking puzzle in Metroid Prime 2 (the one in the Main
+ * Gyro Chamber).
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#define PREFERRED_TILE_SIZE 48
+#define TILE_SIZE (ds->tilesize)
+#define BORDER    (TILE_SIZE / 2)
+#define HIGHLIGHT_WIDTH (TILE_SIZE / 20)
+#define COORD(x)  ( (x) * TILE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
+
+#define ANIM_PER_BLKSIZE_UNIT 0.13F
+#define FLASH_FRAME 0.13F
+
+enum {
+    COL_BACKGROUND,
+    COL_TEXT,
+    COL_HIGHLIGHT,
+    COL_HIGHLIGHT_GENTLE,
+    COL_LOWLIGHT,
+    COL_LOWLIGHT_GENTLE,
+    COL_HIGHCURSOR, COL_LOWCURSOR,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h, n;
+    int rowsonly;
+    int orientable;
+    int movetarget;
+};
+
+struct game_state {
+    int w, h, n;
+    int orientable;
+    int *grid;
+    int completed;
+    int used_solve;                    /* used to suppress completion flash */
+    int movecount, movetarget;
+    int lastx, lasty, lastr;           /* coordinates of last rotation */
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = 3;
+    ret->n = 2;
+    ret->rowsonly = ret->orientable = FALSE;
+    ret->movetarget = 0;
+
+    return ret;
+}
+
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    static struct {
+        char *title;
+        game_params params;
+    } presets[] = {
+        { "3x3 rows only", { 3, 3, 2, TRUE, FALSE } },
+        { "3x3 normal", { 3, 3, 2, FALSE, FALSE } },
+        { "3x3 orientable", { 3, 3, 2, FALSE, TRUE } },
+        { "4x4 normal", { 4, 4, 2, FALSE } },
+        { "4x4 orientable", { 4, 4, 2, FALSE, TRUE } },
+        { "4x4, rotating 3x3 blocks", { 4, 4, 3, FALSE } },
+        { "5x5, rotating 3x3 blocks", { 5, 5, 3, FALSE } },
+        { "6x6, rotating 4x4 blocks", { 6, 6, 4, FALSE } },
+    };
+
+    if (i < 0 || i >= lenof(presets))
+        return FALSE;
+
+    *name = dupstr(presets[i].title);
+    *params = dup_params(&presets[i].params);
+
+    return TRUE;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    ret->w = ret->h = atoi(string);
+    ret->n = 2;
+    ret->rowsonly = ret->orientable = FALSE;
+    ret->movetarget = 0;
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        ret->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 'n') {
+        string++;
+        ret->n = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    while (*string) {
+        if (*string == 'r') {
+            ret->rowsonly = TRUE;
+        } else if (*string == 'o') {
+            ret->orientable = TRUE;
+        } else if (*string == 'm') {
+            string++;
+            ret->movetarget = atoi(string);
+            while (string[1] && isdigit((unsigned char)string[1])) string++;
+        }
+        string++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[256];
+    sprintf(buf, "%dx%dn%d%s%s", params->w, params->h, params->n,
+            params->rowsonly ? "r" : "",
+            params->orientable ? "o" : "");
+    /* Shuffle limit is part of the limited parameters, because we have to
+     * supply the target move count. */
+    if (params->movetarget)
+        sprintf(buf + strlen(buf), "m%d", params->movetarget);
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(7, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Rotating block size";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->n);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = "One number per row";
+    ret[3].type = C_BOOLEAN;
+    ret[3].sval = NULL;
+    ret[3].ival = params->rowsonly;
+
+    ret[4].name = "Orientation matters";
+    ret[4].type = C_BOOLEAN;
+    ret[4].sval = NULL;
+    ret[4].ival = params->orientable;
+
+    ret[5].name = "Number of shuffling moves";
+    ret[5].type = C_STRING;
+    sprintf(buf, "%d", params->movetarget);
+    ret[5].sval = dupstr(buf);
+    ret[5].ival = 0;
+
+    ret[6].name = NULL;
+    ret[6].type = C_END;
+    ret[6].sval = NULL;
+    ret[6].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->n = atoi(cfg[2].sval);
+    ret->rowsonly = cfg[3].ival;
+    ret->orientable = cfg[4].ival;
+    ret->movetarget = atoi(cfg[5].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->n < 2)
+        return "Rotating block size must be at least two";
+    if (params->w < params->n)
+        return "Width must be at least the rotating block size";
+    if (params->h < params->n)
+        return "Height must be at least the rotating block size";
+    return NULL;
+}
+
+/*
+ * This function actually performs a rotation on a grid. The `x'
+ * and `y' coordinates passed in are the coordinates of the _top
+ * left corner_ of the rotated region. (Using the centre would have
+ * involved half-integers and been annoyingly fiddly. Clicking in
+ * the centre is good for a user interface, but too inconvenient to
+ * use internally.)
+ */
+static void do_rotate(int *grid, int w, int h, int n, int orientable,
+                      int x, int y, int dir)
+{
+    int i, j;
+
+    assert(x >= 0 && x+n <= w);
+    assert(y >= 0 && y+n <= h);
+    dir &= 3;
+    if (dir == 0)
+        return;                        /* nothing to do */
+
+    grid += y*w+x;                     /* translate region to top corner */
+
+    /*
+     * If we were leaving the result of the rotation in a separate
+     * grid, the simple thing to do would be to loop over each
+     * square within the rotated region and assign it from its
+     * source square. However, to do it in place without taking
+     * O(n^2) memory, we need to be marginally more clever. What
+     * I'm going to do is loop over about one _quarter_ of the
+     * rotated region and permute each element within that quarter
+     * with its rotational coset.
+     * 
+     * The size of the region I need to loop over is (n+1)/2 by
+     * n/2, which is an obvious exact quarter for even n and is a
+     * rectangle for odd n. (For odd n, this technique leaves out
+     * one element of the square, which is of course the central
+     * one that never moves anyway.)
+     */
+    for (i = 0; i < (n+1)/2; i++) {
+        for (j = 0; j < n/2; j++) {
+            int k;
+            int g[4];
+            int p[4];
+            
+            p[0] = j*w+i;
+            p[1] = i*w+(n-j-1);
+            p[2] = (n-j-1)*w+(n-i-1);
+            p[3] = (n-i-1)*w+j;
+
+            for (k = 0; k < 4; k++)
+                g[k] = grid[p[k]];
+
+            for (k = 0; k < 4; k++) {
+                int v = g[(k+dir) & 3];
+                if (orientable)
+                    v ^= ((v+dir) ^ v) & 3;  /* alter orientation */
+                grid[p[k]] = v;
+            }
+        }
+    }
+
+    /*
+     * Don't forget the orientation on the centre square, if n is
+     * odd.
+     */
+    if (orientable && (n & 1)) {
+        int v = grid[n/2*(w+1)];
+        v ^= ((v+dir) ^ v) & 3;  /* alter orientation */
+        grid[n/2*(w+1)] = v;
+    }
+}
+
+static int grid_complete(int *grid, int wh, int orientable)
+{
+    int ok = TRUE;
+    int i;
+    for (i = 1; i < wh; i++)
+        if (grid[i] < grid[i-1])
+            ok = FALSE;
+    if (orientable) {
+        for (i = 0; i < wh; i++)
+            if (grid[i] & 3)
+                ok = FALSE;
+    }
+    return ok;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int *grid;
+    int w = params->w, h = params->h, n = params->n, wh = w*h;
+    int i;
+    char *ret;
+    int retlen;
+    int total_moves;
+
+    /*
+     * Set up a solved grid.
+     */
+    grid = snewn(wh, int);
+    for (i = 0; i < wh; i++)
+        grid[i] = ((params->rowsonly ? i/w : i) + 1) * 4;
+
+    /*
+     * Shuffle it. This game is complex enough that I don't feel up
+     * to analysing its full symmetry properties (particularly at
+     * n=4 and above!), so I'm going to do it the pedestrian way
+     * and simply shuffle the grid by making a long sequence of
+     * randomly chosen moves.
+     */
+    total_moves = params->movetarget;
+    if (!total_moves)
+        /* Add a random move to avoid parity issues. */
+        total_moves = w*h*n*n*2 + random_upto(rs, 2);
+
+    do {
+        int *prevmoves;
+        int rw, rh;                    /* w/h of rotation centre space */
+
+        rw = w - n + 1;
+        rh = h - n + 1;
+        prevmoves = snewn(rw * rh, int);
+        for (i = 0; i < rw * rh; i++)
+            prevmoves[i] = 0;
+
+        for (i = 0; i < total_moves; i++) {
+            int x, y, r, oldtotal, newtotal, dx, dy;
+
+            do {
+                x = random_upto(rs, w - n + 1);
+                y = random_upto(rs, h - n + 1);
+                r = 2 * random_upto(rs, 2) - 1;
+
+                /*
+                 * See if any previous rotations has happened at
+                 * this point which nothing has overlapped since.
+                 * If so, ensure we haven't either undone a
+                 * previous move or repeated one so many times that
+                 * it turns into fewer moves in the inverse
+                 * direction (i.e. three identical rotations).
+                 */
+                oldtotal = prevmoves[y*rw+x];
+                newtotal = oldtotal + r;
+                
+                /*
+                 * Special case here for w==h==n, in which case
+                 * there is actually no way to _avoid_ all moves
+                 * repeating or undoing previous ones.
+                 */
+            } while ((w != n || h != n) &&
+                     (abs(newtotal) < abs(oldtotal) || abs(newtotal) > 2));
+
+            do_rotate(grid, w, h, n, params->orientable, x, y, r);
+
+            /*
+             * Log the rotation we've just performed at this point,
+             * for inversion detection in the next move.
+             * 
+             * Also zero a section of the prevmoves array, because
+             * any rotation area which _overlaps_ this one is now
+             * entirely safe to perform further moves in.
+             * 
+             * Two rotation areas overlap if their top left
+             * coordinates differ by strictly less than n in both
+             * directions
+             */
+            prevmoves[y*rw+x] += r;
+            for (dy = -n+1; dy <= n-1; dy++) {
+                if (y + dy < 0 || y + dy >= rh)
+                    continue;
+                for (dx = -n+1; dx <= n-1; dx++) {
+                    if (x + dx < 0 || x + dx >= rw)
+                        continue;
+                    if (dx == 0 && dy == 0)
+                        continue;
+                    prevmoves[(y+dy)*rw+(x+dx)] = 0;
+                }
+            }
+        }
+
+        sfree(prevmoves);
+
+    } while (grid_complete(grid, wh, params->orientable));
+
+    /*
+     * Now construct the game description, by describing the grid
+     * as a simple sequence of integers. They're comma-separated,
+     * unless the puzzle is orientable in which case they're
+     * separated by orientation letters `u', `d', `l' and `r'.
+     */
+    ret = NULL;
+    retlen = 0;
+    for (i = 0; i < wh; i++) {
+        char buf[80];
+        int k;
+
+        k = sprintf(buf, "%d%c", grid[i] / 4,
+                    (char)(params->orientable ? "uldr"[grid[i] & 3] : ','));
+
+        ret = sresize(ret, retlen + k + 1, char);
+        strcpy(ret + retlen, buf);
+        retlen += k;
+    }
+    if (!params->orientable)
+        ret[retlen-1] = '\0';          /* delete last comma */
+
+    sfree(grid);
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    const char *p;
+    int w = params->w, h = params->h, wh = w*h;
+    int i;
+
+    p = desc;
+
+    for (i = 0; i < wh; i++) {
+        if (*p < '0' || *p > '9')
+            return "Not enough numbers in string";
+        while (*p >= '0' && *p <= '9')
+            p++;
+        if (!params->orientable && i < wh-1) {
+            if (*p != ',')
+                return "Expected comma after number";
+        } else if (params->orientable && i < wh) {
+            if (*p != 'l' && *p != 'r' && *p != 'u' && *p != 'd')
+                return "Expected orientation letter after number";
+        } else if (i == wh-1 && *p) {
+            return "Excess junk at end of string";
+        }
+
+        if (*p) p++;                   /* eat comma */
+    }
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+    int w = params->w, h = params->h, n = params->n, wh = w*h;
+    int i;
+    const char *p;
+
+    state->w = w;
+    state->h = h;
+    state->n = n;
+    state->orientable = params->orientable;
+    state->completed = 0;
+    state->used_solve = FALSE;
+    state->movecount = 0;
+    state->movetarget = params->movetarget;
+    state->lastx = state->lasty = state->lastr = -1;
+
+    state->grid = snewn(wh, int);
+
+    p = desc;
+
+    for (i = 0; i < wh; i++) {
+        state->grid[i] = 4 * atoi(p);
+        while (*p >= '0' && *p <= '9')
+            p++;
+        if (*p) {
+            if (params->orientable) {
+                switch (*p) {
+                  case 'l': state->grid[i] |= 1; break;
+                  case 'd': state->grid[i] |= 2; break;
+                  case 'r': state->grid[i] |= 3; break;
+                }
+            }
+            p++;
+        }
+    }
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->n = state->n;
+    ret->orientable = state->orientable;
+    ret->completed = state->completed;
+    ret->movecount = state->movecount;
+    ret->movetarget = state->movetarget;
+    ret->lastx = state->lastx;
+    ret->lasty = state->lasty;
+    ret->lastr = state->lastr;
+    ret->used_solve = state->used_solve;
+
+    ret->grid = snewn(ret->w * ret->h, int);
+    memcpy(ret->grid, state->grid, ret->w * ret->h * sizeof(int));
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    sfree(state);
+}
+
+static int compare_int(const void *av, const void *bv)
+{
+    const int *a = (const int *)av;
+    const int *b = (const int *)bv;
+    if (*a < *b)
+        return -1;
+    else if (*a > *b)
+        return +1;
+    else
+        return 0;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return dupstr("S");
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    char *ret, *p, buf[80];
+    int i, x, y, col, o, maxlen;
+
+    /*
+     * First work out how many characters we need to display each
+     * number. We're pretty flexible on grid contents here, so we
+     * have to scan the entire grid.
+     */
+    col = 0;
+    for (i = 0; i < state->w * state->h; i++) {
+        x = sprintf(buf, "%d", state->grid[i] / 4);
+        if (col < x) col = x;
+    }
+    o = (state->orientable ? 1 : 0);
+
+    /*
+     * Now we know the exact total size of the grid we're going to
+     * produce: it's got h rows, each containing w lots of col+o,
+     * w-1 spaces and a trailing newline.
+     */
+    maxlen = state->h * state->w * (col+o+1);
+
+    ret = snewn(maxlen+1, char);
+    p = ret;
+
+    for (y = 0; y < state->h; y++) {
+        for (x = 0; x < state->w; x++) {
+            int v = state->grid[state->w*y+x];
+            sprintf(buf, "%*d", col, v/4);
+            memcpy(p, buf, col);
+            p += col;
+            if (o)
+                *p++ = "^<v>"[v & 3];
+            if (x+1 == state->w)
+                *p++ = '\n';
+            else
+                *p++ = ' ';
+        }
+    }
+
+    assert(p - ret == maxlen);
+    *p = '\0';
+    return ret;
+}
+
+struct game_ui {
+    int cur_x, cur_y;
+    int cur_visible;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->cur_x = 0;
+    ui->cur_y = 0;
+    ui->cur_visible = FALSE;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int started;
+    int w, h, bgcolour;
+    int *grid;
+    int tilesize;
+    int cur_x, cur_y;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->w, h = state->h, n = state->n /* , wh = w*h */;
+    char buf[80];
+    int dir;
+
+    button = button & (~MOD_MASK | MOD_NUM_KEYPAD);
+
+    if (IS_CURSOR_MOVE(button)) {
+        if (button == CURSOR_LEFT && ui->cur_x > 0)
+            ui->cur_x--;
+        if (button == CURSOR_RIGHT && (ui->cur_x+n) < (w))
+            ui->cur_x++;
+        if (button == CURSOR_UP && ui->cur_y > 0)
+            ui->cur_y--;
+        if (button == CURSOR_DOWN && (ui->cur_y+n) < (h))
+            ui->cur_y++;
+        ui->cur_visible = 1;
+        return "";
+    }
+
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
+        /*
+         * Determine the coordinates of the click. We offset by n-1
+         * half-blocks so that the user must click at the centre of
+         * a rotation region rather than at the corner.
+         */
+        x -= (n-1) * TILE_SIZE / 2;
+        y -= (n-1) * TILE_SIZE / 2;
+        x = FROMCOORD(x);
+        y = FROMCOORD(y);
+        dir = (button == LEFT_BUTTON ? 1 : -1);
+        if (x < 0 || x > w-n || y < 0 || y > h-n)
+            return NULL;
+        ui->cur_visible = 0;
+    } else if (IS_CURSOR_SELECT(button)) {
+        if (ui->cur_visible) {
+            x = ui->cur_x;
+            y = ui->cur_y;
+            dir = (button == CURSOR_SELECT2) ? -1 : +1;
+        } else {
+            ui->cur_visible = 1;
+            return "";
+        }
+    } else if (button == 'a' || button == 'A' || button==MOD_NUM_KEYPAD+'7') {
+        x = y = 0;
+        dir = (button == 'A' ? -1 : +1);
+    } else if (button == 'b' || button == 'B' || button==MOD_NUM_KEYPAD+'9') {
+        x = w-n;
+        y = 0;
+        dir = (button == 'B' ? -1 : +1);
+    } else if (button == 'c' || button == 'C' || button==MOD_NUM_KEYPAD+'1') {
+        x = 0;
+        y = h-n;
+        dir = (button == 'C' ? -1 : +1);
+    } else if (button == 'd' || button == 'D' || button==MOD_NUM_KEYPAD+'3') {
+        x = w-n;
+        y = h-n;
+        dir = (button == 'D' ? -1 : +1);
+    } else if (button==MOD_NUM_KEYPAD+'8' && (w-n) % 2 == 0) {
+        x = (w-n) / 2;
+        y = 0;
+        dir = +1;
+    } else if (button==MOD_NUM_KEYPAD+'2' && (w-n) % 2 == 0) {
+        x = (w-n) / 2;
+        y = h-n;
+        dir = +1;
+    } else if (button==MOD_NUM_KEYPAD+'4' && (h-n) % 2 == 0) {
+        x = 0;
+        y = (h-n) / 2;
+        dir = +1;
+    } else if (button==MOD_NUM_KEYPAD+'6' && (h-n) % 2 == 0) {
+        x = w-n;
+        y = (h-n) / 2;
+        dir = +1;
+    } else if (button==MOD_NUM_KEYPAD+'5' && (w-n) % 2 == 0 && (h-n) % 2 == 0){
+        x = (w-n) / 2;
+        y = (h-n) / 2;
+        dir = +1;
+    } else {
+        return NULL;                   /* no move to be made */
+    }
+
+    /*
+     * If we reach here, we have a valid move.
+     */
+    sprintf(buf, "M%d,%d,%d", x, y, dir);
+    return dupstr(buf);
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    game_state *ret;
+    int w = from->w, h = from->h, n = from->n, wh = w*h;
+    int x, y, dir;
+
+    if (!strcmp(move, "S")) {
+        int i;
+        ret = dup_game(from);
+
+        /*
+         * Simply replace the grid with a solved one. For this game,
+         * this isn't a useful operation for actually telling the user
+         * what they should have done, but it is useful for
+         * conveniently being able to get hold of a clean state from
+         * which to practise manoeuvres.
+         */
+        qsort(ret->grid, ret->w*ret->h, sizeof(int), compare_int);
+        for (i = 0; i < ret->w*ret->h; i++)
+            ret->grid[i] &= ~3;
+        ret->used_solve = TRUE;
+        ret->completed = ret->movecount = 1;
+
+        return ret;
+    }
+
+    if (move[0] != 'M' ||
+        sscanf(move+1, "%d,%d,%d", &x, &y, &dir) != 3 ||
+        x < 0 || y < 0 || x > from->w - n || y > from->h - n)
+        return NULL;                   /* can't parse this move string */
+
+    ret = dup_game(from);
+    ret->movecount++;
+    do_rotate(ret->grid, w, h, n, ret->orientable, x, y, dir);
+    ret->lastx = x;
+    ret->lasty = y;
+    ret->lastr = dir;
+
+    /*
+     * See if the game has been completed. To do this we simply
+     * test that the grid contents are in increasing order.
+     */
+    if (!ret->completed && grid_complete(ret->grid, wh, ret->orientable))
+        ret->completed = ret->movecount;
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = TILE_SIZE * params->w + 2 * BORDER;
+    *y = TILE_SIZE * params->h + 2 * BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    /* cursor is light-background with a red tinge. */
+    ret[COL_HIGHCURSOR * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 1.0F;
+    ret[COL_HIGHCURSOR * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 0.5F;
+    ret[COL_HIGHCURSOR * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 0.5F;
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_HIGHLIGHT_GENTLE * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 1.1F;
+        ret[COL_LOWLIGHT_GENTLE * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 0.9F;
+        ret[COL_TEXT * 3 + i] = 0.0;
+        ret[COL_LOWCURSOR * 3 + i] = ret[COL_HIGHCURSOR * 3 + i] * 0.6F;
+    }
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->started = FALSE;
+    ds->w = state->w;
+    ds->h = state->h;
+    ds->bgcolour = COL_BACKGROUND;
+    ds->grid = snewn(ds->w*ds->h, int);
+    ds->tilesize = 0;                  /* haven't decided yet */
+    for (i = 0; i < ds->w*ds->h; i++)
+        ds->grid[i] = -1;
+    ds->cur_x = ds->cur_y = -state->n;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+struct rotation {
+    int cx, cy, cw, ch;                /* clip region */
+    int ox, oy;                        /* rotation origin */
+    float c, s;                        /* cos and sin of rotation angle */
+    int lc, rc, tc, bc;                /* colours of tile edges */
+};
+
+static void rotate(int *xy, struct rotation *rot)
+{
+    if (rot) {
+        float xf = (float)xy[0] - rot->ox, yf = (float)xy[1] - rot->oy;
+        float xf2, yf2;
+
+        xf2 = rot->c * xf + rot->s * yf;
+        yf2 = - rot->s * xf + rot->c * yf;
+
+        xy[0] = (int)(xf2 + rot->ox + 0.5);   /* round to nearest */
+        xy[1] = (int)(yf2 + rot->oy + 0.5);   /* round to nearest */
+    }
+}
+
+#define CUR_TOP         1
+#define CUR_RIGHT       2
+#define CUR_BOTTOM      4
+#define CUR_LEFT        8
+
+static void draw_tile(drawing *dr, game_drawstate *ds, const game_state *state,
+                      int x, int y, int tile, int flash_colour,
+                      struct rotation *rot, unsigned cedges)
+{
+    int coords[8];
+    char str[40];
+
+    /*
+     * If we've been passed a rotation region but we're drawing a
+     * tile which is outside it, we must draw it normally. This can
+     * occur if we're cleaning up after a completion flash while a
+     * new move is also being made.
+     */
+    if (rot && (x < rot->cx || y < rot->cy ||
+                x >= rot->cx+rot->cw || y >= rot->cy+rot->ch))
+        rot = NULL;
+
+    if (rot)
+        clip(dr, rot->cx, rot->cy, rot->cw, rot->ch);
+
+    /*
+     * We must draw each side of the tile's highlight separately,
+     * because in some cases (during rotation) they will all need
+     * to be different colours.
+     */
+
+    /* The centre point is common to all sides. */
+    coords[4] = x + TILE_SIZE / 2;
+    coords[5] = y + TILE_SIZE / 2;
+    rotate(coords+4, rot);
+
+    /* Right side. */
+    coords[0] = x + TILE_SIZE - 1;
+    coords[1] = y + TILE_SIZE - 1;
+    rotate(coords+0, rot);
+    coords[2] = x + TILE_SIZE - 1;
+    coords[3] = y;
+    rotate(coords+2, rot);
+    draw_polygon(dr, coords, 3, rot ? rot->rc : COL_LOWLIGHT,
+                 rot ? rot->rc : (cedges & CUR_RIGHT) ? COL_LOWCURSOR : COL_LOWLIGHT);
+
+    /* Bottom side. */
+    coords[2] = x;
+    coords[3] = y + TILE_SIZE - 1;
+    rotate(coords+2, rot);
+    draw_polygon(dr, coords, 3, rot ? rot->bc : COL_LOWLIGHT,
+                 rot ? rot->bc : (cedges & CUR_BOTTOM) ? COL_LOWCURSOR : COL_LOWLIGHT);
+
+    /* Left side. */
+    coords[0] = x;
+    coords[1] = y;
+    rotate(coords+0, rot);
+    draw_polygon(dr, coords, 3, rot ? rot->lc : COL_HIGHLIGHT,
+                 rot ? rot->lc : (cedges & CUR_LEFT) ? COL_HIGHCURSOR : COL_HIGHLIGHT);
+
+    /* Top side. */
+    coords[2] = x + TILE_SIZE - 1;
+    coords[3] = y;
+    rotate(coords+2, rot);
+    draw_polygon(dr, coords, 3, rot ? rot->tc : COL_HIGHLIGHT,
+                 rot ? rot->tc : (cedges & CUR_TOP) ? COL_HIGHCURSOR : COL_HIGHLIGHT);
+
+    /*
+     * Now the main blank area in the centre of the tile.
+     */
+    if (rot) {
+        coords[0] = x + HIGHLIGHT_WIDTH;
+        coords[1] = y + HIGHLIGHT_WIDTH;
+        rotate(coords+0, rot);
+        coords[2] = x + HIGHLIGHT_WIDTH;
+        coords[3] = y + TILE_SIZE - 1 - HIGHLIGHT_WIDTH;
+        rotate(coords+2, rot);
+        coords[4] = x + TILE_SIZE - 1 - HIGHLIGHT_WIDTH;
+        coords[5] = y + TILE_SIZE - 1 - HIGHLIGHT_WIDTH;
+        rotate(coords+4, rot);
+        coords[6] = x + TILE_SIZE - 1 - HIGHLIGHT_WIDTH;
+        coords[7] = y + HIGHLIGHT_WIDTH;
+        rotate(coords+6, rot);
+        draw_polygon(dr, coords, 4, flash_colour, flash_colour);
+    } else {
+        draw_rect(dr, x + HIGHLIGHT_WIDTH, y + HIGHLIGHT_WIDTH,
+                  TILE_SIZE - 2*HIGHLIGHT_WIDTH, TILE_SIZE - 2*HIGHLIGHT_WIDTH,
+                  flash_colour);
+    }
+
+    /*
+     * Next, the triangles for orientation.
+     */
+    if (state->orientable) {
+        int xdx, xdy, ydx, ydy;
+        int cx, cy, displ, displ2;
+        switch (tile & 3) {
+          case 0:
+            xdx = 1, xdy = 0;
+            ydx = 0, ydy = 1;
+            break;
+          case 1:
+            xdx = 0, xdy = -1;
+            ydx = 1, ydy = 0;
+            break;
+          case 2:
+            xdx = -1, xdy = 0;
+            ydx = 0, ydy = -1;
+            break;
+          default /* case 3 */:
+            xdx = 0, xdy = 1;
+            ydx = -1, ydy = 0;
+            break;
+        }
+
+        cx = x + TILE_SIZE / 2;
+        cy = y + TILE_SIZE / 2;
+        displ = TILE_SIZE / 2 - HIGHLIGHT_WIDTH - 2;
+        displ2 = TILE_SIZE / 3 - HIGHLIGHT_WIDTH;
+
+        coords[0] = cx - displ * xdx + displ2 * ydx;
+        coords[1] = cy - displ * xdy + displ2 * ydy;
+        rotate(coords+0, rot);
+        coords[2] = cx + displ * xdx + displ2 * ydx;
+        coords[3] = cy + displ * xdy + displ2 * ydy;
+        rotate(coords+2, rot);
+        coords[4] = cx - displ * ydx;
+        coords[5] = cy - displ * ydy;
+        rotate(coords+4, rot);
+        draw_polygon(dr, coords, 3, COL_LOWLIGHT_GENTLE, COL_LOWLIGHT_GENTLE);
+    }
+
+    coords[0] = x + TILE_SIZE/2;
+    coords[1] = y + TILE_SIZE/2;
+    rotate(coords+0, rot);
+    sprintf(str, "%d", tile / 4);
+    draw_text(dr, coords[0], coords[1],
+              FONT_VARIABLE, TILE_SIZE/3, ALIGN_VCENTRE | ALIGN_HCENTRE,
+              COL_TEXT, str);
+
+    if (rot)
+        unclip(dr);
+
+    draw_update(dr, x, y, TILE_SIZE, TILE_SIZE);
+}
+
+static int highlight_colour(float angle)
+{
+    int colours[32] = {
+        COL_LOWLIGHT,
+        COL_LOWLIGHT_GENTLE,
+        COL_LOWLIGHT_GENTLE,
+        COL_LOWLIGHT_GENTLE,
+        COL_HIGHLIGHT_GENTLE,
+        COL_HIGHLIGHT_GENTLE,
+        COL_HIGHLIGHT_GENTLE,
+        COL_HIGHLIGHT,
+        COL_HIGHLIGHT,
+        COL_HIGHLIGHT,
+        COL_HIGHLIGHT,
+        COL_HIGHLIGHT,
+        COL_HIGHLIGHT,
+        COL_HIGHLIGHT,
+        COL_HIGHLIGHT,
+        COL_HIGHLIGHT,
+        COL_HIGHLIGHT,
+        COL_HIGHLIGHT_GENTLE,
+        COL_HIGHLIGHT_GENTLE,
+        COL_HIGHLIGHT_GENTLE,
+        COL_LOWLIGHT_GENTLE,
+        COL_LOWLIGHT_GENTLE,
+        COL_LOWLIGHT_GENTLE,
+        COL_LOWLIGHT,
+        COL_LOWLIGHT,
+        COL_LOWLIGHT,
+        COL_LOWLIGHT,
+        COL_LOWLIGHT,
+        COL_LOWLIGHT,
+        COL_LOWLIGHT,
+        COL_LOWLIGHT,
+        COL_LOWLIGHT,
+    };
+
+    return colours[(int)((angle + 2*PI) / (PI/16)) & 31];
+}
+
+static float game_anim_length_real(const game_state *oldstate,
+                                   const game_state *newstate, int dir,
+                                   const game_ui *ui)
+{
+    /*
+     * Our game_anim_length doesn't need to modify its game_ui, so
+     * this is the real function which declares ui as const. We must
+     * wrap this for the backend structure with a version that has ui
+     * non-const, but we still need this version to call from within
+     * game_redraw which only has a const ui available.
+     */
+    return (float)(ANIM_PER_BLKSIZE_UNIT * sqrt(newstate->n-1));
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return game_anim_length_real(oldstate, newstate, dir, ui);
+
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->used_solve && !newstate->used_solve)
+        return 2 * FLASH_FRAME;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int i, bgcolour;
+    struct rotation srot, *rot;
+    int lastx = -1, lasty = -1, lastr = -1;
+    int cx, cy, cmoved = 0, n = state->n;
+
+    cx = ui->cur_visible ? ui->cur_x : -state->n;
+    cy = ui->cur_visible ? ui->cur_y : -state->n;
+    if (cx != ds->cur_x || cy != ds->cur_y)
+        cmoved = 1;
+
+    if (flashtime > 0) {
+        int frame = (int)(flashtime / FLASH_FRAME);
+        bgcolour = (frame % 2 ? COL_LOWLIGHT : COL_HIGHLIGHT);
+    } else
+        bgcolour = COL_BACKGROUND;
+
+    if (!ds->started) {
+        int coords[10];
+
+        draw_rect(dr, 0, 0,
+                  TILE_SIZE * state->w + 2 * BORDER,
+                  TILE_SIZE * state->h + 2 * BORDER, COL_BACKGROUND);
+        draw_update(dr, 0, 0,
+                    TILE_SIZE * state->w + 2 * BORDER,
+                    TILE_SIZE * state->h + 2 * BORDER);
+
+        /*
+         * Recessed area containing the whole puzzle.
+         */
+        coords[0] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
+        coords[1] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
+        coords[2] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
+        coords[3] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[4] = coords[2] - TILE_SIZE;
+        coords[5] = coords[3] + TILE_SIZE;
+        coords[8] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[9] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
+        coords[6] = coords[8] + TILE_SIZE;
+        coords[7] = coords[9] - TILE_SIZE;
+        draw_polygon(dr, coords, 5, COL_HIGHLIGHT, COL_HIGHLIGHT);
+
+        coords[1] = COORD(0) - HIGHLIGHT_WIDTH;
+        coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
+        draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
+
+        ds->started = TRUE;
+    }
+
+    /*
+     * If we're drawing any rotated tiles, sort out the rotation
+     * parameters, and also zap the rotation region to the
+     * background colour before doing anything else.
+     */
+    if (oldstate) {
+        float angle;
+        float anim_max = game_anim_length_real(oldstate, state, dir, ui);
+
+        if (dir > 0) {
+            lastx = state->lastx;
+            lasty = state->lasty;
+            lastr = state->lastr;
+        } else {
+            lastx = oldstate->lastx;
+            lasty = oldstate->lasty;
+            lastr = -oldstate->lastr;
+        }
+
+        rot = &srot;
+        rot->cx = COORD(lastx);
+        rot->cy = COORD(lasty);
+        rot->cw = rot->ch = TILE_SIZE * state->n;
+        rot->ox = rot->cx + rot->cw/2;
+        rot->oy = rot->cy + rot->ch/2;
+        angle = (float)((-PI/2 * lastr) * (1.0 - animtime / anim_max));
+        rot->c = (float)cos(angle);
+        rot->s = (float)sin(angle);
+
+        /*
+         * Sort out the colours of the various sides of the tile.
+         */
+        rot->lc = highlight_colour((float)PI + angle);
+        rot->rc = highlight_colour(angle);
+        rot->tc = highlight_colour((float)(PI/2.0) + angle);
+        rot->bc = highlight_colour((float)(-PI/2.0) + angle);
+
+        draw_rect(dr, rot->cx, rot->cy, rot->cw, rot->ch, bgcolour);
+    } else
+        rot = NULL;
+
+    /*
+     * Now draw each tile.
+     */
+    for (i = 0; i < state->w * state->h; i++) {
+        int t, cc = 0;
+        int tx = i % state->w, ty = i / state->w;
+
+        /*
+         * Figure out what should be displayed at this location.
+         * Usually it will be state->grid[i], unless we're in the
+         * middle of animating an actual rotation and this cell is
+         * within the rotation region, in which case we set -1
+         * (always display).
+         */
+        if (oldstate && lastx >= 0 && lasty >= 0 &&
+            tx >= lastx && tx < lastx + state->n &&
+            ty >= lasty && ty < lasty + state->n)
+            t = -1;
+        else
+            t = state->grid[i];
+
+        if (cmoved) {
+            /* cursor has moved (or changed visibility)... */
+            if (tx == cx || tx == cx+n-1 || ty == cy || ty == cy+n-1)
+                cc = 1; /* ...we're on new cursor, redraw */
+            if (tx == ds->cur_x || tx == ds->cur_x+n-1 ||
+                ty == ds->cur_y || ty == ds->cur_y+n-1)
+                cc = 1; /* ...we were on old cursor, redraw */
+        }
+
+        if (ds->bgcolour != bgcolour ||   /* always redraw when flashing */
+            ds->grid[i] != t || ds->grid[i] == -1 || t == -1 || cc) {
+            int x = COORD(tx), y = COORD(ty);
+            unsigned cedges = 0;
+
+            if (tx == cx     && ty >= cy && ty <= cy+n-1) cedges |= CUR_LEFT;
+            if (ty == cy     && tx >= cx && tx <= cx+n-1) cedges |= CUR_TOP;
+            if (tx == cx+n-1 && ty >= cy && ty <= cy+n-1) cedges |= CUR_RIGHT;
+            if (ty == cy+n-1 && tx >= cx && tx <= cx+n-1) cedges |= CUR_BOTTOM;
+
+            draw_tile(dr, ds, state, x, y, state->grid[i], bgcolour, rot, cedges);
+            ds->grid[i] = t;
+        }
+    }
+    ds->bgcolour = bgcolour;
+    ds->cur_x = cx; ds->cur_y = cy;
+
+    /*
+     * Update the status bar.
+     */
+    {
+        char statusbuf[256];
+
+        /*
+         * Don't show the new status until we're also showing the
+         * new _state_ - after the game animation is complete.
+         */
+        if (oldstate)
+            state = oldstate;
+
+        if (state->used_solve)
+            sprintf(statusbuf, "Moves since auto-solve: %d",
+                    state->movecount - state->completed);
+        else {
+            sprintf(statusbuf, "%sMoves: %d",
+                    (state->completed ? "COMPLETED! " : ""),
+                    (state->completed ? state->completed : state->movecount));
+            if (state->movetarget)
+                sprintf(statusbuf+strlen(statusbuf), " (target %d)",
+                        state->movetarget);
+        }
+
+        status_bar(dr, statusbuf);
+    }
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame twiddle
+#endif
+
+const struct game thegame = {
+    "Twiddle", "games.twiddle", "twiddle",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/undead.R b/apps/plugins/puzzles/undead.R
new file mode 100644
index 0000000000..5907ed6b74
--- /dev/null
+++ b/apps/plugins/puzzles/undead.R
@@ -0,0 +1,18 @@
+# -*- makefile -*-
+
+undead : [X] GTK COMMON undead undead-icon|no-icon
+undead : [G] WINDOWS COMMON undead undead.res|noicon.res
+
+ALL += undead[COMBINED]
+
+!begin am gtk
+GAMES += undead
+!end
+
+!begin >list.c
+    A(undead) \
+!end
+
+!begin >gamedesc.txt
+undead:undead.exe:Undead:Monster-placing puzzle:Place ghosts, vampires and zombies so that the right numbers of them can be seen in mirrors.
+!end
diff --git a/apps/plugins/puzzles/undead.c b/apps/plugins/puzzles/undead.c
new file mode 100644
index 0000000000..28fd0f35fe
--- /dev/null
+++ b/apps/plugins/puzzles/undead.c
@@ -0,0 +1,2738 @@
+/*
+ * undead: Implementation of Haunted Mirror Mazes
+ *
+ * http://www.janko.at/Raetsel/Spukschloss/index.htm
+ *
+ * Puzzle definition is the total number of each monster type, the
+ * grid definition, and the list of sightings (clockwise, starting
+ * from top left corner)
+ *
+ * Example: (Janko puzzle No. 1,
+ * http://www.janko.at/Raetsel/Spukschloss/001.a.htm )
+ *
+ *   Ghosts: 0 Vampires: 2 Zombies: 6
+ *
+ *     2 1 1 1
+ *   1 \ \ . / 2
+ *   0 \ . / . 2
+ *   0 / . / . 2
+ *   3 . . . \ 2
+ *     3 3 2 2
+ *
+ *  would be encoded into: 
+ *     4x4:0,2,6,LLaRLaRaRaRdL,2,1,1,1,2,2,2,2,2,2,3,3,3,0,0,1
+ *
+ *  Additionally, the game description can contain monsters fixed at a
+ *  certain grid position. The internal generator does not (yet) use
+ *  this feature, but this is needed to enter puzzles like Janko No.
+ *  14, which is encoded as:
+ *  8x5:12,12,0,LaRbLaRaLaRLbRaVaVaGRaRaRaLbLaRbRLb,0,2,0,2,2,1,2,1,3,1,0,1,8,4,3,0,0,2,3,2,7,2,1,6,2,1
+ * 
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_TEXT,
+    COL_ERROR,
+    COL_HIGHLIGHT,
+    COL_FLASH,
+    COL_GHOST,
+    COL_ZOMBIE,
+    COL_VAMPIRE,
+    COL_DONE,
+    NCOLOURS
+};
+
+#define DIFFLIST(A)                             \
+    A(EASY,Easy,e)                              \
+    A(NORMAL,Normal,n)                          \
+    A(TRICKY,Tricky,t)
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const undead_diffnames[] = { DIFFLIST(TITLE) "(count)" };
+static char const undead_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+struct game_params {
+    int w;      /* Grid width */
+    int h;      /* Grid height */
+    int diff;   /* Puzzle difficulty */
+};
+
+static const struct game_params undead_presets[] = {
+    {  4,  4, DIFF_EASY },
+    {  4,  4, DIFF_NORMAL },
+    {  4,  4, DIFF_TRICKY },
+    {  5,  5, DIFF_EASY },
+    {  5,  5, DIFF_NORMAL },
+    {  5,  5, DIFF_TRICKY },
+    {  7,  7, DIFF_EASY },
+    {  7,  7, DIFF_NORMAL }
+};
+
+#define DEFAULT_PRESET 1
+
+static game_params *default_params(void) {
+    game_params *ret = snew(game_params);
+
+    *ret = undead_presets[DEFAULT_PRESET];
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params) {
+    game_params *ret;
+    char buf[64];
+
+    if (i < 0 || i >= lenof(undead_presets)) return FALSE;
+
+    ret = default_params();
+    *ret = undead_presets[i]; /* struct copy */
+    *params = ret;
+
+    sprintf(buf, "%dx%d %s",
+            undead_presets[i].w, undead_presets[i].h,
+            undead_diffnames[undead_presets[i].diff]);
+    *name = dupstr(buf);
+
+    return TRUE;
+}
+
+static void free_params(game_params *params) {
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;            /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string) {
+    params->w = params->h = atoi(string);
+
+    while (*string && isdigit((unsigned char) *string)) ++string;
+    if (*string == 'x') {
+        string++;
+        params->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+
+    params->diff = DIFF_NORMAL;
+    if (*string == 'd') {
+        int i;
+        string++;
+        for (i = 0; i < DIFFCOUNT; i++)
+            if (*string == undead_diffchars[i])
+                params->diff = i;
+        if (*string) string++;
+    }
+
+    return;
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[256];
+    sprintf(buf, "%dx%d", params->w, params->h);
+    if (full)
+        sprintf(buf + strlen(buf), "d%c", undead_diffchars[params->diff]);
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[64];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Difficulty";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = DIFFCONFIG;
+    ret[2].ival = params->diff;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->diff = cfg[2].ival;
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if ((params->w * params->h ) > 54)  return "Grid is too big";
+    if (params->w < 3)                  return "Width must be at least 3";
+    if (params->h < 3)                  return "Height must be at least 3";
+    if (params->diff >= DIFFCOUNT)      return "Unknown difficulty rating";
+    return NULL;
+}
+
+/* --------------------------------------------------------------- */
+/* Game state allocation, deallocation. */
+
+struct path {
+    int length;
+    int *p;
+    int grid_start;
+    int grid_end;
+    int num_monsters;
+    int *mapping;
+    int sightings_start;
+    int sightings_end;
+    int *xy;
+};
+
+struct game_common {
+    int refcount;
+    struct game_params params;
+    int wh;
+    int num_ghosts,num_vampires,num_zombies,num_total;
+    int num_paths;
+    struct path *paths;
+    int *grid;
+    int *xinfo;
+    int *fixed;
+    int solved;
+};
+
+struct game_state {
+    struct game_common *common;
+    int *guess;
+    unsigned char *pencils;
+    unsigned char *cell_errors;
+    unsigned char *hint_errors;
+    unsigned char *hints_done;
+    unsigned char count_errors[3];
+    int solved;
+    int cheated;
+};
+
+static game_state *new_state(const game_params *params) {
+    int i;
+    game_state *state = snew(game_state);
+    state->common = snew(struct game_common);
+
+    state->common->refcount = 1;
+    state->common->params.w = params->w;
+    state->common->params.h = params->h;
+    state->common->params.diff = params->diff;
+
+    state->common->wh = (state->common->params.w +2) * (state->common->params.h +2);
+
+    state->common->num_ghosts = 0;
+    state->common->num_vampires = 0;
+    state->common->num_zombies = 0;
+    state->common->num_total = 0;
+
+    state->common->grid = snewn(state->common->wh, int);
+    state->common->xinfo = snewn(state->common->wh, int);
+    state->common->fixed = NULL;
+    state->common->solved = FALSE;
+
+    state->common->num_paths =
+        state->common->params.w + state->common->params.h;
+    state->common->paths = snewn(state->common->num_paths, struct path);
+
+    for (i=0;i<state->common->num_paths;i++) {
+        state->common->paths[i].length = 0;
+        state->common->paths[i].grid_start = -1;
+        state->common->paths[i].grid_end = -1;
+        state->common->paths[i].num_monsters = 0;
+        state->common->paths[i].sightings_start = 0;
+        state->common->paths[i].sightings_end = 0;
+        state->common->paths[i].p = snewn(state->common->wh,int);
+        state->common->paths[i].xy = snewn(state->common->wh,int);
+        state->common->paths[i].mapping = snewn(state->common->wh,int);
+    }
+
+    state->guess = NULL;
+    state->pencils = NULL;
+
+    state->cell_errors = snewn(state->common->wh, unsigned char);
+    for (i=0;i<state->common->wh;i++)
+        state->cell_errors[i] = FALSE;
+    state->hint_errors = snewn(2*state->common->num_paths, unsigned char);
+    for (i=0;i<2*state->common->num_paths;i++)
+        state->hint_errors[i] = FALSE;
+    state->hints_done = snewn(2 * state->common->num_paths, unsigned char);
+    memset(state->hints_done, 0,
+           2 * state->common->num_paths * sizeof(unsigned char));
+    for (i=0;i<3;i++)
+        state->count_errors[i] = FALSE;
+
+    state->solved = FALSE;
+    state->cheated = FALSE;
+    
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->common = state->common;
+    ret->common->refcount++;
+
+    if (state->guess != NULL) {
+        ret->guess = snewn(ret->common->num_total,int);
+        memcpy(ret->guess, state->guess, ret->common->num_total*sizeof(int));
+    }
+    else ret->guess = NULL;
+
+    if (state->pencils != NULL) {
+        ret->pencils = snewn(ret->common->num_total,unsigned char);
+        memcpy(ret->pencils, state->pencils,
+               ret->common->num_total*sizeof(unsigned char));
+    }
+    else ret->pencils = NULL;
+
+    if (state->cell_errors != NULL) {
+        ret->cell_errors = snewn(ret->common->wh,unsigned char);
+        memcpy(ret->cell_errors, state->cell_errors,
+               ret->common->wh*sizeof(unsigned char));
+    }
+    else ret->cell_errors = NULL;
+
+    if (state->hint_errors != NULL) {
+        ret->hint_errors = snewn(2*ret->common->num_paths,unsigned char);
+        memcpy(ret->hint_errors, state->hint_errors,
+               2*ret->common->num_paths*sizeof(unsigned char));
+    }
+    else ret->hint_errors = NULL;
+
+    if (state->hints_done != NULL) {
+        ret->hints_done = snewn(2 * state->common->num_paths, unsigned char);
+        memcpy(ret->hints_done, state->hints_done,
+               2 * state->common->num_paths * sizeof(unsigned char));
+    }
+    else ret->hints_done = NULL;
+
+    ret->count_errors[0] = state->count_errors[0];
+    ret->count_errors[1] = state->count_errors[1];
+    ret->count_errors[2] = state->count_errors[2];
+
+    ret->solved = state->solved;
+    ret->cheated = state->cheated;
+    
+    return ret;
+}
+
+static void free_game(game_state *state) {
+    int i;
+
+    state->common->refcount--;
+    if (state->common->refcount == 0) {
+        for (i=0;i<state->common->num_paths;i++) {
+            sfree(state->common->paths[i].mapping);
+            sfree(state->common->paths[i].xy);
+            sfree(state->common->paths[i].p);
+        }
+        sfree(state->common->paths);
+        sfree(state->common->xinfo);
+        sfree(state->common->grid);
+        if (state->common->fixed != NULL) sfree(state->common->fixed);
+        sfree(state->common);
+    }
+    if (state->hints_done != NULL) sfree(state->hints_done);
+    if (state->hint_errors != NULL) sfree(state->hint_errors);
+    if (state->cell_errors != NULL) sfree(state->cell_errors);
+    if (state->pencils != NULL) sfree(state->pencils);
+    if (state->guess != NULL) sfree(state->guess);
+    sfree(state);
+
+    return;
+}
+
+/* --------------------------------------------------------------- */
+/* Puzzle generator */
+
+/* cell states */
+enum {
+    CELL_EMPTY,
+    CELL_MIRROR_L,
+    CELL_MIRROR_R,
+    CELL_GHOST,
+    CELL_VAMPIRE,
+    CELL_ZOMBIE,
+    CELL_UNDEF
+};
+
+/* grid walk directions */
+enum {
+    DIRECTION_NONE,
+    DIRECTION_UP,
+    DIRECTION_RIGHT,
+    DIRECTION_LEFT,
+    DIRECTION_DOWN
+};
+
+int range2grid(int rangeno, int width, int height, int *x, int *y) {
+
+    if (rangeno < 0) {
+        *x = 0; *y = 0; return DIRECTION_NONE;
+    }
+    if (rangeno < width) {
+        *x = rangeno+1; *y = 0; return DIRECTION_DOWN;
+    }
+    rangeno = rangeno - width;
+    if (rangeno < height) {
+        *x = width+1; *y = rangeno+1; return DIRECTION_LEFT;
+    }
+    rangeno = rangeno - height;
+    if (rangeno < width) {
+        *x = width-rangeno; *y = height+1; return DIRECTION_UP;
+    }
+    rangeno = rangeno - width;
+    if (rangeno < height) {
+        *x = 0; *y = height-rangeno; return DIRECTION_RIGHT;
+    }
+    *x = 0; *y = 0;
+    return DIRECTION_NONE;
+}
+
+int grid2range(int x, int y, int w, int h) {
+    if (x>0 && x<w+1 && y>0 && y<h+1)           return -1;
+    if (x<0 || x>w+1 || y<0 || y>h+1)           return -1;
+    if ((x == 0 || x==w+1) && (y==0 || y==h+1)) return -1;
+    if (y==0)                                   return x-1;
+    if (x==(w+1))                               return y-1+w;
+    if (y==(h+1))                               return 2*w + h - x;
+    return 2*(w+h) - y;
+}
+
+void make_paths(game_state *state) {
+    int i;
+    int count = 0;
+
+    for (i=0;i<2*(state->common->params.w + state->common->params.h);i++) {
+        int x,y,dir;
+        int j,k,num_monsters;
+        int found;
+        int c,p; 
+        found = FALSE;
+        /* Check whether inverse path is already in list */
+        for (j=0;j<count;j++) {
+            if (i == state->common->paths[j].grid_end) {
+                found = TRUE;
+                break;
+            }
+        }
+        if (found) continue;
+
+        /* We found a new path through the mirror maze */
+        state->common->paths[count].grid_start = i;     
+        dir = range2grid(i, state->common->params.w,
+                         state->common->params.h,&x,&y);     
+        state->common->paths[count].sightings_start =
+            state->common->grid[x+y*(state->common->params.w +2)];
+        while (TRUE) {
+            int c,r;
+
+            if      (dir == DIRECTION_DOWN)     y++;
+            else if (dir == DIRECTION_LEFT)     x--;
+            else if (dir == DIRECTION_UP)       y--;
+            else if (dir == DIRECTION_RIGHT)    x++;
+            
+            r = grid2range(x, y, state->common->params.w,
+                           state->common->params.h);
+            if (r != -1) {
+                state->common->paths[count].grid_end = r;               
+                state->common->paths[count].sightings_end =
+                    state->common->grid[x+y*(state->common->params.w +2)];
+                break;
+            }
+
+            c = state->common->grid[x+y*(state->common->params.w+2)];
+            state->common->paths[count].xy[state->common->paths[count].length] =
+                x+y*(state->common->params.w+2);
+            if (c == CELL_MIRROR_L) {
+                state->common->paths[count].p[state->common->paths[count].length] = -1;
+                if (dir == DIRECTION_DOWN)          dir = DIRECTION_RIGHT;
+                else if (dir == DIRECTION_LEFT)     dir = DIRECTION_UP;
+                else if (dir == DIRECTION_UP)       dir = DIRECTION_LEFT;
+                else if (dir == DIRECTION_RIGHT)    dir = DIRECTION_DOWN;
+            }
+            else if (c == CELL_MIRROR_R) {
+                state->common->paths[count].p[state->common->paths[count].length] = -1;
+                if (dir == DIRECTION_DOWN)          dir = DIRECTION_LEFT;
+                else if (dir == DIRECTION_LEFT)     dir = DIRECTION_DOWN;
+                else if (dir == DIRECTION_UP)       dir = DIRECTION_RIGHT;
+                else if (dir == DIRECTION_RIGHT)    dir = DIRECTION_UP;
+            }
+            else {
+                state->common->paths[count].p[state->common->paths[count].length] =
+                    state->common->xinfo[x+y*(state->common->params.w+2)];
+            }
+            state->common->paths[count].length++;
+        }
+        /* Count unique monster entries in each path */
+        state->common->paths[count].num_monsters = 0;
+        for (j=0;j<state->common->num_total;j++) {
+            num_monsters = 0;
+            for (k=0;k<state->common->paths[count].length;k++)
+                if (state->common->paths[count].p[k] == j)
+                    num_monsters++;
+            if (num_monsters > 0)
+                state->common->paths[count].num_monsters++;
+        }
+
+        /* Generate mapping vector */
+        c = 0;
+        for (p=0;p<state->common->paths[count].length;p++) {
+            int m;
+            m = state->common->paths[count].p[p];
+            if (m == -1) continue;
+            found = FALSE;
+            for (j=0; j<c; j++)
+                if (state->common->paths[count].mapping[j] == m) found = TRUE;
+            if (!found) state->common->paths[count].mapping[c++] = m;
+        }
+        count++;
+    }
+    return;
+}
+
+struct guess {
+    int length;
+    int *guess;
+    int *possible;
+};
+
+int next_list(struct guess *g, int pos) {
+
+    if (pos == 0) {
+        if ((g->guess[pos] == 1 && g->possible[pos] == 1) || 
+            (g->guess[pos] == 2 && (g->possible[pos] == 3 ||
+                                    g->possible[pos] == 2)) ||
+            g->guess[pos] == 4)
+            return FALSE;
+        if (g->guess[pos] == 1 && (g->possible[pos] == 3 ||
+                                   g->possible[pos] == 7)) {
+            g->guess[pos] = 2; return TRUE;
+        }
+        if (g->guess[pos] == 1 && g->possible[pos] == 5) {
+            g->guess[pos] = 4; return TRUE;
+        }
+        if (g->guess[pos] == 2 && (g->possible[pos] == 6 || g->possible[pos] == 7)) {
+            g->guess[pos] = 4; return TRUE;
+        }
+    }
+
+    if (g->guess[pos] == 1) {
+        if (g->possible[pos] == 1) {
+            return next_list(g,pos-1);
+        }
+        if (g->possible[pos] == 3 || g->possible[pos] == 7) {
+            g->guess[pos] = 2; return TRUE;
+        }
+        if (g->possible[pos] == 5) {
+            g->guess[pos] = 4; return TRUE;
+        }
+    }
+
+    if (g->guess[pos] == 2) {
+        if (g->possible[pos] == 2) {
+            return next_list(g,pos-1);
+        }
+        if (g->possible[pos] == 3) {
+            g->guess[pos] = 1; return next_list(g,pos-1);
+        }
+        if (g->possible[pos] == 6 || g->possible[pos] == 7) {
+            g->guess[pos] = 4; return TRUE;
+        }
+    }
+
+    if (g->guess[pos] == 4) {
+        if (g->possible[pos] == 5 || g->possible[pos] == 7) {
+            g->guess[pos] = 1; return next_list(g,pos-1);
+        }
+        if (g->possible[pos] == 6) {
+            g->guess[pos] = 2; return next_list(g,pos-1);
+        }
+        if (g->possible[pos] == 4) {
+            return next_list(g,pos-1);
+        }
+    }
+    return FALSE;
+}
+
+void get_unique(game_state *state, int counter, random_state *rs) {
+
+    int p,i,c,pathlimit,count_uniques;
+    struct guess path_guess;
+    int *view_count;
+    
+    struct entry {
+        struct entry *link;
+        int *guess;
+        int start_view;
+        int end_view;
+    };
+
+    struct {
+        struct entry *head;
+        struct entry *node;
+    } views, single_views, test_views;
+
+    struct entry test_entry;
+
+    path_guess.length = state->common->paths[counter].num_monsters;
+    path_guess.guess = snewn(path_guess.length,int);
+    path_guess.possible = snewn(path_guess.length,int);
+    for (i=0;i<path_guess.length;i++) 
+        path_guess.guess[i] = path_guess.possible[i] = 0;
+
+    for (p=0;p<path_guess.length;p++) {
+        path_guess.possible[p] =
+            state->guess[state->common->paths[counter].mapping[p]];
+        switch (path_guess.possible[p]) {
+          case 1: path_guess.guess[p] = 1; break;
+          case 2: path_guess.guess[p] = 2; break;
+          case 3: path_guess.guess[p] = 1; break;
+          case 4: path_guess.guess[p] = 4; break;
+          case 5: path_guess.guess[p] = 1; break;
+          case 6: path_guess.guess[p] = 2; break;
+          case 7: path_guess.guess[p] = 1; break;
+        }
+    }
+
+    views.head = NULL;
+    views.node = NULL;
+
+    pathlimit = state->common->paths[counter].length + 1;
+    view_count = snewn(pathlimit*pathlimit, int);
+    for (i = 0; i < pathlimit*pathlimit; i++)
+        view_count[i] = 0;
+    
+    do {
+        int mirror, start_view, end_view;
+        
+        mirror = FALSE;
+        start_view = 0;
+        for (p=0;p<state->common->paths[counter].length;p++) {
+            if (state->common->paths[counter].p[p] == -1) mirror = TRUE;
+            else {
+                for (i=0;i<path_guess.length;i++) {
+                    if (state->common->paths[counter].p[p] ==
+                        state->common->paths[counter].mapping[i]) {
+                        if (path_guess.guess[i] == 1 && mirror == TRUE)
+                            start_view++;
+                        if (path_guess.guess[i] == 2 && mirror == FALSE)
+                            start_view++;
+                        if (path_guess.guess[i] == 4)
+                            start_view++;
+                        break;
+                    }
+                }
+            }
+        }
+        mirror = FALSE;
+        end_view = 0;
+        for (p=state->common->paths[counter].length-1;p>=0;p--) {
+            if (state->common->paths[counter].p[p] == -1) mirror = TRUE;
+            else {
+                for (i=0;i<path_guess.length;i++) {
+                    if (state->common->paths[counter].p[p] ==
+                        state->common->paths[counter].mapping[i]) {
+                        if (path_guess.guess[i] == 1 && mirror == TRUE)
+                            end_view++;
+                        if (path_guess.guess[i] == 2 && mirror == FALSE)
+                            end_view++;
+                        if (path_guess.guess[i] == 4)
+                            end_view++;
+                        break;
+                    }
+                }
+            }
+        }
+
+        assert(start_view >= 0 && start_view < pathlimit);
+        assert(end_view >= 0 && end_view < pathlimit);
+        i = start_view * pathlimit + end_view;
+        view_count[i]++;
+        if (view_count[i] == 1) {
+            views.node = snewn(1,struct entry);
+            views.node->link = views.head;
+            views.node->guess = snewn(path_guess.length,int);
+            views.head = views.node;
+            views.node->start_view = start_view;
+            views.node->end_view = end_view;
+            memcpy(views.node->guess, path_guess.guess,
+                   path_guess.length*sizeof(int));
+        }
+    } while (next_list(&path_guess, path_guess.length-1));
+
+    /*  extract single entries from view list */
+
+    test_views.head = views.head;
+    test_views.node = views.node;
+    
+    test_entry.guess = snewn(path_guess.length,int);
+
+    single_views.head = NULL;
+    single_views.node = NULL;
+
+    count_uniques = 0;
+    while (test_views.head != NULL) {
+        test_views.node = test_views.head;
+        test_views.head = test_views.head->link;
+        i = test_views.node->start_view * pathlimit + test_views.node->end_view;
+        if (view_count[i] == 1) {
+            single_views.node = snewn(1,struct entry);
+            single_views.node->link = single_views.head;
+            single_views.node->guess = snewn(path_guess.length,int);
+            single_views.head = single_views.node;
+            single_views.node->start_view = test_views.node->start_view;
+            single_views.node->end_view = test_views.node->end_view;
+            memcpy(single_views.node->guess, test_views.node->guess,
+                   path_guess.length*sizeof(int));
+            count_uniques++;
+        }
+    }
+
+    sfree(view_count);
+
+    if (count_uniques > 0) {
+        test_entry.start_view = 0;
+        test_entry.end_view = 0;
+        /* Choose one unique guess per random */
+        /* While we are busy with looping through single_views, we
+         * conveniently free the linked list single_view */
+        c = random_upto(rs,count_uniques);
+        while(single_views.head != NULL) {
+            single_views.node = single_views.head;
+            single_views.head = single_views.head->link;
+            if (c-- == 0) {
+                memcpy(test_entry.guess, single_views.node->guess,
+                       path_guess.length*sizeof(int));
+                test_entry.start_view = single_views.node->start_view;
+                test_entry.end_view = single_views.node->end_view;
+            }
+            sfree(single_views.node->guess);
+            sfree(single_views.node);
+        }
+        
+        /* Modify state_guess according to path_guess.mapping */
+        for (i=0;i<path_guess.length;i++)
+            state->guess[state->common->paths[counter].mapping[i]] =
+                test_entry.guess[i];
+    }
+
+    sfree(test_entry.guess);
+
+    while (views.head != NULL) {
+        views.node = views.head;
+        views.head = views.head->link;
+        sfree(views.node->guess);
+        sfree(views.node);
+    }
+
+    sfree(path_guess.possible);
+    sfree(path_guess.guess);
+
+    return;
+}
+
+int count_monsters(game_state *state,
+                   int *cGhost, int *cVampire, int *cZombie) {
+    int cNone;
+    int i;
+
+    *cGhost = *cVampire = *cZombie = cNone = 0;
+
+    for (i=0;i<state->common->num_total;i++) {
+        if (state->guess[i] == 1) (*cGhost)++;
+        else if (state->guess[i] == 2) (*cVampire)++;
+        else if (state->guess[i] == 4) (*cZombie)++;
+        else cNone++;
+    }
+
+    return cNone;
+}
+
+int check_numbers(game_state *state, int *guess) {
+    int valid;
+    int i;
+    int count_ghosts, count_vampires, count_zombies;
+
+    count_ghosts = count_vampires = count_zombies = 0;  
+    for (i=0;i<state->common->num_total;i++) {
+        if (guess[i] == 1) count_ghosts++;
+        if (guess[i] == 2) count_vampires++;
+        if (guess[i] == 4) count_zombies++;
+    }
+
+    valid = TRUE;
+
+    if (count_ghosts   > state->common->num_ghosts)   valid = FALSE; 
+    if (count_vampires > state->common->num_vampires) valid = FALSE; 
+    if (count_zombies > state->common->num_zombies)   valid = FALSE; 
+
+    return valid;
+}
+
+int check_solution(int *g, struct path path) {
+    int i;
+    int mirror;
+    int count;
+
+    count = 0;
+    mirror = FALSE;
+    for (i=0;i<path.length;i++) {
+        if (path.p[i] == -1) mirror = TRUE;
+        else {
+            if (g[path.p[i]] == 1 && mirror) count++;
+            else if (g[path.p[i]] == 2 && !mirror) count++;
+            else if (g[path.p[i]] == 4) count++;
+        }
+    }
+    if (count != path.sightings_start) return FALSE;    
+
+    count = 0;
+    mirror = FALSE;
+    for (i=path.length-1;i>=0;i--) {
+        if (path.p[i] == -1) mirror = TRUE;
+        else {
+            if (g[path.p[i]] == 1 && mirror) count++;
+            else if (g[path.p[i]] == 2 && !mirror) count++;
+            else if (g[path.p[i]] == 4) count++;
+        }
+    }
+    if (count != path.sightings_end) return FALSE;  
+
+    return TRUE;
+}
+
+int solve_iterative(game_state *state, struct path *paths) {
+    int solved;
+    int p,i,j,count;
+
+    int *guess;
+    int *possible;
+
+    struct guess loop;
+
+    solved = TRUE;
+    loop.length = state->common->num_total;
+    guess = snewn(state->common->num_total,int);
+    possible = snewn(state->common->num_total,int);
+
+    for (i=0;i<state->common->num_total;i++) {
+        guess[i] = state->guess[i];
+        possible[i] = 0;
+    }
+
+    for (p=0;p<state->common->num_paths;p++) {
+        if (paths[p].num_monsters > 0) {
+            loop.length = paths[p].num_monsters;
+            loop.guess = snewn(paths[p].num_monsters,int);
+            loop.possible = snewn(paths[p].num_monsters,int);
+
+            for (i=0;i<paths[p].num_monsters;i++) {
+                switch (state->guess[paths[p].mapping[i]]) {
+                  case 1: loop.guess[i] = 1; break;
+                  case 2: loop.guess[i] = 2; break;
+                  case 3: loop.guess[i] = 1; break;
+                  case 4: loop.guess[i] = 4; break;
+                  case 5: loop.guess[i] = 1; break;
+                  case 6: loop.guess[i] = 2; break;
+                  case 7: loop.guess[i] = 1; break;
+                }
+                loop.possible[i] = state->guess[paths[p].mapping[i]];
+                possible[paths[p].mapping[i]] = 0;
+            }
+
+            while(TRUE) {
+                for (i=0;i<state->common->num_total;i++) {
+                    guess[i] = state->guess[i];
+                }
+                count = 0;
+                for (i=0;i<paths[p].num_monsters;i++) 
+                    guess[paths[p].mapping[i]] = loop.guess[count++];
+                if (check_numbers(state,guess) &&
+                    check_solution(guess,paths[p]))
+                    for (j=0;j<paths[p].num_monsters;j++)
+                        possible[paths[p].mapping[j]] |= loop.guess[j];
+                if (!next_list(&loop,loop.length-1)) break;
+            }
+            for (i=0;i<paths[p].num_monsters;i++)       
+                state->guess[paths[p].mapping[i]] &=
+                    possible[paths[p].mapping[i]];
+            sfree(loop.possible);
+            sfree(loop.guess);
+        }
+    }
+
+    for (i=0;i<state->common->num_total;i++) {
+        if (state->guess[i] == 3 || state->guess[i] == 5 ||
+            state->guess[i] == 6 || state->guess[i] == 7) {
+            solved = FALSE; break;
+        }
+    }
+
+    sfree(possible);
+    sfree(guess);
+
+    return solved;
+}
+
+int solve_bruteforce(game_state *state, struct path *paths) {
+    int solved, correct;
+    int number_solutions;
+    int p,i;
+
+    struct guess loop;
+
+    loop.guess = snewn(state->common->num_total,int);
+    loop.possible = snewn(state->common->num_total,int);
+
+    for (i=0;i<state->common->num_total;i++) {
+        loop.possible[i] = state->guess[i];
+        switch (state->guess[i]) {
+          case 1: loop.guess[i] = 1; break;
+          case 2: loop.guess[i] = 2; break;
+          case 3: loop.guess[i] = 1; break;
+          case 4: loop.guess[i] = 4; break;
+          case 5: loop.guess[i] = 1; break;
+          case 6: loop.guess[i] = 2; break;
+          case 7: loop.guess[i] = 1; break;
+        }
+    }
+
+    solved = FALSE;
+    number_solutions = 0;
+
+    while (TRUE) {
+
+        correct = TRUE;
+        if (!check_numbers(state,loop.guess)) correct = FALSE;
+        else 
+            for (p=0;p<state->common->num_paths;p++)
+                if (!check_solution(loop.guess,paths[p])) {
+                    correct = FALSE; break;
+                }
+        if (correct) {
+            number_solutions++;
+            solved = TRUE;
+            if(number_solutions > 1) {
+                solved = FALSE;
+                break; 
+            }
+            for (i=0;i<state->common->num_total;i++)
+                state->guess[i] = loop.guess[i];
+        }
+        if (!next_list(&loop,state->common->num_total -1)) {
+            break;
+        }
+    }
+
+    sfree(loop.possible);
+    sfree(loop.guess);
+
+    return solved;
+}
+
+int path_cmp(const void *a, const void *b) {
+    const struct path *pa = (const struct path *)a;
+    const struct path *pb = (const struct path *)b;
+    return pa->num_monsters - pb->num_monsters;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive) {
+    int i,count,c,w,h,r,p,g;
+    game_state *new;
+
+    /* Variables for puzzle generation algorithm */
+    int filling;
+    int max_length;
+    int count_ghosts, count_vampires, count_zombies;
+    int abort;
+    float ratio;
+    
+    /* Variables for solver algorithm */
+    int solved_iterative, solved_bruteforce, contains_inconsistency,
+        count_ambiguous;
+    int iterative_depth;
+    int *old_guess;
+
+    /* Variables for game description generation */
+    int x,y;
+    char *e;
+    char *desc; 
+
+    i = 0;
+    while (TRUE) {
+        new = new_state(params);
+        abort = FALSE;
+
+        /* Fill grid with random mirrors and (later to be populated)
+         * empty monster cells */
+        count = 0;
+        for (h=1;h<new->common->params.h+1;h++)
+            for (w=1;w<new->common->params.w+1;w++) {
+                c = random_upto(rs,5);
+                if (c >= 2) {
+                    new->common->grid[w+h*(new->common->params.w+2)] = CELL_EMPTY;
+                    new->common->xinfo[w+h*(new->common->params.w+2)] = count++;
+                }
+                else if (c == 0) {
+                    new->common->grid[w+h*(new->common->params.w+2)] = 
+                        CELL_MIRROR_L;
+                    new->common->xinfo[w+h*(new->common->params.w+2)] = -1;
+                }
+                else {
+                    new->common->grid[w+h*(new->common->params.w+2)] =
+                        CELL_MIRROR_R;
+                    new->common->xinfo[w+h*(new->common->params.w+2)] = -1;         
+                }
+            }
+        new->common->num_total = count; /* Total number of monsters in maze */
+
+        /* Puzzle is boring if it has too few monster cells. Discard
+         * grid, make new grid */
+        if (new->common->num_total <= 4) {
+            free_game(new);
+            continue;
+        }
+
+        /* Monsters / Mirrors ratio should be balanced */
+        ratio = (float)new->common->num_total /
+            (float)(new->common->params.w * new->common->params.h);
+        if (ratio < 0.48 || ratio > 0.78) {
+            free_game(new);
+            continue;
+        }        
+
+        /* Assign clue identifiers */   
+        for (r=0;r<2*(new->common->params.w+new->common->params.h);r++) {
+            int x,y,gridno;
+            gridno = range2grid(r,new->common->params.w,new->common->params.h,
+                                &x,&y);
+            new->common->grid[x+y*(new->common->params.w +2)] = gridno;
+            new->common->xinfo[x+y*(new->common->params.w +2)] = 0;
+        }
+        /* The four corners don't matter at all for the game. Set them
+         * all to zero, just to have a nice data structure */
+        new->common->grid[0] = 0;        
+        new->common->xinfo[0] = 0;      
+        new->common->grid[new->common->params.w+1] = 0; 
+        new->common->xinfo[new->common->params.w+1] = 0;
+        new->common->grid[new->common->params.w+1 + (new->common->params.h+1)*(new->common->params.w+2)] = 0; 
+        new->common->xinfo[new->common->params.w+1 + (new->common->params.h+1)*(new->common->params.w+2)] = 0;
+        new->common->grid[(new->common->params.h+1)*(new->common->params.w+2)] = 0; 
+        new->common->xinfo[(new->common->params.h+1)*(new->common->params.w+2)] = 0;
+
+        /* Initialize solution vector */
+        new->guess = snewn(new->common->num_total,int);
+        for (g=0;g<new->common->num_total;g++) new->guess[g] = 7;
+
+        /* Initialize fixed flag from common. Not needed for the
+         * puzzle generator; initialize it for having clean code */
+        new->common->fixed = snewn(new->common->num_total,int);
+        for (g=0;g<new->common->num_total;g++)
+            new->common->fixed[g] = FALSE;
+
+        /* paths generation */
+        make_paths(new);
+
+        /* Grid is invalid if max. path length > threshold. Discard
+         * grid, make new one */
+        switch (new->common->params.diff) {
+          case DIFF_EASY:     max_length = min(new->common->params.w,new->common->params.h) + 1; break;
+          case DIFF_NORMAL:   max_length = (max(new->common->params.w,new->common->params.h) * 3) / 2; break;
+          case DIFF_TRICKY:   max_length = 9; break;
+          default:            max_length = 9; break;
+        }
+
+        for (p=0;p<new->common->num_paths;p++) {
+            if (new->common->paths[p].num_monsters > max_length) {
+                abort = TRUE;
+            }
+        }
+        if (abort) {
+            free_game(new);
+            continue;
+        }
+
+        qsort(new->common->paths, new->common->num_paths,
+              sizeof(struct path), path_cmp);
+
+        /* Grid monster initialization */
+        /*  For easy puzzles, we try to fill nearly the whole grid
+            with unique solution paths (up to 2) For more difficult
+            puzzles, we fill only roughly half the grid, and choose
+            random monsters for the rest For hard puzzles, we fill
+            even less paths with unique solutions */
+
+        switch (new->common->params.diff) {
+          case DIFF_EASY:   filling = 2; break;
+          case DIFF_NORMAL: filling = min( (new->common->params.w+new->common->params.h) , (new->common->num_total)/2 ); break;
+          case DIFF_TRICKY: filling = max( (new->common->params.w+new->common->params.h) , (new->common->num_total)/2 ); break;
+          default:          filling = 0; break;
+        }
+
+        count = 0;
+        while ( (count_monsters(new, &count_ghosts, &count_vampires,
+                                &count_zombies)) > filling) {
+            if ((count) >= new->common->num_paths) break;
+            if (new->common->paths[count].num_monsters == 0) {
+                count++;
+                continue;
+            }
+            get_unique(new,count,rs);
+            count++;
+        }
+
+        /* Fill any remaining ambiguous entries with random monsters */ 
+        for(g=0;g<new->common->num_total;g++) {
+            if (new->guess[g] == 7) {
+                r = random_upto(rs,3);
+                new->guess[g] = (r == 0) ? 1 : ( (r == 1) ? 2 : 4 );        
+            }
+        }
+
+        /*  Determine all hints */
+        count_monsters(new, &new->common->num_ghosts,
+                       &new->common->num_vampires, &new->common->num_zombies);
+
+        /* Puzzle is trivial if it has only one type of monster. Discard. */
+        if ((new->common->num_ghosts == 0 && new->common->num_vampires == 0) ||
+            (new->common->num_ghosts == 0 && new->common->num_zombies == 0) ||
+            (new->common->num_vampires == 0 && new->common->num_zombies == 0)) {
+            free_game(new);
+            continue;
+        }
+
+        /* Discard puzzle if difficulty Tricky, and it has only 1
+         * member of any monster type */
+        if (new->common->params.diff == DIFF_TRICKY && 
+            (new->common->num_ghosts <= 1 ||
+             new->common->num_vampires <= 1 || new->common->num_zombies <= 1)) {
+            free_game(new);
+            continue;
+        }
+
+        for (w=1;w<new->common->params.w+1;w++)
+            for (h=1;h<new->common->params.h+1;h++) {
+                c = new->common->xinfo[w+h*(new->common->params.w+2)];
+                if (c >= 0) {
+                    if (new->guess[c] == 1) new->common->grid[w+h*(new->common->params.w+2)] = CELL_GHOST;
+                    if (new->guess[c] == 2) new->common->grid[w+h*(new->common->params.w+2)] = CELL_VAMPIRE;
+                    if (new->guess[c] == 4) new->common->grid[w+h*(new->common->params.w+2)] = CELL_ZOMBIE;                 
+                }
+            }
+
+        /* Prepare path information needed by the solver (containing all hints) */  
+        for (p=0;p<new->common->num_paths;p++) {
+            int mirror,x,y;
+
+            new->common->paths[p].sightings_start = 0;
+            new->common->paths[p].sightings_end = 0;
+            
+            mirror = FALSE;
+            for (g=0;g<new->common->paths[p].length;g++) {
+
+                if (new->common->paths[p].p[g] == -1) mirror = TRUE;
+                else {
+                    if      (new->guess[new->common->paths[p].p[g]] == 1 && mirror == TRUE)  (new->common->paths[p].sightings_start)++;
+                    else if (new->guess[new->common->paths[p].p[g]] == 2 && mirror == FALSE) (new->common->paths[p].sightings_start)++;
+                    else if (new->guess[new->common->paths[p].p[g]] == 4)                    (new->common->paths[p].sightings_start)++;
+                }
+            }
+
+            mirror = FALSE;
+            for (g=new->common->paths[p].length-1;g>=0;g--) {
+                if (new->common->paths[p].p[g] == -1) mirror = TRUE;
+                else {
+                    if      (new->guess[new->common->paths[p].p[g]] == 1 && mirror == TRUE)  (new->common->paths[p].sightings_end)++;
+                    else if (new->guess[new->common->paths[p].p[g]] == 2 && mirror == FALSE) (new->common->paths[p].sightings_end)++;
+                    else if (new->guess[new->common->paths[p].p[g]] == 4)                    (new->common->paths[p].sightings_end)++;
+                }
+            }
+
+            range2grid(new->common->paths[p].grid_start,
+                       new->common->params.w,new->common->params.h,&x,&y);
+            new->common->grid[x+y*(new->common->params.w +2)] =
+                new->common->paths[p].sightings_start;
+            range2grid(new->common->paths[p].grid_end,
+                       new->common->params.w,new->common->params.h,&x,&y);
+            new->common->grid[x+y*(new->common->params.w +2)] =
+                new->common->paths[p].sightings_end;
+        }
+
+        /* Try to solve the puzzle with the iterative solver */
+        old_guess = snewn(new->common->num_total,int);
+        for (p=0;p<new->common->num_total;p++) {
+            new->guess[p] = 7;
+            old_guess[p] = 7;
+        }
+        iterative_depth = 0;
+        solved_iterative = FALSE;
+        contains_inconsistency = FALSE;
+        count_ambiguous = 0;
+
+        while (TRUE) {
+            int no_change;          
+            no_change = TRUE;
+            solved_iterative = solve_iterative(new,new->common->paths);
+            iterative_depth++;      
+            for (p=0;p<new->common->num_total;p++) {
+                if (new->guess[p] != old_guess[p]) no_change = FALSE;
+                old_guess[p] = new->guess[p];
+                if (new->guess[p] == 0) contains_inconsistency = TRUE;
+            }
+            if (solved_iterative || no_change) break;
+        } 
+
+        /* If necessary, try to solve the puzzle with the brute-force solver */
+        solved_bruteforce = FALSE;  
+        if (new->common->params.diff != DIFF_EASY &&
+            !solved_iterative && !contains_inconsistency) {
+            for (p=0;p<new->common->num_total;p++)
+                if (new->guess[p] != 1 && new->guess[p] != 2 &&
+                    new->guess[p] != 4) count_ambiguous++;
+
+            solved_bruteforce = solve_bruteforce(new, new->common->paths);
+        }   
+
+        /*  Determine puzzle difficulty level */    
+        if (new->common->params.diff == DIFF_EASY && solved_iterative &&
+            iterative_depth <= 3 && !contains_inconsistency) { 
+/*          printf("Puzzle level: EASY Level %d Ratio %f Ambiguous %d (Found after %i tries)\n",iterative_depth, ratio, count_ambiguous, i); */
+            break;
+        }
+
+        if (new->common->params.diff == DIFF_NORMAL &&
+            ((solved_iterative && iterative_depth > 3) ||
+             (solved_bruteforce && count_ambiguous < 4)) &&
+            !contains_inconsistency) {  
+/*          printf("Puzzle level: NORMAL Level %d Ratio %f Ambiguous %d (Found after %d tries)\n", iterative_depth, ratio, count_ambiguous, i); */
+            break;
+        }
+        if (new->common->params.diff == DIFF_TRICKY &&
+            solved_bruteforce && iterative_depth > 0 &&
+            count_ambiguous >= 4 && !contains_inconsistency) {
+/*          printf("Puzzle level: TRICKY Level %d Ratio %f Ambiguous %d (Found after %d tries)\n", iterative_depth, ratio, count_ambiguous, i); */
+            break;
+        }
+
+        /* If puzzle is not solvable or does not satisfy the desired
+         * difficulty level, free memory and start from scratch */    
+        sfree(old_guess);
+        free_game(new);
+        i++;
+    }
+    
+    /* We have a valid puzzle! */
+    
+    desc = snewn(10 + new->common->wh +
+                 6*(new->common->params.w + new->common->params.h), char);
+    e = desc;
+
+    /* Encode monster counts */
+    e += sprintf(e, "%d,", new->common->num_ghosts);
+    e += sprintf(e, "%d,", new->common->num_vampires);
+    e += sprintf(e, "%d,", new->common->num_zombies);
+
+    /* Encode grid */
+    count = 0;
+    for (y=1;y<new->common->params.h+1;y++)
+        for (x=1;x<new->common->params.w+1;x++) {
+            c = new->common->grid[x+y*(new->common->params.w+2)];
+            if (count > 25) {
+                *e++ = 'z';
+                count -= 26;
+            }
+            if (c != CELL_MIRROR_L && c != CELL_MIRROR_R) {
+                count++;
+            }
+            else if (c == CELL_MIRROR_L) {
+                if (count > 0) *e++ = (count-1 + 'a');
+                *e++ = 'L';
+                count = 0;
+            }
+            else {
+                if (count > 0) *e++ = (count-1 + 'a');
+                *e++ = 'R';
+                count = 0;          
+            }
+        }
+    if (count > 0) *e++ = (count-1 + 'a');
+
+    /* Encode hints */
+    for (p=0;p<2*(new->common->params.w + new->common->params.h);p++) {
+        range2grid(p,new->common->params.w,new->common->params.h,&x,&y);
+        e += sprintf(e, ",%d", new->common->grid[x+y*(new->common->params.w+2)]);
+    }
+
+    *e++ = '\0';
+    desc = sresize(desc, e - desc, char);
+
+    sfree(old_guess);
+    free_game(new);
+
+    return desc;
+}
+
+void num2grid(int num, int width, int height, int *x, int *y) {
+    *x = 1+(num%width);
+    *y = 1+(num/width);
+    return;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int i;
+    int n;
+    int count;
+
+    game_state *state = new_state(params);
+
+    state->common->num_ghosts = atoi(desc);
+    while (*desc && isdigit((unsigned char)*desc)) desc++;
+    desc++;
+    state->common->num_vampires = atoi(desc);
+    while (*desc && isdigit((unsigned char)*desc)) desc++;
+    desc++;
+    state->common->num_zombies = atoi(desc);
+    while (*desc && isdigit((unsigned char)*desc)) desc++;
+    desc++;
+
+    state->common->num_total = state->common->num_ghosts + state->common->num_vampires + state->common->num_zombies;
+
+    state->guess = snewn(state->common->num_total,int);
+    state->pencils = snewn(state->common->num_total,unsigned char);
+    state->common->fixed = snewn(state->common->num_total,int);
+    for (i=0;i<state->common->num_total;i++) {
+        state->guess[i] = 7;
+        state->pencils[i] = 0;
+        state->common->fixed[i] = FALSE;
+    }
+    for (i=0;i<state->common->wh;i++)
+        state->cell_errors[i] = FALSE;
+    for (i=0;i<2*state->common->num_paths;i++)
+        state->hint_errors[i] = FALSE;
+    for (i=0;i<3;i++)
+        state->count_errors[i] = FALSE;
+
+    count = 0;
+    n = 0;
+    while (*desc != ',') {
+        int c;
+        int x,y;
+
+        if (*desc == 'L') {
+            num2grid(n,state->common->params.w,state->common->params.h,&x,&y);
+            state->common->grid[x+y*(state->common->params.w +2)] = CELL_MIRROR_L;
+            state->common->xinfo[x+y*(state->common->params.w+2)] = -1;
+            n++;
+        }
+        else if (*desc == 'R') {
+            num2grid(n,state->common->params.w,state->common->params.h,&x,&y);
+            state->common->grid[x+y*(state->common->params.w +2)] = CELL_MIRROR_R;
+            state->common->xinfo[x+y*(state->common->params.w+2)] = -1;
+            n++;
+        }
+        else if (*desc == 'G') {
+            num2grid(n,state->common->params.w,state->common->params.h,&x,&y);
+            state->common->grid[x+y*(state->common->params.w +2)] = CELL_GHOST;
+            state->common->xinfo[x+y*(state->common->params.w+2)] = count;
+            state->guess[count] = 1;
+            state->common->fixed[count++] = TRUE;
+            n++;
+        }
+        else if (*desc == 'V') {
+            num2grid(n,state->common->params.w,state->common->params.h,&x,&y);
+            state->common->grid[x+y*(state->common->params.w +2)] = CELL_VAMPIRE;
+            state->common->xinfo[x+y*(state->common->params.w+2)] = count;
+            state->guess[count] = 2;
+            state->common->fixed[count++] = TRUE;
+            n++;
+        }
+        else if (*desc == 'Z') {
+            num2grid(n,state->common->params.w,state->common->params.h,&x,&y);
+            state->common->grid[x+y*(state->common->params.w +2)] = CELL_ZOMBIE;
+            state->common->xinfo[x+y*(state->common->params.w+2)] = count;
+            state->guess[count] = 4;
+            state->common->fixed[count++] = TRUE;
+            n++;
+        }
+        else {
+            c = *desc - ('a' -1);
+            while (c-- > 0) {
+                num2grid(n,state->common->params.w,state->common->params.h,&x,&y);
+                state->common->grid[x+y*(state->common->params.w +2)] = CELL_EMPTY;
+                state->common->xinfo[x+y*(state->common->params.w+2)] = count;
+                state->guess[count] = 7;
+                state->common->fixed[count++] = FALSE;
+                n++;
+            }
+        }
+        desc++;
+    }
+    desc++;
+
+    for (i=0;i<2*(state->common->params.w + state->common->params.h);i++) {
+        int x,y;
+        int sights;
+
+        sights = atoi(desc);
+        while (*desc && isdigit((unsigned char)*desc)) desc++;
+        desc++;
+
+
+        range2grid(i,state->common->params.w,state->common->params.h,&x,&y);
+        state->common->grid[x+y*(state->common->params.w +2)] = sights;
+        state->common->xinfo[x+y*(state->common->params.w +2)] = -2;
+    }
+
+    state->common->grid[0] = 0;
+    state->common->xinfo[0] = -2;
+    state->common->grid[state->common->params.w+1] = 0;
+    state->common->xinfo[state->common->params.w+1] = -2;
+    state->common->grid[state->common->params.w+1 + (state->common->params.h+1)*(state->common->params.w+2)] = 0;
+    state->common->xinfo[state->common->params.w+1 + (state->common->params.h+1)*(state->common->params.w+2)] = -2;
+    state->common->grid[(state->common->params.h+1)*(state->common->params.w+2)] = 0;
+    state->common->xinfo[(state->common->params.h+1)*(state->common->params.w+2)] = -2;
+
+    make_paths(state);
+    qsort(state->common->paths, state->common->num_paths, sizeof(struct path), path_cmp);
+
+    return state;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int i;
+    int w = params->w, h = params->h;
+    int wh = w*h;
+    int area;
+    int monsters;
+    int monster_count;
+    const char *desc_s = desc;
+        
+    for (i=0;i<3;i++) {
+        if (!*desc) return "Faulty game description";
+        while (*desc && isdigit((unsigned char)*desc)) { desc++; }
+        if (*desc != ',') return "Invalid character in number list";
+        desc++;
+    }
+    desc = desc_s;
+    
+    area = monsters = monster_count = 0;
+    for (i=0;i<3;i++) {
+        monster_count += atoi(desc);
+        while (*desc && isdigit((unsigned char)*desc)) desc++;
+        desc++;
+    }
+    while (*desc && *desc != ',') {
+        if (*desc >= 'a' && *desc <= 'z') {
+            area += *desc - 'a' +1; monsters += *desc - 'a' +1;
+        } else if (*desc == 'G' || *desc == 'V' || *desc == 'Z') {
+            area++; monsters++;
+        } else if (*desc == 'L' || *desc == 'R') {
+            area++;
+        } else
+            return "Invalid character in grid specification";
+        desc++;
+    }
+    if (area < wh) return "Not enough data to fill grid";
+    else if (area > wh) return "Too much data to fill grid";
+    if (monsters != monster_count)
+        return "Monster numbers do not match grid spaces";
+
+    for (i = 0; i < 2*(w+h); i++) {
+        if (!*desc) return "Not enough numbers given after grid specification";
+        else if (*desc != ',') return "Invalid character in number list";
+        desc++;
+        while (*desc && isdigit((unsigned char)*desc)) { desc++; }
+    }
+
+    if (*desc) return "Unexpected additional data at end of game description";
+
+    return NULL;
+}
+
+static char *solve_game(const game_state *state_start, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int p;
+    int *old_guess;
+    int iterative_depth;
+    int solved_iterative, solved_bruteforce, contains_inconsistency,
+        count_ambiguous;
+
+    int i;
+    char *move, *c;
+
+    game_state *solve_state = dup_game(currstate);
+
+    old_guess = snewn(solve_state->common->num_total,int);
+    for (p=0;p<solve_state->common->num_total;p++) {
+        if (solve_state->common->fixed[p]) {
+            old_guess[p] = solve_state->guess[p] = state_start->guess[p];
+        }
+        else {
+            old_guess[p] = solve_state->guess[p] = 7;
+        }
+    }
+    iterative_depth = 0;
+    solved_iterative = FALSE;
+    contains_inconsistency = FALSE;
+    count_ambiguous = 0;
+    
+    /* Try to solve the puzzle with the iterative solver */
+    while (TRUE) {
+        int no_change;
+        no_change = TRUE;
+        solved_iterative =
+            solve_iterative(solve_state,solve_state->common->paths);
+        iterative_depth++;
+        for (p=0;p<solve_state->common->num_total;p++) {
+            if (solve_state->guess[p] != old_guess[p]) no_change = FALSE;
+            old_guess[p] = solve_state->guess[p];
+            if (solve_state->guess[p] == 0) contains_inconsistency = TRUE;
+        }
+        if (solved_iterative || no_change || contains_inconsistency) break;
+    }
+
+    if (contains_inconsistency) {
+        *error = "Puzzle is inconsistent";
+        sfree(old_guess);
+        free_game(solve_state);
+        return NULL;
+    }
+
+    /* If necessary, try to solve the puzzle with the brute-force solver */
+    solved_bruteforce = FALSE;  
+    if (!solved_iterative) {
+        for (p=0;p<solve_state->common->num_total;p++)
+            if (solve_state->guess[p] != 1 && solve_state->guess[p] != 2 &&
+                solve_state->guess[p] != 4) count_ambiguous++;
+        solved_bruteforce =
+            solve_bruteforce(solve_state, solve_state->common->paths);
+    }
+
+    if (!solved_iterative && !solved_bruteforce) {
+        *error = "Puzzle is unsolvable";
+        sfree(old_guess);
+        free_game(solve_state);
+        return NULL;
+    }
+
+/*  printf("Puzzle solved at level %s, iterations %d, ambiguous %d\n", (solved_bruteforce ? "TRICKY" : "NORMAL"), iterative_depth, count_ambiguous); */
+
+    move = snewn(solve_state->common->num_total * 4 +2, char);
+    c = move;
+    *c++='S';
+    for (i = 0; i < solve_state->common->num_total; i++) {
+        if (solve_state->guess[i] == 1) c += sprintf(c, ";G%d", i);
+        if (solve_state->guess[i] == 2) c += sprintf(c, ";V%d", i);
+        if (solve_state->guess[i] == 4) c += sprintf(c, ";Z%d", i);
+    }
+    *c++ = '\0';
+    move = sresize(move, c - move, char);
+
+    sfree(old_guess);   
+    free_game(solve_state);
+    return move;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w,h,c,r,xi,g;
+    char *ret;
+    char buf[120];
+
+    ret = snewn(50 + 6*(state->common->params.w +2) +
+                6*(state->common->params.h+2) +
+                3*(state->common->params.w * state->common->params.h), char);
+
+    sprintf(ret,"G: %d V: %d Z: %d\n\n",state->common->num_ghosts,
+            state->common->num_vampires, state->common->num_zombies);
+
+    for (h=0;h<state->common->params.h+2;h++) {
+        for (w=0;w<state->common->params.w+2;w++) {
+            c = state->common->grid[w+h*(state->common->params.w+2)];
+            xi = state->common->xinfo[w+h*(state->common->params.w+2)];
+            r = grid2range(w,h,state->common->params.w,state->common->params.h);
+            if (r != -1) {
+                sprintf(buf,"%2d", c);  strcat(ret,buf);
+            } else if (c == CELL_MIRROR_L) {
+                sprintf(buf," \\"); strcat(ret,buf);
+            } else if (c == CELL_MIRROR_R) {
+                sprintf(buf," /"); strcat(ret,buf);
+            } else if (xi >= 0) {
+                g = state->guess[xi];
+                if (g == 1)      { sprintf(buf," G"); strcat(ret,buf); }
+                else if (g == 2) { sprintf(buf," V"); strcat(ret,buf); }
+                else if (g == 4) { sprintf(buf," Z"); strcat(ret,buf); }
+                else             { sprintf(buf," ."); strcat(ret,buf); }
+            } else {
+                sprintf(buf,"  "); strcat(ret,buf);
+            }
+        }
+        sprintf(buf,"\n"); strcat(ret,buf);
+    }
+
+    return ret;
+}
+
+struct game_ui {
+    int hx, hy;                         /* as for solo.c, highlight pos */
+    int hshow, hpencil, hcursor;        /* show state, type, and ?cursor. */
+    int ascii;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->hx = ui->hy = 0;
+    ui->hpencil = ui->hshow = ui->hcursor = 0;
+    ui->ascii = FALSE;
+    return ui;
+}
+
+static void free_ui(game_ui *ui) {
+    sfree(ui);
+    return;
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+    return;
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    /* See solo.c; if we were pencil-mode highlighting and
+     * somehow a square has just been properly filled, cancel
+     * pencil mode. */
+    if (ui->hshow && ui->hpencil && !ui->hcursor) {
+        int g = newstate->guess[newstate->common->xinfo[ui->hx + ui->hy*(newstate->common->params.w+2)]];
+        if (g == 1 || g == 2 || g == 4)
+            ui->hshow = 0;
+    }
+}
+
+struct game_drawstate {
+    int tilesize, started, solved;
+    int w, h;
+        
+    int *monsters;
+    unsigned char *pencils;
+
+    unsigned char count_errors[3];
+    unsigned char *cell_errors;
+    unsigned char *hint_errors;
+    unsigned char *hints_done;
+
+    int hx, hy, hshow, hpencil; /* as for game_ui. */
+    int hflash;
+    int ascii;
+};
+
+static int is_clue(const game_state *state, int x, int y)
+{
+    int h = state->common->params.h, w = state->common->params.w;
+
+    if (((x == 0 || x == w + 1) && y > 0 && y <= h) ||
+        ((y == 0 || y == h + 1) && x > 0 && x <= w))
+        return TRUE;
+
+    return FALSE;
+}
+
+static int clue_index(const game_state *state, int x, int y)
+{
+    int h = state->common->params.h, w = state->common->params.w;
+
+    if (y == 0)
+        return x - 1;
+    else if (x == w + 1)
+        return w + y - 1;
+    else if (y == h + 1)
+        return 2 * w + h - x;
+    else if (x == 0)
+        return 2 * (w + h) - y;
+
+    return -1;
+}
+
+#define TILESIZE (ds->tilesize)
+#define BORDER (TILESIZE/4)
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int gx,gy;
+    int g,xi;
+    char buf[80]; 
+
+    gx = ((x-BORDER-1) / TILESIZE );
+    gy = ((y-BORDER-2) / TILESIZE ) - 1;
+
+    if (button == 'a' || button == 'A') {
+        ui->ascii = !ui->ascii;
+        return "";      
+    }
+
+    if (button == 'm' || button == 'M') {
+        return dupstr("M");
+    }
+    
+    if (ui->hshow == 1 && ui->hpencil == 0) {
+        xi = state->common->xinfo[ui->hx + ui->hy*(state->common->params.w+2)];
+        if (xi >= 0 && !state->common->fixed[xi]) {
+            if (button == 'g' || button == 'G' || button == '1') {
+                if (!ui->hcursor) ui->hshow = 0;
+                sprintf(buf,"G%d",xi);
+                return dupstr(buf);
+            }
+            if (button == 'v' || button == 'V' || button == '2') {
+                if (!ui->hcursor) ui->hshow = 0;
+                sprintf(buf,"V%d",xi);
+                return dupstr(buf);
+            }
+            if (button == 'z' || button == 'Z' || button == '3') {
+                if (!ui->hcursor) ui->hshow = 0;
+                sprintf(buf,"Z%d",xi);
+                return dupstr(buf);
+            }
+            if (button == 'e' || button == 'E' || button == CURSOR_SELECT2 ||
+                button == '0' || button == '\b' ) {
+                if (!ui->hcursor) ui->hshow = 0;
+                sprintf(buf,"E%d",xi);
+                return dupstr(buf);
+            }
+        }       
+    }
+
+    if (IS_CURSOR_MOVE(button)) {
+        if (ui->hx == 0 && ui->hy == 0) {
+            ui->hx = 1;
+            ui->hy = 1;
+        }
+        else switch (button) {
+              case CURSOR_UP:     ui->hy -= (ui->hy > 1)     ? 1 : 0; break;
+              case CURSOR_DOWN:   ui->hy += (ui->hy < ds->h) ? 1 : 0; break;
+              case CURSOR_RIGHT:  ui->hx += (ui->hx < ds->w) ? 1 : 0; break;
+              case CURSOR_LEFT:   ui->hx -= (ui->hx > 1)     ? 1 : 0; break;
+            }
+        ui->hshow = ui->hcursor = 1;
+        return "";
+    }
+    if (ui->hshow && button == CURSOR_SELECT) {
+        ui->hpencil = 1 - ui->hpencil;
+        ui->hcursor = 1;
+        return "";
+    }
+
+    if (ui->hshow == 1 && ui->hpencil == 1) {
+        xi = state->common->xinfo[ui->hx + ui->hy*(state->common->params.w+2)];
+        if (xi >= 0 && !state->common->fixed[xi]) {
+            if (button == 'g' || button == 'G' || button == '1') {
+                sprintf(buf,"g%d",xi);
+                if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
+                return dupstr(buf);
+            }
+            if (button == 'v' || button == 'V' || button == '2') {
+                sprintf(buf,"v%d",xi);
+                if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
+                return dupstr(buf);
+            }
+            if (button == 'z' || button == 'Z' || button == '3') {
+                sprintf(buf,"z%d",xi);
+                if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
+                return dupstr(buf);
+            }
+            if (button == 'e' || button == 'E' || button == CURSOR_SELECT2 ||
+                button == '0' || button == '\b') {
+                sprintf(buf,"E%d",xi);
+                if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
+                return dupstr(buf);
+            }
+        }       
+    }
+
+    if (gx > 0 && gx < ds->w+1 && gy > 0 && gy < ds->h+1) {
+        xi = state->common->xinfo[gx+gy*(state->common->params.w+2)];
+        if (xi >= 0 && !state->common->fixed[xi]) {
+            g = state->guess[xi];
+            if (ui->hshow == 0) {
+                if (button == LEFT_BUTTON) {
+                    ui->hshow = 1; ui->hpencil = 0; ui->hcursor = 0;
+                    ui->hx = gx; ui->hy = gy;
+                    return "";
+                }
+                else if (button == RIGHT_BUTTON && g == 7) {
+                    ui->hshow = 1; ui->hpencil = 1; ui->hcursor = 0;
+                    ui->hx = gx; ui->hy = gy;
+                    return "";
+                }
+            }
+            else if (ui->hshow == 1) {
+                if (button == LEFT_BUTTON) {
+                    if (ui->hpencil == 0) {
+                        if (gx == ui->hx && gy == ui->hy) {
+                            ui->hshow = 0; ui->hpencil = 0; ui->hcursor = 0;
+                            ui->hx = 0; ui->hy = 0;
+                            return "";
+                        }
+                        else {
+                            ui->hshow = 1; ui->hpencil = 0; ui->hcursor = 0;
+                            ui->hx = gx; ui->hy = gy;
+                            return "";
+                        }
+                    }
+                    else {
+                        ui->hshow = 1; ui->hpencil = 0; ui->hcursor = 0;
+                        ui->hx = gx; ui->hy = gy;
+                        return "";
+                    }
+                }
+                else if (button == RIGHT_BUTTON) {
+                    if (ui->hpencil == 0 && g == 7) {
+                        ui->hshow = 1; ui->hpencil = 1; ui->hcursor = 0;
+                        ui->hx = gx; ui->hy = gy;
+                        return "";
+                    }
+                    else {
+                        if (gx == ui->hx && gy == ui->hy) {
+                            ui->hshow = 0; ui->hpencil = 0; ui->hcursor = 0;
+                            ui->hx = 0; ui->hy = 0;
+                            return "";
+                        }
+                        else if (g == 7) {
+                            ui->hshow = 1; ui->hpencil = 1; ui->hcursor = 0;
+                            ui->hx = gx; ui->hy = gy;
+                            return "";
+                        }
+                    }
+                }
+            }
+        }
+    } else if (button == LEFT_BUTTON) {
+        if (is_clue(state, gx, gy)) {
+            sprintf(buf, "D%d,%d", gx, gy);
+            return dupstr(buf);
+        }
+    }
+
+    return NULL;
+}
+
+int check_numbers_draw(game_state *state, int *guess) {
+    int valid, filled;
+    int i,x,y,xy;
+    int count_ghosts, count_vampires, count_zombies;
+
+    count_ghosts = count_vampires = count_zombies = 0;  
+    for (i=0;i<state->common->num_total;i++) {
+        if (guess[i] == 1) count_ghosts++;
+        if (guess[i] == 2) count_vampires++;
+        if (guess[i] == 4) count_zombies++;
+    }
+
+    valid = TRUE;
+    filled = (count_ghosts + count_vampires + count_zombies >=
+              state->common->num_total);
+
+    if (count_ghosts > state->common->num_ghosts ||
+        (filled && count_ghosts != state->common->num_ghosts) ) {
+        valid = FALSE; 
+        state->count_errors[0] = TRUE; 
+        for (x=1;x<state->common->params.w+1;x++)
+            for (y=1;y<state->common->params.h+1;y++) {
+                xy = x+y*(state->common->params.w+2);
+                if (state->common->xinfo[xy] >= 0 &&
+                    guess[state->common->xinfo[xy]] == 1)
+                    state->cell_errors[xy] = TRUE;
+            }
+    }
+    if (count_vampires > state->common->num_vampires ||
+        (filled && count_vampires != state->common->num_vampires) ) {
+        valid = FALSE; 
+        state->count_errors[1] = TRUE; 
+        for (x=1;x<state->common->params.w+1;x++)
+            for (y=1;y<state->common->params.h+1;y++) {
+                xy = x+y*(state->common->params.w+2);
+                if (state->common->xinfo[xy] >= 0 &&
+                    guess[state->common->xinfo[xy]] == 2)
+                    state->cell_errors[xy] = TRUE;
+            }
+    }
+    if (count_zombies > state->common->num_zombies ||
+        (filled && count_zombies != state->common->num_zombies) )  {
+        valid = FALSE; 
+        state->count_errors[2] = TRUE; 
+        for (x=1;x<state->common->params.w+1;x++)
+            for (y=1;y<state->common->params.h+1;y++) {
+                xy = x+y*(state->common->params.w+2);
+                if (state->common->xinfo[xy] >= 0 &&
+                    guess[state->common->xinfo[xy]] == 4)
+                    state->cell_errors[xy] = TRUE;
+            }
+    }
+
+    return valid;
+}
+
+int check_path_solution(game_state *state, int p) {
+    int i;
+    int mirror;
+    int count;
+    int correct;
+    int unfilled;
+
+    count = 0;
+    mirror = FALSE;
+    correct = TRUE;
+
+    unfilled = 0;
+    for (i=0;i<state->common->paths[p].length;i++) {
+        if (state->common->paths[p].p[i] == -1) mirror = TRUE;
+        else {
+            if (state->guess[state->common->paths[p].p[i]] == 1 && mirror)
+                count++;
+            else if (state->guess[state->common->paths[p].p[i]] == 2 && !mirror)
+                count++;
+            else if (state->guess[state->common->paths[p].p[i]] == 4)
+                count++;
+            else if (state->guess[state->common->paths[p].p[i]] == 7)
+                unfilled++;
+        }
+    }
+
+    if (count            > state->common->paths[p].sightings_start ||
+        count + unfilled < state->common->paths[p].sightings_start)
+    {
+        correct = FALSE;
+        state->hint_errors[state->common->paths[p].grid_start] = TRUE;
+    }
+
+    count = 0;
+    mirror = FALSE;
+    unfilled = 0;
+    for (i=state->common->paths[p].length-1;i>=0;i--) {
+        if (state->common->paths[p].p[i] == -1) mirror = TRUE;
+        else {
+            if (state->guess[state->common->paths[p].p[i]] == 1 && mirror)
+                count++;
+            else if (state->guess[state->common->paths[p].p[i]] == 2 && !mirror)
+                count++;
+            else if (state->guess[state->common->paths[p].p[i]] == 4)
+                count++;
+            else if (state->guess[state->common->paths[p].p[i]] == 7)
+                unfilled++;
+        }
+    }
+
+    if (count            > state->common->paths[p].sightings_end ||
+        count + unfilled < state->common->paths[p].sightings_end)
+    {
+        correct = FALSE;
+        state->hint_errors[state->common->paths[p].grid_end] = TRUE;
+    }
+
+    if (!correct) {
+        for (i=0;i<state->common->paths[p].length;i++) 
+            state->cell_errors[state->common->paths[p].xy[i]] = TRUE;
+    }
+
+    return correct;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int x,y,n,p,i;
+    char c;
+    int correct; 
+    int solver; 
+
+    game_state *ret = dup_game(state);
+    solver = FALSE;
+
+    while (*move) {
+        c = *move;
+        if (c == 'S') {
+            move++;
+            solver = TRUE;
+        }
+        if (c == 'G' || c == 'V' || c == 'Z' || c == 'E' ||
+            c == 'g' || c == 'v' || c == 'z') {
+            move++;
+            sscanf(move, "%d%n", &x, &n);
+            if (c == 'G') ret->guess[x] = 1;
+            if (c == 'V') ret->guess[x] = 2;
+            if (c == 'Z') ret->guess[x] = 4;
+            if (c == 'E') { ret->guess[x] = 7; ret->pencils[x] = 0; }
+            if (c == 'g') ret->pencils[x] ^= 1;
+            if (c == 'v') ret->pencils[x] ^= 2;
+            if (c == 'z') ret->pencils[x] ^= 4;
+            move += n;
+        }
+        if (c == 'D' && sscanf(move + 1, "%d,%d%n", &x, &y, &n) == 2 &&
+            is_clue(ret, x, y)) {
+            ret->hints_done[clue_index(ret, x, y)] ^= 1;
+            move += n + 1;
+        }
+        if (c == 'M') {
+            /*
+             * Fill in absolutely all pencil marks in unfilled
+             * squares, for those who like to play by the rigorous
+             * approach of starting off in that state and eliminating
+             * things.
+             */
+            for (i = 0; i < ret->common->wh; i++)
+                if (ret->guess[i] == 7)
+                    ret->pencils[i] = 7;
+            move++;
+        }
+        if (*move == ';') move++;
+    }
+
+    correct = TRUE;
+
+    for (i=0;i<ret->common->wh;i++) ret->cell_errors[i] = FALSE;
+    for (i=0;i<2*ret->common->num_paths;i++) ret->hint_errors[i] = FALSE;
+    for (i=0;i<3;i++) ret->count_errors[i] = FALSE;
+
+    if (!check_numbers_draw(ret,ret->guess)) correct = FALSE;
+
+    for (p=0;p<state->common->num_paths;p++)
+        if (!check_path_solution(ret,p)) correct = FALSE;
+
+    for (i=0;i<state->common->num_total;i++)
+        if (!(ret->guess[i] == 1 || ret->guess[i] == 2 ||
+              ret->guess[i] == 4)) correct = FALSE;
+
+    if (correct && !solver) ret->solved = TRUE;
+    if (solver) ret->cheated = TRUE;
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define PREFERRED_TILE_SIZE 64
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = 2*BORDER+(params->w+2)*TILESIZE;
+    *y = 2*BORDER+(params->h+3)*TILESIZE;
+    return;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+    return;
+}
+
+#define COLOUR(ret, i, r, g, b)     ((ret[3*(i)+0] = (r)), (ret[3*(i)+1] = (g)), (ret[3*(i)+2] = (b)))
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_GRID * 3 + 0] = 0.0F;
+    ret[COL_GRID * 3 + 1] = 0.0F;
+    ret[COL_GRID * 3 + 2] = 0.0F;
+
+    ret[COL_TEXT * 3 + 0] = 0.0F;
+    ret[COL_TEXT * 3 + 1] = 0.0F;
+    ret[COL_TEXT * 3 + 2] = 0.0F;
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_HIGHLIGHT * 3 + 0] = 0.78F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_HIGHLIGHT * 3 + 1] = 0.78F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_HIGHLIGHT * 3 + 2] = 0.78F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_FLASH * 3 + 0] = 1.0F;
+    ret[COL_FLASH * 3 + 1] = 1.0F;
+    ret[COL_FLASH * 3 + 2] = 1.0F;
+
+    ret[COL_GHOST * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.5F;
+    ret[COL_GHOST * 3 + 1] = ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_GHOST * 3 + 2] = ret[COL_BACKGROUND * 3 + 0];
+
+    ret[COL_ZOMBIE * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.5F;
+    ret[COL_ZOMBIE * 3 + 1] = ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_ZOMBIE * 3 + 2] = ret[COL_BACKGROUND * 3 + 0] * 0.5F;
+
+    ret[COL_VAMPIRE * 3 + 0] = ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_VAMPIRE * 3 + 1] = ret[COL_BACKGROUND * 3 + 0] * 0.9F;
+    ret[COL_VAMPIRE * 3 + 2] = ret[COL_BACKGROUND * 3 + 0] * 0.9F;
+
+    ret[COL_DONE * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] / 1.5F;
+    ret[COL_DONE * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] / 1.5F;
+    ret[COL_DONE * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] / 1.5F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int i;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->tilesize = 0;
+    ds->started = ds->solved = FALSE;
+    ds->w = state->common->params.w;
+    ds->h = state->common->params.h;
+    ds->ascii = FALSE;
+    
+    ds->count_errors[0] = FALSE;
+    ds->count_errors[1] = FALSE;
+    ds->count_errors[2] = FALSE;
+
+    ds->monsters = snewn(state->common->num_total,int);
+    for (i=0;i<(state->common->num_total);i++)
+        ds->monsters[i] = 7;
+    ds->pencils = snewn(state->common->num_total,unsigned char);
+    for (i=0;i<state->common->num_total;i++)
+        ds->pencils[i] = 0;
+
+    ds->cell_errors = snewn(state->common->wh,unsigned char);
+    for (i=0;i<state->common->wh;i++)
+        ds->cell_errors[i] = FALSE;
+    ds->hint_errors = snewn(2*state->common->num_paths,unsigned char);
+    for (i=0;i<2*state->common->num_paths;i++)
+        ds->hint_errors[i] = FALSE;
+    ds->hints_done = snewn(2 * state->common->num_paths, unsigned char);
+    memset(ds->hints_done, 0,
+           2 * state->common->num_paths * sizeof(unsigned char));
+
+    ds->hshow = ds->hpencil = ds->hflash = 0;
+    ds->hx = ds->hy = 0;
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds) {
+    sfree(ds->hints_done);
+    sfree(ds->hint_errors);
+    sfree(ds->cell_errors);
+    sfree(ds->pencils);
+    sfree(ds->monsters);
+    sfree(ds);
+    return;
+}
+
+static void draw_cell_background(drawing *dr, game_drawstate *ds,
+                                 const game_state *state, const game_ui *ui,
+                                 int x, int y) {
+
+    int hon;
+    int dx,dy;
+    dx = BORDER+(x* ds->tilesize)+(TILESIZE/2);
+    dy = BORDER+(y* ds->tilesize)+(TILESIZE/2)+TILESIZE;
+
+    hon = (ui->hshow && x == ui->hx && y == ui->hy);
+    draw_rect(dr,dx-(TILESIZE/2)+1,dy-(TILESIZE/2)+1,TILESIZE-1,TILESIZE-1,(hon && !ui->hpencil) ? COL_HIGHLIGHT : COL_BACKGROUND);
+
+    if (hon && ui->hpencil) {
+        int coords[6];
+        coords[0] = dx-(TILESIZE/2)+1;
+        coords[1] = dy-(TILESIZE/2)+1;
+        coords[2] = coords[0] + TILESIZE/2;
+        coords[3] = coords[1];
+        coords[4] = coords[0];
+        coords[5] = coords[1] + TILESIZE/2;
+        draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+    }
+
+    draw_update(dr,dx-(TILESIZE/2)+1,dy-(TILESIZE/2)+1,TILESIZE-1,TILESIZE-1);
+
+    return;
+}
+
+static void draw_circle_or_point(drawing *dr, int cx, int cy, int radius,
+                                 int colour)
+{
+    if (radius > 0)
+        draw_circle(dr, cx, cy, radius, colour, colour);
+    else
+        draw_rect(dr, cx, cy, 1, 1, colour);
+}
+
+static void draw_monster(drawing *dr, game_drawstate *ds, int x, int y,
+                         int tilesize, int hflash, int monster)
+{
+    int black = (hflash ? COL_FLASH : COL_TEXT);
+    
+    if (monster == 1) {                /* ghost */
+        int poly[80], i, j;
+
+        clip(dr,x-(tilesize/2)+2,y-(tilesize/2)+2,tilesize-3,tilesize/2+1);
+        draw_circle(dr,x,y,2*tilesize/5, COL_GHOST,black);
+        unclip(dr);
+
+        i = 0;
+        poly[i++] = x - 2*tilesize/5;
+        poly[i++] = y-2;
+        poly[i++] = x - 2*tilesize/5;
+        poly[i++] = y + 2*tilesize/5;
+
+        for (j = 0; j < 3; j++) {
+            int total = (2*tilesize/5) * 2;
+            int before = total * j / 3;
+            int after = total * (j+1) / 3;
+            int mid = (before + after) / 2;
+            poly[i++] = x - 2*tilesize/5 + mid;
+            poly[i++] = y + 2*tilesize/5 - (total / 6);
+            poly[i++] = x - 2*tilesize/5 + after;
+            poly[i++] = y + 2*tilesize/5;
+        }
+
+        poly[i++] = x + 2*tilesize/5;
+        poly[i++] = y-2;
+
+        clip(dr,x-(tilesize/2)+2,y,tilesize-3,tilesize-(tilesize/2)-1);
+        draw_polygon(dr, poly, i/2, COL_GHOST, black);
+        unclip(dr);
+
+        draw_circle(dr,x-tilesize/6,y-tilesize/12,tilesize/10,
+                    COL_BACKGROUND,black);
+        draw_circle(dr,x+tilesize/6,y-tilesize/12,tilesize/10,
+                    COL_BACKGROUND,black);
+        
+        draw_circle_or_point(dr,x-tilesize/6+1+tilesize/48,y-tilesize/12,
+                             tilesize/48,black);
+        draw_circle_or_point(dr,x+tilesize/6+1+tilesize/48,y-tilesize/12,
+                             tilesize/48,black);
+        
+    } else if (monster == 2) {         /* vampire */
+        int poly[80], i;
+
+        clip(dr,x-(tilesize/2)+2,y-(tilesize/2)+2,tilesize-3,tilesize/2);
+        draw_circle(dr,x,y,2*tilesize/5,black,black);
+        unclip(dr);
+
+        clip(dr,x-(tilesize/2)+2,y-(tilesize/2)+2,tilesize/2+1,tilesize/2);
+        draw_circle(dr,x-tilesize/7,y,2*tilesize/5-tilesize/7,
+                    COL_VAMPIRE,black);
+        unclip(dr);
+        clip(dr,x,y-(tilesize/2)+2,tilesize/2+1,tilesize/2);
+        draw_circle(dr,x+tilesize/7,y,2*tilesize/5-tilesize/7,
+                    COL_VAMPIRE,black);
+        unclip(dr);
+
+        clip(dr,x-(tilesize/2)+2,y,tilesize-3,tilesize/2);
+        draw_circle(dr,x,y,2*tilesize/5, COL_VAMPIRE,black);
+        unclip(dr);
+
+        draw_circle(dr, x-tilesize/7, y-tilesize/16, tilesize/16,
+                    COL_BACKGROUND, black);
+        draw_circle(dr, x+tilesize/7, y-tilesize/16, tilesize/16,
+                    COL_BACKGROUND, black);
+        draw_circle_or_point(dr, x-tilesize/7, y-tilesize/16, tilesize/48,
+                             black);
+        draw_circle_or_point(dr, x+tilesize/7, y-tilesize/16, tilesize/48,
+                             black);
+
+        clip(dr, x-(tilesize/2)+2, y+tilesize/8, tilesize-3, tilesize/4);
+
+        i = 0;
+        poly[i++] = x-3*tilesize/16;
+        poly[i++] = y+1*tilesize/8;
+        poly[i++] = x-2*tilesize/16;
+        poly[i++] = y+7*tilesize/24;
+        poly[i++] = x-1*tilesize/16;
+        poly[i++] = y+1*tilesize/8;
+        draw_polygon(dr, poly, i/2, COL_BACKGROUND, black);
+        i = 0;
+        poly[i++] = x+3*tilesize/16;
+        poly[i++] = y+1*tilesize/8;
+        poly[i++] = x+2*tilesize/16;
+        poly[i++] = y+7*tilesize/24;
+        poly[i++] = x+1*tilesize/16;
+        poly[i++] = y+1*tilesize/8;
+        draw_polygon(dr, poly, i/2, COL_BACKGROUND, black);
+
+        draw_circle(dr, x, y-tilesize/5, 2*tilesize/5, COL_VAMPIRE, black);
+        unclip(dr);
+
+    } else if (monster == 4) {         /* zombie */
+        draw_circle(dr,x,y,2*tilesize/5, COL_ZOMBIE,black);
+
+        draw_line(dr,
+                  x-tilesize/7-tilesize/16, y-tilesize/12-tilesize/16,
+                  x-tilesize/7+tilesize/16, y-tilesize/12+tilesize/16,
+                  black);
+        draw_line(dr,
+                  x-tilesize/7+tilesize/16, y-tilesize/12-tilesize/16,
+                  x-tilesize/7-tilesize/16, y-tilesize/12+tilesize/16,
+                  black);
+        draw_line(dr,
+                  x+tilesize/7-tilesize/16, y-tilesize/12-tilesize/16,
+                  x+tilesize/7+tilesize/16, y-tilesize/12+tilesize/16,
+                  black);
+        draw_line(dr,
+                  x+tilesize/7+tilesize/16, y-tilesize/12-tilesize/16,
+                  x+tilesize/7-tilesize/16, y-tilesize/12+tilesize/16,
+                  black);
+
+        clip(dr, x-tilesize/5, y+tilesize/6, 2*tilesize/5+1, tilesize/2);
+        draw_circle(dr, x-tilesize/15, y+tilesize/6, tilesize/12,
+                    COL_BACKGROUND, black);
+        unclip(dr);
+
+        draw_line(dr, x-tilesize/5, y+tilesize/6, x+tilesize/5, y+tilesize/6,
+                  black);
+    }
+
+    draw_update(dr,x-(tilesize/2)+2,y-(tilesize/2)+2,tilesize-3,tilesize-3);
+}
+
+static void draw_monster_count(drawing *dr, game_drawstate *ds,
+                               const game_state *state, int c, int hflash) {
+    int dx,dy;
+    char buf[8];
+    char bufm[8];
+    
+    dy = TILESIZE/4;
+    dx = BORDER+(ds->w+2)*TILESIZE/2+TILESIZE/4;
+    switch (c) {
+      case 0: 
+        sprintf(buf,"%d",state->common->num_ghosts);
+        sprintf(bufm,"G");
+        dx -= 3*TILESIZE/2;
+        break;
+      case 1: 
+        sprintf(buf,"%d",state->common->num_vampires); 
+        sprintf(bufm,"V");
+        break;
+      case 2: 
+        sprintf(buf,"%d",state->common->num_zombies); 
+        sprintf(bufm,"Z");
+        dx += 3*TILESIZE/2;
+        break;
+    }
+
+    draw_rect(dr, dx-2*TILESIZE/3, dy, 3*TILESIZE/2, TILESIZE,
+              COL_BACKGROUND);
+    if (!ds->ascii) { 
+        draw_monster(dr, ds, dx-TILESIZE/3, dy+TILESIZE/2,
+                     2*TILESIZE/3, hflash, 1<<c);
+    } else {
+        draw_text(dr, dx-TILESIZE/3,dy+TILESIZE/2,FONT_VARIABLE,TILESIZE/2,
+                  ALIGN_HCENTRE|ALIGN_VCENTRE,
+                  hflash ? COL_FLASH : COL_TEXT, bufm);
+    }
+    draw_text(dr, dx, dy+TILESIZE/2, FONT_VARIABLE, TILESIZE/2,
+              ALIGN_HLEFT|ALIGN_VCENTRE,
+              (state->count_errors[c] ? COL_ERROR :
+               hflash ? COL_FLASH : COL_TEXT), buf);
+    draw_update(dr, dx-2*TILESIZE/3, dy, 3*TILESIZE/2, TILESIZE);
+
+    return;
+}
+
+static void draw_path_hint(drawing *dr, game_drawstate *ds,
+                           const struct game_params *params,
+                           int hint_index, int hflash, int hint) {
+    int x, y, color, dx, dy, text_dx, text_dy, text_size;
+    char buf[4];
+
+    if (ds->hint_errors[hint_index])
+        color = COL_ERROR;
+    else if (hflash)
+        color = COL_FLASH;
+    else if (ds->hints_done[hint_index])
+        color = COL_DONE;
+    else
+        color = COL_TEXT;
+
+    range2grid(hint_index, params->w, params->h, &x, &y);
+    /* Upper-left corner of the "tile" */
+    dx = BORDER + x * TILESIZE;
+    dy = BORDER + y * TILESIZE + TILESIZE;
+    /* Center of the "tile" */
+    text_dx = dx + TILESIZE / 2;
+    text_dy = dy +  TILESIZE / 2;
+    /* Avoid wiping out the borders of the puzzle */
+    dx += 2;
+    dy += 2;
+    text_size = TILESIZE - 3;
+
+    sprintf(buf,"%d", hint);
+    draw_rect(dr, dx, dy, text_size, text_size, COL_BACKGROUND);
+    draw_text(dr, text_dx, text_dy, FONT_FIXED, TILESIZE / 2,
+              ALIGN_HCENTRE | ALIGN_VCENTRE, color, buf);
+    draw_update(dr, dx, dy, text_size, text_size);
+
+    return;
+}
+
+static void draw_mirror(drawing *dr, game_drawstate *ds,
+                        const game_state *state, int x, int y,
+                        int hflash, int mirror) {
+    int dx,dy,mx1,my1,mx2,my2;
+    dx = BORDER+(x* ds->tilesize)+(TILESIZE/2);
+    dy = BORDER+(y* ds->tilesize)+(TILESIZE/2)+TILESIZE;
+
+    if (mirror == CELL_MIRROR_L) {
+        mx1 = dx-(TILESIZE/4);
+        my1 = dy-(TILESIZE/4);
+        mx2 = dx+(TILESIZE/4);
+        my2 = dy+(TILESIZE/4);
+    }
+    else {
+        mx1 = dx-(TILESIZE/4);
+        my1 = dy+(TILESIZE/4);
+        mx2 = dx+(TILESIZE/4);
+        my2 = dy-(TILESIZE/4);
+    }
+    draw_thick_line(dr,(float)(TILESIZE/16),mx1,my1,mx2,my2,
+                    hflash ? COL_FLASH : COL_TEXT);
+    draw_update(dr,dx-(TILESIZE/2)+1,dy-(TILESIZE/2)+1,TILESIZE-1,TILESIZE-1);
+
+    return;
+}
+
+static void draw_big_monster(drawing *dr, game_drawstate *ds,
+                             const game_state *state, int x, int y,
+                             int hflash, int monster)
+{
+    int dx,dy;
+    char buf[10];
+    dx = BORDER+(x* ds->tilesize)+(TILESIZE/2);
+    dy = BORDER+(y* ds->tilesize)+(TILESIZE/2)+TILESIZE;
+    if (ds->ascii) {
+        if (monster == 1) sprintf(buf,"G");
+        else if (monster == 2) sprintf(buf,"V");
+        else if (monster == 4) sprintf(buf,"Z");
+        else sprintf(buf," ");
+        draw_text(dr,dx,dy,FONT_FIXED,TILESIZE/2,ALIGN_HCENTRE|ALIGN_VCENTRE,
+                  hflash ? COL_FLASH : COL_TEXT,buf);
+        draw_update(dr,dx-(TILESIZE/2)+2,dy-(TILESIZE/2)+2,TILESIZE-3,
+                    TILESIZE-3);
+    }
+    else {
+        draw_monster(dr, ds, dx, dy, 3*TILESIZE/4, hflash, monster);
+    }
+    return;
+}
+
+static void draw_pencils(drawing *dr, game_drawstate *ds,
+                         const game_state *state, int x, int y, int pencil)
+{
+    int dx, dy;
+    int monsters[4];
+    int i, j, px, py;
+    char buf[10];
+    dx = BORDER+(x* ds->tilesize)+(TILESIZE/4);
+    dy = BORDER+(y* ds->tilesize)+(TILESIZE/4)+TILESIZE;
+
+    for (i = 0, j = 1; j < 8; j *= 2)
+        if (pencil & j)
+            monsters[i++] = j;
+    while (i < 4)
+        monsters[i++] = 0;
+
+    for (py = 0; py < 2; py++)
+        for (px = 0; px < 2; px++)
+            if (monsters[py*2+px]) {
+                if (!ds->ascii) {
+                    draw_monster(dr, ds,
+                                 dx + TILESIZE/2 * px, dy + TILESIZE/2 * py,
+                                 TILESIZE/2, 0, monsters[py*2+px]);
+                }
+                else {
+                    switch (monsters[py*2+px]) {
+                      case 1: sprintf(buf,"G"); break;
+                      case 2: sprintf(buf,"V"); break;
+                      case 4: sprintf(buf,"Z"); break;
+                    }
+                    draw_text(dr,dx + TILESIZE/2 * px,dy + TILESIZE/2 * py,
+                              FONT_FIXED,TILESIZE/4,ALIGN_HCENTRE|ALIGN_VCENTRE,
+                              COL_TEXT,buf);
+                }
+            }
+    draw_update(dr,dx-(TILESIZE/4)+2,dy-(TILESIZE/4)+2,
+                (TILESIZE/2)-3,(TILESIZE/2)-3);
+
+    return;
+}
+
+#define FLASH_TIME 0.7F
+
+static int is_hint_stale(const game_drawstate *ds, int hflash,
+                         const game_state *state, int index)
+{
+    int ret = FALSE;
+    if (!ds->started) ret = TRUE;
+    if (ds->hflash != hflash) ret = TRUE;
+
+    if (ds->hint_errors[index] != state->hint_errors[index]) {
+        ds->hint_errors[index] = state->hint_errors[index];
+        ret = TRUE;
+    }
+
+    if (ds->hints_done[index] != state->hints_done[index]) {
+        ds->hints_done[index] = state->hints_done[index];
+        ret = TRUE;
+    }
+
+    return ret;
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int i,j,x,y,xy;
+    int stale, xi, c, hflash, hchanged, changed_ascii;
+
+    hflash = (int)(flashtime * 5 / FLASH_TIME) % 2;
+
+    /* Draw static grid components at startup */    
+    if (!ds->started) { 
+        draw_rect(dr, 0, 0, 2*BORDER+(ds->w+2)*TILESIZE,
+                  2*BORDER+(ds->h+3)*TILESIZE, COL_BACKGROUND);
+        draw_rect(dr, BORDER+TILESIZE-1, BORDER+2*TILESIZE-1,
+                  (ds->w)*TILESIZE +3, (ds->h)*TILESIZE +3, COL_GRID);
+        for (i=0;i<ds->w;i++)
+            for (j=0;j<ds->h;j++)
+                draw_rect(dr, BORDER+(ds->tilesize*(i+1))+1,
+                          BORDER+(ds->tilesize*(j+2))+1, ds->tilesize-1,
+                          ds->tilesize-1, COL_BACKGROUND);
+        draw_update(dr, 0, 0, 2*BORDER+(ds->w+2)*TILESIZE,
+                    2*BORDER+(ds->h+3)*TILESIZE);
+    }
+
+    hchanged = FALSE;
+    if (ds->hx != ui->hx || ds->hy != ui->hy ||
+        ds->hshow != ui->hshow || ds->hpencil != ui->hpencil)
+        hchanged = TRUE;
+
+    if (ds->ascii != ui->ascii) {
+        ds->ascii = ui->ascii;
+        changed_ascii = TRUE;
+    } else
+        changed_ascii = FALSE;
+
+    /* Draw monster count hints */
+
+    for (i=0;i<3;i++) {
+        stale = FALSE;
+        if (!ds->started) stale = TRUE;
+        if (ds->hflash != hflash) stale = TRUE;
+        if (changed_ascii) stale = TRUE;
+        if (ds->count_errors[i] != state->count_errors[i]) {
+            stale = TRUE;
+            ds->count_errors[i] = state->count_errors[i];
+        }
+        
+        if (stale) {
+            draw_monster_count(dr, ds, state, i, hflash);
+        }
+    }
+
+    /* Draw path count hints */
+    for (i=0;i<state->common->num_paths;i++) {
+        struct path *path = &state->common->paths[i];
+        
+        if (is_hint_stale(ds, hflash, state, path->grid_start)) {
+            draw_path_hint(dr, ds, &state->common->params, path->grid_start,
+                           hflash, path->sightings_start);
+        }
+
+        if (is_hint_stale(ds, hflash, state, path->grid_end)) {
+            draw_path_hint(dr, ds, &state->common->params, path->grid_end,
+                           hflash, path->sightings_end);
+        }
+    }
+
+    /* Draw puzzle grid contents */
+    for (x = 1; x < ds->w+1; x++)
+        for (y = 1; y < ds->h+1; y++) {
+            stale = FALSE;
+            xy = x+y*(state->common->params.w+2);
+            xi = state->common->xinfo[xy];
+            c = state->common->grid[xy];
+    
+            if (!ds->started) stale = TRUE;
+            if (ds->hflash != hflash) stale = TRUE;
+            if (changed_ascii) stale = TRUE;
+        
+            if (hchanged) {
+                if ((x == ui->hx && y == ui->hy) ||
+                    (x == ds->hx && y == ds->hy))
+                    stale = TRUE;
+            }
+
+            if (xi >= 0 && (state->guess[xi] != ds->monsters[xi]) ) {
+                stale = TRUE;
+                ds->monsters[xi] = state->guess[xi];
+            }
+        
+            if (xi >= 0 && (state->pencils[xi] != ds->pencils[xi]) ) {
+                stale = TRUE;
+                ds->pencils[xi] = state->pencils[xi];
+            }
+
+            if (state->cell_errors[xy] != ds->cell_errors[xy]) {
+                stale = TRUE;
+                ds->cell_errors[xy] = state->cell_errors[xy];
+            }
+                
+            if (stale) {
+                draw_cell_background(dr, ds, state, ui, x, y);
+                if (xi < 0) 
+                    draw_mirror(dr, ds, state, x, y, hflash, c);
+                else if (state->guess[xi] == 1 || state->guess[xi] == 2 ||
+                         state->guess[xi] == 4)
+                    draw_big_monster(dr, ds, state, x, y, hflash, state->guess[xi]);
+                else 
+                    draw_pencils(dr, ds, state, x, y, state->pencils[xi]);
+            }
+        }
+
+    ds->hx = ui->hx; ds->hy = ui->hy;
+    ds->hshow = ui->hshow;
+    ds->hpencil = ui->hpencil;
+    ds->hflash = hflash;
+    ds->started = TRUE;
+    return;
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    return (!oldstate->solved && newstate->solved && !oldstate->cheated &&
+            !newstate->cheated) ? FLASH_TIME : 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->solved;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame undead
+#endif
+
+const struct game thegame = {
+    "Undead", "games.undead", "undead",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    FALSE,                 /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                     /* flags */
+};
diff --git a/apps/plugins/puzzles/unequal.R b/apps/plugins/puzzles/unequal.R
new file mode 100644
index 0000000000..a061582768
--- /dev/null
+++ b/apps/plugins/puzzles/unequal.R
@@ -0,0 +1,27 @@
+# -*- makefile -*-
+
+UNEQUAL_EXTRA = latin tree234 maxflow
+
+unequal  : [X] GTK COMMON unequal UNEQUAL_EXTRA unequal-icon|no-icon
+
+unequal  : [G] WINDOWS COMMON unequal UNEQUAL_EXTRA unequal.res|noicon.res
+
+unequalsolver : [U] unequal[STANDALONE_SOLVER] latin[STANDALONE_SOLVER] tree234 maxflow STANDALONE
+unequalsolver : [C] unequal[STANDALONE_SOLVER] latin[STANDALONE_SOLVER] tree234 maxflow STANDALONE
+
+latincheck : [U] latin[STANDALONE_LATIN_TEST] tree234 maxflow STANDALONE
+latincheck : [C] latin[STANDALONE_LATIN_TEST] tree234 maxflow STANDALONE
+
+ALL += unequal[COMBINED] UNEQUAL_EXTRA
+
+!begin am gtk
+GAMES += unequal
+!end
+
+!begin >list.c
+    A(unequal) \
+!end
+
+!begin >gamedesc.txt
+unequal:unequal.exe:Unequal:Latin square puzzle:Complete the latin square in accordance with the > signs.
+!end
diff --git a/apps/plugins/puzzles/unequal.c b/apps/plugins/puzzles/unequal.c
new file mode 100644
index 0000000000..457965b4ff
--- /dev/null
+++ b/apps/plugins/puzzles/unequal.c
@@ -0,0 +1,2267 @@
+/*
+ * unequal.c
+ *
+ * Implementation of 'Futoshiki', a puzzle featured in the Guardian.
+ *
+ * TTD:
+   * add multiple-links-on-same-col/row solver nous
+   * Optimise set solver to use bit operations instead
+ *
+ * Guardian puzzles of note:
+   * #1: 5:0,0L,0L,0,0,0R,0,0L,0D,0L,0R,0,2,0D,0,0,0,0,0,0,0U,0,0,0,0U,
+   * #2: 5:0,0,0,4L,0L,0,2LU,0L,0U,0,0,0U,0,0,0,0,0D,0,3LRUD,0,0R,3,0L,0,0,
+   * #3: (reprint of #2)
+   * #4: 
+   * #5: 5:0,0,0,0,0,0,2,0U,3U,0U,0,0,3,0,0,0,3,0D,4,0,0,0L,0R,0,0,
+   * #6: 5:0D,0L,0,0R,0,0,0D,0,3,0D,0,0R,0,0R,0D,0U,0L,0,1,2,0,0,0U,0,0L,
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "latin.h" /* contains typedef for digit */
+
+/* ----------------------------------------------------------
+ * Constant and structure definitions
+ */
+
+#define FLASH_TIME 0.4F
+
+#define PREFERRED_TILE_SIZE 32
+
+#define TILE_SIZE (ds->tilesize)
+#define GAP_SIZE  (TILE_SIZE/2)
+#define SQUARE_SIZE (TILE_SIZE + GAP_SIZE)
+
+#define BORDER    (TILE_SIZE / 2)
+
+#define COORD(x)  ( (x) * SQUARE_SIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + SQUARE_SIZE) / SQUARE_SIZE - 1 )
+
+#define GRID(p,w,x,y) ((p)->w[((y)*(p)->order)+(x)])
+#define GRID3(p,w,x,y,z) ((p)->w[ (((x)*(p)->order+(y))*(p)->order+(z)) ])
+#define HINT(p,x,y,n) GRID3(p, hints, x, y, n)
+
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_TEXT, COL_GUESS, COL_ERROR, COL_PENCIL,
+    COL_HIGHLIGHT, COL_LOWLIGHT, COL_SPENT = COL_LOWLIGHT,
+    NCOLOURS
+};
+
+struct game_params {
+    int order;          /* Size of latin square */
+    int diff;           /* Difficulty */
+    int adjacent;       /* Puzzle indicators are 'adjacent number'
+                            not 'greater-than'. */
+};
+
+#define F_IMMUTABLE     1       /* passed in as game description */
+#define F_ADJ_UP        2
+#define F_ADJ_RIGHT     4
+#define F_ADJ_DOWN      8
+#define F_ADJ_LEFT      16
+#define F_ERROR         32
+#define F_ERROR_UP      64
+#define F_ERROR_RIGHT   128
+#define F_ERROR_DOWN    256
+#define F_ERROR_LEFT    512
+#define F_SPENT_UP      1024
+#define F_SPENT_RIGHT   2048
+#define F_SPENT_DOWN    4096
+#define F_SPENT_LEFT    8192
+
+#define ADJ_TO_SPENT(x) ((x) << 9)
+
+#define F_ERROR_MASK (F_ERROR|F_ERROR_UP|F_ERROR_RIGHT|F_ERROR_DOWN|F_ERROR_LEFT)
+
+struct game_state {
+    int order, completed, cheated, adjacent;
+    digit *nums;                 /* actual numbers (size order^2) */
+    unsigned char *hints;        /* remaining possiblities (size order^3) */
+    unsigned int *flags;         /* flags (size order^2) */
+};
+
+/* ----------------------------------------------------------
+ * Game parameters and presets
+ */
+
+/* Steal the method from map.c for difficulty levels. */
+#define DIFFLIST(A)               \
+    A(LATIN,Trivial,NULL,t)       \
+    A(EASY,Easy,solver_easy, e)   \
+    A(SET,Tricky,solver_set, k)   \
+    A(EXTREME,Extreme,NULL,x)     \
+    A(RECURSIVE,Recursive,NULL,r)
+
+#define ENUM(upper,title,func,lower) DIFF_ ## upper,
+#define TITLE(upper,title,func,lower) #title,
+#define ENCODE(upper,title,func,lower) #lower
+#define CONFIG(upper,title,func,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT, DIFF_IMPOSSIBLE = diff_impossible, DIFF_AMBIGUOUS = diff_ambiguous, DIFF_UNFINISHED = diff_unfinished };
+static char const *const unequal_diffnames[] = { DIFFLIST(TITLE) };
+static char const unequal_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+#define DEFAULT_PRESET 0
+
+const static struct game_params unequal_presets[] = {
+    {  4, DIFF_EASY,    0 },
+    {  5, DIFF_EASY,    0 },
+    {  5, DIFF_SET,     0 },
+    {  5, DIFF_SET,     1 },
+    {  5, DIFF_EXTREME, 0 },
+    {  6, DIFF_EASY,    0 },
+    {  6, DIFF_SET,     0 },
+    {  6, DIFF_SET,     1 },
+    {  6, DIFF_EXTREME, 0 },
+    {  7, DIFF_SET,     0 },
+    {  7, DIFF_SET,     1 },
+    {  7, DIFF_EXTREME, 0 }
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(unequal_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = unequal_presets[i]; /* structure copy */
+
+    sprintf(buf, "%s: %dx%d %s",
+            ret->adjacent ? "Adjacent" : "Unequal",
+            ret->order, ret->order,
+            unequal_diffnames[ret->diff]);
+
+    *name = dupstr(buf);
+    *params = ret;
+    return TRUE;
+}
+
+static game_params *default_params(void)
+{
+    game_params *ret;
+    char *name;
+
+    if (!game_fetch_preset(DEFAULT_PRESET, &name, &ret)) return NULL;
+    sfree(name);
+    return ret;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;       /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *ret, char const *string)
+{
+    char const *p = string;
+
+    ret->order = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+
+    if (*p == 'a') {
+        p++;
+        ret->adjacent = 1;
+    } else
+        ret->adjacent = 0;
+
+    if (*p == 'd') {
+        int i;
+        p++;
+        ret->diff = DIFFCOUNT+1; /* ...which is invalid */
+        if (*p) {
+            for (i = 0; i < DIFFCOUNT; i++) {
+                if (*p == unequal_diffchars[i])
+                    ret->diff = i;
+            }
+            p++;
+        }
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char ret[80];
+
+    sprintf(ret, "%d", params->order);
+    if (params->adjacent)
+        sprintf(ret + strlen(ret), "a");
+    if (full)
+        sprintf(ret + strlen(ret), "d%c", unequal_diffchars[params->diff]);
+
+    return dupstr(ret);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Mode";
+    ret[0].type = C_CHOICES;
+    ret[0].sval = ":Unequal:Adjacent";
+    ret[0].ival = params->adjacent;
+
+    ret[1].name = "Size (s*s)";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->order);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Difficulty";
+    ret[2].type = C_CHOICES;
+    ret[2].sval = DIFFCONFIG;
+    ret[2].ival = params->diff;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->adjacent = cfg[0].ival;
+    ret->order = atoi(cfg[1].sval);
+    ret->diff = cfg[2].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->order < 3 || params->order > 32)
+        return "Order must be between 3 and 32";
+    if (params->diff >= DIFFCOUNT)
+        return "Unknown difficulty rating";
+    if (params->order < 5 && params->adjacent &&
+        params->diff >= DIFF_SET)
+        return "Order must be at least 5 for Adjacent puzzles of this difficulty.";
+    return NULL;
+}
+
+/* ----------------------------------------------------------
+ * Various utility functions
+ */
+
+static const struct { unsigned int f, fo, fe; int dx, dy; char c, ac; } adjthan[] = {
+    { F_ADJ_UP,    F_ADJ_DOWN,  F_ERROR_UP,     0, -1, '^', '-' },
+    { F_ADJ_RIGHT, F_ADJ_LEFT,  F_ERROR_RIGHT,  1,  0, '>', '|' },
+    { F_ADJ_DOWN,  F_ADJ_UP,    F_ERROR_DOWN,   0,  1, 'v', '-' },
+    { F_ADJ_LEFT,  F_ADJ_RIGHT, F_ERROR_LEFT,  -1,  0, '<', '|' }
+};
+
+static game_state *blank_game(int order, int adjacent)
+{
+    game_state *state = snew(game_state);
+    int o2 = order*order, o3 = o2*order;
+
+    state->order = order;
+    state->adjacent = adjacent;
+    state->completed = state->cheated = 0;
+
+    state->nums = snewn(o2, digit);
+    state->hints = snewn(o3, unsigned char);
+    state->flags = snewn(o2, unsigned int);
+
+    memset(state->nums, 0, o2 * sizeof(digit));
+    memset(state->hints, 0, o3);
+    memset(state->flags, 0, o2 * sizeof(unsigned int));
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = blank_game(state->order, state->adjacent);
+    int o2 = state->order*state->order, o3 = o2*state->order;
+
+    memcpy(ret->nums, state->nums, o2 * sizeof(digit));
+    memcpy(ret->hints, state->hints, o3);
+    memcpy(ret->flags, state->flags, o2 * sizeof(unsigned int));
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->nums);
+    sfree(state->hints);
+    sfree(state->flags);
+    sfree(state);
+}
+
+#define CHECKG(x,y) grid[(y)*o+(x)]
+
+/* Returns 0 if it finds an error, 1 otherwise. */
+static int check_num_adj(digit *grid, game_state *state,
+                        int x, int y, int me)
+{
+    unsigned int f = GRID(state, flags, x, y);
+    int ret = 1, i, o = state->order;
+
+    for (i = 0; i < 4; i++) {
+        int dx = adjthan[i].dx, dy = adjthan[i].dy, n, dn;
+
+        if (x+dx < 0 || x+dx >= o || y+dy < 0 || y+dy >= o)
+            continue;
+
+        n = CHECKG(x, y);
+        dn = CHECKG(x+dx, y+dy);
+
+        assert (n != 0);
+        if (dn == 0) continue;
+
+        if (state->adjacent) {
+            int gd = abs(n-dn);
+
+            if ((f & adjthan[i].f) && (gd != 1)) {
+                debug(("check_adj error (%d,%d):%d should be | (%d,%d):%d",
+                       x, y, n, x+dx, y+dy, dn));
+                if (me) GRID(state, flags, x, y) |= adjthan[i].fe;
+                ret = 0;
+            }
+            if (!(f & adjthan[i].f) && (gd == 1)) {
+                debug(("check_adj error (%d,%d):%d should not be | (%d,%d):%d",
+                       x, y, n, x+dx, y+dy, dn));
+                if (me) GRID(state, flags, x, y) |= adjthan[i].fe;
+                ret = 0;
+            }
+
+        } else {
+            if ((f & adjthan[i].f) && (n <= dn)) {
+                debug(("check_adj error (%d,%d):%d not > (%d,%d):%d",
+                       x, y, n, x+dx, y+dy, dn));
+                if (me) GRID(state, flags, x, y) |= adjthan[i].fe;
+                ret = 0;
+            }
+        }
+    }
+    return ret;
+}
+
+/* Returns 0 if it finds an error, 1 otherwise. */
+static int check_num_error(digit *grid, game_state *state,
+                           int x, int y, int mark_errors)
+{
+    int o = state->order;
+    int xx, yy, val = CHECKG(x,y), ret = 1;
+
+    assert(val != 0);
+
+    /* check for dups in same column. */
+    for (yy = 0; yy < state->order; yy++) {
+        if (yy == y) continue;
+        if (CHECKG(x,yy) == val) ret = 0;
+    }
+
+    /* check for dups in same row. */
+    for (xx = 0; xx < state->order; xx++) {
+        if (xx == x) continue;
+        if (CHECKG(xx,y) == val) ret = 0;
+    }
+
+    if (!ret) {
+        debug(("check_num_error (%d,%d) duplicate %d", x, y, val));
+        if (mark_errors) GRID(state, flags, x, y) |= F_ERROR;
+    }
+    return ret;
+}
+
+/* Returns:     -1 for 'wrong'
+ *               0 for 'incomplete'
+ *               1 for 'complete and correct'
+ */
+static int check_complete(digit *grid, game_state *state, int mark_errors)
+{
+    int x, y, ret = 1, o = state->order;
+
+    if (mark_errors)
+        assert(grid == state->nums);
+
+    for (x = 0; x < state->order; x++) {
+        for (y = 0; y < state->order; y++) {
+            if (mark_errors)
+                GRID(state, flags, x, y) &= ~F_ERROR_MASK;
+            if (grid[y*o+x] == 0) {
+                ret = 0;
+            } else {
+                if (!check_num_error(grid, state, x, y, mark_errors)) ret = -1;
+                if (!check_num_adj(grid, state, x, y, mark_errors)) ret = -1;
+            }
+        }
+    }
+    if (ret == 1 && latin_check(grid, o))
+        ret = -1;
+    return ret;
+}
+
+static char n2c(digit n, int order) {
+    if (n == 0)         return ' ';
+    if (order < 10) {
+        if (n < 10)     return '0' + n;
+    } else {
+        if (n < 11)     return '0' + n-1;
+        n -= 11;
+        if (n <= 26)    return 'A' + n;
+    }
+    return '?';
+}
+
+/* should be 'digit', but includes -1 for 'not a digit'.
+ * Includes keypresses (0 especially) for interpret_move. */
+static int c2n(int c, int order) {
+    if (c < 0 || c > 0xff)
+        return -1;
+    if (c == ' ' || c == '\b')
+        return 0;
+    if (order < 10) {
+        if (c >= '0' && c <= '9')
+            return (int)(c - '0');
+    } else {
+        if (c >= '0' && c <= '9')
+            return (int)(c - '0' + 1);
+        if (c >= 'A' && c <= 'Z')
+            return (int)(c - 'A' + 11);
+        if (c >= 'a' && c <= 'z')
+            return (int)(c - 'a' + 11);
+    }
+    return -1;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int x, y, len, n;
+    char *ret, *p;
+
+    len = (state->order*2) * (state->order*2-1) + 1;
+    ret = snewn(len, char);
+    p = ret;
+
+    for (y = 0; y < state->order; y++) {
+        for (x = 0; x < state->order; x++) {
+            n = GRID(state, nums, x, y);
+            *p++ = n > 0 ? n2c(n, state->order) : '.';
+
+            if (x < (state->order-1)) {
+                if (state->adjacent) {
+                    *p++ = (GRID(state, flags, x, y) & F_ADJ_RIGHT) ? '|' : ' ';
+                } else {
+                    if (GRID(state, flags, x, y) & F_ADJ_RIGHT)
+                        *p++ = '>';
+                    else if (GRID(state, flags, x+1, y) & F_ADJ_LEFT)
+                        *p++ = '<';
+                    else
+                        *p++ = ' ';
+                }
+            }
+        }
+        *p++ = '\n';
+
+        if (y < (state->order-1)) {
+            for (x = 0; x < state->order; x++) {
+                if (state->adjacent) {
+                    *p++ = (GRID(state, flags, x, y) & F_ADJ_DOWN) ? '-' : ' ';
+                } else {
+                    if (GRID(state, flags, x, y) & F_ADJ_DOWN)
+                        *p++ = 'v';
+                    else if (GRID(state, flags, x, y+1) & F_ADJ_UP)
+                        *p++ = '^';
+                    else
+                        *p++ = ' ';
+                }
+
+                if (x < state->order-1)
+                  *p++ = ' ';
+            }
+            *p++ = '\n';
+        }
+    }
+    *p++ = '\0';
+
+    assert(p - ret == len);
+    return ret;
+}
+
+#ifdef STANDALONE_SOLVER
+static void game_debug(game_state *state)
+{
+    char *dbg = game_text_format(state);
+    printf("%s", dbg);
+    sfree(dbg);
+}
+#endif
+
+/* ----------------------------------------------------------
+ * Solver.
+ */
+
+struct solver_link {
+    int len, gx, gy, lx, ly;
+};
+
+struct solver_ctx {
+    game_state *state;
+
+    int nlinks, alinks;
+    struct solver_link *links;
+};
+
+static void solver_add_link(struct solver_ctx *ctx,
+                            int gx, int gy, int lx, int ly, int len)
+{
+    if (ctx->alinks < ctx->nlinks+1) {
+        ctx->alinks = ctx->alinks*2 + 1;
+        /*debug(("resizing ctx->links, new size %d", ctx->alinks));*/
+        ctx->links = sresize(ctx->links, ctx->alinks, struct solver_link);
+    }
+    ctx->links[ctx->nlinks].gx = gx;
+    ctx->links[ctx->nlinks].gy = gy;
+    ctx->links[ctx->nlinks].lx = lx;
+    ctx->links[ctx->nlinks].ly = ly;
+    ctx->links[ctx->nlinks].len = len;
+    ctx->nlinks++;
+    /*debug(("Adding new link: len %d (%d,%d) < (%d,%d), nlinks now %d",
+           len, lx, ly, gx, gy, ctx->nlinks));*/
+}
+
+static struct solver_ctx *new_ctx(game_state *state)
+{
+    struct solver_ctx *ctx = snew(struct solver_ctx);
+    int o = state->order;
+    int i, x, y;
+    unsigned int f;
+
+    ctx->nlinks = ctx->alinks = 0;
+    ctx->links = NULL;
+    ctx->state = state;
+
+    if (state->adjacent) return ctx; /* adjacent mode doesn't use links. */
+
+    for (x = 0; x < o; x++) {
+        for (y = 0; y < o; y++) {
+            f = GRID(state, flags, x, y);
+            for (i = 0; i < 4; i++) {
+                if (f & adjthan[i].f)
+                    solver_add_link(ctx, x, y, x+adjthan[i].dx, y+adjthan[i].dy, 1);
+            }
+        }
+    }
+
+    return ctx;
+}
+
+static void *clone_ctx(void *vctx)
+{
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    return new_ctx(ctx->state);
+}
+
+static void free_ctx(void *vctx)
+{
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    if (ctx->links) sfree(ctx->links);
+    sfree(ctx);
+}
+
+static void solver_nminmax(struct latin_solver *solver,
+                           int x, int y, int *min_r, int *max_r,
+                           unsigned char **ns_r)
+{
+    int o = solver->o, min = o, max = 0, n;
+    unsigned char *ns;
+
+    assert(x >= 0 && y >= 0 && x < o && y < o);
+
+    ns = solver->cube + cubepos(x,y,1);
+
+    if (grid(x,y) > 0) {
+        min = max = grid(x,y)-1;
+    } else {
+        for (n = 0; n < o; n++) {
+            if (ns[n]) {
+                if (n > max) max = n;
+                if (n < min) min = n;
+            }
+        }
+    }
+    if (min_r) *min_r = min;
+    if (max_r) *max_r = max;
+    if (ns_r) *ns_r = ns;
+}
+
+static int solver_links(struct latin_solver *solver, void *vctx)
+{
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    int i, j, lmin, gmax, nchanged = 0;
+    unsigned char *gns, *lns;
+    struct solver_link *link;
+
+    for (i = 0; i < ctx->nlinks; i++) {
+        link = &ctx->links[i];
+        solver_nminmax(solver, link->gx, link->gy, NULL, &gmax, &gns);
+        solver_nminmax(solver, link->lx, link->ly, &lmin, NULL, &lns);
+
+        for (j = 0; j < solver->o; j++) {
+            /* For the 'greater' end of the link, discount all numbers
+             * too small to satisfy the inequality. */
+            if (gns[j]) {
+                if (j < (lmin+link->len)) {
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*slink elimination, (%d,%d) > (%d,%d):\n",
+                               solver_recurse_depth*4, "",
+                               link->gx+1, link->gy+1, link->lx+1, link->ly+1);
+                        printf("%*s  ruling out %d at (%d,%d)\n",
+                               solver_recurse_depth*4, "",
+                               j+1, link->gx+1, link->gy+1);
+                    }
+#endif
+                    cube(link->gx, link->gy, j+1) = FALSE;
+                    nchanged++;
+                }
+            }
+            /* For the 'lesser' end of the link, discount all numbers
+             * too large to satisfy inequality. */
+            if (lns[j]) {
+                if (j > (gmax-link->len)) {
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*slink elimination, (%d,%d) > (%d,%d):\n",
+                               solver_recurse_depth*4, "",
+                               link->gx+1, link->gy+1, link->lx+1, link->ly+1);
+                        printf("%*s  ruling out %d at (%d,%d)\n",
+                               solver_recurse_depth*4, "",
+                               j+1, link->lx+1, link->ly+1);
+                    }
+#endif
+                    cube(link->lx, link->ly, j+1) = FALSE;
+                    nchanged++;
+                }
+            }
+        }
+    }
+    return nchanged;
+}
+
+static int solver_adjacent(struct latin_solver *solver, void *vctx)
+{
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    int nchanged = 0, x, y, i, n, o = solver->o, nx, ny, gd;
+
+    /* Update possible values based on known values and adjacency clues. */
+
+    for (x = 0; x < o; x++) {
+        for (y = 0; y < o; y++) {
+            if (grid(x, y) == 0) continue;
+
+            /* We have a definite number here. Make sure that any
+             * adjacent possibles reflect the adjacent/non-adjacent clue. */
+
+            for (i = 0; i < 4; i++) {
+                int isadjacent = (GRID(ctx->state, flags, x, y) & adjthan[i].f);
+
+                nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
+                if (nx < 0 || ny < 0 || nx >= o || ny >= o)
+                    continue;
+
+                for (n = 0; n < o; n++) {
+                    /* Continue past numbers the adjacent square _could_ be,
+                     * given the clue we have. */
+                    gd = abs((n+1) - grid(x, y));
+                    if (isadjacent && (gd == 1)) continue;
+                    if (!isadjacent && (gd != 1)) continue;
+
+                    if (cube(nx, ny, n+1) == FALSE)
+                        continue; /* already discounted this possibility. */
+
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*sadjacent elimination, (%d,%d):%d %s (%d,%d):\n",
+                               solver_recurse_depth*4, "",
+                               x+1, y+1, grid(x, y), isadjacent ? "|" : "!|", nx+1, ny+1);
+                        printf("%*s  ruling out %d at (%d,%d)\n",
+                               solver_recurse_depth*4, "", n+1, nx+1, ny+1);
+                    }
+#endif
+                    cube(nx, ny, n+1) = FALSE;
+                    nchanged++;
+                }
+            }
+        }
+    }
+
+    return nchanged;
+}
+
+static int solver_adjacent_set(struct latin_solver *solver, void *vctx)
+{
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    int x, y, i, n, nn, o = solver->o, nx, ny, gd;
+    int nchanged = 0, *scratch = snewn(o, int);
+
+    /* Update possible values based on other possible values
+     * of adjacent squares, and adjacency clues. */
+
+    for (x = 0; x < o; x++) {
+        for (y = 0; y < o; y++) {
+            for (i = 0; i < 4; i++) {
+                int isadjacent = (GRID(ctx->state, flags, x, y) & adjthan[i].f);
+
+                nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
+                if (nx < 0 || ny < 0 || nx >= o || ny >= o)
+                    continue;
+
+                /* We know the current possibles for the square (x,y)
+                 * and also the adjacency clue from (x,y) to (nx,ny).
+                 * Construct a maximum set of possibles for (nx,ny)
+                 * in scratch, based on these constraints... */
+
+                memset(scratch, 0, o*sizeof(int));
+
+                for (n = 0; n < o; n++) {
+                    if (cube(x, y, n+1) == FALSE) continue;
+
+                    for (nn = 0; nn < o; nn++) {
+                        if (n == nn) continue;
+
+                        gd = abs(nn - n);
+                        if (isadjacent && (gd != 1)) continue;
+                        if (!isadjacent && (gd == 1)) continue;
+
+                        scratch[nn] = 1;
+                    }
+                }
+
+                /* ...and remove any possibilities for (nx,ny) that are
+                 * currently set but are not indicated in scratch. */
+                for (n = 0; n < o; n++) {
+                    if (scratch[n] == 1) continue;
+                    if (cube(nx, ny, n+1) == FALSE) continue;
+
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*sadjacent possible elimination, (%d,%d) %s (%d,%d):\n",
+                               solver_recurse_depth*4, "",
+                               x+1, y+1, isadjacent ? "|" : "!|", nx+1, ny+1);
+                        printf("%*s  ruling out %d at (%d,%d)\n",
+                               solver_recurse_depth*4, "", n+1, nx+1, ny+1);
+                    }
+#endif
+                    cube(nx, ny, n+1) = FALSE;
+                    nchanged++;
+                }
+            }
+        }
+    }
+
+    return nchanged;
+}
+
+static int solver_easy(struct latin_solver *solver, void *vctx)
+{
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    if (ctx->state->adjacent)
+        return solver_adjacent(solver, vctx);
+    else
+        return solver_links(solver, vctx);
+}
+
+static int solver_set(struct latin_solver *solver, void *vctx)
+{
+    struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+    if (ctx->state->adjacent)
+        return solver_adjacent_set(solver, vctx);
+    else
+        return 0;
+}
+
+#define SOLVER(upper,title,func,lower) func,
+static usersolver_t const unequal_solvers[] = { DIFFLIST(SOLVER) };
+
+static int solver_state(game_state *state, int maxdiff)
+{
+    struct solver_ctx *ctx = new_ctx(state);
+    struct latin_solver solver;
+    int diff;
+
+    latin_solver_alloc(&solver, state->nums, state->order);
+
+    diff = latin_solver_main(&solver, maxdiff,
+                             DIFF_LATIN, DIFF_SET, DIFF_EXTREME,
+                             DIFF_EXTREME, DIFF_RECURSIVE,
+                             unequal_solvers, ctx, clone_ctx, free_ctx);
+
+    memcpy(state->hints, solver.cube, state->order*state->order*state->order);
+
+    free_ctx(ctx);
+
+    latin_solver_free(&solver);
+
+    if (diff == DIFF_IMPOSSIBLE)
+        return -1;
+    if (diff == DIFF_UNFINISHED)
+        return 0;
+    if (diff == DIFF_AMBIGUOUS)
+        return 2;
+    return 1;
+}
+
+static game_state *solver_hint(const game_state *state, int *diff_r,
+                               int mindiff, int maxdiff)
+{
+    game_state *ret = dup_game(state);
+    int diff, r = 0;
+
+    for (diff = mindiff; diff <= maxdiff; diff++) {
+        r = solver_state(ret, diff);
+        debug(("solver_state after %s %d", unequal_diffnames[diff], r));
+        if (r != 0) goto done;
+    }
+
+done:
+    if (diff_r) *diff_r = (r > 0) ? diff : -1;
+    return ret;
+}
+
+/* ----------------------------------------------------------
+ * Game generation.
+ */
+
+static char *latin_desc(digit *sq, size_t order)
+{
+    int o2 = order*order, i;
+    char *soln = snewn(o2+2, char);
+
+    soln[0] = 'S';
+    for (i = 0; i < o2; i++)
+        soln[i+1] = n2c(sq[i], order);
+    soln[o2+1] = '\0';
+
+    return soln;
+}
+
+/* returns non-zero if it placed (or could have placed) clue. */
+static int gg_place_clue(game_state *state, int ccode, digit *latin, int checkonly)
+{
+    int loc = ccode / 5, which = ccode % 5;
+    int x = loc % state->order, y = loc / state->order;
+
+    assert(loc < state->order*state->order);
+
+    if (which == 4) {           /* add number */
+        if (state->nums[loc] != 0) {
+#ifdef STANDALONE_SOLVER
+            if (state->nums[loc] != latin[loc]) {
+                printf("inconsistency for (%d,%d): state %d latin %d\n",
+                       x+1, y+1, state->nums[loc], latin[loc]);
+            }
+#endif
+            assert(state->nums[loc] == latin[loc]);
+            return 0;
+        }
+        if (!checkonly) {
+            state->nums[loc] = latin[loc];
+        }
+    } else {                    /* add flag */
+        int lx, ly, lloc;
+
+        if (state->adjacent)
+            return 0; /* never add flag clues in adjacent mode (they're always
+                         all present) */
+
+        if (state->flags[loc] & adjthan[which].f)
+            return 0; /* already has flag. */
+
+        lx = x + adjthan[which].dx;
+        ly = y + adjthan[which].dy;
+        if (lx < 0 || ly < 0 || lx >= state->order || ly >= state->order)
+            return 0; /* flag compares to off grid */
+
+        lloc = loc + adjthan[which].dx + adjthan[which].dy*state->order;
+        if (latin[loc] <= latin[lloc])
+            return 0; /* flag would be incorrect */
+
+        if (!checkonly) {
+            state->flags[loc] |= adjthan[which].f;
+        }
+    }
+    return 1;
+}
+
+/* returns non-zero if it removed (or could have removed) the clue. */
+static int gg_remove_clue(game_state *state, int ccode, int checkonly)
+{
+    int loc = ccode / 5, which = ccode % 5;
+#ifdef STANDALONE_SOLVER
+    int x = loc % state->order, y = loc / state->order;
+#endif
+
+    assert(loc < state->order*state->order);
+
+    if (which == 4) {           /* remove number. */
+        if (state->nums[loc] == 0) return 0;
+        if (!checkonly) {
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working)
+                printf("gg_remove_clue: removing %d at (%d,%d)",
+                       state->nums[loc], x+1, y+1);
+#endif
+            state->nums[loc] = 0;
+        }
+    } else {                    /* remove flag */
+        if (state->adjacent)
+            return 0; /* never remove clues in adjacent mode. */
+
+        if (!(state->flags[loc] & adjthan[which].f)) return 0;
+        if (!checkonly) {
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working)
+               printf("gg_remove_clue: removing %c at (%d,%d)",
+                       adjthan[which].c, x+1, y+1);
+#endif
+            state->flags[loc] &= ~adjthan[which].f;
+        }
+    }
+    return 1;
+}
+
+static int gg_best_clue(game_state *state, int *scratch, digit *latin)
+{
+    int ls = state->order * state->order * 5;
+    int maxposs = 0, minclues = 5, best = -1, i, j;
+    int nposs, nclues, loc;
+
+#ifdef STANDALONE_SOLVER
+    if (solver_show_working) {
+        game_debug(state);
+        latin_solver_debug(state->hints, state->order);
+    }
+#endif
+
+    for (i = ls; i-- > 0 ;) {
+        if (!gg_place_clue(state, scratch[i], latin, 1)) continue;
+
+        loc = scratch[i] / 5;
+        for (j = nposs = 0; j < state->order; j++) {
+            if (state->hints[loc*state->order + j]) nposs++;
+        }
+        for (j = nclues = 0; j < 4; j++) {
+            if (state->flags[loc] & adjthan[j].f) nclues++;
+        }
+        if ((nposs > maxposs) ||
+            (nposs == maxposs && nclues < minclues)) {
+            best = i; maxposs = nposs; minclues = nclues;
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working) {
+                int x = loc % state->order, y = loc / state->order;
+                printf("gg_best_clue: b%d (%d,%d) new best [%d poss, %d clues].\n",
+                       best, x+1, y+1, nposs, nclues);
+            }
+#endif
+        }
+    }
+    /* if we didn't solve, we must have 1 clue to place! */
+    assert(best != -1);
+    return best;
+}
+
+#ifdef STANDALONE_SOLVER
+int maxtries;
+#define MAXTRIES maxtries
+#else
+#define MAXTRIES 50
+#endif
+int gg_solved;
+
+static int game_assemble(game_state *new, int *scratch, digit *latin,
+                         int difficulty)
+{
+    game_state *copy = dup_game(new);
+    int best;
+
+    if (difficulty >= DIFF_RECURSIVE) {
+        /* We mustn't use any solver that might guess answers;
+         * if it guesses wrongly but solves, gg_place_clue will
+         * get mighty confused. We will always trim clues down
+         * (making it more difficult) in game_strip, which doesn't
+         * have this problem. */
+        difficulty = DIFF_RECURSIVE-1;
+    }
+
+#ifdef STANDALONE_SOLVER
+    if (solver_show_working) {
+        game_debug(new);
+        latin_solver_debug(new->hints, new->order);
+    }
+#endif
+
+    while(1) {
+        gg_solved++;
+        if (solver_state(copy, difficulty) == 1) break;
+
+        best = gg_best_clue(copy, scratch, latin);
+        gg_place_clue(new, scratch[best], latin, 0);
+        gg_place_clue(copy, scratch[best], latin, 0);
+    }
+    free_game(copy);
+#ifdef STANDALONE_SOLVER
+    if (solver_show_working) {
+        char *dbg = game_text_format(new);
+        printf("game_assemble: done, %d solver iterations:\n%s\n", gg_solved, dbg);
+        sfree(dbg);
+    }
+#endif
+    return 0;
+}
+
+static void game_strip(game_state *new, int *scratch, digit *latin,
+                       int difficulty)
+{
+    int o = new->order, o2 = o*o, lscratch = o2*5, i;
+    game_state *copy = blank_game(new->order, new->adjacent);
+
+    /* For each symbol (if it exists in new), try and remove it and
+     * solve again; if we couldn't solve without it put it back. */
+    for (i = 0; i < lscratch; i++) {
+        if (!gg_remove_clue(new, scratch[i], 0)) continue;
+
+        memcpy(copy->nums,  new->nums,  o2 * sizeof(digit));
+        memcpy(copy->flags, new->flags, o2 * sizeof(unsigned int));
+        gg_solved++;
+        if (solver_state(copy, difficulty) != 1) {
+            /* put clue back, we can't solve without it. */
+            int ret = gg_place_clue(new, scratch[i], latin, 0);
+            assert(ret == 1);
+        } else {
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working)
+                printf("game_strip: clue was redundant.");
+#endif
+        }
+    }
+    free_game(copy);
+#ifdef STANDALONE_SOLVER
+    if (solver_show_working) {
+        char *dbg = game_text_format(new);
+        debug(("game_strip: done, %d solver iterations.", gg_solved));
+        debug(("%s", dbg));
+        sfree(dbg);
+    }
+#endif
+}
+
+static void add_adjacent_flags(game_state *state, digit *latin)
+{
+    int x, y, o = state->order;
+
+    /* All clues in adjacent mode are always present (the only variables are
+     * the numbers). This adds all the flags to state based on the supplied
+     * latin square. */
+
+    for (y = 0; y < o; y++) {
+        for (x = 0; x < o; x++) {
+            if (x < (o-1) && (abs(latin[y*o+x] - latin[y*o+x+1]) == 1)) {
+                GRID(state, flags, x, y) |= F_ADJ_RIGHT;
+                GRID(state, flags, x+1, y) |= F_ADJ_LEFT;
+            }
+            if (y < (o-1) && (abs(latin[y*o+x] - latin[(y+1)*o+x]) == 1)) {
+                GRID(state, flags, x, y) |= F_ADJ_DOWN;
+                GRID(state, flags, x, y+1) |= F_ADJ_UP;
+            }
+        }
+    }
+}
+
+static char *new_game_desc(const game_params *params_in, random_state *rs,
+                           char **aux, int interactive)
+{
+    game_params params_copy = *params_in; /* structure copy */
+    game_params *params = &params_copy;
+    digit *sq = NULL;
+    int i, x, y, retlen, k, nsol;
+    int o2 = params->order * params->order, ntries = 1;
+    int *scratch, lscratch = o2*5;
+    char *ret, buf[80];
+    game_state *state = blank_game(params->order, params->adjacent);
+
+    /* Generate a list of 'things to strip' (randomised later) */
+    scratch = snewn(lscratch, int);
+    /* Put the numbers (4 mod 5) before the inequalities (0-3 mod 5) */
+    for (i = 0; i < lscratch; i++) scratch[i] = (i%o2)*5 + 4 - (i/o2);
+
+generate:
+#ifdef STANDALONE_SOLVER
+    if (solver_show_working)
+        printf("new_game_desc: generating %s puzzle, ntries so far %d\n",
+               unequal_diffnames[params->diff], ntries);
+#endif
+    if (sq) sfree(sq);
+    sq = latin_generate(params->order, rs);
+    latin_debug(sq, params->order);
+    /* Separately shuffle the numeric and inequality clues */
+    shuffle(scratch, lscratch/5, sizeof(int), rs);
+    shuffle(scratch+lscratch/5, 4*lscratch/5, sizeof(int), rs);
+
+    memset(state->nums, 0, o2 * sizeof(digit));
+    memset(state->flags, 0, o2 * sizeof(unsigned int));
+
+    if (state->adjacent) {
+        /* All adjacency flags are always present. */
+        add_adjacent_flags(state, sq);
+    }
+
+    gg_solved = 0;
+    if (game_assemble(state, scratch, sq, params->diff) < 0)
+        goto generate;
+    game_strip(state, scratch, sq, params->diff);
+
+    if (params->diff > 0) {
+        game_state *copy = dup_game(state);
+        nsol = solver_state(copy, params->diff-1);
+        free_game(copy);
+        if (nsol > 0) {
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working)
+                printf("game_assemble: puzzle as generated is too easy.\n");
+#endif
+            if (ntries < MAXTRIES) {
+                ntries++;
+                goto generate;
+            }
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working)
+                printf("Unable to generate %s %dx%d after %d attempts.\n",
+                       unequal_diffnames[params->diff],
+                       params->order, params->order, MAXTRIES);
+#endif
+            params->diff--;
+        }
+    }
+#ifdef STANDALONE_SOLVER
+    if (solver_show_working)
+        printf("new_game_desc: generated %s puzzle; %d attempts (%d solver).\n",
+               unequal_diffnames[params->diff], ntries, gg_solved);
+#endif
+
+    ret = NULL; retlen = 0;
+    for (y = 0; y < params->order; y++) {
+        for (x = 0; x < params->order; x++) {
+            unsigned int f = GRID(state, flags, x, y);
+            k = sprintf(buf, "%d%s%s%s%s,",
+                        GRID(state, nums, x, y),
+                        (f & F_ADJ_UP)    ? "U" : "",
+                        (f & F_ADJ_RIGHT) ? "R" : "",
+                        (f & F_ADJ_DOWN)  ? "D" : "",
+                        (f & F_ADJ_LEFT)  ? "L" : "");
+
+            ret = sresize(ret, retlen + k + 1, char);
+            strcpy(ret + retlen, buf);
+            retlen += k;
+        }
+    }
+    *aux = latin_desc(sq, params->order);
+
+    free_game(state);
+    sfree(sq);
+    sfree(scratch);
+
+    return ret;
+}
+
+static game_state *load_game(const game_params *params, const char *desc,
+                             char **why_r)
+{
+    game_state *state = blank_game(params->order, params->adjacent);
+    const char *p = desc;
+    int i = 0, n, o = params->order, x, y;
+    char *why = NULL;
+
+    while (*p) {
+        while (*p >= 'a' && *p <= 'z') {
+            i += *p - 'a' + 1;
+            p++;
+        }
+        if (i >= o*o) {
+            why = "Too much data to fill grid"; goto fail;
+        }
+
+        if (*p < '0' && *p > '9') {
+            why = "Expecting number in game description"; goto fail;
+        }
+        n = atoi(p);
+        if (n < 0 || n > o) {
+            why = "Out-of-range number in game description"; goto fail;
+        }
+        state->nums[i] = (digit)n;
+        while (*p >= '0' && *p <= '9') p++; /* skip number */
+
+        if (state->nums[i] != 0)
+            state->flags[i] |= F_IMMUTABLE; /* === number set by game description */
+
+        while (*p == 'U' || *p == 'R' || *p == 'D' || *p == 'L') {
+            switch (*p) {
+            case 'U': state->flags[i] |= F_ADJ_UP;    break;
+            case 'R': state->flags[i] |= F_ADJ_RIGHT; break;
+            case 'D': state->flags[i] |= F_ADJ_DOWN;  break;
+            case 'L': state->flags[i] |= F_ADJ_LEFT;  break;
+            default: why = "Expecting flag URDL in game description"; goto fail;
+            }
+            p++;
+        }
+        i++;
+        if (i < o*o && *p != ',') {
+            why = "Missing separator"; goto fail;
+        }
+        if (*p == ',') p++;
+    }
+    if (i < o*o) {
+        why = "Not enough data to fill grid"; goto fail;
+    }
+    i = 0;
+    for (y = 0; y < o; y++) {
+        for (x = 0; x < o; x++) {
+            for (n = 0; n < 4; n++) {
+                if (GRID(state, flags, x, y) & adjthan[n].f) {
+                    int nx = x + adjthan[n].dx;
+                    int ny = y + adjthan[n].dy;
+                    /* a flag must not point us off the grid. */
+                    if (nx < 0 || ny < 0 || nx >= o || ny >= o) {
+                        why = "Flags go off grid"; goto fail;
+                    }
+                    if (params->adjacent) {
+                        /* if one cell is adjacent to another, the other must
+                         * also be adjacent to the first. */
+                        if (!(GRID(state, flags, nx, ny) & adjthan[n].fo)) {
+                            why = "Flags contradicting each other"; goto fail;
+                        }
+                    } else {
+                        /* if one cell is GT another, the other must _not_ also
+                         * be GT the first. */
+                        if (GRID(state, flags, nx, ny) & adjthan[n].fo) {
+                            why = "Flags contradicting each other"; goto fail;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return state;
+
+fail:
+    free_game(state);
+    if (why_r) *why_r = why;
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = load_game(params, desc, NULL);
+    if (!state) {
+        assert("Unable to load ?validated game.");
+        return NULL;
+    }
+    return state;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    char *why = NULL;
+    game_state *dummy = load_game(params, desc, &why);
+    if (dummy) {
+        free_game(dummy);
+        assert(!why);
+    } else
+        assert(why);
+    return why;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    game_state *solved;
+    int r;
+    char *ret = NULL;
+
+    if (aux) return dupstr(aux);
+
+    solved = dup_game(state);
+    for (r = 0; r < state->order*state->order; r++) {
+        if (!(solved->flags[r] & F_IMMUTABLE))
+            solved->nums[r] = 0;
+    }
+    r = solver_state(solved, DIFFCOUNT-1);   /* always use full solver */
+    if (r > 0) ret = latin_desc(solved->nums, solved->order);
+    free_game(solved);
+    return ret;
+}
+
+/* ----------------------------------------------------------
+ * Game UI input processing.
+ */
+
+struct game_ui {
+    int hx, hy;                         /* as for solo.c, highlight pos */
+    int hshow, hpencil, hcursor;        /* show state, type, and ?cursor. */
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->hx = ui->hy = 0;
+    ui->hpencil = ui->hshow = ui->hcursor = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    /* See solo.c; if we were pencil-mode highlighting and
+     * somehow a square has just been properly filled, cancel
+     * pencil mode. */
+    if (ui->hshow && ui->hpencil && !ui->hcursor &&
+        GRID(newstate, nums, ui->hx, ui->hy) != 0) {
+        ui->hshow = 0;
+    }
+}
+
+struct game_drawstate {
+    int tilesize, order, started, adjacent;
+    digit *nums;                /* copy of nums, o^2 */
+    unsigned char *hints;       /* copy of hints, o^3 */
+    unsigned int *flags;        /* o^2 */
+
+    int hx, hy, hshow, hpencil; /* as for game_ui. */
+    int hflash;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int ox, int oy, int button)
+{
+    int x = FROMCOORD(ox), y = FROMCOORD(oy), n;
+    char buf[80];
+    int shift_or_control = button & (MOD_SHFT | MOD_CTRL);
+
+    button &= ~MOD_MASK;
+
+    if (x >= 0 && x < ds->order && y >= 0 && y < ds->order && IS_MOUSE_DOWN(button)) {
+        if (oy - COORD(y) > TILE_SIZE && ox - COORD(x) > TILE_SIZE)
+            return NULL;
+
+        if (oy - COORD(y) > TILE_SIZE) {
+            if (GRID(state, flags, x, y) & F_ADJ_DOWN)
+                sprintf(buf, "F%d,%d,%d", x, y, F_SPENT_DOWN);
+            else if (y + 1 < ds->order && GRID(state, flags, x, y + 1) & F_ADJ_UP)
+                sprintf(buf, "F%d,%d,%d", x, y + 1, F_SPENT_UP);
+            else return NULL;
+            return dupstr(buf);
+        }
+
+        if (ox - COORD(x) > TILE_SIZE) {
+            if (GRID(state, flags, x, y) & F_ADJ_RIGHT)
+                sprintf(buf, "F%d,%d,%d", x, y, F_SPENT_RIGHT);
+            else if (x + 1 < ds->order && GRID(state, flags, x + 1, y) & F_ADJ_LEFT)
+                sprintf(buf, "F%d,%d,%d", x + 1, y, F_SPENT_LEFT);
+            else return NULL;
+            return dupstr(buf);
+        }
+
+        if (button == LEFT_BUTTON) {
+            /* normal highlighting for non-immutable squares */
+            if (GRID(state, flags, x, y) & F_IMMUTABLE)
+                ui->hshow = 0;
+            else if (x == ui->hx && y == ui->hy &&
+                     ui->hshow && ui->hpencil == 0)
+                ui->hshow = 0;
+            else {
+                ui->hx = x; ui->hy = y; ui->hpencil = 0;
+                ui->hshow = 1;
+            }
+            ui->hcursor = 0;
+            return "";
+        }
+        if (button == RIGHT_BUTTON) {
+            /* pencil highlighting for non-filled squares */
+            if (GRID(state, nums, x, y) != 0)
+                ui->hshow = 0;
+            else if (x == ui->hx && y == ui->hy &&
+                     ui->hshow && ui->hpencil)
+                ui->hshow = 0;
+            else {
+                ui->hx = x; ui->hy = y; ui->hpencil = 1;
+                ui->hshow = 1;
+            }
+            ui->hcursor = 0;
+            return "";
+        }
+    }
+
+    if (IS_CURSOR_MOVE(button)) {
+        if (shift_or_control) {
+            int nx = ui->hx, ny = ui->hy, i, self;
+            move_cursor(button, &nx, &ny, ds->order, ds->order, FALSE);
+            ui->hshow = ui->hcursor = 1;
+
+            for (i = 0; i < 4 && (nx != ui->hx + adjthan[i].dx ||
+                                  ny != ui->hy + adjthan[i].dy); ++i);
+
+            if (i == 4)
+                return ""; /* invalid direction, i.e. out of the board */
+
+            if (!(GRID(state, flags, ui->hx, ui->hy) & adjthan[i].f ||
+                  GRID(state, flags, nx,     ny    ) & adjthan[i].fo))
+                return ""; /* no clue to toggle */
+
+            if (state->adjacent)
+                self = (adjthan[i].dx >= 0 && adjthan[i].dy >= 0);
+            else
+                self = (GRID(state, flags, ui->hx, ui->hy) & adjthan[i].f);
+
+            if (self)
+                sprintf(buf, "F%d,%d,%d", ui->hx, ui->hy,
+                        ADJ_TO_SPENT(adjthan[i].f));
+            else
+                sprintf(buf, "F%d,%d,%d", nx, ny,
+                        ADJ_TO_SPENT(adjthan[i].fo));
+
+            return dupstr(buf);
+        } else {
+            move_cursor(button, &ui->hx, &ui->hy, ds->order, ds->order, FALSE);
+            ui->hshow = ui->hcursor = 1;
+            return "";
+        }
+    }
+    if (ui->hshow && IS_CURSOR_SELECT(button)) {
+        ui->hpencil = 1 - ui->hpencil;
+        ui->hcursor = 1;
+        return "";
+    }
+
+    n = c2n(button, state->order);
+    if (ui->hshow && n >= 0 && n <= ds->order) {
+        debug(("button %d, cbutton %d", button, (int)((char)button)));
+
+        debug(("n %d, h (%d,%d) p %d flags 0x%x nums %d",
+               n, ui->hx, ui->hy, ui->hpencil,
+               GRID(state, flags, ui->hx, ui->hy),
+               GRID(state, nums, ui->hx, ui->hy)));
+
+        if (GRID(state, flags, ui->hx, ui->hy) & F_IMMUTABLE)
+            return NULL;        /* can't edit immutable square (!) */
+        if (ui->hpencil && GRID(state, nums, ui->hx, ui->hy) > 0)
+            return NULL;        /* can't change hints on filled square (!) */
+
+
+        sprintf(buf, "%c%d,%d,%d",
+                (char)(ui->hpencil && n > 0 ? 'P' : 'R'), ui->hx, ui->hy, n);
+
+        if (!ui->hcursor) ui->hshow = 0;
+
+        return dupstr(buf);
+    }
+
+    if (button == 'H' || button == 'h')
+        return dupstr("H");
+    if (button == 'M' || button == 'm')
+        return dupstr("M");
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    game_state *ret = NULL;
+    int x, y, n, i, rc;
+
+    debug(("execute_move: %s", move));
+
+    if ((move[0] == 'P' || move[0] == 'R') &&
+        sscanf(move+1, "%d,%d,%d", &x, &y, &n) == 3 &&
+        x >= 0 && x < state->order && y >= 0 && y < state->order &&
+        n >= 0 && n <= state->order) {
+        ret = dup_game(state);
+        if (move[0] == 'P' && n > 0)
+            HINT(ret, x, y, n-1) = !HINT(ret, x, y, n-1);
+        else {
+            GRID(ret, nums, x, y) = n;
+            for (i = 0; i < state->order; i++)
+                HINT(ret, x, y, i) = 0;
+
+            /* real change to grid; check for completion */
+            if (!ret->completed && check_complete(ret->nums, ret, 1) > 0)
+                ret->completed = TRUE;
+        }
+        return ret;
+    } else if (move[0] == 'S') {
+        const char *p;
+
+        ret = dup_game(state);
+        ret->completed = ret->cheated = TRUE;
+
+        p = move+1;
+        for (i = 0; i < state->order*state->order; i++) {
+            n = c2n((int)*p, state->order);
+            if (!*p || n <= 0 || n > state->order)
+                goto badmove;
+            ret->nums[i] = n;
+            p++;
+        }
+        if (*p) goto badmove;
+        rc = check_complete(ret->nums, ret, 1);
+        assert(rc > 0);
+        return ret;
+    } else if (move[0] == 'M') {
+        ret = dup_game(state);
+        for (x = 0; x < state->order; x++) {
+            for (y = 0; y < state->order; y++) {
+                for (n = 0; n < state->order; n++) {
+                    HINT(ret, x, y, n) = 1;
+                }
+            }
+        }
+        return ret;
+    } else if (move[0] == 'H') {
+        return solver_hint(state, NULL, DIFF_EASY, DIFF_EASY);
+    } else if (move[0] == 'F' && sscanf(move+1, "%d,%d,%d", &x, &y, &n) == 3 &&
+               x >= 0 && x < state->order && y >= 0 && y < state->order) {
+        ret = dup_game(state);
+        GRID(ret, flags, x, y) ^= n;
+        return ret;
+    }
+
+badmove:
+    if (ret) free_game(ret);
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing/printing routines.
+ */
+
+#define DRAW_SIZE (TILE_SIZE*ds->order + GAP_SIZE*(ds->order-1) + BORDER*2)
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize, order; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+    ads.order = params->order;
+
+    *x = *y = DRAW_SIZE;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_TEXT * 3 + i] = 0.0F;
+        ret[COL_GRID * 3 + i] = 0.5F;
+    }
+
+    /* Lots of these were taken from solo.c. */
+    ret[COL_GUESS * 3 + 0] = 0.0F;
+    ret[COL_GUESS * 3 + 1] = 0.6F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_GUESS * 3 + 2] = 0.0F;
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_PENCIL * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_PENCIL * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_PENCIL * 3 + 2] = ret[COL_BACKGROUND * 3 + 2];
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int o2 = state->order*state->order, o3 = o2*state->order;
+
+    ds->tilesize = 0;
+    ds->order = state->order;
+    ds->adjacent = state->adjacent;
+
+    ds->nums = snewn(o2, digit);
+    ds->hints = snewn(o3, unsigned char);
+    ds->flags = snewn(o2, unsigned int);
+    memset(ds->nums, 0, o2*sizeof(digit));
+    memset(ds->hints, 0, o3);
+    memset(ds->flags, 0, o2*sizeof(unsigned int));
+
+    ds->hx = ds->hy = 0;
+    ds->started = ds->hshow = ds->hpencil = ds->hflash = 0;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->nums);
+    sfree(ds->hints);
+    sfree(ds->flags);
+    sfree(ds);
+}
+
+static void draw_gt(drawing *dr, int ox, int oy,
+                    int dx1, int dy1, int dx2, int dy2, int col)
+{
+    int coords[12];
+    int xdx = (dx1+dx2 ? 0 : 1), xdy = (dx1+dx2 ? 1 : 0);
+    coords[0] = ox + xdx;
+    coords[1] = oy + xdy;
+    coords[2] = ox + xdx + dx1;
+    coords[3] = oy + xdy + dy1;
+    coords[4] = ox + xdx + dx1 + dx2;
+    coords[5] = oy + xdy + dy1 + dy2;
+    coords[6] = ox - xdx + dx1 + dx2;
+    coords[7] = oy - xdy + dy1 + dy2;
+    coords[8] = ox - xdx + dx1;
+    coords[9] = oy - xdy + dy1;
+    coords[10] = ox - xdx;
+    coords[11] = oy - xdy;
+    draw_polygon(dr, coords, 6, col, col);
+}
+
+#define COLOUR(direction) (f & (F_ERROR_##direction) ? COL_ERROR : \
+                           f & (F_SPENT_##direction) ? COL_SPENT : fg)
+
+static void draw_gts(drawing *dr, game_drawstate *ds, int ox, int oy,
+                     unsigned int f, int bg, int fg)
+{
+    int g = GAP_SIZE, g2 = (g+1)/2, g4 = (g+1)/4;
+
+    /* Draw all the greater-than signs emanating from this tile. */
+
+    if (f & F_ADJ_UP) {
+        if (bg >= 0) draw_rect(dr, ox, oy - g, TILE_SIZE, g, bg);
+        draw_gt(dr, ox+g2, oy-g4, g2, -g2, g2, g2, COLOUR(UP));
+        draw_update(dr, ox, oy-g, TILE_SIZE, g);
+    }
+    if (f & F_ADJ_RIGHT) {
+        if (bg >= 0) draw_rect(dr, ox + TILE_SIZE, oy, g, TILE_SIZE, bg);
+        draw_gt(dr, ox+TILE_SIZE+g4, oy+g2, g2, g2, -g2, g2, COLOUR(RIGHT));
+        draw_update(dr, ox+TILE_SIZE, oy, g, TILE_SIZE);
+    }
+    if (f & F_ADJ_DOWN) {
+        if (bg >= 0) draw_rect(dr, ox, oy + TILE_SIZE, TILE_SIZE, g, bg);
+        draw_gt(dr, ox+g2, oy+TILE_SIZE+g4, g2, g2, g2, -g2, COLOUR(DOWN));
+        draw_update(dr, ox, oy+TILE_SIZE, TILE_SIZE, g);
+    }
+    if (f & F_ADJ_LEFT) {
+        if (bg >= 0) draw_rect(dr, ox - g, oy, g, TILE_SIZE, bg);
+        draw_gt(dr, ox-g4, oy+g2, -g2, g2, g2, g2, COLOUR(LEFT));
+        draw_update(dr, ox-g, oy, g, TILE_SIZE);
+    }
+}
+
+static void draw_adjs(drawing *dr, game_drawstate *ds, int ox, int oy,
+                      unsigned int f, int bg, int fg)
+{
+    int g = GAP_SIZE, g38 = 3*(g+1)/8, g4 = (g+1)/4;
+
+    /* Draw all the adjacency bars relevant to this tile; we only have
+     * to worry about F_ADJ_RIGHT and F_ADJ_DOWN.
+     *
+     * If we _only_ have the error flag set (i.e. it's not supposed to be
+     * adjacent, but adjacent numbers were entered) draw an outline red bar.
+     */
+
+    if (f & (F_ADJ_RIGHT|F_ERROR_RIGHT)) {
+        if (f & F_ADJ_RIGHT) {
+            draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, COLOUR(RIGHT));
+        } else {
+            draw_rect_outline(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, COL_ERROR);
+        }
+    } else if (bg >= 0) {
+        draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, bg);
+    }
+    draw_update(dr, ox+TILE_SIZE, oy, g, TILE_SIZE);
+
+    if (f & (F_ADJ_DOWN|F_ERROR_DOWN)) {
+        if (f & F_ADJ_DOWN) {
+            draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, COLOUR(DOWN));
+        } else {
+            draw_rect_outline(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, COL_ERROR);
+        }
+    } else if (bg >= 0) {
+        draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, bg);
+    }
+    draw_update(dr, ox, oy+TILE_SIZE, TILE_SIZE, g);
+}
+
+static void draw_furniture(drawing *dr, game_drawstate *ds,
+                           const game_state *state, const game_ui *ui,
+                           int x, int y, int hflash)
+{
+    int ox = COORD(x), oy = COORD(y), bg, hon;
+    unsigned int f = GRID(state, flags, x, y);
+
+    bg = hflash ? COL_HIGHLIGHT : COL_BACKGROUND;
+
+    hon = (ui->hshow && x == ui->hx && y == ui->hy);
+
+    /* Clear square. */
+    draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE,
+              (hon && !ui->hpencil) ? COL_HIGHLIGHT : bg);
+
+    /* Draw the highlight (pencil or full), if we're the highlight */
+    if (hon && ui->hpencil) {
+        int coords[6];
+        coords[0] = ox;
+        coords[1] = oy;
+        coords[2] = ox + TILE_SIZE/2;
+        coords[3] = oy;
+        coords[4] = ox;
+        coords[5] = oy + TILE_SIZE/2;
+        draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+    }
+
+    /* Draw the square outline (which is the cursor, if we're the cursor). */
+    draw_rect_outline(dr, ox, oy, TILE_SIZE, TILE_SIZE, COL_GRID);
+
+    draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
+
+    /* Draw the adjacent clue signs. */
+    if (ds->adjacent)
+        draw_adjs(dr, ds, ox, oy, f, COL_BACKGROUND, COL_GRID);
+    else
+        draw_gts(dr, ds, ox, oy, f, COL_BACKGROUND, COL_TEXT);
+}
+
+static void draw_num(drawing *dr, game_drawstate *ds, int x, int y)
+{
+    int ox = COORD(x), oy = COORD(y);
+    unsigned int f = GRID(ds,flags,x,y);
+    char str[2];
+
+    /* (can assume square has just been cleared) */
+
+    /* Draw number, choosing appropriate colour */
+    str[0] = n2c(GRID(ds, nums, x, y), ds->order);
+    str[1] = '\0';
+    draw_text(dr, ox + TILE_SIZE/2, oy + TILE_SIZE/2,
+              FONT_VARIABLE, 3*TILE_SIZE/4, ALIGN_VCENTRE | ALIGN_HCENTRE,
+              (f & F_IMMUTABLE) ? COL_TEXT : (f & F_ERROR) ? COL_ERROR : COL_GUESS, str);
+}
+
+static void draw_hints(drawing *dr, game_drawstate *ds, int x, int y)
+{
+    int ox = COORD(x), oy = COORD(y);
+    int nhints, i, j, hw, hh, hmax, fontsz;
+    char str[2];
+
+    /* (can assume square has just been cleared) */
+
+    /* Draw hints; steal ingenious algorithm (basically)
+     * from solo.c:draw_number() */
+    for (i = nhints = 0; i < ds->order; i++) {
+        if (HINT(ds, x, y, i)) nhints++;
+    }
+
+    for (hw = 1; hw * hw < nhints; hw++);
+    if (hw < 3) hw = 3;
+    hh = (nhints + hw - 1) / hw;
+    if (hh < 2) hh = 2;
+    hmax = max(hw, hh);
+    fontsz = TILE_SIZE/(hmax*(11-hmax)/8);
+
+    for (i = j = 0; i < ds->order; i++) {
+        if (HINT(ds,x,y,i)) {
+            int hx = j % hw, hy = j / hw;
+
+            str[0] = n2c(i+1, ds->order);
+            str[1] = '\0';
+            draw_text(dr,
+                      ox + (4*hx+3) * TILE_SIZE / (4*hw+2),
+                      oy + (4*hy+3) * TILE_SIZE / (4*hh+2),
+                      FONT_VARIABLE, fontsz,
+                      ALIGN_VCENTRE | ALIGN_HCENTRE, COL_PENCIL, str);
+            j++;
+        }
+    }
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int x, y, i, hchanged = 0, stale, hflash = 0;
+
+    debug(("highlight old (%d,%d), new (%d,%d)", ds->hx, ds->hy, ui->hx, ui->hy));
+
+    if (flashtime > 0 &&
+        (flashtime <= FLASH_TIME/3 || flashtime >= FLASH_TIME*2/3))
+         hflash = 1;
+
+    if (!ds->started) {
+        draw_rect(dr, 0, 0, DRAW_SIZE, DRAW_SIZE, COL_BACKGROUND);
+        draw_update(dr, 0, 0, DRAW_SIZE, DRAW_SIZE);
+    }
+    if (ds->hx != ui->hx || ds->hy != ui->hy ||
+        ds->hshow != ui->hshow || ds->hpencil != ui->hpencil)
+        hchanged = 1;
+
+    for (x = 0; x < ds->order; x++) {
+        for (y = 0; y < ds->order; y++) {
+            if (!ds->started)
+                stale = 1;
+            else if (hflash != ds->hflash)
+                stale = 1;
+            else
+                stale = 0;
+
+            if (hchanged) {
+                if ((x == ui->hx && y == ui->hy) ||
+                    (x == ds->hx && y == ds->hy))
+                    stale = 1;
+            }
+
+            if (GRID(state, nums, x, y) != GRID(ds, nums, x, y)) {
+                GRID(ds, nums, x, y) = GRID(state, nums, x, y);
+                stale = 1;
+            }
+            if (GRID(state, flags, x, y) != GRID(ds, flags, x, y)) {
+                GRID(ds, flags, x, y) = GRID(state, flags, x, y);
+                stale = 1;
+            }
+            if (GRID(ds, nums, x, y) == 0) {
+                /* We're not a number square (therefore we might
+                 * display hints); do we need to update? */
+                for (i = 0; i < ds->order; i++) {
+                    if (HINT(state, x, y, i) != HINT(ds, x, y, i)) {
+                        HINT(ds, x, y, i) = HINT(state, x, y, i);
+                        stale = 1;
+                    }
+                }
+            }
+            if (stale) {
+                draw_furniture(dr, ds, state, ui, x, y, hflash);
+                if (GRID(ds, nums, x, y) > 0)
+                    draw_num(dr, ds, x, y);
+                else
+                    draw_hints(dr, ds, x, y);
+            }
+        }
+    }
+    ds->hx = ui->hx; ds->hy = ui->hy;
+    ds->hshow = ui->hshow;
+    ds->hpencil = ui->hpencil;
+
+    ds->started = 1;
+    ds->hflash = hflash;
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /* 10mm squares by default, roughly the same as Grauniad. */
+    game_compute_size(params, 1000, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int ink = print_mono_colour(dr, 0);
+    int x, y, o = state->order, ox, oy, n;
+    char str[2];
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    print_line_width(dr, 2 * TILE_SIZE / 40);
+
+    /* Squares, numbers, gt signs */
+    for (y = 0; y < o; y++) {
+        for (x = 0; x < o; x++) {
+            ox = COORD(x); oy = COORD(y);
+            n = GRID(state, nums, x, y);
+
+            draw_rect_outline(dr, ox, oy, TILE_SIZE, TILE_SIZE, ink);
+
+            str[0] = n ? n2c(n, state->order) : ' ';
+            str[1] = '\0';
+            draw_text(dr, ox + TILE_SIZE/2, oy + TILE_SIZE/2,
+                      FONT_VARIABLE, TILE_SIZE/2, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                      ink, str);
+
+            if (state->adjacent)
+                draw_adjs(dr, ds, ox, oy, GRID(state, flags, x, y), -1, ink);
+            else
+                draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), -1, ink);
+        }
+    }
+}
+
+/* ----------------------------------------------------------------------
+ * Housekeeping.
+ */
+
+#ifdef COMBINED
+#define thegame unequal
+#endif
+
+const struct game thegame = {
+    "Unequal", "games.unequal", "unequal",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON | REQUIRE_NUMPAD,  /* flags */
+};
+
+/* ----------------------------------------------------------------------
+ * Standalone solver.
+ */
+
+#ifdef STANDALONE_SOLVER
+
+#include <time.h>
+#include <stdarg.h>
+
+const char *quis = NULL;
+
+#if 0 /* currently unused */
+
+static void debug_printf(char *fmt, ...)
+{
+    char buf[4096];
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsprintf(buf, fmt, ap);
+    puts(buf);
+    va_end(ap);
+}
+
+static void game_printf(game_state *state)
+{
+    char *dbg = game_text_format(state);
+    printf("%s", dbg);
+    sfree(dbg);
+}
+
+static void game_printf_wide(game_state *state)
+{
+    int x, y, i, n;
+
+    for (y = 0; y < state->order; y++) {
+        for (x = 0; x < state->order; x++) {
+            n = GRID(state, nums, x, y);
+            for (i = 0; i < state->order; i++) {
+                if (n > 0)
+                    printf("%c", n2c(n, state->order));
+                else if (HINT(state, x, y, i))
+                    printf("%c", n2c(i+1, state->order));
+                else
+                    printf(".");
+            }
+            printf(" ");
+        }
+        printf("\n");
+    }
+    printf("\n");
+}
+
+#endif
+
+static void pdiff(int diff)
+{
+    if (diff == DIFF_IMPOSSIBLE)
+        printf("Game is impossible.\n");
+    else if (diff == DIFF_UNFINISHED)
+        printf("Game has incomplete.\n");
+    else if (diff == DIFF_AMBIGUOUS)
+        printf("Game has multiple solutions.\n");
+    else
+        printf("Game has difficulty %s.\n", unequal_diffnames[diff]);
+}
+
+static int solve(game_params *p, char *desc, int debug)
+{
+    game_state *state = new_game(NULL, p, desc);
+    struct solver_ctx *ctx = new_ctx(state);
+    struct latin_solver solver;
+    int diff;
+
+    solver_show_working = debug;
+    game_debug(state);
+
+    latin_solver_alloc(&solver, state->nums, state->order);
+
+    diff = latin_solver_main(&solver, DIFF_RECURSIVE,
+                             DIFF_LATIN, DIFF_SET, DIFF_EXTREME,
+                             DIFF_EXTREME, DIFF_RECURSIVE,
+                             unequal_solvers, ctx, clone_ctx, free_ctx);
+
+    free_ctx(ctx);
+
+    latin_solver_free(&solver);
+
+    if (debug) pdiff(diff);
+
+    game_debug(state);
+    free_game(state);
+    return diff;
+}
+
+static void check(game_params *p)
+{
+    char *msg = validate_params(p, 1);
+    if (msg) {
+        fprintf(stderr, "%s: %s", quis, msg);
+        exit(1);
+    }
+}
+
+static int gen(game_params *p, random_state *rs, int debug)
+{
+    char *desc, *aux;
+    int diff;
+
+    check(p);
+
+    solver_show_working = debug;
+    desc = new_game_desc(p, rs, &aux, 0);
+    diff = solve(p, desc, debug);
+    sfree(aux);
+    sfree(desc);
+
+    return diff;
+}
+
+static void soak(game_params *p, random_state *rs)
+{
+    time_t tt_start, tt_now, tt_last;
+    char *aux, *desc;
+    game_state *st;
+    int n = 0, neasy = 0, realdiff = p->diff;
+
+    check(p);
+
+    solver_show_working = 0;
+    maxtries = 1;
+
+    tt_start = tt_now = time(NULL);
+
+    printf("Soak-generating an %s %dx%d grid, difficulty %s.\n",
+           p->adjacent ? "adjacent" : "unequal",
+           p->order, p->order, unequal_diffnames[p->diff]);
+
+    while (1) {
+        p->diff = realdiff;
+        desc = new_game_desc(p, rs, &aux, 0);
+        st = new_game(NULL, p, desc);
+        solver_state(st, DIFF_RECURSIVE);
+        free_game(st);
+        sfree(aux);
+        sfree(desc);
+
+        n++;
+        if (realdiff != p->diff) neasy++;
+
+        tt_last = time(NULL);
+        if (tt_last > tt_now) {
+            tt_now = tt_last;
+            printf("%d total, %3.1f/s; %d/%2.1f%% easy, %3.1f/s good.\n",
+                   n, (double)n / ((double)tt_now - tt_start),
+                   neasy, (double)neasy*100.0/(double)n,
+                   (double)(n - neasy) / ((double)tt_now - tt_start));
+        }
+    }
+}
+
+static void usage_exit(const char *msg)
+{
+    if (msg)
+        fprintf(stderr, "%s: %s\n", quis, msg);
+    fprintf(stderr, "Usage: %s [--seed SEED] --soak <params> | [game_id [game_id ...]]\n", quis);
+    exit(1);
+}
+
+int main(int argc, const char *argv[])
+{
+    random_state *rs;
+    time_t seed = time(NULL);
+    int do_soak = 0, diff;
+
+    game_params *p;
+
+    maxtries = 50;
+
+    quis = argv[0];
+    while (--argc > 0) {
+        const char *p = *++argv;
+        if (!strcmp(p, "--soak"))
+            do_soak = 1;
+        else if (!strcmp(p, "--seed")) {
+            if (argc == 0)
+                usage_exit("--seed needs an argument");
+            seed = (time_t)atoi(*++argv);
+            argc--;
+        } else if (*p == '-')
+            usage_exit("unrecognised option");
+        else
+            break;
+    }
+    rs = random_new((void*)&seed, sizeof(time_t));
+
+    if (do_soak == 1) {
+        if (argc != 1) usage_exit("only one argument for --soak");
+        p = default_params();
+        decode_params(p, *argv);
+        soak(p, rs);
+    } else if (argc > 0) {
+        int i;
+        for (i = 0; i < argc; i++) {
+            const char *id = *argv++;
+            char *desc = strchr(id, ':'), *err;
+            p = default_params();
+            if (desc) {
+                *desc++ = '\0';
+                decode_params(p, id);
+                err = validate_desc(p, desc);
+                if (err) {
+                    fprintf(stderr, "%s: %s\n", quis, err);
+                    exit(1);
+                }
+                solve(p, desc, 1);
+            } else {
+                decode_params(p, id);
+                diff = gen(p, rs, 1);
+            }
+        }
+    } else {
+        while(1) {
+            p = default_params();
+            p->order = random_upto(rs, 7) + 3;
+            p->diff = random_upto(rs, 4);
+            diff = gen(p, rs, 0);
+            pdiff(diff);
+        }
+    }
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/unfinished/README b/apps/plugins/puzzles/unfinished/README
new file mode 100644
index 0000000000..0f8bb41d7c
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/README
@@ -0,0 +1,9 @@
+This subdirectory contains puzzle implementations which are
+half-written, fundamentally flawed, or in other ways unready to be
+shipped as part of the polished Puzzles collection.
+
+Those puzzles which have .R files can be built as part of the
+Puzzles collection by symlinking their source files into the parent
+directory and re-running mkfiles.pl. Anything without a .R file
+isn't even finished enough to do that, and you should read the
+source file itself to find out the status.
diff --git a/apps/plugins/puzzles/unfinished/group.R b/apps/plugins/puzzles/unfinished/group.R
new file mode 100644
index 0000000000..a11d22e9b9
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/group.R
@@ -0,0 +1,25 @@
+# -*- makefile -*-
+
+GROUP_LATIN_EXTRA = tree234 maxflow
+GROUP_EXTRA = latin GROUP_LATIN_EXTRA
+
+group    : [X] GTK COMMON group GROUP_EXTRA group-icon|no-icon
+
+group    : [G] WINDOWS COMMON group GROUP_EXTRA group.res|noicon.res
+
+groupsolver : [U] group[STANDALONE_SOLVER] latin[STANDALONE_SOLVER] GROUP_LATIN_EXTRA STANDALONE
+groupsolver : [C] group[STANDALONE_SOLVER] latin[STANDALONE_SOLVER] GROUP_LATIN_EXTRA STANDALONE
+
+ALL += group[COMBINED] GROUP_EXTRA
+
+!begin am gtk
+GAMES += group
+!end
+
+!begin >list.c
+    A(group) \
+!end
+
+!begin >gamedesc.txt
+group:group.exe:Group:Group theory puzzle:Complete the unfinished Cayley table of a group.
+!end
diff --git a/apps/plugins/puzzles/unfinished/group.c b/apps/plugins/puzzles/unfinished/group.c
new file mode 100644
index 0000000000..bec826e367
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/group.c
@@ -0,0 +1,2198 @@
+/*
+ * group.c: a Latin-square puzzle, but played with groups' Cayley
+ * tables. That is, you are given a Cayley table of a group with
+ * most elements blank and a few clues, and you must fill it in
+ * so as to preserve the group axioms.
+ *
+ * This is a perfectly playable and fully working puzzle, but I'm
+ * leaving it for the moment in the 'unfinished' directory because
+ * it's just too esoteric (not to mention _hard_) for me to be
+ * comfortable presenting it to the general public as something they
+ * might (implicitly) actually want to play.
+ *
+ * TODO:
+ *
+ *  - more solver techniques?
+ *     * Inverses: once we know that gh = e, we can immediately
+ *       deduce hg = e as well; then for any gx=y we can deduce
+ *       hy=x, and for any xg=y we have yh=x.
+ *     * Hard-mode associativity: we currently deduce based on
+ *       definite numbers in the grid, but we could also winnow
+ *       based on _possible_ numbers.
+ *     * My overambitious original thoughts included wondering if we
+ *       could infer that there must be elements of certain orders
+ *       (e.g. a group of order divisible by 5 must contain an
+ *       element of order 5), but I think in fact this is probably
+ *       silly.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "latin.h"
+
+/*
+ * Difficulty levels. I do some macro ickery here to ensure that my
+ * enum and the various forms of my name list always match up.
+ */
+#define DIFFLIST(A) \
+    A(TRIVIAL,Trivial,NULL,t) \
+    A(NORMAL,Normal,solver_normal,n) \
+    A(HARD,Hard,NULL,h) \
+    A(EXTREME,Extreme,NULL,x) \
+    A(UNREASONABLE,Unreasonable,NULL,u)
+#define ENUM(upper,title,func,lower) DIFF_ ## upper,
+#define TITLE(upper,title,func,lower) #title,
+#define ENCODE(upper,title,func,lower) #lower
+#define CONFIG(upper,title,func,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const group_diffnames[] = { DIFFLIST(TITLE) };
+static char const group_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_USER,
+    COL_HIGHLIGHT,
+    COL_ERROR,
+    COL_PENCIL,
+    COL_DIAGONAL,
+    NCOLOURS
+};
+
+/*
+ * In identity mode, we number the elements e,a,b,c,d,f,g,h,...
+ * Otherwise, they're a,b,c,d,e,f,g,h,... in the obvious way.
+ */
+#define E_TO_FRONT(c,id) ( (id) && (c)<=5 ? (c) % 5 + 1 : (c) )
+#define E_FROM_FRONT(c,id) ( (id) && (c)<=5 ? ((c) + 3) % 5 + 1 : (c) )
+
+#define FROMCHAR(c,id) E_TO_FRONT((((c)-('A'-1)) & ~0x20), id)
+#define ISCHAR(c) (((c)>='A'&&(c)<='Z') || ((c)>='a'&&(c)<='z'))
+#define TOCHAR(c,id) (E_FROM_FRONT(c,id) + ('a'-1))
+
+struct game_params {
+    int w, diff, id;
+};
+
+struct game_state {
+    game_params par;
+    digit *grid;
+    unsigned char *immutable;
+    int *pencil;                       /* bitmaps using bits 1<<1..1<<n */
+    int completed, cheated;
+    digit *sequence;                   /* sequence of group elements shown */
+
+    /*
+     * This array indicates thick lines separating rows and columns
+     * placed and unplaced manually by the user as a visual aid, e.g.
+     * to delineate a subgroup and its cosets.
+     *
+     * When a line is placed, it's deemed to be between the two
+     * particular group elements that are on either side of it at the
+     * time; dragging those two away from each other automatically
+     * gets rid of the line. Hence, for a given element i, dividers[i]
+     * is either -1 (indicating no divider to the right of i), or some
+     * other element (indicating a divider to the right of i iff that
+     * element is the one right of it). These are eagerly cleared
+     * during drags.
+     */
+    int *dividers;                     /* thick lines between rows/cols */
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = 6;
+    ret->diff = DIFF_NORMAL;
+    ret->id = TRUE;
+
+    return ret;
+}
+
+const static struct game_params group_presets[] = {
+    {  6, DIFF_NORMAL, TRUE },
+    {  6, DIFF_NORMAL, FALSE },
+    {  8, DIFF_NORMAL, TRUE },
+    {  8, DIFF_NORMAL, FALSE },
+    {  8, DIFF_HARD, TRUE },
+    {  8, DIFF_HARD, FALSE },
+    { 12, DIFF_NORMAL, TRUE },
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(group_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = group_presets[i]; /* structure copy */
+
+    sprintf(buf, "%dx%d %s%s", ret->w, ret->w, group_diffnames[ret->diff],
+            ret->id ? "" : ", identity hidden");
+
+    *name = dupstr(buf);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    char const *p = string;
+
+    params->w = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+    params->diff = DIFF_NORMAL;
+    params->id = TRUE;
+
+    while (*p) {
+        if (*p == 'd') {
+            int i;
+            p++;
+            params->diff = DIFFCOUNT+1; /* ...which is invalid */
+            if (*p) {
+                for (i = 0; i < DIFFCOUNT; i++) {
+                    if (*p == group_diffchars[i])
+                        params->diff = i;
+                }
+                p++;
+            }
+        } else if (*p == 'i') {
+            params->id = FALSE;
+            p++;
+        } else {
+            /* unrecognised character */
+            p++;
+        }
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char ret[80];
+
+    sprintf(ret, "%d", params->w);
+    if (full)
+        sprintf(ret + strlen(ret), "d%c", group_diffchars[params->diff]);
+    if (!params->id)
+        sprintf(ret + strlen(ret), "i");
+
+    return dupstr(ret);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Grid size";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Difficulty";
+    ret[1].type = C_CHOICES;
+    ret[1].sval = DIFFCONFIG;
+    ret[1].ival = params->diff;
+
+    ret[2].name = "Show identity";
+    ret[2].type = C_BOOLEAN;
+    ret[2].sval = NULL;
+    ret[2].ival = params->id;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->diff = cfg[1].ival;
+    ret->id = cfg[2].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 3 || params->w > 26)
+        return "Grid size must be between 3 and 26";
+    if (params->diff >= DIFFCOUNT)
+        return "Unknown difficulty rating";
+    if (!params->id && params->diff == DIFF_TRIVIAL) {
+        /*
+         * We can't have a Trivial-difficulty puzzle (i.e. latin
+         * square deductions only) without a clear identity, because
+         * identityless puzzles always have two rows and two columns
+         * entirely blank, and no latin-square deduction permits the
+         * distinguishing of two such rows.
+         */
+        return "Trivial puzzles must have an identity";
+    }
+    if (!params->id && params->w == 3) {
+        /*
+         * We can't have a 3x3 puzzle without an identity either,
+         * because 3x3 puzzles can't ever be harder than Trivial
+         * (there are no 3x3 latin squares which aren't also valid
+         * group tables, so enabling group-based deductions doesn't
+         * rule out any possible solutions) and - as above - Trivial
+         * puzzles can't not have an identity.
+         */
+        return "3x3 puzzles must have an identity";
+    }
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver.
+ */
+
+static int solver_normal(struct latin_solver *solver, void *vctx)
+{
+    int w = solver->o;
+#ifdef STANDALONE_SOLVER
+    char **names = solver->names;
+#endif
+    digit *grid = solver->grid;
+    int i, j, k;
+
+    /*
+     * Deduce using associativity: (ab)c = a(bc).
+     *
+     * So we pick any a,b,c we like; then if we know ab, bc, and
+     * (ab)c we can fill in a(bc).
+     */
+    for (i = 1; i < w; i++)
+        for (j = 1; j < w; j++)
+            for (k = 1; k < w; k++) {
+                if (!grid[i*w+j] || !grid[j*w+k])
+                    continue;
+                if (grid[(grid[i*w+j]-1)*w+k] &&
+                    !grid[i*w+(grid[j*w+k]-1)]) {
+                    int x = grid[j*w+k]-1, y = i;
+                    int n = grid[(grid[i*w+j]-1)*w+k];
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*sassociativity on %s,%s,%s: %s*%s = %s*%s\n",
+                               solver_recurse_depth*4, "",
+                               names[i], names[j], names[k],
+                               names[grid[i*w+j]-1], names[k],
+                               names[i], names[grid[j*w+k]-1]);
+                        printf("%*s  placing %s at (%d,%d)\n",
+                               solver_recurse_depth*4, "",
+                               names[n-1], x+1, y+1);
+                    }
+#endif
+                    if (solver->cube[(x*w+y)*w+n-1]) {
+                        latin_solver_place(solver, x, y, n);
+                        return 1;
+                    } else {
+#ifdef STANDALONE_SOLVER
+                        if (solver_show_working)
+                            printf("%*s  contradiction!\n",
+                                   solver_recurse_depth*4, "");
+                        return -1;
+#endif
+                    }
+                }
+                if (!grid[(grid[i*w+j]-1)*w+k] &&
+                    grid[i*w+(grid[j*w+k]-1)]) {
+                    int x = k, y = grid[i*w+j]-1;
+                    int n = grid[i*w+(grid[j*w+k]-1)];
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*sassociativity on %s,%s,%s: %s*%s = %s*%s\n",
+                               solver_recurse_depth*4, "",
+                               names[i], names[j], names[k],
+                               names[grid[i*w+j]-1], names[k],
+                               names[i], names[grid[j*w+k]-1]);
+                        printf("%*s  placing %s at (%d,%d)\n",
+                               solver_recurse_depth*4, "",
+                               names[n-1], x+1, y+1);
+                    }
+#endif
+                    if (solver->cube[(x*w+y)*w+n-1]) {
+                        latin_solver_place(solver, x, y, n);
+                        return 1;
+                    } else {
+#ifdef STANDALONE_SOLVER
+                        if (solver_show_working)
+                            printf("%*s  contradiction!\n",
+                                   solver_recurse_depth*4, "");
+                        return -1;
+#endif
+                    }
+                }
+            }
+
+    return 0;
+}
+
+#define SOLVER(upper,title,func,lower) func,
+static usersolver_t const group_solvers[] = { DIFFLIST(SOLVER) };
+
+static int solver(const game_params *params, digit *grid, int maxdiff)
+{
+    int w = params->w;
+    int ret;
+    struct latin_solver solver;
+#ifdef STANDALONE_SOLVER
+    char *p, text[100], *names[50];
+    int i;
+#endif
+
+    latin_solver_alloc(&solver, grid, w);
+#ifdef STANDALONE_SOLVER
+    for (i = 0, p = text; i < w; i++) {
+        names[i] = p;
+        *p++ = TOCHAR(i+1, params->id);
+        *p++ = '\0';
+    }
+    solver.names = names;
+#endif
+
+    ret = latin_solver_main(&solver, maxdiff,
+                            DIFF_TRIVIAL, DIFF_HARD, DIFF_EXTREME,
+                            DIFF_EXTREME, DIFF_UNREASONABLE,
+                            group_solvers, NULL, NULL, NULL);
+
+    latin_solver_free(&solver);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Grid generation.
+ */
+
+static char *encode_grid(char *desc, digit *grid, int area)
+{
+    int run, i;
+    char *p = desc;
+
+    run = 0;
+    for (i = 0; i <= area; i++) {
+        int n = (i < area ? grid[i] : -1);
+
+        if (!n)
+            run++;
+        else {
+            if (run) {
+                while (run > 0) {
+                    int c = 'a' - 1 + run;
+                    if (run > 26)
+                        c = 'z';
+                    *p++ = c;
+                    run -= c - ('a' - 1);
+                }
+            } else {
+                /*
+                 * If there's a number in the very top left or
+                 * bottom right, there's no point putting an
+                 * unnecessary _ before or after it.
+                 */
+                if (p > desc && n > 0)
+                    *p++ = '_';
+            }
+            if (n > 0)
+                p += sprintf(p, "%d", n);
+            run = 0;
+        }
+    }
+    return p;
+}
+
+/* ----- data generated by group.gap begins ----- */
+
+struct group {
+    unsigned long autosize;
+    int order, ngens;
+    const char *gens;
+};
+struct groups {
+    int ngroups;
+    const struct group *groups;
+};
+
+static const struct group groupdata[] = {
+    /* order 2 */
+    {1L, 2, 1, "BA"},
+    /* order 3 */
+    {2L, 3, 1, "BCA"},
+    /* order 4 */
+    {2L, 4, 1, "BCDA"},
+    {6L, 4, 2, "BADC" "CDAB"},
+    /* order 5 */
+    {4L, 5, 1, "BCDEA"},
+    /* order 6 */
+    {6L, 6, 2, "CFEBAD" "BADCFE"},
+    {2L, 6, 1, "DCFEBA"},
+    /* order 7 */
+    {6L, 7, 1, "BCDEFGA"},
+    /* order 8 */
+    {4L, 8, 1, "BCEFDGHA"},
+    {8L, 8, 2, "BDEFGAHC" "EGBHDCFA"},
+    {8L, 8, 2, "EGBHDCFA" "BAEFCDHG"},
+    {24L, 8, 2, "BDEFGAHC" "CHDGBEAF"},
+    {168L, 8, 3, "BAEFCDHG" "CEAGBHDF" "DFGAHBCE"},
+    /* order 9 */
+    {6L, 9, 1, "BDECGHFIA"},
+    {48L, 9, 2, "BDEAGHCIF" "CEFGHAIBD"},
+    /* order 10 */
+    {20L, 10, 2, "CJEBGDIFAH" "BADCFEHGJI"},
+    {4L, 10, 1, "DCFEHGJIBA"},
+    /* order 11 */
+    {10L, 11, 1, "BCDEFGHIJKA"},
+    /* order 12 */
+    {12L, 12, 2, "GLDKJEHCBIAF" "BCEFAGIJDKLH"},
+    {4L, 12, 1, "EHIJKCBLDGFA"},
+    {24L, 12, 2, "BEFGAIJKCDLH" "FJBKHLEGDCIA"},
+    {12L, 12, 2, "GLDKJEHCBIAF" "BAEFCDIJGHLK"},
+    {12L, 12, 2, "FDIJGHLBKAEC" "GIDKFLHCJEAB"},
+    /* order 13 */
+    {12L, 13, 1, "BCDEFGHIJKLMA"},
+    /* order 14 */
+    {42L, 14, 2, "ELGNIBKDMFAHCJ" "BADCFEHGJILKNM"},
+    {6L, 14, 1, "FEHGJILKNMBADC"},
+    /* order 15 */
+    {8L, 15, 1, "EGHCJKFMNIOBLDA"},
+    /* order 16 */
+    {8L, 16, 1, "MKNPFOADBGLCIEHJ"},
+    {96L, 16, 2, "ILKCONFPEDJHGMAB" "BDFGHIAKLMNCOEPJ"},
+    {32L, 16, 2, "MIHPFDCONBLAKJGE" "BEFGHJKALMNOCDPI"},
+    {32L, 16, 2, "IFACOGLMDEJBNPKH" "BEFGHJKALMNOCDPI"},
+    {16L, 16, 2, "MOHPFKCINBLADJGE" "BDFGHIEKLMNJOAPC"},
+    {16L, 16, 2, "MIHPFDJONBLEKCGA" "BDFGHIEKLMNJOAPC"},
+    {32L, 16, 2, "MOHPFDCINBLEKJGA" "BAFGHCDELMNIJKPO"},
+    {16L, 16, 2, "MIHPFKJONBLADCGE" "GDPHNOEKFLBCIAMJ"},
+    {32L, 16, 2, "MIBPFDJOGHLEKCNA" "CLEIJGMPKAOHNFDB"},
+    {192L, 16, 3,
+     "MCHPFAIJNBLDEOGK" "BEFGHJKALMNOCDPI" "GKLBNOEDFPHJIAMC"},
+    {64L, 16, 3, "MCHPFAIJNBLDEOGK" "LOGFPKJIBNMEDCHA" "CMAIJHPFDEONBLKG"},
+    {192L, 16, 3,
+     "IPKCOGMLEDJBNFAH" "BEFGHJKALMNOCDPI" "CMEIJBPFKAOGHLDN"},
+    {48L, 16, 3, "IPDJONFLEKCBGMAH" "FJBLMEOCGHPKAIND" "DGIEKLHNJOAMPBCF"},
+    {20160L, 16, 4,
+     "EHJKAMNBOCDPFGIL" "BAFGHCDELMNIJKPO" "CFAIJBLMDEOGHPKN"
+     "DGIAKLBNCOEFPHJM"},
+    /* order 17 */
+    {16L, 17, 1, "EFGHIJKLMNOPQABCD"},
+    /* order 18 */
+    {54L, 18, 2, "MKIQOPNAGLRECDBJHF" "BAEFCDJKLGHIOPMNRQ"},
+    {6L, 18, 1, "ECJKGHFOPDMNLRIQBA"},
+    {12L, 18, 2, "ECJKGHBOPAMNFRDQLI" "KNOPQCFREIGHLJAMBD"},
+    {432L, 18, 3,
+     "IFNAKLQCDOPBGHREMJ" "NOQCFRIGHKLJAMPBDE" "BAEFCDJKLGHIOPMNRQ"},
+    {48L, 18, 2, "ECJKGHBOPAMNFRDQLI" "FDKLHIOPBMNAREQCJG"},
+    /* order 19 */
+    {18L, 19, 1, "EFGHIJKLMNOPQRSABCD"},
+    /* order 20 */
+    {40L, 20, 2, "GTDKREHOBILSFMPCJQAN" "EABICDFMGHJQKLNTOPRS"},
+    {8L, 20, 1, "EHIJLCMNPGQRSKBTDOFA"},
+    {20L, 20, 2, "DJSHQNCLTRGPEBKAIFOM" "EABICDFMGHJQKLNTOPRS"},
+    {40L, 20, 2, "GTDKREHOBILSFMPCJQAN" "ECBIAGFMDKJQHONTLSRP"},
+    {24L, 20, 2, "IGFMDKJQHONTLSREPCBA" "FDIJGHMNKLQROPTBSAEC"},
+    /* order 21 */
+    {42L, 21, 2, "ITLSBOUERDHAGKCJNFMQP" "EJHLMKOPNRSQAUTCDBFGI"},
+    {12L, 21, 1, "EGHCJKFMNIPQLSTOUBRDA"},
+    /* order 22 */
+    {110L, 22, 2, "ETGVIBKDMFOHQJSLUNAPCR" "BADCFEHGJILKNMPORQTSVU"},
+    {10L, 22, 1, "FEHGJILKNMPORQTSVUBADC"},
+    /* order 23 */
+    {22L, 23, 1, "EFGHIJKLMNOPQRSTUVWABCD"},
+    /* order 24 */
+    {24L, 24, 2, "QXEJWPUMKLRIVBFTSACGHNDO" "HRNOPSWCTUVBLDIJXFGAKQME"},
+    {8L, 24, 1, "MQBTUDRWFGHXJELINOPKSAVC"},
+    {24L, 24, 2, "IOQRBEUVFWGHKLAXMNPSCDTJ" "NJXOVGDKSMTFIPQELCURBWAH"},
+    {48L, 24, 2, "QUEJWVXFKLRIPGMNSACBOTDH" "HSNOPWLDTUVBRIAKXFGCQEMJ"},
+    {24L, 24, 2, "QXEJWPUMKLRIVBFTSACGHNDO" "TWHNXLRIOPUMSACQVBFDEJGK"},
+    {48L, 24, 2, "QUEJWVXFKLRIPGMNSACBOTDH" "BAFGHCDEMNOPIJKLTUVQRSXW"},
+    {48L, 24, 3,
+     "QXKJWVUMESRIPGFTLDCBONAH" "JUEQRPXFKLWCVBMNSAIGHTDO"
+     "HSNOPWLDTUVBRIAKXFGCQEMJ"},
+    {24L, 24, 3,
+     "QUKJWPXFESRIVBMNLDCGHTAO" "JXEQRVUMKLWCPGFTSAIBONDH"
+     "TRONXLWCHVUMSAIJPGFDEQBK"},
+    {16L, 24, 2, "MRGTULWIOPFXSDJQBVNEKCHA" "VKXHOQASNTPBCWDEUFGIJLMR"},
+    {16L, 24, 2, "MRGTULWIOPFXSDJQBVNEKCHA" "RMLWIGTUSDJQOPFXEKCBVNAH"},
+    {48L, 24, 2, "IULQRGXMSDCWOPNTEKJBVFAH" "GLMOPRSDTUBVWIEKFXHJQANC"},
+    {24L, 24, 2, "UJPXMRCSNHGTLWIKFVBEDQOA" "NRUFVLWIPXMOJEDQHGTCSABK"},
+    {24L, 24, 2, "MIBTUAQRFGHXCDEWNOPJKLVS" "OKXVFWSCGUTNDRQJBPMALIHE"},
+    {144L, 24, 3,
+     "QXKJWVUMESRIPGFTLDCBONAH" "JUEQRPXFKLWCVBMNSAIGHTDO"
+     "BAFGHCDEMNOPIJKLTUVQRSXW"},
+    {336L, 24, 3,
+     "QTKJWONXESRIHVUMLDCPGFAB" "JNEQRHTUKLWCOPXFSAIVBMDG"
+     "HENOPJKLTUVBQRSAXFGWCDMI"},
+    /* order 25 */
+    {20L, 25, 1, "EHILMNPQRSFTUVBJWXDOYGAKC"},
+    {480L, 25, 2, "EHILMNPQRSCTUVBFWXDJYGOKA" "BDEGHIKLMNAPQRSCTUVFWXJYO"},
+    /* order 26 */
+    {156L, 26, 2,
+     "EXGZIBKDMFOHQJSLUNWPYRATCV" "BADCFEHGJILKNMPORQTSVUXWZY"},
+    {12L, 26, 1, "FEHGJILKNMPORQTSVUXWZYBADC"},
+};
+
+static const struct groups groups[] = {
+    {0, NULL},                  /* trivial case: 0 */
+    {0, NULL},                  /* trivial case: 1 */
+    {1, groupdata + 0},         /* 2 */
+    {1, groupdata + 1},         /* 3 */
+    {2, groupdata + 2},         /* 4 */
+    {1, groupdata + 4},         /* 5 */
+    {2, groupdata + 5},         /* 6 */
+    {1, groupdata + 7},         /* 7 */
+    {5, groupdata + 8},         /* 8 */
+    {2, groupdata + 13},        /* 9 */
+    {2, groupdata + 15},        /* 10 */
+    {1, groupdata + 17},        /* 11 */
+    {5, groupdata + 18},        /* 12 */
+    {1, groupdata + 23},        /* 13 */
+    {2, groupdata + 24},        /* 14 */
+    {1, groupdata + 26},        /* 15 */
+    {14, groupdata + 27},       /* 16 */
+    {1, groupdata + 41},        /* 17 */
+    {5, groupdata + 42},        /* 18 */
+    {1, groupdata + 47},        /* 19 */
+    {5, groupdata + 48},        /* 20 */
+    {2, groupdata + 53},        /* 21 */
+    {2, groupdata + 55},        /* 22 */
+    {1, groupdata + 57},        /* 23 */
+    {15, groupdata + 58},       /* 24 */
+    {2, groupdata + 73},        /* 25 */
+    {2, groupdata + 75},        /* 26 */
+};
+
+/* ----- data generated by group.gap ends ----- */
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, a = w*w;
+    digit *grid, *soln, *soln2;
+    int *indices;
+    int i, j, k, qh, qt;
+    int diff = params->diff;
+    const struct group *group;
+    char *desc, *p;
+
+    /*
+     * Difficulty exceptions: some combinations of size and
+     * difficulty cannot be satisfied, because all puzzles of at
+     * most that difficulty are actually even easier.
+     *
+     * Remember to re-test this whenever a change is made to the
+     * solver logic!
+     *
+     * I tested it using the following shell command:
+
+for d in t n h x u; do
+  for id in '' i; do
+    for i in {3..9}; do
+      echo -n "./group --generate 1 ${i}d${d}${id}: "
+      perl -e 'alarm 30; exec @ARGV' \
+        ./group --generate 1 ${i}d${d}${id} >/dev/null && echo ok
+    done
+  done
+done
+
+     * Of course, it's better to do that after taking the exceptions
+     * _out_, so as to detect exceptions that should be removed as
+     * well as those which should be added.
+     */
+    if (w < 5 && diff == DIFF_UNREASONABLE)
+        diff--;
+    if ((w < 5 || ((w == 6 || w == 8) && params->id)) && diff == DIFF_EXTREME)
+        diff--;
+    if ((w < 6 || (w == 6 && params->id)) && diff == DIFF_HARD)
+        diff--;
+    if ((w < 4 || (w == 4 && params->id)) && diff == DIFF_NORMAL)
+        diff--;
+
+    grid = snewn(a, digit);
+    soln = snewn(a, digit);
+    soln2 = snewn(a, digit);
+    indices = snewn(a, int);
+
+    while (1) {
+        /*
+         * Construct a valid group table, by picking a group from
+         * the above data table, decompressing it into a full
+         * representation by BFS, and then randomly permuting its
+         * non-identity elements.
+         *
+         * We build the canonical table in 'soln' (and use 'grid' as
+         * our BFS queue), then transfer the table into 'grid'
+         * having shuffled the rows.
+         */
+        assert(w >= 2);
+        assert(w < lenof(groups));
+        group = groups[w].groups + random_upto(rs, groups[w].ngroups);
+        assert(group->order == w);
+        memset(soln, 0, a);
+        for (i = 0; i < w; i++)
+            soln[i] = i+1;
+        qh = qt = 0;
+        grid[qt++] = 1;
+        while (qh < qt) {
+            digit *row, *newrow;
+
+            i = grid[qh++];
+            row = soln + (i-1)*w;
+
+            for (j = 0; j < group->ngens; j++) {
+                int nri;
+                const char *gen = group->gens + j*w;
+
+                /*
+                 * Apply each group generator to row, constructing a
+                 * new row.
+                 */
+                nri = gen[row[0]-1] - 'A' + 1;   /* which row is it? */
+                newrow = soln + (nri-1)*w;
+                if (!newrow[0]) {   /* not done yet */
+                    for (k = 0; k < w; k++)
+                        newrow[k] = gen[row[k]-1] - 'A' + 1;
+                    grid[qt++] = nri;
+                }
+            }
+        }
+        /* That's got the canonical table. Now shuffle it. */
+        for (i = 0; i < w; i++)
+            soln2[i] = i;
+        if (params->id)                /* do we shuffle in the identity? */
+            shuffle(soln2+1, w-1, sizeof(*soln2), rs);
+        else
+            shuffle(soln2, w, sizeof(*soln2), rs);
+        for (i = 0; i < w; i++)
+            for (j = 0; j < w; j++)
+                grid[(soln2[i])*w+(soln2[j])] = soln2[soln[i*w+j]-1]+1;
+
+        /*
+         * Remove entries one by one while the puzzle is still
+         * soluble at the appropriate difficulty level.
+         */
+        memcpy(soln, grid, a);
+        if (!params->id) {
+            /*
+             * Start by blanking the entire identity row and column,
+             * and also another row and column so that the player
+             * can't trivially determine which element is the
+             * identity.
+             */
+
+            j = 1 + random_upto(rs, w-1);  /* pick a second row/col to blank */
+            for (i = 0; i < w; i++) {
+                grid[(soln2[0])*w+i] = grid[i*w+(soln2[0])] = 0;
+                grid[(soln2[j])*w+i] = grid[i*w+(soln2[j])] = 0;
+            }
+
+            memcpy(soln2, grid, a);
+            if (solver(params, soln2, diff) > diff)
+                continue;              /* go round again if that didn't work */
+        }
+
+        k = 0;
+        for (i = (params->id ? 1 : 0); i < w; i++)
+            for (j = (params->id ? 1 : 0); j < w; j++)
+                if (grid[i*w+j])
+                    indices[k++] = i*w+j;
+        shuffle(indices, k, sizeof(*indices), rs);
+
+        for (i = 0; i < k; i++) {
+            memcpy(soln2, grid, a);
+            soln2[indices[i]] = 0;
+            if (solver(params, soln2, diff) <= diff)
+                grid[indices[i]] = 0;
+        }
+
+        /*
+         * Make sure the puzzle isn't too easy.
+         */
+        if (diff > 0) {
+            memcpy(soln2, grid, a);
+            if (solver(params, soln2, diff-1) < diff)
+                continue;              /* go round and try again */
+        }
+
+        /*
+         * Done.
+         */
+        break;
+    }
+
+    /*
+     * Encode the puzzle description.
+     */
+    desc = snewn(a*20, char);
+    p = encode_grid(desc, grid, a);
+    *p++ = '\0';
+    desc = sresize(desc, p - desc, char);
+
+    /*
+     * Encode the solution.
+     */
+    *aux = snewn(a+2, char);
+    (*aux)[0] = 'S';
+    for (i = 0; i < a; i++)
+        (*aux)[i+1] = TOCHAR(soln[i], params->id);
+    (*aux)[a+1] = '\0';
+
+    sfree(grid);
+    sfree(soln);
+    sfree(soln2);
+    sfree(indices);
+
+    return desc;
+}
+
+/* ----------------------------------------------------------------------
+ * Gameplay.
+ */
+
+static char *validate_grid_desc(const char **pdesc, int range, int area)
+{
+    const char *desc = *pdesc;
+    int squares = 0;
+    while (*desc && *desc != ',') {
+        int n = *desc++;
+        if (n >= 'a' && n <= 'z') {
+            squares += n - 'a' + 1;
+        } else if (n == '_') {
+            /* do nothing */;
+        } else if (n > '0' && n <= '9') {
+            int val = atoi(desc-1);
+            if (val < 1 || val > range)
+                return "Out-of-range number in game description";
+            squares++;
+            while (*desc >= '0' && *desc <= '9')
+                desc++;
+        } else
+            return "Invalid character in game description";
+    }
+
+    if (squares < area)
+        return "Not enough data to fill grid";
+
+    if (squares > area)
+        return "Too much data to fit in grid";
+    *pdesc = desc;
+    return NULL;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, a = w*w;
+    const char *p = desc;
+
+    return validate_grid_desc(&p, w, a);
+}
+
+static const char *spec_to_grid(const char *desc, digit *grid, int area)
+{
+    int i = 0;
+    while (*desc && *desc != ',') {
+        int n = *desc++;
+        if (n >= 'a' && n <= 'z') {
+            int run = n - 'a' + 1;
+            assert(i + run <= area);
+            while (run-- > 0)
+                grid[i++] = 0;
+        } else if (n == '_') {
+            /* do nothing */;
+        } else if (n > '0' && n <= '9') {
+            assert(i < area);
+            grid[i++] = atoi(desc-1);
+            while (*desc >= '0' && *desc <= '9')
+                desc++;
+        } else {
+            assert(!"We can't get here");
+        }
+    }
+    assert(i == area);
+    return desc;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, a = w*w;
+    game_state *state = snew(game_state);
+    int i;
+
+    state->par = *params;              /* structure copy */
+    state->grid = snewn(a, digit);
+    state->immutable = snewn(a, unsigned char);
+    state->pencil = snewn(a, int);
+    for (i = 0; i < a; i++) {
+        state->grid[i] = 0;
+        state->immutable[i] = 0;
+        state->pencil[i] = 0;
+    }
+    state->sequence = snewn(w, digit);
+    state->dividers = snewn(w, int);
+    for (i = 0; i < w; i++) {
+        state->sequence[i] = i;
+        state->dividers[i] = -1;
+    }
+
+    desc = spec_to_grid(desc, state->grid, a);
+    for (i = 0; i < a; i++)
+        if (state->grid[i] != 0)
+            state->immutable[i] = TRUE;
+
+    state->completed = state->cheated = FALSE;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w = state->par.w, a = w*w;
+    game_state *ret = snew(game_state);
+
+    ret->par = state->par;             /* structure copy */
+
+    ret->grid = snewn(a, digit);
+    ret->immutable = snewn(a, unsigned char);
+    ret->pencil = snewn(a, int);
+    ret->sequence = snewn(w, digit);
+    ret->dividers = snewn(w, int);
+    memcpy(ret->grid, state->grid, a*sizeof(digit));
+    memcpy(ret->immutable, state->immutable, a*sizeof(unsigned char));
+    memcpy(ret->pencil, state->pencil, a*sizeof(int));
+    memcpy(ret->sequence, state->sequence, w*sizeof(digit));
+    memcpy(ret->dividers, state->dividers, w*sizeof(int));
+
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    sfree(state->immutable);
+    sfree(state->pencil);
+    sfree(state->sequence);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int w = state->par.w, a = w*w;
+    int i, ret;
+    digit *soln;
+    char *out;
+
+    if (aux)
+        return dupstr(aux);
+
+    soln = snewn(a, digit);
+    memcpy(soln, state->grid, a*sizeof(digit));
+
+    ret = solver(&state->par, soln, DIFFCOUNT-1);
+
+    if (ret == diff_impossible) {
+        *error = "No solution exists for this puzzle";
+        out = NULL;
+    } else if (ret == diff_ambiguous) {
+        *error = "Multiple solutions exist for this puzzle";
+        out = NULL;
+    } else {
+        out = snewn(a+2, char);
+        out[0] = 'S';
+        for (i = 0; i < a; i++)
+            out[i+1] = TOCHAR(soln[i], state->par.id);
+        out[a+1] = '\0';
+    }
+
+    sfree(soln);
+    return out;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w = state->par.w;
+    int x, y;
+    char *ret, *p, ch;
+
+    ret = snewn(2*w*w+1, char);        /* leave room for terminating NUL */
+
+    p = ret;
+    for (y = 0; y < w; y++) {
+        for (x = 0; x < w; x++) {
+            digit d = state->grid[y*w+x];
+
+            if (d == 0) {
+                ch = '.';
+            } else {
+                ch = TOCHAR(d, state->par.id);
+            }
+
+            *p++ = ch;
+            if (x == w-1) {
+                *p++ = '\n';
+            } else {
+                *p++ = ' ';
+            }
+        }
+    }
+
+    assert(p - ret == 2*w*w);
+    *p = '\0';
+    return ret;
+}
+
+struct game_ui {
+    /*
+     * These are the coordinates of the primary highlighted square on
+     * the grid, if hshow = 1.
+     */
+    int hx, hy;
+    /*
+     * These are the coordinates hx,hy _before_ they go through
+     * state->sequence.
+     */
+    int ohx, ohy;
+    /*
+     * These variables give the length and displacement of a diagonal
+     * sequence of highlighted squares starting at ohx,ohy (still if
+     * hshow = 1). To find the squares' real coordinates, for 0<=i<dn,
+     * compute ohx+i*odx and ohy+i*ody and then map through
+     * state->sequence.
+     */
+    int odx, ody, odn;
+    /*
+     * This indicates whether the current highlight is a
+     * pencil-mark one or a real one.
+     */
+    int hpencil;
+    /*
+     * This indicates whether or not we're showing the highlight
+     * (used to be hx = hy = -1); important so that when we're
+     * using the cursor keys it doesn't keep coming back at a
+     * fixed position. When hshow = 1, pressing a valid number
+     * or letter key or Space will enter that number or letter in the grid.
+     */
+    int hshow;
+    /*
+     * This indicates whether we're using the highlight as a cursor;
+     * it means that it doesn't vanish on a keypress, and that it is
+     * allowed on immutable squares.
+     */
+    int hcursor;
+    /*
+     * This indicates whether we're dragging a table header to
+     * reposition an entire row or column.
+     */
+    int drag;                          /* 0=none 1=row 2=col */
+    int dragnum;                       /* element being dragged */
+    int dragpos;                       /* its current position */
+    int edgepos;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->hx = ui->hy = 0;
+    ui->hpencil = ui->hshow = ui->hcursor = 0;
+    ui->drag = 0;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    int w = newstate->par.w;
+    /*
+     * We prevent pencil-mode highlighting of a filled square, unless
+     * we're using the cursor keys. So if the user has just filled in
+     * a square which we had a pencil-mode highlight in (by Undo, or
+     * by Redo, or by Solve), then we cancel the highlight.
+     */
+    if (ui->hshow && ui->hpencil && !ui->hcursor &&
+        newstate->grid[ui->hy * w + ui->hx] != 0) {
+        ui->hshow = 0;
+    }
+    if (ui->hshow && ui->odn > 1) {
+        /*
+         * Reordering of rows or columns within the range of a
+         * multifill selection cancels the multifill and deselects
+         * everything.
+         */
+        int i;
+        for (i = 0; i < ui->odn; i++) {
+            if (oldstate->sequence[ui->ohx + i*ui->odx] !=
+                newstate->sequence[ui->ohx + i*ui->odx]) {
+                ui->hshow = 0;
+                break;
+            }
+            if (oldstate->sequence[ui->ohy + i*ui->ody] !=
+                newstate->sequence[ui->ohy + i*ui->ody]) {
+                ui->hshow = 0;
+                break;
+            }
+        }
+    } else if (ui->hshow &&
+               (newstate->sequence[ui->ohx] != ui->hx ||
+                newstate->sequence[ui->ohy] != ui->hy)) {
+        /*
+         * Otherwise, reordering of the row or column containing the
+         * selection causes the selection to move with it.
+         */
+        int i;
+        for (i = 0; i < w; i++) {
+            if (newstate->sequence[i] == ui->hx)
+                ui->ohx = i;
+            if (newstate->sequence[i] == ui->hy)
+                ui->ohy = i;
+        }
+    }
+}
+
+#define PREFERRED_TILESIZE 48
+#define TILESIZE (ds->tilesize)
+#define BORDER (TILESIZE / 2)
+#define LEGEND (TILESIZE)
+#define GRIDEXTRA max((TILESIZE / 32),1)
+#define COORD(x) ((x)*TILESIZE + BORDER + LEGEND)
+#define FROMCOORD(x) (((x)+(TILESIZE-BORDER-LEGEND)) / TILESIZE - 1)
+
+#define FLASH_TIME 0.4F
+
+#define DF_DIVIDER_TOP 0x1000
+#define DF_DIVIDER_BOT 0x2000
+#define DF_DIVIDER_LEFT 0x4000
+#define DF_DIVIDER_RIGHT 0x8000
+#define DF_HIGHLIGHT 0x0400
+#define DF_HIGHLIGHT_PENCIL 0x0200
+#define DF_IMMUTABLE 0x0100
+#define DF_LEGEND 0x0080
+#define DF_DIGIT_MASK 0x001F
+
+#define EF_DIGIT_SHIFT 5
+#define EF_DIGIT_MASK ((1 << EF_DIGIT_SHIFT) - 1)
+#define EF_LEFT_SHIFT 0
+#define EF_RIGHT_SHIFT (3*EF_DIGIT_SHIFT)
+#define EF_LEFT_MASK ((1UL << (3*EF_DIGIT_SHIFT)) - 1UL)
+#define EF_RIGHT_MASK (EF_LEFT_MASK << EF_RIGHT_SHIFT)
+#define EF_LATIN (1UL << (6*EF_DIGIT_SHIFT))
+
+struct game_drawstate {
+    game_params par;
+    int w, tilesize;
+    int started;
+    long *tiles, *legend, *pencil, *errors;
+    long *errtmp;
+    digit *sequence;
+};
+
+static int check_errors(const game_state *state, long *errors)
+{
+    int w = state->par.w, a = w*w;
+    digit *grid = state->grid;
+    int i, j, k, x, y, errs = FALSE;
+
+    /*
+     * To verify that we have a valid group table, it suffices to
+     * test latin-square-hood and associativity only. All the other
+     * group axioms follow from those two.
+     *
+     * Proof:
+     *
+     * Associativity is given; closure is obvious from latin-
+     * square-hood. We need to show that an identity exists and that
+     * every element has an inverse.
+     *
+     * Identity: take any element a. There will be some element e
+     * such that ea=a (in a latin square, every element occurs in
+     * every row and column, so a must occur somewhere in the a
+     * column, say on row e). For any other element b, there must
+     * exist x such that ax=b (same argument from latin-square-hood
+     * again), and then associativity gives us eb = e(ax) = (ea)x =
+     * ax = b. Hence eb=b for all b, i.e. e is a left-identity. A
+     * similar argument tells us that there must be some f which is
+     * a right-identity, and then we show they are the same element
+     * by observing that ef must simultaneously equal e and equal f.
+     *
+     * Inverses: given any a, by the latin-square argument again,
+     * there must exist p and q such that pa=e and aq=e (i.e. left-
+     * and right-inverses). We can show these are equal by
+     * associativity: p = pe = p(aq) = (pa)q = eq = q. []
+     */
+
+    if (errors)
+        for (i = 0; i < a; i++)
+            errors[i] = 0;
+
+    for (y = 0; y < w; y++) {
+        unsigned long mask = 0, errmask = 0;
+        for (x = 0; x < w; x++) {
+            unsigned long bit = 1UL << grid[y*w+x];
+            errmask |= (mask & bit);
+            mask |= bit;
+        }
+
+        if (mask != (1 << (w+1)) - (1 << 1)) {
+            errs = TRUE;
+            errmask &= ~1UL;
+            if (errors) {
+                for (x = 0; x < w; x++)
+                    if (errmask & (1UL << grid[y*w+x]))
+                        errors[y*w+x] |= EF_LATIN;
+            }
+        }
+    }
+
+    for (x = 0; x < w; x++) {
+        unsigned long mask = 0, errmask = 0;
+        for (y = 0; y < w; y++) {
+            unsigned long bit = 1UL << grid[y*w+x];
+            errmask |= (mask & bit);
+            mask |= bit;
+        }
+
+        if (mask != (1 << (w+1)) - (1 << 1)) {
+            errs = TRUE;
+            errmask &= ~1UL;
+            if (errors) {
+                for (y = 0; y < w; y++)
+                    if (errmask & (1UL << grid[y*w+x]))
+                        errors[y*w+x] |= EF_LATIN;
+            }
+        }
+    }
+
+    for (i = 1; i < w; i++)
+        for (j = 1; j < w; j++)
+            for (k = 1; k < w; k++)
+                if (grid[i*w+j] && grid[j*w+k] &&
+                    grid[(grid[i*w+j]-1)*w+k] &&
+                    grid[i*w+(grid[j*w+k]-1)] &&
+                    grid[(grid[i*w+j]-1)*w+k] != grid[i*w+(grid[j*w+k]-1)]) {
+                    if (errors) {
+                        int a = i+1, b = j+1, c = k+1;
+                        int ab = grid[i*w+j], bc = grid[j*w+k];
+                        int left = (ab-1)*w+(c-1), right = (a-1)*w+(bc-1);
+                        /*
+                         * If the appropriate error slot is already
+                         * used for one of the squares, we don't
+                         * fill either of them.
+                         */
+                        if (!(errors[left] & EF_LEFT_MASK) &&
+                            !(errors[right] & EF_RIGHT_MASK)) {
+                            long err;
+                            err = a;
+                            err = (err << EF_DIGIT_SHIFT) | b;
+                            err = (err << EF_DIGIT_SHIFT) | c;
+                            errors[left] |= err << EF_LEFT_SHIFT;
+                            errors[right] |= err << EF_RIGHT_SHIFT;
+                        }
+                    }
+                    errs = TRUE;
+                }
+
+    return errs;
+}
+
+static int find_in_sequence(digit *seq, int len, digit n)
+{
+    int i;
+
+    for (i = 0; i < len; i++)
+        if (seq[i] == n)
+            return i;
+
+    assert(!"Should never get here");
+    return -1;
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->par.w;
+    int tx, ty;
+    char buf[80];
+
+    button &= ~MOD_MASK;
+
+    tx = FROMCOORD(x);
+    ty = FROMCOORD(y);
+
+    if (ui->drag) {
+        if (IS_MOUSE_DRAG(button)) {
+            int tcoord = ((ui->drag &~ 4) == 1 ? ty : tx);
+            ui->drag |= 4;             /* some movement has happened */
+            if (tcoord >= 0 && tcoord < w) {
+                ui->dragpos = tcoord;
+                return "";
+            }
+        } else if (IS_MOUSE_RELEASE(button)) {
+            if (ui->drag & 4) {
+                ui->drag = 0;          /* end drag */
+                if (state->sequence[ui->dragpos] == ui->dragnum)
+                    return "";         /* drag was a no-op overall */
+                sprintf(buf, "D%d,%d", ui->dragnum, ui->dragpos);
+                return dupstr(buf);
+            } else {
+                ui->drag = 0;          /* end 'drag' */
+                if (ui->edgepos > 0 && ui->edgepos < w) {
+                    sprintf(buf, "V%d,%d",
+                            state->sequence[ui->edgepos-1],
+                            state->sequence[ui->edgepos]);
+                    return dupstr(buf);
+                } else
+                    return "";         /* no-op */
+            }
+        }
+    } else if (IS_MOUSE_DOWN(button)) {
+        if (tx >= 0 && tx < w && ty >= 0 && ty < w) {
+            int otx = tx, oty = ty;
+            tx = state->sequence[tx];
+            ty = state->sequence[ty];
+            if (button == LEFT_BUTTON) {
+                if (tx == ui->hx && ty == ui->hy &&
+                    ui->hshow && ui->hpencil == 0) {
+                    ui->hshow = 0;
+                } else {
+                    ui->hx = tx;
+                    ui->hy = ty;
+                    ui->ohx = otx;
+                    ui->ohy = oty;
+                    ui->odx = ui->ody = 0;
+                    ui->odn = 1;
+                    ui->hshow = !state->immutable[ty*w+tx];
+                    ui->hpencil = 0;
+                }
+                ui->hcursor = 0;
+                return "";                     /* UI activity occurred */
+            }
+            if (button == RIGHT_BUTTON) {
+                /*
+                 * Pencil-mode highlighting for non filled squares.
+                 */
+                if (state->grid[ty*w+tx] == 0) {
+                    if (tx == ui->hx && ty == ui->hy &&
+                        ui->hshow && ui->hpencil) {
+                        ui->hshow = 0;
+                    } else {
+                        ui->hpencil = 1;
+                        ui->hx = tx;
+                        ui->hy = ty;
+                        ui->ohx = otx;
+                        ui->ohy = oty;
+                        ui->odx = ui->ody = 0;
+                        ui->odn = 1;
+                        ui->hshow = 1;
+                    }
+                } else {
+                    ui->hshow = 0;
+                }
+                ui->hcursor = 0;
+                return "";                     /* UI activity occurred */
+            }
+        } else if (tx >= 0 && tx < w && ty == -1) {
+            ui->drag = 2;
+            ui->dragnum = state->sequence[tx];
+            ui->dragpos = tx;
+            ui->edgepos = FROMCOORD(x + TILESIZE/2);
+            return "";
+        } else if (ty >= 0 && ty < w && tx == -1) {
+            ui->drag = 1;
+            ui->dragnum = state->sequence[ty];
+            ui->dragpos = ty;
+            ui->edgepos = FROMCOORD(y + TILESIZE/2);
+            return "";
+        }
+    } else if (IS_MOUSE_DRAG(button)) {
+        if (!ui->hpencil &&
+            tx >= 0 && tx < w && ty >= 0 && ty < w &&
+            abs(tx - ui->ohx) == abs(ty - ui->ohy)) {
+            ui->odn = abs(tx - ui->ohx) + 1;
+            ui->odx = (tx < ui->ohx ? -1 : +1);
+            ui->ody = (ty < ui->ohy ? -1 : +1);
+        } else {
+            ui->odx = ui->ody = 0;
+            ui->odn = 1;
+        }
+        return "";
+    }
+
+    if (IS_CURSOR_MOVE(button)) {
+        int cx = find_in_sequence(state->sequence, w, ui->hx);
+        int cy = find_in_sequence(state->sequence, w, ui->hy);
+        move_cursor(button, &cx, &cy, w, w, 0);
+        ui->hx = state->sequence[cx];
+        ui->hy = state->sequence[cy];
+        ui->hshow = ui->hcursor = 1;
+        return "";
+    }
+    if (ui->hshow &&
+        (button == CURSOR_SELECT)) {
+        ui->hpencil = 1 - ui->hpencil;
+        ui->hcursor = 1;
+        return "";
+    }
+
+    if (ui->hshow &&
+        ((ISCHAR(button) && FROMCHAR(button, state->par.id) <= w) ||
+         button == CURSOR_SELECT2 || button == '\b')) {
+        int n = FROMCHAR(button, state->par.id);
+        int i, buflen;
+        char *movebuf;
+
+        if (button == CURSOR_SELECT2 || button == '\b')
+            n = 0;
+
+        for (i = 0; i < ui->odn; i++) {
+            int x = state->sequence[ui->ohx + i*ui->odx];
+            int y = state->sequence[ui->ohy + i*ui->ody];
+            int index = y*w+x;
+
+            /*
+             * Can't make pencil marks in a filled square. This can only
+             * become highlighted if we're using cursor keys.
+             */
+            if (ui->hpencil && state->grid[index])
+                return NULL;
+
+            /*
+             * Can't do anything to an immutable square. Exception:
+             * trying to set it to what it already was is OK (so that
+             * multifilling can set a whole diagonal to a without
+             * having to detour round the one immutable square in the
+             * middle that already said a).
+             */
+            if (!ui->hpencil && state->grid[index] == n)
+                /* OK even if it is immutable */;
+            else if (state->immutable[index])
+                return NULL;
+        }
+
+        movebuf = snewn(80 * ui->odn, char);
+        buflen = sprintf(movebuf, "%c%d,%d,%d",
+                         (char)(ui->hpencil && n > 0 ? 'P' : 'R'),
+                         ui->hx, ui->hy, n);
+        for (i = 1; i < ui->odn; i++) {
+            assert(buflen < i*80);
+            buflen += sprintf(movebuf + buflen, "+%d,%d",
+                              state->sequence[ui->ohx + i*ui->odx],
+                              state->sequence[ui->ohy + i*ui->ody]);
+        }
+        movebuf = sresize(movebuf, buflen+1, char);
+
+        if (!ui->hcursor) ui->hshow = 0;
+
+        return movebuf;
+    }
+
+    if (button == 'M' || button == 'm')
+        return dupstr("M");
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *from, const char *move)
+{
+    int w = from->par.w, a = w*w;
+    game_state *ret;
+    int x, y, i, j, n, pos;
+
+    if (move[0] == 'S') {
+        ret = dup_game(from);
+        ret->completed = ret->cheated = TRUE;
+
+        for (i = 0; i < a; i++) {
+            if (!ISCHAR(move[i+1]) || FROMCHAR(move[i+1], from->par.id) > w) {
+                free_game(ret);
+                return NULL;
+            }
+            ret->grid[i] = FROMCHAR(move[i+1], from->par.id);
+            ret->pencil[i] = 0;
+        }
+
+        if (move[a+1] != '\0') {
+            free_game(ret);
+            return NULL;
+        }
+
+        return ret;
+    } else if ((move[0] == 'P' || move[0] == 'R') &&
+               sscanf(move+1, "%d,%d,%d%n", &x, &y, &n, &pos) == 3 &&
+               n >= 0 && n <= w) {
+        const char *mp = move + 1 + pos;
+        int pencil = (move[0] == 'P');
+        ret = dup_game(from);
+
+        while (1) {
+            if (x < 0 || x >= w || y < 0 || y >= w) {
+                free_game(ret);
+                return NULL;
+            }
+            if (from->immutable[y*w+x] && !(!pencil && from->grid[y*w+x] == n))
+                return NULL;
+
+            if (move[0] == 'P' && n > 0) {
+                ret->pencil[y*w+x] ^= 1 << n;
+            } else {
+                ret->grid[y*w+x] = n;
+                ret->pencil[y*w+x] = 0;
+            }
+
+            if (!*mp)
+                break;
+
+            if (*mp != '+')
+                return NULL;
+            if (sscanf(mp, "+%d,%d%n", &x, &y, &pos) < 2)
+                return NULL;
+            mp += pos;
+        }
+
+        if (!ret->completed && !check_errors(ret, NULL))
+            ret->completed = TRUE;
+
+        return ret;
+    } else if (move[0] == 'M') {
+        /*
+         * Fill in absolutely all pencil marks everywhere. (I
+         * wouldn't use this for actual play, but it's a handy
+         * starting point when following through a set of
+         * diagnostics output by the standalone solver.)
+         */
+        ret = dup_game(from);
+        for (i = 0; i < a; i++) {
+            if (!ret->grid[i])
+                ret->pencil[i] = (1 << (w+1)) - (1 << 1);
+        }
+        return ret;
+    } else if (move[0] == 'D' &&
+               sscanf(move+1, "%d,%d", &x, &y) == 2) {
+        /*
+         * Reorder the rows and columns so that digit x is in position
+         * y.
+         */
+        ret = dup_game(from);
+        for (i = j = 0; i < w; i++) {
+            if (i == y) {
+                ret->sequence[i] = x;
+            } else {
+                if (from->sequence[j] == x)
+                    j++;
+                ret->sequence[i] = from->sequence[j++];
+            }
+        }
+        /*
+         * Eliminate any obsoleted dividers.
+         */
+        for (x = 0; x < w; x++) {
+            int i = ret->sequence[x];
+            int j = (x+1 < w ? ret->sequence[x+1] : -1);
+            if (ret->dividers[i] != j)
+                ret->dividers[i] = -1;
+        }
+        return ret;
+    } else if (move[0] == 'V' &&
+               sscanf(move+1, "%d,%d", &i, &j) == 2) {
+        ret = dup_game(from);
+        if (ret->dividers[i] == j)
+            ret->dividers[i] = -1;
+        else
+            ret->dividers[i] = j;
+        return ret;
+    } else
+        return NULL;                   /* couldn't parse move string */
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+#define SIZE(w) ((w) * TILESIZE + 2*BORDER + LEGEND)
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = *y = SIZE(params->w);
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    ret[COL_GRID * 3 + 0] = 0.0F;
+    ret[COL_GRID * 3 + 1] = 0.0F;
+    ret[COL_GRID * 3 + 2] = 0.0F;
+
+    ret[COL_USER * 3 + 0] = 0.0F;
+    ret[COL_USER * 3 + 1] = 0.6F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_USER * 3 + 2] = 0.0F;
+
+    ret[COL_HIGHLIGHT * 3 + 0] = 0.78F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_HIGHLIGHT * 3 + 1] = 0.78F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_HIGHLIGHT * 3 + 2] = 0.78F * ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_PENCIL * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_PENCIL * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_PENCIL * 3 + 2] = ret[COL_BACKGROUND * 3 + 2];
+
+    ret[COL_DIAGONAL * 3 + 0] = 0.95F * ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_DIAGONAL * 3 + 1] = 0.95F * ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_DIAGONAL * 3 + 2] = 0.95F * ret[COL_BACKGROUND * 3 + 2];
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int w = state->par.w, a = w*w;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->w = w;
+    ds->par = state->par;              /* structure copy */
+    ds->tilesize = 0;
+    ds->started = FALSE;
+    ds->tiles = snewn(a, long);
+    ds->legend = snewn(w, long);
+    ds->pencil = snewn(a, long);
+    ds->errors = snewn(a, long);
+    ds->sequence = snewn(a, digit);
+    for (i = 0; i < a; i++)
+        ds->tiles[i] = ds->pencil[i] = -1;
+    for (i = 0; i < w; i++)
+        ds->legend[i] = -1;
+    ds->errtmp = snewn(a, long);
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->tiles);
+    sfree(ds->pencil);
+    sfree(ds->errors);
+    sfree(ds->errtmp);
+    sfree(ds->sequence);
+    sfree(ds);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds, int x, int y, long tile,
+                      long pencil, long error)
+{
+    int w = ds->w /* , a = w*w */;
+    int tx, ty, tw, th;
+    int cx, cy, cw, ch;
+    char str[64];
+
+    tx = BORDER + LEGEND + x * TILESIZE + 1;
+    ty = BORDER + LEGEND + y * TILESIZE + 1;
+
+    cx = tx;
+    cy = ty;
+    cw = tw = TILESIZE-1;
+    ch = th = TILESIZE-1;
+
+    if (tile & DF_LEGEND) {
+        cx += TILESIZE/10;
+        cy += TILESIZE/10;
+        cw -= TILESIZE/5;
+        ch -= TILESIZE/5;
+        tile |= DF_IMMUTABLE;
+    }
+
+    clip(dr, cx, cy, cw, ch);
+
+    /* background needs erasing */
+    draw_rect(dr, cx, cy, cw, ch,
+              (tile & DF_HIGHLIGHT) ? COL_HIGHLIGHT :
+              (x == y) ? COL_DIAGONAL : COL_BACKGROUND);
+
+    /* dividers */
+    if (tile & DF_DIVIDER_TOP)
+        draw_rect(dr, cx, cy, cw, 1, COL_GRID);
+    if (tile & DF_DIVIDER_BOT)
+        draw_rect(dr, cx, cy+ch-1, cw, 1, COL_GRID);
+    if (tile & DF_DIVIDER_LEFT)
+        draw_rect(dr, cx, cy, 1, ch, COL_GRID);
+    if (tile & DF_DIVIDER_RIGHT)
+        draw_rect(dr, cx+cw-1, cy, 1, ch, COL_GRID);
+
+    /* pencil-mode highlight */
+    if (tile & DF_HIGHLIGHT_PENCIL) {
+        int coords[6];
+        coords[0] = cx;
+        coords[1] = cy;
+        coords[2] = cx+cw/2;
+        coords[3] = cy;
+        coords[4] = cx;
+        coords[5] = cy+ch/2;
+        draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+    }
+
+    /* new number needs drawing? */
+    if (tile & DF_DIGIT_MASK) {
+        str[1] = '\0';
+        str[0] = TOCHAR(tile & DF_DIGIT_MASK, ds->par.id);
+        draw_text(dr, tx + TILESIZE/2, ty + TILESIZE/2,
+                  FONT_VARIABLE, TILESIZE/2, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                  (error & EF_LATIN) ? COL_ERROR :
+                  (tile & DF_IMMUTABLE) ? COL_GRID : COL_USER, str);
+
+        if (error & EF_LEFT_MASK) {
+            int a = (error >> (EF_LEFT_SHIFT+2*EF_DIGIT_SHIFT))&EF_DIGIT_MASK;
+            int b = (error >> (EF_LEFT_SHIFT+1*EF_DIGIT_SHIFT))&EF_DIGIT_MASK;
+            int c = (error >> (EF_LEFT_SHIFT                 ))&EF_DIGIT_MASK;
+            char buf[10];
+            sprintf(buf, "(%c%c)%c", TOCHAR(a, ds->par.id),
+                    TOCHAR(b, ds->par.id), TOCHAR(c, ds->par.id));
+            draw_text(dr, tx + TILESIZE/2, ty + TILESIZE/6,
+                      FONT_VARIABLE, TILESIZE/6, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                      COL_ERROR, buf);
+        }
+        if (error & EF_RIGHT_MASK) {
+            int a = (error >> (EF_RIGHT_SHIFT+2*EF_DIGIT_SHIFT))&EF_DIGIT_MASK;
+            int b = (error >> (EF_RIGHT_SHIFT+1*EF_DIGIT_SHIFT))&EF_DIGIT_MASK;
+            int c = (error >> (EF_RIGHT_SHIFT                 ))&EF_DIGIT_MASK;
+            char buf[10];
+            sprintf(buf, "%c(%c%c)", TOCHAR(a, ds->par.id),
+                    TOCHAR(b, ds->par.id), TOCHAR(c, ds->par.id));
+            draw_text(dr, tx + TILESIZE/2, ty + TILESIZE - TILESIZE/6,
+                      FONT_VARIABLE, TILESIZE/6, ALIGN_VCENTRE | ALIGN_HCENTRE,
+                      COL_ERROR, buf);
+        }
+    } else {
+        int i, j, npencil;
+        int pl, pr, pt, pb;
+        float bestsize;
+        int pw, ph, minph, pbest, fontsize;
+
+        /* Count the pencil marks required. */
+        for (i = 1, npencil = 0; i <= w; i++)
+            if (pencil & (1 << i))
+                npencil++;
+        if (npencil) {
+
+            minph = 2;
+
+            /*
+             * Determine the bounding rectangle within which we're going
+             * to put the pencil marks.
+             */
+            /* Start with the whole square */
+            pl = tx + GRIDEXTRA;
+            pr = pl + TILESIZE - GRIDEXTRA;
+            pt = ty + GRIDEXTRA;
+            pb = pt + TILESIZE - GRIDEXTRA;
+
+            /*
+             * We arrange our pencil marks in a grid layout, with
+             * the number of rows and columns adjusted to allow the
+             * maximum font size.
+             *
+             * So now we work out what the grid size ought to be.
+             */
+            bestsize = 0.0;
+            pbest = 0;
+            /* Minimum */
+            for (pw = 3; pw < max(npencil,4); pw++) {
+                float fw, fh, fs;
+
+                ph = (npencil + pw - 1) / pw;
+                ph = max(ph, minph);
+                fw = (pr - pl) / (float)pw;
+                fh = (pb - pt) / (float)ph;
+                fs = min(fw, fh);
+                if (fs > bestsize) {
+                    bestsize = fs;
+                    pbest = pw;
+                }
+            }
+            assert(pbest > 0);
+            pw = pbest;
+            ph = (npencil + pw - 1) / pw;
+            ph = max(ph, minph);
+
+            /*
+             * Now we've got our grid dimensions, work out the pixel
+             * size of a grid element, and round it to the nearest
+             * pixel. (We don't want rounding errors to make the
+             * grid look uneven at low pixel sizes.)
+             */
+            fontsize = min((pr - pl) / pw, (pb - pt) / ph);
+
+            /*
+             * Centre the resulting figure in the square.
+             */
+            pl = tx + (TILESIZE - fontsize * pw) / 2;
+            pt = ty + (TILESIZE - fontsize * ph) / 2;
+
+            /*
+             * Now actually draw the pencil marks.
+             */
+            for (i = 1, j = 0; i <= w; i++)
+                if (pencil & (1 << i)) {
+                    int dx = j % pw, dy = j / pw;
+
+                    str[1] = '\0';
+                    str[0] = TOCHAR(i, ds->par.id);
+                    draw_text(dr, pl + fontsize * (2*dx+1) / 2,
+                              pt + fontsize * (2*dy+1) / 2,
+                              FONT_VARIABLE, fontsize,
+                              ALIGN_VCENTRE | ALIGN_HCENTRE, COL_PENCIL, str);
+                    j++;
+                }
+        }
+    }
+
+    unclip(dr);
+
+    draw_update(dr, cx, cy, cw, ch);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->par.w /*, a = w*w */;
+    int x, y, i, j;
+
+    if (!ds->started) {
+        /*
+         * The initial contents of the window are not guaranteed and
+         * can vary with front ends. To be on the safe side, all
+         * games should start by drawing a big background-colour
+         * rectangle covering the whole window.
+         */
+        draw_rect(dr, 0, 0, SIZE(w), SIZE(w), COL_BACKGROUND);
+
+        /*
+         * Big containing rectangle.
+         */
+        draw_rect(dr, COORD(0) - GRIDEXTRA, COORD(0) - GRIDEXTRA,
+                  w*TILESIZE+1+GRIDEXTRA*2, w*TILESIZE+1+GRIDEXTRA*2,
+                  COL_GRID);
+
+        draw_update(dr, 0, 0, SIZE(w), SIZE(w));
+
+        ds->started = TRUE;
+    }
+
+    check_errors(state, ds->errtmp);
+
+    /*
+     * Construct a modified version of state->sequence which takes
+     * into account an unfinished drag operation.
+     */
+    if (ui->drag) {
+        x = ui->dragnum;
+        y = ui->dragpos;
+    } else {
+        x = y = -1;
+    }
+    for (i = j = 0; i < w; i++) {
+        if (i == y) {
+            ds->sequence[i] = x;
+        } else {
+            if (state->sequence[j] == x)
+                j++;
+            ds->sequence[i] = state->sequence[j++];
+        }
+    }
+
+    /*
+     * Draw the table legend.
+     */
+    for (x = 0; x < w; x++) {
+        int sx = ds->sequence[x];
+        long tile = (sx+1) | DF_LEGEND;
+        if (ds->legend[x] != tile) {
+            ds->legend[x] = tile;
+            draw_tile(dr, ds, -1, x, tile, 0, 0);
+            draw_tile(dr, ds, x, -1, tile, 0, 0);
+        }
+    }
+
+    for (y = 0; y < w; y++) {
+        int sy = ds->sequence[y];
+        for (x = 0; x < w; x++) {
+            long tile = 0L, pencil = 0L, error;
+            int sx = ds->sequence[x];
+
+            if (state->grid[sy*w+sx])
+                tile = state->grid[sy*w+sx];
+            else
+                pencil = (long)state->pencil[sy*w+sx];
+
+            if (state->immutable[sy*w+sx])
+                tile |= DF_IMMUTABLE;
+
+            if ((ui->drag == 5 && ui->dragnum == sy) ||
+                (ui->drag == 6 && ui->dragnum == sx)) {
+                tile |= DF_HIGHLIGHT;
+            } else if (ui->hshow) {
+                int i = abs(x - ui->ohx);
+                int highlight = 0;
+                if (ui->odn > 1) {
+                    /*
+                     * When a diagonal multifill selection is shown,
+                     * we show it in its original grid position
+                     * regardless of in-progress row/col drags. Moving
+                     * every square about would be horrible.
+                     */
+                    if (i >= 0 && i < ui->odn &&
+                        x == ui->ohx + i*ui->odx &&
+                        y == ui->ohy + i*ui->ody)
+                        highlight = 1;
+                } else {
+                    /*
+                     * For a single square, we move its highlight
+                     * around with the drag.
+                     */
+                    highlight = (ui->hx == sx && ui->hy == sy);
+                }
+                if (highlight)
+                    tile |= (ui->hpencil ? DF_HIGHLIGHT_PENCIL : DF_HIGHLIGHT);
+            }
+
+            if (flashtime > 0 &&
+                (flashtime <= FLASH_TIME/3 ||
+                 flashtime >= FLASH_TIME*2/3))
+                tile |= DF_HIGHLIGHT;  /* completion flash */
+
+            if (y <= 0 || state->dividers[ds->sequence[y-1]] == sy)
+                tile |= DF_DIVIDER_TOP;
+            if (y+1 >= w || state->dividers[sy] == ds->sequence[y+1])
+                tile |= DF_DIVIDER_BOT;
+            if (x <= 0 || state->dividers[ds->sequence[x-1]] == sx)
+                tile |= DF_DIVIDER_LEFT;
+            if (x+1 >= w || state->dividers[sx] == ds->sequence[x+1])
+                tile |= DF_DIVIDER_RIGHT;
+
+            error = ds->errtmp[sy*w+sx];
+
+            if (ds->tiles[y*w+x] != tile ||
+                ds->pencil[y*w+x] != pencil ||
+                ds->errors[y*w+x] != error) {
+                ds->tiles[y*w+x] = tile;
+                ds->pencil[y*w+x] = pencil;
+                ds->errors[y*w+x] = error;
+                draw_tile(dr, ds, x, y, tile, pencil, error);
+            }
+        }
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    if (state->completed)
+        return FALSE;
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * We use 9mm squares by default, like Solo.
+     */
+    game_compute_size(params, 900, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w = state->par.w;
+    int ink = print_mono_colour(dr, 0);
+    int x, y;
+
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    game_drawstate ads, *ds = &ads;
+    game_set_size(dr, ds, NULL, tilesize);
+
+    /*
+     * Border.
+     */
+    print_line_width(dr, 3 * TILESIZE / 40);
+    draw_rect_outline(dr, BORDER + LEGEND, BORDER + LEGEND,
+                      w*TILESIZE, w*TILESIZE, ink);
+
+    /*
+     * Legend on table.
+     */
+    for (x = 0; x < w; x++) {
+        char str[2];
+        str[1] = '\0';
+        str[0] = TOCHAR(x+1, state->par.id);
+        draw_text(dr, BORDER+LEGEND + x*TILESIZE + TILESIZE/2,
+                  BORDER + TILESIZE/2,
+                  FONT_VARIABLE, TILESIZE/2,
+                  ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str);
+        draw_text(dr, BORDER + TILESIZE/2,
+                  BORDER+LEGEND + x*TILESIZE + TILESIZE/2,
+                  FONT_VARIABLE, TILESIZE/2,
+                  ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str);
+    }
+
+    /*
+     * Main grid.
+     */
+    for (x = 1; x < w; x++) {
+        print_line_width(dr, TILESIZE / 40);
+        draw_line(dr, BORDER+LEGEND+x*TILESIZE, BORDER+LEGEND,
+                  BORDER+LEGEND+x*TILESIZE, BORDER+LEGEND+w*TILESIZE, ink);
+    }
+    for (y = 1; y < w; y++) {
+        print_line_width(dr, TILESIZE / 40);
+        draw_line(dr, BORDER+LEGEND, BORDER+LEGEND+y*TILESIZE,
+                  BORDER+LEGEND+w*TILESIZE, BORDER+LEGEND+y*TILESIZE, ink);
+    }
+
+    /*
+     * Numbers.
+     */
+    for (y = 0; y < w; y++)
+        for (x = 0; x < w; x++)
+            if (state->grid[y*w+x]) {
+                char str[2];
+                str[1] = '\0';
+                str[0] = TOCHAR(state->grid[y*w+x], state->par.id);
+                draw_text(dr, BORDER+LEGEND + x*TILESIZE + TILESIZE/2,
+                          BORDER+LEGEND + y*TILESIZE + TILESIZE/2,
+                          FONT_VARIABLE, TILESIZE/2,
+                          ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str);
+            }
+}
+
+#ifdef COMBINED
+#define thegame group
+#endif
+
+const struct game thegame = {
+    "Group", NULL, NULL,
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    REQUIRE_RBUTTON | REQUIRE_NUMPAD,  /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+#include <stdarg.h>
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err;
+    digit *grid;
+    int grade = FALSE;
+    int ret, diff, really_show_working = FALSE;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "-v")) {
+            really_show_working = TRUE;
+        } else if (!strcmp(p, "-g")) {
+            grade = TRUE;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-g | -v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    grid = snewn(p->w * p->w, digit);
+
+    /*
+     * When solving a Normal puzzle, we don't want to bother the
+     * user with Hard-level deductions. For this reason, we grade
+     * the puzzle internally before doing anything else.
+     */
+    ret = -1;                          /* placate optimiser */
+    solver_show_working = FALSE;
+    for (diff = 0; diff < DIFFCOUNT; diff++) {
+        memcpy(grid, s->grid, p->w * p->w);
+        ret = solver(&s->par, grid, diff);
+        if (ret <= diff)
+            break;
+    }
+
+    if (diff == DIFFCOUNT) {
+        if (grade)
+            printf("Difficulty rating: ambiguous\n");
+        else
+            printf("Unable to find a unique solution\n");
+    } else {
+        if (grade) {
+            if (ret == diff_impossible)
+                printf("Difficulty rating: impossible (no solution exists)\n");
+            else
+                printf("Difficulty rating: %s\n", group_diffnames[ret]);
+        } else {
+            solver_show_working = really_show_working;
+            memcpy(grid, s->grid, p->w * p->w);
+            ret = solver(&s->par, grid, diff);
+            if (ret != diff)
+                printf("Puzzle is inconsistent\n");
+            else {
+                memcpy(s->grid, grid, p->w * p->w);
+                fputs(game_text_format(s), stdout);
+            }
+        }
+    }
+
+    return 0;
+}
+
+#endif
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/unfinished/group.gap b/apps/plugins/puzzles/unfinished/group.gap
new file mode 100644
index 0000000000..280adf4664
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/group.gap
@@ -0,0 +1,97 @@
+# run this file with
+#   gap -b -q < /dev/null group.gap | perl -pe 's/\\\n//s' | indent -kr
+
+Print("/* ----- data generated by group.gap begins ----- */\n\n");
+Print("struct group {\n    unsigned long autosize;\n");
+Print("    int order, ngens;\n    const char *gens;\n};\n");
+Print("struct groups {\n    int ngroups;\n");
+Print("    const struct group *groups;\n};\n\n");
+Print("static const struct group groupdata[] = {\n");
+offsets := [0];
+offset := 0;
+for n in [2..26] do
+  Print("    /* order ", n, " */\n");
+  for G in AllSmallGroups(n) do
+
+    # Construct a representation of the group G as a subgroup
+    # of a permutation group, and find its generators in that
+    # group.
+
+    # GAP has the 'IsomorphismPermGroup' function, but I don't want
+    # to use it because it doesn't guarantee that the permutation
+    # representation of the group forms a Cayley table. For example,
+    # C_4 could be represented as a subgroup of S_4 in many ways,
+    # and not all of them work: the group generated by (12) and (34)
+    # is clearly isomorphic to C_4 but its four elements do not form
+    # a Cayley table. The group generated by (12)(34) and (13)(24)
+    # is OK, though.
+    #
+    # Hence I construct the permutation representation _as_ the
+    # Cayley table, and then pick generators of that. This
+    # guarantees that when we rebuild the full group by BFS in
+    # group.c, we will end up with the right thing.
+
+    ge := Elements(G);
+    gi := [];
+    for g in ge do
+      gr := [];
+      for h in ge do
+        k := g*h;
+        for i in [1..n] do
+          if k = ge[i] then
+            Add(gr, i);
+          fi;
+        od;
+      od;
+      Add(gi, PermList(gr));
+    od;
+
+    # GAP has the 'GeneratorsOfGroup' function, but we don't want to
+    # use it because it's bad at picking generators - it thinks the
+    # generators of C_4 are [ (1,2)(3,4), (1,3,2,4) ] and that those
+    # of C_6 are [ (1,2,3)(4,5,6), (1,4)(2,5)(3,6) ] !
+
+    gl := ShallowCopy(Elements(gi));
+    Sort(gl, function(v,w) return Order(v) > Order(w); end);
+
+    gens := [];
+    for x in gl do
+      if gens = [] or not (x in gp) then
+        Add(gens, x);
+        gp := GroupWithGenerators(gens);
+      fi;
+    od;
+
+    # Construct the C representation of the group generators.
+    s := [];
+    for x in gens do
+      if Size(s) > 0 then
+        Add(s, '"');
+        Add(s, ' ');
+        Add(s, '"');
+      fi;
+      sep := "\\0";
+      for i in ListPerm(x) do
+        chars := "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        Add(s, chars[i]);
+      od;
+    od;
+    s := JoinStringsWithSeparator(["    {", String(Size(AutomorphismGroup(G))),
+                                   "L, ", String(Size(G)),
+                                   ", ", String(Size(gens)),
+                                   ", \"", s, "\"},\n"],"");
+    Print(s);
+    offset := offset + 1;
+  od;
+  Add(offsets, offset);
+od;
+Print("};\n\nstatic const struct groups groups[] = {\n");
+Print("    {0, NULL}, /* trivial case: 0 */\n");
+Print("    {0, NULL}, /* trivial case: 1 */\n");
+n := 2;
+for i in [1..Size(offsets)-1] do
+  Print("    {", offsets[i+1] - offsets[i], ", groupdata+",
+        offsets[i], "}, /* ", i+1, " */\n");
+od;
+Print("};\n\n/* ----- data generated by group.gap ends ----- */\n");
+quit;
diff --git a/apps/plugins/puzzles/unfinished/numgame.c b/apps/plugins/puzzles/unfinished/numgame.c
new file mode 100644
index 0000000000..aed5c17347
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/numgame.c
@@ -0,0 +1,1290 @@
+/*
+ * This program implements a breadth-first search which
+ * exhaustively solves the Countdown numbers game, and related
+ * games with slightly different rule sets such as `Flippo'.
+ * 
+ * Currently it is simply a standalone command-line utility to
+ * which you provide a set of numbers and it tells you everything
+ * it can make together with how many different ways it can be
+ * made. I would like ultimately to turn it into the generator for
+ * a Puzzles puzzle, but I haven't even started on writing a
+ * Puzzles user interface yet.
+ */
+
+/*
+ * TODO:
+ * 
+ *  - start thinking about difficulty ratings
+ *     + anything involving associative operations will be flagged
+ *       as many-paths because of the associative options (e.g.
+ *       2*3*4 can be (2*3)*4 or 2*(3*4), or indeed (2*4)*3). This
+ *       is probably a _good_ thing, since those are unusually
+ *       easy.
+ *     + tree-structured calculations ((a*b)/(c+d)) have multiple
+ *       paths because the independent branches of the tree can be
+ *       evaluated in either order, whereas straight-line
+ *       calculations with no branches will be considered easier.
+ *       Can we do anything about this? It's certainly not clear to
+ *       me that tree-structure calculations are _easier_, although
+ *       I'm also not convinced they're harder.
+ *     + I think for a realistic difficulty assessment we must also
+ *       consider the `obviousness' of the arithmetic operations in
+ *       some heuristic sense, and also (in Countdown) how many
+ *       numbers ended up being used.
+ *  - actually try some generations
+ *  - at this point we're probably ready to start on the Puzzles
+ *    integration.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <assert.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+
+/*
+ * To search for numbers we can make, we employ a breadth-first
+ * search across the space of sets of input numbers. That is, for
+ * example, we start with the set (3,6,25,50,75,100); we apply
+ * moves which involve combining two numbers (e.g. adding the 50
+ * and the 75 takes us to the set (3,6,25,100,125); and then we see
+ * if we ever end up with a set containing (say) 952.
+ * 
+ * If the rules are changed so that all the numbers must be used,
+ * this is easy to adjust to: we simply see if we end up with a set
+ * containing _only_ (say) 952.
+ * 
+ * Obviously, we can vary the rules about permitted arithmetic
+ * operations simply by altering the set of valid moves in the bfs.
+ * However, there's one common rule in this sort of puzzle which
+ * takes a little more thought, and that's _concatenation_. For
+ * example, if you are given (say) four 4s and required to make 10,
+ * you are permitted to combine two of the 4s into a 44 to begin
+ * with, making (44-4)/4 = 10. However, you are generally not
+ * allowed to concatenate two numbers that _weren't_ both in the
+ * original input set (you couldn't multiply two 4s to get 16 and
+ * then concatenate a 4 on to it to make 164), so concatenation is
+ * not an operation which is valid in all situations.
+ * 
+ * We could enforce this restriction by storing a flag alongside
+ * each number indicating whether or not it's an original number;
+ * the rules being that concatenation of two numbers is only valid
+ * if they both have the original flag, and that its output _also_
+ * has the original flag (so that you can concatenate three 4s into
+ * a 444), but that applying any other arithmetic operation clears
+ * the original flag on the output. However, we can get marginally
+ * simpler than that by observing that since concatenation has to
+ * happen to a number before any other operation, we can simply
+ * place all the concatenations at the start of the search. In
+ * other words, we have a global flag on an entire number _set_
+ * which indicates whether we are still permitted to perform
+ * concatenations; if so, we can concatenate any of the numbers in
+ * that set. Performing any other operation clears the flag.
+ */
+
+#define SETFLAG_CONCAT 1               /* we can do concatenation */
+
+struct sets;
+
+struct ancestor {
+    struct set *prev;                  /* index of ancestor set in set list */
+    unsigned char pa, pb, po, pr;      /* operation that got here from prev */
+};
+
+struct set {
+    int *numbers;                      /* rationals stored as n,d pairs */
+    short nnumbers;                    /* # of rationals, so half # of ints */
+    short flags;                       /* SETFLAG_CONCAT only, at present */
+    int npaths;                        /* number of ways to reach this set */
+    struct ancestor a;                 /* primary ancestor */
+    struct ancestor *as;               /* further ancestors, if we care */
+    int nas, assize;
+};
+
+struct output {
+    int number;
+    struct set *set;
+    int index;                         /* which number in the set is it? */
+    int npaths;                        /* number of ways to reach this */
+};
+
+#define SETLISTLEN 1024
+#define NUMBERLISTLEN 32768
+#define OUTPUTLISTLEN 1024
+struct operation;
+struct sets {
+    struct set **setlists;
+    int nsets, nsetlists, setlistsize;
+    tree234 *settree;
+    int **numberlists;
+    int nnumbers, nnumberlists, numberlistsize;
+    struct output **outputlists;
+    int noutputs, noutputlists, outputlistsize;
+    tree234 *outputtree;
+    const struct operation *const *ops;
+};
+
+#define OPFLAG_NEEDS_CONCAT 1
+#define OPFLAG_KEEPS_CONCAT 2
+#define OPFLAG_UNARY        4
+#define OPFLAG_UNARYPREFIX  8
+#define OPFLAG_FN           16
+
+struct operation {
+    /*
+     * Most operations should be shown in the output working, but
+     * concatenation should not; we just take the result of the
+     * concatenation and assume that it's obvious how it was
+     * derived.
+     */
+    int display;
+
+    /*
+     * Text display of the operator, in expressions and for
+     * debugging respectively.
+     */
+    char *text, *dbgtext;
+
+    /*
+     * Flags dictating when the operator can be applied.
+     */
+    int flags;
+
+    /*
+     * Priority of the operator (for avoiding unnecessary
+     * parentheses when formatting it into a string).
+     */
+    int priority;
+
+    /*
+     * Associativity of the operator. Bit 0 means we need parens
+     * when the left operand of one of these operators is another
+     * instance of it, e.g. (2^3)^4. Bit 1 means we need parens
+     * when the right operand is another instance of the same
+     * operator, e.g. 2-(3-4). Thus:
+     * 
+     *  - this field is 0 for a fully associative operator, since
+     *    we never need parens.
+     *  - it's 1 for a right-associative operator.
+     *  - it's 2 for a left-associative operator.
+     *  - it's 3 for a _non_-associative operator (which always
+     *    uses parens just to be sure).
+     */
+    int assoc;
+
+    /*
+     * Whether the operator is commutative. Saves time in the
+     * search if we don't have to try it both ways round.
+     */
+    int commutes;
+
+    /*
+     * Function which implements the operator. Returns TRUE on
+     * success, FALSE on failure. Takes two rationals and writes
+     * out a third.
+     */
+    int (*perform)(int *a, int *b, int *output);
+};
+
+struct rules {
+    const struct operation *const *ops;
+    int use_all;
+};
+
+#define MUL(r, a, b) do { \
+    (r) = (a) * (b); \
+    if ((b) && (a) && (r) / (b) != (a)) return FALSE; \
+} while (0)
+
+#define ADD(r, a, b) do { \
+    (r) = (a) + (b); \
+    if ((a) > 0 && (b) > 0 && (r) < 0) return FALSE; \
+    if ((a) < 0 && (b) < 0 && (r) > 0) return FALSE; \
+} while (0)
+
+#define OUT(output, n, d) do { \
+    int g = gcd((n),(d)); \
+    if (g < 0) g = -g; \
+    if ((d) < 0) g = -g; \
+    if (g == -1 && (n) < -INT_MAX) return FALSE; \
+    if (g == -1 && (d) < -INT_MAX) return FALSE; \
+    (output)[0] = (n)/g; \
+    (output)[1] = (d)/g; \
+    assert((output)[1] > 0); \
+} while (0)
+
+static int gcd(int x, int y)
+{
+    while (x != 0 && y != 0) {
+        int t = x;
+        x = y;
+        y = t % y;
+    }
+
+    return abs(x + y);                 /* i.e. whichever one isn't zero */
+}
+
+static int perform_add(int *a, int *b, int *output)
+{
+    int at, bt, tn, bn;
+    /*
+     * a0/a1 + b0/b1 = (a0*b1 + b0*a1) / (a1*b1)
+     */
+    MUL(at, a[0], b[1]);
+    MUL(bt, b[0], a[1]);
+    ADD(tn, at, bt);
+    MUL(bn, a[1], b[1]);
+    OUT(output, tn, bn);
+    return TRUE;
+}
+
+static int perform_sub(int *a, int *b, int *output)
+{
+    int at, bt, tn, bn;
+    /*
+     * a0/a1 - b0/b1 = (a0*b1 - b0*a1) / (a1*b1)
+     */
+    MUL(at, a[0], b[1]);
+    MUL(bt, b[0], a[1]);
+    ADD(tn, at, -bt);
+    MUL(bn, a[1], b[1]);
+    OUT(output, tn, bn);
+    return TRUE;
+}
+
+static int perform_mul(int *a, int *b, int *output)
+{
+    int tn, bn;
+    /*
+     * a0/a1 * b0/b1 = (a0*b0) / (a1*b1)
+     */
+    MUL(tn, a[0], b[0]);
+    MUL(bn, a[1], b[1]);
+    OUT(output, tn, bn);
+    return TRUE;
+}
+
+static int perform_div(int *a, int *b, int *output)
+{
+    int tn, bn;
+
+    /*
+     * Division by zero is outlawed.
+     */
+    if (b[0] == 0)
+        return FALSE;
+
+    /*
+     * a0/a1 / b0/b1 = (a0*b1) / (a1*b0)
+     */
+    MUL(tn, a[0], b[1]);
+    MUL(bn, a[1], b[0]);
+    OUT(output, tn, bn);
+    return TRUE;
+}
+
+static int perform_exact_div(int *a, int *b, int *output)
+{
+    int tn, bn;
+
+    /*
+     * Division by zero is outlawed.
+     */
+    if (b[0] == 0)
+        return FALSE;
+
+    /*
+     * a0/a1 / b0/b1 = (a0*b1) / (a1*b0)
+     */
+    MUL(tn, a[0], b[1]);
+    MUL(bn, a[1], b[0]);
+    OUT(output, tn, bn);
+
+    /*
+     * Exact division means we require the result to be an integer.
+     */
+    return (output[1] == 1);
+}
+
+static int max_p10(int n, int *p10_r)
+{
+    /*
+     * Find the smallest power of ten strictly greater than n.
+     *
+     * Special case: we must return at least 10, even if n is
+     * zero. (This is because this function is used for finding
+     * the power of ten by which to multiply a number being
+     * concatenated to the front of n, and concatenating 1 to 0
+     * should yield 10 and not 1.)
+     */
+    int p10 = 10;
+    while (p10 <= (INT_MAX/10) && p10 <= n)
+        p10 *= 10;
+    if (p10 > INT_MAX/10)
+        return FALSE;                  /* integer overflow */
+    *p10_r = p10;
+    return TRUE;
+}
+
+static int perform_concat(int *a, int *b, int *output)
+{
+    int t1, t2, p10;
+
+    /*
+     * We can't concatenate anything which isn't a non-negative
+     * integer.
+     */
+    if (a[1] != 1 || b[1] != 1 || a[0] < 0 || b[0] < 0)
+        return FALSE;
+
+    /*
+     * For concatenation, we can safely assume leading zeroes
+     * aren't an issue. It isn't clear whether they `should' be
+     * allowed, but it turns out not to matter: concatenating a
+     * leading zero on to a number in order to harmlessly get rid
+     * of the zero is never necessary because unwanted zeroes can
+     * be disposed of by adding them to something instead. So we
+     * disallow them always.
+     *
+     * The only other possibility is that you might want to
+     * concatenate a leading zero on to something and then
+     * concatenate another non-zero digit on to _that_ (to make,
+     * for example, 106); but that's also unnecessary, because you
+     * can make 106 just as easily by concatenating the 0 on to the
+     * _end_ of the 1 first.
+     */
+    if (a[0] == 0)
+        return FALSE;
+
+    if (!max_p10(b[0], &p10)) return FALSE;
+
+    MUL(t1, p10, a[0]);
+    ADD(t2, t1, b[0]);
+    OUT(output, t2, 1);
+    return TRUE;
+}
+
+#define IPOW(ret, x, y) do { \
+    int ipow_limit = (y); \
+    if ((x) == 1 || (x) == 0) ipow_limit = 1; \
+    else if ((x) == -1) ipow_limit &= 1; \
+    (ret) = 1; \
+    while (ipow_limit-- > 0) { \
+        int tmp; \
+        MUL(tmp, ret, x); \
+        ret = tmp; \
+    } \
+} while (0)
+
+static int perform_exp(int *a, int *b, int *output)
+{
+    int an, ad, xn, xd;
+
+    /*
+     * Exponentiation is permitted if the result is rational. This
+     * means that:
+     * 
+     *  - first we see whether we can take the (denominator-of-b)th
+     *    root of a and get a rational; if not, we give up.
+     * 
+     *  - then we do take that root of a
+     * 
+     *  - then we multiply by itself (numerator-of-b) times.
+     */
+    if (b[1] > 1) {
+        an = (int)(0.5 + pow(a[0], 1.0/b[1]));
+        ad = (int)(0.5 + pow(a[1], 1.0/b[1]));
+        IPOW(xn, an, b[1]);
+        IPOW(xd, ad, b[1]);
+        if (xn != a[0] || xd != a[1])
+            return FALSE;
+    } else {
+        an = a[0];
+        ad = a[1];
+    }
+    if (b[0] >= 0) {
+        IPOW(xn, an, b[0]);
+        IPOW(xd, ad, b[0]);
+    } else {
+        IPOW(xd, an, -b[0]);
+        IPOW(xn, ad, -b[0]);
+    }
+    if (xd == 0)
+        return FALSE;
+
+    OUT(output, xn, xd);
+    return TRUE;
+}
+
+static int perform_factorial(int *a, int *b, int *output)
+{
+    int ret, t, i;
+
+    /*
+     * Factorials of non-negative integers are permitted.
+     */
+    if (a[1] != 1 || a[0] < 0)
+        return FALSE;
+
+    /*
+     * However, a special case: we don't take a factorial of
+     * anything which would thereby remain the same.
+     */
+    if (a[0] == 1 || a[0] == 2)
+        return FALSE;
+
+    ret = 1;
+    for (i = 1; i <= a[0]; i++) {
+        MUL(t, ret, i);
+        ret = t;
+    }
+
+    OUT(output, ret, 1);
+    return TRUE;
+}
+
+static int perform_decimal(int *a, int *b, int *output)
+{
+    int p10;
+
+    /*
+     * Add a decimal digit to the front of a number;
+     * fail if it's not an integer.
+     * So, 1 --> 0.1, 15 --> 0.15,
+     * or, rather, 1 --> 1/10, 15 --> 15/100,
+     * x --> x / (smallest power of 10 > than x)
+     *
+     */
+    if (a[1] != 1) return FALSE;
+
+    if (!max_p10(a[0], &p10)) return FALSE;
+
+    OUT(output, a[0], p10);
+    return TRUE;
+}
+
+static int perform_recur(int *a, int *b, int *output)
+{
+    int p10, tn, bn;
+
+    /*
+     * This converts a number like .4 to .44444..., or .45 to .45454...
+     * The input number must be -1 < a < 1.
+     *
+     * Calculate the smallest power of 10 that divides the denominator exactly,
+     * returning if no such power of 10 exists. Then multiply the numerator
+     * up accordingly, and the new denominator becomes that power of 10 - 1.
+     */
+    if (abs(a[0]) >= abs(a[1])) return FALSE; /* -1 < a < 1 */
+
+    p10 = 10;
+    while (p10 <= (INT_MAX/10)) {
+        if ((a[1] <= p10) && (p10 % a[1]) == 0) goto found;
+        p10 *= 10;
+    }
+    return FALSE;
+found:
+    tn = a[0] * (p10 / a[1]);
+    bn = p10 - 1;
+
+    OUT(output, tn, bn);
+    return TRUE;
+}
+
+static int perform_root(int *a, int *b, int *output)
+{
+    /*
+     * A root B is: 1           iff a == 0
+     *              B ^ (1/A)   otherwise
+     */
+    int ainv[2], res;
+
+    if (a[0] == 0) {
+        OUT(output, 1, 1);
+        return TRUE;
+    }
+
+    OUT(ainv, a[1], a[0]);
+    res = perform_exp(b, ainv, output);
+    return res;
+}
+
+static int perform_perc(int *a, int *b, int *output)
+{
+    if (a[0] == 0) return FALSE; /* 0% = 0, uninteresting. */
+    if (a[1] > (INT_MAX/100)) return FALSE;
+
+    OUT(output, a[0], a[1]*100);
+    return TRUE;
+}
+
+static int perform_gamma(int *a, int *b, int *output)
+{
+    int asub1[2];
+
+    /*
+     * gamma(a) = (a-1)!
+     *
+     * special case not caught by perform_fact: gamma(1) is 1 so
+     * don't bother.
+     */
+    if (a[0] == 1 && a[1] == 1) return FALSE;
+
+    OUT(asub1, a[0]-a[1], a[1]);
+    return perform_factorial(asub1, b, output);
+}
+
+static int perform_sqrt(int *a, int *b, int *output)
+{
+    int half[2] = { 1, 2 };
+
+    /*
+     * sqrt(0) == 0, sqrt(1) == 1: don't perform unary noops.
+     */
+    if (a[0] == 0 || (a[0] == 1 && a[1] == 1)) return FALSE;
+
+    return perform_exp(a, half, output);
+}
+
+const static struct operation op_add = {
+    TRUE, "+", "+", 0, 10, 0, TRUE, perform_add
+};
+const static struct operation op_sub = {
+    TRUE, "-", "-", 0, 10, 2, FALSE, perform_sub
+};
+const static struct operation op_mul = {
+    TRUE, "*", "*", 0, 20, 0, TRUE, perform_mul
+};
+const static struct operation op_div = {
+    TRUE, "/", "/", 0, 20, 2, FALSE, perform_div
+};
+const static struct operation op_xdiv = {
+    TRUE, "/", "/", 0, 20, 2, FALSE, perform_exact_div
+};
+const static struct operation op_concat = {
+    FALSE, "", "concat", OPFLAG_NEEDS_CONCAT | OPFLAG_KEEPS_CONCAT,
+        1000, 0, FALSE, perform_concat
+};
+const static struct operation op_exp = {
+    TRUE, "^", "^", 0, 30, 1, FALSE, perform_exp
+};
+const static struct operation op_factorial = {
+    TRUE, "!", "!", OPFLAG_UNARY, 40, 0, FALSE, perform_factorial
+};
+const static struct operation op_decimal = {
+    TRUE, ".", ".", OPFLAG_UNARY | OPFLAG_UNARYPREFIX | OPFLAG_NEEDS_CONCAT | OPFLAG_KEEPS_CONCAT, 50, 0, FALSE, perform_decimal
+};
+const static struct operation op_recur = {
+    TRUE, "...", "recur", OPFLAG_UNARY | OPFLAG_NEEDS_CONCAT, 45, 2, FALSE, perform_recur
+};
+const static struct operation op_root = {
+    TRUE, "v~", "root", 0, 30, 1, FALSE, perform_root
+};
+const static struct operation op_perc = {
+    TRUE, "%", "%", OPFLAG_UNARY | OPFLAG_NEEDS_CONCAT, 45, 1, FALSE, perform_perc
+};
+const static struct operation op_gamma = {
+    TRUE, "gamma", "gamma", OPFLAG_UNARY | OPFLAG_UNARYPREFIX | OPFLAG_FN, 1, 3, FALSE, perform_gamma
+};
+const static struct operation op_sqrt = {
+    TRUE, "v~", "sqrt", OPFLAG_UNARY | OPFLAG_UNARYPREFIX, 30, 1, FALSE, perform_sqrt
+};
+
+/*
+ * In Countdown, divisions resulting in fractions are disallowed.
+ * http://www.askoxford.com/wordgames/countdown/rules/
+ */
+const static struct operation *const ops_countdown[] = {
+    &op_add, &op_mul, &op_sub, &op_xdiv, NULL
+};
+const static struct rules rules_countdown = {
+    ops_countdown, FALSE
+};
+
+/*
+ * A slightly different rule set which handles the reasonably well
+ * known puzzle of making 24 using two 3s and two 8s. For this we
+ * need rational rather than integer division.
+ */
+const static struct operation *const ops_3388[] = {
+    &op_add, &op_mul, &op_sub, &op_div, NULL
+};
+const static struct rules rules_3388 = {
+    ops_3388, TRUE
+};
+
+/*
+ * A still more permissive rule set usable for the four-4s problem
+ * and similar things. Permits concatenation.
+ */
+const static struct operation *const ops_four4s[] = {
+    &op_add, &op_mul, &op_sub, &op_div, &op_concat, NULL
+};
+const static struct rules rules_four4s = {
+    ops_four4s, TRUE
+};
+
+/*
+ * The most permissive ruleset I can think of. Permits
+ * exponentiation, and also silly unary operators like factorials.
+ */
+const static struct operation *const ops_anythinggoes[] = {
+    &op_add, &op_mul, &op_sub, &op_div, &op_concat, &op_exp, &op_factorial, 
+    &op_decimal, &op_recur, &op_root, &op_perc, &op_gamma, &op_sqrt, NULL
+};
+const static struct rules rules_anythinggoes = {
+    ops_anythinggoes, TRUE
+};
+
+#define ratcmp(a,op,b) ( (long long)(a)[0] * (b)[1] op \
+                         (long long)(b)[0] * (a)[1] )
+
+static int addtoset(struct set *set, int newnumber[2])
+{
+    int i, j;
+
+    /* Find where we want to insert the new number */
+    for (i = 0; i < set->nnumbers &&
+         ratcmp(set->numbers+2*i, <, newnumber); i++);
+
+    /* Move everything else up */
+    for (j = set->nnumbers; j > i; j--) {
+        set->numbers[2*j] = set->numbers[2*j-2];
+        set->numbers[2*j+1] = set->numbers[2*j-1];
+    }
+
+    /* Insert the new number */
+    set->numbers[2*i] = newnumber[0];
+    set->numbers[2*i+1] = newnumber[1];
+
+    set->nnumbers++;
+
+    return i;
+}
+
+#define ensure(array, size, newlen, type) do { \
+    if ((newlen) > (size)) { \
+        (size) = (newlen) + 512; \
+        (array) = sresize((array), (size), type); \
+    } \
+} while (0)
+
+static int setcmp(void *av, void *bv)
+{
+    struct set *a = (struct set *)av;
+    struct set *b = (struct set *)bv;
+    int i;
+
+    if (a->nnumbers < b->nnumbers)
+        return -1;
+    else if (a->nnumbers > b->nnumbers)
+        return +1;
+
+    if (a->flags < b->flags)
+        return -1;
+    else if (a->flags > b->flags)
+        return +1;
+
+    for (i = 0; i < a->nnumbers; i++) {
+        if (ratcmp(a->numbers+2*i, <, b->numbers+2*i))
+            return -1;
+        else if (ratcmp(a->numbers+2*i, >, b->numbers+2*i))
+            return +1;
+    }
+
+    return 0;
+}
+
+static int outputcmp(void *av, void *bv)
+{
+    struct output *a = (struct output *)av;
+    struct output *b = (struct output *)bv;
+
+    if (a->number < b->number)
+        return -1;
+    else if (a->number > b->number)
+        return +1;
+
+    return 0;
+}
+
+static int outputfindcmp(void *av, void *bv)
+{
+    int *a = (int *)av;
+    struct output *b = (struct output *)bv;
+
+    if (*a < b->number)
+        return -1;
+    else if (*a > b->number)
+        return +1;
+
+    return 0;
+}
+
+static void addset(struct sets *s, struct set *set, int multiple,
+                   struct set *prev, int pa, int po, int pb, int pr)
+{
+    struct set *s2;
+    int npaths = (prev ? prev->npaths : 1);
+
+    assert(set == s->setlists[s->nsets / SETLISTLEN] + s->nsets % SETLISTLEN);
+    s2 = add234(s->settree, set);
+    if (s2 == set) {
+        /*
+         * New set added to the tree.
+         */
+        set->a.prev = prev;
+        set->a.pa = pa;
+        set->a.po = po;
+        set->a.pb = pb;
+        set->a.pr = pr;
+        set->npaths = npaths;
+        s->nsets++;
+        s->nnumbers += 2 * set->nnumbers;
+        set->as = NULL;
+        set->nas = set->assize = 0;
+    } else {
+        /*
+         * Rediscovered an existing set. Update its npaths.
+         */
+        s2->npaths += npaths;
+        /*
+         * And optionally enter it as an additional ancestor.
+         */
+        if (multiple) {
+            if (s2->nas >= s2->assize) {
+                s2->assize = s2->nas * 3 / 2 + 4;
+                s2->as = sresize(s2->as, s2->assize, struct ancestor);
+            }
+            s2->as[s2->nas].prev = prev;
+            s2->as[s2->nas].pa = pa;
+            s2->as[s2->nas].po = po;
+            s2->as[s2->nas].pb = pb;
+            s2->as[s2->nas].pr = pr;
+            s2->nas++;
+        }
+    }
+}
+
+static struct set *newset(struct sets *s, int nnumbers, int flags)
+{
+    struct set *sn;
+
+    ensure(s->setlists, s->setlistsize, s->nsets/SETLISTLEN+1, struct set *);
+    while (s->nsetlists <= s->nsets / SETLISTLEN)
+        s->setlists[s->nsetlists++] = snewn(SETLISTLEN, struct set);
+    sn = s->setlists[s->nsets / SETLISTLEN] + s->nsets % SETLISTLEN;
+
+    if (s->nnumbers + nnumbers * 2 > s->nnumberlists * NUMBERLISTLEN)
+        s->nnumbers = s->nnumberlists * NUMBERLISTLEN;
+    ensure(s->numberlists, s->numberlistsize,
+           s->nnumbers/NUMBERLISTLEN+1, int *);
+    while (s->nnumberlists <= s->nnumbers / NUMBERLISTLEN)
+        s->numberlists[s->nnumberlists++] = snewn(NUMBERLISTLEN, int);
+    sn->numbers = s->numberlists[s->nnumbers / NUMBERLISTLEN] +
+        s->nnumbers % NUMBERLISTLEN;
+
+    /*
+     * Start the set off empty.
+     */
+    sn->nnumbers = 0;
+
+    sn->flags = flags;
+
+    return sn;
+}
+
+static int addoutput(struct sets *s, struct set *ss, int index, int *n)
+{
+    struct output *o, *o2;
+
+    /*
+     * Target numbers are always integers.
+     */
+    if (ss->numbers[2*index+1] != 1)
+        return FALSE;
+
+    ensure(s->outputlists, s->outputlistsize, s->noutputs/OUTPUTLISTLEN+1,
+           struct output *);
+    while (s->noutputlists <= s->noutputs / OUTPUTLISTLEN)
+        s->outputlists[s->noutputlists++] = snewn(OUTPUTLISTLEN,
+                                                  struct output);
+    o = s->outputlists[s->noutputs / OUTPUTLISTLEN] +
+        s->noutputs % OUTPUTLISTLEN;
+
+    o->number = ss->numbers[2*index];
+    o->set = ss;
+    o->index = index;
+    o->npaths = ss->npaths;
+    o2 = add234(s->outputtree, o);
+    if (o2 != o) {
+        o2->npaths += o->npaths;
+    } else {
+        s->noutputs++;
+    }
+    *n = o->number;
+    return TRUE;
+}
+
+static struct sets *do_search(int ninputs, int *inputs,
+                              const struct rules *rules, int *target,
+                              int debug, int multiple)
+{
+    struct sets *s;
+    struct set *sn;
+    int qpos, i;
+    const struct operation *const *ops = rules->ops;
+
+    s = snew(struct sets);
+    s->setlists = NULL;
+    s->nsets = s->nsetlists = s->setlistsize = 0;
+    s->numberlists = NULL;
+    s->nnumbers = s->nnumberlists = s->numberlistsize = 0;
+    s->outputlists = NULL;
+    s->noutputs = s->noutputlists = s->outputlistsize = 0;
+    s->settree = newtree234(setcmp);
+    s->outputtree = newtree234(outputcmp);
+    s->ops = ops;
+
+    /*
+     * Start with the input set.
+     */
+    sn = newset(s, ninputs, SETFLAG_CONCAT);
+    for (i = 0; i < ninputs; i++) {
+        int newnumber[2];
+        newnumber[0] = inputs[i];
+        newnumber[1] = 1;
+        addtoset(sn, newnumber);
+    }
+    addset(s, sn, multiple, NULL, 0, 0, 0, 0);
+
+    /*
+     * Now perform the breadth-first search: keep looping over sets
+     * until we run out of steam.
+     */
+    qpos = 0;
+    while (qpos < s->nsets) {
+        struct set *ss = s->setlists[qpos / SETLISTLEN] + qpos % SETLISTLEN;
+        struct set *sn;
+        int i, j, k, m;
+
+        if (debug) {
+            int i;
+            printf("processing set:");
+            for (i = 0; i < ss->nnumbers; i++) {
+                printf(" %d", ss->numbers[2*i]);
+                if (ss->numbers[2*i+1] != 1)
+                    printf("/%d", ss->numbers[2*i+1]);
+            }
+            printf("\n");
+        }
+
+        /*
+         * Record all the valid output numbers in this state. We
+         * can always do this if there's only one number in the
+         * state; otherwise, we can only do it if we aren't
+         * required to use all the numbers in coming to our answer.
+         */
+        if (ss->nnumbers == 1 || !rules->use_all) {
+            for (i = 0; i < ss->nnumbers; i++) {
+                int n;
+
+                if (addoutput(s, ss, i, &n) && target && n == *target)
+                    return s;
+            }
+        }
+
+        /*
+         * Try every possible operation from this state.
+         */
+        for (k = 0; ops[k] && ops[k]->perform; k++) {
+            if ((ops[k]->flags & OPFLAG_NEEDS_CONCAT) &&
+                !(ss->flags & SETFLAG_CONCAT))
+                continue;              /* can't use this operation here */
+            for (i = 0; i < ss->nnumbers; i++) {
+                int jlimit = (ops[k]->flags & OPFLAG_UNARY ? 1 : ss->nnumbers);
+                for (j = 0; j < jlimit; j++) {
+                    int n[2], newnn = ss->nnumbers;
+                    int pa, po, pb, pr;
+
+                    if (!(ops[k]->flags & OPFLAG_UNARY)) {
+                        if (i == j)
+                            continue;  /* can't combine a number with itself */
+                        if (i > j && ops[k]->commutes)
+                            continue;  /* no need to do this both ways round */
+                        newnn--;
+                    }
+                    if (!ops[k]->perform(ss->numbers+2*i, ss->numbers+2*j, n))
+                        continue;      /* operation failed */
+
+                    sn = newset(s, newnn, ss->flags);
+
+                    if (!(ops[k]->flags & OPFLAG_KEEPS_CONCAT))
+                        sn->flags &= ~SETFLAG_CONCAT;
+
+                    for (m = 0; m < ss->nnumbers; m++) {
+                        if (m == i || (!(ops[k]->flags & OPFLAG_UNARY) &&
+                                       m == j))
+                            continue;
+                        sn->numbers[2*sn->nnumbers] = ss->numbers[2*m];
+                        sn->numbers[2*sn->nnumbers + 1] = ss->numbers[2*m + 1];
+                        sn->nnumbers++;
+                    }
+                    pa = i;
+                    if (ops[k]->flags & OPFLAG_UNARY)
+                        pb = sn->nnumbers+10;
+                    else
+                        pb = j;
+                    po = k;
+                    pr = addtoset(sn, n);
+                    addset(s, sn, multiple, ss, pa, po, pb, pr);
+                    if (debug) {
+                        int i;
+                        if (ops[k]->flags & OPFLAG_UNARYPREFIX)
+                            printf("  %s %d ->", ops[po]->dbgtext, pa);
+                        else if (ops[k]->flags & OPFLAG_UNARY)
+                            printf("  %d %s ->", pa, ops[po]->dbgtext);
+                        else
+                            printf("  %d %s %d ->", pa, ops[po]->dbgtext, pb);
+                        for (i = 0; i < sn->nnumbers; i++) {
+                            printf(" %d", sn->numbers[2*i]);
+                            if (sn->numbers[2*i+1] != 1)
+                                printf("/%d", sn->numbers[2*i+1]);
+                        }
+                        printf("\n");
+                    }
+                }
+            }
+        }
+
+        qpos++;
+    }
+
+    return s;
+}
+
+static void free_sets(struct sets *s)
+{
+    int i;
+
+    freetree234(s->settree);
+    freetree234(s->outputtree);
+    for (i = 0; i < s->nsetlists; i++)
+        sfree(s->setlists[i]);
+    sfree(s->setlists);
+    for (i = 0; i < s->nnumberlists; i++)
+        sfree(s->numberlists[i]);
+    sfree(s->numberlists);
+    for (i = 0; i < s->noutputlists; i++)
+        sfree(s->outputlists[i]);
+    sfree(s->outputlists);
+    sfree(s);
+}
+
+/*
+ * Print a text formula for producing a given output.
+ */
+void print_recurse(struct sets *s, struct set *ss, int pathindex, int index,
+                   int priority, int assoc, int child);
+void print_recurse_inner(struct sets *s, struct set *ss,
+                         struct ancestor *a, int pathindex, int index,
+                         int priority, int assoc, int child)
+{
+    if (a->prev && index != a->pr) {
+        int pi;
+
+        /*
+         * This number was passed straight down from this set's
+         * predecessor. Find its index in the previous set and
+         * recurse to there.
+         */
+        pi = index;
+        assert(pi != a->pr);
+        if (pi > a->pr)
+            pi--;
+        if (pi >= min(a->pa, a->pb)) {
+            pi++;
+            if (pi >= max(a->pa, a->pb))
+                pi++;
+        }
+        print_recurse(s, a->prev, pathindex, pi, priority, assoc, child);
+    } else if (a->prev && index == a->pr &&
+               s->ops[a->po]->display) {
+        /*
+         * This number was created by a displayed operator in the
+         * transition from this set to its predecessor. Hence we
+         * write an open paren, then recurse into the first
+         * operand, then write the operator, then the second
+         * operand, and finally close the paren.
+         */
+        char *op;
+        int parens, thispri, thisassoc;
+
+        /*
+         * Determine whether we need parentheses.
+         */
+        thispri = s->ops[a->po]->priority;
+        thisassoc = s->ops[a->po]->assoc;
+        parens = (thispri < priority ||
+                  (thispri == priority && (assoc & child)));
+
+        if (parens)
+            putchar('(');
+
+        if (s->ops[a->po]->flags & OPFLAG_UNARYPREFIX)
+            for (op = s->ops[a->po]->text; *op; op++)
+                putchar(*op);
+
+        if (s->ops[a->po]->flags & OPFLAG_FN)
+            putchar('(');
+
+        print_recurse(s, a->prev, pathindex, a->pa, thispri, thisassoc, 1);
+
+        if (s->ops[a->po]->flags & OPFLAG_FN)
+            putchar(')');
+
+        if (!(s->ops[a->po]->flags & OPFLAG_UNARYPREFIX))
+            for (op = s->ops[a->po]->text; *op; op++)
+                putchar(*op);
+
+        if (!(s->ops[a->po]->flags & OPFLAG_UNARY))
+            print_recurse(s, a->prev, pathindex, a->pb, thispri, thisassoc, 2);
+
+        if (parens)
+            putchar(')');
+    } else {
+        /*
+         * This number is either an original, or something formed
+         * by a non-displayed operator (concatenation). Either way,
+         * we display it as is.
+         */
+        printf("%d", ss->numbers[2*index]);
+        if (ss->numbers[2*index+1] != 1)
+            printf("/%d", ss->numbers[2*index+1]);
+    }
+}
+void print_recurse(struct sets *s, struct set *ss, int pathindex, int index,
+                   int priority, int assoc, int child)
+{
+    if (!ss->a.prev || pathindex < ss->a.prev->npaths) {
+        print_recurse_inner(s, ss, &ss->a, pathindex,
+                            index, priority, assoc, child);
+    } else {
+        int i;
+        pathindex -= ss->a.prev->npaths;
+        for (i = 0; i < ss->nas; i++) {
+            if (pathindex < ss->as[i].prev->npaths) {
+                print_recurse_inner(s, ss, &ss->as[i], pathindex,
+                                    index, priority, assoc, child);
+                break;
+            }
+            pathindex -= ss->as[i].prev->npaths;
+        }
+    }
+}
+void print(int pathindex, struct sets *s, struct output *o)
+{
+    print_recurse(s, o->set, pathindex, o->index, 0, 0, 0);
+}
+
+/*
+ * gcc -g -O0 -o numgame numgame.c -I.. ../{malloc,tree234,nullfe}.c -lm
+ */
+int main(int argc, char **argv)
+{
+    int doing_opts = TRUE;
+    const struct rules *rules = NULL;
+    char *pname = argv[0];
+    int got_target = FALSE, target = 0;
+    int numbers[10], nnumbers = 0;
+    int verbose = FALSE;
+    int pathcounts = FALSE;
+    int multiple = FALSE;
+    int debug_bfs = FALSE;
+    int got_range = FALSE, rangemin = 0, rangemax = 0;
+
+    struct output *o;
+    struct sets *s;
+    int i, start, limit;
+
+    while (--argc) {
+        char *p = *++argv;
+        int c;
+
+        if (doing_opts && *p == '-') {
+            p++;
+
+            if (!strcmp(p, "-")) {
+                doing_opts = FALSE;
+                continue;
+            } else if (*p == '-') {
+                p++;
+                if (!strcmp(p, "debug-bfs")) {
+                    debug_bfs = TRUE;
+                } else {
+                    fprintf(stderr, "%s: option '--%s' not recognised\n",
+                            pname, p);
+                }
+            } else while (p && *p) switch (c = *p++) {
+              case 'C':
+                rules = &rules_countdown;
+                break;
+              case 'B':
+                rules = &rules_3388;
+                break;
+              case 'D':
+                rules = &rules_four4s;
+                break;
+              case 'A':
+                rules = &rules_anythinggoes;
+                break;
+              case 'v':
+                verbose = TRUE;
+                break;
+              case 'p':
+                pathcounts = TRUE;
+                break;
+              case 'm':
+                multiple = TRUE;
+                break;
+              case 't':
+              case 'r':
+                {
+                    char *v;
+                    if (*p) {
+                        v = p;
+                        p = NULL;
+                    } else if (--argc) {
+                        v = *++argv;
+                    } else {
+                        fprintf(stderr, "%s: option '-%c' expects an"
+                                " argument\n", pname, c);
+                        return 1;
+                    }
+                    switch (c) {
+                      case 't':
+                        got_target = TRUE;
+                        target = atoi(v);
+                        break;
+                      case 'r':
+                        {
+                             char *sep = strchr(v, '-');
+                             got_range = TRUE;
+                             if (sep) {
+                                 rangemin = atoi(v);
+                                 rangemax = atoi(sep+1);
+                             } else {
+                                 rangemin = 0;
+                                 rangemax = atoi(v);
+                             }
+                        }
+                        break;
+                    }
+                }
+                break;
+              default:
+                fprintf(stderr, "%s: option '-%c' not"
+                        " recognised\n", pname, c);
+                return 1;
+            }
+        } else {
+            if (nnumbers >= lenof(numbers)) {
+                fprintf(stderr, "%s: internal limit of %d numbers exceeded\n",
+                        pname, (int)lenof(numbers));
+                return 1;
+            } else {
+                numbers[nnumbers++] = atoi(p);
+            }
+        }
+    }
+
+    if (!rules) {
+        fprintf(stderr, "%s: no rule set specified; use -C,-B,-D,-A\n", pname);
+        return 1;
+    }
+
+    if (!nnumbers) {
+        fprintf(stderr, "%s: no input numbers specified\n", pname);
+        return 1;
+    }
+
+    if (got_range) {
+        if (got_target) {
+            fprintf(stderr, "%s: only one of -t and -r may be specified\n", pname);
+            return 1;
+        }
+        if (rangemin >= rangemax) {
+            fprintf(stderr, "%s: range not sensible (%d - %d)\n", pname, rangemin, rangemax);
+            return 1;
+        }
+    }
+
+    s = do_search(nnumbers, numbers, rules, (got_target ? &target : NULL),
+                  debug_bfs, multiple);
+
+    if (got_target) {
+        o = findrelpos234(s->outputtree, &target, outputfindcmp,
+                          REL234_LE, &start);
+        if (!o)
+            start = -1;
+        o = findrelpos234(s->outputtree, &target, outputfindcmp,
+                          REL234_GE, &limit);
+        if (!o)
+            limit = -1;
+        assert(start != -1 || limit != -1);
+        if (start == -1)
+            start = limit;
+        else if (limit == -1)
+            limit = start;
+        limit++;
+    } else if (got_range) {
+        if (!findrelpos234(s->outputtree, &rangemin, outputfindcmp,
+                           REL234_GE, &start) ||
+            !findrelpos234(s->outputtree, &rangemax, outputfindcmp,
+                           REL234_LE, &limit)) {
+            printf("No solutions available in specified range %d-%d\n", rangemin, rangemax);
+            return 1;
+        }
+        limit++;
+    } else {
+        start = 0;
+        limit = count234(s->outputtree);
+    }
+
+    for (i = start; i < limit; i++) {
+        char buf[256];
+
+        o = index234(s->outputtree, i);
+
+        sprintf(buf, "%d", o->number);
+
+        if (pathcounts)
+            sprintf(buf + strlen(buf), " [%d]", o->npaths);
+
+        if (got_target || verbose) {
+            int j, npaths;
+
+            if (multiple)
+                npaths = o->npaths;
+            else
+                npaths = 1;
+
+            for (j = 0; j < npaths; j++) {
+                printf("%s = ", buf);
+                print(j, s, o);
+                putchar('\n');
+            }
+        } else {
+            printf("%s\n", buf);
+        }
+    }
+
+    free_sets(s);
+
+    return 0;
+}
+
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/unfinished/path.c b/apps/plugins/puzzles/unfinished/path.c
new file mode 100644
index 0000000000..61d6c61c6a
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/path.c
@@ -0,0 +1,786 @@
+/*
+ * Experimental grid generator for Nikoli's `Number Link' puzzle.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "puzzles.h"
+
+/*
+ * 2005-07-08: This is currently a Path grid generator which will
+ * construct valid grids at a plausible speed. However, the grids
+ * are not of suitable quality to be used directly as puzzles.
+ * 
+ * The basic strategy is to start with an empty grid, and
+ * repeatedly either (a) add a new path to it, or (b) extend one
+ * end of a path by one square in some direction and push other
+ * paths into new shapes in the process. The effect of this is that
+ * we are able to construct a set of paths which between them fill
+ * the entire grid.
+ * 
+ * Quality issues: if we set the main loop to do (a) where possible
+ * and (b) only where necessary, we end up with a grid containing a
+ * few too many small paths, which therefore doesn't make for an
+ * interesting puzzle. If we reverse the priority so that we do (b)
+ * where possible and (a) only where necessary, we end up with some
+ * staggeringly interwoven grids with very very few separate paths,
+ * but the result of this is that there's invariably a solution
+ * other than the intended one which leaves many grid squares
+ * unfilled. There's also a separate problem which is that many
+ * grids have really boring and obvious paths in them, such as the
+ * entire bottom row of the grid being taken up by a single path.
+ * 
+ * It's not impossible that a few tweaks might eliminate or reduce
+ * the incidence of boring paths, and might also find a happy
+ * medium between too many and too few. There remains the question
+ * of unique solutions, however. I fear there is no alternative but
+ * to write - somehow! - a solver.
+ * 
+ * While I'm here, some notes on UI strategy for the parts of the
+ * puzzle implementation that _aren't_ the generator:
+ * 
+ *  - data model is to track connections between adjacent squares,
+ *    so that you aren't limited to extending a path out from each
+ *    number but can also mark sections of path which you know
+ *    _will_ come in handy later.
+ * 
+ *  - user interface is to click in one square and drag to an
+ *    adjacent one, thus creating a link between them. We can
+ *    probably tolerate rapid mouse motion causing a drag directly
+ *    to a square which is a rook move away, but any other rapid
+ *    motion is ambiguous and probably the best option is to wait
+ *    until the mouse returns to a square we know how to reach.
+ * 
+ *  - a drag causing the current path to backtrack has the effect
+ *    of removing bits of it.
+ * 
+ *  - the UI should enforce at all times the constraint that at
+ *    most two links can come into any square.
+ * 
+ *  - my Cunning Plan for actually implementing this: the game_ui
+ *    contains a grid-sized array, which is copied from the current
+ *    game_state on starting a drag. While a drag is active, the
+ *    contents of the game_ui is adjusted with every mouse motion,
+ *    and is displayed _in place_ of the game_state itself. On
+ *    termination of a drag, the game_ui array is copied back into
+ *    the new game_state (or rather, a string move is encoded which
+ *    has precisely the set of link changes to cause that effect).
+ */
+
+/*
+ * Standard notation for directions.
+ */
+#define L 0
+#define U 1
+#define R 2
+#define D 3
+#define DX(dir) ( (dir)==L ? -1 : (dir)==R ? +1 : 0)
+#define DY(dir) ( (dir)==U ? -1 : (dir)==D ? +1 : 0)
+
+/*
+ * Perform a breadth-first search over a grid of squares with the
+ * colour of square (X,Y) given by grid[Y*w+X]. The search begins
+ * at (x,y), and finds all squares which are the same colour as
+ * (x,y) and reachable from it by orthogonal moves. On return:
+ *  - dist[Y*w+X] gives the distance of (X,Y) from (x,y), or -1 if
+ *    unreachable or a different colour
+ *  - the returned value is the number of reachable squares,
+ *    including (x,y) itself
+ *  - list[0] up to list[returned value - 1] list those squares, in
+ *    increasing order of distance from (x,y) (and in arbitrary
+ *    order within that).
+ */
+static int bfs(int w, int h, int *grid, int x, int y, int *dist, int *list)
+{
+    int i, j, c, listsize, listdone;
+
+    /*
+     * Start by clearing the output arrays.
+     */
+    for (i = 0; i < w*h; i++)
+        dist[i] = list[i] = -1;
+
+    /*
+     * Set up the initial list.
+     */
+    listsize = 1;
+    listdone = 0;
+    list[0] = y*w+x;
+    dist[y*w+x] = 0;
+    c = grid[y*w+x];
+
+    /*
+     * Repeatedly process a square and add any extra squares to the
+     * end of list.
+     */
+    while (listdone < listsize) {
+        i = list[listdone++];
+        y = i / w;
+        x = i % w;
+        for (j = 0; j < 4; j++) {
+            int xx, yy, ii;
+
+            xx = x + DX(j);
+            yy = y + DY(j);
+            ii = yy*w+xx;
+
+            if (xx >= 0 && xx < w && yy >= 0 && yy < h &&
+                grid[ii] == c && dist[ii] == -1) {
+                dist[ii] = dist[i] + 1;
+                assert(listsize < w*h);
+                list[listsize++] = ii;
+            }
+        }
+    }
+
+    return listsize;
+}
+
+struct genctx {
+    int w, h;
+    int *grid, *sparegrid, *sparegrid2, *sparegrid3;
+    int *dist, *list;
+
+    int npaths, pathsize;
+    int *pathends, *sparepathends;     /* 2*npaths entries */
+    int *pathspare;                    /* npaths entries */
+    int *extends;                      /* 8*npaths entries */
+};
+
+static struct genctx *new_genctx(int w, int h)
+{
+    struct genctx *ctx = snew(struct genctx);
+    ctx->w = w;
+    ctx->h = h;
+    ctx->grid = snewn(w * h, int);
+    ctx->sparegrid = snewn(w * h, int);
+    ctx->sparegrid2 = snewn(w * h, int);
+    ctx->sparegrid3 = snewn(w * h, int);
+    ctx->dist = snewn(w * h, int);
+    ctx->list = snewn(w * h, int);
+    ctx->npaths = ctx->pathsize = 0;
+    ctx->pathends = ctx->sparepathends = ctx->pathspare = ctx->extends = NULL;
+    return ctx;
+}
+
+static void free_genctx(struct genctx *ctx)
+{
+    sfree(ctx->grid);
+    sfree(ctx->sparegrid);
+    sfree(ctx->sparegrid2);
+    sfree(ctx->sparegrid3);
+    sfree(ctx->dist);
+    sfree(ctx->list);
+    sfree(ctx->pathends);
+    sfree(ctx->sparepathends);
+    sfree(ctx->pathspare);
+    sfree(ctx->extends);
+}
+
+static int newpath(struct genctx *ctx)
+{
+    int n;
+
+    n = ctx->npaths++;
+    if (ctx->npaths > ctx->pathsize) {
+        ctx->pathsize += 16;
+        ctx->pathends = sresize(ctx->pathends, ctx->pathsize*2, int);
+        ctx->sparepathends = sresize(ctx->sparepathends, ctx->pathsize*2, int);
+        ctx->pathspare = sresize(ctx->pathspare, ctx->pathsize, int);
+        ctx->extends = sresize(ctx->extends, ctx->pathsize*8, int);
+    }
+    return n;
+}
+
+static int is_endpoint(struct genctx *ctx, int x, int y)
+{
+    int w = ctx->w, h = ctx->h, c;
+
+    assert(x >= 0 && x < w && y >= 0 && y < h);
+
+    c = ctx->grid[y*w+x];
+    if (c < 0)
+        return FALSE;                  /* empty square is not an endpoint! */
+    assert(c >= 0 && c < ctx->npaths);
+    if (ctx->pathends[c*2] == y*w+x || ctx->pathends[c*2+1] == y*w+x)
+        return TRUE;
+    return FALSE;
+}
+
+/*
+ * Tries to extend a path by one square in the given direction,
+ * pushing other paths around if necessary. Returns TRUE on success
+ * or FALSE on failure.
+ */
+static int extend_path(struct genctx *ctx, int path, int end, int direction)
+{
+    int w = ctx->w, h = ctx->h;
+    int x, y, xe, ye, cut;
+    int i, j, jp, n, first, last;
+
+    assert(path >= 0 && path < ctx->npaths);
+    assert(end == 0 || end == 1);
+
+    /*
+     * Find the endpoint of the path and the point we plan to
+     * extend it into.
+     */
+    y = ctx->pathends[path * 2 + end] / w;
+    x = ctx->pathends[path * 2 + end] % w;
+    assert(x >= 0 && x < w && y >= 0 && y < h);
+
+    xe = x + DX(direction);
+    ye = y + DY(direction);
+    if (xe < 0 || xe >= w || ye < 0 || ye >= h)
+        return FALSE;                  /* could not extend in this direction */
+
+    /*
+     * We don't extend paths _directly_ into endpoints of other
+     * paths, although we don't mind too much if a knock-on effect
+     * of an extension is to push part of another path into a third
+     * path's endpoint.
+     */
+    if (is_endpoint(ctx, xe, ye))
+        return FALSE;
+
+    /*
+     * We can't extend a path back the way it came.
+     */
+    if (ctx->grid[ye*w+xe] == path)
+        return FALSE;
+
+    /*
+     * Paths may not double back on themselves. Check if the new
+     * point is adjacent to any point of this path other than (x,y).
+     */
+    for (j = 0; j < 4; j++) {
+        int xf, yf;
+
+        xf = xe + DX(j);
+        yf = ye + DY(j);
+
+        if (xf >= 0 && xf < w && yf >= 0 && yf < h &&
+            (xf != x || yf != y) && ctx->grid[yf*w+xf] == path)
+            return FALSE;
+    }
+
+    /*
+     * Now we're convinced it's valid to _attempt_ the extension.
+     * It may still fail if we run out of space to push other paths
+     * into.
+     *
+     * So now we can set up our temporary data structures. We will
+     * need:
+     * 
+     *  - a spare copy of the grid on which to gradually move paths
+     *    around (sparegrid)
+     * 
+     *  - a second spare copy with which to remember how paths
+     *    looked just before being cut (sparegrid2). FIXME: is
+     *    sparegrid2 necessary? right now it's never different from
+     *    grid itself
+     * 
+     *  - a third spare copy with which to do the internal
+     *    calculations involved in reconstituting a cut path
+     *    (sparegrid3)
+     * 
+     *  - something to track which paths currently need
+     *    reconstituting after being cut, and which have already
+     *    been cut (pathspare)
+     * 
+     *  - a spare copy of pathends to store the altered states in
+     *    (sparepathends)
+     */
+    memcpy(ctx->sparegrid, ctx->grid, w*h*sizeof(int));
+    memcpy(ctx->sparegrid2, ctx->grid, w*h*sizeof(int));
+    memcpy(ctx->sparepathends, ctx->pathends, ctx->npaths*2*sizeof(int));
+    for (i = 0; i < ctx->npaths; i++)
+        ctx->pathspare[i] = 0;         /* 0=untouched, 1=broken, 2=fixed */
+
+    /*
+     * Working in sparegrid, actually extend the path. If it cuts
+     * another, begin a loop in which we restore any cut path by
+     * moving it out of the way.
+     */
+    cut = ctx->sparegrid[ye*w+xe];
+    ctx->sparegrid[ye*w+xe] = path;
+    ctx->sparepathends[path*2+end] = ye*w+xe;
+    ctx->pathspare[path] = 2;          /* this one is sacrosanct */
+    if (cut >= 0) {
+        assert(cut >= 0 && cut < ctx->npaths);
+        ctx->pathspare[cut] = 1;       /* broken */
+
+        while (1) {
+            for (i = 0; i < ctx->npaths; i++)
+                if (ctx->pathspare[i] == 1)
+                    break;
+            if (i == ctx->npaths)
+                break;                 /* we're done */
+
+            /*
+             * Path i needs restoring. So walk along its original
+             * track (as given in sparegrid2) and see where it's
+             * been cut. Where it has, surround the cut points in
+             * the same colour, without overwriting already-fixed
+             * paths.
+             */
+            memcpy(ctx->sparegrid3, ctx->sparegrid, w*h*sizeof(int));
+            n = bfs(w, h, ctx->sparegrid2,
+                    ctx->pathends[i*2] % w, ctx->pathends[i*2] / w,
+                    ctx->dist, ctx->list);
+            first = last = -1;
+if (ctx->sparegrid3[ctx->pathends[i*2]] != i ||
+    ctx->sparegrid3[ctx->pathends[i*2+1]] != i) return FALSE;/* FIXME */
+            for (j = 0; j < n; j++) {
+                jp = ctx->list[j];
+                assert(ctx->dist[jp] == j);
+                assert(ctx->sparegrid2[jp] == i);
+
+                /*
+                 * Wipe out the original path in sparegrid.
+                 */
+                if (ctx->sparegrid[jp] == i)
+                    ctx->sparegrid[jp] = -1;
+
+                /*
+                 * Be prepared to shorten the path at either end if
+                 * the endpoints have been stomped on.
+                 */
+                if (ctx->sparegrid3[jp] == i) {
+                    if (first < 0)
+                        first = jp;
+                    last = jp;
+                }
+
+                if (ctx->sparegrid3[jp] != i) {
+                    int jx = jp % w, jy = jp / w;
+                    int dx, dy;
+                    for (dy = -1; dy <= +1; dy++)
+                        for (dx = -1; dx <= +1; dx++) {
+                            int newp, newv;
+                            if (!dy && !dx)
+                                continue;   /* central square */
+                            if (jx+dx < 0 || jx+dx >= w ||
+                                jy+dy < 0 || jy+dy >= h)
+                                continue;   /* out of range */
+                            newp = (jy+dy)*w+(jx+dx);
+                            newv = ctx->sparegrid3[newp];
+                            if (newv >= 0 && (newv == i ||
+                                              ctx->pathspare[newv] == 2))
+                                continue;   /* can't use this square */
+                            ctx->sparegrid3[newp] = i;
+                        }
+                }
+            }
+
+            if (first < 0 || last < 0)
+                return FALSE;          /* path is completely wiped out! */
+
+            /*
+             * Now we've covered sparegrid3 in possible squares for
+             * the new layout of path i. Find the actual layout
+             * we're going to use by bfs: we want the shortest path
+             * from one endpoint to the other.
+             */
+            n = bfs(w, h, ctx->sparegrid3, first % w, first / w,
+                    ctx->dist, ctx->list);
+            if (ctx->dist[last] < 2) {
+                /*
+                 * Either there is no way to get between the path's
+                 * endpoints, or the remaining endpoints simply
+                 * aren't far enough apart to make the path viable
+                 * any more. This means the entire push operation
+                 * has failed.
+                 */
+                return FALSE;
+            }
+
+            /*
+             * Write the new path into sparegrid. Also save the new
+             * endpoint locations, in case they've changed.
+             */
+            jp = last;
+            j = ctx->dist[jp];
+            while (1) {
+                int d;
+
+                if (ctx->sparegrid[jp] >= 0) {
+                    if (ctx->pathspare[ctx->sparegrid[jp]] == 2)
+                        return FALSE;  /* somehow we've hit a fixed path */
+                    ctx->pathspare[ctx->sparegrid[jp]] = 1;   /* broken */
+                }
+                ctx->sparegrid[jp] = i;
+
+                if (j == 0)
+                    break;
+
+                /*
+                 * Now look at the neighbours of jp to find one
+                 * which has dist[] one less.
+                 */
+                for (d = 0; d < 4; d++) {
+                    int jx = (jp % w) + DX(d), jy = (jp / w) + DY(d);
+                    if (jx >= 0 && jx < w && jy >= 0 && jy < w &&
+                        ctx->dist[jy*w+jx] == j-1) {
+                        jp = jy*w+jx;
+                        j--;
+                        break;
+                    }
+                }
+                assert(d < 4);
+            }
+
+            ctx->sparepathends[i*2] = first;
+            ctx->sparepathends[i*2+1] = last;
+//printf("new ends of path %d: %d,%d\n", i, first, last);
+            ctx->pathspare[i] = 2;     /* fixed */
+        }
+    }
+
+    /*
+     * If we got here, the extension was successful!
+     */
+    memcpy(ctx->grid, ctx->sparegrid, w*h*sizeof(int));
+    memcpy(ctx->pathends, ctx->sparepathends, ctx->npaths*2*sizeof(int));
+    return TRUE;
+}
+
+/*
+ * Tries to add a new path to the grid.
+ */
+static int add_path(struct genctx *ctx, random_state *rs)
+{
+    int w = ctx->w, h = ctx->h;
+    int i, ii, n;
+
+    /*
+     * Our strategy is:
+     *  - randomly choose an empty square in the grid
+     *  - do a BFS from that point to find a long path starting
+     *    from it
+     *  - if we run out of viable empty squares, return failure.
+     */
+
+    /*
+     * Use `sparegrid' to collect a list of empty squares.
+     */
+    n = 0;
+    for (i = 0; i < w*h; i++)
+        if (ctx->grid[i] == -1)
+            ctx->sparegrid[n++] = i;
+
+    /*
+     * Shuffle the grid.
+     */
+    for (i = n; i-- > 1 ;) {
+        int k = random_upto(rs, i+1);
+        if (k != i) {
+            int t = ctx->sparegrid[i];
+            ctx->sparegrid[i] = ctx->sparegrid[k];
+            ctx->sparegrid[k] = t;
+        }
+    }
+
+    /*
+     * Loop over it trying to add paths. This looks like a
+     * horrifying N^4 algorithm (that is, (w*h)^2), but I predict
+     * that in fact the worst case will very rarely arise because
+     * when there's lots of grid space an attempt will succeed very
+     * quickly.
+     */
+    for (ii = 0; ii < n; ii++) {
+        int i = ctx->sparegrid[ii];
+        int y = i / w, x = i % w, nsq;
+        int r, c, j;
+
+        /*
+         * BFS from here to find long paths.
+         */
+        nsq = bfs(w, h, ctx->grid, x, y, ctx->dist, ctx->list);
+
+        /*
+         * If there aren't any long enough, give up immediately.
+         */
+        assert(nsq > 0);               /* must be the start square at least! */
+        if (ctx->dist[ctx->list[nsq-1]] < 3)
+            continue;
+
+        /*
+         * Find the first viable endpoint in ctx->list (i.e. the
+         * first point with distance at least three). I could
+         * binary-search for this, but that would be O(log N)
+         * whereas in fact I can get a constant time bound by just
+         * searching up from the start - after all, there can be at
+         * most 13 points at _less_ than distance 3 from the
+         * starting one!
+         */
+        for (j = 0; j < nsq; j++)
+            if (ctx->dist[ctx->list[j]] >= 3)
+                break;
+        assert(j < nsq);               /* we tested above that there was one */
+
+        /*
+         * Now we know that any element of `list' between j and nsq
+         * would be valid in principle. However, we want a few long
+         * paths rather than many small ones, so select only those
+         * elements which are either the maximum length or one
+         * below it.
+         */
+        while (ctx->dist[ctx->list[j]] + 1 < ctx->dist[ctx->list[nsq-1]])
+            j++;
+        r = j + random_upto(rs, nsq - j);
+        j = ctx->list[r];
+
+        /*
+         * And that's our endpoint. Mark the new path on the grid.
+         */
+        c = newpath(ctx);
+        ctx->pathends[c*2] = i;
+        ctx->pathends[c*2+1] = j;
+        ctx->grid[j] = c;
+        while (j != i) {
+            int d, np, index, pts[4];
+            np = 0;
+            for (d = 0; d < 4; d++) {
+                int xn = (j % w) + DX(d), yn = (j / w) + DY(d);
+                if (xn >= 0 && xn < w && yn >= 0 && yn < w &&
+                    ctx->dist[yn*w+xn] == ctx->dist[j] - 1)
+                    pts[np++] = yn*w+xn;
+            }
+            if (np > 1)
+                index = random_upto(rs, np);
+            else
+                index = 0;
+            j = pts[index];
+            ctx->grid[j] = c;
+        }
+
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+/*
+ * The main grid generation loop.
+ */
+static void gridgen_mainloop(struct genctx *ctx, random_state *rs)
+{
+    int w = ctx->w, h = ctx->h;
+    int i, n;
+
+    /*
+     * The generation algorithm doesn't always converge. Loop round
+     * until it does.
+     */
+    while (1) {
+        for (i = 0; i < w*h; i++)
+            ctx->grid[i] = -1;
+        ctx->npaths = 0;
+
+        while (1) {
+            /*
+             * See if the grid is full.
+             */
+            for (i = 0; i < w*h; i++)
+                if (ctx->grid[i] < 0)
+                    break;
+            if (i == w*h)
+                return;
+
+#ifdef GENERATION_DIAGNOSTICS
+            {
+                int x, y;
+                for (y = 0; y < h; y++) {
+                    printf("|");
+                    for (x = 0; x < w; x++) {
+                        if (ctx->grid[y*w+x] >= 0)
+                            printf("%2d", ctx->grid[y*w+x]);
+                        else
+                            printf(" .");
+                    }
+                    printf(" |\n");
+                }
+            }
+#endif
+            /*
+             * Try adding a path.
+             */
+            if (add_path(ctx, rs)) {
+#ifdef GENERATION_DIAGNOSTICS
+                printf("added path\n");
+#endif
+                continue;
+            }
+
+            /*
+             * Try extending a path. First list all the possible
+             * extensions.
+             */
+            for (i = 0; i < ctx->npaths * 8; i++)
+                ctx->extends[i] = i;
+            n = i;
+
+            /*
+             * Then shuffle the list.
+             */
+            for (i = n; i-- > 1 ;) {
+                int k = random_upto(rs, i+1);
+                if (k != i) {
+                    int t = ctx->extends[i];
+                    ctx->extends[i] = ctx->extends[k];
+                    ctx->extends[k] = t;
+                }
+            }
+
+            /*
+             * Now try each one in turn until one works.
+             */
+            for (i = 0; i < n; i++) {
+                int p, d, e;
+                p = ctx->extends[i];
+                d = p % 4;
+                p /= 4;
+                e = p % 2;
+                p /= 2;
+
+#ifdef GENERATION_DIAGNOSTICS
+                printf("trying to extend path %d end %d (%d,%d) in dir %d\n", p, e,
+                       ctx->pathends[p*2+e] % w,
+                       ctx->pathends[p*2+e] / w, d);
+#endif
+                if (extend_path(ctx, p, e, d)) {
+#ifdef GENERATION_DIAGNOSTICS
+                    printf("extended path %d end %d (%d,%d) in dir %d\n", p, e,
+                           ctx->pathends[p*2+e] % w,
+                           ctx->pathends[p*2+e] / w, d);
+#endif
+                    break;
+                }
+            }
+
+            if (i < n)
+                continue;
+
+            break;
+        }
+    }
+}
+
+/*
+ * Wrapper function which deals with the boring bits such as
+ * removing the solution from the generated grid, shuffling the
+ * numeric labels and creating/disposing of the context structure.
+ */
+static int *gridgen(int w, int h, random_state *rs)
+{
+    struct genctx *ctx;
+    int *ret;
+    int i;
+
+    ctx = new_genctx(w, h);
+
+    gridgen_mainloop(ctx, rs);
+
+    /*
+     * There is likely to be an ordering bias in the numbers
+     * (longer paths on lower numbers due to there having been more
+     * grid space when laying them down). So we must shuffle the
+     * numbers. We use ctx->pathspare for this.
+     * 
+     * This is also as good a time as any to shift to numbering
+     * from 1, for display to the user.
+     */
+    for (i = 0; i < ctx->npaths; i++)
+        ctx->pathspare[i] = i+1;
+    for (i = ctx->npaths; i-- > 1 ;) {
+        int k = random_upto(rs, i+1);
+        if (k != i) {
+            int t = ctx->pathspare[i];
+            ctx->pathspare[i] = ctx->pathspare[k];
+            ctx->pathspare[k] = t;
+        }
+    }
+
+    /* FIXME: remove this at some point! */
+    {
+        int y, x;
+        for (y = 0; y < h; y++) {
+            printf("|");
+            for (x = 0; x < w; x++) {
+                assert(ctx->grid[y*w+x] >= 0);
+                printf("%2d", ctx->pathspare[ctx->grid[y*w+x]]);
+            }
+            printf(" |\n");
+        }
+        printf("\n");
+    }
+
+    /*
+     * Clear the grid, and write in just the endpoints.
+     */
+    for (i = 0; i < w*h; i++)
+        ctx->grid[i] = 0;
+    for (i = 0; i < ctx->npaths; i++) {
+        ctx->grid[ctx->pathends[i*2]] =
+            ctx->grid[ctx->pathends[i*2+1]] = ctx->pathspare[i];
+    }
+
+    ret = ctx->grid;
+    ctx->grid = NULL;
+
+    free_genctx(ctx);
+
+    return ret;
+}
+
+#ifdef TEST_GEN
+
+#define TEST_GENERAL
+
+int main(void)
+{
+    int w = 10, h = 8;
+    random_state *rs = random_init("12345", 5);
+    int x, y, i, *grid;
+
+    for (i = 0; i < 10; i++) {
+        grid = gridgen(w, h, rs);
+
+        for (y = 0; y < h; y++) {
+            printf("|");
+            for (x = 0; x < w; x++) {
+                if (grid[y*w+x] > 0)
+                    printf("%2d", grid[y*w+x]);
+                else
+                    printf(" .");
+            }
+            printf(" |\n");
+        }
+        printf("\n");
+
+        sfree(grid);
+    }
+
+    return 0;
+}
+#endif
+
+#ifdef TEST_GENERAL
+#include <stdarg.h>
+
+void fatal(char *fmt, ...)
+{
+    va_list ap;
+
+    fprintf(stderr, "fatal error: ");
+
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+
+    fprintf(stderr, "\n");
+    exit(1);
+}
+#endif
diff --git a/apps/plugins/puzzles/unfinished/separate.R b/apps/plugins/puzzles/unfinished/separate.R
new file mode 100644
index 0000000000..f861c8f4fe
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/separate.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+SEPARATE_EXTRA = divvy dsf
+
+separate       : [X] GTK COMMON separate SEPARATE_EXTRA separate-icon|no-icon
+
+separate       : [G] WINDOWS COMMON separate SEPARATE_EXTRA separate.res|noicon.res
+
+ALL += separate[COMBINED] SEPARATE_EXTRA
+
+!begin am gtk
+GAMES += separate
+!end
+
+!begin >list.c
+    A(separate) \
+!end
+
+!begin >gamedesc.txt
+separate:separate.exe:Separate:Rectangle-dividing puzzle:Partition the grid into regions containing one of each letter.
+!end
diff --git a/apps/plugins/puzzles/unfinished/separate.c b/apps/plugins/puzzles/unfinished/separate.c
new file mode 100644
index 0000000000..898304a0e6
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/separate.c
@@ -0,0 +1,859 @@
+/*
+ * separate.c: Implementation of `Block Puzzle', a Japanese-only
+ * Nikoli puzzle seen at
+ *   http://www.nikoli.co.jp/ja/puzzles/block_puzzle/
+ * 
+ * It's difficult to be absolutely sure of the rules since online
+ * Japanese translators are so bad, but looking at the sample
+ * puzzle it seems fairly clear that the rules of this one are
+ * very simple. You have an mxn grid in which every square
+ * contains a letter, there are k distinct letters with k dividing
+ * mn, and every letter occurs the same number of times; your aim
+ * is to find a partition of the grid into disjoint k-ominoes such
+ * that each k-omino contains exactly one of each letter.
+ * 
+ * (It may be that Nikoli always have m,n,k equal to one another.
+ * However, I don't see that that's critical to the puzzle; k|mn
+ * is the only really important constraint, and even that could
+ * probably be dispensed with if some squares were marked as
+ * unused.)
+ */
+
+/*
+ * Current status: only the solver/generator is yet written, and
+ * although working in principle it's _very_ slow. It generates
+ * 5x5n5 or 6x6n4 readily enough, 6x6n6 with a bit of effort, and
+ * 7x7n7 only with a serious strain. I haven't dared try it higher
+ * than that yet.
+ * 
+ * One idea to speed it up is to implement more of the solver.
+ * Ideas I've so far had include:
+ * 
+ *  - Generalise the deduction currently expressed as `an
+ *    undersized chain with only one direction to extend must take
+ *    it'. More generally, the deduction should say `if all the
+ *    possible k-ominoes containing a given chain also contain
+ *    square x, then mark square x as part of that k-omino'.
+ *     + For example, consider this case:
+ * 
+ *         a ? b    This represents the top left of a board; the letters
+ *         ? ? ?    a,b,c do not represent the letters used in the puzzle,
+ *         c ? ?    but indicate that those three squares are known to be
+ *                  of different ominoes. Now if k >= 4, we can immediately
+ *         deduce that the square midway between b and c belongs to the
+ *         same omino as a, because there is no way we can make a 4-or-
+ *         more-omino containing a which does not also contain that square.
+ *         (Most easily seen by imagining cutting that square out of the 
+ *         grid; then, clearly, the omino containing a has only two
+ *         squares to expand into, and needs at least three.)
+ * 
+ *    The key difficulty with this mode of reasoning is
+ *    identifying such squares. I can't immediately think of a
+ *    simple algorithm for finding them on a wholesale basis.
+ * 
+ *  - Bfs out from a chain looking for the letters it lacks. For
+ *    example, in this situation (top three rows of a 7x7n7 grid):
+ * 
+ *        +-----------+-+
+ *        |E-A-F-B-C D|D|
+ *        +-------     ||
+ *        |E-C-G-D G|G E|
+ *        +-+---        |
+ *        |E|E G A B F A|
+ *
+ *    In this situation we can be sure that the top left chain
+ *    E-A-F-B-C does extend rightwards to the D, because there is
+ *    no other D within reach of that chain. Note also that the
+ *    bfs can skip squares which are known to belong to other
+ *    ominoes than this one.
+ * 
+ *    (This deduction, I fear, should only be used in an
+ *    emergency, because it relies on _all_ squares within range
+ *    of the bfs having particular values and so using it during
+ *    incremental generation rather nails down a lot of the grid.)
+ * 
+ * It's conceivable that another thing we could do would be to
+ * increase the flexibility in the grid generator: instead of
+ * nailing down the _value_ of any square depended on, merely nail
+ * down its equivalence to other squares. Unfortunately this turns
+ * the letter-selection phase of generation into a general graph
+ * colouring problem (we must draw a graph with equivalence
+ * classes of squares as the vertices, and an edge between any two
+ * vertices representing equivalence classes which contain squares
+ * that share an omino, and then k-colour the result) and hence
+ * requires recursion, which bodes ill for something we're doing
+ * that many times per generation.
+ * 
+ * I suppose a simple thing I could try would be tuning the retry
+ * count, just in case it's set too high or too low for efficient
+ * generation.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+enum {
+    COL_BACKGROUND,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h, k;
+};
+
+struct game_state {
+    int FIXME;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = ret->h = ret->k = 5;      /* FIXME: a bit bigger? */
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    return FALSE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->w = params->h = params->k = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        params->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 'n') {
+        string++;
+        params->k = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[256];
+    sprintf(buf, "%dx%dn%d", params->w, params->h, params->k);
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    return NULL;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    return NULL;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver and generator.
+ */
+
+struct solver_scratch {
+    int w, h, k;
+
+    /*
+     * Tracks connectedness between squares.
+     */
+    int *dsf;
+
+    /*
+     * size[dsf_canonify(dsf, yx)] tracks the size of the
+     * connected component containing yx.
+     */
+    int *size;
+
+    /*
+     * contents[dsf_canonify(dsf, yx)*k+i] tracks whether or not
+     * the connected component containing yx includes letter i. If
+     * the value is -1, it doesn't; otherwise its value is the
+     * index in the main grid of the square which contributes that
+     * letter to the component.
+     */
+    int *contents;
+
+    /*
+     * disconnect[dsf_canonify(dsf, yx1)*w*h + dsf_canonify(dsf, yx2)]
+     * tracks whether or not the connected components containing
+     * yx1 and yx2 are known to be distinct.
+     */
+    unsigned char *disconnect;
+
+    /*
+     * Temporary space used only inside particular solver loops.
+     */
+    int *tmp;
+};
+
+struct solver_scratch *solver_scratch_new(int w, int h, int k)
+{
+    int wh = w*h;
+    struct solver_scratch *sc = snew(struct solver_scratch);
+
+    sc->w = w;
+    sc->h = h;
+    sc->k = k;
+
+    sc->dsf = snew_dsf(wh);
+    sc->size = snewn(wh, int);
+    sc->contents = snewn(wh * k, int);
+    sc->disconnect = snewn(wh*wh, unsigned char);
+    sc->tmp = snewn(wh, int);
+
+    return sc;
+}
+
+void solver_scratch_free(struct solver_scratch *sc)
+{
+    sfree(sc->dsf);
+    sfree(sc->size);
+    sfree(sc->contents);
+    sfree(sc->disconnect);
+    sfree(sc->tmp);
+    sfree(sc);
+}
+
+void solver_connect(struct solver_scratch *sc, int yx1, int yx2)
+{
+    int w = sc->w, h = sc->h, k = sc->k;
+    int wh = w*h;
+    int i, yxnew;
+
+    yx1 = dsf_canonify(sc->dsf, yx1);
+    yx2 = dsf_canonify(sc->dsf, yx2);
+    assert(yx1 != yx2);
+
+    /*
+     * To connect two components together into a bigger one, we
+     * start by merging them in the dsf itself.
+     */
+    dsf_merge(sc->dsf, yx1, yx2);
+    yxnew = dsf_canonify(sc->dsf, yx2);
+
+    /*
+     * The size of the new component is the sum of the sizes of the
+     * old ones.
+     */
+    sc->size[yxnew] = sc->size[yx1] + sc->size[yx2];
+
+    /*
+     * The contents bitmap of the new component is the union of the
+     * contents of the old ones.
+     * 
+     * Given two numbers at most one of which is not -1, we can
+     * find the other one by adding the two and adding 1; this
+     * will yield -1 if both were -1 to begin with, otherwise the
+     * other.
+     * 
+     * (A neater approach would be to take their bitwise AND, but
+     * this is unfortunately not well-defined standard C when done
+     * to signed integers.)
+     */
+    for (i = 0; i < k; i++) {
+        assert(sc->contents[yx1*k+i] < 0 || sc->contents[yx2*k+i] < 0);
+        sc->contents[yxnew*k+i] = (sc->contents[yx1*k+i] +
+                                   sc->contents[yx2*k+i] + 1);
+    }
+
+    /*
+     * We must combine the rows _and_ the columns in the disconnect
+     * matrix.
+     */
+    for (i = 0; i < wh; i++)
+        sc->disconnect[yxnew*wh+i] = (sc->disconnect[yx1*wh+i] ||
+                                      sc->disconnect[yx2*wh+i]);
+    for (i = 0; i < wh; i++)
+        sc->disconnect[i*wh+yxnew] = (sc->disconnect[i*wh+yx1] ||
+                                      sc->disconnect[i*wh+yx2]);
+}
+
+void solver_disconnect(struct solver_scratch *sc, int yx1, int yx2)
+{
+    int w = sc->w, h = sc->h;
+    int wh = w*h;
+
+    yx1 = dsf_canonify(sc->dsf, yx1);
+    yx2 = dsf_canonify(sc->dsf, yx2);
+    assert(yx1 != yx2);
+    assert(!sc->disconnect[yx1*wh+yx2]);
+    assert(!sc->disconnect[yx2*wh+yx1]);
+
+    /*
+     * Mark the components as disconnected from each other in the
+     * disconnect matrix.
+     */
+    sc->disconnect[yx1*wh+yx2] = sc->disconnect[yx2*wh+yx1] = 1;
+}
+
+void solver_init(struct solver_scratch *sc)
+{
+    int w = sc->w, h = sc->h;
+    int wh = w*h;
+    int i;
+
+    /*
+     * Set up most of the scratch space. We don't set up the
+     * contents array, however, because this will change if we
+     * adjust the letter arrangement and re-run the solver.
+     */
+    dsf_init(sc->dsf, wh);
+    for (i = 0; i < wh; i++) sc->size[i] = 1;
+    memset(sc->disconnect, 0, wh*wh);
+}
+
+int solver_attempt(struct solver_scratch *sc, const unsigned char *grid,
+                   unsigned char *gen_lock)
+{
+    int w = sc->w, h = sc->h, k = sc->k;
+    int wh = w*h;
+    int i, x, y;
+    int done_something_overall = FALSE;
+
+    /*
+     * Set up the contents array from the grid.
+     */
+    for (i = 0; i < wh*k; i++)
+        sc->contents[i] = -1;
+    for (i = 0; i < wh; i++)
+        sc->contents[dsf_canonify(sc->dsf, i)*k+grid[i]] = i;
+
+    while (1) {
+        int done_something = FALSE;
+
+        /*
+         * Go over the grid looking for reasons to add to the
+         * disconnect matrix. We're after pairs of squares which:
+         * 
+         *  - are adjacent in the grid
+         *  - belong to distinct dsf components
+         *  - their components are not already marked as
+         *    disconnected
+         *  - their components share a letter in common.
+         */
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                int dir;
+                for (dir = 0; dir < 2; dir++) {
+                    int x2 = x + dir, y2 = y + 1 - dir;
+                    int yx = y*w+x, yx2 = y2*w+x2;
+
+                    if (x2 >= w || y2 >= h)
+                        continue;      /* one square is outside the grid */
+
+                    yx = dsf_canonify(sc->dsf, yx);
+                    yx2 = dsf_canonify(sc->dsf, yx2);
+                    if (yx == yx2)
+                        continue;      /* same dsf component */
+
+                    if (sc->disconnect[yx*wh+yx2])
+                        continue;      /* already known disconnected */
+
+                    for (i = 0; i < k; i++)
+                        if (sc->contents[yx*k+i] >= 0 &&
+                            sc->contents[yx2*k+i] >= 0)
+                            break;
+                    if (i == k)
+                        continue;      /* no letter in common */
+
+                    /*
+                     * We've found one. Mark yx and yx2 as
+                     * disconnected from each other.
+                     */
+#ifdef SOLVER_DIAGNOSTICS
+                    printf("Disconnecting %d and %d (%c)\n", yx, yx2, 'A'+i);
+#endif
+                    solver_disconnect(sc, yx, yx2);
+                    done_something = done_something_overall = TRUE;
+
+                    /*
+                     * We have just made a deduction which hinges
+                     * on two particular grid squares being the
+                     * same. If we are feeding back to a generator
+                     * loop, we must therefore mark those squares
+                     * as fixed in the generator, so that future
+                     * rearrangement of the grid will not break
+                     * the information on which we have already
+                     * based deductions.
+                     */
+                    if (gen_lock) {
+                        gen_lock[sc->contents[yx*k+i]] = 1;
+                        gen_lock[sc->contents[yx2*k+i]] = 1;
+                    }
+                }
+            }
+        }
+
+        /*
+         * Now go over the grid looking for dsf components which
+         * are below maximum size and only have one way to extend,
+         * and extending them.
+         */
+        for (i = 0; i < wh; i++)
+            sc->tmp[i] = -1;
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w; x++) {
+                int yx = dsf_canonify(sc->dsf, y*w+x);
+                int dir;
+
+                if (sc->size[yx] == k)
+                    continue;
+
+                for (dir = 0; dir < 4; dir++) {
+                    int x2 = x + (dir==0 ? -1 : dir==2 ? 1 : 0);
+                    int y2 = y + (dir==1 ? -1 : dir==3 ? 1 : 0);
+                    int yx2, yx2c;
+
+                    if (y2 < 0 || y2 >= h || x2 < 0 || x2 >= w)
+                        continue;
+                    yx2 = y2*w+x2;
+                    yx2c = dsf_canonify(sc->dsf, yx2);
+
+                    if (yx2c != yx && !sc->disconnect[yx2c*wh+yx]) {
+                        /*
+                         * Component yx can be extended into square
+                         * yx2.
+                         */
+                        if (sc->tmp[yx] == -1)
+                            sc->tmp[yx] = yx2;
+                        else if (sc->tmp[yx] != yx2)
+                            sc->tmp[yx] = -2;   /* multiple choices found */
+                    }
+                }
+            }
+        }
+        for (i = 0; i < wh; i++) {
+            if (sc->tmp[i] >= 0) {
+                /*
+                 * Make sure we haven't connected the two already
+                 * during this loop (which could happen if for
+                 * _both_ components this was the only way to
+                 * extend them).
+                 */
+                if (dsf_canonify(sc->dsf, i) ==
+                    dsf_canonify(sc->dsf, sc->tmp[i]))
+                    continue;
+
+#ifdef SOLVER_DIAGNOSTICS
+                printf("Connecting %d and %d\n", i, sc->tmp[i]);
+#endif
+                solver_connect(sc, i, sc->tmp[i]);
+                done_something = done_something_overall = TRUE;
+                break;
+            }
+        }
+
+        if (!done_something)
+            break;
+    }
+
+    /*
+     * Return 0 if we haven't made any progress; 1 if we've done
+     * something but not solved it completely; 2 if we've solved
+     * it completely.
+     */
+    for (i = 0; i < wh; i++)
+        if (sc->size[dsf_canonify(sc->dsf, i)] != k)
+            break;
+    if (i == wh)
+        return 2;
+    if (done_something_overall)
+        return 1;
+    return 0;
+}
+
+unsigned char *generate(int w, int h, int k, random_state *rs)
+{
+    int wh = w*h;
+    int n = wh/k;
+    struct solver_scratch *sc;
+    unsigned char *grid;
+    unsigned char *shuffled;
+    int i, j, m, retries;
+    int *permutation;
+    unsigned char *gen_lock;
+    extern int *divvy_rectangle(int w, int h, int k, random_state *rs);
+
+    sc = solver_scratch_new(w, h, k);
+    grid = snewn(wh, unsigned char);
+    shuffled = snewn(k, unsigned char);
+    permutation = snewn(wh, int);
+    gen_lock = snewn(wh, unsigned char);
+
+    do {
+        int *dsf = divvy_rectangle(w, h, k, rs);
+
+        /*
+         * Go through the dsf and find the indices of all the
+         * squares involved in each omino, in a manner conducive
+         * to per-omino indexing. We set permutation[i*k+j] to be
+         * the index of the jth square (ordered arbitrarily) in
+         * omino i.
+         */
+        for (i = j = 0; i < wh; i++)
+            if (dsf_canonify(dsf, i) == i) {
+                sc->tmp[i] = j;
+                /*
+                 * During this loop and the following one, we use
+                 * the last element of each row of permutation[]
+                 * as a counter of the number of indices so far
+                 * placed in it. When we place the final index of
+                 * an omino, that counter is overwritten, but that
+                 * doesn't matter because we'll never use it
+                 * again. Of course this depends critically on
+                 * divvy_rectangle() having returned correct
+                 * results, or else chaos would ensue.
+                 */
+                permutation[j*k+k-1] = 0;
+                j++;
+            }
+        for (i = 0; i < wh; i++) {
+            j = sc->tmp[dsf_canonify(dsf, i)];
+            m = permutation[j*k+k-1]++;
+            permutation[j*k+m] = i;
+        }
+
+        /*
+         * Track which squares' letters we have already depended
+         * on for deductions. This is gradually updated by
+         * solver_attempt().
+         */
+        memset(gen_lock, 0, wh);
+
+        /*
+         * Now repeatedly fill the grid with letters, and attempt
+         * to solve it. If the solver makes progress but does not
+         * fail completely, then gen_lock will have been updated
+         * and we try again. On a complete failure, though, we
+         * have no option but to give up and abandon this set of
+         * ominoes.
+         */
+        solver_init(sc);
+        retries = k*k;
+        while (1) {
+            /*
+             * Fill the grid with letters. We can safely use
+             * sc->tmp to hold the set of letters required at each
+             * stage, since it's at least size k and is currently
+             * unused.
+             */
+            for (i = 0; i < n; i++) {
+                /*
+                 * First, determine the set of letters already
+                 * placed in this omino by gen_lock.
+                 */
+                for (j = 0; j < k; j++)
+                    sc->tmp[j] = j;
+                for (j = 0; j < k; j++) {
+                    int index = permutation[i*k+j];
+                    int letter = grid[index];
+                    if (gen_lock[index])
+                        sc->tmp[letter] = -1;
+                }
+                /*
+                 * Now collect together all the remaining letters
+                 * and randomly shuffle them.
+                 */
+                for (j = m = 0; j < k; j++)
+                    if (sc->tmp[j] >= 0)
+                        sc->tmp[m++] = sc->tmp[j];
+                shuffle(sc->tmp, m, sizeof(*sc->tmp), rs);
+                /*
+                 * Finally, write the shuffled letters into the
+                 * grid.
+                 */
+                for (j = 0; j < k; j++) {
+                    int index = permutation[i*k+j];
+                    if (!gen_lock[index])
+                        grid[index] = sc->tmp[--m];
+                }
+                assert(m == 0);
+            }
+
+            /*
+             * Now we have a candidate grid. Attempt to progress
+             * the solution.
+             */
+            m = solver_attempt(sc, grid, gen_lock);
+            if (m == 2 ||              /* success */
+                (m == 0 && retries-- <= 0))   /* failure */
+                break;
+            if (m == 1)
+                retries = k*k;         /* reset this counter, and continue */
+        }
+
+        sfree(dsf);
+    } while (m == 0);
+
+    sfree(gen_lock);
+    sfree(permutation);
+    sfree(shuffled);
+    solver_scratch_free(sc);
+
+    return grid;
+}
+
+/* ----------------------------------------------------------------------
+ * End of solver/generator code.
+ */
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, h = params->h, wh = w*h, k = params->k;
+    unsigned char *grid;
+    char *desc;
+    int i;
+
+    grid = generate(w, h, k, rs);
+
+    desc = snewn(wh+1, char);
+    for (i = 0; i < wh; i++)
+        desc[i] = 'A' + grid[i];
+    desc[wh] = '\0';
+
+    sfree(grid);
+
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    game_state *state = snew(game_state);
+
+    state->FIXME = 0;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    game_state *ret = snew(game_state);
+
+    ret->FIXME = state->FIXME;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return NULL;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+static game_ui *new_ui(const game_state *state)
+{
+    return NULL;
+}
+
+static void free_ui(game_ui *ui)
+{
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int tilesize;
+    int FIXME;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    *x = *y = 10 * tilesize;           /* FIXME */
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    ds->tilesize = 0;
+    ds->FIXME = 0;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    /*
+     * The initial contents of the window are not guaranteed and
+     * can vary with front ends. To be on the safe side, all games
+     * should start by drawing a big background-colour rectangle
+     * covering the whole window.
+     */
+    draw_rect(dr, 0, 0, 10*ds->tilesize, 10*ds->tilesize, COL_BACKGROUND);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame separate
+#endif
+
+const struct game thegame = {
+    "Separate", NULL, NULL,
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    FALSE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    FALSE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    20 /* FIXME */, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
diff --git a/apps/plugins/puzzles/unfinished/slide.R b/apps/plugins/puzzles/unfinished/slide.R
new file mode 100644
index 0000000000..189ed652d1
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/slide.R
@@ -0,0 +1,24 @@
+# -*- makefile -*-
+
+SLIDE_EXTRA    = dsf tree234
+
+slide          : [X] GTK COMMON slide SLIDE_EXTRA slide-icon|no-icon
+
+slide          : [G] WINDOWS COMMON slide SLIDE_EXTRA slide.res|noicon.res
+
+slidesolver :   [U] slide[STANDALONE_SOLVER] SLIDE_EXTRA STANDALONE
+slidesolver :   [C] slide[STANDALONE_SOLVER] SLIDE_EXTRA STANDALONE
+
+ALL += slide[COMBINED] SLIDE_EXTRA
+
+!begin am gtk
+GAMES += slide
+!end
+
+!begin >list.c
+    A(slide) \
+!end
+
+!begin >gamedesc.txt
+slide:slide.exe:Slide:Sliding block puzzle:Slide the blocks to let the key block out.
+!end
diff --git a/apps/plugins/puzzles/unfinished/slide.c b/apps/plugins/puzzles/unfinished/slide.c
new file mode 100644
index 0000000000..b1aa04bc90
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/slide.c
@@ -0,0 +1,2445 @@
+/*
+ * slide.c: Implementation of the block-sliding puzzle `Klotski'.
+ */
+
+/*
+ * TODO:
+ * 
+ *  - Improve the generator.
+ *     * actually, we seem to be mostly sensible already now. I
+ *       want more choice over the type of main block and location
+ *       of the exit/target, and I think I probably ought to give
+ *       up on compactness and just bite the bullet and have the
+ *       target area right outside the main wall, but mostly I
+ *       think it's OK.
+ *     * the move limit tends to make the game _slower_ to
+ *       generate, which is odd. Perhaps investigate why.
+ * 
+ *  - Improve the graphics.
+ *     * All the colours are a bit wishy-washy. _Some_ dark
+ *       colours would surely not be excessive? Probably darken
+ *       the tiles, the walls and the main block, and leave the
+ *       target marker pale.
+ *     * The cattle grid effect is still disgusting. Think of
+ *       something completely different.
+ *     * The highlight for next-piece-to-move in the solver is
+ *       excessive, and the shadow blends in too well with the
+ *       piece lowlights. Adjust both.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+
+/*
+ * The implementation of this game revolves around the insight
+ * which makes an exhaustive-search solver feasible: although
+ * there are many blocks which can be rearranged in many ways, any
+ * two blocks of the same shape are _indistinguishable_ and hence
+ * the number of _distinct_ board layouts is generally much
+ * smaller. So we adopt a representation for board layouts which
+ * is inherently canonical, i.e. there are no two distinct
+ * representations which encode indistinguishable layouts.
+ *
+ * The way we do this is to encode each square of the board, in
+ * the normal left-to-right top-to-bottom order, as being one of
+ * the following things:
+ *  - the first square (in the given order) of a block (`anchor')
+ *  - special case of the above: the anchor for the _main_ block
+ *    (i.e. the one which the aim of the game is to get to the
+ *    target position)
+ *  - a subsequent square of a block whose previous square was N
+ *    squares ago
+ *  - an impassable wall
+ * 
+ * (We also separately store data about which board positions are
+ * forcefields only passable by the main block. We can't encode
+ * that in the main board data, because then the main block would
+ * destroy forcefields as it went over them.)
+ *
+ * Hence, for example, a 2x2 square block would be encoded as
+ * ANCHOR, followed by DIST(1), and w-2 squares later on there
+ * would be DIST(w-1) followed by DIST(1). So if you start at the
+ * last of those squares, the DIST numbers give you a linked list
+ * pointing back through all the other squares in the same block.
+ *
+ * So the solver simply does a bfs over all reachable positions,
+ * encoding them in this format and storing them in a tree234 to
+ * ensure it doesn't ever revisit an already-analysed position.
+ */
+
+enum {
+    /*
+     * The colours are arranged here so that every base colour is
+     * directly followed by its highlight colour and then its
+     * lowlight colour. Do not break this, or draw_tile() will get
+     * confused.
+     */
+    COL_BACKGROUND,
+    COL_HIGHLIGHT,
+    COL_LOWLIGHT,
+    COL_DRAGGING,
+    COL_DRAGGING_HIGHLIGHT,
+    COL_DRAGGING_LOWLIGHT,
+    COL_MAIN,
+    COL_MAIN_HIGHLIGHT,
+    COL_MAIN_LOWLIGHT,
+    COL_MAIN_DRAGGING,
+    COL_MAIN_DRAGGING_HIGHLIGHT,
+    COL_MAIN_DRAGGING_LOWLIGHT,
+    COL_TARGET,
+    COL_TARGET_HIGHLIGHT,
+    COL_TARGET_LOWLIGHT,
+    NCOLOURS
+};
+
+/*
+ * Board layout is a simple array of bytes. Each byte holds:
+ */
+#define ANCHOR      255                /* top-left-most square of some piece */
+#define MAINANCHOR  254                /* anchor of _main_ piece */
+#define EMPTY       253                /* empty square */
+#define WALL        252                /* immovable wall */
+#define MAXDIST     251
+/* all other values indicate distance back to previous square of same block */
+#define ISDIST(x) ( (unsigned char)((x)-1) <= MAXDIST-1 )
+#define DIST(x) (x)
+#define ISANCHOR(x) ( (x)==ANCHOR || (x)==MAINANCHOR )
+#define ISBLOCK(x) ( ISANCHOR(x) || ISDIST(x) )
+
+/*
+ * MAXDIST is the largest DIST value we can encode. This must
+ * therefore also be the maximum puzzle width in theory (although
+ * solver running time will dictate a much smaller limit in
+ * practice).
+ */
+#define MAXWID MAXDIST
+
+struct game_params {
+    int w, h;
+    int maxmoves;
+};
+
+struct game_immutable_state {
+    int refcount;
+    unsigned char *forcefield;
+};
+
+struct game_solution {
+    int nmoves;
+    int *moves;                        /* just like from solve_board() */
+    int refcount;
+};
+
+struct game_state {
+    int w, h;
+    unsigned char *board;
+    int tx, ty;                        /* target coords for MAINANCHOR */
+    int minmoves;                      /* for display only */
+    int lastmoved, lastmoved_pos;      /* for move counting */
+    int movecount;
+    int completed;
+    int cheated;
+    struct game_immutable_state *imm;
+    struct game_solution *soln;
+    int soln_index;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = 7;
+    ret->h = 6;
+    ret->maxmoves = 40;
+
+    return ret;
+}
+
+static const struct game_params slide_presets[] = {
+    {7, 6, 25},
+    {7, 6, -1},
+    {8, 6, -1},
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char str[80];
+
+    if (i < 0 || i >= lenof(slide_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = slide_presets[i];
+
+    sprintf(str, "%dx%d", ret->w, ret->h);
+    if (ret->maxmoves >= 0)
+        sprintf(str + strlen(str), ", max %d moves", ret->maxmoves);
+    else
+        sprintf(str + strlen(str), ", no move limit");
+
+    *name = dupstr(str);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->w = params->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        params->h = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    }
+    if (*string == 'm') {
+        string++;
+        params->maxmoves = atoi(string);
+        while (*string && isdigit((unsigned char)*string)) string++;
+    } else if (*string == 'u') {
+        string++;
+        params->maxmoves = -1;
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    sprintf(data, "%dx%d", params->w, params->h);
+    if (params->maxmoves >= 0)
+        sprintf(data + strlen(data), "m%d", params->maxmoves);
+    else
+        sprintf(data + strlen(data), "u");
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(4, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Solution length limit";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->maxmoves);
+    ret[2].sval = dupstr(buf);
+    ret[2].ival = 0;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+    ret[3].sval = NULL;
+    ret[3].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+    ret->maxmoves = atoi(cfg[2].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w > MAXWID)
+        return "Width must be at most " STR(MAXWID);
+
+    if (params->w < 5)
+        return "Width must be at least 5";
+    if (params->h < 4)
+        return "Height must be at least 4";
+
+    return NULL;
+}
+
+static char *board_text_format(int w, int h, unsigned char *data,
+                               unsigned char *forcefield)
+{
+    int wh = w*h;
+    int *dsf = snew_dsf(wh);
+    int i, x, y;
+    int retpos, retlen = (w*2+2)*(h*2+1)+1;
+    char *ret = snewn(retlen, char);
+
+    for (i = 0; i < wh; i++)
+        if (ISDIST(data[i]))
+            dsf_merge(dsf, i - data[i], i);
+    retpos = 0;
+    for (y = 0; y < 2*h+1; y++) {
+        for (x = 0; x < 2*w+1; x++) {
+            int v;
+            int i = (y/2)*w+(x/2);
+
+#define dtype(i) (ISBLOCK(data[i]) ? \
+                  dsf_canonify(dsf, i) : data[i])
+#define dchar(t) ((t)==EMPTY ? ' ' : (t)==WALL ? '#' : \
+                  data[t] == MAINANCHOR ? '*' : '%')
+
+            if (y % 2 && x % 2) {
+                int j = dtype(i);
+                v = dchar(j);
+            } else if (y % 2 && !(x % 2)) {
+                int j1 = (x > 0 ? dtype(i-1) : -1);
+                int j2 = (x < 2*w ? dtype(i) : -1);
+                if (j1 != j2)
+                    v = '|';
+                else
+                    v = dchar(j1);
+            } else if (!(y % 2) && (x % 2)) {
+                int j1 = (y > 0 ? dtype(i-w) : -1);
+                int j2 = (y < 2*h ? dtype(i) : -1);
+                if (j1 != j2)
+                    v = '-';
+                else
+                    v = dchar(j1);
+            } else {
+                int j1 = (x > 0 && y > 0 ? dtype(i-w-1) : -1);
+                int j2 = (x > 0 && y < 2*h ? dtype(i-1) : -1);
+                int j3 = (x < 2*w && y > 0 ? dtype(i-w) : -1);
+                int j4 = (x < 2*w && y < 2*h ? dtype(i) : -1);
+                if (j1 == j2 && j2 == j3 && j3 == j4)
+                    v = dchar(j1);
+                else if (j1 == j2 && j3 == j4)
+                    v = '|';
+                else if (j1 == j3 && j2 == j4)
+                    v = '-';
+                else
+                    v = '+';
+            }
+
+            assert(retpos < retlen);
+            ret[retpos++] = v;
+        }
+        assert(retpos < retlen);
+        ret[retpos++] = '\n';
+    }
+    assert(retpos < retlen);
+    ret[retpos++] = '\0';
+    assert(retpos == retlen);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver.
+ */
+
+/*
+ * During solver execution, the set of visited board positions is
+ * stored as a tree234 of the following structures. `w', `h' and
+ * `data' are obvious in meaning; `dist' represents the minimum
+ * distance to reach this position from the starting point.
+ * 
+ * `prev' links each board to the board position from which it was
+ * most efficiently derived.
+ */
+struct board {
+    int w, h;
+    int dist;
+    struct board *prev;
+    unsigned char *data;
+};
+
+static int boardcmp(void *av, void *bv)
+{
+    struct board *a = (struct board *)av;
+    struct board *b = (struct board *)bv;
+    return memcmp(a->data, b->data, a->w * a->h);
+}
+
+static struct board *newboard(int w, int h, unsigned char *data)
+{
+    struct board *b = malloc(sizeof(struct board) + w*h);
+    b->data = (unsigned char *)b + sizeof(struct board);
+    memcpy(b->data, data, w*h);
+    b->w = w;
+    b->h = h;
+    b->dist = -1;
+    b->prev = NULL;
+    return b;
+}
+
+/*
+ * The actual solver. Given a board, attempt to find the minimum
+ * length of move sequence which moves MAINANCHOR to (tx,ty), or
+ * -1 if no solution exists. Returns that minimum length.
+ * 
+ * Also, if `moveout' is provided, writes out the moves in the
+ * form of a sequence of pairs of integers indicating the source
+ * and destination points of the anchor of the moved piece in each
+ * move. Exactly twice as many integers are written as the number
+ * returned from solve_board(), and `moveout' receives an int *
+ * which is a pointer to a dynamically allocated array.
+ */
+static int solve_board(int w, int h, unsigned char *board,
+                       unsigned char *forcefield, int tx, int ty,
+                       int movelimit, int **moveout)
+{
+    int wh = w*h;
+    struct board *b, *b2, *b3;
+    int *next, *anchors, *which;
+    int *movereached, *movequeue, mqhead, mqtail;
+    tree234 *sorted, *queue;
+    int i, j, dir;
+    int qlen, lastdist;
+    int ret;
+
+#ifdef SOLVER_DIAGNOSTICS
+    {
+        char *t = board_text_format(w, h, board);
+        for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+                int c = board[i*w+j];
+                if (ISDIST(c))
+                    printf("D%-3d", c);
+                else if (c == MAINANCHOR)
+                    printf("M   ");
+                else if (c == ANCHOR)
+                    printf("A   ");
+                else if (c == WALL)
+                    printf("W   ");
+                else if (c == EMPTY)
+                    printf("E   ");
+            }
+            printf("\n");
+        }
+        
+        printf("Starting solver for:\n%s\n", t);
+        sfree(t);
+    }
+#endif
+
+    sorted = newtree234(boardcmp);
+    queue = newtree234(NULL);
+
+    b = newboard(w, h, board);
+    b->dist = 0;
+    add234(sorted, b);
+    addpos234(queue, b, 0);
+    qlen = 1;
+
+    next = snewn(wh, int);
+    anchors = snewn(wh, int);
+    which = snewn(wh, int);
+    movereached = snewn(wh, int);
+    movequeue = snewn(wh, int);
+    lastdist = -1;
+
+    while ((b = delpos234(queue, 0)) != NULL) {
+        qlen--;
+        if (movelimit >= 0 && b->dist >= movelimit) {
+            /*
+             * The problem is not soluble in under `movelimit'
+             * moves, so we can quit right now.
+             */
+            b2 = NULL;
+            goto done;
+        }
+        if (b->dist != lastdist) {
+#ifdef SOLVER_DIAGNOSTICS
+            printf("dist %d (%d)\n", b->dist, count234(sorted));
+#endif
+            lastdist = b->dist;
+        }
+        /*
+         * Find all the anchors and form a linked list of the
+         * squares within each block.
+         */
+        for (i = 0; i < wh; i++) {
+            next[i] = -1;
+            anchors[i] = FALSE;
+            which[i] = -1;
+            if (ISANCHOR(b->data[i])) {
+                anchors[i] = TRUE;
+                which[i] = i;
+            } else if (ISDIST(b->data[i])) {
+                j = i - b->data[i];
+                next[j] = i;
+                which[i] = which[j];
+            }
+        }
+
+        /*
+         * For each anchor, do an array-based BFS to find all the
+         * places we can slide it to.
+         */
+        for (i = 0; i < wh; i++) {
+            if (!anchors[i])
+                continue;
+
+            mqhead = mqtail = 0;
+            for (j = 0; j < wh; j++)
+                movereached[j] = FALSE;
+            movequeue[mqtail++] = i;
+            while (mqhead < mqtail) {
+                int pos = movequeue[mqhead++];
+
+                /*
+                 * Try to move in each direction from here.
+                 */
+                for (dir = 0; dir < 4; dir++) {
+                    int dx = (dir == 0 ? -1 : dir == 1 ? +1 : 0);
+                    int dy = (dir == 2 ? -1 : dir == 3 ? +1 : 0);
+                    int offset = dy*w + dx;
+                    int newpos = pos + offset;
+                    int d = newpos - i;
+
+                    /*
+                     * For each square involved in this block,
+                     * check to see if the square d spaces away
+                     * from it is either empty or part of the same
+                     * block.
+                     */
+                    for (j = i; j >= 0; j = next[j]) {
+                        int jy = (pos+j-i) / w + dy, jx = (pos+j-i) % w + dx;
+                        if (jy >= 0 && jy < h && jx >= 0 && jx < w &&
+                            ((b->data[j+d] == EMPTY || which[j+d] == i) &&
+                             (b->data[i] == MAINANCHOR || !forcefield[j+d])))
+                            /* ok */;
+                        else
+                            break;
+                    }
+                    if (j >= 0)
+                        continue;              /* this direction wasn't feasible */
+
+                    /*
+                     * If we've already tried moving this piece
+                     * here, leave it.
+                     */
+                    if (movereached[newpos])
+                        continue;
+                    movereached[newpos] = TRUE;
+                    movequeue[mqtail++] = newpos;
+
+                    /*
+                     * We have a viable move. Make it.
+                     */
+                    b2 = newboard(w, h, b->data);
+                    for (j = i; j >= 0; j = next[j])
+                        b2->data[j] = EMPTY;
+                    for (j = i; j >= 0; j = next[j])
+                        b2->data[j+d] = b->data[j];
+
+                    b3 = add234(sorted, b2);
+                    if (b3 != b2) {
+                        sfree(b2);             /* we already got one */
+                    } else {
+                        b2->dist = b->dist + 1;
+                        b2->prev = b;
+                        addpos234(queue, b2, qlen++);
+                        if (b2->data[ty*w+tx] == MAINANCHOR)
+                            goto done;     /* search completed! */
+                    }
+                }
+            }
+        }
+    }
+    b2 = NULL;
+
+    done:
+
+    if (b2) {
+        ret = b2->dist;
+        if (moveout) {
+            /*
+             * Now b2 represents the solved position. Backtrack to
+             * output the solution.
+             */
+            *moveout = snewn(ret * 2, int);
+            j = ret * 2;
+
+            while (b2->prev) {
+                int from = -1, to = -1;
+
+                b = b2->prev;
+
+                /*
+                 * Scan b and b2 to find out which piece has
+                 * moved.
+                 */
+                for (i = 0; i < wh; i++) {
+                    if (ISANCHOR(b->data[i]) && !ISANCHOR(b2->data[i])) {
+                        assert(from == -1);
+                        from = i;
+                    } else if (!ISANCHOR(b->data[i]) && ISANCHOR(b2->data[i])){
+                        assert(to == -1);
+                        to = i;
+                    }
+                }
+
+                assert(from >= 0 && to >= 0);
+                assert(j >= 2);
+                (*moveout)[--j] = to;
+                (*moveout)[--j] = from;
+
+                b2 = b;
+            }
+            assert(j == 0);
+        }
+    } else {
+        ret = -1;                      /* no solution */
+        if (moveout)
+            *moveout = NULL;
+    }
+
+    freetree234(queue);
+
+    while ((b = delpos234(sorted, 0)) != NULL)
+        sfree(b);
+    freetree234(sorted);
+
+    sfree(next);
+    sfree(anchors);
+    sfree(movereached);
+    sfree(movequeue);
+    sfree(which);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Random board generation.
+ */
+
+static void generate_board(int w, int h, int *rtx, int *rty, int *minmoves,
+                           random_state *rs, unsigned char **rboard,
+                           unsigned char **rforcefield, int movelimit)
+{
+    int wh = w*h;
+    unsigned char *board, *board2, *forcefield;
+    unsigned char *tried_merge;
+    int *dsf;
+    int *list, nlist, pos;
+    int tx, ty;
+    int i, j;
+    int moves = 0;                     /* placate optimiser */
+
+    /*
+     * Set up a board and fill it with singletons, except for a
+     * border of walls.
+     */
+    board = snewn(wh, unsigned char);
+    forcefield = snewn(wh, unsigned char);
+    board2 = snewn(wh, unsigned char);
+    memset(board, ANCHOR, wh);
+    memset(forcefield, FALSE, wh);
+    for (i = 0; i < w; i++)
+        board[i] = board[i+w*(h-1)] = WALL;
+    for (i = 0; i < h; i++)
+        board[i*w] = board[i*w+(w-1)] = WALL;
+
+    tried_merge = snewn(wh * wh, unsigned char);
+    memset(tried_merge, 0, wh*wh);
+    dsf = snew_dsf(wh);
+
+    /*
+     * Invent a main piece at one extreme. (FIXME: vary the
+     * extreme, and the piece.)
+     */
+    board[w+1] = MAINANCHOR;
+    board[w+2] = DIST(1);
+    board[w*2+1] = DIST(w-1);
+    board[w*2+2] = DIST(1);
+
+    /*
+     * Invent a target position. (FIXME: vary this too.)
+     */
+    tx = w-2;
+    ty = h-3;
+    forcefield[ty*w+tx+1] = forcefield[(ty+1)*w+tx+1] = TRUE;
+    board[ty*w+tx+1] = board[(ty+1)*w+tx+1] = EMPTY;
+
+    /*
+     * Gradually remove singletons until the game becomes soluble.
+     */
+    for (j = w; j-- > 0 ;)
+        for (i = h; i-- > 0 ;)
+            if (board[i*w+j] == ANCHOR) {
+                /*
+                 * See if the board is already soluble.
+                 */
+                if ((moves = solve_board(w, h, board, forcefield,
+                                         tx, ty, movelimit, NULL)) >= 0)
+                    goto soluble;
+
+                /*
+                 * Otherwise, remove this piece.
+                 */
+                board[i*w+j] = EMPTY;
+            }
+    assert(!"We shouldn't get here");
+    soluble:
+
+    /*
+     * Make a list of all the inter-block edges on the board.
+     */
+    list = snewn(wh*2, int);
+    nlist = 0;
+    for (i = 0; i+1 < w; i++)
+        for (j = 0; j < h; j++)
+            list[nlist++] = (j*w+i) * 2 + 0;   /* edge to the right of j*w+i */
+    for (j = 0; j+1 < h; j++)
+        for (i = 0; i < w; i++)
+            list[nlist++] = (j*w+i) * 2 + 1;   /* edge below j*w+i */
+
+    /*
+     * Now go through that list in random order, trying to merge
+     * the blocks on each side of each edge.
+     */
+    shuffle(list, nlist, sizeof(*list), rs);
+    while (nlist > 0) {
+        int x1, y1, p1, c1;
+        int x2, y2, p2, c2;
+
+        pos = list[--nlist];
+        y1 = y2 = pos / (w*2);
+        x1 = x2 = (pos / 2) % w;
+        if (pos % 2)
+            y2++;
+        else
+            x2++;
+        p1 = y1*w+x1;
+        p2 = y2*w+x2;
+
+        /*
+         * Immediately abandon the attempt if we've already tried
+         * to merge the same pair of blocks along a different
+         * edge.
+         */
+        c1 = dsf_canonify(dsf, p1);
+        c2 = dsf_canonify(dsf, p2);
+        if (tried_merge[c1 * wh + c2])
+            continue;
+
+        /*
+         * In order to be mergeable, these two squares must each
+         * either be, or belong to, a non-main anchor, and their
+         * anchors must also be distinct.
+         */
+        if (!ISBLOCK(board[p1]) || !ISBLOCK(board[p2]))
+            continue;
+        while (ISDIST(board[p1]))
+            p1 -= board[p1];
+        while (ISDIST(board[p2]))
+            p2 -= board[p2];
+        if (board[p1] == MAINANCHOR || board[p2] == MAINANCHOR || p1 == p2)
+            continue;
+
+        /*
+         * We can merge these blocks. Try it, and see if the
+         * puzzle remains soluble.
+         */
+        memcpy(board2, board, wh);
+        j = -1;
+        while (p1 < wh || p2 < wh) {
+            /*
+             * p1 and p2 are the squares at the head of each block
+             * list. Pick the smaller one and put it on the output
+             * block list.
+             */
+            i = min(p1, p2);
+            if (j < 0) {
+                board[i] = ANCHOR;
+            } else {
+                assert(i - j <= MAXDIST);
+                board[i] = DIST(i - j);
+            }
+            j = i;
+
+            /*
+             * Now advance whichever list that came from.
+             */
+            if (i == p1) {
+                do {
+                    p1++;
+                } while (p1 < wh && board[p1] != DIST(p1-i));
+            } else {
+                do {
+                    p2++;
+                } while (p2 < wh && board[p2] != DIST(p2-i));
+            }
+        }
+        j = solve_board(w, h, board, forcefield, tx, ty, movelimit, NULL);
+        if (j < 0) {
+            /*
+             * Didn't work. Revert the merge.
+             */
+            memcpy(board, board2, wh);
+            tried_merge[c1 * wh + c2] = tried_merge[c2 * wh + c1] = TRUE;
+        } else {
+            int c;
+
+            moves = j;
+
+            dsf_merge(dsf, c1, c2);
+            c = dsf_canonify(dsf, c1);
+            for (i = 0; i < wh; i++)
+                tried_merge[c*wh+i] = (tried_merge[c1*wh+i] |
+                                       tried_merge[c2*wh+i]);
+            for (i = 0; i < wh; i++)
+                tried_merge[i*wh+c] = (tried_merge[i*wh+c1] |
+                                       tried_merge[i*wh+c2]);
+        }
+    }
+
+    sfree(dsf);
+    sfree(list);
+    sfree(tried_merge);
+    sfree(board2);
+
+    *rtx = tx;
+    *rty = ty;
+    *rboard = board;
+    *rforcefield = forcefield;
+    *minmoves = moves;
+}
+
+/* ----------------------------------------------------------------------
+ * End of solver/generator code.
+ */
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    int tx, ty, minmoves;
+    unsigned char *board, *forcefield;
+    char *ret, *p;
+    int i;
+
+    generate_board(params->w, params->h, &tx, &ty, &minmoves, rs,
+                   &board, &forcefield, params->maxmoves);
+#ifdef GENERATOR_DIAGNOSTICS
+    {
+        char *t = board_text_format(params->w, params->h, board);
+        printf("%s\n", t);
+        sfree(t);
+    }
+#endif
+
+    /*
+     * Encode as a game ID.
+     */
+    ret = snewn(wh * 6 + 40, char);
+    p = ret;
+    i = 0;
+    while (i < wh) {
+        if (ISDIST(board[i])) {
+            p += sprintf(p, "d%d", board[i]);
+            i++;
+        } else {
+            int count = 1;
+            int b = board[i], f = forcefield[i];
+            int c = (b == ANCHOR ? 'a' :
+                     b == MAINANCHOR ? 'm' :
+                     b == EMPTY ? 'e' :
+                     /* b == WALL ? */ 'w');
+            if (f) *p++ = 'f';
+            *p++ = c;
+            i++;
+            while (i < wh && board[i] == b && forcefield[i] == f)
+                i++, count++;
+            if (count > 1)
+                p += sprintf(p, "%d", count);
+        }
+    }
+    p += sprintf(p, ",%d,%d,%d", tx, ty, minmoves);
+    ret = sresize(ret, p+1 - ret, char);
+
+    sfree(board);
+    sfree(forcefield);
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    int *active, *link;
+    int mains = 0;
+    int i, tx, ty, minmoves;
+    char *ret;
+
+    active = snewn(wh, int);
+    link = snewn(wh, int);
+    i = 0;
+
+    while (*desc && *desc != ',') {
+        if (i >= wh) {
+            ret = "Too much data in game description";
+            goto done;
+        }
+        link[i] = -1;
+        active[i] = FALSE;
+        if (*desc == 'f' || *desc == 'F') {
+            desc++;
+            if (!*desc) {
+                ret = "Expected another character after 'f' in game "
+                    "description";
+                goto done;
+            }
+        }
+
+        if (*desc == 'd' || *desc == 'D') {
+            int dist;
+
+            desc++;
+            if (!isdigit((unsigned char)*desc)) {
+                ret = "Expected a number after 'd' in game description";
+                goto done;
+            }
+            dist = atoi(desc);
+            while (*desc && isdigit((unsigned char)*desc)) desc++;
+
+            if (dist <= 0 || dist > i) {
+                ret = "Out-of-range number after 'd' in game description";
+                goto done;
+            }
+
+            if (!active[i - dist]) {
+                ret = "Invalid back-reference in game description";
+                goto done;
+            }
+
+            link[i] = i - dist;
+
+            active[i] = TRUE;
+            active[link[i]] = FALSE;
+            i++;
+        } else {
+            int c = *desc++;
+            int count = 1;
+
+            if (!strchr("aAmMeEwW", c)) {
+                ret = "Invalid character in game description";
+                goto done;
+            }
+            if (isdigit((unsigned char)*desc)) {
+                count = atoi(desc);
+                while (*desc && isdigit((unsigned char)*desc)) desc++;
+            }
+            if (i + count > wh) {
+                ret = "Too much data in game description";
+                goto done;
+            }
+            while (count-- > 0) {
+                active[i] = (strchr("aAmM", c) != NULL);
+                link[i] = -1;
+                if (strchr("mM", c) != NULL) {
+                    mains++;
+                }
+                i++;
+            }
+        }
+    }
+    if (mains != 1) {
+        ret = (mains == 0 ? "No main piece specified in game description" :
+               "More than one main piece specified in game description");
+        goto done;
+    }
+    if (i < wh) {
+        ret = "Not enough data in game description";
+        goto done;
+    }
+
+    /*
+     * Now read the target coordinates.
+     */
+    i = sscanf(desc, ",%d,%d,%d", &tx, &ty, &minmoves);
+    if (i < 2) {
+        ret = "No target coordinates specified";
+        goto done;
+        /*
+         * (but minmoves is optional)
+         */
+    }
+
+    ret = NULL;
+
+    done:
+    sfree(active);
+    sfree(link);
+    return ret;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    game_state *state;
+    int i;
+
+    state = snew(game_state);
+    state->w = w;
+    state->h = h;
+    state->board = snewn(wh, unsigned char);
+    state->lastmoved = state->lastmoved_pos = -1;
+    state->movecount = 0;
+    state->imm = snew(struct game_immutable_state);
+    state->imm->refcount = 1;
+    state->imm->forcefield = snewn(wh, unsigned char);
+
+    i = 0;
+
+    while (*desc && *desc != ',') {
+        int f = FALSE;
+
+        assert(i < wh);
+
+        if (*desc == 'f') {
+            f = TRUE;
+            desc++;
+            assert(*desc);
+        }
+
+        if (*desc == 'd' || *desc == 'D') {
+            int dist;
+
+            desc++;
+            dist = atoi(desc);
+            while (*desc && isdigit((unsigned char)*desc)) desc++;
+
+            state->board[i] = DIST(dist);
+            state->imm->forcefield[i] = f;
+
+            i++;
+        } else {
+            int c = *desc++;
+            int count = 1;
+
+            if (isdigit((unsigned char)*desc)) {
+                count = atoi(desc);
+                while (*desc && isdigit((unsigned char)*desc)) desc++;
+            }
+            assert(i + count <= wh);
+
+            c = (c == 'a' || c == 'A' ? ANCHOR :
+                 c == 'm' || c == 'M' ? MAINANCHOR :
+                 c == 'e' || c == 'E' ? EMPTY :
+                 /* c == 'w' || c == 'W' ? */ WALL);             
+
+            while (count-- > 0) {
+                state->board[i] = c;
+                state->imm->forcefield[i] = f;
+                i++;
+            }
+        }
+    }
+
+    /*
+     * Now read the target coordinates.
+     */
+    state->tx = state->ty = 0;
+    state->minmoves = -1;
+    i = sscanf(desc, ",%d,%d,%d", &state->tx, &state->ty, &state->minmoves);
+
+    if (state->board[state->ty*w+state->tx] == MAINANCHOR)
+        state->completed = 0;          /* already complete! */
+    else
+        state->completed = -1;
+
+    state->cheated = FALSE;
+    state->soln = NULL;
+    state->soln_index = -1;
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w = state->w, h = state->h, wh = w*h;
+    game_state *ret = snew(game_state);
+
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->board = snewn(wh, unsigned char);
+    memcpy(ret->board, state->board, wh);
+    ret->tx = state->tx;
+    ret->ty = state->ty;
+    ret->minmoves = state->minmoves;
+    ret->lastmoved = state->lastmoved;
+    ret->lastmoved_pos = state->lastmoved_pos;
+    ret->movecount = state->movecount;
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+    ret->imm = state->imm;
+    ret->imm->refcount++;
+    ret->soln = state->soln;
+    ret->soln_index = state->soln_index;
+    if (ret->soln)
+        ret->soln->refcount++;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (--state->imm->refcount <= 0) {
+        sfree(state->imm->forcefield);
+        sfree(state->imm);
+    }
+    if (state->soln && --state->soln->refcount <= 0) {
+        sfree(state->soln->moves);
+        sfree(state->soln);
+    }
+    sfree(state->board);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int *moves;
+    int nmoves;
+    int i;
+    char *ret, *p, sep;
+
+    /*
+     * Run the solver and attempt to find the shortest solution
+     * from the current position.
+     */
+    nmoves = solve_board(state->w, state->h, state->board,
+                         state->imm->forcefield, state->tx, state->ty,
+                         -1, &moves);
+
+    if (nmoves < 0) {
+        *error = "Unable to find a solution to this puzzle";
+        return NULL;
+    }
+    if (nmoves == 0) {
+        *error = "Puzzle is already solved";
+        return NULL;
+    }
+
+    /*
+     * Encode the resulting solution as a move string.
+     */
+    ret = snewn(nmoves * 40, char);
+    p = ret;
+    sep = 'S';
+
+    for (i = 0; i < nmoves; i++) {
+        p += sprintf(p, "%c%d-%d", sep, moves[i*2], moves[i*2+1]);
+        sep = ',';
+    }
+
+    sfree(moves);
+    assert(p - ret < nmoves * 40);
+    ret = sresize(ret, p+1 - ret, char);
+
+    return ret;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return board_text_format(state->w, state->h, state->board,
+                             state->imm->forcefield);
+}
+
+struct game_ui {
+    int dragging;
+    int drag_anchor;
+    int drag_offset_x, drag_offset_y;
+    int drag_currpos;
+    unsigned char *reachable;
+    int *bfs_queue;                    /* used as scratch in interpret_move */
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    int w = state->w, h = state->h, wh = w*h;
+    game_ui *ui = snew(game_ui);
+
+    ui->dragging = FALSE;
+    ui->drag_anchor = ui->drag_currpos = -1;
+    ui->drag_offset_x = ui->drag_offset_y = -1;
+    ui->reachable = snewn(wh, unsigned char);
+    memset(ui->reachable, 0, wh);
+    ui->bfs_queue = snewn(wh, int);
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui->bfs_queue);
+    sfree(ui->reachable);
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+#define PREFERRED_TILESIZE 32
+#define TILESIZE (ds->tilesize)
+#define BORDER (TILESIZE/2)
+#define COORD(x)  ( (x) * TILESIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILESIZE) / TILESIZE - 1 )
+#define BORDER_WIDTH (1 + TILESIZE/20)
+#define HIGHLIGHT_WIDTH (1 + TILESIZE/16)
+
+#define FLASH_INTERVAL 0.10F
+#define FLASH_TIME 3*FLASH_INTERVAL
+
+struct game_drawstate {
+    int tilesize;
+    int w, h;
+    unsigned long *grid;               /* what's currently displayed */
+    int started;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int w = state->w, h = state->h, wh = w*h;
+    int tx, ty, i, j;
+    int qhead, qtail;
+
+    if (button == LEFT_BUTTON) {
+        tx = FROMCOORD(x);
+        ty = FROMCOORD(y);
+
+        if (tx < 0 || tx >= w || ty < 0 || ty >= h ||
+            !ISBLOCK(state->board[ty*w+tx]))
+            return NULL;               /* this click has no effect */
+
+        /*
+         * User has clicked on a block. Find the block's anchor
+         * and register that we've started dragging it.
+         */
+        i = ty*w+tx;
+        while (ISDIST(state->board[i]))
+            i -= state->board[i];
+        assert(i >= 0 && i < wh);
+
+        ui->dragging = TRUE;
+        ui->drag_anchor = i;
+        ui->drag_offset_x = tx - (i % w);
+        ui->drag_offset_y = ty - (i / w);
+        ui->drag_currpos = i;
+
+        /*
+         * Now we immediately bfs out from the current location of
+         * the anchor, to find all the places to which this block
+         * can be dragged.
+         */
+        memset(ui->reachable, FALSE, wh);
+        qhead = qtail = 0;
+        ui->reachable[i] = TRUE;
+        ui->bfs_queue[qtail++] = i;
+        for (j = i; j < wh; j++)
+            if (state->board[j] == DIST(j - i))
+                i = j;
+        while (qhead < qtail) {
+            int pos = ui->bfs_queue[qhead++];
+            int x = pos % w, y = pos / w;
+            int dir;
+
+            for (dir = 0; dir < 4; dir++) {
+                int dx = (dir == 0 ? -1 : dir == 1 ? +1 : 0);
+                int dy = (dir == 2 ? -1 : dir == 3 ? +1 : 0);
+                int newpos;
+
+                if (x + dx < 0 || x + dx >= w ||
+                    y + dy < 0 || y + dy >= h)
+                    continue;
+
+                newpos = pos + dy*w + dx;
+                if (ui->reachable[newpos])
+                    continue;          /* already done this one */
+
+                /*
+                 * Now search the grid to see if the block we're
+                 * dragging could fit into this space.
+                 */
+                for (j = i; j >= 0; j = (ISDIST(state->board[j]) ?
+                                         j - state->board[j] : -1)) {
+                    int jx = (j+pos-ui->drag_anchor) % w;
+                    int jy = (j+pos-ui->drag_anchor) / w;
+                    int j2;
+
+                    if (jx + dx < 0 || jx + dx >= w ||
+                        jy + dy < 0 || jy + dy >= h)
+                        break;         /* this position isn't valid at all */
+
+                    j2 = (j+pos-ui->drag_anchor) + dy*w + dx;
+
+                    if (state->board[j2] == EMPTY &&
+                        (!state->imm->forcefield[j2] ||
+                         state->board[ui->drag_anchor] == MAINANCHOR))
+                        continue;
+                    while (ISDIST(state->board[j2]))
+                        j2 -= state->board[j2];
+                    assert(j2 >= 0 && j2 < wh);
+                    if (j2 == ui->drag_anchor)
+                        continue;
+                    else
+                        break;
+                }
+
+                if (j < 0) {
+                    /*
+                     * If we got to the end of that loop without
+                     * disqualifying this position, mark it as
+                     * reachable for this drag.
+                     */
+                    ui->reachable[newpos] = TRUE;
+                    ui->bfs_queue[qtail++] = newpos;
+                }
+            }
+        }
+
+        /*
+         * And that's it. Update the display to reflect the start
+         * of a drag.
+         */
+        return "";
+    } else if (button == LEFT_DRAG && ui->dragging) {
+        int dist, distlimit, dx, dy, s, px, py;
+
+        tx = FROMCOORD(x);
+        ty = FROMCOORD(y);
+
+        tx -= ui->drag_offset_x;
+        ty -= ui->drag_offset_y;
+
+        /*
+         * Now search outwards from (tx,ty), in order of Manhattan
+         * distance, until we find a reachable square.
+         */
+        distlimit = w+tx;
+        distlimit = max(distlimit, h+ty);
+        distlimit = max(distlimit, tx);
+        distlimit = max(distlimit, ty);
+        for (dist = 0; dist <= distlimit; dist++) {
+            for (dx = -dist; dx <= dist; dx++)
+                for (s = -1; s <= +1; s += 2) {
+                    dy = s * (dist - abs(dx));
+                    px = tx + dx;
+                    py = ty + dy;
+                    if (px >= 0 && px < w && py >= 0 && py < h &&
+                        ui->reachable[py*w+px]) {
+                        ui->drag_currpos = py*w+px;
+                        return "";
+                    }
+                }
+        }
+        return NULL;                   /* give up - this drag has no effect */
+    } else if (button == LEFT_RELEASE && ui->dragging) {
+        char data[256], *str;
+
+        /*
+         * Terminate the drag, and if the piece has actually moved
+         * then return a move string quoting the old and new
+         * locations of the piece's anchor.
+         */
+        if (ui->drag_anchor != ui->drag_currpos) {
+            sprintf(data, "M%d-%d", ui->drag_anchor, ui->drag_currpos);
+            str = dupstr(data);
+        } else
+            str = "";                  /* null move; just update the UI */
+        
+        ui->dragging = FALSE;
+        ui->drag_anchor = ui->drag_currpos = -1;
+        ui->drag_offset_x = ui->drag_offset_y = -1;
+        memset(ui->reachable, 0, wh);
+
+        return str;
+    } else if (button == ' ' && state->soln) {
+        /*
+         * Make the next move in the stored solution.
+         */
+        char data[256];
+        int a1, a2;
+
+        a1 = state->soln->moves[state->soln_index*2];
+        a2 = state->soln->moves[state->soln_index*2+1];
+        if (a1 == state->lastmoved_pos)
+            a1 = state->lastmoved;
+
+        sprintf(data, "M%d-%d", a1, a2);
+        return dupstr(data);
+    }
+
+    return NULL;
+}
+
+static int move_piece(int w, int h, const unsigned char *src,
+                      unsigned char *dst, unsigned char *ff, int from, int to)
+{
+    int wh = w*h;
+    int i, j;
+
+    if (!ISANCHOR(dst[from]))
+        return FALSE;
+
+    /*
+     * Scan to the far end of the piece's linked list.
+     */
+    for (i = j = from; j < wh; j++)
+        if (src[j] == DIST(j - i))
+            i = j;
+
+    /*
+     * Remove the piece from its old location in the new
+     * game state.
+     */
+    for (j = i; j >= 0; j = (ISDIST(src[j]) ? j - src[j] : -1))
+        dst[j] = EMPTY;
+
+    /*
+     * And put it back in at the new location.
+     */
+    for (j = i; j >= 0; j = (ISDIST(src[j]) ? j - src[j] : -1)) {
+        int jn = j + to - from;
+        if (jn < 0 || jn >= wh)
+            return FALSE;
+        if (dst[jn] == EMPTY && (!ff[jn] || src[from] == MAINANCHOR)) {
+            dst[jn] = src[j];
+        } else {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int w = state->w, h = state->h /* , wh = w*h */;
+    char c;
+    int a1, a2, n, movesize;
+    game_state *ret = dup_game(state);
+
+    while (*move) {
+        c = *move;
+        if (c == 'S') {
+            /*
+             * This is a solve move, so we just set up a stored
+             * solution path.
+             */
+            if (ret->soln && --ret->soln->refcount <= 0) {
+                sfree(ret->soln->moves);
+                sfree(ret->soln);
+            }
+            ret->soln = snew(struct game_solution);
+            ret->soln->nmoves = 0;
+            ret->soln->moves = NULL;
+            ret->soln->refcount = 1;
+            ret->soln_index = 0;
+            ret->cheated = TRUE;
+
+            movesize = 0;
+            move++;
+            while (1) {
+                if (sscanf(move, "%d-%d%n", &a1, &a2, &n) != 2) {
+                    free_game(ret);
+                    return NULL;
+                }
+
+                /*
+                 * Special case: if the first move in the solution
+                 * involves the piece for which we already have a
+                 * partial stored move, adjust the source point to
+                 * the original starting point of that piece.
+                 */
+                if (ret->soln->nmoves == 0 && a1 == ret->lastmoved)
+                    a1 = ret->lastmoved_pos;
+
+                if (ret->soln->nmoves >= movesize) {
+                    movesize = (ret->soln->nmoves + 48) * 4 / 3;
+                    ret->soln->moves = sresize(ret->soln->moves,
+                                               2*movesize, int);
+                }
+
+                ret->soln->moves[2*ret->soln->nmoves] = a1;
+                ret->soln->moves[2*ret->soln->nmoves+1] = a2;
+                ret->soln->nmoves++;
+                move += n;
+                if (*move != ',')
+                    break;
+                move++;                /* eat comma */
+            }
+        } else if (c == 'M') {
+            move++;
+            if (sscanf(move, "%d-%d%n", &a1, &a2, &n) != 2 ||
+                !move_piece(w, h, state->board, ret->board,
+                            state->imm->forcefield, a1, a2)) {
+                free_game(ret);
+                return NULL;
+            }
+            if (a1 == ret->lastmoved) {
+                /*
+                 * If the player has moved the same piece as they
+                 * moved last time, don't increment the move
+                 * count. In fact, if they've put the piece back
+                 * where it started from, _decrement_ the move
+                 * count.
+                 */
+                if (a2 == ret->lastmoved_pos) {
+                    ret->movecount--;  /* reverted last move */
+                    ret->lastmoved = ret->lastmoved_pos = -1;
+                } else {
+                    ret->lastmoved = a2;
+                    /* don't change lastmoved_pos */
+                }
+            } else {
+                ret->lastmoved = a2;
+                ret->lastmoved_pos = a1;
+                ret->movecount++;
+            }
+
+            /*
+             * If we have a stored solution path, see if we've
+             * strayed from it or successfully made the next move
+             * along it.
+             */
+            if (ret->soln && ret->lastmoved_pos >= 0) {
+                if (ret->lastmoved_pos !=
+                    ret->soln->moves[ret->soln_index*2]) {
+                    /* strayed from the path */
+                    ret->soln->refcount--;
+                    assert(ret->soln->refcount > 0);
+                                       /* `state' at least still exists */
+                    ret->soln = NULL;
+                    ret->soln_index = -1;
+                } else if (ret->lastmoved ==
+                           ret->soln->moves[ret->soln_index*2+1]) {
+                    /* advanced along the path */
+                    ret->soln_index++;
+                    if (ret->soln_index >= ret->soln->nmoves) {
+                        /* finished the path! */
+                        ret->soln->refcount--;
+                        assert(ret->soln->refcount > 0);
+                                       /* `state' at least still exists */
+                        ret->soln = NULL;
+                        ret->soln_index = -1;
+                    }
+                }
+            }
+
+            if (ret->board[a2] == MAINANCHOR &&
+                a2 == ret->ty * w + ret->tx && ret->completed < 0)
+                ret->completed = ret->movecount;
+            move += n;
+        } else {
+            free_game(ret);
+            return NULL;
+        }
+        if (*move == ';')
+            move++;
+        else if (*move) {
+            free_game(ret);
+            return NULL;
+        }
+    }
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* fool the macros */
+    struct dummy { int tilesize; } dummy, *ds = &dummy;
+    dummy.tilesize = tilesize;
+
+    *x = params->w * TILESIZE + 2*BORDER;
+    *y = params->h * TILESIZE + 2*BORDER;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static void raise_colour(float *target, float *src, float *limit)
+{
+    int i;
+    for (i = 0; i < 3; i++)
+        target[i] = (2*src[i] + limit[i]) / 3;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    /*
+     * When dragging a tile, we light it up a bit.
+     */
+    raise_colour(ret+3*COL_DRAGGING,
+                 ret+3*COL_BACKGROUND, ret+3*COL_HIGHLIGHT);
+    raise_colour(ret+3*COL_DRAGGING_HIGHLIGHT,
+                 ret+3*COL_HIGHLIGHT, ret+3*COL_HIGHLIGHT);
+    raise_colour(ret+3*COL_DRAGGING_LOWLIGHT,
+                 ret+3*COL_LOWLIGHT, ret+3*COL_HIGHLIGHT);
+
+    /*
+     * The main tile is tinted blue.
+     */
+    ret[COL_MAIN * 3 + 0] = ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_MAIN * 3 + 1] = ret[COL_BACKGROUND * 3 + 1];
+    ret[COL_MAIN * 3 + 2] = ret[COL_HIGHLIGHT * 3 + 2];
+    game_mkhighlight_specific(fe, ret, COL_MAIN,
+                              COL_MAIN_HIGHLIGHT, COL_MAIN_LOWLIGHT);
+
+    /*
+     * And we light that up a bit too when dragging.
+     */
+    raise_colour(ret+3*COL_MAIN_DRAGGING,
+                 ret+3*COL_MAIN, ret+3*COL_MAIN_HIGHLIGHT);
+    raise_colour(ret+3*COL_MAIN_DRAGGING_HIGHLIGHT,
+                 ret+3*COL_MAIN_HIGHLIGHT, ret+3*COL_MAIN_HIGHLIGHT);
+    raise_colour(ret+3*COL_MAIN_DRAGGING_LOWLIGHT,
+                 ret+3*COL_MAIN_LOWLIGHT, ret+3*COL_MAIN_HIGHLIGHT);
+
+    /*
+     * The target area on the floor is tinted green.
+     */
+    ret[COL_TARGET * 3 + 0] = ret[COL_BACKGROUND * 3 + 0];
+    ret[COL_TARGET * 3 + 1] = ret[COL_HIGHLIGHT * 3 + 1];
+    ret[COL_TARGET * 3 + 2] = ret[COL_BACKGROUND * 3 + 2];
+    game_mkhighlight_specific(fe, ret, COL_TARGET,
+                              COL_TARGET_HIGHLIGHT, COL_TARGET_LOWLIGHT);
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int w = state->w, h = state->h, wh = w*h;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = 0;
+    ds->w = w;
+    ds->h = h;
+    ds->started = FALSE;
+    ds->grid = snewn(wh, unsigned long);
+    for (i = 0; i < wh; i++)
+        ds->grid[i] = ~(unsigned long)0;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+#define BG_NORMAL       0x00000001UL
+#define BG_TARGET       0x00000002UL
+#define BG_FORCEFIELD   0x00000004UL
+#define FLASH_LOW       0x00000008UL
+#define FLASH_HIGH      0x00000010UL
+#define FG_WALL         0x00000020UL
+#define FG_MAIN         0x00000040UL
+#define FG_NORMAL       0x00000080UL
+#define FG_DRAGGING     0x00000100UL
+#define FG_SHADOW       0x00000200UL
+#define FG_SOLVEPIECE   0x00000400UL
+#define FG_MAINPIECESH  11
+#define FG_SHADOWSH     19
+
+#define PIECE_LBORDER   0x00000001UL
+#define PIECE_TBORDER   0x00000002UL
+#define PIECE_RBORDER   0x00000004UL
+#define PIECE_BBORDER   0x00000008UL
+#define PIECE_TLCORNER  0x00000010UL
+#define PIECE_TRCORNER  0x00000020UL
+#define PIECE_BLCORNER  0x00000040UL
+#define PIECE_BRCORNER  0x00000080UL
+#define PIECE_MASK      0x000000FFUL
+
+/*
+ * Utility function.
+ */
+#define TYPE_MASK 0xF000
+#define COL_MASK 0x0FFF
+#define TYPE_RECT 0x0000
+#define TYPE_TLCIRC 0x4000
+#define TYPE_TRCIRC 0x5000
+#define TYPE_BLCIRC 0x6000
+#define TYPE_BRCIRC 0x7000
+static void maybe_rect(drawing *dr, int x, int y, int w, int h,
+                       int coltype, int col2)
+{
+    int colour = coltype & COL_MASK, type = coltype & TYPE_MASK;
+
+    if (colour > NCOLOURS)
+        return;
+    if (type == TYPE_RECT) {
+        draw_rect(dr, x, y, w, h, colour);
+    } else {
+        int cx, cy, r;
+
+        clip(dr, x, y, w, h);
+
+        cx = x;
+        cy = y;
+        r = w-1;
+        if (type & 0x1000)
+            cx += r;
+        if (type & 0x2000)
+            cy += r;
+
+        if (col2 == -1 || col2 == coltype) {
+            assert(w == h);
+            draw_circle(dr, cx, cy, r, colour, colour);
+        } else {
+            /*
+             * We aim to draw a quadrant of a circle in two
+             * different colours. We do this using Bresenham's
+             * algorithm directly, because the Puzzles drawing API
+             * doesn't have a draw-sector primitive.
+             */
+            int bx, by, bd, bd2;
+            int xm = (type & 0x1000 ? -1 : +1);
+            int ym = (type & 0x2000 ? -1 : +1);
+
+            by = r;
+            bx = 0;
+            bd = 0;
+            while (by >= bx) {
+                /*
+                 * Plot the point.
+                 */
+                {
+                    int x1 = cx+xm*bx, y1 = cy+ym*bx;
+                    int x2, y2;
+
+                    x2 = cx+xm*by; y2 = y1;
+                    draw_rect(dr, min(x1,x2), min(y1,y2),
+                              abs(x1-x2)+1, abs(y1-y2)+1, colour);
+                    x2 = x1; y2 = cy+ym*by;
+                    draw_rect(dr, min(x1,x2), min(y1,y2),
+                              abs(x1-x2)+1, abs(y1-y2)+1, col2);
+                }
+
+                bd += 2*bx + 1;
+                bd2 = bd - (2*by - 1);
+                if (abs(bd2) < abs(bd)) {
+                    bd = bd2;
+                    by--;
+                }
+                bx++;
+            }
+        }
+
+        unclip(dr);
+    }
+}
+
+static void draw_wallpart(drawing *dr, game_drawstate *ds,
+                          int tx, int ty, unsigned long val,
+                          int cl, int cc, int ch)
+{
+    int coords[6];
+
+    draw_rect(dr, tx, ty, TILESIZE, TILESIZE, cc);
+    if (val & PIECE_LBORDER)
+        draw_rect(dr, tx, ty, HIGHLIGHT_WIDTH, TILESIZE,
+                  ch);
+    if (val & PIECE_RBORDER)
+        draw_rect(dr, tx+TILESIZE-HIGHLIGHT_WIDTH, ty,
+                  HIGHLIGHT_WIDTH, TILESIZE, cl);
+    if (val & PIECE_TBORDER)
+        draw_rect(dr, tx, ty, TILESIZE, HIGHLIGHT_WIDTH, ch);
+    if (val & PIECE_BBORDER)
+        draw_rect(dr, tx, ty+TILESIZE-HIGHLIGHT_WIDTH,
+                  TILESIZE, HIGHLIGHT_WIDTH, cl);
+    if (!((PIECE_BBORDER | PIECE_LBORDER) &~ val)) {
+        draw_rect(dr, tx, ty+TILESIZE-HIGHLIGHT_WIDTH,
+                  HIGHLIGHT_WIDTH, HIGHLIGHT_WIDTH, cl);
+        clip(dr, tx, ty+TILESIZE-HIGHLIGHT_WIDTH,
+             HIGHLIGHT_WIDTH, HIGHLIGHT_WIDTH);
+        coords[0] = tx - 1;
+        coords[1] = ty + TILESIZE - HIGHLIGHT_WIDTH - 1;
+        coords[2] = tx + HIGHLIGHT_WIDTH;
+        coords[3] = ty + TILESIZE - HIGHLIGHT_WIDTH - 1;
+        coords[4] = tx - 1;
+        coords[5] = ty + TILESIZE;
+        draw_polygon(dr, coords, 3, ch, ch);
+        unclip(dr);
+    } else if (val & PIECE_BLCORNER) {
+        draw_rect(dr, tx, ty+TILESIZE-HIGHLIGHT_WIDTH,
+                  HIGHLIGHT_WIDTH, HIGHLIGHT_WIDTH, ch);
+        clip(dr, tx, ty+TILESIZE-HIGHLIGHT_WIDTH,
+             HIGHLIGHT_WIDTH, HIGHLIGHT_WIDTH);
+        coords[0] = tx - 1;
+        coords[1] = ty + TILESIZE - HIGHLIGHT_WIDTH - 1;
+        coords[2] = tx + HIGHLIGHT_WIDTH;
+        coords[3] = ty + TILESIZE - HIGHLIGHT_WIDTH - 1;
+        coords[4] = tx - 1;
+        coords[5] = ty + TILESIZE;
+        draw_polygon(dr, coords, 3, cl, cl);
+        unclip(dr);
+    }
+    if (!((PIECE_TBORDER | PIECE_RBORDER) &~ val)) {
+        draw_rect(dr, tx+TILESIZE-HIGHLIGHT_WIDTH, ty,
+                  HIGHLIGHT_WIDTH, HIGHLIGHT_WIDTH, cl);
+        clip(dr, tx+TILESIZE-HIGHLIGHT_WIDTH, ty,
+             HIGHLIGHT_WIDTH, HIGHLIGHT_WIDTH);
+        coords[0] = tx + TILESIZE - HIGHLIGHT_WIDTH - 1;
+        coords[1] = ty - 1;
+        coords[2] = tx + TILESIZE;
+        coords[3] = ty - 1;
+        coords[4] = tx + TILESIZE - HIGHLIGHT_WIDTH - 1;
+        coords[5] = ty + HIGHLIGHT_WIDTH;
+        draw_polygon(dr, coords, 3, ch, ch);
+        unclip(dr);
+    } else if (val & PIECE_TRCORNER) {
+        draw_rect(dr, tx+TILESIZE-HIGHLIGHT_WIDTH, ty,
+                  HIGHLIGHT_WIDTH, HIGHLIGHT_WIDTH, ch);
+        clip(dr, tx+TILESIZE-HIGHLIGHT_WIDTH, ty,
+             HIGHLIGHT_WIDTH, HIGHLIGHT_WIDTH);
+        coords[0] = tx + TILESIZE - HIGHLIGHT_WIDTH - 1;
+        coords[1] = ty - 1;
+        coords[2] = tx + TILESIZE;
+        coords[3] = ty - 1;
+        coords[4] = tx + TILESIZE - HIGHLIGHT_WIDTH - 1;
+        coords[5] = ty + HIGHLIGHT_WIDTH;
+        draw_polygon(dr, coords, 3, cl, cl);
+        unclip(dr);
+    }
+    if (val & PIECE_TLCORNER)
+        draw_rect(dr, tx, ty, HIGHLIGHT_WIDTH, HIGHLIGHT_WIDTH, ch);
+    if (val & PIECE_BRCORNER)
+        draw_rect(dr, tx+TILESIZE-HIGHLIGHT_WIDTH,
+                  ty+TILESIZE-HIGHLIGHT_WIDTH,
+                  HIGHLIGHT_WIDTH, HIGHLIGHT_WIDTH, cl);
+}
+
+static void draw_piecepart(drawing *dr, game_drawstate *ds,
+                           int tx, int ty, unsigned long val,
+                           int cl, int cc, int ch)
+{
+    int x[6], y[6];
+
+    /*
+     * Drawing the blocks is hellishly fiddly. The blocks don't
+     * stretch to the full size of the tile; there's a border
+     * around them of size BORDER_WIDTH. Then they have bevelled
+     * borders of size HIGHLIGHT_WIDTH, and also rounded corners.
+     *
+     * I tried for some time to find a clean and clever way to
+     * figure out what needed drawing from the corner and border
+     * flags, but in the end the cleanest way I could find was the
+     * following. We divide the grid square into 25 parts by
+     * ruling four horizontal and four vertical lines across it;
+     * those lines are at BORDER_WIDTH and BORDER_WIDTH +
+     * HIGHLIGHT_WIDTH from the top, from the bottom, from the
+     * left and from the right. Then we carefully consider each of
+     * the resulting 25 sections of square, and decide separately
+     * what needs to go in it based on the flags. In complicated
+     * cases there can be up to five possibilities affecting any
+     * given section (no corner or border flags, just the corner
+     * flag, one border flag, the other border flag, both border
+     * flags). So there's a lot of very fiddly logic here and all
+     * I could really think to do was give it my best shot and
+     * then test it and correct all the typos. Not fun to write,
+     * and I'm sure it isn't fun to read either, but it seems to
+     * work.
+     */
+
+    x[0] = tx;
+    x[1] = x[0] + BORDER_WIDTH;
+    x[2] = x[1] + HIGHLIGHT_WIDTH;
+    x[5] = tx + TILESIZE;
+    x[4] = x[5] - BORDER_WIDTH;
+    x[3] = x[4] - HIGHLIGHT_WIDTH;
+
+    y[0] = ty;
+    y[1] = y[0] + BORDER_WIDTH;
+    y[2] = y[1] + HIGHLIGHT_WIDTH;
+    y[5] = ty + TILESIZE;
+    y[4] = y[5] - BORDER_WIDTH;
+    y[3] = y[4] - HIGHLIGHT_WIDTH;
+
+#define RECT(p,q) x[p], y[q], x[(p)+1]-x[p], y[(q)+1]-y[q]
+
+    maybe_rect(dr, RECT(0,0),
+               (val & (PIECE_TLCORNER | PIECE_TBORDER |
+                       PIECE_LBORDER)) ? -1 : cc, -1);
+    maybe_rect(dr, RECT(1,0),
+               (val & PIECE_TLCORNER) ? ch : (val & PIECE_TBORDER) ? -1 :
+               (val & PIECE_LBORDER) ? ch : cc, -1);
+    maybe_rect(dr, RECT(2,0),
+               (val & PIECE_TBORDER) ? -1 : cc, -1);
+    maybe_rect(dr, RECT(3,0),
+               (val & PIECE_TRCORNER) ? cl : (val & PIECE_TBORDER) ? -1 :
+               (val & PIECE_RBORDER) ? cl : cc, -1);
+    maybe_rect(dr, RECT(4,0),
+               (val & (PIECE_TRCORNER | PIECE_TBORDER |
+                       PIECE_RBORDER)) ? -1 : cc, -1);
+    maybe_rect(dr, RECT(0,1),
+               (val & PIECE_TLCORNER) ? ch : (val & PIECE_LBORDER) ? -1 :
+               (val & PIECE_TBORDER) ? ch : cc, -1);
+    maybe_rect(dr, RECT(1,1),
+               (val & PIECE_TLCORNER) ? cc : -1, -1);
+    maybe_rect(dr, RECT(1,1),
+               (val & PIECE_TLCORNER) ? ch | TYPE_TLCIRC :
+               !((PIECE_TBORDER | PIECE_LBORDER) &~ val) ? ch | TYPE_BRCIRC :
+               (val & (PIECE_TBORDER | PIECE_LBORDER)) ? ch : cc, -1);
+    maybe_rect(dr, RECT(2,1),
+               (val & PIECE_TBORDER) ? ch : cc, -1);
+    maybe_rect(dr, RECT(3,1),
+               (val & PIECE_TRCORNER) ? cc : -1, -1);
+    maybe_rect(dr, RECT(3,1),
+               (val & (PIECE_TBORDER | PIECE_RBORDER)) == PIECE_TBORDER ? ch :
+               (val & (PIECE_TBORDER | PIECE_RBORDER)) == PIECE_RBORDER ? cl :
+               !((PIECE_TBORDER|PIECE_RBORDER) &~ val) ? cl | TYPE_BLCIRC :
+               (val & PIECE_TRCORNER) ? cl | TYPE_TRCIRC :
+               cc, ch);
+    maybe_rect(dr, RECT(4,1),
+               (val & PIECE_TRCORNER) ? ch : (val & PIECE_RBORDER) ? -1 :
+               (val & PIECE_TBORDER) ? ch : cc, -1);
+    maybe_rect(dr, RECT(0,2),
+               (val & PIECE_LBORDER) ? -1 : cc, -1);
+    maybe_rect(dr, RECT(1,2),
+               (val & PIECE_LBORDER) ? ch : cc, -1);
+    maybe_rect(dr, RECT(2,2),
+               cc, -1);
+    maybe_rect(dr, RECT(3,2),
+               (val & PIECE_RBORDER) ? cl : cc, -1);
+    maybe_rect(dr, RECT(4,2),
+               (val & PIECE_RBORDER) ? -1 : cc, -1);
+    maybe_rect(dr, RECT(0,3),
+               (val & PIECE_BLCORNER) ? cl : (val & PIECE_LBORDER) ? -1 :
+               (val & PIECE_BBORDER) ? cl : cc, -1);
+    maybe_rect(dr, RECT(1,3),
+               (val & PIECE_BLCORNER) ? cc : -1, -1);
+    maybe_rect(dr, RECT(1,3),
+               (val & (PIECE_BBORDER | PIECE_LBORDER)) == PIECE_BBORDER ? cl :
+               (val & (PIECE_BBORDER | PIECE_LBORDER)) == PIECE_LBORDER ? ch :
+               !((PIECE_BBORDER|PIECE_LBORDER) &~ val) ? ch | TYPE_TRCIRC :
+               (val & PIECE_BLCORNER) ? ch | TYPE_BLCIRC :
+               cc, cl);
+    maybe_rect(dr, RECT(2,3),
+               (val & PIECE_BBORDER) ? cl : cc, -1);
+    maybe_rect(dr, RECT(3,3),
+               (val & PIECE_BRCORNER) ? cc : -1, -1);
+    maybe_rect(dr, RECT(3,3),
+               (val & PIECE_BRCORNER) ? cl | TYPE_BRCIRC :
+               !((PIECE_BBORDER | PIECE_RBORDER) &~ val) ? cl | TYPE_TLCIRC :
+               (val & (PIECE_BBORDER | PIECE_RBORDER)) ? cl : cc, -1);
+    maybe_rect(dr, RECT(4,3),
+               (val & PIECE_BRCORNER) ? cl : (val & PIECE_RBORDER) ? -1 :
+               (val & PIECE_BBORDER) ? cl : cc, -1);
+    maybe_rect(dr, RECT(0,4),
+               (val & (PIECE_BLCORNER | PIECE_BBORDER |
+                       PIECE_LBORDER)) ? -1 : cc, -1);
+    maybe_rect(dr, RECT(1,4),
+               (val & PIECE_BLCORNER) ? ch : (val & PIECE_BBORDER) ? -1 :
+               (val & PIECE_LBORDER) ? ch : cc, -1);
+    maybe_rect(dr, RECT(2,4),
+               (val & PIECE_BBORDER) ? -1 : cc, -1);
+    maybe_rect(dr, RECT(3,4),
+               (val & PIECE_BRCORNER) ? cl : (val & PIECE_BBORDER) ? -1 :
+               (val & PIECE_RBORDER) ? cl : cc, -1);
+    maybe_rect(dr, RECT(4,4),
+               (val & (PIECE_BRCORNER | PIECE_BBORDER |
+                       PIECE_RBORDER)) ? -1 : cc, -1);
+
+#undef RECT
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds,
+                      int x, int y, unsigned long val)
+{
+    int tx = COORD(x), ty = COORD(y);
+    int cc, ch, cl;
+
+    /*
+     * Draw the tile background.
+     */
+    if (val & BG_TARGET)
+        cc = COL_TARGET;
+    else
+        cc = COL_BACKGROUND;
+    ch = cc+1;
+    cl = cc+2;
+    if (val & FLASH_LOW)
+        cc = cl;
+    else if (val & FLASH_HIGH)
+        cc = ch;
+
+    draw_rect(dr, tx, ty, TILESIZE, TILESIZE, cc);
+    if (val & BG_FORCEFIELD) {
+        /*
+         * Cattle-grid effect to indicate that nothing but the
+         * main block can slide over this square.
+         */
+        int n = 3 * (TILESIZE / (3*HIGHLIGHT_WIDTH));
+        int i;
+
+        for (i = 1; i < n; i += 3) {
+            draw_rect(dr, tx,ty+(TILESIZE*i/n), TILESIZE,HIGHLIGHT_WIDTH, cl);
+            draw_rect(dr, tx+(TILESIZE*i/n),ty, HIGHLIGHT_WIDTH,TILESIZE, cl);
+        }
+    }
+
+    /*
+     * Draw the tile midground: a shadow of a block, for
+     * displaying partial solutions.
+     */
+    if (val & FG_SHADOW) {
+        draw_piecepart(dr, ds, tx, ty, (val >> FG_SHADOWSH) & PIECE_MASK,
+                       cl, cl, cl);
+    }
+
+    /*
+     * Draw the tile foreground, i.e. some section of a block or
+     * wall.
+     */
+    if (val & FG_WALL) {
+        cc = COL_BACKGROUND;
+        ch = cc+1;
+        cl = cc+2;
+        if (val & FLASH_LOW)
+            cc = cl;
+        else if (val & FLASH_HIGH)
+            cc = ch;
+
+        draw_wallpart(dr, ds, tx, ty, (val >> FG_MAINPIECESH) & PIECE_MASK,
+                      cl, cc, ch);
+    } else if (val & (FG_MAIN | FG_NORMAL)) {
+        if (val & FG_DRAGGING)
+            cc = (val & FG_MAIN ? COL_MAIN_DRAGGING : COL_DRAGGING);
+        else
+            cc = (val & FG_MAIN ? COL_MAIN : COL_BACKGROUND);
+        ch = cc+1;
+        cl = cc+2;
+
+        if (val & FLASH_LOW)
+            cc = cl;
+        else if (val & (FLASH_HIGH | FG_SOLVEPIECE))
+            cc = ch;
+
+        draw_piecepart(dr, ds, tx, ty, (val >> FG_MAINPIECESH) & PIECE_MASK,
+                       cl, cc, ch);
+    }
+
+    draw_update(dr, tx, ty, TILESIZE, TILESIZE);
+}
+
+static unsigned long find_piecepart(int w, int h, int *dsf, int x, int y)
+{
+    int i = y*w+x;
+    int canon = dsf_canonify(dsf, i);
+    unsigned long val = 0;
+
+    if (x == 0 || canon != dsf_canonify(dsf, i-1))
+        val |= PIECE_LBORDER;
+    if (y== 0 || canon != dsf_canonify(dsf, i-w))
+        val |= PIECE_TBORDER;
+    if (x == w-1 || canon != dsf_canonify(dsf, i+1))
+        val |= PIECE_RBORDER;
+    if (y == h-1 || canon != dsf_canonify(dsf, i+w))
+        val |= PIECE_BBORDER;
+    if (!(val & (PIECE_TBORDER | PIECE_LBORDER)) &&
+        canon != dsf_canonify(dsf, i-1-w))
+        val |= PIECE_TLCORNER;
+    if (!(val & (PIECE_TBORDER | PIECE_RBORDER)) &&
+        canon != dsf_canonify(dsf, i+1-w))
+        val |= PIECE_TRCORNER;
+    if (!(val & (PIECE_BBORDER | PIECE_LBORDER)) &&
+        canon != dsf_canonify(dsf, i-1+w))
+        val |= PIECE_BLCORNER;
+    if (!(val & (PIECE_BBORDER | PIECE_RBORDER)) &&
+        canon != dsf_canonify(dsf, i+1+w))
+        val |= PIECE_BRCORNER;
+    return val;
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->w, h = state->h, wh = w*h;
+    unsigned char *board;
+    int *dsf;
+    int x, y, mainanchor, mainpos, dragpos, solvepos, solvesrc, solvedst;
+
+    if (!ds->started) {
+        /*
+         * The initial contents of the window are not guaranteed
+         * and can vary with front ends. To be on the safe side,
+         * all games should start by drawing a big
+         * background-colour rectangle covering the whole window.
+         */
+        draw_rect(dr, 0, 0, 10*ds->tilesize, 10*ds->tilesize, COL_BACKGROUND);
+        ds->started = TRUE;
+    }
+
+    /*
+     * Construct the board we'll be displaying (which may be
+     * different from the one in state if ui describes a drag in
+     * progress).
+     */
+    board = snewn(wh, unsigned char);
+    memcpy(board, state->board, wh);
+    if (ui->dragging) {
+        int mpret = move_piece(w, h, state->board, board,
+                               state->imm->forcefield,
+                               ui->drag_anchor, ui->drag_currpos);
+        assert(mpret);
+    }
+
+    if (state->soln) {
+        solvesrc = state->soln->moves[state->soln_index*2];
+        solvedst = state->soln->moves[state->soln_index*2+1];
+        if (solvesrc == state->lastmoved_pos)
+            solvesrc = state->lastmoved;
+        if (solvesrc == ui->drag_anchor)
+            solvesrc = ui->drag_currpos;
+    } else
+        solvesrc = solvedst = -1;
+
+    /*
+     * Build a dsf out of that board, so we can conveniently tell
+     * which edges are connected and which aren't.
+     */
+    dsf = snew_dsf(wh);
+    mainanchor = -1;
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int i = y*w+x;
+
+            if (ISDIST(board[i]))
+                dsf_merge(dsf, i, i - board[i]);
+            if (board[i] == MAINANCHOR)
+                mainanchor = i;
+            if (board[i] == WALL) {
+                if (x > 0 && board[i-1] == WALL)
+                    dsf_merge(dsf, i, i-1);
+                if (y > 0 && board[i-w] == WALL)
+                    dsf_merge(dsf, i, i-w);
+            }
+        }
+    assert(mainanchor >= 0);
+    mainpos = dsf_canonify(dsf, mainanchor);
+    dragpos = ui->drag_currpos > 0 ? dsf_canonify(dsf, ui->drag_currpos) : -1;
+    solvepos = solvesrc >= 0 ? dsf_canonify(dsf, solvesrc) : -1;
+
+    /*
+     * Now we can construct the data about what we want to draw.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int i = y*w+x;
+            int j;
+            unsigned long val;
+            int canon;
+
+            /*
+             * See if this square is part of the target area.
+             */
+            j = i + mainanchor - (state->ty * w + state->tx);
+            while (j >= 0 && j < wh && ISDIST(board[j]))
+                j -= board[j];
+            if (j == mainanchor)
+                val = BG_TARGET;
+            else
+                val = BG_NORMAL;
+
+            if (state->imm->forcefield[i])
+                val |= BG_FORCEFIELD;
+
+            if (flashtime > 0) {
+                int flashtype = (int)(flashtime / FLASH_INTERVAL) & 1;
+                val |= (flashtype ? FLASH_LOW : FLASH_HIGH);
+            }
+
+            if (board[i] != EMPTY) {
+                canon = dsf_canonify(dsf, i);
+
+                if (board[i] == WALL)
+                    val |= FG_WALL;
+                else if (canon == mainpos)
+                    val |= FG_MAIN;
+                else
+                    val |= FG_NORMAL;
+                if (canon == dragpos)
+                    val |= FG_DRAGGING;
+                if (canon == solvepos)
+                    val |= FG_SOLVEPIECE;
+
+                /*
+                 * Now look around to see if other squares
+                 * belonging to the same block are adjacent to us.
+                 */
+                val |= find_piecepart(w, h, dsf, x, y) << FG_MAINPIECESH;
+            }
+
+            /*
+             * If we're in the middle of showing a solution,
+             * display a shadow piece for the target of the
+             * current move.
+             */
+            if (solvepos >= 0) {
+                int si = i - solvedst + solvesrc;
+                if (si >= 0 && si < wh && dsf_canonify(dsf, si) == solvepos) {
+                    val |= find_piecepart(w, h, dsf,
+                                          si % w, si / w) << FG_SHADOWSH;
+                    val |= FG_SHADOW;
+                }
+            }
+
+            if (val != ds->grid[i]) {
+                draw_tile(dr, ds, x, y, val);
+                ds->grid[i] = val;
+            }
+        }
+
+    /*
+     * Update the status bar.
+     */
+    {
+        char statusbuf[256];
+
+        sprintf(statusbuf, "%sMoves: %d",
+                (state->completed >= 0 ?
+                 (state->cheated ? "Auto-solved. " : "COMPLETED! ") :
+                 (state->cheated ? "Auto-solver used. " : "")),
+                (state->completed >= 0 ? state->completed : state->movecount));
+        if (state->minmoves >= 0)
+            sprintf(statusbuf+strlen(statusbuf), " (min %d)",
+                    state->minmoves);
+
+        status_bar(dr, statusbuf);
+    }
+
+    sfree(dsf);
+    sfree(board);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (oldstate->completed < 0 && newstate->completed >= 0)
+        return FLASH_TIME;
+
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame slide
+#endif
+
+const struct game thegame = {
+    "Slide", NULL, NULL,
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,                              /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
+
+#ifdef STANDALONE_SOLVER
+
+#include <stdarg.h>
+
+int main(int argc, char **argv)
+{
+    game_params *p;
+    game_state *s;
+    char *id = NULL, *desc, *err;
+    int count = FALSE;
+    int ret;
+    int *moves;
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        /*
+        if (!strcmp(p, "-v")) {
+            verbose = TRUE;
+        } else
+        */
+        if (!strcmp(p, "-c")) {
+            count = TRUE;
+        } else if (*p == '-') {
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s [-c | -v] <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    ret = solve_board(s->w, s->h, s->board, s->imm->forcefield,
+                      s->tx, s->ty, -1, &moves);
+    if (ret < 0) {
+        printf("No solution found\n");
+    } else {
+        int index = 0;
+        if (count) {
+            printf("%d moves required\n", ret);
+            return 0;
+        }
+        while (1) {
+            int moveret;
+            char *text = board_text_format(s->w, s->h, s->board,
+                                           s->imm->forcefield);
+            game_state *s2;
+
+            printf("position %d:\n%s", index, text);
+
+            if (index >= ret)
+                break;
+
+            s2 = dup_game(s);
+            moveret = move_piece(s->w, s->h, s->board,
+                                 s2->board, s->imm->forcefield,
+                                 moves[index*2], moves[index*2+1]);
+            assert(moveret);
+
+            free_game(s);
+            s = s2;
+            index++;
+        }
+    }
+
+    return 0;
+}
+
+#endif
diff --git a/apps/plugins/puzzles/unfinished/sokoban.R b/apps/plugins/puzzles/unfinished/sokoban.R
new file mode 100644
index 0000000000..3b6dab56ba
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/sokoban.R
@@ -0,0 +1,19 @@
+# -*- makefile -*-
+
+sokoban  : [X] GTK COMMON sokoban sokoban-icon|no-icon
+
+sokoban  : [G] WINDOWS COMMON sokoban sokoban.res?
+
+ALL += sokoban[COMBINED]
+
+!begin am gtk
+GAMES += sokoban
+!end
+
+!begin >list.c
+    A(sokoban) \
+!end
+
+!begin >gamedesc.txt
+sokoban:sokoban.exe:Sokoban:Barrel-pushing puzzle:Push all the barrels into the target squares.
+!end
diff --git a/apps/plugins/puzzles/unfinished/sokoban.c b/apps/plugins/puzzles/unfinished/sokoban.c
new file mode 100644
index 0000000000..b5533c9034
--- /dev/null
+++ b/apps/plugins/puzzles/unfinished/sokoban.c
@@ -0,0 +1,1479 @@
+/*
+ * sokoban.c: An implementation of the well-known Sokoban barrel-
+ * pushing game. Random generation is too simplistic to be
+ * credible, but the rest of the gameplay works well enough to use
+ * it with hand-written level descriptions.
+ */
+
+/*
+ * TODO:
+ * 
+ *  - I think it would be better to ditch the `prev' array, and
+ *    instead make the `dist' array strictly monotonic (by having
+ *    each distance be something like I*A+S, where A is the grid
+ *    area, I the number of INITIAL squares trampled on, and S the
+ *    number of harmless spaces moved through). This would permit
+ *    the path-tracing when a pull is actually made to choose
+ *    randomly from all the possible shortest routes, which would
+ *    be superior in terms of eliminating directional bias.
+ *     + So when tracing the path back to the current px,py, we
+ *       look at all four adjacent squares, find the minimum
+ *       distance, check that it's _strictly smaller_ than that of
+ *       the current square, and restrict our choice to precisely
+ *       those squares with that minimum distance.
+ *     + The other place `prev' is currently used is in the check
+ *       for consistency of a pull. We would have to replace the
+ *       check for whether prev[ny*w+nx]==oy*w+ox with a check that
+ *       made sure there was at least one adjacent square with a
+ *       smaller distance which _wasn't_ oy*w+ox. Then when we did
+ *       the path-tracing we'd also have to take this special case
+ *       into account.
+ * 
+ *  - More discriminating choice of pull. (Snigger.)
+ *     + favour putting targets in clumps
+ *     + try to shoot for a reasonably consistent number of barrels
+ *       (adjust willingness to generate a new barrel depending on
+ *       how many are already present)
+ *     + adjust willingness to break new ground depending on how
+ *       much is already broken
+ * 
+ *  - generation time parameters:
+ *     + enable NetHack mode (and find a better place for the hole)
+ *     + decide how many of the remaining Is should be walls
+ * 
+ *  - at the end of generation, randomly position the starting
+ *    player coordinates, probably by (somehow) reusing the same
+ *    bfs currently inside the loop.
+ * 
+ *  - possible backtracking?
+ * 
+ *  - IWBNI we could spot completely unreachable bits of level at
+ *    the outside, and not bother drawing grid lines for them. The
+ *    NH levels currently look a bit weird with grid lines on the
+ *    outside of the boundary.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+/*
+ * Various subsets of these constants are used during game
+ * generation, game play, game IDs and the game_drawstate.
+ */
+#define INITIAL      'i'               /* used only in game generation */
+#define SPACE        's'
+#define WALL         'w'
+#define PIT          'p'
+#define DEEP_PIT     'd'
+#define TARGET       't'
+#define BARREL       'b'
+#define BARRELTARGET 'f'               /* target is 'f'illed */
+#define PLAYER       'u'               /* yo'u'; used in game IDs */
+#define PLAYERTARGET 'v'               /* bad letter: v is to u as t is to s */
+#define INVALID      '!'               /* used in drawstate to force redraw */
+/*
+ * We also support the use of any capital letter as a barrel, which
+ * will be displayed with that letter as a label. (This facilitates
+ * people distributing annotated game IDs for particular Sokoban
+ * levels, so they can accompany them with verbal instructions
+ * about pushing particular barrels in particular ways.) Therefore,
+ * to find out whether something is a barrel, we need a test
+ * function which does a bit more than just comparing to BARREL.
+ * 
+ * When resting on target squares, capital-letter barrels are
+ * replaced with their control-character value (A -> ^A).
+ */
+#define IS_PLAYER(c) ( (c)==PLAYER || (c)==PLAYERTARGET )
+#define IS_BARREL(c) ( (c)==BARREL || (c)==BARRELTARGET || \
+                       ((c)>='A' && (c)<='Z') || ((c)>=1 && (c)<=26) )
+#define IS_ON_TARGET(c) ( (c)==TARGET || (c)==BARRELTARGET || \
+                          (c)==PLAYERTARGET || ((c)>=1 && (c)<=26) )
+#define TARGETISE(b) ( (b)==BARREL ? BARRELTARGET : (b)-('A'-1) )
+#define DETARGETISE(b) ( (b)==BARRELTARGET ? BARREL : (b)+('A'-1) )
+#define BARREL_LABEL(b) ( (b)>='A'&&(b)<='Z' ? (b) : \
+                          (b)>=1 && (b)<=26 ? (b)+('A'-1) : 0 )
+
+#define DX(d) (d == 0 ? -1 : d == 2 ? +1 : 0)
+#define DY(d) (d == 1 ? -1 : d == 3 ? +1 : 0)
+
+#define FLASH_LENGTH 0.3F
+
+enum {
+    COL_BACKGROUND,
+    COL_TARGET,
+    COL_PIT,
+    COL_DEEP_PIT,
+    COL_BARREL,
+    COL_PLAYER,
+    COL_TEXT,
+    COL_GRID,
+    COL_OUTLINE,
+    COL_HIGHLIGHT,
+    COL_LOWLIGHT,
+    COL_WALL,
+    NCOLOURS
+};
+
+struct game_params {
+    int w, h;
+    /*
+     * FIXME: a parameter involving degree of filling in?
+     */
+};
+
+struct game_state {
+    game_params p;
+    unsigned char *grid;
+    int px, py;
+    int completed;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = 12;
+    ret->h = 10;
+
+    return ret;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static const struct game_params sokoban_presets[] = {
+    { 12, 10 },
+    { 16, 12 },
+    { 20, 16 },
+};
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params p, *ret;
+    char *retname;
+    char namebuf[80];
+
+    if (i < 0 || i >= lenof(sokoban_presets))
+        return FALSE;
+
+    p = sokoban_presets[i];
+    ret = dup_params(&p);
+    sprintf(namebuf, "%dx%d", ret->w, ret->h);
+    retname = dupstr(namebuf);
+
+    *params = ret;
+    *name = retname;
+    return TRUE;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->w = params->h = atoi(string);
+    while (*string && isdigit((unsigned char)*string)) string++;
+    if (*string == 'x') {
+        string++;
+        params->h = atoi(string);
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char data[256];
+
+    sprintf(data, "%dx%d", params->w, params->h);
+
+    return dupstr(data);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(3, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = NULL;
+    ret[2].type = C_END;
+    ret[2].sval = NULL;
+    ret[2].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].sval);
+    ret->h = atoi(cfg[1].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->w < 4 || params->h < 4)
+        return "Width and height must both be at least 4";
+
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Game generation mechanism.
+ * 
+ * To generate a Sokoban level, we begin with a completely blank
+ * grid and make valid inverse moves. Grid squares can be in a
+ * number of states. The states are:
+ * 
+ *  - INITIAL: this square has not as yet been touched by any
+ *    inverse move, which essentially means we haven't decided what
+ *    it is yet.
+ * 
+ *  - SPACE: this square is a space.
+ * 
+ *  - TARGET: this square is a space which is also the target for a
+ *    barrel.
+ * 
+ *  - BARREL: this square contains a barrel.
+ * 
+ *  - BARRELTARGET: this square contains a barrel _on_ a target.
+ * 
+ *  - WALL: this square is a wall.
+ * 
+ *  - PLAYER: this square contains the player.
+ * 
+ *  - PLAYERTARGET: this square contains the player on a target.
+ * 
+ * We begin with every square of the in state INITIAL, apart from a
+ * solid ring of WALLs around the edge. We randomly position the
+ * PLAYER somewhere. Thereafter our valid moves are:
+ * 
+ *  - to move the PLAYER in one direction _pulling_ a barrel after
+ *    us. For this to work, we must have SPACE or INITIAL in the
+ *    direction we're moving, and BARREL or BARRELTARGET in the
+ *    direction we're moving away from. We leave SPACE or TARGET
+ *    respectively in the vacated square.
+ * 
+ *  - to create a new barrel by transforming an INITIAL square into
+ *    BARRELTARGET.
+ * 
+ *  - to move the PLAYER freely through SPACE and TARGET squares,
+ *    leaving SPACE or TARGET where it started.
+ * 
+ *  - to move the player through INITIAL squares, carving a tunnel
+ *    of SPACEs as it goes.
+ * 
+ * We try to avoid destroying INITIAL squares wherever possible (if
+ * there's a path to where we want to be using only SPACE, then we
+ * should always use that). At the end of generation, every square
+ * still in state INITIAL is one which was not required at any
+ * point during generation, which means we can randomly choose
+ * whether to make it SPACE or WALL.
+ * 
+ * It's unclear as yet what the right strategy for wall placement
+ * should be. Too few WALLs will yield many alternative solutions
+ * to the puzzle, whereas too many might rule out so many
+ * possibilities that the intended solution becomes obvious.
+ */
+
+static void sokoban_generate(int w, int h, unsigned char *grid, int moves,
+                             int nethack, random_state *rs)
+{
+    struct pull {
+        int ox, oy, nx, ny, score;
+    };
+
+    struct pull *pulls;
+    int *dist, *prev, *heap;
+    int x, y, px, py, i, j, d, heapsize, npulls;
+
+    pulls = snewn(w * h * 4, struct pull);
+    dist = snewn(w * h, int);
+    prev = snewn(w * h, int);
+    heap = snewn(w * h, int);
+
+    /*
+     * Configure the initial grid.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            grid[y*w+x] = (x == 0 || y == 0 || x == w-1 || y == h-1 ?
+                           WALL : INITIAL);
+    if (nethack)
+        grid[1] = DEEP_PIT;
+
+    /*
+     * Place the player.
+     */
+    i = random_upto(rs, (w-2) * (h-2));
+    x = 1 + i % (w-2);
+    y = 1 + i / (w-2);
+    grid[y*w+x] = SPACE;
+    px = x;
+    py = y;
+
+    /*
+     * Now loop around making random inverse Sokoban moves. In this
+     * loop we aim to make one actual barrel-pull per iteration,
+     * plus as many free moves as are necessary to get into
+     * position for that pull.
+     */
+    while (moves-- >= 0) {
+        /*
+         * First enumerate all the viable barrel-pulls we can
+         * possibly make, counting two pulls of the same barrel in
+         * different directions as different. We also include pulls
+         * we can perform by creating a new barrel. Each pull is
+         * marked with the amount of violence it would have to do
+         * to the grid.
+         */
+        npulls = 0;
+        for (y = 0; y < h; y++)
+            for (x = 0; x < w; x++)
+                for (d = 0; d < 4; d++) {
+                    int dx = DX(d);
+                    int dy = DY(d);
+                    int nx = x + dx, ny = y + dy;
+                    int npx = nx + dx, npy = ny + dy;
+                    int score = 0;
+
+                    /*
+                     * The candidate move is to put the player at
+                     * (nx,ny), and move him to (npx,npy), pulling
+                     * a barrel at (x,y) to (nx,ny). So first we
+                     * must check that all those squares are within
+                     * the boundaries of the grid. For this it is
+                     * sufficient to check npx,npy.
+                     */
+                    if (npx < 0 || npx >= w || npy < 0 || npy >= h)
+                        continue;
+
+                    /*
+                     * (x,y) must either be a barrel, or a square
+                     * which we can convert into a barrel.
+                     */
+                    switch (grid[y*w+x]) {
+                      case BARREL: case BARRELTARGET:
+                        break;
+                      case INITIAL:
+                        if (nethack)
+                            continue;
+                        score += 10 /* new_barrel_score */;
+                        break;
+                      case DEEP_PIT:
+                        if (!nethack)
+                            continue;
+                        break;
+                      default:
+                        continue;
+                    }
+
+                    /*
+                     * (nx,ny) must either be a space, or a square
+                     * which we can convert into a space.
+                     */
+                    switch (grid[ny*w+nx]) {
+                      case SPACE: case TARGET:
+                        break;
+                      case INITIAL:
+                        score += 3 /* new_space_score */;
+                        break;
+                      default:
+                        continue;
+                    }
+
+                    /*
+                     * (npx,npy) must also either be a space, or a
+                     * square which we can convert into a space.
+                     */
+                    switch (grid[npy*w+npx]) {
+                      case SPACE: case TARGET:
+                        break;
+                      case INITIAL:
+                        score += 3 /* new_space_score */;
+                        break;
+                      default:
+                        continue;
+                    }
+
+                    /*
+                     * That's sufficient to tag this as a possible
+                     * pull right now. We still don't know if we
+                     * can reach the required player position, but
+                     * that's a job for the subsequent BFS phase to
+                     * tell us.
+                     */
+                    pulls[npulls].ox = x;
+                    pulls[npulls].oy = y;
+                    pulls[npulls].nx = nx;
+                    pulls[npulls].ny = ny;
+                    pulls[npulls].score = score;
+#ifdef GENERATION_DIAGNOSTICS
+                    printf("found potential pull: (%d,%d)-(%d,%d) cost %d\n",
+                           pulls[npulls].ox, pulls[npulls].oy,
+                           pulls[npulls].nx, pulls[npulls].ny,
+                           pulls[npulls].score);
+#endif
+                    npulls++;
+                }
+#ifdef GENERATION_DIAGNOSTICS
+        printf("found %d potential pulls\n", npulls);
+#endif
+
+        /*
+         * If there are no pulls available at all, we give up.
+         * 
+         * (FIXME: or perhaps backtrack?)
+         */
+        if (npulls == 0)
+            break;
+
+        /*
+         * Now we do a BFS from our current position, to find all
+         * the squares we can get the player into.
+         * 
+         * This BFS is unusually tricky. We want to give a positive
+         * distance only to squares which we have to carve through
+         * INITIALs to get to, which means we can't just stick
+         * every square we reach on the end of our to-do list.
+         * Instead, we must maintain our list as a proper priority
+         * queue.
+         */
+        for (i = 0; i < w*h; i++)
+            dist[i] = prev[i] = -1;
+
+        heap[0] = py*w+px;
+        heapsize = 1;
+        dist[py*w+px] = 0;
+
+#define PARENT(n) ( ((n)-1)/2 )
+#define LCHILD(n) ( 2*(n)+1 )
+#define RCHILD(n) ( 2*(n)+2 )
+#define SWAP(i,j) do { int swaptmp = (i); (i) = (j); (j) = swaptmp; } while (0)
+
+        while (heapsize > 0) {
+            /*
+             * Pull the smallest element off the heap: it's at
+             * position 0. Move the arbitrary element from the very
+             * end of the heap into position 0.
+             */
+            y = heap[0] / w;
+            x = heap[0] % w;
+
+            heapsize--;
+            heap[0] = heap[heapsize];
+
+            /*
+             * Now repeatedly move that arbitrary element down the
+             * heap by swapping it with the more suitable of its
+             * children.
+             */
+            i = 0;
+            while (1) {
+                int lc, rc;
+
+                lc = LCHILD(i);
+                rc = RCHILD(i);
+
+                if (lc >= heapsize)
+                    break;             /* we've hit bottom */
+
+                if (rc >= heapsize) {
+                    /*
+                     * Special case: there is only one child to
+                     * check.
+                     */
+                    if (dist[heap[i]] > dist[heap[lc]])
+                        SWAP(heap[i], heap[lc]);
+
+                    /* _Now_ we've hit bottom. */
+                    break;
+                } else {
+                    /*
+                     * The common case: there are two children and
+                     * we must check them both.
+                     */
+                    if (dist[heap[i]] > dist[heap[lc]] ||
+                        dist[heap[i]] > dist[heap[rc]]) {
+                        /*
+                         * Pick the more appropriate child to swap with
+                         * (i.e. the one which would want to be the
+                         * parent if one were above the other - as one
+                         * is about to be).
+                         */
+                        if (dist[heap[lc]] > dist[heap[rc]]) {
+                            SWAP(heap[i], heap[rc]);
+                            i = rc;
+                        } else {
+                            SWAP(heap[i], heap[lc]);
+                            i = lc;
+                        }
+                    } else {
+                        /* This element is in the right place; we're done. */
+                        break;
+                    }
+                }
+            }
+
+            /*
+             * OK, that's given us (x,y) for this phase of the
+             * search. Now try all directions from here.
+             */
+
+            for (d = 0; d < 4; d++) {
+                int dx = DX(d);
+                int dy = DY(d);
+                int nx = x + dx, ny = y + dy;
+                if (nx < 0 || nx >= w || ny < 0 || ny >= h)
+                    continue;
+                if (grid[ny*w+nx] != SPACE && grid[ny*w+nx] != TARGET &&
+                    grid[ny*w+nx] != INITIAL)
+                    continue;
+                if (dist[ny*w+nx] == -1) {
+                    dist[ny*w+nx] = dist[y*w+x] + (grid[ny*w+nx] == INITIAL);
+                    prev[ny*w+nx] = y*w+x;
+
+                    /*
+                     * Now insert ny*w+nx at the end of the heap,
+                     * and move it down to its appropriate resting
+                     * place.
+                     */
+                    i = heapsize;
+                    heap[heapsize++] = ny*w+nx;
+
+                    /*
+                     * Swap element n with its parent repeatedly to
+                     * preserve the heap property.
+                     */
+
+                    while (i > 0) {
+                        int p = PARENT(i);
+
+                        if (dist[heap[p]] > dist[heap[i]]) {
+                            SWAP(heap[p], heap[i]);
+                            i = p;
+                        } else
+                            break;
+                    }
+                }
+            }
+        }
+
+#undef PARENT
+#undef LCHILD
+#undef RCHILD
+#undef SWAP
+
+#ifdef GENERATION_DIAGNOSTICS
+        printf("distance map:\n");
+        for (i = 0; i < h; i++) {
+            for (j = 0; j < w; j++) {
+                int d = dist[i*w+j];
+                int c;
+                if (d < 0)
+                    c = '#';
+                else if (d >= 36)
+                    c = '!';
+                else if (d >= 10)
+                    c = 'A' - 10 + d;
+                else
+                    c = '0' + d;
+                putchar(c);
+            }
+            putchar('\n');
+        }
+#endif
+
+        /*
+         * Now we can go back through the `pulls' array, adjusting
+         * the score for each pull depending on how hard it is to
+         * reach its starting point, and also throwing out any
+         * whose starting points are genuinely unreachable even
+         * with the possibility of carving through INITIAL squares.
+         */
+        for (i = j = 0; i < npulls; i++) {
+#ifdef GENERATION_DIAGNOSTICS
+            printf("potential pull (%d,%d)-(%d,%d)",
+                   pulls[i].ox, pulls[i].oy,
+                   pulls[i].nx, pulls[i].ny);
+#endif
+            x = pulls[i].nx;
+            y = pulls[i].ny;
+            if (dist[y*w+x] < 0) {
+#ifdef GENERATION_DIAGNOSTICS
+                printf(" unreachable\n");
+#endif
+                continue;              /* this pull isn't feasible at all */
+            } else {
+                /*
+                 * Another nasty special case we have to check is
+                 * whether the initial barrel location (ox,oy) is
+                 * on the path used to reach the square. This can
+                 * occur if that square is in state INITIAL: the
+                 * pull is initially considered valid on the basis
+                 * that the INITIAL can become BARRELTARGET, and
+                 * it's also considered reachable on the basis that
+                 * INITIAL can be turned into SPACE, but it can't
+                 * be both at once.
+                 * 
+                 * Fortunately, if (ox,oy) is on the path at all,
+                 * it must be only one space from the end, so this
+                 * is easy to spot and rule out.
+                 */
+                if (prev[y*w+x] == pulls[i].oy*w+pulls[i].ox) {
+#ifdef GENERATION_DIAGNOSTICS
+                    printf(" goes through itself\n");
+#endif
+                    continue;          /* this pull isn't feasible at all */
+                }
+                pulls[j] = pulls[i];   /* structure copy */
+                pulls[j].score += dist[y*w+x] * 3 /* new_space_score */;
+#ifdef GENERATION_DIAGNOSTICS
+                printf(" reachable at distance %d (cost now %d)\n",
+                       dist[y*w+x], pulls[j].score);
+#endif
+                j++;
+            }
+        }
+        npulls = j;
+
+        /*
+         * Again, if there are no pulls available at all, we give
+         * up.
+         * 
+         * (FIXME: or perhaps backtrack?)
+         */
+        if (npulls == 0)
+            break;
+
+        /*
+         * Now choose which pull to make. On the one hand we should
+         * prefer pulls which do less damage to the INITIAL squares
+         * (thus, ones for which we can already get into position
+         * via existing SPACEs, and for which the barrel already
+         * exists and doesn't have to be invented); on the other,
+         * we want to avoid _always_ preferring such pulls, on the
+         * grounds that that will lead to levels without very much
+         * stuff in.
+         * 
+         * When creating new barrels, we prefer creations which are
+         * next to existing TARGET squares.
+         * 
+         * FIXME: for the moment I'll make this very simple indeed.
+         */
+        i = random_upto(rs, npulls);
+
+        /*
+         * Actually make the pull, including carving a path to get
+         * to the site if necessary.
+         */
+        x = pulls[i].nx;
+        y = pulls[i].ny;
+        while (prev[y*w+x] >= 0) {
+            int p;
+
+            if (grid[y*w+x] == INITIAL)
+                grid[y*w+x] = SPACE;
+
+            p = prev[y*w+x];
+            y = p / w;
+            x = p % w;
+        }
+        px = 2*pulls[i].nx - pulls[i].ox;
+        py = 2*pulls[i].ny - pulls[i].oy;
+        if (grid[py*w+px] == INITIAL)
+            grid[py*w+px] = SPACE;
+        if (grid[pulls[i].ny*w+pulls[i].nx] == TARGET)
+            grid[pulls[i].ny*w+pulls[i].nx] = BARRELTARGET;
+        else
+            grid[pulls[i].ny*w+pulls[i].nx] = BARREL;
+        if (grid[pulls[i].oy*w+pulls[i].ox] == BARREL)
+            grid[pulls[i].oy*w+pulls[i].ox] = SPACE;
+        else if (grid[pulls[i].oy*w+pulls[i].ox] != DEEP_PIT)
+            grid[pulls[i].oy*w+pulls[i].ox] = TARGET;
+    }
+
+    sfree(heap);
+    sfree(prev);
+    sfree(dist);
+    sfree(pulls);
+
+    if (grid[py*w+px] == TARGET)
+        grid[py*w+px] = PLAYERTARGET;
+    else
+        grid[py*w+px] = PLAYER;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int w = params->w, h = params->h;
+    char *desc;
+    int desclen, descpos, descsize, prev, count;
+    unsigned char *grid;
+    int i, j;
+
+    /*
+     * FIXME: perhaps some more interesting means of choosing how
+     * many moves to try?
+     */
+    grid = snewn(w*h, unsigned char);
+    sokoban_generate(w, h, grid, w*h, FALSE, rs);
+
+    desclen = descpos = descsize = 0;
+    desc = NULL;
+    prev = -1;
+    count = 0;
+    for (i = 0; i < w*h; i++) {
+        if (descsize < desclen + 40) {
+            descsize = desclen + 100;
+            desc = sresize(desc, descsize, char);
+            desc[desclen] = '\0';
+        }
+        switch (grid[i]) {
+          case INITIAL:
+            j = 'w';                   /* FIXME: make some of these 's'? */
+            break;
+          case SPACE:
+            j = 's';
+            break;
+          case WALL:
+            j = 'w';
+            break;
+          case TARGET:
+            j = 't';
+            break;
+          case BARREL:
+            j = 'b';
+            break;
+          case BARRELTARGET:
+            j = 'f';
+            break;
+          case DEEP_PIT:
+            j = 'd';
+            break;
+          case PLAYER:
+            j = 'u';
+            break;
+          case PLAYERTARGET:
+            j = 'v';
+            break;
+          default:
+            j = '?';
+            break;
+        }
+        assert(j != '?');
+        if (j != prev) {
+            desc[desclen++] = j;
+            descpos = desclen;
+            prev = j;
+            count = 1;
+        } else {
+            count++;
+            desclen = descpos + sprintf(desc+descpos, "%d", count);
+        }
+    }
+
+    sfree(grid);
+
+    return desc;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, h = params->h;
+    int area = 0;
+    int nplayers = 0;
+
+    while (*desc) {
+        int c = *desc++;
+        int n = 1;
+        if (*desc && isdigit((unsigned char)*desc)) {
+            n = atoi(desc);
+            while (*desc && isdigit((unsigned char)*desc)) desc++;
+        }
+
+        area += n;
+
+        if (c == PLAYER || c == PLAYERTARGET)
+            nplayers += n;
+        else if (c == INITIAL || c == SPACE || c == WALL || c == TARGET ||
+                 c == PIT || c == DEEP_PIT || IS_BARREL(c))
+            /* ok */;
+        else
+            return "Invalid character in game description";
+    }
+
+    if (area > w*h)
+        return "Too much data in game description";
+    if (area < w*h)
+        return "Too little data in game description";
+    if (nplayers < 1)
+        return "No starting player position specified";
+    if (nplayers > 1)
+        return "More than one starting player position specified";
+
+    return NULL;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w = params->w, h = params->h;
+    game_state *state = snew(game_state);
+    int i;
+
+    state->p = *params;                /* structure copy */
+    state->grid = snewn(w*h, unsigned char);
+    state->px = state->py = -1;
+    state->completed = FALSE;
+
+    i = 0;
+
+    while (*desc) {
+        int c = *desc++;
+        int n = 1;
+        if (*desc && isdigit((unsigned char)*desc)) {
+            n = atoi(desc);
+            while (*desc && isdigit((unsigned char)*desc)) desc++;
+        }
+
+        if (c == PLAYER || c == PLAYERTARGET) {
+            state->py = i / w;
+            state->px = i % w;
+            c = IS_ON_TARGET(c) ? TARGET : SPACE;
+        }
+
+        while (n-- > 0)
+            state->grid[i++] = c;
+    }
+
+    assert(i == w*h);
+    assert(state->px != -1 && state->py != -1);
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w = state->p.w, h = state->p.h;
+    game_state *ret = snew(game_state);
+
+    ret->p = state->p;                 /* structure copy */
+    ret->grid = snewn(w*h, unsigned char);
+    memcpy(ret->grid, state->grid, w*h);
+    ret->px = state->px;
+    ret->py = state->py;
+    ret->completed = state->completed;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    return NULL;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+static game_ui *new_ui(const game_state *state)
+{
+    return NULL;
+}
+
+static void free_ui(game_ui *ui)
+{
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    game_params p;
+    int tilesize;
+    int started;
+    unsigned short *grid;
+};
+
+#define PREFERRED_TILESIZE 32
+#define TILESIZE (ds->tilesize)
+#define BORDER    (TILESIZE)
+#define HIGHLIGHT_WIDTH (TILESIZE / 10)
+#define COORD(x)  ( (x) * TILESIZE + BORDER )
+#define FROMCOORD(x)  ( ((x) - BORDER + TILESIZE) / TILESIZE - 1 )
+
+/*
+ * I'm going to need to do most of the move-type analysis in both
+ * interpret_move and execute_move, so I'll abstract it out into a
+ * subfunction. move_type() returns -1 for an illegal move, 0 for a
+ * movement, and 1 for a push.
+ */
+int move_type(game_state *state, int dx, int dy)
+{
+    int w = state->p.w, h = state->p.h;
+    int px = state->px, py = state->py;
+    int nx, ny, nbx, nby;
+
+    assert(dx >= -1 && dx <= +1);
+    assert(dy >= -1 && dy <= +1);
+    assert(dx || dy);
+
+    nx = px + dx;
+    ny = py + dy;
+
+    /*
+     * Disallow any move that goes off the grid.
+     */
+    if (nx < 0 || nx >= w || ny < 0 || ny >= h)
+        return -1;
+
+    /*
+     * Examine the target square of the move to see whether it's a
+     * space, a barrel, or a wall.
+     */
+
+    if (state->grid[ny*w+nx] == WALL ||
+        state->grid[ny*w+nx] == PIT ||
+        state->grid[ny*w+nx] == DEEP_PIT)
+        return -1;                     /* this one's easy; just disallow it */
+
+    if (IS_BARREL(state->grid[ny*w+nx])) {
+        /*
+         * This is a push move. For a start, that means it must not
+         * be diagonal.
+         */
+        if (dy && dx)
+            return -1;
+
+        /*
+         * Now find the location of the third square involved in
+         * the push, and stop if it's off the edge.
+         */
+        nbx = nx + dx;
+        nby = ny + dy;
+        if (nbx < 0 || nbx >= w || nby < 0 || nby >= h)
+            return -1;
+
+        /*
+         * That third square must be able to accept a barrel.
+         */
+        if (state->grid[nby*w+nbx] == SPACE ||
+            state->grid[nby*w+nbx] == TARGET ||
+            state->grid[nby*w+nbx] == PIT ||
+            state->grid[nby*w+nbx] == DEEP_PIT) {
+            /*
+             * The push is valid.
+             */
+            return 1;
+        } else {
+            return -1;
+        }
+    } else {
+        /*
+         * This is just an ordinary move. We've already checked the
+         * target square, so the only thing left to check is that a
+         * diagonal move has a space on one side to have notionally
+         * gone through.
+         */
+        if (dx && dy &&
+            state->grid[(py+dy)*w+px] != SPACE &&
+            state->grid[(py+dy)*w+px] != TARGET &&
+            state->grid[py*w+(px+dx)] != SPACE &&
+            state->grid[py*w+(px+dx)] != TARGET)
+            return -1;
+
+        /*
+         * Otherwise, the move is valid.
+         */
+        return 0;
+    }
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int dx=0, dy=0;
+    char *move;
+
+    /*
+     * Diagonal movement is supported as it is in NetHack: it's
+     * for movement only (never pushing), and one of the two
+     * squares adjacent to both the source and destination
+     * squares must be free to move through. In other words, it
+     * is only a shorthand for two orthogonal moves and cannot
+     * change the nature of the actual puzzle game.
+     */
+    if (button == CURSOR_UP || button == (MOD_NUM_KEYPAD | '8'))
+        dx = 0, dy = -1;
+    else if (button == CURSOR_DOWN || button == (MOD_NUM_KEYPAD | '2'))
+        dx = 0, dy = +1;
+    else if (button == CURSOR_LEFT || button == (MOD_NUM_KEYPAD | '4'))
+        dx = -1, dy = 0;
+    else if (button == CURSOR_RIGHT || button == (MOD_NUM_KEYPAD | '6'))
+        dx = +1, dy = 0;
+    else if (button == (MOD_NUM_KEYPAD | '7'))
+        dx = -1, dy = -1;
+    else if (button == (MOD_NUM_KEYPAD | '9'))
+        dx = +1, dy = -1;
+    else if (button == (MOD_NUM_KEYPAD | '1'))
+        dx = -1, dy = +1;
+    else if (button == (MOD_NUM_KEYPAD | '3'))
+        dx = +1, dy = +1;
+    else if (button == LEFT_BUTTON)
+    {
+        if(x < COORD(state->px))
+            dx = -1;
+        else if (x > COORD(state->px + 1))
+            dx = 1;
+        if(y < COORD(state->py))
+            dy = -1;
+        else if (y > COORD(state->py + 1))
+            dy = 1;
+    }
+    else
+        return NULL;
+
+    if((dx == 0) && (dy == 0))
+        return(NULL);
+
+    if (move_type(state, dx, dy) < 0)
+        return NULL;
+
+    move = snewn(2, char);
+    move[1] = '\0';
+    move[0] = '5' - 3*dy + dx;
+    return move;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int w = state->p.w, h = state->p.h;
+    int px = state->px, py = state->py;
+    int dx, dy, nx, ny, nbx, nby, type, m, i, freebarrels, freetargets;
+    game_state *ret;
+
+    if (*move < '1' || *move == '5' || *move > '9' || move[1])
+        return NULL;                   /* invalid move string */
+
+    m = *move - '0';
+    dx = (m + 2) % 3 - 1;
+    dy = 2 - (m + 2) / 3;
+    type = move_type(state, dx, dy);
+    if (type < 0)
+        return NULL;
+
+    ret = dup_game(state);
+
+    nx = px + dx;
+    ny = py + dy;
+    nbx = nx + dx;
+    nby = ny + dy;
+
+    if (type) {
+        int b;
+
+        /*
+         * Push.
+         */
+        b = ret->grid[ny*w+nx];
+        if (IS_ON_TARGET(b)) {
+            ret->grid[ny*w+nx] = TARGET;
+            b = DETARGETISE(b);
+        } else
+            ret->grid[ny*w+nx] = SPACE;
+
+        if (ret->grid[nby*w+nbx] == PIT)
+            ret->grid[nby*w+nbx] = SPACE;
+        else if (ret->grid[nby*w+nbx] == DEEP_PIT)
+            /* do nothing - the pit eats the barrel and remains there */;
+        else if (ret->grid[nby*w+nbx] == TARGET)
+            ret->grid[nby*w+nbx] = TARGETISE(b);
+        else
+            ret->grid[nby*w+nbx] = b;
+    }
+
+    ret->px = nx;
+    ret->py = ny;
+
+    /*
+     * Check for completion. This is surprisingly complicated,
+     * given the presence of pits and deep pits, and also the fact
+     * that some Sokoban levels with pits have fewer pits than
+     * barrels (due to providing spares, e.g. NetHack's). I think
+     * the completion condition in fact must be that the game
+     * cannot become any _more_ complete. That is, _either_ there
+     * are no remaining barrels not on targets, _or_ there is a
+     * good reason why any such barrels cannot be placed. The only
+     * available good reason is that there are no remaining pits,
+     * no free target squares, and no deep pits at all.
+     */
+    if (!ret->completed) {
+        freebarrels = FALSE;
+        freetargets = FALSE;
+        for (i = 0; i < w*h; i++) {
+            int v = ret->grid[i];
+
+            if (IS_BARREL(v) && !IS_ON_TARGET(v))
+                freebarrels = TRUE;
+            if (v == DEEP_PIT || v == PIT ||
+                (!IS_BARREL(v) && IS_ON_TARGET(v)))
+                freetargets = TRUE;
+        }
+
+        if (!freebarrels || !freetargets)
+            ret->completed = TRUE;
+    }
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
+    *x = 2 * BORDER + 1 + params->w * TILESIZE;
+    *y = 2 * BORDER + 1 + params->h * TILESIZE;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
+
+    ret[COL_OUTLINE * 3 + 0] = 0.0F;
+    ret[COL_OUTLINE * 3 + 1] = 0.0F;
+    ret[COL_OUTLINE * 3 + 2] = 0.0F;
+
+    ret[COL_PLAYER * 3 + 0] = 0.0F;
+    ret[COL_PLAYER * 3 + 1] = 1.0F;
+    ret[COL_PLAYER * 3 + 2] = 0.0F;
+
+    ret[COL_BARREL * 3 + 0] = 0.6F;
+    ret[COL_BARREL * 3 + 1] = 0.3F;
+    ret[COL_BARREL * 3 + 2] = 0.0F;
+
+    ret[COL_TARGET * 3 + 0] = ret[COL_LOWLIGHT * 3 + 0];
+    ret[COL_TARGET * 3 + 1] = ret[COL_LOWLIGHT * 3 + 1];
+    ret[COL_TARGET * 3 + 2] = ret[COL_LOWLIGHT * 3 + 2];
+
+    ret[COL_PIT * 3 + 0] = ret[COL_LOWLIGHT * 3 + 0] / 2;
+    ret[COL_PIT * 3 + 1] = ret[COL_LOWLIGHT * 3 + 1] / 2;
+    ret[COL_PIT * 3 + 2] = ret[COL_LOWLIGHT * 3 + 2] / 2;
+
+    ret[COL_DEEP_PIT * 3 + 0] = 0.0F;
+    ret[COL_DEEP_PIT * 3 + 1] = 0.0F;
+    ret[COL_DEEP_PIT * 3 + 2] = 0.0F;
+
+    ret[COL_TEXT * 3 + 0] = 1.0F;
+    ret[COL_TEXT * 3 + 1] = 1.0F;
+    ret[COL_TEXT * 3 + 2] = 1.0F;
+
+    ret[COL_GRID * 3 + 0] = ret[COL_LOWLIGHT * 3 + 0];
+    ret[COL_GRID * 3 + 1] = ret[COL_LOWLIGHT * 3 + 1];
+    ret[COL_GRID * 3 + 2] = ret[COL_LOWLIGHT * 3 + 2];
+
+    ret[COL_OUTLINE * 3 + 0] = 0.0F;
+    ret[COL_OUTLINE * 3 + 1] = 0.0F;
+    ret[COL_OUTLINE * 3 + 2] = 0.0F;
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_WALL * 3 + i] = (3 * ret[COL_BACKGROUND * 3 + i] +
+                                 1 * ret[COL_HIGHLIGHT * 3 + i]) / 4;
+    }
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    int w = state->p.w, h = state->p.h;
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = 0;
+    ds->p = state->p;                  /* structure copy */
+    ds->grid = snewn(w*h, unsigned short);
+    for (i = 0; i < w*h; i++)
+        ds->grid[i] = INVALID;
+    ds->started = FALSE;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+static void draw_tile(drawing *dr, game_drawstate *ds, int x, int y, int v)
+{
+    int tx = COORD(x), ty = COORD(y);
+    int bg = (v & 0x100 ? COL_HIGHLIGHT : COL_BACKGROUND);
+
+    v &= 0xFF;
+
+    clip(dr, tx+1, ty+1, TILESIZE-1, TILESIZE-1);
+    draw_rect(dr, tx+1, ty+1, TILESIZE-1, TILESIZE-1, bg);
+
+    if (v == WALL) {
+        int coords[6];
+
+        coords[0] = tx + TILESIZE;
+        coords[1] = ty + TILESIZE;
+        coords[2] = tx + TILESIZE;
+        coords[3] = ty + 1;
+        coords[4] = tx + 1;
+        coords[5] = ty + TILESIZE;
+        draw_polygon(dr, coords, 3, COL_LOWLIGHT, COL_LOWLIGHT);
+
+        coords[0] = tx + 1;
+        coords[1] = ty + 1;
+        draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
+
+        draw_rect(dr, tx + 1 + HIGHLIGHT_WIDTH, ty + 1 + HIGHLIGHT_WIDTH,
+                  TILESIZE - 2*HIGHLIGHT_WIDTH,
+                  TILESIZE - 2*HIGHLIGHT_WIDTH, COL_WALL);
+    } else if (v == PIT) {
+        draw_circle(dr, tx + TILESIZE/2, ty + TILESIZE/2,
+                    TILESIZE*3/7, COL_PIT, COL_OUTLINE);
+    } else if (v == DEEP_PIT) {
+        draw_circle(dr, tx + TILESIZE/2, ty + TILESIZE/2,
+                    TILESIZE*3/7, COL_DEEP_PIT, COL_OUTLINE);
+    } else {
+        if (IS_ON_TARGET(v)) {
+            draw_circle(dr, tx + TILESIZE/2, ty + TILESIZE/2,
+                        TILESIZE*3/7, COL_TARGET, COL_OUTLINE);
+        }
+        if (IS_PLAYER(v)) {
+            draw_circle(dr, tx + TILESIZE/2, ty + TILESIZE/2,
+                        TILESIZE/3, COL_PLAYER, COL_OUTLINE);
+        } else if (IS_BARREL(v)) {
+            char str[2];
+
+            draw_circle(dr, tx + TILESIZE/2, ty + TILESIZE/2,
+                        TILESIZE/3, COL_BARREL, COL_OUTLINE);
+            str[1] = '\0';
+            str[0] = BARREL_LABEL(v);
+            if (str[0]) {
+                draw_text(dr, tx + TILESIZE/2, ty + TILESIZE/2,
+                          FONT_VARIABLE, TILESIZE/2,
+                          ALIGN_VCENTRE | ALIGN_HCENTRE, COL_TEXT, str);
+            }
+        }
+    }
+
+    unclip(dr);
+    draw_update(dr, tx, ty, TILESIZE, TILESIZE);
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w = state->p.w, h = state->p.h /*, wh = w*h */;
+    int x, y;
+    int flashtype;
+
+    if (flashtime &&
+        !((int)(flashtime * 3 / FLASH_LENGTH) % 2))
+        flashtype = 0x100;
+    else
+        flashtype = 0;
+
+    /*
+     * Initialise a fresh drawstate.
+     */
+    if (!ds->started) {
+        int wid, ht;
+
+        /*
+         * Blank out the window initially.
+         */
+        game_compute_size(&ds->p, TILESIZE, &wid, &ht);
+        draw_rect(dr, 0, 0, wid, ht, COL_BACKGROUND);
+        draw_update(dr, 0, 0, wid, ht);
+
+        /*
+         * Draw the grid lines.
+         */
+        for (y = 0; y <= h; y++)
+            draw_line(dr, COORD(0), COORD(y), COORD(w), COORD(y),
+                      COL_LOWLIGHT);
+        for (x = 0; x <= w; x++)
+            draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h),
+                      COL_LOWLIGHT);
+
+        ds->started = TRUE;
+    }
+
+    /*
+     * Draw the grid contents.
+     */
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++) {
+            int v = state->grid[y*w+x];
+            if (y == state->py && x == state->px) {
+                if (v == TARGET)
+                    v = PLAYERTARGET;
+                else {
+                    assert(v == SPACE);
+                    v = PLAYER;
+                }
+            }
+
+            v |= flashtype;
+
+            if (ds->grid[y*w+x] != v) {
+                draw_tile(dr, ds, x, y, v);
+                ds->grid[y*w+x] = v;
+            }
+        }
+
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed)
+        return FLASH_LENGTH;
+    else
+        return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame sokoban
+#endif
+
+const struct game thegame = {
+    "Sokoban", NULL, NULL,
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    FALSE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                                 /* flags */
+};
diff --git a/apps/plugins/puzzles/unruly.R b/apps/plugins/puzzles/unruly.R
new file mode 100644
index 0000000000..064ccc35ba
--- /dev/null
+++ b/apps/plugins/puzzles/unruly.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+unruly : [X] GTK COMMON unruly unruly-icon|no-icon
+unruly : [G] WINDOWS COMMON unruly unruly.res|noicon.res
+
+unrulysolver : [U] unruly[STANDALONE_SOLVER] STANDALONE
+unrulysolver : [C] unruly[STANDALONE_SOLVER] STANDALONE
+
+ALL += unruly[COMBINED]
+
+!begin am gtk
+GAMES += unruly
+!end
+
+!begin >list.c
+    A(unruly) \
+!end
+
+!begin >gamedesc.txt
+unruly:unruly.exe:Unruly:Black and white grid puzzle:Fill in the black and white grid to avoid runs of three.
+!end
diff --git a/apps/plugins/puzzles/unruly.c b/apps/plugins/puzzles/unruly.c
new file mode 100644
index 0000000000..aea4cdf789
--- /dev/null
+++ b/apps/plugins/puzzles/unruly.c
@@ -0,0 +1,2071 @@
+/*
+ * unruly.c: Implementation for Binary Puzzles.
+ * (C) 2012 Lennard Sprong
+ * Created for Simon Tatham's Portable Puzzle Collection
+ * See LICENCE for licence details
+ *
+ * Objective of the game: Fill the grid with zeros and ones, with the
+ * following rules:
+ * - There can't be a run of three or more equal numbers.
+ * - Each row and column contains an equal amount of zeros and ones.
+ *
+ * This puzzle type is known under several names, including
+ * Tohu-Wa-Vohu, One and Two and Binairo.
+ *
+ * Some variants include an extra constraint, stating that no two rows or two
+ * columns may contain the same exact sequence of zeros and ones.
+ * This rule is rarely used, so it is not enabled in the default presets
+ * (but it can be selected via the Custom configurer).
+ *
+ * More information:
+ * http://www.janko.at/Raetsel/Tohu-Wa-Vohu/index.htm
+ */
+
+/*
+ * Possible future improvements:
+ *
+ * More solver cleverness
+ *
+ *  - a counting-based deduction in which you find groups of squares
+ *    which must each contain at least one of a given colour, plus
+ *    other squares which are already known to be that colour, and see
+ *    if you have any squares left over when you've worked out where
+ *    they all have to be. This is a generalisation of the current
+ *    check_near_complete: where that only covers rows with three
+ *    unfilled squares, this would handle more, such as
+ *        0 . . 1 0 1 . . 0 .
+ *    in which each of the two-square gaps must contain a 0, and there
+ *    are three 0s placed, and that means the rightmost square can't
+ *    be a 0.
+ *
+ *  - an 'Unreasonable' difficulty level, supporting recursion and
+ *    backtracking.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+
+#ifdef STANDALONE_SOLVER
+int solver_verbose = FALSE;
+#endif
+
+enum {
+    COL_BACKGROUND,
+    COL_GRID,
+    COL_EMPTY,
+    /*
+     * When editing this enum, maintain the invariants
+     *   COL_n_HIGHLIGHT = COL_n + 1
+     *   COL_n_LOWLIGHT = COL_n + 2
+     */
+    COL_0,
+    COL_0_HIGHLIGHT,
+    COL_0_LOWLIGHT,
+    COL_1,
+    COL_1_HIGHLIGHT,
+    COL_1_LOWLIGHT,
+    COL_CURSOR,
+    COL_ERROR,
+    NCOLOURS
+};
+
+struct game_params {
+    int w2, h2;        /* full grid width and height respectively */
+    int unique;        /* should row and column patterns be unique? */
+    int diff;
+};
+#define DIFFLIST(A)                             \
+    A(EASY,Easy, e)                             \
+    A(NORMAL,Normal, n)                         \
+
+#define ENUM(upper,title,lower) DIFF_ ## upper,
+#define TITLE(upper,title,lower) #title,
+#define ENCODE(upper,title,lower) #lower
+#define CONFIG(upper,title,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT };
+static char const *const unruly_diffnames[] = { DIFFLIST(TITLE) };
+
+static char const unruly_diffchars[] = DIFFLIST(ENCODE);
+#define DIFFCONFIG DIFFLIST(CONFIG)
+
+const static struct game_params unruly_presets[] = {
+    { 8,  8, FALSE, DIFF_EASY},
+    { 8,  8, FALSE, DIFF_NORMAL},
+    {10, 10, FALSE, DIFF_EASY},
+    {10, 10, FALSE, DIFF_NORMAL},
+    {14, 14, FALSE, DIFF_EASY},
+    {14, 14, FALSE, DIFF_NORMAL}
+};
+
+#define DEFAULT_PRESET 0
+
+enum {
+    EMPTY,
+    N_ONE,
+    N_ZERO,
+    BOGUS
+};
+
+#define FE_HOR_ROW_LEFT   0x0001
+#define FE_HOR_ROW_MID    0x0003
+#define FE_HOR_ROW_RIGHT  0x0002
+
+#define FE_VER_ROW_TOP    0x0004
+#define FE_VER_ROW_MID    0x000C
+#define FE_VER_ROW_BOTTOM 0x0008
+
+#define FE_COUNT          0x0010
+
+#define FE_ROW_MATCH      0x0020
+#define FE_COL_MATCH      0x0040
+
+#define FF_ONE            0x0080
+#define FF_ZERO           0x0100
+#define FF_CURSOR         0x0200
+
+#define FF_FLASH1         0x0400
+#define FF_FLASH2         0x0800
+#define FF_IMMUTABLE      0x1000
+
+struct game_state {
+    int w2, h2;
+    int unique;
+    char *grid;
+    unsigned char *immutable;
+
+    int completed, cheated;
+};
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    *ret = unruly_presets[DEFAULT_PRESET];        /* structure copy */
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    char buf[80];
+
+    if (i < 0 || i >= lenof(unruly_presets))
+        return FALSE;
+
+    ret = snew(game_params);
+    *ret = unruly_presets[i];     /* structure copy */
+
+    sprintf(buf, "%dx%d %s", ret->w2, ret->h2, unruly_diffnames[ret->diff]);
+
+    *name = dupstr(buf);
+    *params = ret;
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;             /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    char const *p = string;
+
+    params->unique = FALSE;
+
+    params->w2 = atoi(p);
+    while (*p && isdigit((unsigned char)*p)) p++;
+    if (*p == 'x') {
+        p++;
+        params->h2 = atoi(p);
+        while (*p && isdigit((unsigned char)*p)) p++;
+    } else {
+        params->h2 = params->w2;
+    }
+
+    if (*p == 'u') {
+        p++;
+        params->unique = TRUE;
+    }
+
+    if (*p == 'd') {
+        int i;
+        p++;
+        params->diff = DIFFCOUNT + 1;   /* ...which is invalid */
+        if (*p) {
+            for (i = 0; i < DIFFCOUNT; i++) {
+                if (*p == unruly_diffchars[i])
+                    params->diff = i;
+            }
+            p++;
+        }
+    }
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[80];
+
+    sprintf(buf, "%dx%d", params->w2, params->h2);
+    if (params->unique)
+        strcat(buf, "u");
+    if (full)
+        sprintf(buf + strlen(buf), "d%c", unruly_diffchars[params->diff]);
+
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(5, config_item);
+
+    ret[0].name = "Width";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->w2);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h2);
+    ret[1].sval = dupstr(buf);
+    ret[1].ival = 0;
+
+    ret[2].name = "Unique rows and columns";
+    ret[2].type = C_BOOLEAN;
+    ret[2].ival = params->unique;
+
+    ret[3].name = "Difficulty";
+    ret[3].type = C_CHOICES;
+    ret[3].sval = DIFFCONFIG;
+    ret[3].ival = params->diff;
+
+    ret[4].name = NULL;
+    ret[4].type = C_END;
+    ret[4].sval = NULL;
+    ret[4].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w2 = atoi(cfg[0].sval);
+    ret->h2 = atoi(cfg[1].sval);
+    ret->unique = cfg[2].ival;
+    ret->diff = cfg[3].ival;
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if ((params->w2 & 1) || (params->h2 & 1))
+        return "Width and height must both be even";
+    if (params->w2 < 6 || params->h2 < 6)
+        return "Width and height must be at least 6";
+    if (params->unique) {
+        static const long A177790[] = {
+            /*
+             * The nth element of this array gives the number of
+             * distinct possible Unruly rows of length 2n (that is,
+             * containing exactly n 1s and n 0s and not containing
+             * three consecutive elements the same) for as long as
+             * those numbers fit in a 32-bit signed int.
+             *
+             * So in unique-rows mode, if the puzzle width is 2n, then
+             * the height must be at most (this array)[n], and vice
+             * versa.
+             *
+             * This is sequence A177790 in the Online Encyclopedia of
+             * Integer Sequences: http://oeis.org/A177790
+             */
+            1L, 2L, 6L, 14L, 34L, 84L, 208L, 518L, 1296L, 3254L,
+            8196L, 20700L, 52404L, 132942L, 337878L, 860142L,
+            2192902L, 5598144L, 14308378L, 36610970L, 93770358L,
+            240390602L, 616787116L, 1583765724L
+        };
+        if (params->w2 < 2*lenof(A177790) &&
+            params->h2 > A177790[params->w2/2]) {
+            return "Puzzle is too tall for unique-rows mode";
+        }
+        if (params->h2 < 2*lenof(A177790) &&
+            params->w2 > A177790[params->h2/2]) {
+            return "Puzzle is too long for unique-rows mode";
+        }
+    }
+    if (params->diff >= DIFFCOUNT)
+        return "Unknown difficulty rating";
+
+    return NULL;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int w2 = params->w2, h2 = params->h2;
+    int s = w2 * h2;
+
+    const char *p = desc;
+    int pos = 0;
+
+    while (*p) {
+        if (*p >= 'a' && *p < 'z')
+            pos += 1 + (*p - 'a');
+        else if (*p >= 'A' && *p < 'Z')
+            pos += 1 + (*p - 'A');
+        else if (*p == 'Z' || *p == 'z')
+            pos += 25;
+        else
+            return "Description contains invalid characters";
+
+        ++p;
+    }
+
+    if (pos < s+1)
+        return "Description too short";
+    if (pos > s+1)
+        return "Description too long";
+
+    return NULL;
+}
+
+static game_state *blank_state(int w2, int h2, int unique)
+{
+    game_state *state = snew(game_state);
+    int s = w2 * h2;
+
+    state->w2 = w2;
+    state->h2 = h2;
+    state->unique = unique;
+    state->grid = snewn(s, char);
+    state->immutable = snewn(s, unsigned char);
+
+    memset(state->grid, EMPTY, s);
+    memset(state->immutable, FALSE, s);
+
+    state->completed = state->cheated = FALSE;
+
+    return state;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int w2 = params->w2, h2 = params->h2;
+    int s = w2 * h2;
+
+    game_state *state = blank_state(w2, h2, params->unique);
+
+    const char *p = desc;
+    int pos = 0;
+
+    while (*p) {
+        if (*p >= 'a' && *p < 'z') {
+            pos += (*p - 'a');
+            if (pos < s) {
+                state->grid[pos] = N_ZERO;
+                state->immutable[pos] = TRUE;
+            }
+            pos++;
+        } else if (*p >= 'A' && *p < 'Z') {
+            pos += (*p - 'A');
+            if (pos < s) {
+                state->grid[pos] = N_ONE;
+                state->immutable[pos] = TRUE;
+            }
+            pos++;
+        } else if (*p == 'Z' || *p == 'z') {
+            pos += 25;
+        } else
+            assert(!"Description contains invalid characters");
+
+        ++p;
+    }
+    assert(pos == s+1);
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int w2 = state->w2, h2 = state->h2;
+    int s = w2 * h2;
+
+    game_state *ret = blank_state(w2, h2, state->unique);
+
+    memcpy(ret->grid, state->grid, s);
+    memcpy(ret->immutable, state->immutable, s);
+
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    sfree(state->grid);
+    sfree(state->immutable);
+
+    sfree(state);
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    int w2 = state->w2, h2 = state->h2;
+    int lr = w2*2 + 1;
+
+    char *ret = snewn(lr * h2 + 1, char);
+    char *p = ret;
+
+    int x, y;
+    for (y = 0; y < h2; y++) {
+        for (x = 0; x < w2; x++) {
+            /* Place number */
+            char c = state->grid[y * w2 + x];
+            *p++ = (c == N_ONE ? '1' : c == N_ZERO ? '0' : '.');
+            *p++ = ' ';
+        }
+        /* End line */
+        *p++ = '\n';
+    }
+    /* End with NUL */
+    *p++ = '\0';
+
+    return ret;
+}
+
+/* ****** *
+ * Solver *
+ * ****** */
+
+struct unruly_scratch {
+    int *ones_rows;
+    int *ones_cols;
+    int *zeros_rows;
+    int *zeros_cols;
+};
+
+static void unruly_solver_update_remaining(const game_state *state,
+                                           struct unruly_scratch *scratch)
+{
+    int w2 = state->w2, h2 = state->h2;
+    int x, y;
+
+    /* Reset all scratch data */
+    memset(scratch->ones_rows, 0, h2 * sizeof(int));
+    memset(scratch->ones_cols, 0, w2 * sizeof(int));
+    memset(scratch->zeros_rows, 0, h2 * sizeof(int));
+    memset(scratch->zeros_cols, 0, w2 * sizeof(int));
+
+    for (x = 0; x < w2; x++)
+        for (y = 0; y < h2; y++) {
+            if (state->grid[y * w2 + x] == N_ONE) {
+                scratch->ones_rows[y]++;
+                scratch->ones_cols[x]++;
+            } else if (state->grid[y * w2 + x] == N_ZERO) {
+                scratch->zeros_rows[y]++;
+                scratch->zeros_cols[x]++;
+            }
+        }
+}
+
+static struct unruly_scratch *unruly_new_scratch(const game_state *state)
+{
+    int w2 = state->w2, h2 = state->h2;
+
+    struct unruly_scratch *ret = snew(struct unruly_scratch);
+
+    ret->ones_rows = snewn(h2, int);
+    ret->ones_cols = snewn(w2, int);
+    ret->zeros_rows = snewn(h2, int);
+    ret->zeros_cols = snewn(w2, int);
+
+    unruly_solver_update_remaining(state, ret);
+
+    return ret;
+}
+
+static void unruly_free_scratch(struct unruly_scratch *scratch)
+{
+    sfree(scratch->ones_rows);
+    sfree(scratch->ones_cols);
+    sfree(scratch->zeros_rows);
+    sfree(scratch->zeros_cols);
+
+    sfree(scratch);
+}
+
+static int unruly_solver_check_threes(game_state *state, int *rowcount,
+                                      int *colcount, int horizontal,
+                                      char check, char block)
+{
+    int w2 = state->w2, h2 = state->h2;
+
+    int dx = horizontal ? 1 : 0, dy = 1 - dx;
+    int sx = dx, sy = dy;
+    int ex = w2 - dx, ey = h2 - dy;
+
+    int x, y;
+    int ret = 0;
+
+    /* Check for any three squares which almost form three in a row */
+    for (y = sy; y < ey; y++) {
+        for (x = sx; x < ex; x++) {
+            int i1 = (y-dy) * w2 + (x-dx);
+            int i2 = y * w2 + x;
+            int i3 = (y+dy) * w2 + (x+dx);
+
+            if (state->grid[i1] == check && state->grid[i2] == check
+                && state->grid[i3] == EMPTY) {
+                ret++;
+#ifdef STANDALONE_SOLVER
+                if (solver_verbose) {
+                    printf("Solver: %i,%i and %i,%i confirm %c at %i,%i\n",
+                           i1 % w2, i1 / w2, i2 % w2, i2 / w2,
+                           (block == N_ONE ? '1' : '0'), i3 % w2,
+                           i3 / w2);
+                }
+#endif
+                state->grid[i3] = block;
+                rowcount[i3 / w2]++;
+                colcount[i3 % w2]++;
+            }
+            if (state->grid[i1] == check && state->grid[i2] == EMPTY
+                && state->grid[i3] == check) {
+                ret++;
+#ifdef STANDALONE_SOLVER
+                if (solver_verbose) {
+                    printf("Solver: %i,%i and %i,%i confirm %c at %i,%i\n",
+                           i1 % w2, i1 / w2, i3 % w2, i3 / w2,
+                           (block == N_ONE ? '1' : '0'), i2 % w2,
+                           i2 / w2);
+                }
+#endif
+                state->grid[i2] = block;
+                rowcount[i2 / w2]++;
+                colcount[i2 % w2]++;
+            }
+            if (state->grid[i1] == EMPTY && state->grid[i2] == check
+                && state->grid[i3] == check) {
+                ret++;
+#ifdef STANDALONE_SOLVER
+                if (solver_verbose) {
+                    printf("Solver: %i,%i and %i,%i confirm %c at %i,%i\n",
+                           i2 % w2, i2 / w2, i3 % w2, i3 / w2,
+                           (block == N_ONE ? '1' : '0'), i1 % w2,
+                           i1 / w2);
+                }
+#endif
+                state->grid[i1] = block;
+                rowcount[i1 / w2]++;
+                colcount[i1 % w2]++;
+            }
+        }
+    }
+
+    return ret;
+}
+
+static int unruly_solver_check_all_threes(game_state *state,
+                                          struct unruly_scratch *scratch)
+{
+    int ret = 0;
+
+    ret +=
+        unruly_solver_check_threes(state, scratch->zeros_rows,
+                                   scratch->zeros_cols, TRUE, N_ONE, N_ZERO);
+    ret +=
+        unruly_solver_check_threes(state, scratch->ones_rows,
+                                   scratch->ones_cols, TRUE, N_ZERO, N_ONE);
+    ret +=
+        unruly_solver_check_threes(state, scratch->zeros_rows,
+                                   scratch->zeros_cols, FALSE, N_ONE,
+                                   N_ZERO);
+    ret +=
+        unruly_solver_check_threes(state, scratch->ones_rows,
+                                   scratch->ones_cols, FALSE, N_ZERO, N_ONE);
+
+    return ret;
+}
+
+static int unruly_solver_check_uniques(game_state *state, int *rowcount,
+                                       int horizontal, char check, char block,
+                                       struct unruly_scratch *scratch)
+{
+    int w2 = state->w2, h2 = state->h2;
+
+    int rmult = (horizontal ? w2 : 1);
+    int cmult = (horizontal ? 1 : w2);
+    int nr = (horizontal ? h2 : w2);
+    int nc = (horizontal ? w2 : h2);
+    int max = nc / 2;
+
+    int r, r2, c;
+    int ret = 0;
+
+    /*
+     * Find each row that has max entries of type 'check', and see if
+     * all those entries match those in any row with max-1 entries. If
+     * so, set the last non-matching entry of the latter row to ensure
+     * that it's different.
+     */
+    for (r = 0; r < nr; r++) {
+        if (rowcount[r] != max)
+            continue;
+        for (r2 = 0; r2 < nr; r2++) {
+            int nmatch = 0, nonmatch = -1;
+            if (rowcount[r2] != max-1)
+                continue;
+            for (c = 0; c < nc; c++) {
+                if (state->grid[r*rmult + c*cmult] == check) {
+                    if (state->grid[r2*rmult + c*cmult] == check)
+                        nmatch++;
+                    else
+                        nonmatch = c;
+                }
+            }
+            if (nmatch == max-1) {
+                int i1 = r2 * rmult + nonmatch * cmult;
+                assert(nonmatch != -1);
+                if (state->grid[i1] == block)
+                    continue;
+                assert(state->grid[i1] == EMPTY);
+#ifdef STANDALONE_SOLVER
+                if (solver_verbose) {
+                    printf("Solver: matching %s %i, %i gives %c at %i,%i\n",
+                           horizontal ? "rows" : "cols",
+                           r, r2, (block == N_ONE ? '1' : '0'), i1 % w2,
+                           i1 / w2);
+                }
+#endif
+                state->grid[i1] = block;
+                if (block == N_ONE) {
+                    scratch->ones_rows[i1 / w2]++;
+                    scratch->ones_cols[i1 % w2]++;
+                } else {
+                    scratch->zeros_rows[i1 / w2]++;
+                    scratch->zeros_cols[i1 % w2]++;
+                }
+                ret++;
+            }
+        }
+    }
+    return ret;
+}
+
+static int unruly_solver_check_all_uniques(game_state *state,
+                                           struct unruly_scratch *scratch)
+{
+    int ret = 0;
+
+    ret += unruly_solver_check_uniques(state, scratch->ones_rows,
+                                       TRUE, N_ONE, N_ZERO, scratch);
+    ret += unruly_solver_check_uniques(state, scratch->zeros_rows,
+                                       TRUE, N_ZERO, N_ONE, scratch);
+    ret += unruly_solver_check_uniques(state, scratch->ones_cols,
+                                       FALSE, N_ONE, N_ZERO, scratch);
+    ret += unruly_solver_check_uniques(state, scratch->zeros_cols,
+                                       FALSE, N_ZERO, N_ONE, scratch);
+
+    return ret;
+}
+
+static int unruly_solver_fill_row(game_state *state, int i, int horizontal,
+                                  int *rowcount, int *colcount, char fill)
+{
+    int ret = 0;
+    int w2 = state->w2, h2 = state->h2;
+    int j;
+
+#ifdef STANDALONE_SOLVER
+    if (solver_verbose) {
+        printf("Solver: Filling %s %i with %c:",
+               (horizontal ? "Row" : "Col"), i,
+               (fill == N_ZERO ? '0' : '1'));
+    }
+#endif
+    /* Place a number in every empty square in a row/column */
+    for (j = 0; j < (horizontal ? w2 : h2); j++) {
+        int p = (horizontal ? i * w2 + j : j * w2 + i);
+
+        if (state->grid[p] == EMPTY) {
+#ifdef STANDALONE_SOLVER
+            if (solver_verbose) {
+                printf(" (%i,%i)", (horizontal ? j : i),
+                       (horizontal ? i : j));
+            }
+#endif
+            ret++;
+            state->grid[p] = fill;
+            rowcount[(horizontal ? i : j)]++;
+            colcount[(horizontal ? j : i)]++;
+        }
+    }
+
+#ifdef STANDALONE_SOLVER
+    if (solver_verbose) {
+        printf("\n");
+    }
+#endif
+
+    return ret;
+}
+
+static int unruly_solver_check_complete_nums(game_state *state,
+                                             int *complete, int horizontal,
+                                             int *rowcount, int *colcount,
+                                             char fill)
+{
+    int w2 = state->w2, h2 = state->h2;
+    int count = (horizontal ? h2 : w2); /* number of rows to check */
+    int target = (horizontal ? w2 : h2) / 2; /* target number of 0s/1s */
+    int *other = (horizontal ? rowcount : colcount);
+
+    int ret = 0;
+
+    int i;
+    /* Check for completed rows/cols for one number, then fill in the rest */
+    for (i = 0; i < count; i++) {
+        if (complete[i] == target && other[i] < target) {
+#ifdef STANDALONE_SOLVER
+            if (solver_verbose) {
+                printf("Solver: Row %i satisfied for %c\n", i,
+                       (fill != N_ZERO ? '0' : '1'));
+            }
+#endif
+            ret += unruly_solver_fill_row(state, i, horizontal, rowcount,
+                                          colcount, fill);
+        }
+    }
+
+    return ret;
+}
+
+static int unruly_solver_check_all_complete_nums(game_state *state,
+                                                 struct unruly_scratch *scratch)
+{
+    int ret = 0;
+
+    ret +=
+        unruly_solver_check_complete_nums(state, scratch->ones_rows, TRUE,
+                                          scratch->zeros_rows,
+                                          scratch->zeros_cols, N_ZERO);
+    ret +=
+        unruly_solver_check_complete_nums(state, scratch->ones_cols, FALSE,
+                                          scratch->zeros_rows,
+                                          scratch->zeros_cols, N_ZERO);
+    ret +=
+        unruly_solver_check_complete_nums(state, scratch->zeros_rows, TRUE,
+                                          scratch->ones_rows,
+                                          scratch->ones_cols, N_ONE);
+    ret +=
+        unruly_solver_check_complete_nums(state, scratch->zeros_cols, FALSE,
+                                          scratch->ones_rows,
+                                          scratch->ones_cols, N_ONE);
+
+    return ret;
+}
+
+static int unruly_solver_check_near_complete(game_state *state,
+                                             int *complete, int horizontal,
+                                             int *rowcount, int *colcount,
+                                             char fill)
+{
+    int w2 = state->w2, h2 = state->h2;
+    int w = w2/2, h = h2/2;
+
+    int dx = horizontal ? 1 : 0, dy = 1 - dx;
+
+    int sx = dx, sy = dy;
+    int ex = w2 - dx, ey = h2 - dy;
+
+    int x, y;
+    int ret = 0;
+
+    /*
+     * This function checks for a row with one Y remaining, then looks
+     * for positions that could cause the remaining squares in the row
+     * to make 3 X's in a row. Example:
+     *
+     * Consider the following row:
+     * 1 1 0 . . .
+     * If the last 1 was placed in the last square, the remaining
+     * squares would be 0:
+     * 1 1 0 0 0 1
+     * This violates the 3 in a row rule. We now know that the last 1
+     * shouldn't be in the last cell.
+     * 1 1 0 . . 0
+     */
+
+    /* Check for any two blank and one filled square */
+    for (y = sy; y < ey; y++) {
+        /* One type must have 1 remaining, the other at least 2 */
+        if (horizontal && (complete[y] < w - 1 || rowcount[y] > w - 2))
+            continue;
+
+        for (x = sx; x < ex; x++) {
+            int i, i1, i2, i3;
+            if (!horizontal
+                && (complete[x] < h - 1 || colcount[x] > h - 2))
+                continue;
+
+            i = (horizontal ? y : x);
+            i1 = (y-dy) * w2 + (x-dx);
+            i2 = y * w2 + x;
+            i3 = (y+dy) * w2 + (x+dx);
+
+            if (state->grid[i1] == fill && state->grid[i2] == EMPTY
+                && state->grid[i3] == EMPTY) {
+                /*
+                 * Temporarily fill the empty spaces with something else.
+                 * This avoids raising the counts for the row and column
+                 */
+                state->grid[i2] = BOGUS;
+                state->grid[i3] = BOGUS;
+
+#ifdef STANDALONE_SOLVER
+                if (solver_verbose) {
+                    printf("Solver: Row %i nearly satisfied for %c\n", i,
+                           (fill != N_ZERO ? '0' : '1'));
+                }
+#endif
+                ret +=
+                    unruly_solver_fill_row(state, i, horizontal, rowcount,
+                                         colcount, fill);
+
+                state->grid[i2] = EMPTY;
+                state->grid[i3] = EMPTY;
+            }
+
+            else if (state->grid[i1] == EMPTY && state->grid[i2] == fill
+                     && state->grid[i3] == EMPTY) {
+                state->grid[i1] = BOGUS;
+                state->grid[i3] = BOGUS;
+
+#ifdef STANDALONE_SOLVER
+                if (solver_verbose) {
+                    printf("Solver: Row %i nearly satisfied for %c\n", i,
+                           (fill != N_ZERO ? '0' : '1'));
+                }
+#endif
+                ret +=
+                    unruly_solver_fill_row(state, i, horizontal, rowcount,
+                                         colcount, fill);
+
+                state->grid[i1] = EMPTY;
+                state->grid[i3] = EMPTY;
+            }
+
+            else if (state->grid[i1] == EMPTY && state->grid[i2] == EMPTY
+                     && state->grid[i3] == fill) {
+                state->grid[i1] = BOGUS;
+                state->grid[i2] = BOGUS;
+
+#ifdef STANDALONE_SOLVER
+                if (solver_verbose) {
+                    printf("Solver: Row %i nearly satisfied for %c\n", i,
+                           (fill != N_ZERO ? '0' : '1'));
+                }
+#endif
+                ret +=
+                    unruly_solver_fill_row(state, i, horizontal, rowcount,
+                                         colcount, fill);
+
+                state->grid[i1] = EMPTY;
+                state->grid[i2] = EMPTY;
+            }
+
+            else if (state->grid[i1] == EMPTY && state->grid[i2] == EMPTY
+                     && state->grid[i3] == EMPTY) {
+                state->grid[i1] = BOGUS;
+                state->grid[i2] = BOGUS;
+                state->grid[i3] = BOGUS;
+
+#ifdef STANDALONE_SOLVER
+                if (solver_verbose) {
+                    printf("Solver: Row %i nearly satisfied for %c\n", i,
+                           (fill != N_ZERO ? '0' : '1'));
+                }
+#endif
+                ret +=
+                    unruly_solver_fill_row(state, i, horizontal, rowcount,
+                                         colcount, fill);
+
+                state->grid[i1] = EMPTY;
+                state->grid[i2] = EMPTY;
+                state->grid[i3] = EMPTY;
+            }
+        }
+    }
+
+    return ret;
+}
+
+static int unruly_solver_check_all_near_complete(game_state *state,
+                                                 struct unruly_scratch *scratch)
+{
+    int ret = 0;
+
+    ret +=
+        unruly_solver_check_near_complete(state, scratch->ones_rows, TRUE,
+                                        scratch->zeros_rows,
+                                        scratch->zeros_cols, N_ZERO);
+    ret +=
+        unruly_solver_check_near_complete(state, scratch->ones_cols, FALSE,
+                                        scratch->zeros_rows,
+                                        scratch->zeros_cols, N_ZERO);
+    ret +=
+        unruly_solver_check_near_complete(state, scratch->zeros_rows, TRUE,
+                                        scratch->ones_rows,
+                                        scratch->ones_cols, N_ONE);
+    ret +=
+        unruly_solver_check_near_complete(state, scratch->zeros_cols, FALSE,
+                                        scratch->ones_rows,
+                                        scratch->ones_cols, N_ONE);
+
+    return ret;
+}
+
+static int unruly_validate_rows(const game_state *state, int horizontal,
+                                char check, int *errors)
+{
+    int w2 = state->w2, h2 = state->h2;
+
+    int dx = horizontal ? 1 : 0, dy = 1 - dx;
+
+    int sx = dx, sy = dy;
+    int ex = w2 - dx, ey = h2 - dy;
+
+    int x, y;
+    int ret = 0;
+
+    int err1 = (horizontal ? FE_HOR_ROW_LEFT : FE_VER_ROW_TOP);
+    int err2 = (horizontal ? FE_HOR_ROW_MID : FE_VER_ROW_MID);
+    int err3 = (horizontal ? FE_HOR_ROW_RIGHT : FE_VER_ROW_BOTTOM);
+
+    /* Check for any three in a row, and mark errors accordingly (if
+     * required) */
+    for (y = sy; y < ey; y++) {
+        for (x = sx; x < ex; x++) {
+            int i1 = (y-dy) * w2 + (x-dx);
+            int i2 = y * w2 + x;
+            int i3 = (y+dy) * w2 + (x+dx);
+
+            if (state->grid[i1] == check && state->grid[i2] == check
+                && state->grid[i3] == check) {
+                ret++;
+                if (errors) {
+                    errors[i1] |= err1;
+                    errors[i2] |= err2;
+                    errors[i3] |= err3;
+                }
+            }
+        }
+    }
+
+    return ret;
+}
+
+static int unruly_validate_unique(const game_state *state, int horizontal,
+                                  int *errors)
+{
+    int w2 = state->w2, h2 = state->h2;
+
+    int rmult = (horizontal ? w2 : 1);
+    int cmult = (horizontal ? 1 : w2);
+    int nr = (horizontal ? h2 : w2);
+    int nc = (horizontal ? w2 : h2);
+    int err = (horizontal ? FE_ROW_MATCH : FE_COL_MATCH);
+
+    int r, r2, c;
+    int ret = 0;
+
+    /* Check for any two full rows matching exactly, and mark errors
+     * accordingly (if required) */
+    for (r = 0; r < nr; r++) {
+        int nfull = 0;
+        for (c = 0; c < nc; c++)
+            if (state->grid[r*rmult + c*cmult] != EMPTY)
+                nfull++;
+        if (nfull != nc)
+            continue;
+        for (r2 = r+1; r2 < nr; r2++) {
+            int match = TRUE;
+            for (c = 0; c < nc; c++)
+                if (state->grid[r*rmult + c*cmult] !=
+                    state->grid[r2*rmult + c*cmult])
+                    match = FALSE;
+            if (match) {
+                if (errors) {
+                    for (c = 0; c < nc; c++) {
+                        errors[r*rmult + c*cmult] |= err;
+                        errors[r2*rmult + c*cmult] |= err;
+                    }
+                }
+                ret++;
+            }
+        }
+    }
+
+    return ret;
+}
+
+static int unruly_validate_all_rows(const game_state *state, int *errors)
+{
+    int errcount = 0;
+
+    errcount += unruly_validate_rows(state, TRUE, N_ONE, errors);
+    errcount += unruly_validate_rows(state, FALSE, N_ONE, errors);
+    errcount += unruly_validate_rows(state, TRUE, N_ZERO, errors);
+    errcount += unruly_validate_rows(state, FALSE, N_ZERO, errors);
+
+    if (state->unique) {
+        errcount += unruly_validate_unique(state, TRUE, errors);
+        errcount += unruly_validate_unique(state, FALSE, errors);
+    }
+
+    if (errcount)
+        return -1;
+    return 0;
+}
+
+static int unruly_validate_counts(const game_state *state,
+                                  struct unruly_scratch *scratch, int *errors)
+{
+    int w2 = state->w2, h2 = state->h2;
+    int w = w2/2, h = h2/2;
+    char below = FALSE;
+    char above = FALSE;
+    int i;
+
+    /* See if all rows/columns are satisfied. If one is exceeded,
+     * mark it as an error (if required)
+     */
+
+    char hasscratch = TRUE;
+    if (!scratch) {
+        scratch = unruly_new_scratch(state);
+        hasscratch = FALSE;
+    }
+
+    for (i = 0; i < w2; i++) {
+        if (scratch->ones_cols[i] < h)
+            below = TRUE;
+        if (scratch->zeros_cols[i] < h)
+            below = TRUE;
+
+        if (scratch->ones_cols[i] > h) {
+            above = TRUE;
+            if (errors)
+                errors[2*h2 + i] = TRUE;
+        } else if (errors)
+            errors[2*h2 + i] = FALSE;
+
+        if (scratch->zeros_cols[i] > h) {
+            above = TRUE;
+            if (errors)
+                errors[2*h2 + w2 + i] = TRUE;
+        } else if (errors)
+            errors[2*h2 + w2 + i] = FALSE;
+    }
+    for (i = 0; i < h2; i++) {
+        if (scratch->ones_rows[i] < w)
+            below = TRUE;
+        if (scratch->zeros_rows[i] < w)
+            below = TRUE;
+
+        if (scratch->ones_rows[i] > w) {
+            above = TRUE;
+            if (errors)
+                errors[i] = TRUE;
+        } else if (errors)
+            errors[i] = FALSE;
+
+        if (scratch->zeros_rows[i] > w) {
+            above = TRUE;
+            if (errors)
+                errors[h2 + i] = TRUE;
+        } else if (errors)
+            errors[h2 + i] = FALSE;
+    }
+
+    if (!hasscratch)
+        unruly_free_scratch(scratch);
+
+    return (above ? -1 : below ? 1 : 0);
+}
+
+static int unruly_solve_game(game_state *state,
+                             struct unruly_scratch *scratch, int diff)
+{
+    int done, maxdiff = -1;
+
+    while (TRUE) {
+        done = 0;
+
+        /* Check for impending 3's */
+        done += unruly_solver_check_all_threes(state, scratch);
+
+        /* Keep using the simpler techniques while they produce results */
+        if (done) {
+            if (maxdiff < DIFF_EASY)
+                maxdiff = DIFF_EASY;
+            continue;
+        }
+
+        /* Check for completed rows */
+        done += unruly_solver_check_all_complete_nums(state, scratch);
+
+        if (done) {
+            if (maxdiff < DIFF_EASY)
+                maxdiff = DIFF_EASY;
+            continue;
+        }
+
+        /* Check for impending failures of row/column uniqueness, if
+         * it's enabled in this game mode */
+        if (state->unique) {
+            done += unruly_solver_check_all_uniques(state, scratch);
+
+            if (done) {
+                if (maxdiff < DIFF_EASY)
+                    maxdiff = DIFF_EASY;
+                continue;
+            }
+        }
+
+        /* Normal techniques */
+        if (diff < DIFF_NORMAL)
+            break;
+
+        /* Check for nearly completed rows */
+        done += unruly_solver_check_all_near_complete(state, scratch);
+
+        if (done) {
+            if (maxdiff < DIFF_NORMAL)
+                maxdiff = DIFF_NORMAL;
+            continue;
+        }
+
+        break;
+    }
+    return maxdiff;
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    game_state *solved = dup_game(state);
+    struct unruly_scratch *scratch = unruly_new_scratch(solved);
+    char *ret = NULL;
+    int result;
+
+    unruly_solve_game(solved, scratch, DIFFCOUNT);
+
+    result = unruly_validate_counts(solved, scratch, NULL);
+    if (unruly_validate_all_rows(solved, NULL) == -1)
+        result = -1;
+
+    if (result == 0) {
+        int w2 = solved->w2, h2 = solved->h2;
+        int s = w2 * h2;
+        char *p;
+        int i;
+
+        ret = snewn(s + 2, char);
+        p = ret;
+        *p++ = 'S';
+
+        for (i = 0; i < s; i++)
+            *p++ = (solved->grid[i] == N_ONE ? '1' : '0');
+
+        *p++ = '\0';
+    } else if (result == 1)
+        *error = "No solution found.";
+    else if (result == -1)
+        *error = "Puzzle is invalid.";
+
+    free_game(solved);
+    unruly_free_scratch(scratch);
+    return ret;
+}
+
+/* ********* *
+ * Generator *
+ * ********* */
+
+static int unruly_fill_game(game_state *state, struct unruly_scratch *scratch,
+                            random_state *rs)
+{
+
+    int w2 = state->w2, h2 = state->h2;
+    int s = w2 * h2;
+    int i, j;
+    int *spaces;
+
+#ifdef STANDALONE_SOLVER
+    if (solver_verbose) {
+        printf("Generator: Attempt to fill grid\n");
+    }
+#endif
+
+    /* Generate random array of spaces */
+    spaces = snewn(s, int);
+    for (i = 0; i < s; i++)
+        spaces[i] = i;
+    shuffle(spaces, s, sizeof(*spaces), rs);
+
+    /*
+     * Construct a valid filled grid by repeatedly picking an unfilled
+     * space and fill it, then calling the solver to fill in any
+     * spaces forced by the change.
+     */
+    for (j = 0; j < s; j++) {
+        i = spaces[j];
+
+        if (state->grid[i] != EMPTY)
+            continue;
+
+        if (random_upto(rs, 2)) {
+            state->grid[i] = N_ONE;
+            scratch->ones_rows[i / w2]++;
+            scratch->ones_cols[i % w2]++;
+        } else {
+            state->grid[i] = N_ZERO;
+            scratch->zeros_rows[i / w2]++;
+            scratch->zeros_cols[i % w2]++;
+        }
+
+        unruly_solve_game(state, scratch, DIFFCOUNT);
+    }
+    sfree(spaces);
+
+    if (unruly_validate_all_rows(state, NULL) != 0
+        || unruly_validate_counts(state, scratch, NULL) != 0)
+        return FALSE;
+
+    return TRUE;
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+#ifdef STANDALONE_SOLVER
+    char *debug;
+    int temp_verbose = FALSE;
+#endif
+
+    int w2 = params->w2, h2 = params->h2;
+    int s = w2 * h2;
+    int *spaces;
+    int i, j, run;
+    char *ret, *p;
+
+    game_state *state;
+    struct unruly_scratch *scratch;
+
+    int attempts = 0;
+
+    while (1) {
+
+        while (TRUE) {
+            attempts++;
+            state = blank_state(w2, h2, params->unique);
+            scratch = unruly_new_scratch(state);
+            if (unruly_fill_game(state, scratch, rs))
+                break;
+            free_game(state);
+            unruly_free_scratch(scratch);
+        }
+
+#ifdef STANDALONE_SOLVER
+        if (solver_verbose) {
+            printf("Puzzle generated in %i attempts\n", attempts);
+            debug = game_text_format(state);
+            fputs(debug, stdout);
+            sfree(debug);
+
+            temp_verbose = solver_verbose;
+            solver_verbose = FALSE;
+        }
+#endif
+
+        unruly_free_scratch(scratch);
+
+        /* Generate random array of spaces */
+        spaces = snewn(s, int);
+        for (i = 0; i < s; i++)
+            spaces[i] = i;
+        shuffle(spaces, s, sizeof(*spaces), rs);
+
+        /*
+         * Winnow the clues by starting from our filled grid, repeatedly
+         * picking a filled space and emptying it, as long as the solver
+         * reports that the puzzle can still be solved after doing so.
+         */
+        for (j = 0; j < s; j++) {
+            char c;
+            game_state *solver;
+
+            i = spaces[j];
+
+            c = state->grid[i];
+            state->grid[i] = EMPTY;
+
+            solver = dup_game(state);
+            scratch = unruly_new_scratch(state);
+
+            unruly_solve_game(solver, scratch, params->diff);
+
+            if (unruly_validate_counts(solver, scratch, NULL) != 0)
+                state->grid[i] = c;
+
+            free_game(solver);
+            unruly_free_scratch(scratch);
+        }
+        sfree(spaces);
+
+#ifdef STANDALONE_SOLVER
+        if (temp_verbose) {
+            solver_verbose = TRUE;
+
+            printf("Final puzzle:\n");
+            debug = game_text_format(state);
+            fputs(debug, stdout);
+            sfree(debug);
+        }
+#endif
+
+        /*
+         * See if the game has accidentally come out too easy.
+         */
+        if (params->diff > 0) {
+            int ok;
+            game_state *solver;
+
+            solver = dup_game(state);
+            scratch = unruly_new_scratch(state);
+
+            unruly_solve_game(solver, scratch, params->diff - 1);
+
+            ok = unruly_validate_counts(solver, scratch, NULL);
+
+            free_game(solver);
+            unruly_free_scratch(scratch);
+
+            if (ok)
+                break;
+        } else {
+            /*
+             * Puzzles of the easiest difficulty can't be too easy.
+             */
+            break;
+        }
+    }
+
+    /* Encode description */
+    ret = snewn(s + 1, char);
+    p = ret;
+    run = 0;
+    for (i = 0; i < s+1; i++) {
+        if (i == s || state->grid[i] == N_ZERO) {
+            while (run > 24) {
+                *p++ = 'z';
+                run -= 25;
+            }
+            *p++ = 'a' + run;
+            run = 0;
+        } else if (state->grid[i] == N_ONE) {
+            while (run > 24) {
+                *p++ = 'Z';
+                run -= 25;
+            }
+            *p++ = 'A' + run;
+            run = 0;
+        } else {
+            run++;
+        }
+    }
+    *p = '\0';
+
+    free_game(state);
+
+    return ret;
+}
+
+/* ************** *
+ * User Interface *
+ * ************** */
+
+struct game_ui {
+    int cx, cy;
+    char cursor;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ret = snew(game_ui);
+
+    ret->cx = ret->cy = 0;
+    ret->cursor = FALSE;
+
+    return ret;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    int tilesize;
+    int w2, h2;
+    int started;
+
+    int *gridfs;
+    int *rowfs;
+
+    int *grid;
+};
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+
+    int w2 = state->w2, h2 = state->h2;
+    int s = w2 * h2;
+    int i;
+
+    ds->tilesize = 0;
+    ds->w2 = w2;
+    ds->h2 = h2;
+    ds->started = FALSE;
+
+    ds->gridfs = snewn(s, int);
+    ds->rowfs = snewn(2 * (w2 + h2), int);
+
+    ds->grid = snewn(s, int);
+    for (i = 0; i < s; i++)
+        ds->grid[i] = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->gridfs);
+    sfree(ds->rowfs);
+    sfree(ds->grid);
+    sfree(ds);
+}
+
+#define COORD(x)     ( (x) * ds->tilesize + ds->tilesize/2 )
+#define FROMCOORD(x) ( ((x)-(ds->tilesize/2)) / ds->tilesize )
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int ox, int oy, int button)
+{
+    int hx = ui->cx;
+    int hy = ui->cy;
+
+    int gx = FROMCOORD(ox);
+    int gy = FROMCOORD(oy);
+
+    int w2 = state->w2, h2 = state->h2;
+
+    button &= ~MOD_MASK;
+
+    /* Mouse click */
+    if (button == LEFT_BUTTON || button == RIGHT_BUTTON ||
+        button == MIDDLE_BUTTON) {
+        if (ox >= (ds->tilesize / 2) && gx < w2
+            && oy >= (ds->tilesize / 2) && gy < h2) {
+            hx = gx;
+            hy = gy;
+            ui->cursor = FALSE;
+        } else
+            return NULL;
+    }
+
+    /* Keyboard move */
+    if (IS_CURSOR_MOVE(button)) {
+        move_cursor(button, &ui->cx, &ui->cy, w2, h2, 0);
+        ui->cursor = TRUE;
+        return "";
+    }
+
+    /* Place one */
+    if ((ui->cursor && (button == CURSOR_SELECT || button == CURSOR_SELECT2
+                        || button == '\b' || button == '0' || button == '1'
+                        || button == '2')) ||
+        button == LEFT_BUTTON || button == RIGHT_BUTTON ||
+        button == MIDDLE_BUTTON) {
+        char buf[80];
+        char c, i;
+
+        if (state->immutable[hy * w2 + hx])
+            return NULL;
+
+        c = '-';
+        i = state->grid[hy * w2 + hx];
+
+        if (button == '0' || button == '2')
+            c = '0';
+        else if (button == '1')
+            c = '1';
+        else if (button == MIDDLE_BUTTON)
+            c = '-';
+
+        /* Cycle through options */
+        else if (button == CURSOR_SELECT2 || button == RIGHT_BUTTON)
+            c = (i == EMPTY ? '0' : i == N_ZERO ? '1' : '-');
+        else if (button == CURSOR_SELECT || button == LEFT_BUTTON)
+            c = (i == EMPTY ? '1' : i == N_ONE ? '0' : '-');
+
+        if (state->grid[hy * w2 + hx] ==
+            (c == '0' ? N_ZERO : c == '1' ? N_ONE : EMPTY))
+            return NULL;               /* don't put no-ops on the undo chain */
+
+        sprintf(buf, "P%c,%d,%d", c, hx, hy);
+
+        return dupstr(buf);
+    }
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int w2 = state->w2, h2 = state->h2;
+    int s = w2 * h2;
+    int x, y, i;
+    char c;
+
+    game_state *ret;
+
+    if (move[0] == 'S') {
+        const char *p;
+
+        ret = dup_game(state);
+        p = move + 1;
+
+        for (i = 0; i < s; i++) {
+
+            if (!*p || !(*p == '1' || *p == '0')) {
+                free_game(ret);
+                return NULL;
+            }
+
+            ret->grid[i] = (*p == '1' ? N_ONE : N_ZERO);
+            p++;
+        }
+
+        ret->completed = ret->cheated = TRUE;
+        return ret;
+    } else if (move[0] == 'P'
+               && sscanf(move + 1, "%c,%d,%d", &c, &x, &y) == 3 && x >= 0
+               && x < w2 && y >= 0 && y < h2 && (c == '-' || c == '0'
+                                                 || c == '1')) {
+        ret = dup_game(state);
+        i = y * w2 + x;
+
+        if (state->immutable[i]) {
+            free_game(ret);
+            return NULL;
+        }
+
+        ret->grid[i] = (c == '1' ? N_ONE : c == '0' ? N_ZERO : EMPTY);
+
+        if (!ret->completed && unruly_validate_counts(ret, NULL, NULL) == 0
+            && (unruly_validate_all_rows(ret, NULL) == 0))
+            ret->completed = TRUE;
+
+        return ret;
+    }
+
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    *x = tilesize * (params->w2 + 1);
+    *y = tilesize * (params->h2 + 1);
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+    int i;
+
+    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
+
+    for (i = 0; i < 3; i++) {
+        ret[COL_1 * 3 + i] = 0.2F;
+        ret[COL_1_HIGHLIGHT * 3 + i] = 0.4F;
+        ret[COL_1_LOWLIGHT * 3 + i] = 0.0F;
+        ret[COL_0 * 3 + i] = 0.95F;
+        ret[COL_0_HIGHLIGHT * 3 + i] = 1.0F;
+        ret[COL_0_LOWLIGHT * 3 + i] = 0.9F;
+        ret[COL_EMPTY * 3 + i] = 0.5F;
+        ret[COL_GRID * 3 + i] = 0.3F;
+    }
+    game_mkhighlight_specific(fe, ret, COL_0, COL_0_HIGHLIGHT, COL_0_LOWLIGHT);
+    game_mkhighlight_specific(fe, ret, COL_1, COL_1_HIGHLIGHT, COL_1_LOWLIGHT);
+
+    ret[COL_ERROR * 3 + 0] = 1.0F;
+    ret[COL_ERROR * 3 + 1] = 0.0F;
+    ret[COL_ERROR * 3 + 2] = 0.0F;
+
+    ret[COL_CURSOR * 3 + 0] = 0.0F;
+    ret[COL_CURSOR * 3 + 1] = 0.7F;
+    ret[COL_CURSOR * 3 + 2] = 0.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static void unruly_draw_err_rectangle(drawing *dr, int x, int y, int w, int h,
+                                      int tilesize)
+{
+    double thick = tilesize / 10;
+    double margin = tilesize / 20;
+
+    draw_rect(dr, x+margin, y+margin, w-2*margin, thick, COL_ERROR);
+    draw_rect(dr, x+margin, y+margin, thick, h-2*margin, COL_ERROR);
+    draw_rect(dr, x+margin, y+h-margin-thick, w-2*margin, thick, COL_ERROR);
+    draw_rect(dr, x+w-margin-thick, y+margin, thick, h-2*margin, COL_ERROR);
+}
+
+static void unruly_draw_tile(drawing *dr, int x, int y, int tilesize, int tile)
+{
+    clip(dr, x, y, tilesize, tilesize);
+
+    /* Draw the grid edge first, so the tile can overwrite it */
+    draw_rect(dr, x, y, tilesize, tilesize, COL_GRID);
+
+    /* Background of the tile */
+    {
+        int val = (tile & FF_ZERO ? 0 : tile & FF_ONE ? 2 : 1);
+        val = (val == 0 ? COL_0 : val == 2 ? COL_1 : COL_EMPTY);
+
+        if ((tile & (FF_FLASH1 | FF_FLASH2)) &&
+             (val == COL_0 || val == COL_1)) {
+            val += (tile & FF_FLASH1 ? 1 : 2);
+        }
+
+        draw_rect(dr, x, y, tilesize-1, tilesize-1, val);
+
+        if ((val == COL_0 || val == COL_1) && (tile & FF_IMMUTABLE)) {
+            draw_rect(dr, x + tilesize/6, y + tilesize/6,
+                      tilesize - 2*(tilesize/6) - 2, 1, val + 2);
+            draw_rect(dr, x + tilesize/6, y + tilesize/6,
+                      1, tilesize - 2*(tilesize/6) - 2, val + 2);
+            draw_rect(dr, x + tilesize/6 + 1, y + tilesize - tilesize/6 - 2,
+                      tilesize - 2*(tilesize/6) - 2, 1, val + 1);
+            draw_rect(dr, x + tilesize - tilesize/6 - 2, y + tilesize/6 + 1,
+                      1, tilesize - 2*(tilesize/6) - 2, val + 1);
+        }
+    }
+
+    /* 3-in-a-row errors */
+    if (tile & (FE_HOR_ROW_LEFT | FE_HOR_ROW_RIGHT)) {
+        int left = x, right = x + tilesize - 1;
+        if ((tile & FE_HOR_ROW_LEFT))
+            right += tilesize/2;
+        if ((tile & FE_HOR_ROW_RIGHT))
+            left -= tilesize/2;
+        unruly_draw_err_rectangle(dr, left, y, right-left, tilesize-1, tilesize);
+    }
+    if (tile & (FE_VER_ROW_TOP | FE_VER_ROW_BOTTOM)) {
+        int top = y, bottom = y + tilesize - 1;
+        if ((tile & FE_VER_ROW_TOP))
+            bottom += tilesize/2;
+        if ((tile & FE_VER_ROW_BOTTOM))
+            top -= tilesize/2;
+        unruly_draw_err_rectangle(dr, x, top, tilesize-1, bottom-top, tilesize);
+    }
+
+    /* Count errors */
+    if (tile & FE_COUNT) {
+        draw_text(dr, x + tilesize/2, y + tilesize/2, FONT_VARIABLE,
+                  tilesize/2, ALIGN_HCENTRE | ALIGN_VCENTRE, COL_ERROR, "!");
+    }
+
+    /* Row-match errors */
+    if (tile & FE_ROW_MATCH) {
+        draw_rect(dr, x, y+tilesize/2-tilesize/12,
+                  tilesize, 2*(tilesize/12), COL_ERROR);
+    }
+    if (tile & FE_COL_MATCH) {
+        draw_rect(dr, x+tilesize/2-tilesize/12, y,
+                  2*(tilesize/12), tilesize, COL_ERROR);
+    }
+
+    /* Cursor rectangle */
+    if (tile & FF_CURSOR) {
+        draw_rect(dr, x, y, tilesize/12, tilesize-1, COL_CURSOR);
+        draw_rect(dr, x, y, tilesize-1, tilesize/12, COL_CURSOR);
+        draw_rect(dr, x+tilesize-1-tilesize/12, y, tilesize/12, tilesize-1,
+                  COL_CURSOR);
+        draw_rect(dr, x, y+tilesize-1-tilesize/12, tilesize-1, tilesize/12,
+                  COL_CURSOR);
+    }
+
+    unclip(dr);
+    draw_update(dr, x, y, tilesize, tilesize);
+}
+
+#define TILE_SIZE (ds->tilesize)
+#define DEFAULT_TILE_SIZE 32
+#define FLASH_FRAME 0.12F
+#define FLASH_TIME (FLASH_FRAME * 3)
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w2 = state->w2, h2 = state->h2;
+    int s = w2 * h2;
+    int flash;
+    int x, y, i;
+
+    if (!ds->started) {
+        /* Main window background */
+        draw_rect(dr, 0, 0, TILE_SIZE * (w2+1), TILE_SIZE * (h2+1),
+                  COL_BACKGROUND);
+        /* Outer edge of grid */
+        draw_rect(dr, COORD(0)-TILE_SIZE/10, COORD(0)-TILE_SIZE/10,
+                  TILE_SIZE*w2 + 2*(TILE_SIZE/10) - 1,
+                  TILE_SIZE*h2 + 2*(TILE_SIZE/10) - 1, COL_GRID);
+
+        draw_update(dr, 0, 0, TILE_SIZE * (w2+1), TILE_SIZE * (h2+1));
+        ds->started = TRUE;
+    }
+
+    flash = 0;
+    if (flashtime > 0)
+        flash = (int)(flashtime / FLASH_FRAME) == 1 ? FF_FLASH2 : FF_FLASH1;
+
+    for (i = 0; i < s; i++)
+        ds->gridfs[i] = 0;
+    unruly_validate_all_rows(state, ds->gridfs);
+    for (i = 0; i < 2 * (h2 + w2); i++)
+        ds->rowfs[i] = 0;
+    unruly_validate_counts(state, NULL, ds->rowfs);
+
+    for (y = 0; y < h2; y++) {
+        for (x = 0; x < w2; x++) {
+            int tile;
+
+            i = y * w2 + x;
+
+            tile = ds->gridfs[i];
+
+            if (state->grid[i] == N_ONE) {
+                tile |= FF_ONE;
+                if (ds->rowfs[y] || ds->rowfs[2*h2 + x])
+                    tile |= FE_COUNT;
+            } else if (state->grid[i] == N_ZERO) {
+                tile |= FF_ZERO;
+                if (ds->rowfs[h2 + y] || ds->rowfs[2*h2 + w2 + x])
+                    tile |= FE_COUNT;
+            }
+
+            tile |= flash;
+
+            if (state->immutable[i])
+                tile |= FF_IMMUTABLE;
+
+            if (ui->cursor && ui->cx == x && ui->cy == y)
+                tile |= FF_CURSOR;
+
+            if (ds->grid[i] != tile) {
+                ds->grid[i] = tile;
+                unruly_draw_tile(dr, COORD(x), COORD(y), TILE_SIZE, tile);
+            }
+        }
+    }
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    return 0.0F;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+    int pw, ph;
+
+    /* Using 7mm squares */
+    game_compute_size(params, 700, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+    int w2 = state->w2, h2 = state->h2;
+    int x, y;
+
+    int ink = print_mono_colour(dr, 0);
+
+    for (y = 0; y < h2; y++)
+        for (x = 0; x < w2; x++) {
+            int tx = x * tilesize + (tilesize / 2);
+            int ty = y * tilesize + (tilesize / 2);
+
+            /* Draw the border */
+            int coords[8];
+            coords[0] = tx;
+            coords[1] = ty - 1;
+            coords[2] = tx + tilesize;
+            coords[3] = ty - 1;
+            coords[4] = tx + tilesize;
+            coords[5] = ty + tilesize - 1;
+            coords[6] = tx;
+            coords[7] = ty + tilesize - 1;
+            draw_polygon(dr, coords, 4, -1, ink);
+
+            if (state->grid[y * w2 + x] == N_ONE)
+                draw_rect(dr, tx, ty, tilesize, tilesize, ink);
+            else if (state->grid[y * w2 + x] == N_ZERO)
+                draw_circle(dr, tx + tilesize/2, ty + tilesize/2,
+                            tilesize/12, ink, ink);
+        }
+}
+
+#ifdef COMBINED
+#define thegame unruly
+#endif
+
+const struct game thegame = {
+    "Unruly", "games.unruly", "unruly",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    TRUE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    DEFAULT_TILE_SIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    TRUE, FALSE, game_print_size, game_print,
+    FALSE,                      /* wants_statusbar */
+    FALSE, game_timing_state,
+    0,                          /* flags */
+};
+
+/* ***************** *
+ * Standalone solver *
+ * ***************** */
+
+#ifdef STANDALONE_SOLVER
+#include <time.h>
+#include <stdarg.h>
+
+/* Most of the standalone solver code was copied from unequal.c and singles.c */
+
+const char *quis;
+
+static void usage_exit(const char *msg)
+{
+    if (msg)
+        fprintf(stderr, "%s: %s\n", quis, msg);
+    fprintf(stderr,
+            "Usage: %s [-v] [--seed SEED] <params> | [game_id [game_id ...]]\n",
+            quis);
+    exit(1);
+}
+
+int main(int argc, char *argv[])
+{
+    random_state *rs;
+    time_t seed = time(NULL);
+
+    game_params *params = NULL;
+
+    char *id = NULL, *desc = NULL, *err;
+
+    quis = argv[0];
+
+    while (--argc > 0) {
+        char *p = *++argv;
+        if (!strcmp(p, "--seed")) {
+            if (argc == 0)
+                usage_exit("--seed needs an argument");
+            seed = (time_t) atoi(*++argv);
+            argc--;
+        } else if (!strcmp(p, "-v"))
+            solver_verbose = TRUE;
+        else if (*p == '-')
+            usage_exit("unrecognised option");
+        else
+            id = p;
+    }
+
+    if (id) {
+        desc = strchr(id, ':');
+        if (desc)
+            *desc++ = '\0';
+
+        params = default_params();
+        decode_params(params, id);
+        err = validate_params(params, TRUE);
+        if (err) {
+            fprintf(stderr, "Parameters are invalid\n");
+            fprintf(stderr, "%s: %s", argv[0], err);
+            exit(1);
+        }
+    }
+
+    if (!desc) {
+        char *desc_gen, *aux;
+        rs = random_new((void *) &seed, sizeof(time_t));
+        if (!params)
+            params = default_params();
+        printf("Generating puzzle with parameters %s\n",
+               encode_params(params, TRUE));
+        desc_gen = new_game_desc(params, rs, &aux, FALSE);
+
+        if (!solver_verbose) {
+            char *fmt = game_text_format(new_game(NULL, params, desc_gen));
+            fputs(fmt, stdout);
+            sfree(fmt);
+        }
+
+        printf("Game ID: %s\n", desc_gen);
+    } else {
+        game_state *input;
+        struct unruly_scratch *scratch;
+        int maxdiff, errcode;
+
+        err = validate_desc(params, desc);
+        if (err) {
+            fprintf(stderr, "Description is invalid\n");
+            fprintf(stderr, "%s", err);
+            exit(1);
+        }
+
+        input = new_game(NULL, params, desc);
+        scratch = unruly_new_scratch(input);
+
+        maxdiff = unruly_solve_game(input, scratch, DIFFCOUNT);
+
+        errcode = unruly_validate_counts(input, scratch, NULL);
+        if (unruly_validate_all_rows(input, NULL) == -1)
+            errcode = -1;
+
+        if (errcode != -1) {
+            char *fmt = game_text_format(input);
+            fputs(fmt, stdout);
+            sfree(fmt);
+            if (maxdiff < 0)
+                printf("Difficulty: already solved!\n");
+            else
+                printf("Difficulty: %s\n", unruly_diffnames[maxdiff]);
+        }
+
+        if (errcode == 1)
+            printf("No solution found.\n");
+        else if (errcode == -1)
+            printf("Puzzle is invalid.\n");
+
+        free_game(input);
+        unruly_free_scratch(scratch);
+    }
+
+    return 0;
+}
+#endif
diff --git a/apps/plugins/puzzles/untangle.R b/apps/plugins/puzzles/untangle.R
new file mode 100644
index 0000000000..a57f1e56fd
--- /dev/null
+++ b/apps/plugins/puzzles/untangle.R
@@ -0,0 +1,21 @@
+# -*- makefile -*-
+
+UNTANGLE_EXTRA = tree234
+
+untangle : [X] GTK COMMON untangle UNTANGLE_EXTRA untangle-icon|no-icon
+
+untangle : [G] WINDOWS COMMON untangle UNTANGLE_EXTRA untangle.res|noicon.res
+
+ALL += untangle[COMBINED] UNTANGLE_EXTRA
+
+!begin am gtk
+GAMES += untangle
+!end
+
+!begin >list.c
+    A(untangle) \
+!end
+
+!begin >gamedesc.txt
+untangle:untangle.exe:Untangle:Planar graph layout puzzle:Reposition the points so that the lines do not cross.
+!end
diff --git a/apps/plugins/puzzles/untangle.c b/apps/plugins/puzzles/untangle.c
new file mode 100644
index 0000000000..67da03d8c0
--- /dev/null
+++ b/apps/plugins/puzzles/untangle.c
@@ -0,0 +1,1491 @@
+/*
+ * untangle.c: Game about planar graphs. You are given a graph
+ * represented by points and straight lines, with some lines
+ * crossing; your task is to drag the points into a configuration
+ * where none of the lines cross.
+ * 
+ * Cloned from a Flash game called `Planarity', by John Tantalo.
+ * <http://home.cwru.edu/~jnt5/Planarity> at the time of writing
+ * this. The Flash game had a fixed set of levels; my added value,
+ * as usual, is automatic generation of random games to order.
+ */
+
+/*
+ * TODO:
+ *
+ *  - This puzzle, perhaps uniquely among the collection, could use
+ *    support for non-aspect-ratio-preserving resizes. This would
+ *    require some sort of fairly large redesign, unfortunately (since
+ *    it would invalidate the basic assumption that puzzles' size
+ *    requirements are adequately expressed by a single scalar tile
+ *    size), and probably complicate the rest of the puzzles' API as a
+ *    result. So I'm not sure I really want to do it.
+ *
+ *  - It would be nice if we could somehow auto-detect a real `long
+ *    long' type on the host platform and use it in place of my
+ *    hand-hacked int64s. It'd be faster and more reliable.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <math.h>
+
+#include "puzzles.h"
+#include "tree234.h"
+
+#define CIRCLE_RADIUS 6
+#define DRAG_THRESHOLD (CIRCLE_RADIUS * 2)
+#define PREFERRED_TILESIZE 64
+
+#define FLASH_TIME 0.30F
+#define ANIM_TIME 0.13F
+#define SOLVEANIM_TIME 0.50F
+
+enum {
+    COL_SYSBACKGROUND,
+    COL_BACKGROUND,
+    COL_LINE,
+#ifdef SHOW_CROSSINGS
+    COL_CROSSEDLINE,
+#endif
+    COL_OUTLINE,
+    COL_POINT,
+    COL_DRAGPOINT,
+    COL_NEIGHBOUR,
+    COL_FLASH1,
+    COL_FLASH2,
+    NCOLOURS
+};
+
+typedef struct point {
+    /*
+     * Points are stored using rational coordinates, with the same
+     * denominator for both coordinates.
+     */
+    long x, y, d;
+} point;
+
+typedef struct edge {
+    /*
+     * This structure is implicitly associated with a particular
+     * point set, so all it has to do is to store two point
+     * indices. It is required to store them in the order (lower,
+     * higher), i.e. a < b always.
+     */
+    int a, b;
+} edge;
+
+struct game_params {
+    int n;                             /* number of points */
+};
+
+struct graph {
+    int refcount;                      /* for deallocation */
+    tree234 *edges;                    /* stores `edge' structures */
+};
+
+struct game_state {
+    game_params params;
+    int w, h;                          /* extent of coordinate system only */
+    point *pts;
+#ifdef SHOW_CROSSINGS
+    int *crosses;                      /* mark edges which are crossed */
+#endif
+    struct graph *graph;
+    int completed, cheated, just_solved;
+};
+
+static int edgecmpC(const void *av, const void *bv)
+{
+    const edge *a = (const edge *)av;
+    const edge *b = (const edge *)bv;
+
+    if (a->a < b->a)
+        return -1;
+    else if (a->a > b->a)
+        return +1;
+    else if (a->b < b->b)
+        return -1;
+    else if (a->b > b->b)
+        return +1;
+    return 0;
+}
+
+static int edgecmp(void *av, void *bv) { return edgecmpC(av, bv); }
+
+static game_params *default_params(void)
+{
+    game_params *ret = snew(game_params);
+
+    ret->n = 10;
+
+    return ret;
+}
+
+static int game_fetch_preset(int i, char **name, game_params **params)
+{
+    game_params *ret;
+    int n;
+    char buf[80];
+
+    switch (i) {
+      case 0: n = 6; break;
+      case 1: n = 10; break;
+      case 2: n = 15; break;
+      case 3: n = 20; break;
+      case 4: n = 25; break;
+      default: return FALSE;
+    }
+
+    sprintf(buf, "%d points", n);
+    *name = dupstr(buf);
+
+    *params = ret = snew(game_params);
+    ret->n = n;
+
+    return TRUE;
+}
+
+static void free_params(game_params *params)
+{
+    sfree(params);
+}
+
+static game_params *dup_params(const game_params *params)
+{
+    game_params *ret = snew(game_params);
+    *ret = *params;                    /* structure copy */
+    return ret;
+}
+
+static void decode_params(game_params *params, char const *string)
+{
+    params->n = atoi(string);
+}
+
+static char *encode_params(const game_params *params, int full)
+{
+    char buf[80];
+
+    sprintf(buf, "%d", params->n);
+
+    return dupstr(buf);
+}
+
+static config_item *game_configure(const game_params *params)
+{
+    config_item *ret;
+    char buf[80];
+
+    ret = snewn(3, config_item);
+
+    ret[0].name = "Number of points";
+    ret[0].type = C_STRING;
+    sprintf(buf, "%d", params->n);
+    ret[0].sval = dupstr(buf);
+    ret[0].ival = 0;
+
+    ret[1].name = NULL;
+    ret[1].type = C_END;
+    ret[1].sval = NULL;
+    ret[1].ival = 0;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->n = atoi(cfg[0].sval);
+
+    return ret;
+}
+
+static char *validate_params(const game_params *params, int full)
+{
+    if (params->n < 4)
+        return "Number of points must be at least four";
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Small number of 64-bit integer arithmetic operations, to prevent
+ * integer overflow at the very core of cross().
+ */
+
+typedef struct {
+    long hi;
+    unsigned long lo;
+} int64;
+
+#define greater64(i,j) ( (i).hi>(j).hi || ((i).hi==(j).hi && (i).lo>(j).lo))
+#define sign64(i) ((i).hi < 0 ? -1 : (i).hi==0 && (i).lo==0 ? 0 : +1)
+
+static int64 mulu32to64(unsigned long x, unsigned long y)
+{
+    unsigned long a, b, c, d, t;
+    int64 ret;
+
+    a = (x & 0xFFFF) * (y & 0xFFFF);
+    b = (x & 0xFFFF) * (y >> 16);
+    c = (x >> 16) * (y & 0xFFFF);
+    d = (x >> 16) * (y >> 16);
+
+    ret.lo = a;
+    ret.hi = d + (b >> 16) + (c >> 16);
+    t = (b & 0xFFFF) << 16;
+    ret.lo += t;
+    if (ret.lo < t)
+        ret.hi++;
+    t = (c & 0xFFFF) << 16;
+    ret.lo += t;
+    if (ret.lo < t)
+        ret.hi++;
+
+#ifdef DIAGNOSTIC_VIA_LONGLONG
+    assert(((unsigned long long)ret.hi << 32) + ret.lo ==
+           (unsigned long long)x * y);
+#endif
+
+    return ret;
+}
+
+static int64 mul32to64(long x, long y)
+{
+    int sign = +1;
+    int64 ret;
+#ifdef DIAGNOSTIC_VIA_LONGLONG
+    long long realret = (long long)x * y;
+#endif
+
+    if (x < 0)
+        x = -x, sign = -sign;
+    if (y < 0)
+        y = -y, sign = -sign;
+
+    ret = mulu32to64(x, y);
+
+    if (sign < 0) {
+        ret.hi = -ret.hi;
+        ret.lo = -ret.lo;
+        if (ret.lo)
+            ret.hi--;
+    }
+
+#ifdef DIAGNOSTIC_VIA_LONGLONG
+    assert(((unsigned long long)ret.hi << 32) + ret.lo == realret);
+#endif
+
+    return ret;
+}
+
+static int64 dotprod64(long a, long b, long p, long q)
+{
+    int64 ab, pq;
+
+    ab = mul32to64(a, b);
+    pq = mul32to64(p, q);
+    ab.hi += pq.hi;
+    ab.lo += pq.lo;
+    if (ab.lo < pq.lo)
+        ab.hi++;
+    return ab;
+}
+
+/*
+ * Determine whether the line segments between a1 and a2, and
+ * between b1 and b2, intersect. We count it as an intersection if
+ * any of the endpoints lies _on_ the other line.
+ */
+static int cross(point a1, point a2, point b1, point b2)
+{
+    long b1x, b1y, b2x, b2y, px, py;
+    int64 d1, d2, d3;
+
+    /*
+     * The condition for crossing is that b1 and b2 are on opposite
+     * sides of the line a1-a2, and vice versa. We determine this
+     * by taking the dot product of b1-a1 with a vector
+     * perpendicular to a2-a1, and similarly with b2-a1, and seeing
+     * if they have different signs.
+     */
+
+    /*
+     * Construct the vector b1-a1. We don't have to worry too much
+     * about the denominator, because we're only going to check the
+     * sign of this vector; we just need to get the numerator
+     * right.
+     */
+    b1x = b1.x * a1.d - a1.x * b1.d;
+    b1y = b1.y * a1.d - a1.y * b1.d;
+    /* Now construct b2-a1, and a vector perpendicular to a2-a1,
+     * in the same way. */
+    b2x = b2.x * a1.d - a1.x * b2.d;
+    b2y = b2.y * a1.d - a1.y * b2.d;
+    px = a1.y * a2.d - a2.y * a1.d;
+    py = a2.x * a1.d - a1.x * a2.d;
+    /* Take the dot products. Here we resort to 64-bit arithmetic. */
+    d1 = dotprod64(b1x, px, b1y, py);
+    d2 = dotprod64(b2x, px, b2y, py);
+    /* If they have the same non-zero sign, the lines do not cross. */
+    if ((sign64(d1) > 0 && sign64(d2) > 0) ||
+        (sign64(d1) < 0 && sign64(d2) < 0))
+        return FALSE;
+
+    /*
+     * If the dot products are both exactly zero, then the two line
+     * segments are collinear. At this point the intersection
+     * condition becomes whether or not they overlap within their
+     * line.
+     */
+    if (sign64(d1) == 0 && sign64(d2) == 0) {
+        /* Construct the vector a2-a1. */
+        px = a2.x * a1.d - a1.x * a2.d;
+        py = a2.y * a1.d - a1.y * a2.d;
+        /* Determine the dot products of b1-a1 and b2-a1 with this. */
+        d1 = dotprod64(b1x, px, b1y, py);
+        d2 = dotprod64(b2x, px, b2y, py);
+        /* If they're both strictly negative, the lines do not cross. */
+        if (sign64(d1) < 0 && sign64(d2) < 0)
+            return FALSE;
+        /* Otherwise, take the dot product of a2-a1 with itself. If
+         * the other two dot products both exceed this, the lines do
+         * not cross. */
+        d3 = dotprod64(px, px, py, py);
+        if (greater64(d1, d3) && greater64(d2, d3))
+            return FALSE;
+    }
+
+    /*
+     * We've eliminated the only important special case, and we
+     * have determined that b1 and b2 are on opposite sides of the
+     * line a1-a2. Now do the same thing the other way round and
+     * we're done.
+     */
+    b1x = a1.x * b1.d - b1.x * a1.d;
+    b1y = a1.y * b1.d - b1.y * a1.d;
+    b2x = a2.x * b1.d - b1.x * a2.d;
+    b2y = a2.y * b1.d - b1.y * a2.d;
+    px = b1.y * b2.d - b2.y * b1.d;
+    py = b2.x * b1.d - b1.x * b2.d;
+    d1 = dotprod64(b1x, px, b1y, py);
+    d2 = dotprod64(b2x, px, b2y, py);
+    if ((sign64(d1) > 0 && sign64(d2) > 0) ||
+        (sign64(d1) < 0 && sign64(d2) < 0))
+        return FALSE;
+
+    /*
+     * The lines must cross.
+     */
+    return TRUE;
+}
+
+static unsigned long squarert(unsigned long n) {
+    unsigned long d, a, b, di;
+
+    d = n;
+    a = 0;
+    b = 1L << 30;                      /* largest available power of 4 */
+    do {
+        a >>= 1;
+        di = 2*a + b;
+        if (di <= d) {
+            d -= di;
+            a += b;
+        }
+        b >>= 2;
+    } while (b);
+
+    return a;
+}
+
+/*
+ * Our solutions are arranged on a square grid big enough that n
+ * points occupy about 1/POINTDENSITY of the grid.
+ */
+#define POINTDENSITY 3
+#define MAXDEGREE 4
+#define COORDLIMIT(n) squarert((n) * POINTDENSITY)
+
+static void addedge(tree234 *edges, int a, int b)
+{
+    edge *e = snew(edge);
+
+    assert(a != b);
+
+    e->a = min(a, b);
+    e->b = max(a, b);
+
+    add234(edges, e);
+}
+
+static int isedge(tree234 *edges, int a, int b)
+{
+    edge e;
+
+    assert(a != b);
+
+    e.a = min(a, b);
+    e.b = max(a, b);
+
+    return find234(edges, &e, NULL) != NULL;
+}
+
+typedef struct vertex {
+    int param;
+    int vindex;
+} vertex;
+
+static int vertcmpC(const void *av, const void *bv)
+{
+    const vertex *a = (vertex *)av;
+    const vertex *b = (vertex *)bv;
+
+    if (a->param < b->param)
+        return -1;
+    else if (a->param > b->param)
+        return +1;
+    else if (a->vindex < b->vindex)
+        return -1;
+    else if (a->vindex > b->vindex)
+        return +1;
+    return 0;
+}
+static int vertcmp(void *av, void *bv) { return vertcmpC(av, bv); }
+
+/*
+ * Construct point coordinates for n points arranged in a circle,
+ * within the bounding box (0,0) to (w,w).
+ */
+static void make_circle(point *pts, int n, int w)
+{
+    long d, r, c, i;
+
+    /*
+     * First, decide on a denominator. Although in principle it
+     * would be nice to set this really high so as to finely
+     * distinguish all the points on the circle, I'm going to set
+     * it at a fixed size to prevent integer overflow problems.
+     */
+    d = PREFERRED_TILESIZE;
+
+    /*
+     * Leave a little space outside the circle.
+     */
+    c = d * w / 2;
+    r = d * w * 3 / 7;
+
+    /*
+     * Place the points.
+     */
+    for (i = 0; i < n; i++) {
+        double angle = i * 2 * PI / n;
+        double x = r * sin(angle), y = - r * cos(angle);
+        pts[i].x = (long)(c + x + 0.5);
+        pts[i].y = (long)(c + y + 0.5);
+        pts[i].d = d;
+    }
+}
+
+static char *new_game_desc(const game_params *params, random_state *rs,
+                           char **aux, int interactive)
+{
+    int n = params->n, i;
+    long w, h, j, k, m;
+    point *pts, *pts2;
+    long *tmp;
+    tree234 *edges, *vertices;
+    edge *e, *e2;
+    vertex *v, *vs, *vlist;
+    char *ret;
+
+    w = h = COORDLIMIT(n);
+
+    /*
+     * Choose n points from this grid.
+     */
+    pts = snewn(n, point);
+    tmp = snewn(w*h, long);
+    for (i = 0; i < w*h; i++)
+        tmp[i] = i;
+    shuffle(tmp, w*h, sizeof(*tmp), rs);
+    for (i = 0; i < n; i++) {
+        pts[i].x = tmp[i] % w;
+        pts[i].y = tmp[i] / w;
+        pts[i].d = 1;
+    }
+    sfree(tmp);
+
+    /*
+     * Now start adding edges between the points.
+     * 
+     * At all times, we attempt to add an edge to the lowest-degree
+     * vertex we currently have, and we try the other vertices as
+     * candidate second endpoints in order of distance from this
+     * one. We stop as soon as we find an edge which
+     * 
+     *  (a) does not increase any vertex's degree beyond MAXDEGREE
+     *  (b) does not cross any existing edges
+     *  (c) does not intersect any actual point.
+     */
+    vs = snewn(n, vertex);
+    vertices = newtree234(vertcmp);
+    for (i = 0; i < n; i++) {
+        v = vs + i;
+        v->param = 0;                  /* in this tree, param is the degree */
+        v->vindex = i;
+        add234(vertices, v);
+    }
+    edges = newtree234(edgecmp);
+    vlist = snewn(n, vertex);
+    while (1) {
+        int added = FALSE;
+
+        for (i = 0; i < n; i++) {
+            v = index234(vertices, i);
+            j = v->vindex;
+
+            if (v->param >= MAXDEGREE)
+                break;                 /* nothing left to add! */
+
+            /*
+             * Sort the other vertices into order of their distance
+             * from this one. Don't bother looking below i, because
+             * we've already tried those edges the other way round.
+             * Also here we rule out target vertices with too high
+             * a degree, and (of course) ones to which we already
+             * have an edge.
+             */
+            m = 0;
+            for (k = i+1; k < n; k++) {
+                vertex *kv = index234(vertices, k);
+                int ki = kv->vindex;
+                int dx, dy;
+
+                if (kv->param >= MAXDEGREE || isedge(edges, ki, j))
+                    continue;
+
+                vlist[m].vindex = ki;
+                dx = pts[ki].x - pts[j].x;
+                dy = pts[ki].y - pts[j].y;
+                vlist[m].param = dx*dx + dy*dy;
+                m++;
+            }
+
+            qsort(vlist, m, sizeof(*vlist), vertcmpC);
+
+            for (k = 0; k < m; k++) {
+                int p;
+                int ki = vlist[k].vindex;
+
+                /*
+                 * Check to see whether this edge intersects any
+                 * existing edge or point.
+                 */
+                for (p = 0; p < n; p++)
+                    if (p != ki && p != j && cross(pts[ki], pts[j],
+                                                   pts[p], pts[p]))
+                        break;
+                if (p < n)
+                    continue;
+                for (p = 0; (e = index234(edges, p)) != NULL; p++)
+                    if (e->a != ki && e->a != j &&
+                        e->b != ki && e->b != j &&
+                        cross(pts[ki], pts[j], pts[e->a], pts[e->b]))
+                        break;
+                if (e)
+                    continue;
+
+                /*
+                 * We're done! Add this edge, modify the degrees of
+                 * the two vertices involved, and break.
+                 */
+                addedge(edges, j, ki);
+                added = TRUE;
+                del234(vertices, vs+j);
+                vs[j].param++;
+                add234(vertices, vs+j);
+                del234(vertices, vs+ki);
+                vs[ki].param++;
+                add234(vertices, vs+ki);
+                break;
+            }
+
+            if (k < m)
+                break;
+        }
+
+        if (!added)
+            break;                     /* we're done. */
+    }
+
+    /*
+     * That's our graph. Now shuffle the points, making sure that
+     * they come out with at least one crossed line when arranged
+     * in a circle (so that the puzzle isn't immediately solved!).
+     */
+    tmp = snewn(n, long);
+    for (i = 0; i < n; i++)
+        tmp[i] = i;
+    pts2 = snewn(n, point);
+    make_circle(pts2, n, w);
+    while (1) {
+        shuffle(tmp, n, sizeof(*tmp), rs);
+        for (i = 0; (e = index234(edges, i)) != NULL; i++) {
+            for (j = i+1; (e2 = index234(edges, j)) != NULL; j++) {
+                if (e2->a == e->a || e2->a == e->b ||
+                    e2->b == e->a || e2->b == e->b)
+                    continue;
+                if (cross(pts2[tmp[e2->a]], pts2[tmp[e2->b]],
+                          pts2[tmp[e->a]], pts2[tmp[e->b]]))
+                    break;
+            }
+            if (e2)
+                break;
+        }
+        if (e)
+            break;                     /* we've found a crossing */
+    }
+
+    /*
+     * We're done. Now encode the graph in a string format. Let's
+     * use a comma-separated list of dash-separated vertex number
+     * pairs, numbered from zero. We'll sort the list to prevent
+     * side channels.
+     */
+    ret = NULL;
+    {
+        char *sep;
+        char buf[80];
+        int retlen;
+        edge *ea;
+
+        retlen = 0;
+        m = count234(edges);
+        ea = snewn(m, edge);
+        for (i = 0; (e = index234(edges, i)) != NULL; i++) {
+            assert(i < m);
+            ea[i].a = min(tmp[e->a], tmp[e->b]);
+            ea[i].b = max(tmp[e->a], tmp[e->b]);
+            retlen += 1 + sprintf(buf, "%d-%d", ea[i].a, ea[i].b);
+        }
+        assert(i == m);
+        qsort(ea, m, sizeof(*ea), edgecmpC);
+
+        ret = snewn(retlen, char);
+        sep = "";
+        k = 0;
+
+        for (i = 0; i < m; i++) {
+            k += sprintf(ret + k, "%s%d-%d", sep, ea[i].a, ea[i].b);
+            sep = ",";
+        }
+        assert(k < retlen);
+
+        sfree(ea);
+    }
+
+    /*
+     * Encode the solution we started with as an aux_info string.
+     */
+    {
+        char buf[80];
+        char *auxstr;
+        int auxlen;
+
+        auxlen = 2;                    /* leading 'S' and trailing '\0' */
+        for (i = 0; i < n; i++) {
+            j = tmp[i];
+            pts2[j] = pts[i];
+            if (pts2[j].d & 1) {
+                pts2[j].x *= 2;
+                pts2[j].y *= 2;
+                pts2[j].d *= 2;
+            }
+            pts2[j].x += pts2[j].d / 2;
+            pts2[j].y += pts2[j].d / 2;
+            auxlen += sprintf(buf, ";P%d:%ld,%ld/%ld", i,
+                              pts2[j].x, pts2[j].y, pts2[j].d);
+        }
+        k = 0;
+        auxstr = snewn(auxlen, char);
+        auxstr[k++] = 'S';
+        for (i = 0; i < n; i++)
+            k += sprintf(auxstr+k, ";P%d:%ld,%ld/%ld", i,
+                         pts2[i].x, pts2[i].y, pts2[i].d);
+        assert(k < auxlen);
+        *aux = auxstr;
+    }
+    sfree(pts2);
+
+    sfree(tmp);
+    sfree(vlist);
+    freetree234(vertices);
+    sfree(vs);
+    while ((e = delpos234(edges, 0)) != NULL)
+        sfree(e);
+    freetree234(edges);
+    sfree(pts);
+
+    return ret;
+}
+
+static char *validate_desc(const game_params *params, const char *desc)
+{
+    int a, b;
+
+    while (*desc) {
+        a = atoi(desc);
+        if (a < 0 || a >= params->n)
+            return "Number out of range in game description";
+        while (*desc && isdigit((unsigned char)*desc)) desc++;
+        if (*desc != '-')
+            return "Expected '-' after number in game description";
+        desc++;                        /* eat dash */
+        b = atoi(desc);
+        if (b < 0 || b >= params->n)
+            return "Number out of range in game description";
+        while (*desc && isdigit((unsigned char)*desc)) desc++;
+        if (*desc) {
+            if (*desc != ',')
+                return "Expected ',' after number in game description";
+            desc++;                    /* eat comma */
+        }
+    }
+
+    return NULL;
+}
+
+static void mark_crossings(game_state *state)
+{
+    int ok = TRUE;
+    int i, j;
+    edge *e, *e2;
+
+#ifdef SHOW_CROSSINGS
+    for (i = 0; (e = index234(state->graph->edges, i)) != NULL; i++)
+        state->crosses[i] = FALSE;
+#endif
+
+    /*
+     * Check correctness: for every pair of edges, see whether they
+     * cross.
+     */
+    for (i = 0; (e = index234(state->graph->edges, i)) != NULL; i++) {
+        for (j = i+1; (e2 = index234(state->graph->edges, j)) != NULL; j++) {
+            if (e2->a == e->a || e2->a == e->b ||
+                e2->b == e->a || e2->b == e->b)
+                continue;
+            if (cross(state->pts[e2->a], state->pts[e2->b],
+                      state->pts[e->a], state->pts[e->b])) {
+                ok = FALSE;
+#ifdef SHOW_CROSSINGS
+                state->crosses[i] = state->crosses[j] = TRUE;
+#else
+                goto done;             /* multi-level break - sorry */
+#endif
+            }
+        }
+    }
+
+    /*
+     * e == NULL if we've gone through all the edge pairs
+     * without finding a crossing.
+     */
+#ifndef SHOW_CROSSINGS
+    done:
+#endif
+    if (ok)
+        state->completed = TRUE;
+}
+
+static game_state *new_game(midend *me, const game_params *params,
+                            const char *desc)
+{
+    int n = params->n;
+    game_state *state = snew(game_state);
+    int a, b;
+
+    state->params = *params;
+    state->w = state->h = COORDLIMIT(n);
+    state->pts = snewn(n, point);
+    make_circle(state->pts, n, state->w);
+    state->graph = snew(struct graph);
+    state->graph->refcount = 1;
+    state->graph->edges = newtree234(edgecmp);
+    state->completed = state->cheated = state->just_solved = FALSE;
+
+    while (*desc) {
+        a = atoi(desc);
+        assert(a >= 0 && a < params->n);
+        while (*desc && isdigit((unsigned char)*desc)) desc++;
+        assert(*desc == '-');
+        desc++;                        /* eat dash */
+        b = atoi(desc);
+        assert(b >= 0 && b < params->n);
+        while (*desc && isdigit((unsigned char)*desc)) desc++;
+        if (*desc) {
+            assert(*desc == ',');
+            desc++;                    /* eat comma */
+        }
+        addedge(state->graph->edges, a, b);
+    }
+
+#ifdef SHOW_CROSSINGS
+    state->crosses = snewn(count234(state->graph->edges), int);
+    mark_crossings(state);             /* sets up `crosses' and `completed' */
+#endif
+
+    return state;
+}
+
+static game_state *dup_game(const game_state *state)
+{
+    int n = state->params.n;
+    game_state *ret = snew(game_state);
+
+    ret->params = state->params;
+    ret->w = state->w;
+    ret->h = state->h;
+    ret->pts = snewn(n, point);
+    memcpy(ret->pts, state->pts, n * sizeof(point));
+    ret->graph = state->graph;
+    ret->graph->refcount++;
+    ret->completed = state->completed;
+    ret->cheated = state->cheated;
+    ret->just_solved = state->just_solved;
+#ifdef SHOW_CROSSINGS
+    ret->crosses = snewn(count234(ret->graph->edges), int);
+    memcpy(ret->crosses, state->crosses,
+           count234(ret->graph->edges) * sizeof(int));
+#endif
+
+    return ret;
+}
+
+static void free_game(game_state *state)
+{
+    if (--state->graph->refcount <= 0) {
+        edge *e;
+        while ((e = delpos234(state->graph->edges, 0)) != NULL)
+            sfree(e);
+        freetree234(state->graph->edges);
+        sfree(state->graph);
+    }
+    sfree(state->pts);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, char **error)
+{
+    int n = state->params.n;
+    int matrix[4];
+    point *pts;
+    int i, j, besti;
+    float bestd;
+    char buf[80], *ret;
+    int retlen, retsize;
+
+    if (!aux) {
+        *error = "Solution not known for this puzzle";
+        return NULL;
+    }
+
+    /*
+     * Decode the aux_info to get the original point positions.
+     */
+    pts = snewn(n, point);
+    aux++;                             /* eat 'S' */
+    for (i = 0; i < n; i++) {
+        int p, k;
+        long x, y, d;
+        int ret = sscanf(aux, ";P%d:%ld,%ld/%ld%n", &p, &x, &y, &d, &k);
+        if (ret != 4 || p != i) {
+            *error = "Internal error: aux_info badly formatted";
+            sfree(pts);
+            return NULL;
+        }
+        pts[i].x = x;
+        pts[i].y = y;
+        pts[i].d = d;
+        aux += k;
+    }
+
+    /*
+     * Now go through eight possible symmetries of the point set.
+     * For each one, work out the sum of the Euclidean distances
+     * between the points' current positions and their new ones.
+     * 
+     * We're squaring distances here, which means we're at risk of
+     * integer overflow. Fortunately, there's no real need to be
+     * massively careful about rounding errors, since this is a
+     * non-essential bit of the code; so I'll just work in floats
+     * internally.
+     */
+    besti = -1;
+    bestd = 0.0F;
+
+    for (i = 0; i < 8; i++) {
+        float d;
+
+        matrix[0] = matrix[1] = matrix[2] = matrix[3] = 0;
+        matrix[i & 1] = (i & 2) ? +1 : -1;
+        matrix[3-(i&1)] = (i & 4) ? +1 : -1;
+
+        d = 0.0F;
+        for (j = 0; j < n; j++) {
+            float px = (float)pts[j].x / pts[j].d;
+            float py = (float)pts[j].y / pts[j].d;
+            float sx = (float)currstate->pts[j].x / currstate->pts[j].d;
+            float sy = (float)currstate->pts[j].y / currstate->pts[j].d;
+            float cx = (float)currstate->w / 2;
+            float cy = (float)currstate->h / 2;
+            float ox, oy, dx, dy;
+
+            px -= cx;
+            py -= cy;
+
+            ox = matrix[0] * px + matrix[1] * py;
+            oy = matrix[2] * px + matrix[3] * py;
+
+            ox += cx;
+            oy += cy;
+
+            dx = ox - sx;
+            dy = oy - sy;
+
+            d += dx*dx + dy*dy;
+        }
+
+        if (besti < 0 || bestd > d) {
+            besti = i;
+            bestd = d;
+        }
+    }
+
+    assert(besti >= 0);
+
+    /*
+     * Now we know which symmetry is closest to the points' current
+     * positions. Use it.
+     */
+    matrix[0] = matrix[1] = matrix[2] = matrix[3] = 0;
+    matrix[besti & 1] = (besti & 2) ? +1 : -1;
+    matrix[3-(besti&1)] = (besti & 4) ? +1 : -1;
+
+    retsize = 256;
+    ret = snewn(retsize, char);
+    retlen = 0;
+    ret[retlen++] = 'S';
+    ret[retlen] = '\0';
+
+    for (i = 0; i < n; i++) {
+        float px = (float)pts[i].x / pts[i].d;
+        float py = (float)pts[i].y / pts[i].d;
+        float cx = (float)currstate->w / 2;
+        float cy = (float)currstate->h / 2;
+        float ox, oy;
+        int extra;
+
+        px -= cx;
+        py -= cy;
+
+        ox = matrix[0] * px + matrix[1] * py;
+        oy = matrix[2] * px + matrix[3] * py;
+
+        ox += cx;
+        oy += cy;
+
+        /*
+         * Use a fixed denominator of 2, because we know the
+         * original points were on an integer grid offset by 1/2.
+         */
+        pts[i].d = 2;
+        ox *= pts[i].d;
+        oy *= pts[i].d;
+        pts[i].x = (long)(ox + 0.5F);
+        pts[i].y = (long)(oy + 0.5F);
+
+        extra = sprintf(buf, ";P%d:%ld,%ld/%ld", i,
+                        pts[i].x, pts[i].y, pts[i].d);
+        if (retlen + extra >= retsize) {
+            retsize = retlen + extra + 256;
+            ret = sresize(ret, retsize, char);
+        }
+        strcpy(ret + retlen, buf);
+        retlen += extra;
+    }
+
+    sfree(pts);
+
+    return ret;
+}
+
+static int game_can_format_as_text_now(const game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
+{
+    return NULL;
+}
+
+struct game_ui {
+    int dragpoint;                     /* point being dragged; -1 if none */
+    point newpoint;                    /* where it's been dragged to so far */
+    int just_dragged;                  /* reset in game_changed_state */
+    int just_moved;                    /* _set_ in game_changed_state */
+    float anim_length;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+    ui->dragpoint = -1;
+    ui->just_moved = ui->just_dragged = FALSE;
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static char *encode_ui(const game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, const char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+    ui->dragpoint = -1;
+    ui->just_moved = ui->just_dragged;
+    ui->just_dragged = FALSE;
+}
+
+struct game_drawstate {
+    long tilesize;
+    int bg, dragpoint;
+    long *x, *y;
+};
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+                            const game_drawstate *ds,
+                            int x, int y, int button)
+{
+    int n = state->params.n;
+
+    if (IS_MOUSE_DOWN(button)) {
+        int i, best;
+        long bestd;
+
+        /*
+         * Begin drag. We drag the vertex _nearest_ to the pointer,
+         * just in case one is nearly on top of another and we want
+         * to drag the latter. However, we drag nothing at all if
+         * the nearest vertex is outside DRAG_THRESHOLD.
+         */
+        best = -1;
+        bestd = 0;
+
+        for (i = 0; i < n; i++) {
+            long px = state->pts[i].x * ds->tilesize / state->pts[i].d;
+            long py = state->pts[i].y * ds->tilesize / state->pts[i].d;
+            long dx = px - x;
+            long dy = py - y;
+            long d = dx*dx + dy*dy;
+
+            if (best == -1 || bestd > d) {
+                best = i;
+                bestd = d;
+            }
+        }
+
+        if (bestd <= DRAG_THRESHOLD * DRAG_THRESHOLD) {
+            ui->dragpoint = best;
+            ui->newpoint.x = x;
+            ui->newpoint.y = y;
+            ui->newpoint.d = ds->tilesize;
+            return "";
+        }
+
+    } else if (IS_MOUSE_DRAG(button) && ui->dragpoint >= 0) {
+        ui->newpoint.x = x;
+        ui->newpoint.y = y;
+        ui->newpoint.d = ds->tilesize;
+        return "";
+    } else if (IS_MOUSE_RELEASE(button) && ui->dragpoint >= 0) {
+        int p = ui->dragpoint;
+        char buf[80];
+
+        ui->dragpoint = -1;            /* terminate drag, no matter what */
+
+        /*
+         * First, see if we're within range. The user can cancel a
+         * drag by dragging the point right off the window.
+         */
+        if (ui->newpoint.x < 0 ||
+            ui->newpoint.x >= (long)state->w*ui->newpoint.d ||
+            ui->newpoint.y < 0 ||
+            ui->newpoint.y >= (long)state->h*ui->newpoint.d)
+            return "";
+
+        /*
+         * We aren't cancelling the drag. Construct a move string
+         * indicating where this point is going to.
+         */
+        sprintf(buf, "P%d:%ld,%ld/%ld", p,
+                ui->newpoint.x, ui->newpoint.y, ui->newpoint.d);
+        ui->just_dragged = TRUE;
+        return dupstr(buf);
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(const game_state *state, const char *move)
+{
+    int n = state->params.n;
+    int p, k;
+    long x, y, d;
+    game_state *ret = dup_game(state);
+
+    ret->just_solved = FALSE;
+
+    while (*move) {
+        if (*move == 'S') {
+            move++;
+            if (*move == ';') move++;
+            ret->cheated = ret->just_solved = TRUE;
+        }
+        if (*move == 'P' &&
+            sscanf(move+1, "%d:%ld,%ld/%ld%n", &p, &x, &y, &d, &k) == 4 &&
+            p >= 0 && p < n && d > 0) {
+            ret->pts[p].x = x;
+            ret->pts[p].y = y;
+            ret->pts[p].d = d;
+
+            move += k+1;
+            if (*move == ';') move++;
+        } else {
+            free_game(ret);
+            return NULL;
+        }
+    }
+
+    mark_crossings(ret);
+
+    return ret;
+}
+
+/* ----------------------------------------------------------------------
+ * Drawing routines.
+ */
+
+static void game_compute_size(const game_params *params, int tilesize,
+                              int *x, int *y)
+{
+    *x = *y = COORDLIMIT(params->n) * tilesize;
+}
+
+static void game_set_size(drawing *dr, game_drawstate *ds,
+                          const game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
+{
+    float *ret = snewn(3 * NCOLOURS, float);
+
+    /*
+     * COL_BACKGROUND is what we use as the normal background colour.
+     * Unusually, though, it isn't colour #0: COL_SYSBACKGROUND, a bit
+     * darker, takes that place. This means that if the user resizes
+     * an Untangle window so as to change its aspect ratio, the
+     * still-square playable area will be distinguished from the dead
+     * space around it.
+     */
+    game_mkhighlight(fe, ret, COL_BACKGROUND, -1, COL_SYSBACKGROUND);
+
+    ret[COL_LINE * 3 + 0] = 0.0F;
+    ret[COL_LINE * 3 + 1] = 0.0F;
+    ret[COL_LINE * 3 + 2] = 0.0F;
+
+#ifdef SHOW_CROSSINGS
+    ret[COL_CROSSEDLINE * 3 + 0] = 1.0F;
+    ret[COL_CROSSEDLINE * 3 + 1] = 0.0F;
+    ret[COL_CROSSEDLINE * 3 + 2] = 0.0F;
+#endif
+
+    ret[COL_OUTLINE * 3 + 0] = 0.0F;
+    ret[COL_OUTLINE * 3 + 1] = 0.0F;
+    ret[COL_OUTLINE * 3 + 2] = 0.0F;
+
+    ret[COL_POINT * 3 + 0] = 0.0F;
+    ret[COL_POINT * 3 + 1] = 0.0F;
+    ret[COL_POINT * 3 + 2] = 1.0F;
+
+    ret[COL_DRAGPOINT * 3 + 0] = 1.0F;
+    ret[COL_DRAGPOINT * 3 + 1] = 1.0F;
+    ret[COL_DRAGPOINT * 3 + 2] = 1.0F;
+
+    ret[COL_NEIGHBOUR * 3 + 0] = 1.0F;
+    ret[COL_NEIGHBOUR * 3 + 1] = 0.0F;
+    ret[COL_NEIGHBOUR * 3 + 2] = 0.0F;
+
+    ret[COL_FLASH1 * 3 + 0] = 0.5F;
+    ret[COL_FLASH1 * 3 + 1] = 0.5F;
+    ret[COL_FLASH1 * 3 + 2] = 0.5F;
+
+    ret[COL_FLASH2 * 3 + 0] = 1.0F;
+    ret[COL_FLASH2 * 3 + 1] = 1.0F;
+    ret[COL_FLASH2 * 3 + 2] = 1.0F;
+
+    *ncolours = NCOLOURS;
+    return ret;
+}
+
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
+{
+    struct game_drawstate *ds = snew(struct game_drawstate);
+    int i;
+
+    ds->tilesize = 0;
+    ds->x = snewn(state->params.n, long);
+    ds->y = snewn(state->params.n, long);
+    for (i = 0; i < state->params.n; i++)
+        ds->x[i] = ds->y[i] = -1;
+    ds->bg = -1;
+    ds->dragpoint = -1;
+
+    return ds;
+}
+
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
+{
+    sfree(ds->y);
+    sfree(ds->x);
+    sfree(ds);
+}
+
+static point mix(point a, point b, float distance)
+{
+    point ret;
+
+    ret.d = a.d * b.d;
+    ret.x = (long)(a.x * b.d + distance * (b.x * a.d - a.x * b.d));
+    ret.y = (long)(a.y * b.d + distance * (b.y * a.d - a.y * b.d));
+
+    return ret;
+}
+
+static void game_redraw(drawing *dr, game_drawstate *ds,
+                        const game_state *oldstate, const game_state *state,
+                        int dir, const game_ui *ui,
+                        float animtime, float flashtime)
+{
+    int w, h;
+    edge *e;
+    int i, j;
+    int bg, points_moved;
+
+    /*
+     * There's no terribly sensible way to do partial redraws of
+     * this game, so I'm going to have to resort to redrawing the
+     * whole thing every time.
+     */
+
+    if (flashtime == 0)
+        bg = COL_BACKGROUND;
+    else if ((int)(flashtime * 4 / FLASH_TIME) % 2 == 0)
+        bg = COL_FLASH1;
+    else
+        bg = COL_FLASH2;
+
+    /*
+     * To prevent excessive spinning on redraw during a completion
+     * flash, we first check to see if _either_ the flash
+     * background colour has changed _or_ at least one point has
+     * moved _or_ a drag has begun or ended, and abandon the redraw
+     * if neither is the case.
+     * 
+     * Also in this loop we work out the coordinates of all the
+     * points for this redraw.
+     */
+    points_moved = FALSE;
+    for (i = 0; i < state->params.n; i++) {
+        point p = state->pts[i];
+        long x, y;
+
+        if (ui->dragpoint == i)
+            p = ui->newpoint;
+
+        if (oldstate)
+            p = mix(oldstate->pts[i], p, animtime / ui->anim_length);
+
+        x = p.x * ds->tilesize / p.d;
+        y = p.y * ds->tilesize / p.d;
+
+        if (ds->x[i] != x || ds->y[i] != y)
+            points_moved = TRUE;
+
+        ds->x[i] = x;
+        ds->y[i] = y;
+    }
+
+    if (ds->bg == bg && ds->dragpoint == ui->dragpoint && !points_moved)
+        return;                        /* nothing to do */
+
+    ds->dragpoint = ui->dragpoint;
+    ds->bg = bg;
+
+    game_compute_size(&state->params, ds->tilesize, &w, &h);
+    draw_rect(dr, 0, 0, w, h, bg);
+
+    /*
+     * Draw the edges.
+     */
+
+    for (i = 0; (e = index234(state->graph->edges, i)) != NULL; i++) {
+        draw_line(dr, ds->x[e->a], ds->y[e->a], ds->x[e->b], ds->y[e->b],
+#ifdef SHOW_CROSSINGS
+                  (oldstate?oldstate:state)->crosses[i] ?
+                  COL_CROSSEDLINE :
+#endif
+                  COL_LINE);
+    }
+
+    /*
+     * Draw the points.
+     * 
+     * When dragging, we should not only vary the colours, but
+     * leave the point being dragged until last.
+     */
+    for (j = 0; j < 3; j++) {
+        int thisc = (j == 0 ? COL_POINT :
+                     j == 1 ? COL_NEIGHBOUR : COL_DRAGPOINT);
+        for (i = 0; i < state->params.n; i++) {
+            int c;
+
+            if (ui->dragpoint == i) {
+                c = COL_DRAGPOINT;
+            } else if (ui->dragpoint >= 0 &&
+                       isedge(state->graph->edges, ui->dragpoint, i)) {
+                c = COL_NEIGHBOUR;
+            } else {
+                c = COL_POINT;
+            }
+
+            if (c == thisc) {
+#ifdef VERTEX_NUMBERS
+                draw_circle(dr, ds->x[i], ds->y[i], DRAG_THRESHOLD, bg, bg);
+                {
+                    char buf[80];
+                    sprintf(buf, "%d", i);
+                    draw_text(dr, ds->x[i], ds->y[i], FONT_VARIABLE,
+                              DRAG_THRESHOLD*3/2,
+                              ALIGN_VCENTRE|ALIGN_HCENTRE, c, buf);
+                }
+#else
+                draw_circle(dr, ds->x[i], ds->y[i], CIRCLE_RADIUS,
+                            c, COL_OUTLINE);
+#endif
+            }
+        }
+    }
+
+    draw_update(dr, 0, 0, w, h);
+}
+
+static float game_anim_length(const game_state *oldstate,
+                              const game_state *newstate, int dir, game_ui *ui)
+{
+    if (ui->just_moved)
+        return 0.0F;
+    if ((dir < 0 ? oldstate : newstate)->just_solved)
+        ui->anim_length = SOLVEANIM_TIME;
+    else
+        ui->anim_length = ANIM_TIME;
+    return ui->anim_length;
+}
+
+static float game_flash_length(const game_state *oldstate,
+                               const game_state *newstate, int dir, game_ui *ui)
+{
+    if (!oldstate->completed && newstate->completed &&
+        !oldstate->cheated && !newstate->cheated)
+        return FLASH_TIME;
+    return 0.0F;
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
+{
+    return TRUE;
+}
+
+static void game_print_size(const game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame untangle
+#endif
+
+const struct game thegame = {
+    "Untangle", "games.untangle", "untangle",
+    default_params,
+    game_fetch_preset,
+    decode_params,
+    encode_params,
+    free_params,
+    dup_params,
+    TRUE, game_configure, custom_params,
+    validate_params,
+    new_game_desc,
+    validate_desc,
+    new_game,
+    dup_game,
+    free_game,
+    TRUE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
+    new_ui,
+    free_ui,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILESIZE, game_compute_size, game_set_size,
+    game_colours,
+    game_new_drawstate,
+    game_free_drawstate,
+    game_redraw,
+    game_anim_length,
+    game_flash_length,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    FALSE,                             /* wants_statusbar */
+    FALSE, game_timing_state,
+    SOLVE_ANIMATES,                    /* flags */
+};
diff --git a/apps/plugins/puzzles/version.c b/apps/plugins/puzzles/version.c
new file mode 100644
index 0000000000..1cef29feb7
--- /dev/null
+++ b/apps/plugins/puzzles/version.c
@@ -0,0 +1,7 @@
+/*
+ * Puzzles version numbering.
+ */
+
+#include "version.h"
+
+char ver[] = VER;
diff --git a/apps/plugins/puzzles/version.h b/apps/plugins/puzzles/version.h
new file mode 100644
index 0000000000..997e00592b
--- /dev/null
+++ b/apps/plugins/puzzles/version.h
@@ -0,0 +1,11 @@
+/*
+ * This header file provides the version #define for a particular
+ * build of Puzzles.
+ *
+ * When my automated build system does a full build, Buildscr
+ * completely overwrites this file with information appropriate to
+ * that build. The information _here_ is default stuff used for local
+ * development runs of 'make'.
+ */
+
+#define VER "Unidentified build"
diff --git a/apps/plugins/puzzles/wceinf.pl b/apps/plugins/puzzles/wceinf.pl
new file mode 100644
index 0000000000..4756f3c2b8
--- /dev/null
+++ b/apps/plugins/puzzles/wceinf.pl
@@ -0,0 +1,65 @@
+#!/usr/bin/perl
+
+# Perl script to generate a .INF file for building a Pocket PC .CAB
+# archive of Puzzles. This has to be scripted so that it can read
+# gamedesc.txt and automatically adjust to the current available
+# set of puzzles.
+
+# Usage:
+#
+#   $ ./wceinf.pl gamedesc.txt > puzzles.inf
+
+$desc = shift @ARGV;
+open DESC, "<", $desc;
+while (<DESC>) {
+    chomp;
+    @_ = split /:/;
+    push @exes, $_[1];
+    $names{$_[1]} = $_[2];
+}
+close DESC;
+
+print '[Version]'."\n";
+print 'Signature   = "$Windows NT$"    ; required as-is'."\n";
+print 'Provider    = "Simon Tatham"    ; full app name will be "<Provider> <AppName>"'."\n";
+print 'CESignature = "$Windows CE$"    ; required as-is'."\n";
+print ''."\n";
+print '[CEStrings]'."\n";
+print 'AppName     = "Puzzle Collection"    ; full app name will be "<Provider> <AppName>"'."\n";
+print 'InstallDir  = %CE8%\%AppName%        ; "\Program Files\Games\Puzzle Collection" (default install directory)'."\n";
+print ''."\n";
+print '[CEDevice.x86]'."\n";
+print 'ProcessorType = 686'."\n";
+print ''."\n";
+print '[CEDevice.ARM]'."\n";
+print 'ProcessorType = 2577'."\n";
+print ''."\n";
+print '[SourceDisksNames.x86]             ; CPU-dependent files'."\n";
+print '2 = ,"x86 Files",,.'."\n";
+print ''."\n";
+print '[SourceDisksNames.ARMV4]           ; CPU-dependent files'."\n";
+print '2 = ,"ARM Files",,.'."\n";
+print ''."\n";
+print '[SourceDisksFiles]'."\n";
+for $exe (@exes) {
+    print $exe.' = 2'."\n";
+}
+print ''."\n";
+print '[DefaultInstall]'."\n";
+print 'CopyFiles   = PuzzleFiles'."\n";
+print 'CEShortcuts = Links'."\n";
+print ''."\n";
+print '[DestinationDirs]'."\n";
+print 'PuzzleFiles = 0, %InstallDir%'."\n";
+print 'Links       = 0, %CE14%\Puzzles'."\n";
+print ''."\n";
+print ';File copy list.'."\n";
+print '[PuzzleFiles]'."\n";
+for $exe (@exes) {
+    print $exe."\n";
+}
+print ''."\n";
+print '[Links]'."\n";
+for $exe (@exes) {
+    print '"'.$names{$exe}.'",0,'.$exe."\n";
+}
diff --git a/apps/plugins/puzzles/webpage.pl b/apps/plugins/puzzles/webpage.pl
new file mode 100755
index 0000000000..3a0779ef0a
--- /dev/null
+++ b/apps/plugins/puzzles/webpage.pl
@@ -0,0 +1,69 @@
+#!/usr/bin/perl
+
+# Construct the two pieces of my main puzzle collection web page that
+# need to vary with the set of puzzles: the big list of <span>s with
+# puzzle pictures and links etc, and the list of Windows executable
+# files down in the downloads section.
+
+use strict;
+use warnings;
+use HTML::Entities;
+
+open my $desc, "<", "gamedesc.txt"
+    or die "gamedesc.txt: open: $!\n";
+
+open my $spans, ">", "wwwspans.html"
+    or die "wwwspans.html: open: $!\n";
+
+open my $links, ">", "wwwlinks.html"
+    or die "wwwspans.html: open: $!\n";
+
+my $n = 0;
+while (<$desc>) {
+    chomp;
+    my ($id, $win, $displayname, $description, $summary) = split /:/, $_;
+
+    printf $spans
+        '<span class="puzzle"><table>'.
+        '<tr><th align="center">%s</th></tr>'.
+        '<tr><td align="center">'.
+        '<img style="margin: 0.5em" alt="" title="%s" width=150 height=150 border=0 src="%s-web.png" />'.
+        '</td></tr>'.
+        '<tr><td align="center" style="font-size: 70%%"><code>[</code>'.
+        ' <a href="java/%s.html">java</a> '.
+        '|'.
+        ' <a href="js/%s.html">js</a> '.
+        '|'.
+        ' <a href="doc/%s.html#%s">manual</a> '.
+        '<code>]</code><br><code>[</code>'.
+        ' <a href="%s"><code>%s</code></a> '.
+        '<code>]</code></td></tr>'.
+        '<tr><td align="center">%s</td></tr></table></span>'.
+        "\n",
+        encode_entities($displayname),
+        encode_entities($description),
+        encode_entities($id),
+        encode_entities($id),
+        encode_entities($id),
+        encode_entities($id),
+        encode_entities($id),
+        encode_entities($win),
+        encode_entities($win),
+        encode_entities($summary);
+
+    if ($n > 0) {
+        if ($n % 5 == 0) {
+            print $links "<br />";
+        } else {
+            print $links " | ";
+        }
+    }
+    printf $links '<a href="%s">%s</a>',
+    encode_entities($win), encode_entities($win);
+
+    $n++;
+}
+
+close $desc;
+close $spans;
+close $links;
diff --git a/apps/plugins/puzzles/website.url b/apps/plugins/puzzles/website.url
new file mode 100644
index 0000000000..2ab37f6faf
--- /dev/null
+++ b/apps/plugins/puzzles/website.url
@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=http://www.chiark.greenend.org.uk/~sgtatham/puzzles/
diff --git a/apps/plugins/puzzles/windows.c b/apps/plugins/puzzles/windows.c
new file mode 100644
index 0000000000..492e37ceac
--- /dev/null
+++ b/apps/plugins/puzzles/windows.c
@@ -0,0 +1,3760 @@
+/*
+ * windows.c: Windows front end for my puzzle collection.
+ */
+
+#include <windows.h>
+#include <commctrl.h>
+#ifndef NO_HTMLHELP
+#include <htmlhelp.h>
+#endif /* NO_HTMLHELP */
+
+#ifdef _WIN32_WCE
+#include <commdlg.h>
+#include <aygshell.h>
+#endif
+
+#include <stdio.h>
+#include "rbassert.h"
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <time.h>
+
+#include "puzzles.h"
+
+#ifdef _WIN32_WCE
+#include "resource.h"
+#endif
+
+#define IDM_NEW       0x0010
+#define IDM_RESTART   0x0020
+#define IDM_UNDO      0x0030
+#define IDM_REDO      0x0040
+#define IDM_COPY      0x0050
+#define IDM_SOLVE     0x0060
+#define IDM_QUIT      0x0070
+#define IDM_CONFIG    0x0080
+#define IDM_DESC      0x0090
+#define IDM_SEED      0x00A0
+#define IDM_HELPC     0x00B0
+#define IDM_GAMEHELP  0x00C0
+#define IDM_ABOUT     0x00D0
+#define IDM_SAVE      0x00E0
+#define IDM_LOAD      0x00F0
+#define IDM_PRINT     0x0100
+#define IDM_PRESETS   0x0110
+#define IDM_GAMES     0x0300
+
+#define IDM_KEYEMUL   0x0400
+
+#define HELP_FILE_NAME  "puzzles.hlp"
+#define HELP_CNT_NAME   "puzzles.cnt"
+#ifndef NO_HTMLHELP
+#define CHM_FILE_NAME   "puzzles.chm"
+#endif /* NO_HTMLHELP */
+
+#ifndef NO_HTMLHELP
+typedef HWND (CALLBACK *htmlhelp_t)(HWND, LPCSTR, UINT, DWORD);
+static htmlhelp_t htmlhelp;
+static HINSTANCE hh_dll;
+#endif /* NO_HTMLHELP */
+enum { NONE, HLP, CHM } help_type;
+char *help_path;
+int help_has_contents;
+
+#ifndef FILENAME_MAX
+#define FILENAME_MAX    (260)
+#endif
+
+#ifndef HGDI_ERROR
+#define HGDI_ERROR ((HANDLE)GDI_ERROR)
+#endif
+
+#ifdef COMBINED
+#define CLASSNAME "Puzzles"
+#else
+#define CLASSNAME thegame.name
+#endif
+
+#ifdef _WIN32_WCE
+
+/*
+ * Wrapper implementations of functions not supplied by the
+ * PocketPC API.
+ */
+
+#define SHGetSubMenu(hWndMB,ID_MENU) (HMENU)SendMessage((hWndMB), SHCMBM_GETSUBMENU, (WPARAM)0, (LPARAM)ID_MENU)
+
+#undef MessageBox
+
+int MessageBox(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
+{
+    TCHAR wText[2048];
+    TCHAR wCaption[2048];
+
+    MultiByteToWideChar (CP_ACP, 0, lpText,    -1, wText,    2048);
+    MultiByteToWideChar (CP_ACP, 0, lpCaption, -1, wCaption, 2048);
+
+    return MessageBoxW (hWnd, wText, wCaption, uType);
+}
+
+BOOL SetDlgItemTextA(HWND hDlg, int nIDDlgItem, LPCSTR lpString)
+{
+    TCHAR wText[256];
+
+    MultiByteToWideChar (CP_ACP, 0, lpString, -1, wText, 256);
+    return SetDlgItemTextW(hDlg, nIDDlgItem, wText);
+}
+
+LPCSTR getenv(LPCSTR buf)
+{
+    return NULL;
+}
+
+BOOL GetKeyboardState(PBYTE pb)
+{
+  return FALSE;
+}
+
+static TCHAR wClassName[256], wGameName[256];
+
+#endif
+
+#ifdef DEBUGGING
+static FILE *debug_fp = NULL;
+static HANDLE debug_hdl = INVALID_HANDLE_VALUE;
+static int debug_got_console = 0;
+
+void dputs(char *buf)
+{
+    /*DWORD dw;
+
+    if (!debug_got_console) {
+        if (AllocConsole()) {
+            debug_got_console = 1;
+            debug_hdl = GetStdHandle(STD_OUTPUT_HANDLE);
+        }
+    }
+    if (!debug_fp) {
+        debug_fp = fopen("debug.log", "w");
+    }
+
+    if (debug_hdl != INVALID_HANDLE_VALUE) {
+        WriteFile(debug_hdl, buf, strlen(buf), &dw, NULL);
+    }
+    if (debug_fp) {
+      fputs(buf, debug_fp);
+      fflush(debug_fp);
+    }*/
+    OutputDebugString(buf);
+}
+
+void debug_printf(char *fmt, ...)
+{
+    char buf[4096];
+    va_list ap;
+    static int debugging = -1;
+
+    if (debugging == -1)
+        debugging = getenv("DEBUG_PUZZLES") ? 1 : 0;
+
+    if (debugging) {
+        va_start(ap, fmt);
+        _vsnprintf(buf, 4095, fmt, ap);
+        dputs(buf);
+        va_end(ap);
+    }
+}
+#endif
+
+#ifndef _WIN32_WCE
+#define WINFLAGS (WS_OVERLAPPEDWINDOW &~ \
+                      (WS_MAXIMIZEBOX | WS_OVERLAPPED))
+#else
+#define WINFLAGS (WS_CAPTION | WS_SYSMENU)
+#endif
+
+static void new_game_size(frontend *fe, float scale);
+
+struct font {
+    HFONT font;
+    int type;
+    int size;
+};
+
+struct cfg_aux {
+    int ctlid;
+};
+
+struct blitter {
+    HBITMAP bitmap;
+    frontend *fe;
+    int x, y, w, h;
+};
+
+enum { CFG_PRINT = CFG_FRONTEND_SPECIFIC };
+
+struct frontend {
+    const game *game;
+    midend *me;
+    HWND hwnd, statusbar, cfgbox;
+#ifdef _WIN32_WCE
+    HWND numpad;  /* window handle for the numeric pad */
+#endif
+    HINSTANCE inst;
+    HBITMAP bitmap, prevbm;
+    RECT bitmapPosition;  /* game bitmap position within game window */
+    HDC hdc;
+    COLORREF *colours;
+    HBRUSH *brushes;
+    HPEN *pens;
+    HRGN clip;
+    HMENU gamemenu, typemenu;
+    UINT timer;
+    DWORD timer_last_tickcount;
+    int npresets;
+    game_params **presets;
+    struct font *fonts;
+    int nfonts, fontsize;
+    config_item *cfg;
+    struct cfg_aux *cfgaux;
+    int cfg_which, dlg_done;
+    HFONT cfgfont;
+    HBRUSH oldbr;
+    HPEN oldpen;
+    int help_running;
+    enum { DRAWING, PRINTING, NOTHING } drawstatus;
+    DOCINFO di;
+    int printcount, printw, printh, printsolns, printcurr, printcolour;
+    float printscale;
+    int printoffsetx, printoffsety;
+    float printpixelscale;
+    int fontstart;
+    int linewidth, linedotted;
+    drawing *dr;
+    int xmin, ymin;
+    float puzz_scale;
+};
+
+void frontend_free(frontend *fe)
+{
+    midend_free(fe->me);
+
+    sfree(fe->colours);
+    sfree(fe->brushes);
+    sfree(fe->pens);
+    sfree(fe->presets);
+    sfree(fe->fonts);
+
+    sfree(fe);
+}
+
+static void update_type_menu_tick(frontend *fe);
+static void update_copy_menu_greying(frontend *fe);
+
+void fatal(char *fmt, ...)
+{
+    char buf[2048];
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsprintf(buf, fmt, ap);
+    va_end(ap);
+
+    MessageBox(NULL, buf, "Fatal error", MB_ICONEXCLAMATION | MB_OK);
+
+    exit(1);
+}
+
+char *geterrstr(void)
+{
+    LPVOID lpMsgBuf;
+    DWORD dw = GetLastError();
+    char *ret;
+
+    FormatMessage(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+        FORMAT_MESSAGE_FROM_SYSTEM,
+        NULL,
+        dw,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        (LPTSTR) &lpMsgBuf,
+        0, NULL );
+
+    ret = dupstr(lpMsgBuf);
+
+    LocalFree(lpMsgBuf);
+
+    return ret;
+}
+
+void get_random_seed(void **randseed, int *randseedsize)
+{
+    SYSTEMTIME *st = snew(SYSTEMTIME);
+
+    GetLocalTime(st);
+
+    *randseed = (void *)st;
+    *randseedsize = sizeof(SYSTEMTIME);
+}
+
+static void win_status_bar(void *handle, char *text)
+{
+#ifdef _WIN32_WCE
+    TCHAR wText[255];
+#endif
+    frontend *fe = (frontend *)handle;
+
+#ifdef _WIN32_WCE
+    MultiByteToWideChar (CP_ACP, 0, text, -1, wText, 255);
+    SendMessage(fe->statusbar, SB_SETTEXT,
+                (WPARAM) 255 | SBT_NOBORDERS,
+                (LPARAM) wText);
+#else
+    SetWindowText(fe->statusbar, text);
+#endif
+}
+
+static blitter *win_blitter_new(void *handle, int w, int h)
+{
+    blitter *bl = snew(blitter);
+
+    memset(bl, 0, sizeof(blitter));
+    bl->w = w;
+    bl->h = h;
+    bl->bitmap = 0;
+
+    return bl;
+}
+
+static void win_blitter_free(void *handle, blitter *bl)
+{
+    if (bl->bitmap) DeleteObject(bl->bitmap);
+    sfree(bl);
+}
+
+static void blitter_mkbitmap(frontend *fe, blitter *bl)
+{
+    HDC hdc = GetDC(fe->hwnd);
+    bl->bitmap = CreateCompatibleBitmap(hdc, bl->w, bl->h);
+    ReleaseDC(fe->hwnd, hdc);
+}
+
+/* BitBlt(dstDC, dstX, dstY, dstW, dstH, srcDC, srcX, srcY, dType) */
+
+static void win_blitter_save(void *handle, blitter *bl, int x, int y)
+{
+    frontend *fe = (frontend *)handle;
+    HDC hdc_win, hdc_blit;
+    HBITMAP prev_blit;
+
+    assert(fe->drawstatus == DRAWING);
+
+    if (!bl->bitmap) blitter_mkbitmap(fe, bl);
+
+    bl->x = x; bl->y = y;
+
+    hdc_win = GetDC(fe->hwnd);
+    hdc_blit = CreateCompatibleDC(hdc_win);
+    if (!hdc_blit) fatal("hdc_blit failed: 0x%x", GetLastError());
+
+    prev_blit = SelectObject(hdc_blit, bl->bitmap);
+    if (prev_blit == NULL || prev_blit == HGDI_ERROR)
+        fatal("SelectObject for hdc_main failed: 0x%x", GetLastError());
+
+    if (!BitBlt(hdc_blit, 0, 0, bl->w, bl->h,
+                fe->hdc, x, y, SRCCOPY))
+        fatal("BitBlt failed: 0x%x", GetLastError());
+
+    SelectObject(hdc_blit, prev_blit);
+    DeleteDC(hdc_blit);
+    ReleaseDC(fe->hwnd, hdc_win);
+}
+
+static void win_blitter_load(void *handle, blitter *bl, int x, int y)
+{
+    frontend *fe = (frontend *)handle;
+    HDC hdc_win, hdc_blit;
+    HBITMAP prev_blit;
+
+    assert(fe->drawstatus == DRAWING);
+
+    assert(bl->bitmap); /* we should always have saved before loading */
+
+    if (x == BLITTER_FROMSAVED) x = bl->x;
+    if (y == BLITTER_FROMSAVED) y = bl->y;
+
+    hdc_win = GetDC(fe->hwnd);
+    hdc_blit = CreateCompatibleDC(hdc_win);
+
+    prev_blit = SelectObject(hdc_blit, bl->bitmap);
+
+    BitBlt(fe->hdc, x, y, bl->w, bl->h,
+           hdc_blit, 0, 0, SRCCOPY);
+
+    SelectObject(hdc_blit, prev_blit);
+    DeleteDC(hdc_blit);
+    ReleaseDC(fe->hwnd, hdc_win);
+}
+
+void frontend_default_colour(frontend *fe, float *output)
+{
+    DWORD c = GetSysColor(COLOR_MENU); /* ick */
+
+    output[0] = (float)(GetRValue(c) / 255.0);
+    output[1] = (float)(GetGValue(c) / 255.0);
+    output[2] = (float)(GetBValue(c) / 255.0);
+}
+
+static POINT win_transform_point(frontend *fe, int x, int y)
+{
+    POINT ret;
+
+    assert(fe->drawstatus != NOTHING);
+
+    if (fe->drawstatus == PRINTING) {
+        ret.x = (int)(fe->printoffsetx + fe->printpixelscale * x);
+        ret.y = (int)(fe->printoffsety + fe->printpixelscale * y);
+    } else {
+        ret.x = x;
+        ret.y = y;
+    }
+
+    return ret;
+}
+
+static void win_text_colour(frontend *fe, int colour)
+{
+    assert(fe->drawstatus != NOTHING);
+
+    if (fe->drawstatus == PRINTING) {
+        int hatch;
+        float r, g, b;
+        print_get_colour(fe->dr, colour, fe->printcolour, &hatch, &r, &g, &b);
+
+        /*
+         * Displaying text in hatched colours is not permitted.
+         */
+        assert(hatch < 0);
+
+        SetTextColor(fe->hdc, RGB(r * 255, g * 255, b * 255));
+    } else {
+        SetTextColor(fe->hdc, fe->colours[colour]);
+    }
+}
+
+static void win_set_brush(frontend *fe, int colour)
+{
+    HBRUSH br;
+    assert(fe->drawstatus != NOTHING);
+
+    if (fe->drawstatus == PRINTING) {
+        int hatch;
+        float r, g, b;
+        print_get_colour(fe->dr, colour, fe->printcolour, &hatch, &r, &g, &b);
+
+        if (hatch < 0) {
+            br = CreateSolidBrush(RGB(r * 255, g * 255, b * 255));
+        } else {
+#ifdef _WIN32_WCE
+            /*
+             * This is only ever required during printing, and the
+             * PocketPC port doesn't support printing.
+             */
+            fatal("CreateHatchBrush not supported");
+#else
+            br = CreateHatchBrush(hatch == HATCH_BACKSLASH ? HS_FDIAGONAL :
+                                  hatch == HATCH_SLASH ? HS_BDIAGONAL :
+                                  hatch == HATCH_HORIZ ? HS_HORIZONTAL :
+                                  hatch == HATCH_VERT ? HS_VERTICAL :
+                                  hatch == HATCH_PLUS ? HS_CROSS :
+                                  /* hatch == HATCH_X ? */ HS_DIAGCROSS,
+                                  RGB(0,0,0));
+#endif
+        }
+    } else {
+        br = fe->brushes[colour];
+    }
+    fe->oldbr = SelectObject(fe->hdc, br);
+}
+
+static void win_reset_brush(frontend *fe)
+{
+    HBRUSH br;
+
+    assert(fe->drawstatus != NOTHING);
+
+    br = SelectObject(fe->hdc, fe->oldbr);
+    if (fe->drawstatus == PRINTING)
+        DeleteObject(br);
+}
+
+static void win_set_pen(frontend *fe, int colour, int thin)
+{
+    HPEN pen;
+    assert(fe->drawstatus != NOTHING);
+
+    if (fe->drawstatus == PRINTING) {
+        int hatch;
+        float r, g, b;
+        int width = thin ? 0 : fe->linewidth;
+
+        if (fe->linedotted)
+            width = 0;
+
+        print_get_colour(fe->dr, colour, fe->printcolour, &hatch, &r, &g, &b);
+        /*
+         * Stroking in hatched colours is not permitted.
+         */
+        assert(hatch < 0);
+        pen = CreatePen(fe->linedotted ? PS_DOT : PS_SOLID,
+                        width, RGB(r * 255, g * 255, b * 255));
+    } else {
+        pen = fe->pens[colour];
+    }
+    fe->oldpen = SelectObject(fe->hdc, pen);
+}
+
+static void win_reset_pen(frontend *fe)
+{
+    HPEN pen;
+
+    assert(fe->drawstatus != NOTHING);
+
+    pen = SelectObject(fe->hdc, fe->oldpen);
+    if (fe->drawstatus == PRINTING)
+        DeleteObject(pen);
+}
+
+static void win_clip(void *handle, int x, int y, int w, int h)
+{
+    frontend *fe = (frontend *)handle;
+    POINT p, q;
+
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    p = win_transform_point(fe, x, y);
+    q = win_transform_point(fe, x+w, y+h);
+    IntersectClipRect(fe->hdc, p.x, p.y, q.x, q.y);
+}
+
+static void win_unclip(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    SelectClipRgn(fe->hdc, NULL);
+}
+
+static void win_draw_text(void *handle, int x, int y, int fonttype,
+                          int fontsize, int align, int colour, char *text)
+{
+    frontend *fe = (frontend *)handle;
+    POINT xy;
+    int i;
+    LOGFONT lf;
+
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    if (fe->drawstatus == PRINTING)
+        fontsize = (int)(fontsize * fe->printpixelscale);
+
+    xy = win_transform_point(fe, x, y);
+
+    /*
+     * Find or create the font.
+     */
+    for (i = fe->fontstart; i < fe->nfonts; i++)
+        if (fe->fonts[i].type == fonttype && fe->fonts[i].size == fontsize)
+            break;
+
+    if (i == fe->nfonts) {
+        if (fe->fontsize <= fe->nfonts) {
+            fe->fontsize = fe->nfonts + 10;
+            fe->fonts = sresize(fe->fonts, fe->fontsize, struct font);
+        }
+
+        fe->nfonts++;
+
+        fe->fonts[i].type = fonttype;
+        fe->fonts[i].size = fontsize;
+
+        memset (&lf, 0, sizeof(LOGFONT));
+        lf.lfHeight = -fontsize;
+        lf.lfWeight = (fe->drawstatus == PRINTING ? 0 : FW_BOLD);
+        lf.lfCharSet = DEFAULT_CHARSET;
+        lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
+        lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
+        lf.lfQuality = DEFAULT_QUALITY;
+        lf.lfPitchAndFamily = (fonttype == FONT_FIXED ?
+                               FIXED_PITCH | FF_DONTCARE :
+                               VARIABLE_PITCH | FF_SWISS);
+#ifdef _WIN32_WCE
+        wcscpy(lf.lfFaceName, TEXT("Tahoma"));
+#endif
+
+        fe->fonts[i].font = CreateFontIndirect(&lf);
+    }
+
+    /*
+     * Position and draw the text.
+     */
+    {
+        HFONT oldfont;
+        TEXTMETRIC tm;
+        SIZE size;
+        WCHAR wText[256];
+        MultiByteToWideChar (CP_UTF8, 0, text, -1, wText, 256);
+
+        oldfont = SelectObject(fe->hdc, fe->fonts[i].font);
+        if (GetTextMetrics(fe->hdc, &tm)) {
+            if (align & ALIGN_VCENTRE)
+                xy.y -= (tm.tmAscent+tm.tmDescent)/2;
+            else
+                xy.y -= tm.tmAscent;
+        }
+        if (GetTextExtentPoint32W(fe->hdc, wText, wcslen(wText), &size))
+        {
+            if (align & ALIGN_HCENTRE)
+                xy.x -= size.cx / 2;
+            else if (align & ALIGN_HRIGHT)
+                xy.x -= size.cx;
+        }
+        SetBkMode(fe->hdc, TRANSPARENT);
+        win_text_colour(fe, colour);
+        ExtTextOutW(fe->hdc, xy.x, xy.y, 0, NULL, wText, wcslen(wText), NULL);
+        SelectObject(fe->hdc, oldfont);
+    }
+}
+
+static void win_draw_rect(void *handle, int x, int y, int w, int h, int colour)
+{
+    frontend *fe = (frontend *)handle;
+    POINT p, q;
+
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    if (fe->drawstatus == DRAWING && w == 1 && h == 1) {
+        /*
+         * Rectangle() appears to get uppity if asked to draw a 1x1
+         * rectangle, presumably on the grounds that that's beneath
+         * its dignity and you ought to be using SetPixel instead.
+         * So I will.
+         */
+        SetPixel(fe->hdc, x, y, fe->colours[colour]);
+    } else {
+        win_set_brush(fe, colour);
+        win_set_pen(fe, colour, TRUE);
+        p = win_transform_point(fe, x, y);
+        q = win_transform_point(fe, x+w, y+h);
+        Rectangle(fe->hdc, p.x, p.y, q.x, q.y);
+        win_reset_brush(fe);
+        win_reset_pen(fe);
+    }
+}
+
+static void win_draw_line(void *handle, int x1, int y1, int x2, int y2, int colour)
+{
+    frontend *fe = (frontend *)handle;
+    POINT pp[2];
+
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    win_set_pen(fe, colour, FALSE);
+    pp[0] = win_transform_point(fe, x1, y1);
+    pp[1] = win_transform_point(fe, x2, y2);
+    Polyline(fe->hdc, pp, 2);
+    if (fe->drawstatus == DRAWING)
+        SetPixel(fe->hdc, pp[1].x, pp[1].y, fe->colours[colour]);
+    win_reset_pen(fe);
+}
+
+static void win_draw_circle(void *handle, int cx, int cy, int radius,
+                            int fillcolour, int outlinecolour)
+{
+    frontend *fe = (frontend *)handle;
+    POINT p, q;
+
+    assert(outlinecolour >= 0);
+
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    if (fillcolour >= 0)
+        win_set_brush(fe, fillcolour);
+    else
+        fe->oldbr = SelectObject(fe->hdc, GetStockObject(NULL_BRUSH));
+
+    win_set_pen(fe, outlinecolour, FALSE);
+    p = win_transform_point(fe, cx - radius, cy - radius);
+    q = win_transform_point(fe, cx + radius, cy + radius);
+    Ellipse(fe->hdc, p.x, p.y, q.x+1, q.y+1);
+    win_reset_brush(fe);
+    win_reset_pen(fe);
+}
+
+static void win_draw_polygon(void *handle, int *coords, int npoints,
+                             int fillcolour, int outlinecolour)
+{
+    frontend *fe = (frontend *)handle;
+    POINT *pts;
+    int i;
+
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    pts = snewn(npoints+1, POINT);
+
+    for (i = 0; i <= npoints; i++) {
+        int j = (i < npoints ? i : 0);
+        pts[i] = win_transform_point(fe, coords[j*2], coords[j*2+1]);
+    }
+
+    assert(outlinecolour >= 0);
+
+    if (fillcolour >= 0) {
+        win_set_brush(fe, fillcolour);
+        win_set_pen(fe, outlinecolour, FALSE);
+        Polygon(fe->hdc, pts, npoints);
+        win_reset_brush(fe);
+        win_reset_pen(fe);
+    } else {
+        win_set_pen(fe, outlinecolour, FALSE);
+        Polyline(fe->hdc, pts, npoints+1);
+        win_reset_pen(fe);
+    }
+
+    sfree(pts);
+}
+
+static void win_start_draw(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+    HDC hdc_win;
+
+    assert(fe->drawstatus == NOTHING);
+
+    hdc_win = GetDC(fe->hwnd);
+    fe->hdc = CreateCompatibleDC(hdc_win);
+    fe->prevbm = SelectObject(fe->hdc, fe->bitmap);
+    ReleaseDC(fe->hwnd, hdc_win);
+    fe->clip = NULL;
+#ifndef _WIN32_WCE
+    SetMapMode(fe->hdc, MM_TEXT);
+#endif
+    fe->drawstatus = DRAWING;
+}
+
+static void win_draw_update(void *handle, int x, int y, int w, int h)
+{
+    frontend *fe = (frontend *)handle;
+    RECT r;
+
+    if (fe->drawstatus != DRAWING)
+        return;
+
+    r.left = x;
+    r.top = y;
+    r.right = x + w;
+    r.bottom = y + h;
+
+    OffsetRect(&r, fe->bitmapPosition.left, fe->bitmapPosition.top);
+    InvalidateRect(fe->hwnd, &r, FALSE);
+}
+
+static void win_end_draw(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+    assert(fe->drawstatus == DRAWING);
+    SelectObject(fe->hdc, fe->prevbm);
+    DeleteDC(fe->hdc);
+    if (fe->clip) {
+        DeleteObject(fe->clip);
+        fe->clip = NULL;
+    }
+    fe->drawstatus = NOTHING;
+}
+
+static void win_line_width(void *handle, float width)
+{
+    frontend *fe = (frontend *)handle;
+
+    assert(fe->drawstatus != DRAWING);
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    fe->linewidth = (int)(width * fe->printpixelscale);
+}
+
+static void win_line_dotted(void *handle, int dotted)
+{
+    frontend *fe = (frontend *)handle;
+
+    assert(fe->drawstatus != DRAWING);
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    fe->linedotted = dotted;
+}
+
+static void win_begin_doc(void *handle, int pages)
+{
+    frontend *fe = (frontend *)handle;
+
+    assert(fe->drawstatus != DRAWING);
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    if (StartDoc(fe->hdc, &fe->di) <= 0) {
+        char *e = geterrstr();
+        MessageBox(fe->hwnd, e, "Error starting to print",
+                   MB_ICONERROR | MB_OK);
+        sfree(e);
+        fe->drawstatus = NOTHING;
+    }
+
+    /*
+     * Push a marker on the font stack so that we won't use the
+     * same fonts for printing and drawing. (This is because
+     * drawing seems to look generally better in bold, but printing
+     * is better not in bold.)
+     */
+    fe->fontstart = fe->nfonts;
+}
+
+static void win_begin_page(void *handle, int number)
+{
+    frontend *fe = (frontend *)handle;
+
+    assert(fe->drawstatus != DRAWING);
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    if (StartPage(fe->hdc) <= 0) {
+        char *e = geterrstr();
+        MessageBox(fe->hwnd, e, "Error starting a page",
+                   MB_ICONERROR | MB_OK);
+        sfree(e);
+        fe->drawstatus = NOTHING;
+    }
+}
+
+static void win_begin_puzzle(void *handle, float xm, float xc,
+                             float ym, float yc, int pw, int ph, float wmm)
+{
+    frontend *fe = (frontend *)handle;
+    int ppw, pph, pox, poy;
+    float mmpw, mmph, mmox, mmoy;
+    float scale;
+
+    assert(fe->drawstatus != DRAWING);
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    ppw = GetDeviceCaps(fe->hdc, HORZRES);
+    pph = GetDeviceCaps(fe->hdc, VERTRES);
+    mmpw = (float)GetDeviceCaps(fe->hdc, HORZSIZE);
+    mmph = (float)GetDeviceCaps(fe->hdc, VERTSIZE);
+
+    /*
+     * Compute the puzzle's position on the logical page.
+     */
+    mmox = xm * mmpw + xc;
+    mmoy = ym * mmph + yc;
+
+    /*
+     * Work out what that comes to in pixels.
+     */
+    pox = (int)(mmox * (float)ppw / mmpw);
+    poy = (int)(mmoy * (float)pph / mmph);
+
+    /*
+     * And determine the scale.
+     * 
+     * I need a scale such that the maximum puzzle-coordinate
+     * extent of the rectangle (pw * scale) is equal to the pixel
+     * equivalent of the puzzle's millimetre width (wmm * ppw /
+     * mmpw).
+     */
+    scale = (wmm * ppw) / (mmpw * pw);
+
+    /*
+     * Now store pox, poy and scale for use in the main drawing
+     * functions.
+     */
+    fe->printoffsetx = pox;
+    fe->printoffsety = poy;
+    fe->printpixelscale = scale;
+
+    fe->linewidth = 1;
+    fe->linedotted = FALSE;
+}
+
+static void win_end_puzzle(void *handle)
+{
+    /* Nothing needs to be done here. */
+}
+
+static void win_end_page(void *handle, int number)
+{
+    frontend *fe = (frontend *)handle;
+
+    assert(fe->drawstatus != DRAWING);
+
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    if (EndPage(fe->hdc) <= 0) {
+        char *e = geterrstr();
+        MessageBox(fe->hwnd, e, "Error finishing a page",
+                   MB_ICONERROR | MB_OK);
+        sfree(e);
+        fe->drawstatus = NOTHING;
+    }
+}
+
+static void win_end_doc(void *handle)
+{
+    frontend *fe = (frontend *)handle;
+
+    assert(fe->drawstatus != DRAWING);
+
+    /*
+     * Free all the fonts created since we began printing.
+     */
+    while (fe->nfonts > fe->fontstart) {
+        fe->nfonts--;
+        DeleteObject(fe->fonts[fe->nfonts].font);
+    }
+    fe->fontstart = 0;
+
+    /*
+     * The MSDN web site sample code doesn't bother to call EndDoc
+     * if an error occurs half way through printing. I expect doing
+     * so would cause the erroneous document to actually be
+     * printed, or something equally undesirable.
+     */
+    if (fe->drawstatus == NOTHING)
+        return;
+
+    if (EndDoc(fe->hdc) <= 0) {
+        char *e = geterrstr();
+        MessageBox(fe->hwnd, e, "Error finishing printing",
+                   MB_ICONERROR | MB_OK);
+        sfree(e);
+        fe->drawstatus = NOTHING;
+    }
+}
+
+char *win_text_fallback(void *handle, const char *const *strings, int nstrings)
+{
+    /*
+     * We assume Windows can cope with any UTF-8 likely to be
+     * emitted by a puzzle.
+     */
+    return dupstr(strings[0]);
+}
+
+const struct drawing_api win_drawing = {
+    win_draw_text,
+    win_draw_rect,
+    win_draw_line,
+    win_draw_polygon,
+    win_draw_circle,
+    win_draw_update,
+    win_clip,
+    win_unclip,
+    win_start_draw,
+    win_end_draw,
+    win_status_bar,
+    win_blitter_new,
+    win_blitter_free,
+    win_blitter_save,
+    win_blitter_load,
+    win_begin_doc,
+    win_begin_page,
+    win_begin_puzzle,
+    win_end_puzzle,
+    win_end_page,
+    win_end_doc,
+    win_line_width,
+    win_line_dotted,
+    win_text_fallback,
+};
+
+void print(frontend *fe)
+{
+#ifndef _WIN32_WCE
+    PRINTDLG pd;
+    char doctitle[256];
+    document *doc;
+    midend *nme = NULL;  /* non-interactive midend for bulk puzzle generation */
+    int i;
+    char *err = NULL;
+
+    /*
+     * Create our document structure and fill it up with puzzles.
+     */
+    doc = document_new(fe->printw, fe->printh, fe->printscale / 100.0F);
+    for (i = 0; i < fe->printcount; i++) {
+        if (i == 0 && fe->printcurr) {
+            err = midend_print_puzzle(fe->me, doc, fe->printsolns);
+        } else {
+            if (!nme) {
+                game_params *params;
+
+                nme = midend_new(NULL, fe->game, NULL, NULL);
+
+                /*
+                 * Set the non-interactive mid-end to have the same
+                 * parameters as the standard one.
+                 */
+                params = midend_get_params(fe->me);
+                midend_set_params(nme, params);
+                fe->game->free_params(params);
+            }
+
+            midend_new_game(nme);
+            err = midend_print_puzzle(nme, doc, fe->printsolns);
+        }
+        if (err)
+            break;
+    }
+    if (nme)
+        midend_free(nme);
+
+    if (err) {
+        MessageBox(fe->hwnd, err, "Error preparing puzzles for printing",
+                   MB_ICONERROR | MB_OK);
+        document_free(doc);
+        return;
+    }
+
+    memset(&pd, 0, sizeof(pd));
+    pd.lStructSize = sizeof(pd);
+    pd.hwndOwner = fe->hwnd;
+    pd.hDevMode = NULL;
+    pd.hDevNames = NULL;
+    pd.Flags = PD_USEDEVMODECOPIESANDCOLLATE | PD_RETURNDC |
+        PD_NOPAGENUMS | PD_NOSELECTION;
+    pd.nCopies = 1;
+    pd.nFromPage = pd.nToPage = 0xFFFF;
+    pd.nMinPage = pd.nMaxPage = 1;
+
+    if (!PrintDlg(&pd)) {
+        document_free(doc);
+        return;
+    }
+
+    /*
+     * Now pd.hDC is a device context for the printer.
+     */
+
+    /*
+     * FIXME: IWBNI we put up an Abort box here.
+     */
+
+    memset(&fe->di, 0, sizeof(fe->di));
+    fe->di.cbSize = sizeof(fe->di);
+    sprintf(doctitle, "Printed puzzles from %s (from Simon Tatham's"
+            " Portable Puzzle Collection)", fe->game->name);
+    fe->di.lpszDocName = doctitle;
+    fe->di.lpszOutput = NULL;
+    fe->di.lpszDatatype = NULL;
+    fe->di.fwType = 0;
+
+    fe->drawstatus = PRINTING;
+    fe->hdc = pd.hDC;
+
+    fe->dr = drawing_new(&win_drawing, NULL, fe);
+    document_print(doc, fe->dr);
+    drawing_free(fe->dr);
+    fe->dr = NULL;
+
+    fe->drawstatus = NOTHING;
+
+    DeleteDC(pd.hDC);
+    document_free(doc);
+#endif
+}
+
+void deactivate_timer(frontend *fe)
+{
+    if (!fe)
+        return;                        /* for non-interactive midend */
+    if (fe->hwnd) KillTimer(fe->hwnd, fe->timer);
+    fe->timer = 0;
+}
+
+void activate_timer(frontend *fe)
+{
+    if (!fe)
+        return;                        /* for non-interactive midend */
+    if (!fe->timer) {
+        fe->timer = SetTimer(fe->hwnd, 1, 20, NULL);
+        fe->timer_last_tickcount = GetTickCount();
+    }
+}
+
+void write_clip(HWND hwnd, char *data)
+{
+    HGLOBAL clipdata;
+    int len, i, j;
+    char *data2;
+    void *lock;
+
+    /*
+     * Windows expects CRLF in the clipboard, so we must convert
+     * any \n that has come out of the puzzle backend.
+     */
+    len = 0;
+    for (i = 0; data[i]; i++) {
+        if (data[i] == '\n')
+            len++;
+        len++;
+    }
+    data2 = snewn(len+1, char);
+    j = 0;
+    for (i = 0; data[i]; i++) {
+        if (data[i] == '\n')
+            data2[j++] = '\r';
+        data2[j++] = data[i];
+    }
+    assert(j == len);
+    data2[j] = '\0';
+
+    clipdata = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
+    if (!clipdata) {
+        sfree(data2);
+        return;
+    }
+    lock = GlobalLock(clipdata);
+    if (!lock) {
+        GlobalFree(clipdata);
+        sfree(data2);
+        return;
+    }
+    memcpy(lock, data2, len);
+    ((unsigned char *) lock)[len] = 0;
+    GlobalUnlock(clipdata);
+
+    if (OpenClipboard(hwnd)) {
+        EmptyClipboard();
+        SetClipboardData(CF_TEXT, clipdata);
+        CloseClipboard();
+    } else
+        GlobalFree(clipdata);
+
+    sfree(data2);
+}
+
+/*
+ * Set up Help and see if we can find a help file.
+ */
+static void init_help(void)
+{
+#ifndef _WIN32_WCE
+    char b[2048], *p, *q, *r;
+    FILE *fp;
+
+    /*
+     * Find the executable file path, so we can look alongside
+     * it for help files. Trim the filename off the end.
+     */
+    GetModuleFileName(NULL, b, sizeof(b) - 1);
+    r = b;
+    p = strrchr(b, '\\');
+    if (p && p >= r) r = p+1;
+    q = strrchr(b, ':');
+    if (q && q >= r) r = q+1;
+
+#ifndef NO_HTMLHELP
+    /*
+     * Try HTML Help first.
+     */
+    strcpy(r, CHM_FILE_NAME);
+    if ( (fp = fopen(b, "r")) != NULL) {
+        fclose(fp);
+
+        /*
+         * We have a .CHM. See if we can use it.
+         */
+        hh_dll = LoadLibrary("hhctrl.ocx");
+        if (hh_dll) {
+            htmlhelp = (htmlhelp_t)GetProcAddress(hh_dll, "HtmlHelpA");
+            if (!htmlhelp)
+                FreeLibrary(hh_dll);
+        }
+        if (htmlhelp) {
+            help_path = dupstr(b);
+            help_type = CHM;
+            return;
+        }
+    }
+#endif /* NO_HTMLHELP */
+
+    /*
+     * Now try old-style .HLP.
+     */
+    strcpy(r, HELP_FILE_NAME);
+    if ( (fp = fopen(b, "r")) != NULL) {
+        fclose(fp);
+
+        help_path = dupstr(b);
+        help_type = HLP;
+
+        /*
+         * See if there's a .CNT file alongside it.
+         */
+        strcpy(r, HELP_CNT_NAME);
+        if ( (fp = fopen(b, "r")) != NULL) {
+            fclose(fp);
+            help_has_contents = TRUE;
+        } else
+            help_has_contents = FALSE;
+
+        return;
+    }
+
+    help_type = NONE;          /* didn't find any */
+#endif
+}
+
+#ifndef _WIN32_WCE
+
+/*
+ * Start Help.
+ */
+static void start_help(frontend *fe, const char *topic)
+{
+    char *str = NULL;
+    int cmd;
+
+    switch (help_type) {
+      case HLP:
+        assert(help_path);
+        if (topic) {
+            str = snewn(10+strlen(topic), char);
+            sprintf(str, "JI(`',`%s')", topic);
+            cmd = HELP_COMMAND;
+        } else if (help_has_contents) {
+            cmd = HELP_FINDER;
+        } else {
+            cmd = HELP_CONTENTS;
+        }
+        WinHelp(fe->hwnd, help_path, cmd, (DWORD)str);
+        fe->help_running = TRUE;
+        break;
+      case CHM:
+#ifndef NO_HTMLHELP
+        assert(help_path);
+        assert(htmlhelp);
+        if (topic) {
+            str = snewn(20 + strlen(topic) + strlen(help_path), char);
+            sprintf(str, "%s::/%s.html>main", help_path, topic);
+        } else {
+            str = dupstr(help_path);
+        }
+        htmlhelp(fe->hwnd, str, HH_DISPLAY_TOPIC, 0);
+        fe->help_running = TRUE;
+        break;
+#endif /* NO_HTMLHELP */
+      case NONE:
+        assert(!"This shouldn't happen");
+        break;
+    }
+
+    sfree(str);
+}
+
+/*
+ * Stop Help on window cleanup.
+ */
+static void stop_help(frontend *fe)
+{
+    if (fe->help_running) {
+        switch (help_type) {
+          case HLP:
+            WinHelp(fe->hwnd, help_path, HELP_QUIT, 0);
+            break;
+          case CHM:
+#ifndef NO_HTMLHELP
+            assert(htmlhelp);
+            htmlhelp(NULL, NULL, HH_CLOSE_ALL, 0);
+            break;
+#endif /* NO_HTMLHELP */
+          case NONE:
+            assert(!"This shouldn't happen");
+            break;
+        }
+        fe->help_running = FALSE;
+    }
+}
+
+#endif
+
+/*
+ * Terminate Help on process exit.
+ */
+static void cleanup_help(void)
+{
+    /* Nothing to do currently.
+     * (If we were running HTML Help single-threaded, this is where we'd
+     * call HH_UNINITIALIZE.) */
+}
+
+static int get_statusbar_height(frontend *fe)
+{
+    int sy;
+    if (fe->statusbar) {
+        RECT sr;
+        GetWindowRect(fe->statusbar, &sr);
+        sy = sr.bottom - sr.top;
+    } else {
+        sy = 0;
+    }
+    return sy;
+}
+
+static void adjust_statusbar(frontend *fe, RECT *r)
+{
+    int sy;
+
+    if (!fe->statusbar) return;
+
+    sy = get_statusbar_height(fe);
+#ifndef _WIN32_WCE
+    SetWindowPos(fe->statusbar, NULL, 0, r->bottom-r->top-sy, r->right-r->left,
+                 sy, SWP_NOZORDER);
+#endif
+}
+
+static void get_menu_size(HWND wh, RECT *r)
+{
+    HMENU bar = GetMenu(wh);
+    RECT rect;
+    int i;
+
+    SetRect(r, 0, 0, 0, 0);
+    for (i = 0; i < GetMenuItemCount(bar); i++) {
+        GetMenuItemRect(wh, bar, i, &rect);
+        UnionRect(r, r, &rect);
+    }
+}
+
+/*
+ * Given a proposed new puzzle size (cx,cy), work out the actual
+ * puzzle size that would be (px,py) and the window size including
+ * furniture (wx,wy).
+ */
+
+static int check_window_resize(frontend *fe, int cx, int cy,
+                               int *px, int *py,
+                               int *wx, int *wy)
+{
+    RECT r;
+    int x, y, sy = get_statusbar_height(fe), changed = 0;
+
+    /* disallow making window thinner than menu bar */
+    x = max(cx, fe->xmin);
+    y = max(cy - sy, fe->ymin);
+
+    /*
+     * See if we actually got the window size we wanted, and adjust
+     * the puzzle size if not.
+     */
+    midend_size(fe->me, &x, &y, TRUE);
+    if (x != cx || y != cy) {
+        /*
+         * Resize the window, now we know what size we _really_
+         * want it to be.
+         */
+        r.left = r.top = 0;
+        r.right = x;
+        r.bottom = y + sy;
+        AdjustWindowRectEx(&r, WINFLAGS, TRUE, 0);
+        *wx = r.right - r.left;
+        *wy = r.bottom - r.top;
+        changed = 1;
+    }
+
+    *px = x;
+    *py = y;
+
+    fe->puzz_scale =
+      (float)midend_tilesize(fe->me) / (float)fe->game->preferred_tilesize;
+
+    return changed;
+}
+
+/*
+ * Given the current window size, make sure it's sane for the
+ * current puzzle and resize if necessary.
+ */
+
+static void check_window_size(frontend *fe, int *px, int *py)
+{
+    RECT r;
+    int wx, wy, cx, cy;
+
+    GetClientRect(fe->hwnd, &r);
+    cx = r.right - r.left;
+    cy = r.bottom - r.top;
+
+    if (check_window_resize(fe, cx, cy, px, py, &wx, &wy)) {
+#ifdef _WIN32_WCE
+        SetWindowPos(fe->hwnd, NULL, 0, 0, wx, wy,
+                     SWP_NOMOVE | SWP_NOZORDER);
+#endif
+        ;
+    }
+
+    GetClientRect(fe->hwnd, &r);
+    adjust_statusbar(fe, &r);
+}
+
+static void get_max_puzzle_size(frontend *fe, int *x, int *y)
+{
+    RECT r, sr;
+
+    if (SystemParametersInfo(SPI_GETWORKAREA, 0, &sr, FALSE)) {
+        *x = sr.right - sr.left;
+        *y = sr.bottom - sr.top;
+        r.left = 100;
+        r.right = 200;
+        r.top = 100;
+        r.bottom = 200;
+        AdjustWindowRectEx(&r, WINFLAGS, TRUE, 0);
+        *x -= r.right - r.left - 100;
+        *y -= r.bottom - r.top - 100;
+    } else {
+        *x = *y = INT_MAX;
+    }
+
+    if (fe->statusbar != NULL) {
+        GetWindowRect(fe->statusbar, &sr);
+        *y -= sr.bottom - sr.top;
+    }
+}
+
+#ifdef _WIN32_WCE
+/* Toolbar buttons on the numeric pad */
+static TBBUTTON tbNumpadButtons[] =
+{
+    {0, IDM_KEYEMUL + '1', TBSTATE_ENABLED, TBSTYLE_BUTTON,  0, -1},
+    {1, IDM_KEYEMUL + '2', TBSTATE_ENABLED, TBSTYLE_BUTTON,  0, -1},
+    {2, IDM_KEYEMUL + '3', TBSTATE_ENABLED, TBSTYLE_BUTTON,  0, -1},
+    {3, IDM_KEYEMUL + '4', TBSTATE_ENABLED, TBSTYLE_BUTTON,  0, -1},
+    {4, IDM_KEYEMUL + '5', TBSTATE_ENABLED, TBSTYLE_BUTTON,  0, -1},
+    {5, IDM_KEYEMUL + '6', TBSTATE_ENABLED, TBSTYLE_BUTTON,  0, -1},
+    {6, IDM_KEYEMUL + '7', TBSTATE_ENABLED, TBSTYLE_BUTTON,  0, -1},
+    {7, IDM_KEYEMUL + '8', TBSTATE_ENABLED, TBSTYLE_BUTTON,  0, -1},
+    {8, IDM_KEYEMUL + '9', TBSTATE_ENABLED, TBSTYLE_BUTTON,  0, -1},
+    {9, IDM_KEYEMUL + ' ', TBSTATE_ENABLED, TBSTYLE_BUTTON,  0, -1}
+};
+#endif
+
+/*
+ * Allocate a new frontend structure and create its main window.
+ */
+static frontend *frontend_new(HINSTANCE inst)
+{
+    frontend *fe;
+    const char *nogame = "Puzzles (no game selected)";
+
+    fe = snew(frontend);
+
+    fe->inst = inst;
+
+    fe->game = NULL;
+    fe->me = NULL;
+
+    fe->timer = 0;
+    fe->hwnd = NULL;
+
+    fe->help_running = FALSE;
+
+    fe->drawstatus = NOTHING;
+    fe->dr = NULL;
+    fe->fontstart = 0;
+
+    fe->fonts = NULL;
+    fe->nfonts = fe->fontsize = 0;
+
+    fe->colours = NULL;
+    fe->brushes = NULL;
+    fe->pens = NULL;
+
+    fe->puzz_scale = 1.0;
+
+    #ifdef _WIN32_WCE
+    MultiByteToWideChar (CP_ACP, 0, nogame, -1, wGameName, 256);
+    fe->hwnd = CreateWindowEx(0, wClassName, wGameName,
+                              WS_VISIBLE,
+                              CW_USEDEFAULT, CW_USEDEFAULT,
+                              CW_USEDEFAULT, CW_USEDEFAULT,
+                              NULL, NULL, inst, NULL);
+
+    {
+        SHMENUBARINFO mbi;
+        RECT rc, rcBar, rcTB, rcClient;
+
+        memset (&mbi, 0, sizeof(SHMENUBARINFO));
+        mbi.cbSize     = sizeof(SHMENUBARINFO);
+        mbi.hwndParent = fe->hwnd;
+        mbi.nToolBarId = IDR_MENUBAR1;
+        mbi.hInstRes   = inst;
+
+        SHCreateMenuBar(&mbi);
+
+        GetWindowRect(fe->hwnd, &rc);
+        GetWindowRect(mbi.hwndMB, &rcBar);
+        rc.bottom -= rcBar.bottom - rcBar.top;
+        MoveWindow(fe->hwnd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, FALSE);
+
+        fe->numpad = NULL;
+    }
+#else
+    fe->hwnd = CreateWindowEx(0, CLASSNAME, nogame,
+                              WS_OVERLAPPEDWINDOW &~
+                              (WS_MAXIMIZEBOX),
+                              CW_USEDEFAULT, CW_USEDEFAULT,
+                              CW_USEDEFAULT, CW_USEDEFAULT,
+                              NULL, NULL, inst, NULL);
+    if (!fe->hwnd) {
+        DWORD lerr = GetLastError();
+        printf("no window: 0x%x\n", lerr);
+    }
+#endif
+
+    fe->gamemenu = NULL;
+    fe->presets = NULL;
+
+    fe->statusbar = NULL;
+    fe->bitmap = NULL;
+
+    SetWindowLong(fe->hwnd, GWL_USERDATA, (LONG)fe);
+
+    return fe;
+}
+
+static void savefile_write(void *wctx, void *buf, int len)
+{
+    FILE *fp = (FILE *)wctx;
+    fwrite(buf, 1, len, fp);
+}
+
+static int savefile_read(void *wctx, void *buf, int len)
+{
+    FILE *fp = (FILE *)wctx;
+    int ret;
+
+    ret = fread(buf, 1, len, fp);
+    return (ret == len);
+}
+
+/*
+ * Create an appropriate midend structure to go in a puzzle window,
+ * given a game type and/or a command-line argument.
+ *
+ * 'arg' can be either a game ID string (descriptive, random, or a
+ * plain set of parameters) or the filename of a save file. The two
+ * boolean flag arguments indicate which possibilities are
+ * permissible.
+ */
+static midend *midend_for_new_game(frontend *fe, const game *cgame,
+                                   char *arg, int maybe_game_id,
+                                   int maybe_save_file, char **error)
+{
+    midend *me = NULL;
+
+    if (!arg) {
+        if (me) midend_free(me);
+        me = midend_new(fe, cgame, &win_drawing, fe);
+        midend_new_game(me);
+    } else {
+        FILE *fp;
+        char *err_param, *err_load;
+
+        /*
+         * See if arg is a valid filename of a save game file.
+         */
+        err_load = NULL;
+        if (maybe_save_file && (fp = fopen(arg, "r")) != NULL) {
+            const game *loadgame;
+
+#ifdef COMBINED
+            /*
+             * Find out what kind of game is stored in the save
+             * file; if we're going to end up loading that, it
+             * will have to override our caller's judgment as to
+             * what game to initialise our midend with.
+             */
+            char *id_name;
+            err_load = identify_game(&id_name, savefile_read, fp);
+            if (!err_load) {
+                int i;
+                for (i = 0; i < gamecount; i++)
+                    if (!strcmp(id_name, gamelist[i]->name))
+                        break;
+                if (i == gamecount) {
+                    err_load = "Save file is for a game not supported by"
+                        " this program";
+                } else {
+                    loadgame = gamelist[i];
+                    rewind(fp); /* go back to the start for actual load */
+                }
+            }
+#else
+            loadgame = cgame;
+#endif
+            if (!err_load) {
+                if (me) midend_free(me);
+                me = midend_new(fe, loadgame, &win_drawing, fe);
+                err_load = midend_deserialise(me, savefile_read, fp);
+            }
+        } else {
+            err_load = "Unable to open file";
+        }
+
+        if (maybe_game_id && (!maybe_save_file || err_load)) {
+            /*
+             * See if arg is a game description.
+             */
+            if (me) midend_free(me);
+            me = midend_new(fe, cgame, &win_drawing, fe);
+            err_param = midend_game_id(me, arg);
+            if (!err_param) {
+                midend_new_game(me);
+            } else {
+                if (maybe_save_file) {
+                    *error = snewn(256 + strlen(arg) + strlen(err_param) +
+                                   strlen(err_load), char);
+                    sprintf(*error, "Supplied argument \"%s\" is neither a"
+                            " game ID (%s) nor a save file (%s)",
+                            arg, err_param, err_load);
+                } else {
+                    *error = dupstr(err_param);
+                }
+                midend_free(me);
+                sfree(fe);
+                return NULL;
+            }
+        } else if (err_load) {
+            *error = dupstr(err_load);
+            midend_free(me);
+            sfree(fe);
+            return NULL;
+        }
+    }
+
+    return me;
+}
+
+/*
+ * Populate a frontend structure with a new midend structure, and
+ * create any window furniture that it needs.
+ *
+ * Previously-allocated memory and window furniture will be freed by
+ * this function.
+ *
+ */
+static int fe_set_midend(frontend *fe, midend *me)
+{
+    int x, y;
+    RECT r;
+
+    if (fe->me) midend_free(fe->me);
+    fe->me = me;
+    fe->game = midend_which_game(fe->me);
+
+    {
+        int i, ncolours;
+        float *colours;
+
+        colours = midend_colours(fe->me, &ncolours);
+
+        if (fe->colours) sfree(fe->colours);
+        if (fe->brushes) sfree(fe->brushes);
+        if (fe->pens) sfree(fe->pens);
+
+        fe->colours = snewn(ncolours, COLORREF);
+        fe->brushes = snewn(ncolours, HBRUSH);
+        fe->pens = snewn(ncolours, HPEN);
+
+        for (i = 0; i < ncolours; i++) {
+            fe->colours[i] = RGB(255 * colours[i*3+0],
+                                 255 * colours[i*3+1],
+                                 255 * colours[i*3+2]);
+            fe->brushes[i] = CreateSolidBrush(fe->colours[i]);
+            fe->pens[i] = CreatePen(PS_SOLID, 1, fe->colours[i]);
+        }
+        sfree(colours);
+    }
+
+    if (fe->statusbar)
+        DestroyWindow(fe->statusbar);
+    if (midend_wants_statusbar(fe->me)) {
+        fe->statusbar = CreateWindowEx(0, STATUSCLASSNAME,
+                                       TEXT(DEFAULT_STATUSBAR_TEXT),
+                                       WS_CHILD | WS_VISIBLE,
+                                       0, 0, 0, 0, /* status bar does these */
+                                       NULL, NULL, fe->inst, NULL);
+    } else
+        fe->statusbar = NULL;
+
+    get_max_puzzle_size(fe, &x, &y);
+    midend_size(fe->me, &x, &y, FALSE);
+
+    r.left = r.top = 0;
+    r.right = x;
+    r.bottom = y;
+    AdjustWindowRectEx(&r, WINFLAGS, TRUE, 0);
+
+#ifdef _WIN32_WCE
+    if (fe->numpad)
+        DestroyWindow(fe->numpad);
+    if (fe->game->flags & REQUIRE_NUMPAD)
+    {
+        fe->numpad = CreateToolbarEx (fe->hwnd,
+                                      WS_VISIBLE | WS_CHILD | CCS_NOPARENTALIGN | TBSTYLE_FLAT,
+                                      0, 10, fe->inst, IDR_PADTOOLBAR,
+                                      tbNumpadButtons, sizeof (tbNumpadButtons) / sizeof (TBBUTTON),
+                                      0, 0, 14, 15, sizeof (TBBUTTON));
+        GetWindowRect(fe->numpad, &rcTB);
+        GetClientRect(fe->hwnd, &rcClient);
+        MoveWindow(fe->numpad, 
+                   0, 
+                   rcClient.bottom - (rcTB.bottom - rcTB.top) - 1,
+                   rcClient.right,
+                   rcTB.bottom - rcTB.top,
+                   FALSE);
+        SendMessage(fe->numpad, TB_SETINDENT, (rcClient.right - (10 * 21)) / 2, 0);
+    }
+    else {
+        fe->numpad = NULL;
+    }
+    MultiByteToWideChar (CP_ACP, 0, fe->game->name, -1, wGameName, 256);
+    SetWindowText(fe->hwnd, wGameName);
+#else
+    SetWindowText(fe->hwnd, fe->game->name);
+#endif
+
+    if (fe->statusbar)
+        DestroyWindow(fe->statusbar);
+    if (midend_wants_statusbar(fe->me)) {
+        RECT sr;
+        fe->statusbar = CreateWindowEx(0, STATUSCLASSNAME, TEXT("ooh"),
+                                       WS_CHILD | WS_VISIBLE,
+                                       0, 0, 0, 0, /* status bar does these */
+                                       fe->hwnd, NULL, fe->inst, NULL);
+#ifdef _WIN32_WCE
+        /* Flat status bar looks better on the Pocket PC */
+        SendMessage(fe->statusbar, SB_SIMPLE, (WPARAM) TRUE, 0);
+        SendMessage(fe->statusbar, SB_SETTEXT,
+                                (WPARAM) 255 | SBT_NOBORDERS,
+                                (LPARAM) L"");
+#endif
+
+        /*
+         * Now resize the window to take account of the status bar.
+         */
+        GetWindowRect(fe->statusbar, &sr);
+        GetWindowRect(fe->hwnd, &r);
+#ifndef _WIN32_WCE
+        SetWindowPos(fe->hwnd, NULL, 0, 0, r.right - r.left,
+                     r.bottom - r.top + sr.bottom - sr.top,
+                     SWP_NOMOVE | SWP_NOZORDER);
+#endif
+    } else {
+        fe->statusbar = NULL;
+    }
+
+    {
+        HMENU oldmenu = GetMenu(fe->hwnd);
+
+#ifndef _WIN32_WCE
+        HMENU bar = CreateMenu();
+        HMENU menu = CreateMenu();
+        RECT menusize;
+
+        AppendMenu(bar, MF_ENABLED|MF_POPUP, (UINT)menu, "&Game");
+#else
+        HMENU menu = SHGetSubMenu(SHFindMenuBar(fe->hwnd), ID_GAME);
+        DeleteMenu(menu, 0, MF_BYPOSITION);
+#endif
+        fe->gamemenu = menu;
+        AppendMenu(menu, MF_ENABLED, IDM_NEW, TEXT("&New"));
+        AppendMenu(menu, MF_ENABLED, IDM_RESTART, TEXT("&Restart"));
+#ifndef _WIN32_WCE
+        /* ...here I run out of sensible accelerator characters. */
+        AppendMenu(menu, MF_ENABLED, IDM_DESC, TEXT("Speci&fic..."));
+        AppendMenu(menu, MF_ENABLED, IDM_SEED, TEXT("Rando&m Seed..."));
+#endif
+
+        if (fe->presets)
+            sfree(fe->presets);
+        if ((fe->npresets = midend_num_presets(fe->me)) > 0 ||
+            fe->game->can_configure) {
+            int i;
+#ifndef _WIN32_WCE
+            HMENU sub = CreateMenu();
+
+            AppendMenu(bar, MF_ENABLED|MF_POPUP, (UINT)sub, "&Type");
+#else
+            HMENU sub = SHGetSubMenu(SHFindMenuBar(fe->hwnd), ID_TYPE);
+            DeleteMenu(sub, 0, MF_BYPOSITION);
+#endif
+            fe->presets = snewn(fe->npresets, game_params *);
+
+            for (i = 0; i < fe->npresets; i++) {
+                char *name;
+#ifdef _WIN32_WCE
+                TCHAR wName[255];
+#endif
+
+                midend_fetch_preset(fe->me, i, &name, &fe->presets[i]);
+
+                /*
+                 * FIXME: we ought to go through and do something
+                 * with ampersands here.
+                 */
+
+#ifndef _WIN32_WCE
+                AppendMenu(sub, MF_ENABLED, IDM_PRESETS + 0x10 * i, name);
+#else
+                MultiByteToWideChar (CP_ACP, 0, name, -1, wName, 255);
+                AppendMenu(sub, MF_ENABLED, IDM_PRESETS + 0x10 * i, wName);
+#endif
+            }
+            if (fe->game->can_configure) {
+                AppendMenu(sub, MF_ENABLED, IDM_CONFIG, TEXT("&Custom..."));
+            }
+
+            fe->typemenu = sub;
+        } else {
+            fe->typemenu = INVALID_HANDLE_VALUE;
+            fe->presets = NULL;
+        }
+
+#ifdef COMBINED
+#ifdef _WIN32_WCE
+#error Windows CE does not support COMBINED build.
+#endif
+        {
+            HMENU games = CreateMenu();
+            int i;
+
+            AppendMenu(menu, MF_SEPARATOR, 0, 0);
+            AppendMenu(menu, MF_ENABLED|MF_POPUP, (UINT)games, "&Other");
+            for (i = 0; i < gamecount; i++) {
+                if (strcmp(gamelist[i]->name, fe->game->name) != 0) {
+                    /* only include those games that aren't the same as the
+                     * game we're currently playing. */
+                    AppendMenu(games, MF_ENABLED, IDM_GAMES + i, gamelist[i]->name);
+                }
+            }
+        }
+#endif
+
+        AppendMenu(menu, MF_SEPARATOR, 0, 0);
+#ifndef _WIN32_WCE
+        AppendMenu(menu, MF_ENABLED, IDM_LOAD, TEXT("&Load..."));
+        AppendMenu(menu, MF_ENABLED, IDM_SAVE, TEXT("&Save..."));
+        AppendMenu(menu, MF_SEPARATOR, 0, 0);
+        if (fe->game->can_print) {
+            AppendMenu(menu, MF_ENABLED, IDM_PRINT, TEXT("&Print..."));
+            AppendMenu(menu, MF_SEPARATOR, 0, 0);
+        }
+#endif
+        AppendMenu(menu, MF_ENABLED, IDM_UNDO, TEXT("Undo"));
+        AppendMenu(menu, MF_ENABLED, IDM_REDO, TEXT("Redo"));
+#ifndef _WIN32_WCE
+        if (fe->game->can_format_as_text_ever) {
+            AppendMenu(menu, MF_SEPARATOR, 0, 0);
+            AppendMenu(menu, MF_ENABLED, IDM_COPY, TEXT("&Copy"));
+        }
+#endif
+        if (fe->game->can_solve) {
+            AppendMenu(menu, MF_SEPARATOR, 0, 0);
+            AppendMenu(menu, MF_ENABLED, IDM_SOLVE, TEXT("Sol&ve"));
+        }
+        AppendMenu(menu, MF_SEPARATOR, 0, 0);
+#ifndef _WIN32_WCE
+        AppendMenu(menu, MF_ENABLED, IDM_QUIT, TEXT("E&xit"));
+        menu = CreateMenu();
+        AppendMenu(bar, MF_ENABLED|MF_POPUP, (UINT)menu, TEXT("&Help"));
+#endif
+        AppendMenu(menu, MF_ENABLED, IDM_ABOUT, TEXT("&About"));
+#ifndef _WIN32_WCE
+        if (help_type != NONE) {
+            char *item;
+            AppendMenu(menu, MF_SEPARATOR, 0, 0);
+            AppendMenu(menu, MF_ENABLED, IDM_HELPC, TEXT("&Contents"));
+            assert(fe->game->name);
+            item = snewn(10+strlen(fe->game->name), char); /*ick*/
+            sprintf(item, "&Help on %s", fe->game->name);
+            AppendMenu(menu, MF_ENABLED, IDM_GAMEHELP, item);
+            sfree(item);
+        }
+        DestroyMenu(oldmenu);
+        SetMenu(fe->hwnd, bar);
+        get_menu_size(fe->hwnd, &menusize);
+        fe->xmin = (menusize.right - menusize.left) + 25;
+#endif
+    }
+
+    if (fe->bitmap) DeleteObject(fe->bitmap);
+    fe->bitmap = NULL;
+    new_game_size(fe, fe->puzz_scale); /* initialises fe->bitmap */
+
+    return 0;
+}
+
+static void show_window(frontend *fe)
+{
+    ShowWindow(fe->hwnd, SW_SHOWNORMAL);
+    SetForegroundWindow(fe->hwnd);
+
+    update_type_menu_tick(fe);
+    update_copy_menu_greying(fe);
+
+    midend_redraw(fe->me);
+}
+
+#ifdef _WIN32_WCE
+static HFONT dialog_title_font()
+{
+    static HFONT hf = NULL;
+    LOGFONT lf;
+
+    if (hf)
+        return hf;
+
+    memset (&lf, 0, sizeof(LOGFONT));
+    lf.lfHeight = -11; /* - ((8 * GetDeviceCaps(hdc, LOGPIXELSY)) / 72) */
+    lf.lfWeight = FW_BOLD;
+    wcscpy(lf.lfFaceName, TEXT("Tahoma"));
+
+    return hf = CreateFontIndirect(&lf);
+}
+
+static void make_dialog_full_screen(HWND hwnd)
+{
+    SHINITDLGINFO shidi;
+
+    /* Make dialog full screen */
+    shidi.dwMask = SHIDIM_FLAGS;
+    shidi.dwFlags = SHIDIF_DONEBUTTON | SHIDIF_SIZEDLGFULLSCREEN |
+                    SHIDIF_EMPTYMENU;
+    shidi.hDlg = hwnd;
+    SHInitDialog(&shidi);
+}
+#endif
+
+static int CALLBACK AboutDlgProc(HWND hwnd, UINT msg,
+                                 WPARAM wParam, LPARAM lParam)
+{
+    frontend *fe = (frontend *)GetWindowLong(hwnd, GWL_USERDATA);
+
+    switch (msg) {
+      case WM_INITDIALOG:
+#ifdef _WIN32_WCE
+        {
+            char title[256];
+
+            make_dialog_full_screen(hwnd);
+
+            sprintf(title, "About %.250s", fe->game->name);
+            SetDlgItemTextA(hwnd, IDC_ABOUT_CAPTION, title);
+
+            SendDlgItemMessage(hwnd, IDC_ABOUT_CAPTION, WM_SETFONT,
+                               (WPARAM) dialog_title_font(), 0);
+
+            SetDlgItemTextA(hwnd, IDC_ABOUT_GAME, fe->game->name);
+            SetDlgItemTextA(hwnd, IDC_ABOUT_VERSION, ver);
+        }
+#endif
+        return TRUE;
+
+      case WM_COMMAND:
+        if (LOWORD(wParam) == IDOK)
+#ifdef _WIN32_WCE
+            EndDialog(hwnd, 1);
+#else
+            fe->dlg_done = 1;
+#endif
+        return 0;
+
+      case WM_CLOSE:
+#ifdef _WIN32_WCE
+        EndDialog(hwnd, 1);
+#else
+        fe->dlg_done = 1;
+#endif
+        return 0;
+    }
+
+    return 0;
+}
+
+/*
+ * Wrappers on midend_{get,set}_config, which extend the CFG_*
+ * enumeration to add CFG_PRINT.
+ */
+static config_item *frontend_get_config(frontend *fe, int which,
+                                        char **wintitle)
+{
+    if (which < CFG_FRONTEND_SPECIFIC) {
+        return midend_get_config(fe->me, which, wintitle);
+    } else if (which == CFG_PRINT) {
+        config_item *ret;
+        int i;
+
+        *wintitle = snewn(40 + strlen(fe->game->name), char);
+        sprintf(*wintitle, "%s print setup", fe->game->name);
+
+        ret = snewn(8, config_item);
+
+        i = 0;
+
+        ret[i].name = "Number of puzzles to print";
+        ret[i].type = C_STRING;
+        ret[i].sval = dupstr("1");
+        ret[i].ival = 0;
+        i++;
+
+        ret[i].name = "Number of puzzles across the page";
+        ret[i].type = C_STRING;
+        ret[i].sval = dupstr("1");
+        ret[i].ival = 0;
+        i++;
+
+        ret[i].name = "Number of puzzles down the page";
+        ret[i].type = C_STRING;
+        ret[i].sval = dupstr("1");
+        ret[i].ival = 0;
+        i++;
+
+        ret[i].name = "Percentage of standard size";
+        ret[i].type = C_STRING;
+        ret[i].sval = dupstr("100.0");
+        ret[i].ival = 0;
+        i++;
+
+        ret[i].name = "Include currently shown puzzle";
+        ret[i].type = C_BOOLEAN;
+        ret[i].sval = NULL;
+        ret[i].ival = TRUE;
+        i++;
+
+        ret[i].name = "Print solutions";
+        ret[i].type = C_BOOLEAN;
+        ret[i].sval = NULL;
+        ret[i].ival = FALSE;
+        i++;
+
+        if (fe->game->can_print_in_colour) {
+            ret[i].name = "Print in colour";
+            ret[i].type = C_BOOLEAN;
+            ret[i].sval = NULL;
+            ret[i].ival = FALSE;
+            i++;
+        }
+
+        ret[i].name = NULL;
+        ret[i].type = C_END;
+        ret[i].sval = NULL;
+        ret[i].ival = 0;
+        i++;
+
+        return ret;
+    } else {
+        assert(!"We should never get here");
+        return NULL;
+    }
+}
+
+static char *frontend_set_config(frontend *fe, int which, config_item *cfg)
+{
+    if (which < CFG_FRONTEND_SPECIFIC) {
+        return midend_set_config(fe->me, which, cfg);
+    } else if (which == CFG_PRINT) {
+        if ((fe->printcount = atoi(cfg[0].sval)) <= 0)
+            return "Number of puzzles to print should be at least one";
+        if ((fe->printw = atoi(cfg[1].sval)) <= 0)
+            return "Number of puzzles across the page should be at least one";
+        if ((fe->printh = atoi(cfg[2].sval)) <= 0)
+            return "Number of puzzles down the page should be at least one";
+        if ((fe->printscale = (float)atof(cfg[3].sval)) <= 0)
+            return "Print size should be positive";
+        fe->printcurr = cfg[4].ival;
+        fe->printsolns = cfg[5].ival;
+        fe->printcolour = fe->game->can_print_in_colour && cfg[6].ival;
+        return NULL;
+    } else {
+        assert(!"We should never get here");
+        return "Internal error";
+    }
+}
+
+#ifdef _WIN32_WCE
+/* Separate version of mkctrl function for the Pocket PC. */
+/* Control coordinates should be specified in dialog units. */
+HWND mkctrl(frontend *fe, int x1, int x2, int y1, int y2,
+            LPCTSTR wclass, int wstyle,
+            int exstyle, const char *wtext, int wid)
+{
+    RECT rc;
+    TCHAR wwtext[256];
+
+    /* Convert dialog units into pixels */
+    rc.left = x1;  rc.right  = x2;
+    rc.top  = y1;  rc.bottom = y2;
+    MapDialogRect(fe->cfgbox, &rc);
+
+    MultiByteToWideChar (CP_ACP, 0, wtext, -1, wwtext, 256);
+
+    return CreateWindowEx(exstyle, wclass, wwtext,
+                          wstyle | WS_CHILD | WS_VISIBLE,
+                          rc.left, rc.top,
+                          rc.right - rc.left, rc.bottom - rc.top,
+                          fe->cfgbox, (HMENU) wid, fe->inst, NULL);
+}
+
+static void create_config_controls(frontend * fe)
+{
+    int id, nctrls;
+    int col1l, col1r, col2l, col2r, y;
+    config_item *i;
+    struct cfg_aux *j;
+    HWND ctl;
+
+    /* Control placement done in dialog units */
+    col1l = 4;   col1r = 96;   /* Label column */
+    col2l = 100; col2r = 154;  /* Input column (edit boxes and combo boxes) */
+
+    /*
+     * Count the controls so we can allocate cfgaux.
+     */
+    for (nctrls = 0, i = fe->cfg; i->type != C_END; i++)
+        nctrls++;
+    fe->cfgaux = snewn(nctrls, struct cfg_aux);
+
+    id = 1000;
+    y = 22; /* Leave some room for the dialog title */
+    for (i = fe->cfg, j = fe->cfgaux; i->type != C_END; i++, j++) {
+        switch (i->type) {
+          case C_STRING:
+            /*
+             * Edit box with a label beside it.
+             */
+            mkctrl(fe, col1l, col1r, y + 1, y + 11,
+                   TEXT("Static"), SS_LEFTNOWORDWRAP, 0, i->name, id++);
+            mkctrl(fe, col2l, col2r, y, y + 12,
+                   TEXT("EDIT"), WS_BORDER | WS_TABSTOP | ES_AUTOHSCROLL,
+                   0, "", (j->ctlid = id++));
+            SetDlgItemTextA(fe->cfgbox, j->ctlid, i->sval);
+            break;
+
+          case C_BOOLEAN:
+            /*
+             * Simple checkbox.
+             */
+            mkctrl(fe, col1l, col2r, y + 1, y + 11, TEXT("BUTTON"),
+                   BS_NOTIFY | BS_AUTOCHECKBOX | WS_TABSTOP,
+                   0, i->name, (j->ctlid = id++));
+            CheckDlgButton(fe->cfgbox, j->ctlid, (i->ival != 0));
+            break;
+
+          case C_CHOICES:
+            /*
+             * Drop-down list with a label beside it.
+             */
+            mkctrl(fe, col1l, col1r, y + 1, y + 11,
+                   TEXT("STATIC"), SS_LEFTNOWORDWRAP, 0, i->name, id++);
+            ctl = mkctrl(fe, col2l, col2r, y, y + 48,
+                         TEXT("COMBOBOX"), WS_BORDER | WS_TABSTOP |
+                         CBS_DROPDOWNLIST | CBS_HASSTRINGS,
+                         0, "", (j->ctlid = id++));
+            {
+                char c, *p, *q, *str;
+
+                p = i->sval;
+                c = *p++;
+                while (*p) {
+                    q = p;
+                    while (*q && *q != c) q++;
+                    str = snewn(q-p+1, char);
+                    strncpy(str, p, q-p);
+                    str[q-p] = '\0';
+                    {
+                        TCHAR ws[50];
+                        MultiByteToWideChar (CP_ACP, 0, str, -1, ws, 50);
+                        SendMessage(ctl, CB_ADDSTRING, 0, (LPARAM)ws);
+                    }
+                    
+                    sfree(str);
+                    if (*q) q++;
+                    p = q;
+                }
+            }
+            SendMessage(ctl, CB_SETCURSEL, i->ival, 0);
+            break;
+        }
+
+        y += 15;
+    }
+
+}
+#endif
+
+static int CALLBACK ConfigDlgProc(HWND hwnd, UINT msg,
+                                  WPARAM wParam, LPARAM lParam)
+{
+    frontend *fe = (frontend *)GetWindowLong(hwnd, GWL_USERDATA);
+    config_item *i;
+    struct cfg_aux *j;
+
+    switch (msg) {
+      case WM_INITDIALOG:
+#ifdef _WIN32_WCE
+        {
+            char *title;
+
+            fe = (frontend *) lParam;
+            SetWindowLong(hwnd, GWL_USERDATA, lParam);
+            fe->cfgbox = hwnd;
+
+            fe->cfg = frontend_get_config(fe, fe->cfg_which, &title);
+
+            make_dialog_full_screen(hwnd);
+
+            SetDlgItemTextA(hwnd, IDC_CONFIG_CAPTION, title);
+            SendDlgItemMessage(hwnd, IDC_CONFIG_CAPTION, WM_SETFONT,
+                               (WPARAM) dialog_title_font(), 0);
+
+            create_config_controls(fe);
+        }
+#endif
+        return TRUE;
+
+      case WM_COMMAND:
+        /*
+         * OK and Cancel are special cases.
+         */
+        if ((LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)) {
+            if (LOWORD(wParam) == IDOK) {
+                char *err = frontend_set_config(fe, fe->cfg_which, fe->cfg);
+
+                if (err) {
+                    MessageBox(hwnd, err, "Validation error",
+                               MB_ICONERROR | MB_OK);
+                } else {
+#ifdef _WIN32_WCE
+                    EndDialog(hwnd, 2);
+#else
+                    fe->dlg_done = 2;
+#endif
+                }
+            } else {
+#ifdef _WIN32_WCE
+                EndDialog(hwnd, 1);
+#else
+                fe->dlg_done = 1;
+#endif
+            }
+            return 0;
+        }
+
+        /*
+         * First find the control whose id this is.
+         */
+        for (i = fe->cfg, j = fe->cfgaux; i->type != C_END; i++, j++) {
+            if (j->ctlid == LOWORD(wParam))
+                break;
+        }
+        if (i->type == C_END)
+            return 0;                  /* not our problem */
+
+        if (i->type == C_STRING && HIWORD(wParam) == EN_CHANGE) {
+            char buffer[4096];
+#ifdef _WIN32_WCE
+            TCHAR wBuffer[4096];
+            GetDlgItemText(fe->cfgbox, j->ctlid, wBuffer, 4096);
+            WideCharToMultiByte(CP_ACP, 0, wBuffer, -1, buffer, 4096, NULL, NULL);
+#else
+            GetDlgItemText(fe->cfgbox, j->ctlid, buffer, lenof(buffer));
+#endif
+            buffer[lenof(buffer)-1] = '\0';
+            sfree(i->sval);
+            i->sval = dupstr(buffer);
+        } else if (i->type == C_BOOLEAN && 
+                   (HIWORD(wParam) == BN_CLICKED ||
+                    HIWORD(wParam) == BN_DBLCLK)) {
+            i->ival = IsDlgButtonChecked(fe->cfgbox, j->ctlid);
+        } else if (i->type == C_CHOICES &&
+                   HIWORD(wParam) == CBN_SELCHANGE) {
+            i->ival = SendDlgItemMessage(fe->cfgbox, j->ctlid,
+                                         CB_GETCURSEL, 0, 0);
+        }
+
+        return 0;
+
+      case WM_CLOSE:
+        fe->dlg_done = 1;
+        return 0;
+    }
+
+    return 0;
+}
+
+#ifndef _WIN32_WCE
+HWND mkctrl(frontend *fe, int x1, int x2, int y1, int y2,
+            char *wclass, int wstyle,
+            int exstyle, const char *wtext, int wid)
+{
+    HWND ret;
+    ret = CreateWindowEx(exstyle, wclass, wtext,
+                         wstyle | WS_CHILD | WS_VISIBLE, x1, y1, x2-x1, y2-y1,
+                         fe->cfgbox, (HMENU) wid, fe->inst, NULL);
+    SendMessage(ret, WM_SETFONT, (WPARAM)fe->cfgfont, MAKELPARAM(TRUE, 0));
+    return ret;
+}
+#endif
+
+static void about(frontend *fe)
+{
+#ifdef _WIN32_WCE
+    DialogBox(fe->inst, MAKEINTRESOURCE(IDD_ABOUT), fe->hwnd, AboutDlgProc);
+#else
+    int i;
+    WNDCLASS wc;
+    MSG msg;
+    TEXTMETRIC tm;
+    HDC hdc;
+    HFONT oldfont;
+    SIZE size;
+    int gm, id;
+    int winwidth, winheight, y;
+    int height, width, maxwid;
+    const char *strings[16];
+    int lengths[16];
+    int nstrings = 0;
+    char titlebuf[512];
+
+    sprintf(titlebuf, "About %.250s", fe->game->name);
+
+    strings[nstrings++] = fe->game->name;
+    strings[nstrings++] = "from Simon Tatham's Portable Puzzle Collection";
+    strings[nstrings++] = ver;
+
+    wc.style = CS_DBLCLKS | CS_SAVEBITS;
+    wc.lpfnWndProc = DefDlgProc;
+    wc.cbClsExtra = 0;
+    wc.cbWndExtra = DLGWINDOWEXTRA + 8;
+    wc.hInstance = fe->inst;
+    wc.hIcon = NULL;
+    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+    wc.hbrBackground = (HBRUSH) (COLOR_BACKGROUND +1);
+    wc.lpszMenuName = NULL;
+    wc.lpszClassName = "GameAboutBox";
+    RegisterClass(&wc);
+
+    hdc = GetDC(fe->hwnd);
+    SetMapMode(hdc, MM_TEXT);
+
+    fe->dlg_done = FALSE;
+
+    fe->cfgfont = CreateFont(-MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72),
+                             0, 0, 0, 0,
+                             FALSE, FALSE, FALSE, DEFAULT_CHARSET,
+                             OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
+                             DEFAULT_QUALITY,
+                             FF_SWISS,
+                             "MS Shell Dlg");
+
+    oldfont = SelectObject(hdc, fe->cfgfont);
+    if (GetTextMetrics(hdc, &tm)) {
+        height = tm.tmAscent + tm.tmDescent;
+        width = tm.tmAveCharWidth;
+    } else {
+        height = width = 30;
+    }
+
+    /*
+     * Figure out the layout of the About box by measuring the
+     * length of each piece of text.
+     */
+    maxwid = 0;
+    winheight = height/2;
+
+    for (i = 0; i < nstrings; i++) {
+        if (GetTextExtentPoint32(hdc, strings[i], strlen(strings[i]), &size))
+            lengths[i] = size.cx;
+        else
+            lengths[i] = 0;            /* *shrug* */
+        if (maxwid < lengths[i])
+            maxwid = lengths[i];
+        winheight += height * 3 / 2 + (height / 2);
+    }
+
+    winheight += height + height * 7 / 4;      /* OK button */
+    winwidth = maxwid + 4*width;
+
+    SelectObject(hdc, oldfont);
+    ReleaseDC(fe->hwnd, hdc);
+
+    /*
+     * Create the dialog, now that we know its size.
+     */
+    {
+        RECT r, r2;
+
+        r.left = r.top = 0;
+        r.right = winwidth;
+        r.bottom = winheight;
+
+        AdjustWindowRectEx(&r, (WS_OVERLAPPEDWINDOW /*|
+                                DS_MODALFRAME | WS_POPUP | WS_VISIBLE |
+                                WS_CAPTION | WS_SYSMENU*/) &~
+                           (WS_MAXIMIZEBOX | WS_OVERLAPPED),
+                           FALSE, 0);
+
+        /*
+         * Centre the dialog on its parent window.
+         */
+        r.right -= r.left;
+        r.bottom -= r.top;
+        GetWindowRect(fe->hwnd, &r2);
+        r.left = (r2.left + r2.right - r.right) / 2;
+        r.top = (r2.top + r2.bottom - r.bottom) / 2;
+        r.right += r.left;
+        r.bottom += r.top;
+
+        fe->cfgbox = CreateWindowEx(0, wc.lpszClassName, titlebuf,
+                                    DS_MODALFRAME | WS_POPUP | WS_VISIBLE |
+                                    WS_CAPTION | WS_SYSMENU,
+                                    r.left, r.top,
+                                    r.right-r.left, r.bottom-r.top,
+                                    fe->hwnd, NULL, fe->inst, NULL);
+    }
+
+    SendMessage(fe->cfgbox, WM_SETFONT, (WPARAM)fe->cfgfont, FALSE);
+
+    SetWindowLong(fe->cfgbox, GWL_USERDATA, (LONG)fe);
+    SetWindowLong(fe->cfgbox, DWL_DLGPROC, (LONG)AboutDlgProc);
+
+    id = 1000;
+    y = height/2;
+    for (i = 0; i < nstrings; i++) {
+        int border = width*2 + (maxwid - lengths[i]) / 2;
+        mkctrl(fe, border, border+lengths[i], y+height*1/8, y+height*9/8,
+               "Static", 0, 0, strings[i], id++);
+        y += height*3/2;
+
+        assert(y < winheight);
+        y += height/2;
+    }
+
+    y += height/2;                     /* extra space before OK */
+    mkctrl(fe, width*2, maxwid+width*2, y, y+height*7/4, "BUTTON",
+           BS_PUSHBUTTON | WS_TABSTOP | BS_DEFPUSHBUTTON, 0,
+           "OK", IDOK);
+
+    SendMessage(fe->cfgbox, WM_INITDIALOG, 0, 0);
+
+    EnableWindow(fe->hwnd, FALSE);
+    ShowWindow(fe->cfgbox, SW_SHOWNORMAL);
+    while ((gm=GetMessage(&msg, NULL, 0, 0)) > 0) {
+        if (!IsDialogMessage(fe->cfgbox, &msg))
+            DispatchMessage(&msg);
+        if (fe->dlg_done)
+            break;
+    }
+    EnableWindow(fe->hwnd, TRUE);
+    SetForegroundWindow(fe->hwnd);
+    DestroyWindow(fe->cfgbox);
+    DeleteObject(fe->cfgfont);
+#endif
+}
+
+static int get_config(frontend *fe, int which)
+{
+#ifdef _WIN32_WCE
+    fe->cfg_which = which;
+
+    return DialogBoxParam(fe->inst,
+                          MAKEINTRESOURCE(IDD_CONFIG),
+                          fe->hwnd, ConfigDlgProc,
+                          (LPARAM) fe) == 2;
+#else
+    config_item *i;
+    struct cfg_aux *j;
+    char *title;
+    WNDCLASS wc;
+    MSG msg;
+    TEXTMETRIC tm;
+    HDC hdc;
+    HFONT oldfont;
+    SIZE size;
+    HWND ctl;
+    int gm, id, nctrls;
+    int winwidth, winheight, col1l, col1r, col2l, col2r, y;
+    int height, width, maxlabel, maxcheckbox;
+
+    wc.style = CS_DBLCLKS | CS_SAVEBITS;
+    wc.lpfnWndProc = DefDlgProc;
+    wc.cbClsExtra = 0;
+    wc.cbWndExtra = DLGWINDOWEXTRA + 8;
+    wc.hInstance = fe->inst;
+    wc.hIcon = NULL;
+    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+    wc.hbrBackground = (HBRUSH) (COLOR_BACKGROUND +1);
+    wc.lpszMenuName = NULL;
+    wc.lpszClassName = "GameConfigBox";
+    RegisterClass(&wc);
+
+    hdc = GetDC(fe->hwnd);
+    SetMapMode(hdc, MM_TEXT);
+
+    fe->dlg_done = FALSE;
+
+    fe->cfgfont = CreateFont(-MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72),
+                             0, 0, 0, 0,
+                             FALSE, FALSE, FALSE, DEFAULT_CHARSET,
+                             OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
+                             DEFAULT_QUALITY,
+                             FF_SWISS,
+                             "MS Shell Dlg");
+
+    oldfont = SelectObject(hdc, fe->cfgfont);
+    if (GetTextMetrics(hdc, &tm)) {
+        height = tm.tmAscent + tm.tmDescent;
+        width = tm.tmAveCharWidth;
+    } else {
+        height = width = 30;
+    }
+
+    fe->cfg = frontend_get_config(fe, which, &title);
+    fe->cfg_which = which;
+
+    /*
+     * Figure out the layout of the config box by measuring the
+     * length of each piece of text.
+     */
+    maxlabel = maxcheckbox = 0;
+    winheight = height/2;
+
+    for (i = fe->cfg; i->type != C_END; i++) {
+        switch (i->type) {
+          case C_STRING:
+          case C_CHOICES:
+            /*
+             * Both these control types have a label filling only
+             * the left-hand column of the box.
+             */
+            if (GetTextExtentPoint32(hdc, i->name, strlen(i->name), &size) &&
+                maxlabel < size.cx)
+                maxlabel = size.cx;
+            winheight += height * 3 / 2 + (height / 2);
+            break;
+
+          case C_BOOLEAN:
+            /*
+             * Checkboxes take up the whole of the box width.
+             */
+            if (GetTextExtentPoint32(hdc, i->name, strlen(i->name), &size) &&
+                maxcheckbox < size.cx)
+                maxcheckbox = size.cx;
+            winheight += height + (height / 2);
+            break;
+        }
+    }
+
+    winheight += height + height * 7 / 4;      /* OK / Cancel buttons */
+
+    col1l = 2*width;
+    col1r = col1l + maxlabel;
+    col2l = col1r + 2*width;
+    col2r = col2l + 30*width;
+    if (col2r < col1l+2*height+maxcheckbox)
+        col2r = col1l+2*height+maxcheckbox;
+    winwidth = col2r + 2*width;
+
+    SelectObject(hdc, oldfont);
+    ReleaseDC(fe->hwnd, hdc);
+
+    /*
+     * Create the dialog, now that we know its size.
+     */
+    {
+        RECT r, r2;
+
+        r.left = r.top = 0;
+        r.right = winwidth;
+        r.bottom = winheight;
+
+        AdjustWindowRectEx(&r, (WS_OVERLAPPEDWINDOW /*|
+                                DS_MODALFRAME | WS_POPUP | WS_VISIBLE |
+                                WS_CAPTION | WS_SYSMENU*/) &~
+                           (WS_MAXIMIZEBOX | WS_OVERLAPPED),
+                           FALSE, 0);
+
+        /*
+         * Centre the dialog on its parent window.
+         */
+        r.right -= r.left;
+        r.bottom -= r.top;
+        GetWindowRect(fe->hwnd, &r2);
+        r.left = (r2.left + r2.right - r.right) / 2;
+        r.top = (r2.top + r2.bottom - r.bottom) / 2;
+        r.right += r.left;
+        r.bottom += r.top;
+
+        fe->cfgbox = CreateWindowEx(0, wc.lpszClassName, title,
+                                    DS_MODALFRAME | WS_POPUP | WS_VISIBLE |
+                                    WS_CAPTION | WS_SYSMENU,
+                                    r.left, r.top,
+                                    r.right-r.left, r.bottom-r.top,
+                                    fe->hwnd, NULL, fe->inst, NULL);
+        sfree(title);
+    }
+
+    SendMessage(fe->cfgbox, WM_SETFONT, (WPARAM)fe->cfgfont, FALSE);
+
+    SetWindowLong(fe->cfgbox, GWL_USERDATA, (LONG)fe);
+    SetWindowLong(fe->cfgbox, DWL_DLGPROC, (LONG)ConfigDlgProc);
+
+    /*
+     * Count the controls so we can allocate cfgaux.
+     */
+    for (nctrls = 0, i = fe->cfg; i->type != C_END; i++)
+        nctrls++;
+    fe->cfgaux = snewn(nctrls, struct cfg_aux);
+
+    id = 1000;
+    y = height/2;
+    for (i = fe->cfg, j = fe->cfgaux; i->type != C_END; i++, j++) {
+        switch (i->type) {
+          case C_STRING:
+            /*
+             * Edit box with a label beside it.
+             */
+            mkctrl(fe, col1l, col1r, y+height*1/8, y+height*9/8,
+                   "Static", 0, 0, i->name, id++);
+            ctl = mkctrl(fe, col2l, col2r, y, y+height*3/2,
+                         "EDIT", WS_TABSTOP | ES_AUTOHSCROLL,
+                         WS_EX_CLIENTEDGE, "", (j->ctlid = id++));
+            SetWindowText(ctl, i->sval);
+            y += height*3/2;
+            break;
+
+          case C_BOOLEAN:
+            /*
+             * Simple checkbox.
+             */
+            mkctrl(fe, col1l, col2r, y, y+height, "BUTTON",
+                   BS_NOTIFY | BS_AUTOCHECKBOX | WS_TABSTOP,
+                   0, i->name, (j->ctlid = id++));
+            CheckDlgButton(fe->cfgbox, j->ctlid, (i->ival != 0));
+            y += height;
+            break;
+
+          case C_CHOICES:
+            /*
+             * Drop-down list with a label beside it.
+             */
+            mkctrl(fe, col1l, col1r, y+height*1/8, y+height*9/8,
+                   "STATIC", 0, 0, i->name, id++);
+            ctl = mkctrl(fe, col2l, col2r, y, y+height*41/2,
+                         "COMBOBOX", WS_TABSTOP |
+                         CBS_DROPDOWNLIST | CBS_HASSTRINGS,
+                         WS_EX_CLIENTEDGE, "", (j->ctlid = id++));
+            {
+                char c, *p, *q, *str;
+
+                SendMessage(ctl, CB_RESETCONTENT, 0, 0);
+                p = i->sval;
+                c = *p++;
+                while (*p) {
+                    q = p;
+                    while (*q && *q != c) q++;
+                    str = snewn(q-p+1, char);
+                    strncpy(str, p, q-p);
+                    str[q-p] = '\0';
+                    SendMessage(ctl, CB_ADDSTRING, 0, (LPARAM)str);
+                    sfree(str);
+                    if (*q) q++;
+                    p = q;
+                }
+            }
+
+            SendMessage(ctl, CB_SETCURSEL, i->ival, 0);
+
+            y += height*3/2;
+            break;
+        }
+
+        assert(y < winheight);
+        y += height/2;
+    }
+
+    y += height/2;                     /* extra space before OK and Cancel */
+    mkctrl(fe, col1l, (col1l+col2r)/2-width, y, y+height*7/4, "BUTTON",
+           BS_PUSHBUTTON | WS_TABSTOP | BS_DEFPUSHBUTTON, 0,
+           "OK", IDOK);
+    mkctrl(fe, (col1l+col2r)/2+width, col2r, y, y+height*7/4, "BUTTON",
+           BS_PUSHBUTTON | WS_TABSTOP, 0, "Cancel", IDCANCEL);
+
+    SendMessage(fe->cfgbox, WM_INITDIALOG, 0, 0);
+
+    EnableWindow(fe->hwnd, FALSE);
+    ShowWindow(fe->cfgbox, SW_SHOWNORMAL);
+    while ((gm=GetMessage(&msg, NULL, 0, 0)) > 0) {
+        if (!IsDialogMessage(fe->cfgbox, &msg))
+            DispatchMessage(&msg);
+        if (fe->dlg_done)
+            break;
+    }
+    EnableWindow(fe->hwnd, TRUE);
+    SetForegroundWindow(fe->hwnd);
+    DestroyWindow(fe->cfgbox);
+    DeleteObject(fe->cfgfont);
+
+    free_cfg(fe->cfg);
+    sfree(fe->cfgaux);
+
+    return (fe->dlg_done == 2);
+#endif
+}
+
+#ifdef _WIN32_WCE
+static void calculate_bitmap_position(frontend *fe, int x, int y)
+{
+    /* Pocket PC - center the game in the full screen window */
+    int yMargin;
+    RECT rcClient;
+
+    GetClientRect(fe->hwnd, &rcClient);
+    fe->bitmapPosition.left = (rcClient.right  - x) / 2;
+    yMargin = rcClient.bottom - y;
+
+    if (fe->numpad != NULL) {
+        RECT rcPad;
+        GetWindowRect(fe->numpad, &rcPad);
+        yMargin -= rcPad.bottom - rcPad.top;
+    }
+
+    if (fe->statusbar != NULL) {
+        RECT rcStatus;
+        GetWindowRect(fe->statusbar, &rcStatus);
+        yMargin -= rcStatus.bottom - rcStatus.top;
+    }
+
+    fe->bitmapPosition.top = yMargin / 2;
+
+    fe->bitmapPosition.right  = fe->bitmapPosition.left + x;
+    fe->bitmapPosition.bottom = fe->bitmapPosition.top  + y;
+}
+#else
+static void calculate_bitmap_position(frontend *fe, int x, int y)
+{
+    /* Plain Windows - position the game in the upper-left corner */
+    fe->bitmapPosition.left = 0;
+    fe->bitmapPosition.top = 0;
+    fe->bitmapPosition.right  = fe->bitmapPosition.left + x;
+    fe->bitmapPosition.bottom = fe->bitmapPosition.top  + y;
+}
+#endif
+
+static void new_bitmap(frontend *fe, int x, int y)
+{
+    HDC hdc;
+
+    if (fe->bitmap) DeleteObject(fe->bitmap);
+
+    hdc = GetDC(fe->hwnd);
+    fe->bitmap = CreateCompatibleBitmap(hdc, x, y);
+    calculate_bitmap_position(fe, x, y);
+    ReleaseDC(fe->hwnd, hdc);
+}
+
+static void new_game_size(frontend *fe, float scale)
+{
+    RECT r, sr;
+    int x, y;
+
+    get_max_puzzle_size(fe, &x, &y);
+    midend_size(fe->me, &x, &y, FALSE);
+
+    if (scale != 1.0) {
+      x = (int)((float)x * fe->puzz_scale);
+      y = (int)((float)y * fe->puzz_scale);
+      midend_size(fe->me, &x, &y, TRUE);
+    }
+    fe->ymin = (fe->xmin * y) / x;
+
+    r.left = r.top = 0;
+    r.right = x;
+    r.bottom = y;
+    AdjustWindowRectEx(&r, WINFLAGS, TRUE, 0);
+
+    if (fe->statusbar != NULL) {
+        GetWindowRect(fe->statusbar, &sr);
+    } else {
+        sr.left = sr.right = sr.top = sr.bottom = 0;
+    }
+#ifndef _WIN32_WCE
+    SetWindowPos(fe->hwnd, NULL, 0, 0,
+                 r.right - r.left,
+                 r.bottom - r.top + sr.bottom - sr.top,
+                 SWP_NOMOVE | SWP_NOZORDER);
+#endif
+
+    check_window_size(fe, &x, &y);
+
+#ifndef _WIN32_WCE
+    if (fe->statusbar != NULL)
+        SetWindowPos(fe->statusbar, NULL, 0, y, x,
+                     sr.bottom - sr.top, SWP_NOZORDER);
+#endif
+
+    new_bitmap(fe, x, y);
+
+#ifdef _WIN32_WCE
+    InvalidateRect(fe->hwnd, NULL, TRUE);
+#endif
+    midend_redraw(fe->me);
+}
+
+/*
+ * Given a proposed new window rect, work out the resulting
+ * difference in client size (from current), and use to try
+ * and resize the puzzle, returning (wx,wy) as the actual
+ * new window size.
+ */
+
+static void adjust_game_size(frontend *fe, RECT *proposed, int isedge,
+                             int *wx_r, int *wy_r)
+{
+    RECT cr, wr;
+    int nx, ny, xdiff, ydiff, wx, wy;
+
+    /* Work out the current window sizing, and thus the
+     * difference in size we're asking for. */
+    GetClientRect(fe->hwnd, &cr);
+    wr = cr;
+    AdjustWindowRectEx(&wr, WINFLAGS, TRUE, 0);
+
+    xdiff = (proposed->right - proposed->left) - (wr.right - wr.left);
+    ydiff = (proposed->bottom - proposed->top) - (wr.bottom - wr.top);
+
+    if (isedge) {
+      /* These next four lines work around the fact that midend_size
+       * is happy to shrink _but not grow_ if you change one dimension
+       * but not the other. */
+      if (xdiff > 0 && ydiff == 0)
+        ydiff = (xdiff * (wr.right - wr.left)) / (wr.bottom - wr.top);
+      if (xdiff == 0 && ydiff > 0)
+        xdiff = (ydiff * (wr.bottom - wr.top)) / (wr.right - wr.left);
+    }
+
+    if (check_window_resize(fe,
+                            (cr.right - cr.left) + xdiff,
+                            (cr.bottom - cr.top) + ydiff,
+                            &nx, &ny, &wx, &wy)) {
+        new_bitmap(fe, nx, ny);
+        midend_force_redraw(fe->me);
+    } else {
+        /* reset size to current window size */
+        wx = wr.right - wr.left;
+        wy = wr.bottom - wr.top;
+    }
+    /* Re-fetch rectangle; size limits mean we might not have
+     * taken it quite to the mouse drag positions. */
+    GetClientRect(fe->hwnd, &cr);
+    adjust_statusbar(fe, &cr);
+
+    *wx_r = wx; *wy_r = wy;
+}
+
+static void update_type_menu_tick(frontend *fe)
+{
+    int total, n, i;
+
+    if (fe->typemenu == INVALID_HANDLE_VALUE)
+        return;
+
+    total = GetMenuItemCount(fe->typemenu);
+    n = midend_which_preset(fe->me);
+    if (n < 0)
+        n = total - 1;                 /* "Custom" item */
+
+    for (i = 0; i < total; i++) {
+        int flag = (i == n ? MF_CHECKED : MF_UNCHECKED);
+        CheckMenuItem(fe->typemenu, i, MF_BYPOSITION | flag);
+    }
+
+    DrawMenuBar(fe->hwnd);
+}
+
+static void update_copy_menu_greying(frontend *fe)
+{
+    UINT enable = (midend_can_format_as_text_now(fe->me) ?
+                   MF_ENABLED : MF_GRAYED);
+    EnableMenuItem(fe->gamemenu, IDM_COPY, MF_BYCOMMAND | enable);
+}
+
+static void new_game_type(frontend *fe)
+{
+    midend_new_game(fe->me);
+    new_game_size(fe, 1.0);
+    update_type_menu_tick(fe);
+    update_copy_menu_greying(fe);
+}
+
+static int is_alt_pressed(void)
+{
+    BYTE keystate[256];
+    int r = GetKeyboardState(keystate);
+    if (!r)
+        return FALSE;
+    if (keystate[VK_MENU] & 0x80)
+        return TRUE;
+    if (keystate[VK_RMENU] & 0x80)
+        return TRUE;
+    return FALSE;
+}
+
+static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
+                                WPARAM wParam, LPARAM lParam)
+{
+    frontend *fe = (frontend *)GetWindowLong(hwnd, GWL_USERDATA);
+    int cmd;
+
+    switch (message) {
+      case WM_CLOSE:
+        DestroyWindow(hwnd);
+        return 0;
+      case WM_COMMAND:
+#ifdef _WIN32_WCE
+        /* Numeric pad sends WM_COMMAND messages */
+        if ((wParam >= IDM_KEYEMUL) && (wParam < IDM_KEYEMUL + 256))
+        {
+            midend_process_key(fe->me, 0, 0, wParam - IDM_KEYEMUL);
+        }
+#endif
+        cmd = wParam & ~0xF;           /* low 4 bits reserved to Windows */
+        switch (cmd) {
+          case IDM_NEW:
+            if (!midend_process_key(fe->me, 0, 0, 'n'))
+                PostQuitMessage(0);
+            break;
+          case IDM_RESTART:
+            midend_restart_game(fe->me);
+            break;
+          case IDM_UNDO:
+            if (!midend_process_key(fe->me, 0, 0, 'u'))
+                PostQuitMessage(0);
+            break;
+          case IDM_REDO:
+            if (!midend_process_key(fe->me, 0, 0, '\x12'))
+                PostQuitMessage(0);
+            break;
+          case IDM_COPY:
+            {
+                char *text = midend_text_format(fe->me);
+                if (text)
+                    write_clip(hwnd, text);
+                else
+                    MessageBeep(MB_ICONWARNING);
+                sfree(text);
+            }
+            break;
+          case IDM_SOLVE:
+            {
+                char *msg = midend_solve(fe->me);
+                if (msg)
+                    MessageBox(hwnd, msg, "Unable to solve",
+                               MB_ICONERROR | MB_OK);
+            }
+            break;
+          case IDM_QUIT:
+            if (!midend_process_key(fe->me, 0, 0, 'q'))
+                PostQuitMessage(0);
+            break;
+          case IDM_CONFIG:
+            if (get_config(fe, CFG_SETTINGS))
+                new_game_type(fe);
+            break;
+          case IDM_SEED:
+            if (get_config(fe, CFG_SEED))
+                new_game_type(fe);
+            break;
+          case IDM_DESC:
+            if (get_config(fe, CFG_DESC))
+                new_game_type(fe);
+            break;
+          case IDM_PRINT:
+            if (get_config(fe, CFG_PRINT))
+                print(fe);
+            break;
+          case IDM_ABOUT:
+            about(fe);
+            break;
+          case IDM_LOAD:
+          case IDM_SAVE:
+            {
+                OPENFILENAME of;
+                char filename[FILENAME_MAX];
+                int ret;
+
+                memset(&of, 0, sizeof(of));
+                of.hwndOwner = hwnd;
+                of.lpstrFilter = "All Files (*.*)\0*\0\0\0";
+                of.lpstrCustomFilter = NULL;
+                of.nFilterIndex = 1;
+                of.lpstrFile = filename;
+                filename[0] = '\0';
+                of.nMaxFile = lenof(filename);
+                of.lpstrFileTitle = NULL;
+                of.lpstrTitle = (cmd == IDM_SAVE ?
+                                 "Enter name of game file to save" :
+                                 "Enter name of saved game file to load");
+                of.Flags = 0;
+#ifdef OPENFILENAME_SIZE_VERSION_400
+                of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
+#else
+                of.lStructSize = sizeof(of);
+#endif
+                of.lpstrInitialDir = NULL;
+
+                if (cmd == IDM_SAVE)
+                    ret = GetSaveFileName(&of);
+                else
+                    ret = GetOpenFileName(&of);
+
+                if (ret) {
+                    if (cmd == IDM_SAVE) {
+                        FILE *fp;
+
+                        if ((fp = fopen(filename, "r")) != NULL) {
+                            char buf[256 + FILENAME_MAX];
+                            fclose(fp);
+                            /* file exists */
+
+                            sprintf(buf, "Are you sure you want to overwrite"
+                                    " the file \"%.*s\"?",
+                                    FILENAME_MAX, filename);
+                            if (MessageBox(hwnd, buf, "Question",
+                                           MB_YESNO | MB_ICONQUESTION)
+                                != IDYES)
+                                break;
+                        }
+
+                        fp = fopen(filename, "w");
+
+                        if (!fp) {
+                            MessageBox(hwnd, "Unable to open save file",
+                                       "Error", MB_ICONERROR | MB_OK);
+                            break;
+                        }
+
+                        midend_serialise(fe->me, savefile_write, fp);
+
+                        fclose(fp);
+                    } else {
+                        FILE *fp = fopen(filename, "r");
+                        char *err = NULL;
+                        midend *me = fe->me;
+#ifdef COMBINED
+                        char *id_name;
+#endif
+
+                        if (!fp) {
+                            MessageBox(hwnd, "Unable to open saved game file",
+                                       "Error", MB_ICONERROR | MB_OK);
+                            break;
+                        }
+
+#ifdef COMBINED
+                        /*
+                         * This save file might be from a different
+                         * game.
+                         */
+                        err = identify_game(&id_name, savefile_read, fp);
+                        if (!err) {
+                            int i;
+                            for (i = 0; i < gamecount; i++)
+                                if (!strcmp(id_name, gamelist[i]->name))
+                                    break;
+                            if (i == gamecount) {
+                                err = "Save file is for a game not "
+                                    "supported by this program";
+                            } else {
+                                me = midend_for_new_game(fe, gamelist[i], NULL,
+                                                         FALSE, FALSE, &err);
+                                rewind(fp); /* for the actual load */
+                            }
+                            sfree(id_name);
+                        }
+#endif
+                        if (!err)
+                            err = midend_deserialise(me, savefile_read, fp);
+
+                        fclose(fp);
+
+                        if (err) {
+                            MessageBox(hwnd, err, "Error", MB_ICONERROR|MB_OK);
+                            break;
+                        }
+
+                        if (fe->me != me)
+                            fe_set_midend(fe, me);
+                        new_game_size(fe, 1.0);
+                    }
+                }
+            }
+
+            break;
+#ifndef _WIN32_WCE
+          case IDM_HELPC:
+            start_help(fe, NULL);
+            break;
+          case IDM_GAMEHELP:
+            assert(help_type != NONE);
+            start_help(fe, help_type == CHM ?
+                       fe->game->htmlhelp_topic : fe->game->winhelp_topic);
+            break;
+#endif
+          default:
+#ifdef COMBINED
+            if (wParam >= IDM_GAMES && wParam < (IDM_GAMES + (WPARAM)gamecount)) {
+                int p = wParam - IDM_GAMES;
+                char *error = NULL;
+                fe_set_midend(fe, midend_for_new_game(fe, gamelist[p], NULL,
+                                                      FALSE, FALSE, &error));
+                sfree(error);
+            } else
+#endif
+            {
+                int p = ((wParam &~ 0xF) - IDM_PRESETS) / 0x10;
+
+                if (p >= 0 && p < fe->npresets) {
+                    midend_set_params(fe->me, fe->presets[p]);
+                    new_game_type(fe);
+                }
+            }
+            break;
+        }
+        break;
+      case WM_DESTROY:
+#ifndef _WIN32_WCE
+        stop_help(fe);
+#endif
+        frontend_free(fe);
+        PostQuitMessage(0);
+        return 0;
+      case WM_PAINT:
+        {
+            PAINTSTRUCT p;
+            HDC hdc, hdc2;
+            HBITMAP prevbm;
+            RECT rcDest;
+
+            hdc = BeginPaint(hwnd, &p);
+            hdc2 = CreateCompatibleDC(hdc);
+            prevbm = SelectObject(hdc2, fe->bitmap);
+#ifdef _WIN32_WCE
+            FillRect(hdc, &(p.rcPaint), (HBRUSH) GetStockObject(WHITE_BRUSH));
+#endif
+            IntersectRect(&rcDest, &(fe->bitmapPosition), &(p.rcPaint));
+            BitBlt(hdc,
+                   rcDest.left, rcDest.top,
+                   rcDest.right - rcDest.left,
+                   rcDest.bottom - rcDest.top,
+                   hdc2,
+                   rcDest.left - fe->bitmapPosition.left,
+                   rcDest.top - fe->bitmapPosition.top,
+                   SRCCOPY);
+            SelectObject(hdc2, prevbm);
+            DeleteDC(hdc2);
+            EndPaint(hwnd, &p);
+        }
+        return 0;
+      case WM_KEYDOWN:
+        {
+            int key = -1;
+            BYTE keystate[256];
+            int r = GetKeyboardState(keystate);
+            int shift = (r && (keystate[VK_SHIFT] & 0x80)) ? MOD_SHFT : 0;
+            int ctrl = (r && (keystate[VK_CONTROL] & 0x80)) ? MOD_CTRL : 0;
+
+            switch (wParam) {
+              case VK_LEFT:
+                if (!(lParam & 0x01000000))
+                    key = MOD_NUM_KEYPAD | '4';
+                else
+                    key = shift | ctrl | CURSOR_LEFT;
+                break;
+              case VK_RIGHT:
+                if (!(lParam & 0x01000000))
+                    key = MOD_NUM_KEYPAD | '6';
+                else
+                    key = shift | ctrl | CURSOR_RIGHT;
+                break;
+              case VK_UP:
+                if (!(lParam & 0x01000000))
+                    key = MOD_NUM_KEYPAD | '8';
+                else
+                    key = shift | ctrl | CURSOR_UP;
+                break;
+              case VK_DOWN:
+                if (!(lParam & 0x01000000))
+                    key = MOD_NUM_KEYPAD | '2';
+                else
+                    key = shift | ctrl | CURSOR_DOWN;
+                break;
+                /*
+                 * Diagonal keys on the numeric keypad.
+                 */
+              case VK_PRIOR:
+                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '9';
+                break;
+              case VK_NEXT:
+                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '3';
+                break;
+              case VK_HOME:
+                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '7';
+                break;
+              case VK_END:
+                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '1';
+                break;
+              case VK_INSERT:
+                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '0';
+                break;
+              case VK_CLEAR:
+                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '5';
+                break;
+                /*
+                 * Numeric keypad keys with Num Lock on.
+                 */
+              case VK_NUMPAD4: key = MOD_NUM_KEYPAD | '4'; break;
+              case VK_NUMPAD6: key = MOD_NUM_KEYPAD | '6'; break;
+              case VK_NUMPAD8: key = MOD_NUM_KEYPAD | '8'; break;
+              case VK_NUMPAD2: key = MOD_NUM_KEYPAD | '2'; break;
+              case VK_NUMPAD5: key = MOD_NUM_KEYPAD | '5'; break;
+              case VK_NUMPAD9: key = MOD_NUM_KEYPAD | '9'; break;
+              case VK_NUMPAD3: key = MOD_NUM_KEYPAD | '3'; break;
+              case VK_NUMPAD7: key = MOD_NUM_KEYPAD | '7'; break;
+              case VK_NUMPAD1: key = MOD_NUM_KEYPAD | '1'; break;
+              case VK_NUMPAD0: key = MOD_NUM_KEYPAD | '0'; break;
+            }
+
+            if (key != -1) {
+                if (!midend_process_key(fe->me, 0, 0, key))
+                    PostQuitMessage(0);
+            } else {
+                MSG m;
+                m.hwnd = hwnd;
+                m.message = WM_KEYDOWN;
+                m.wParam = wParam;
+                m.lParam = lParam & 0xdfff;
+                TranslateMessage(&m);
+            }
+        }
+        break;
+      case WM_LBUTTONDOWN:
+      case WM_RBUTTONDOWN:
+      case WM_MBUTTONDOWN:
+        {
+            int button;
+
+            /*
+             * Shift-clicks count as middle-clicks, since otherwise
+             * two-button Windows users won't have any kind of
+             * middle click to use.
+             */
+            if (message == WM_MBUTTONDOWN || (wParam & MK_SHIFT))
+                button = MIDDLE_BUTTON;
+            else if (message == WM_RBUTTONDOWN || is_alt_pressed())
+                button = RIGHT_BUTTON;
+            else
+#ifndef _WIN32_WCE
+                button = LEFT_BUTTON;
+#else
+                if ((fe->game->flags & REQUIRE_RBUTTON) == 0)
+                    button = LEFT_BUTTON;
+                else
+                {
+                    SHRGINFO shrgi;
+
+                    shrgi.cbSize     = sizeof(SHRGINFO);
+                    shrgi.hwndClient = hwnd;
+                    shrgi.ptDown.x   = (signed short)LOWORD(lParam);
+                    shrgi.ptDown.y   = (signed short)HIWORD(lParam);
+                    shrgi.dwFlags    = SHRG_RETURNCMD;
+
+                    if (GN_CONTEXTMENU == SHRecognizeGesture(&shrgi))
+                        button = RIGHT_BUTTON;
+                    else
+                        button = LEFT_BUTTON;
+                }
+#endif
+
+            if (!midend_process_key(fe->me,
+                                    (signed short)LOWORD(lParam) - fe->bitmapPosition.left,
+                                    (signed short)HIWORD(lParam) - fe->bitmapPosition.top,
+                                    button))
+                PostQuitMessage(0);
+
+            SetCapture(hwnd);
+        }
+        break;
+      case WM_LBUTTONUP:
+      case WM_RBUTTONUP:
+      case WM_MBUTTONUP:
+        {
+            int button;
+
+            /*
+             * Shift-clicks count as middle-clicks, since otherwise
+             * two-button Windows users won't have any kind of
+             * middle click to use.
+             */
+            if (message == WM_MBUTTONUP || (wParam & MK_SHIFT))
+                button = MIDDLE_RELEASE;
+            else if (message == WM_RBUTTONUP || is_alt_pressed())
+                button = RIGHT_RELEASE;
+            else
+                button = LEFT_RELEASE;
+
+            if (!midend_process_key(fe->me,
+                                    (signed short)LOWORD(lParam) - fe->bitmapPosition.left,
+                                    (signed short)HIWORD(lParam) - fe->bitmapPosition.top,
+                                    button))
+                PostQuitMessage(0);
+
+            ReleaseCapture();
+        }
+        break;
+      case WM_MOUSEMOVE:
+        {
+            int button;
+
+            if (wParam & (MK_MBUTTON | MK_SHIFT))
+                button = MIDDLE_DRAG;
+            else if (wParam & MK_RBUTTON || is_alt_pressed())
+                button = RIGHT_DRAG;
+            else
+                button = LEFT_DRAG;
+            
+            if (!midend_process_key(fe->me,
+                                    (signed short)LOWORD(lParam) - fe->bitmapPosition.left,
+                                    (signed short)HIWORD(lParam) - fe->bitmapPosition.top,
+                                    button))
+                PostQuitMessage(0);
+        }
+        break;
+      case WM_CHAR:
+        if (!midend_process_key(fe->me, 0, 0, (unsigned char)wParam))
+            PostQuitMessage(0);
+        return 0;
+      case WM_TIMER:
+        if (fe->timer) {
+            DWORD now = GetTickCount();
+            float elapsed = (float) (now - fe->timer_last_tickcount) * 0.001F;
+            midend_timer(fe->me, elapsed);
+            fe->timer_last_tickcount = now;
+        }
+        return 0;
+#ifndef _WIN32_WCE
+      case WM_SIZING:
+        {
+            RECT *sr = (RECT *)lParam;
+            int wx, wy, isedge = 0;
+
+            if (wParam == WMSZ_TOP ||
+                wParam == WMSZ_RIGHT ||
+                wParam == WMSZ_BOTTOM ||
+                wParam == WMSZ_LEFT) isedge = 1;
+            adjust_game_size(fe, sr, isedge, &wx, &wy);
+
+            /* Given the window size the puzzles constrain
+             * us to, work out which edge we should be moving. */
+            if (wParam == WMSZ_TOP ||
+                wParam == WMSZ_TOPLEFT ||
+                wParam == WMSZ_TOPRIGHT) {
+                sr->top = sr->bottom - wy;
+            } else {
+                sr->bottom = sr->top + wy;
+            }
+            if (wParam == WMSZ_LEFT ||
+                wParam == WMSZ_TOPLEFT ||
+                wParam == WMSZ_BOTTOMLEFT) {
+                sr->left = sr->right - wx;
+            } else {
+                sr->right = sr->left + wx;
+            }
+            return TRUE;
+        }
+        break;
+#endif
+    }
+
+    return DefWindowProc(hwnd, message, wParam, lParam);
+}
+
+#ifdef _WIN32_WCE
+static int FindPreviousInstance()
+{
+    /* Check if application is running. If it's running then focus on the window */
+    HWND hOtherWnd = NULL;
+
+    hOtherWnd = FindWindow (wGameName, wGameName);
+    if (hOtherWnd)
+    {
+        SetForegroundWindow (hOtherWnd);
+        return TRUE;
+    }
+
+    return FALSE;
+}
+#endif
+
+/*
+ * Split a complete command line into argc/argv, attempting to do it
+ * exactly the same way the Visual Studio C library would do it (so
+ * that our console utilities, which receive argc and argv already
+ * broken apart by the C library, will have their command lines
+ * processed in the same way as the GUI utilities which get a whole
+ * command line and must call this function).
+ * 
+ * Does not modify the input command line.
+ * 
+ * The final parameter (argstart) is used to return a second array
+ * of char * pointers, the same length as argv, each one pointing
+ * at the start of the corresponding element of argv in the
+ * original command line. So if you get half way through processing
+ * your command line in argc/argv form and then decide you want to
+ * treat the rest as a raw string, you can. If you don't want to,
+ * `argstart' can be safely left NULL.
+ */
+void split_into_argv(char *cmdline, int *argc, char ***argv,
+                     char ***argstart)
+{
+    char *p;
+    char *outputline, *q;
+    char **outputargv, **outputargstart;
+    int outputargc;
+
+    /*
+     * These argument-breaking rules apply to Visual Studio 7, which
+     * is currently the compiler expected to be used for the Windows
+     * port of my puzzles. Visual Studio 10 has different rules,
+     * lacking the curious mod 3 behaviour of consecutive quotes
+     * described below; I presume they fixed a bug. As and when we
+     * migrate to a newer compiler, we'll have to adjust this to
+     * match; however, for the moment we faithfully imitate in our GUI
+     * utilities what our CLI utilities can't be prevented from doing.
+     *
+     * When I investigated this, at first glance the rules appeared to
+     * be:
+     *
+     *  - Single quotes are not special characters.
+     *
+     *  - Double quotes are removed, but within them spaces cease
+     *    to be special.
+     *
+     *  - Backslashes are _only_ special when a sequence of them
+     *    appear just before a double quote. In this situation,
+     *    they are treated like C backslashes: so \" just gives a
+     *    literal quote, \\" gives a literal backslash and then
+     *    opens or closes a double-quoted segment, \\\" gives a
+     *    literal backslash and then a literal quote, \\\\" gives
+     *    two literal backslashes and then opens/closes a
+     *    double-quoted segment, and so forth. Note that this
+     *    behaviour is identical inside and outside double quotes.
+     *
+     *  - Two successive double quotes become one literal double
+     *    quote, but only _inside_ a double-quoted segment.
+     *    Outside, they just form an empty double-quoted segment
+     *    (which may cause an empty argument word).
+     *
+     *  - That only leaves the interesting question of what happens
+     *    when one or more backslashes precedes two or more double
+     *    quotes, starting inside a double-quoted string. And the
+     *    answer to that appears somewhat bizarre. Here I tabulate
+     *    number of backslashes (across the top) against number of
+     *    quotes (down the left), and indicate how many backslashes
+     *    are output, how many quotes are output, and whether a
+     *    quoted segment is open at the end of the sequence:
+     * 
+     *                      backslashes
+     * 
+     *               0         1      2      3      4
+     * 
+     *         0   0,0,y  |  1,0,y  2,0,y  3,0,y  4,0,y
+     *            --------+-----------------------------
+     *         1   0,0,n  |  0,1,y  1,0,n  1,1,y  2,0,n
+     *    q    2   0,1,n  |  0,1,n  1,1,n  1,1,n  2,1,n
+     *    u    3   0,1,y  |  0,2,n  1,1,y  1,2,n  2,1,y
+     *    o    4   0,1,n  |  0,2,y  1,1,n  1,2,y  2,1,n
+     *    t    5   0,2,n  |  0,2,n  1,2,n  1,2,n  2,2,n
+     *    e    6   0,2,y  |  0,3,n  1,2,y  1,3,n  2,2,y
+     *    s    7   0,2,n  |  0,3,y  1,2,n  1,3,y  2,2,n
+     *         8   0,3,n  |  0,3,n  1,3,n  1,3,n  2,3,n
+     *         9   0,3,y  |  0,4,n  1,3,y  1,4,n  2,3,y
+     *        10   0,3,n  |  0,4,y  1,3,n  1,4,y  2,3,n
+     *        11   0,4,n  |  0,4,n  1,4,n  1,4,n  2,4,n
+     * 
+     * 
+     *      [Test fragment was of the form "a\\\"""b c" d.]
+     * 
+     * There is very weird mod-3 behaviour going on here in the
+     * number of quotes, and it even applies when there aren't any
+     * backslashes! How ghastly.
+     * 
+     * With a bit of thought, this extremely odd diagram suddenly
+     * coalesced itself into a coherent, if still ghastly, model of
+     * how things work:
+     * 
+     *  - As before, backslashes are only special when one or more
+     *    of them appear contiguously before at least one double
+     *    quote. In this situation the backslashes do exactly what
+     *    you'd expect: each one quotes the next thing in front of
+     *    it, so you end up with n/2 literal backslashes (if n is
+     *    even) or (n-1)/2 literal backslashes and a literal quote
+     *    (if n is odd). In the latter case the double quote
+     *    character right after the backslashes is used up.
+     * 
+     *  - After that, any remaining double quotes are processed. A
+     *    string of contiguous unescaped double quotes has a mod-3
+     *    behaviour:
+     * 
+     *     * inside a quoted segment, a quote ends the segment.
+     *     * _immediately_ after ending a quoted segment, a quote
+     *       simply produces a literal quote.
+     *     * otherwise, outside a quoted segment, a quote begins a
+     *       quoted segment.
+     * 
+     *    So, for example, if we started inside a quoted segment
+     *    then two contiguous quotes would close the segment and
+     *    produce a literal quote; three would close the segment,
+     *    produce a literal quote, and open a new segment. If we
+     *    started outside a quoted segment, then two contiguous
+     *    quotes would open and then close a segment, producing no
+     *    output (but potentially creating a zero-length argument);
+     *    but three quotes would open and close a segment and then
+     *    produce a literal quote.
+     */
+
+    /*
+     * First deal with the simplest of all special cases: if there
+     * aren't any arguments, return 0,NULL,NULL.
+     */
+    while (*cmdline && isspace(*cmdline)) cmdline++;
+    if (!*cmdline) {
+        if (argc) *argc = 0;
+        if (argv) *argv = NULL;
+        if (argstart) *argstart = NULL;
+        return;
+    }
+
+    /*
+     * This will guaranteeably be big enough; we can realloc it
+     * down later.
+     */
+    outputline = snewn(1+strlen(cmdline), char);
+    outputargv = snewn(strlen(cmdline)+1 / 2, char *);
+    outputargstart = snewn(strlen(cmdline)+1 / 2, char *);
+
+    p = cmdline; q = outputline; outputargc = 0;
+
+    while (*p) {
+        int quote;
+
+        /* Skip whitespace searching for start of argument. */
+        while (*p && isspace(*p)) p++;
+        if (!*p) break;
+
+        /* We have an argument; start it. */
+        outputargv[outputargc] = q;
+        outputargstart[outputargc] = p;
+        outputargc++;
+        quote = 0;
+
+        /* Copy data into the argument until it's finished. */
+        while (*p) {
+            if (!quote && isspace(*p))
+                break;                 /* argument is finished */
+
+            if (*p == '"' || *p == '\\') {
+                /*
+                 * We have a sequence of zero or more backslashes
+                 * followed by a sequence of zero or more quotes.
+                 * Count up how many of each, and then deal with
+                 * them as appropriate.
+                 */
+                int i, slashes = 0, quotes = 0;
+                while (*p == '\\') slashes++, p++;
+                while (*p == '"') quotes++, p++;
+
+                if (!quotes) {
+                    /*
+                     * Special case: if there are no quotes,
+                     * slashes are not special at all, so just copy
+                     * n slashes to the output string.
+                     */
+                    while (slashes--) *q++ = '\\';
+                } else {
+                    /* Slashes annihilate in pairs. */
+                    while (slashes >= 2) slashes -= 2, *q++ = '\\';
+
+                    /* One remaining slash takes out the first quote. */
+                    if (slashes) quotes--, *q++ = '"';
+
+                    if (quotes > 0) {
+                        /* Outside a quote segment, a quote starts one. */
+                        if (!quote) quotes--, quote = 1;
+
+                        /* Now we produce (n+1)/3 literal quotes... */
+                        for (i = 3; i <= quotes+1; i += 3) *q++ = '"';
+
+                        /* ... and end in a quote segment iff 3 divides n. */
+                        quote = (quotes % 3 == 0);
+                    }
+                }
+            } else {
+                *q++ = *p++;
+            }
+        }
+
+        /* At the end of an argument, just append a trailing NUL. */
+        *q++ = '\0';
+    }
+
+    outputargv = sresize(outputargv, outputargc, char *);
+    outputargstart = sresize(outputargstart, outputargc, char *);
+
+    if (argc) *argc = outputargc;
+    if (argv) *argv = outputargv; else sfree(outputargv);
+    if (argstart) *argstart = outputargstart; else sfree(outputargstart);
+}
+
+int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
+{
+    MSG msg;
+    char *error;
+    const game *gg;
+    frontend *fe;
+    midend *me;
+    int argc;
+    char **argv;
+
+    split_into_argv(cmdline, &argc, &argv, NULL);
+
+#ifdef _WIN32_WCE
+    MultiByteToWideChar (CP_ACP, 0, CLASSNAME, -1, wClassName, 256);
+    if (FindPreviousInstance ())
+        return 0;
+#endif
+
+    InitCommonControls();
+
+    if (!prev) {
+        WNDCLASS wndclass;
+
+        wndclass.style = 0;
+        wndclass.lpfnWndProc = WndProc;
+        wndclass.cbClsExtra = 0;
+        wndclass.cbWndExtra = 0;
+        wndclass.hInstance = inst;
+        wndclass.hIcon = LoadIcon(inst, MAKEINTRESOURCE(200));
+#ifndef _WIN32_WCE
+        if (!wndclass.hIcon)           /* in case resource file is absent */
+            wndclass.hIcon = LoadIcon(inst, IDI_APPLICATION);
+#endif
+        wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
+        wndclass.hbrBackground = NULL;
+        wndclass.lpszMenuName = NULL;
+#ifdef _WIN32_WCE
+        wndclass.lpszClassName = wClassName;
+#else
+        wndclass.lpszClassName = CLASSNAME;
+#endif
+
+        RegisterClass(&wndclass);
+    }
+
+    while (*cmdline && isspace((unsigned char)*cmdline))
+        cmdline++;
+
+    init_help();
+
+#ifdef COMBINED
+    gg = gamelist[0];
+    if (argc > 0) {
+        int i;
+        for (i = 0; i < gamecount; i++) {
+            const char *p = gamelist[i]->name;
+            char *q = argv[0];
+            while (*p && *q) {
+                if (isspace((unsigned char)*p)) {
+                    while (*q && isspace((unsigned char)*q))
+                        q++;
+                } else {
+                    if (tolower((unsigned char)*p) !=
+                        tolower((unsigned char)*q))
+                        break;
+                    q++;
+                }
+                p++;
+            }
+            if (!*p) {
+                gg = gamelist[i];
+                --argc;
+                ++argv;
+                break;
+            }
+        }
+    }
+#else
+    gg = &thegame;
+#endif
+
+    fe = frontend_new(inst);
+    me = midend_for_new_game(fe, gg, argc > 0 ? argv[0] : NULL,
+                             TRUE, TRUE, &error);
+    if (!me) {
+        char buf[128];
+#ifdef COMBINED
+        sprintf(buf, "Puzzles Error");
+#else
+        sprintf(buf, "%.100s Error", gg->name);
+#endif
+        MessageBox(NULL, error, buf, MB_OK|MB_ICONERROR);
+        sfree(error);
+        return 1;
+    }
+    fe_set_midend(fe, me);
+    show_window(fe);
+
+    while (GetMessage(&msg, NULL, 0, 0)) {
+        DispatchMessage(&msg);
+    }
+
+    DestroyWindow(fe->hwnd);
+    cleanup_help();
+
+    return msg.wParam;
+}
+/* vim: set shiftwidth=4 tabstop=8: */
diff --git a/apps/plugins/puzzles/winiss.pl b/apps/plugins/puzzles/winiss.pl
new file mode 100755
index 0000000000..eca02d3b15
--- /dev/null
+++ b/apps/plugins/puzzles/winiss.pl
@@ -0,0 +1,79 @@
+#!/usr/bin/perl
+
+# Perl script to generate an Inno Setup installer script for
+# Puzzles. This has to be scripted so that it can read gamedesc.txt
+# and automatically adjust to the current available set of puzzles.
+
+# Usage:
+#
+#   $ ./winiss.pl 20140922.sdfsdf gamedesc.txt > puzzles.iss
+#
+# where the first argument is the version number which will be encoded
+# in the installer's version indicators. The first component of that
+# version number will be expected to be a YYYYMMDD-format date.
+
+use warnings;
+use Time::Local;
+
+$ver = shift @ARGV;
+
+# Parse the date out of $ver, and convert it into an integer number of
+# days since an arbitrary epoch. This number is used for the Windows
+# version resource (which wants a monotonic 16-bit integer). The epoch
+# is chosen so that the first build using this date-based mechanism
+# has a higher number than the last build in which that number was
+# derived from a Subversion revision.
+die "bad date format" if $ver !~ /^(\d{4})(\d{2})(\d{2})/;
+$date = timegm(0,0,0,$3,$2-1,$1);
+$integer_date = int($date / 86400) - 6000;
+
+$desc = shift @ARGV;
+open DESC, "<", $desc;
+while (<DESC>) {
+    chomp;
+    @_ = split /:/;
+    push @exes, $_[1];
+    $names{$_[1]} = $_[2];
+}
+close DESC;
+
+print '; -*- no -*-'."\n";
+print ';'."\n";
+print '; -- Inno Setup installer script for Puzzles.'."\n";
+print ''."\n";
+print '[Setup]'."\n";
+print 'AppName=Simon Tatham\'s Portable Puzzle Collection'."\n";
+print 'AppVerName=Puzzles version '.$ver."\n";
+print 'VersionInfoTextVersion=Version '.$ver."\n";
+print 'AppVersion=r'.$ver."\n";
+print 'VersionInfoVersion=0.0.'.$integer_date.'.0'."\n";
+print 'AppPublisher=Simon Tatham'."\n";
+print 'AppPublisherURL=http://www.chiark.greenend.org.uk/~sgtatham/puzzles/'."\n";
+print 'DefaultDirName={pf}\Simon Tatham\'s Portable Puzzle Collection'."\n";
+print 'DefaultGroupName=Simon Tatham\'s Puzzles'."\n";
+# print 'SetupIconFile=fixmethinkoneup.ico'."\n";
+# print 'UninstallDisplayIcon={app}\fixmethinkoneup.exe'."\n";
+print 'ChangesAssociations=no'."\n";
+print 'Compression=zip/9'."\n";
+print 'AllowNoIcons=yes'."\n";
+print 'OutputBaseFilename=installer'."\n";
+print ''."\n";
+print '[Files]'."\n";
+for $exe (@exes) {
+    print 'Source: "'.$exe.'"; DestDir: "{app}"; Flags: promptifolder replacesameversion uninsrestartdelete'."\n";
+}
+print 'Source: "website.url"; DestDir: "{app}"; Flags: uninsrestartdelete'."\n";
+print 'Source: "puzzles.chm"; DestDir: "{app}"; Flags: uninsrestartdelete'."\n";
+print 'Source: "puzzles.hlp"; DestDir: "{app}"; Flags: uninsrestartdelete'."\n";
+print 'Source: "puzzles.cnt"; DestDir: "{app}"; Flags: uninsrestartdelete'."\n";
+print 'Source: "LICENCE"; DestDir: "{app}"; Flags: uninsrestartdelete'."\n";
+print ''."\n";
+print '[Icons]'."\n";
+for $exe (@exes) {
+    print 'Name: "{group}\\'.$names{$exe}.'"; Filename: "{app}\\'.$exe.'"'."\n";
+}
+print '; We have to fall back from the .chm to the older .hlp file on some Windows'."\n";
+print '; versions.'."\n";
+print 'Name: "{group}\Puzzles Manual"; Filename: "{app}\puzzles.chm"; MinVersion: 4.1,5.0'."\n";
+print 'Name: "{group}\Puzzles Manual"; Filename: "{app}\puzzles.hlp"; OnlyBelowVersion: 4.1,5.0'."\n";
+print 'Name: "{group}\Puzzles Web Site"; Filename: "{app}\website.url"'."\n";
diff --git a/apps/plugins/puzzles/winwix.mc b/apps/plugins/puzzles/winwix.mc
new file mode 100644
index 0000000000..1a1e620b82
--- /dev/null
+++ b/apps/plugins/puzzles/winwix.mc
@@ -0,0 +1,334 @@
+% # Source code for the Puzzles installer.
+% #
+% # The installer is built using WiX, but this file itself is not valid
+% # XML input to WiX's candle.exe; instead, this is a template intended
+% # to be processed through the standalone 'mason.pl' script provided
+% # with Perl's Mason module.
+
+<%class>
+has 'version' => (required => 1);
+has 'descfile' => (required => 1);
+</%class>
+
+<?xml version="1.0" encoding="utf-8"?>
+
+<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
+
+% # Product tag. The Id component is set to "*", which causes WiX to
+% # make up a new GUID every time it's run, whereas UpgradeCode is set
+% # to a fixed GUID. This combination allows Windows to
+% # recognise each new installer as different (because of Id)
+% # versions of the same underlying thing (because of the common
+% # UpgradeCode).
+  <Product
+      Name="Simon Tatham's Portable Puzzle Collection"
+      Manufacturer="Simon Tatham"
+      Id="*"
+      UpgradeCode="<% invent_guid('upgradecode') %>"
+      Language="1033" Codepage="1252" Version="<% $winver %>">
+
+% # We force the install scope to perMachine, largely because I
+% # don't really understand how to make it usefully switchable
+% # between the two. If anyone is a WiX expert and does want to
+% # install Puzzles locally in a user account, I hope they'll send a
+% # well explained patch!
+    <Package Id="*" Keywords="Installer"
+             Description="Simon Tatham's Portable Puzzle Collection installer, version <% $.version %>"
+             Manufacturer="Simon Tatham"
+             InstallerVersion="100" Languages="1033"
+             Compressed="yes" SummaryCodepage="1252"
+             InstallScope="perMachine" />
+
+% # Permit installing an arbitrary one of these installers
+% # over the top of an existing one, whether it's an upgrade or a
+% # downgrade.
+% # 
+% # Setting the REINSTALLMODE property to "amus" (from its default
+% # of "omus") forces every component replaced by a different
+% # version of the installer to be _actually_ reinstalled; the 'o'
+% # flag in the default setting breaks the downgrade case by
+% # causing Windows to disallow installation of an older version
+% # over the top of a newer one - and to do so _silently_, so the
+% # installer claims to have worked fine but the files that would have
+% # been downgraded aren't there.
+    <MajorUpgrade AllowDowngrades="yes" MigrateFeatures="yes" />
+    <Property Id="REINSTALLMODE" Value="amus"/>
+
+% # Boilerplate
+    <Media Id="1" Cabinet="puzzles.cab" EmbedCab="yes" />
+
+% # The actual directory structure and list of 'components'
+% # (individual files or shortcuts or additions to PATH) that are
+% # installed.
+    <Directory Id="TARGETDIR" Name="SourceDir">
+      <Directory Id="ProgramFilesFolder" Name="PFiles">
+        <Directory Id="INSTALLDIR" Name="Simon Tatham's Portable Puzzle Collection">
+
+% # The following components all install things in the main
+% # install directory (implicitly, by being nested where
+% # they are in the XML structure). Most of them also put a
+% # shortcut in a subdir of the Start menu, though some of
+% # the more obscure things like LICENCE are just there for
+% # the sake of being _somewhere_ and don't rate a shortcut.
+
+<%method file_component ($filename, $shortcutname)>
+% my $filename_id = file_component_name($filename);
+<Component Id="File_Component_<% $filename_id %>"
+    Guid="<% invent_guid('file:' . $filename) %>">
+  <File Id="File_<% $filename_id %>"
+        Source="<% $filename %>" KeyPath="yes">
+% if (defined $shortcutname) {
+    <Shortcut Id="startmenu_<% $filename_id %>"
+              Directory="ProgramMenuDir" WorkingDirectory="INSTALLDIR"
+              Name="<% $shortcutname %>" Advertise="no" />
+% }
+  </File>
+</Component>
+</%method>
+
+% for my $exe (@exes) {
+<% $.file_component($exe, $names{$exe}) %>
+% }
+
+<% $.file_component("puzzles.chm", "Puzzles Manual") %>
+<% $.file_component("website.url", "Puzzles Web Site") %>
+<% $.file_component("LICENCE") %>
+
+        </Directory>
+      </Directory>
+
+% # This component doesn't actually install anything, but it
+% # arranges for the Start Menu _directory_ to be removed again
+% # on uninstall. All the actual shortcuts inside the directory
+% # are placed by code above here.
+      <Directory Id="ProgramMenuFolder" Name="Programs">
+        <Directory Id="ProgramMenuDir" Name="Simon Tatham's Portable Puzzle Collection">
+          <Component Id="ProgramMenuDir"
+                     Guid="<% invent_guid('programmenudir') %>">
+            <RemoveFolder Id="ProgramMenuDir" On="uninstall" />
+            <RegistryValue Root="HKLM"
+                           Key="Software\SimonTatham\Puzzles\StartMenu"
+                           Type="string" Value="" KeyPath="yes" />
+          </Component>
+        </Directory>
+      </Directory>
+    </Directory>
+
+% # Detect an installation of Puzzles made by the old Inno Setup
+% # installer, and refuse to run if we find one. I don't know what
+% # would happen if you tried anyway, but since they install files
+% # at the same pathnames, it surely wouldn't end well.
+% # 
+% # It could be argued that a better approach would be to actually
+% # _launch_ the Inno Setup uninstaller automatically at this
+% # point (prompting the user first, of course), but I'm not
+% # nearly skilled enough with WiX to know how, or even if it's
+% # feasible.
+    <Property Id="LEGACYINNOSETUPINSTALLERNATIVE32PROPERTY">
+      <RegistrySearch
+          Id="LegacyInnoSetupInstallerNative32RegSearch"
+          Root="HKLM"
+          Key="SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Simon Tatham's Portable Puzzle Collection_is1"
+          Name="QuietUninstallString" Type="raw" />
+    </Property>
+    <Property Id="LEGACYINNOSETUPINSTALLER32ON64PROPERTY">
+      <RegistrySearch
+          Id="LegacyInnoSetupInstaller32On64RegSearch"
+          Root="HKLM"
+          Key="SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\Simon Tatham's Portable Puzzle Collection_is1"
+          Name="QuietUninstallString" Type="raw" />
+    </Property>
+    <Condition Message="A version of this software is already installed on this system using its old Inno Setup installer. Please uninstall that before running the new installer.">
+      <![CDATA[Installed OR
+               (LEGACYINNOSETUPINSTALLERNATIVE32PROPERTY = "" AND
+                LEGACYINNOSETUPINSTALLER32ON64PROPERTY = "")]]>
+    </Condition>
+
+% # Separate the installation into 'features', which are parts of
+% # the install that can be chosen separately. Trivial: there is only
+% # one feature here.
+    <Feature Id="FilesFeature" Level="1" Absent="disallow" AllowAdvertise="no"
+             Title="Install puzzle games">
+% for my $exe (@exes) {
+      <ComponentRef Id="File_Component_<% file_component_name($exe) %>" />
+% }
+      <ComponentRef Id="File_Component_<% file_component_name("puzzles.chm") %>" />
+      <ComponentRef Id="File_Component_<% file_component_name("website.url") %>" />
+      <ComponentRef Id="File_Component_<% file_component_name("LICENCE") %>" />
+      <ComponentRef Id="ProgramMenuDir" />
+    </Feature>
+
+% # Installer user interface.
+% # 
+% # Basically like WixUI_InstallDir, only I've ripped out the EULA.
+    <UIRef Id="WixUI_Common" />
+
+    <UI>
+      <TextStyle Id="WixUI_Font_Normal" FaceName="Tahoma" Size="8" />
+      <TextStyle Id="WixUI_Font_Bigger" FaceName="Tahoma" Size="12" />
+      <TextStyle Id="WixUI_Font_Title" FaceName="Tahoma" Size="9" Bold="yes" />
+
+      <Property Id="DefaultUIFont" Value="WixUI_Font_Normal" />
+      <Property Id="WixUI_Mode" Value="InstallDir" />
+
+      <DialogRef Id="BrowseDlg" />
+      <DialogRef Id="DiskCostDlg" />
+      <DialogRef Id="ErrorDlg" />
+      <DialogRef Id="FatalError" />
+      <DialogRef Id="FilesInUse" />
+      <DialogRef Id="MsiRMFilesInUse" />
+      <DialogRef Id="PrepareDlg" />
+      <DialogRef Id="ProgressDlg" />
+      <DialogRef Id="ResumeDlg" />
+      <DialogRef Id="UserExit" />
+
+      <Publish Dialog="BrowseDlg" Control="OK" Event="DoAction" Value="WixUIValidatePath" Order="3">1</Publish>
+      <Publish Dialog="BrowseDlg" Control="OK" Event="SpawnDialog" Value="InvalidDirDlg" Order="4"><![CDATA[NOT WIXUI_DONTVALIDATEPATH AND WIXUI_INSTALLDIR_VALID<>"1"]]></Publish>
+
+      <Publish Dialog="ExitDialog" Control="Finish" Event="EndDialog" Value="Return" Order="999">1</Publish>
+
+      <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="InstallDirDlg">NOT Installed</Publish>
+      <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg">Installed</Publish>
+
+      <Publish Dialog="InstallDirDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg">1</Publish>
+      <Publish Dialog="InstallDirDlg" Control="Next" Event="SetTargetPath" Value="[WIXUI_INSTALLDIR]" Order="1">1</Publish>
+      <Publish Dialog="InstallDirDlg" Control="Next" Event="DoAction" Value="WixUIValidatePath" Order="2">NOT WIXUI_DONTVALIDATEPATH</Publish>
+      <Publish Dialog="InstallDirDlg" Control="Next" Event="SpawnDialog" Value="InvalidDirDlg" Order="3"><![CDATA[NOT WIXUI_DONTVALIDATEPATH AND WIXUI_INSTALLDIR_VALID<>"1"]]></Publish>
+      <Publish Dialog="InstallDirDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg" Order="4">WIXUI_DONTVALIDATEPATH OR WIXUI_INSTALLDIR_VALID="1"</Publish>
+      <Publish Dialog="InstallDirDlg" Control="ChangeFolder" Property="_BrowseProperty" Value="[WIXUI_INSTALLDIR]" Order="1">1</Publish>
+      <Publish Dialog="InstallDirDlg" Control="ChangeFolder" Event="SpawnDialog" Value="BrowseDlg" Order="2">1</Publish>
+
+      <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="InstallDirDlg" Order="1">NOT Installed</Publish>
+      <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="MaintenanceTypeDlg" Order="2">Installed AND NOT PATCH</Publish>
+      <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg" Order="2">Installed AND PATCH</Publish>
+
+      <Publish Dialog="MaintenanceWelcomeDlg" Control="Next" Event="NewDialog" Value="MaintenanceTypeDlg">1</Publish>
+
+      <Publish Dialog="MaintenanceTypeDlg" Control="RepairButton" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>
+      <Publish Dialog="MaintenanceTypeDlg" Control="RemoveButton" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>
+      <Publish Dialog="MaintenanceTypeDlg" Control="Back" Event="NewDialog" Value="MaintenanceWelcomeDlg">1</Publish>
+
+% # This ARPNOMODIFY flag prohibits changing the set of
+% # installed features, because we don't have any.
+      <Property Id="ARPNOMODIFY" Value="1" />
+    </UI>
+
+% # Glue: tell the install dir part of the UI what id my actual
+% # install dir is known by. Otherwise the former won't know how
+% # to alter the setting of the latter.
+    <Property Id="WIXUI_INSTALLDIR" Value="INSTALLDIR" />
+
+% # Include my custom installer artwork, created in Buildscr. FIXME:
+% # create some!
+% #    <WixVariable Id="WixUIDialogBmp" Value="msidialog.bmp" />
+% #    <WixVariable Id="WixUIBannerBmp" Value="msibanner.bmp" />
+
+  </Product>
+</Wix>
+
+<%init>
+
+use Digest::SHA qw(sha512_hex);
+use Time::Local;
+
+die "bad date format" if $.version !~ /^(\d{4})(\d{2})(\d{2})/;
+my $date = timegm(0,0,0,$3,$2-1,$1);
+my $integer_date = int($date / 86400) - 6000;
+my $winver = sprintf "0.0.%d.0", $integer_date;
+
+my @exes;
+my %names;
+{
+    open my $descfh, "<", $.descfile or die "$.descfile: open: $!\n";
+    while (<$descfh>) {
+        chomp;
+        my @fields = split /:/;
+        push @exes, $fields[1];
+        $names{$fields[1]} = $fields[2];
+    }
+    close $descfh;
+}
+
+sub file_component_name($) {
+    my ($id) = @_;
+    $id =~ s!.*\\!!;
+    $id =~ y!A-Za-z0-9!_!cs;
+    return $id;
+}
+
+sub invent_guid($) {
+    my ($name) = @_;
+
+    # Invent a GUID. We'll need a lot of these in this installer - one
+    # per puzzle game and a few standard ones - and we'd like to
+    # arrange for them to be stable between versions of the installer,
+    # while not having to _manually_ invent one every time.
+    #
+    # So we generate our GUIDs by hashing a pile of fixed (but
+    # originally randomly generated) data with an identifying string
+    # that acts as source for the particular GUID. For example,
+    # hashing (fixed_random_data || "upgradecode") produces the GUID
+    # used as the upgrade code, and (fixed_random_data ||
+    # "installfile:" || filename) gives the GUID for an MSI component
+    # that installs a specific file.
+    #
+    # Hashing _just_ the id strings would clearly be cheating (it's
+    # quite conceivable that someone might hash the same string for
+    # another reason and so generate a colliding GUID), but hashing a
+    # whole SHA-512 data block of random gibberish as well should make
+    # these GUIDs pseudo-random enough to not collide with anyone
+    # else's.
+
+    my $randdata = pack "N*",
+    0xCCAA8D31,0x42931BD9,0xA9D9878A,0x72E4FB9C,0xEA9B11DE,0x4FF17AEC,
+    0x1AFA2DEC,0xB662640A,0x780143F5,0xBFFFF0FC,0x01CB46CF,0x832AE842,
+    0xBCCDDA12,0x4DB24889,0xEC7A9BCD,0xBCCF70ED,0x85800659,0x8ABA9524,
+    0xE484F8D6,0x5CBE55B3,0x95AD9B3D,0x0555F432,0x46737F89,0xE981471C,
+    0x4B3419AD,0xD4E49DF4,0xB3EF69DE,0x2A7E391E,0xF3C3D370,0x3EA5E9FC,
+    0xB35A57ED,0x52B21099,0x9BD99092,0x7B5097AE,0x4DBE59BD,0x2FCC709B,
+    0xC555A779,0x4AE2E5AB,0xB7C74314,0x7F9194CF,0x8FFBCA88,0x46263306,
+    0x4C714DF7,0x07FE8CEE,0x28974885,0x0869865D,0xBB5B0EA4,0x4064A928,
+    0x28C41910,0x07030758,0x19E66319,0x050C9D4E,0xD79A37FB,0xF232D98B,
+    0x0C3E4C25,0xC94F865B,0xB6D86BED,0x87DB718D,0xC65D4C43,0x7C8BBF6A,
+    0x9DFDD26A,0x8C478976,0x53E47640,0x263E04AA,0xDD7C5456,0x766BDF50,
+    0x86946E34,0xE80D8DE3,0xFB92949E,0x691FDAD0,0x96AB210D,0xB278D60B,
+    0x71C7DC6B,0xD49846FC,0x38953F66,0x39777D72,0x4A0F80E5,0xFE1DD1A4,
+    0xDA9D191A,0xA32844AD,0x171BFBCC,0xA7D556F6,0xF9F6D944,0xF9687060,
+    0xDDDB81D0,0xE9AF4F2F,0xEF84685A,0x8A172492,0x50615EFC,0x20817881,
+    0xC3E507E5,0x33189771,0xB9E2EBBD,0x2AAE34A3,0x8D3E7486,0x0A448F13,
+    0x94F92A81,0x5150A34F,0x5ED50563,0xAD801A42,0xD0617AFA,0xB78F85F7,
+    0x0019D384,0xF0F1C06F,0x6EF8D5B3,0x38092D09,0xC87CD4B3,0xE9D8C84F,
+    0xE036648C,0xF2500BD9,0xCF069B5C,0x835326BA,0xCD107B6A,0x64F152B3,
+    0xA9663E24,0x33ED5E08,0xC3B24F7E,0xA83205C8,0xA0560F30,0xDFF1226E,
+    0xF1A404B7,0x9C2B4EF2,0x62802F88,0xE393A05F,0xC7F72F7B,0x1CD989BD,
+    0x725AB516,0xA84F7E39,0xACC3572A,0x820ACB2D,0xAFF5BF06,0x476A2405,
+    0x90953482,0x8E8035E1,0x1FB95F6E,0x01FD6766,0x1E63D78E,0xD7D42220,
+    0x188D23E4,0x1941BCC5,0xEE1E6487,0x6E197F82,0x32772265,0x9B79D0C8,
+    0xB4B617A1,0xCD2475B4,0xDE0F410B,0xE9CF69E4,0x831AC9A4,0xD549A00E,
+    0x12ECC561,0x3D636A43,0x1FFFC99A,0xF79401C5,0xAA1D8251,0x84D29609,
+    0x5464CB71,0xB28AAE5A,0x4AD934FC,0x347E8A5D,0xC87BCBA0,0x67172E33,
+    0xEC70E245,0x4289A9EF,0xA8AF6BA5,0x1528FE0C,0xA87CBFF8,0x79AE1554,
+    0xBD59DB9E,0xF1879F94,0x14D7E9F6,0x85196447,0xC4363A67,0x7E02A325,
+    0x54051E05,0xABAFE646,0x65D5DF96,0xD3F8173B,0x09D475E7,0x9BF7BD0C,
+    0x2DAF371A,0x793D063C,0xA68FD47B,0xBE2500A7,0x0D5071C4,0x08384AC8,
+    0xF6CFE74E,0x124A5086,0x03475917,0x47267765,0x56F7DF31,0xE5696381,
+    0xEB2B4668,0x78345B5B,0x6E2AFC0F,0x3AD0D43B,0x5C3C2BC9,0x833AB4A0,
+    0x1DE2CDBF,0x4DDDCF58,0xEA25D69B,0x36E9B3B0,0xC8B11465,0x066A997E,
+    0x9D51C7CD,0x8C6AE686,0xAFB06CE6,0xCC3F3017,0x6E4E4CC0,0x85A34875,
+    0x498FE759,0xC24B6332,0xEBCD2257,0xE70FC659,0x439EC788,0xB47F2A06,
+    0x696EE8A7,0xF70A31B8,0xECD840F7,0x80AE5E7A,0xC6EDF8AE,0x8165EAFD,
+    0x5DAE5ADE,0x9FFD39CE,0xFC6B4C23,0x02BCA024,0xC1497A68,0xD18153EF,
+    0xD787EA51,0x91386720,0xBF6E2200,0x98638391,0x144B9148,0x9A554DE1,
+    0xA940DC7F,0x37C08265,0x7B782C60,0xC081FDD7,0x62B47201,0x43427563,
+    0x1B66E983,0x3DAC0305,0x21E9DEA8,0xA9490EE0,0xE2EFD37D,0x3501F306,
+    0x16361BD5,0x668B219D,0x17177844,0x3861A9A4,0x222403B2,0xB29F6714,
+    0x7A2A938A,0xBC797418,0x3B241624,0x9163C3F2;
+    my $digest = sha512_hex($name . "\0" . $randdata);
+    return sprintf("%s-%s-%04x-%04x-%s",
+                   substr($digest,0,8),
+                   substr($digest,8,4),
+                   0x4000 | (0xFFF & hex(substr($digest,12,4))),
+                   0x8000 | (0x3FFF & hex(substr($digest,16,4))),
+                   substr($digest,20,12));
+}
+</%init>
diff --git a/apps/plugins/sgt-puzzles.c b/apps/plugins/sgt-puzzles.c
new file mode 100644
index 0000000000..082e5b4cd1
--- /dev/null
+++ b/apps/plugins/sgt-puzzles.c
@@ -0,0 +1,33 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2009 Franklin Wei
+ *
+ * Overlay loader stub plugin for puzzles
+ *
+ * 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+#include "plugin.h"
+
+#include "lib/overlay.h"
+
+
+
+/* this is the plugin entry point */
+enum plugin_status plugin_start(const void* parameter)
+{
+    return run_overlay(parameter, PLUGIN_GAMES_DIR "/puzzles.ovl", "Puzzles");
+}