puzzles: add Slide and Sokoban.

This enables two of the "unfinished" puzzles. Slide requires a new "sticky
mouse mode" to enable dragging. The help system is disabled for these
puzzles, since they lack manual chapters.

Group is currently unplayable due to lack of request_keys() support, which
will need to be added upstream. Separate fails to draw anything.

Change-Id: I7bcff3679ac5b10b0f39c5eaa19a36b4b1fe8d53

58 files changed, 9698 insertions, 26 deletions

diff --git a/apps/plugins/puzzles/SOURCES b/apps/plugins/puzzles/SOURCES
index f0d2ed27f7..dfbd184ba2 100644
--- a/apps/plugins/puzzles/SOURCES
+++ b/apps/plugins/puzzles/SOURCES
@@ -3,6 +3,7 @@ rockbox.c
 rbwrappers.c
 rbmalloc.c
 lz4tiny.c
+dummy/nullhelp.c
 
 /* puzzles core sources */
 src/combi.c
diff --git a/apps/plugins/puzzles/SOURCES.games b/apps/plugins/puzzles/SOURCES.games
index 190412295b..70f34f3334 100644
--- a/apps/plugins/puzzles/SOURCES.games
+++ b/apps/plugins/puzzles/SOURCES.games
@@ -35,13 +35,8 @@ src/undead.c
 src/unequal.c
 src/unruly.c
 src/untangle.c
-
-/* Disabled for now. Fix puzzles.make and CATEGORIES to accomodate these. */
-/* The help system would also need to be patched to compile these. */
-/*src/unfinished/group.c*/
-/*src/unfinished/separate.c*/
-/*src/unfinished/slide.c*/
-/*src/unfinished/sokoban.c*/
+src/unfinished/slide.c
+src/unfinished/sokoban.c
 
 /* no c200v2 */
 #if PLUGIN_BUFFER_SIZE > 0x14000
diff --git a/apps/plugins/puzzles/SOURCES.rockbox b/apps/plugins/puzzles/SOURCES.rockbox
index c5bbb9af70..61ce4275ff 100644
--- a/apps/plugins/puzzles/SOURCES.rockbox
+++ b/apps/plugins/puzzles/SOURCES.rockbox
@@ -2,3 +2,4 @@ rockbox.c
 rbwrappers.c
 rbmalloc.c
 lz4tiny.c
+dummy/nullhelp.c
diff --git a/apps/plugins/puzzles/compress.c b/apps/plugins/puzzles/compress.c
index 127a02bf0d..d127a9af17 100644
--- a/apps/plugins/puzzles/compress.c
+++ b/apps/plugins/puzzles/compress.c
@@ -158,6 +158,7 @@ int main()
     printf("};\n\n");
     printf("const unsigned short help_text_len = %d;\n", help_text_len);
     printf("const unsigned short help_text_words = %d;\n", word_idx);
+    printf("const bool help_valid = true;\n");
 
     return 0;
 }
diff --git a/apps/plugins/puzzles/dummy/nullhelp.c b/apps/plugins/puzzles/dummy/nullhelp.c
new file mode 100644
index 0000000000..79c36c902b
--- /dev/null
+++ b/apps/plugins/puzzles/dummy/nullhelp.c
@@ -0,0 +1,8 @@
+#include "help.h"
+
+const char help_text[] __attribute__((weak)) = "";
+const char quick_help_text[] __attribute__((weak)) = "";
+const unsigned short help_text_len __attribute__((weak)) = 0, quick_help_text_len __attribute__((weak)) = 0, help_text_words __attribute__((weak)) = 0;
+struct style_text help_text_style[] __attribute__((weak)) = {};
+
+const bool help_valid __attribute__((weak)) = false;
diff --git a/apps/plugins/puzzles/help.h b/apps/plugins/puzzles/help.h
index e9cac9b337..2f870393e8 100644
--- a/apps/plugins/puzzles/help.h
+++ b/apps/plugins/puzzles/help.h
@@ -1,3 +1,5 @@
+#include <stdbool.h>
+
 #ifdef ROCKBOX
 #include "lib/display_text.h"
 #endif
@@ -12,3 +14,5 @@ extern const unsigned short help_text_len, quick_help_text_len, help_text_words;
 #if defined(ROCKBOX)
 extern struct style_text help_text_style[];
 #endif
+
+extern const bool help_valid;
diff --git a/apps/plugins/puzzles/help/blackbox.c b/apps/plugins/puzzles/help/blackbox.c
index c05daf5fd3..90933604c1 100644
--- a/apps/plugins/puzzles/help/blackbox.c
+++ b/apps/plugins/puzzles/help/blackbox.c
@@ -340,4 +340,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 5480;
 const unsigned short help_text_words = 1016;
+const bool help_valid = true;
 const char quick_help_text[] = "Find the hidden balls in the box by bouncing laser beams off them.";
diff --git a/apps/plugins/puzzles/help/bridges.c b/apps/plugins/puzzles/help/bridges.c
index 3e1c91bcc3..4d42314e4b 100644
--- a/apps/plugins/puzzles/help/bridges.c
+++ b/apps/plugins/puzzles/help/bridges.c
@@ -358,4 +358,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 5613;
 const unsigned short help_text_words = 1026;
+const bool help_valid = true;
 const char quick_help_text[] = "Connect all the islands with a network of bridges.";
diff --git a/apps/plugins/puzzles/help/cube.c b/apps/plugins/puzzles/help/cube.c
index fbdd380d57..0e2fc94081 100644
--- a/apps/plugins/puzzles/help/cube.c
+++ b/apps/plugins/puzzles/help/cube.c
@@ -166,4 +166,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2071;
 const unsigned short help_text_words = 386;
+const bool help_valid = true;
 const char quick_help_text[] = "Pick up all the blue squares by rolling the cube over them.";
diff --git a/apps/plugins/puzzles/help/dominosa.c b/apps/plugins/puzzles/help/dominosa.c
index 98947a6ee6..94d876794b 100644
--- a/apps/plugins/puzzles/help/dominosa.c
+++ b/apps/plugins/puzzles/help/dominosa.c
@@ -176,4 +176,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2299;
 const unsigned short help_text_words = 401;
+const bool help_valid = true;
 const char quick_help_text[] = "Tile the rectangle with a full set of dominoes.";
diff --git a/apps/plugins/puzzles/help/fifteen.c b/apps/plugins/puzzles/help/fifteen.c
index 7fc434fc3d..32c8cba399 100644
--- a/apps/plugins/puzzles/help/fifteen.c
+++ b/apps/plugins/puzzles/help/fifteen.c
@@ -152,4 +152,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 1927;
 const unsigned short help_text_words = 353;
+const bool help_valid = true;
 const char quick_help_text[] = "Slide the tiles around to arrange them into order.";
diff --git a/apps/plugins/puzzles/help/filling.c b/apps/plugins/puzzles/help/filling.c
index c0fe6f47e1..785cfce815 100644
--- a/apps/plugins/puzzles/help/filling.c
+++ b/apps/plugins/puzzles/help/filling.c
@@ -142,4 +142,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 1821;
 const unsigned short help_text_words = 328;
+const bool help_valid = true;
 const char quick_help_text[] = "Mark every square with the area of its containing region.";
diff --git a/apps/plugins/puzzles/help/flip.c b/apps/plugins/puzzles/help/flip.c
index fd287cb37b..4f847069cc 100644
--- a/apps/plugins/puzzles/help/flip.c
+++ b/apps/plugins/puzzles/help/flip.c
@@ -131,4 +131,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 1539;
 const unsigned short help_text_words = 299;
+const bool help_valid = true;
 const char quick_help_text[] = "Flip groups of squares to light them all up at once.";
diff --git a/apps/plugins/puzzles/help/flood.c b/apps/plugins/puzzles/help/flood.c
index 28e18a15a9..ad25a5cf34 100644
--- a/apps/plugins/puzzles/help/flood.c
+++ b/apps/plugins/puzzles/help/flood.c
@@ -182,4 +182,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2395;
 const unsigned short help_text_words = 452;
+const bool help_valid = true;
 const char quick_help_text[] = "Turn the grid the same colour in as few flood fills as possible.";
diff --git a/apps/plugins/puzzles/help/galaxies.c b/apps/plugins/puzzles/help/galaxies.c
index 8482abc14e..10bcda7b3b 100644
--- a/apps/plugins/puzzles/help/galaxies.c
+++ b/apps/plugins/puzzles/help/galaxies.c
@@ -208,4 +208,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2766;
 const unsigned short help_text_words = 498;
+const bool help_valid = true;
 const char quick_help_text[] = "Divide the grid into rotationally symmetric regions each centred on a dot.";
diff --git a/apps/plugins/puzzles/help/guess.c b/apps/plugins/puzzles/help/guess.c
index 594f5910cb..3c77344424 100644
--- a/apps/plugins/puzzles/help/guess.c
+++ b/apps/plugins/puzzles/help/guess.c
@@ -238,4 +238,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3506;
 const unsigned short help_text_words = 650;
+const bool help_valid = true;
 const char quick_help_text[] = "Guess the hidden combination of colours.";
diff --git a/apps/plugins/puzzles/help/inertia.c b/apps/plugins/puzzles/help/inertia.c
index 2755cc2eb6..a0f33a9dc3 100644
--- a/apps/plugins/puzzles/help/inertia.c
+++ b/apps/plugins/puzzles/help/inertia.c
@@ -179,4 +179,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2286;
 const unsigned short help_text_words = 431;
+const bool help_valid = true;
 const char quick_help_text[] = "Collect all the gems without running into any of the mines.";
diff --git a/apps/plugins/puzzles/help/keen.c b/apps/plugins/puzzles/help/keen.c
index bcf5b38a1f..0c69aea0d6 100644
--- a/apps/plugins/puzzles/help/keen.c
+++ b/apps/plugins/puzzles/help/keen.c
@@ -260,4 +260,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3969;
 const unsigned short help_text_words = 762;
+const bool help_valid = true;
 const char quick_help_text[] = "Complete the latin square in accordance with the arithmetic clues.";
diff --git a/apps/plugins/puzzles/help/lightup.c b/apps/plugins/puzzles/help/lightup.c
index c3ddd209fa..c109773bf6 100644
--- a/apps/plugins/puzzles/help/lightup.c
+++ b/apps/plugins/puzzles/help/lightup.c
@@ -191,4 +191,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2549;
 const unsigned short help_text_words = 468;
+const bool help_valid = true;
 const char quick_help_text[] = "Place bulbs to light up all the squares.";
diff --git a/apps/plugins/puzzles/help/loopy.c b/apps/plugins/puzzles/help/loopy.c
index f65d2d2793..76c441511c 100644
--- a/apps/plugins/puzzles/help/loopy.c
+++ b/apps/plugins/puzzles/help/loopy.c
@@ -264,4 +264,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3584;
 const unsigned short help_text_words = 660;
+const bool help_valid = true;
 const char quick_help_text[] = "Draw a single closed loop, given clues about number of adjacent edges.";
diff --git a/apps/plugins/puzzles/help/magnets.c b/apps/plugins/puzzles/help/magnets.c
index 9a54586203..aaaa3bcdad 100644
--- a/apps/plugins/puzzles/help/magnets.c
+++ b/apps/plugins/puzzles/help/magnets.c
@@ -190,4 +190,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2522;
 const unsigned short help_text_words = 439;
+const bool help_valid = true;
 const char quick_help_text[] = "Place magnets to satisfy the clues and avoid like poles touching.";
diff --git a/apps/plugins/puzzles/help/map.c b/apps/plugins/puzzles/help/map.c
index 3532ecebbf..05474e3181 100644
--- a/apps/plugins/puzzles/help/map.c
+++ b/apps/plugins/puzzles/help/map.c
@@ -271,4 +271,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3752;
 const unsigned short help_text_words = 686;
+const bool help_valid = true;
 const char quick_help_text[] = "Colour the map so that adjacent regions are never the same colour.";
diff --git a/apps/plugins/puzzles/help/mines.c b/apps/plugins/puzzles/help/mines.c
index 458034ccaa..80cd81ed3f 100644
--- a/apps/plugins/puzzles/help/mines.c
+++ b/apps/plugins/puzzles/help/mines.c
@@ -260,4 +260,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3814;
 const unsigned short help_text_words = 732;
+const bool help_valid = true;
 const char quick_help_text[] = "Find all the mines without treading on any of them.";
diff --git a/apps/plugins/puzzles/help/mosaic.c b/apps/plugins/puzzles/help/mosaic.c
index 9a7d2dd394..eb0c52c0bf 100644
--- a/apps/plugins/puzzles/help/mosaic.c
+++ b/apps/plugins/puzzles/help/mosaic.c
@@ -147,4 +147,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 1673;
 const unsigned short help_text_words = 285;
+const bool help_valid = true;
 const char quick_help_text[] = "Fill in the grid given clues about number of nearby black squares.";
diff --git a/apps/plugins/puzzles/help/net.c b/apps/plugins/puzzles/help/net.c
index 83cd785ed2..de528b53bc 100644
--- a/apps/plugins/puzzles/help/net.c
+++ b/apps/plugins/puzzles/help/net.c
@@ -297,4 +297,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3919;
 const unsigned short help_text_words = 689;
+const bool help_valid = true;
 const char quick_help_text[] = "Rotate each tile to reassemble the network.";
diff --git a/apps/plugins/puzzles/help/netslide.c b/apps/plugins/puzzles/help/netslide.c
index f4067a2303..17ec9ec440 100644
--- a/apps/plugins/puzzles/help/netslide.c
+++ b/apps/plugins/puzzles/help/netslide.c
@@ -58,4 +58,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 546;
 const unsigned short help_text_words = 99;
+const bool help_valid = true;
 const char quick_help_text[] = "Slide a row at a time to reassemble the network.";
diff --git a/apps/plugins/puzzles/help/palisade.c b/apps/plugins/puzzles/help/palisade.c
index d1ee5e7354..36d3c65248 100644
--- a/apps/plugins/puzzles/help/palisade.c
+++ b/apps/plugins/puzzles/help/palisade.c
@@ -140,4 +140,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 1672;
 const unsigned short help_text_words = 285;
+const bool help_valid = true;
 const char quick_help_text[] = "Divide the grid into equal-sized areas in accordance with the clues.";
diff --git a/apps/plugins/puzzles/help/pattern.c b/apps/plugins/puzzles/help/pattern.c
index a0e4edc579..fae35c0f64 100644
--- a/apps/plugins/puzzles/help/pattern.c
+++ b/apps/plugins/puzzles/help/pattern.c
@@ -168,4 +168,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2167;
 const unsigned short help_text_words = 389;
+const bool help_valid = true;
 const char quick_help_text[] = "Fill in the pattern in the grid, given only the lengths of runs of black squares.";
diff --git a/apps/plugins/puzzles/help/pearl.c b/apps/plugins/puzzles/help/pearl.c
index efb3cd0d5a..033aca17fa 100644
--- a/apps/plugins/puzzles/help/pearl.c
+++ b/apps/plugins/puzzles/help/pearl.c
@@ -249,4 +249,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3598;
 const unsigned short help_text_words = 659;
+const bool help_valid = true;
 const char quick_help_text[] = "Draw a single closed loop, given clues about corner and straight squares.";
diff --git a/apps/plugins/puzzles/help/pegs.c b/apps/plugins/puzzles/help/pegs.c
index 8375f87bcf..32552a87fd 100644
--- a/apps/plugins/puzzles/help/pegs.c
+++ b/apps/plugins/puzzles/help/pegs.c
@@ -148,4 +148,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 1734;
 const unsigned short help_text_words = 326;
+const bool help_valid = true;
 const char quick_help_text[] = "Jump pegs over each other to remove all but one.";
diff --git a/apps/plugins/puzzles/help/range.c b/apps/plugins/puzzles/help/range.c
index d5035ef8d2..65495dc3c1 100644
--- a/apps/plugins/puzzles/help/range.c
+++ b/apps/plugins/puzzles/help/range.c
@@ -170,4 +170,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2223;
 const unsigned short help_text_words = 395;
+const bool help_valid = true;
 const char quick_help_text[] = "Place black squares to limit the visible distance from each numbered cell.";
diff --git a/apps/plugins/puzzles/help/rect.c b/apps/plugins/puzzles/help/rect.c
index bf2197aa47..dfd597eb0f 100644
--- a/apps/plugins/puzzles/help/rect.c
+++ b/apps/plugins/puzzles/help/rect.c
@@ -258,4 +258,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3536;
 const unsigned short help_text_words = 603;
+const bool help_valid = true;
 const char quick_help_text[] = "Divide the grid into rectangles with areas equal to the numbers.";
diff --git a/apps/plugins/puzzles/help/samegame.c b/apps/plugins/puzzles/help/samegame.c
index 3c632fca2b..62589b4f11 100644
--- a/apps/plugins/puzzles/help/samegame.c
+++ b/apps/plugins/puzzles/help/samegame.c
@@ -188,4 +188,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2492;
 const unsigned short help_text_words = 445;
+const bool help_valid = true;
 const char quick_help_text[] = "Clear the grid by removing touching groups of the same colour squares.";
diff --git a/apps/plugins/puzzles/help/signpost.c b/apps/plugins/puzzles/help/signpost.c
index 753a202f3e..34e043da57 100644
--- a/apps/plugins/puzzles/help/signpost.c
+++ b/apps/plugins/puzzles/help/signpost.c
@@ -222,4 +222,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3255;
 const unsigned short help_text_words = 595;
+const bool help_valid = true;
 const char quick_help_text[] = "Connect the squares into a path following the arrows.";
diff --git a/apps/plugins/puzzles/help/singles.c b/apps/plugins/puzzles/help/singles.c
index a906addeb6..9a1771e3c7 100644
--- a/apps/plugins/puzzles/help/singles.c
+++ b/apps/plugins/puzzles/help/singles.c
@@ -149,4 +149,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 1780;
 const unsigned short help_text_words = 309;
+const bool help_valid = true;
 const char quick_help_text[] = "Black out the right set of duplicate numbers.";
diff --git a/apps/plugins/puzzles/help/sixteen.c b/apps/plugins/puzzles/help/sixteen.c
index 92e64e29bb..1ba92291f3 100644
--- a/apps/plugins/puzzles/help/sixteen.c
+++ b/apps/plugins/puzzles/help/sixteen.c
@@ -197,4 +197,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2553;
 const unsigned short help_text_words = 454;
+const bool help_valid = true;
 const char quick_help_text[] = "Slide a row at a time to arrange the tiles into order.";
diff --git a/apps/plugins/puzzles/help/slant.c b/apps/plugins/puzzles/help/slant.c
index f51b141827..7c24a1bac3 100644
--- a/apps/plugins/puzzles/help/slant.c
+++ b/apps/plugins/puzzles/help/slant.c
@@ -199,4 +199,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2582;
 const unsigned short help_text_words = 474;
+const bool help_valid = true;
 const char quick_help_text[] = "Draw a maze of slanting lines that matches the clues.";
diff --git a/apps/plugins/puzzles/help/solo.c b/apps/plugins/puzzles/help/solo.c
index cc3d96cf84..68927490e6 100644
--- a/apps/plugins/puzzles/help/solo.c
+++ b/apps/plugins/puzzles/help/solo.c
@@ -383,4 +383,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 6259;
 const unsigned short help_text_words = 1153;
+const bool help_valid = true;
 const char quick_help_text[] = "Fill in the grid so that each row, column and square block contains one of every digit.";
diff --git a/apps/plugins/puzzles/help/tents.c b/apps/plugins/puzzles/help/tents.c
index c486960ec2..8b14490a51 100644
--- a/apps/plugins/puzzles/help/tents.c
+++ b/apps/plugins/puzzles/help/tents.c
@@ -163,4 +163,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2158;
 const unsigned short help_text_words = 401;
+const bool help_valid = true;
 const char quick_help_text[] = "Place a tent next to each tree.";
diff --git a/apps/plugins/puzzles/help/towers.c b/apps/plugins/puzzles/help/towers.c
index 43f1cef5ea..ff5a0a495a 100644
--- a/apps/plugins/puzzles/help/towers.c
+++ b/apps/plugins/puzzles/help/towers.c
@@ -263,4 +263,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3906;
 const unsigned short help_text_words = 732;
+const bool help_valid = true;
 const char quick_help_text[] = "Complete the latin square of towers in accordance with the clues.";
diff --git a/apps/plugins/puzzles/help/tracks.c b/apps/plugins/puzzles/help/tracks.c
index c088145a09..f3677352b5 100644
--- a/apps/plugins/puzzles/help/tracks.c
+++ b/apps/plugins/puzzles/help/tracks.c
@@ -150,4 +150,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 1881;
 const unsigned short help_text_words = 337;
+const bool help_valid = true;
 const char quick_help_text[] = "Fill in the railway track according to the clues.";
diff --git a/apps/plugins/puzzles/help/twiddle.c b/apps/plugins/puzzles/help/twiddle.c
index bea3e25ab8..a07ba931d4 100644
--- a/apps/plugins/puzzles/help/twiddle.c
+++ b/apps/plugins/puzzles/help/twiddle.c
@@ -205,4 +205,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 2945;
 const unsigned short help_text_words = 549;
+const bool help_valid = true;
 const char quick_help_text[] = "Rotate the tiles around themselves to arrange them into order.";
diff --git a/apps/plugins/puzzles/help/undead.c b/apps/plugins/puzzles/help/undead.c
index 78ecdf386c..dc75e88743 100644
--- a/apps/plugins/puzzles/help/undead.c
+++ b/apps/plugins/puzzles/help/undead.c
@@ -248,4 +248,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3574;
 const unsigned short help_text_words = 660;
+const bool help_valid = true;
 const char quick_help_text[] = "Place ghosts, vampires and zombies so that the right numbers of them can be seen in mirrors.";
diff --git a/apps/plugins/puzzles/help/unequal.c b/apps/plugins/puzzles/help/unequal.c
index 563f9d113b..6bccf6bef3 100644
--- a/apps/plugins/puzzles/help/unequal.c
+++ b/apps/plugins/puzzles/help/unequal.c
@@ -257,4 +257,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 3954;
 const unsigned short help_text_words = 731;
+const bool help_valid = true;
 const char quick_help_text[] = "Complete the latin square in accordance with the > signs.";
diff --git a/apps/plugins/puzzles/help/unruly.c b/apps/plugins/puzzles/help/unruly.c
index dafb3274db..97348e5c26 100644
--- a/apps/plugins/puzzles/help/unruly.c
+++ b/apps/plugins/puzzles/help/unruly.c
@@ -145,4 +145,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 1707;
 const unsigned short help_text_words = 306;
+const bool help_valid = true;
 const char quick_help_text[] = "Fill in the black and white grid to avoid runs of three.";
diff --git a/apps/plugins/puzzles/help/untangle.c b/apps/plugins/puzzles/help/untangle.c
index cdf9b96d25..88b6e39d5a 100644
--- a/apps/plugins/puzzles/help/untangle.c
+++ b/apps/plugins/puzzles/help/untangle.c
@@ -97,4 +97,5 @@ const char help_text[] = {
 
 const unsigned short help_text_len = 974;
 const unsigned short help_text_words = 174;
+const bool help_valid = true;
 const char quick_help_text[] = "Reposition the points so that the lines do not cross.";
diff --git a/apps/plugins/puzzles/puzzles.make b/apps/plugins/puzzles/puzzles.make
index 604208cbdd..8c5bc1de40 100644
--- a/apps/plugins/puzzles/puzzles.make
+++ b/apps/plugins/puzzles/puzzles.make
@@ -25,6 +25,8 @@ PUZZLES_OBJ = $(call c2obj, $(PUZZLES_SRC))
 PUZZLES_ROCKS = $(addprefix $(PUZZLES_OBJDIR)/sgt-, $(notdir $(PUZZLES_GAMES_SRC:.c=.rock)))
 
 OTHER_SRC += $(PUZZLES_SRC)
+OTHER_INC += -I$(PUZZLES_SRCDIR)/src -I $(PUZZLES_SRCDIR)
+
 ROCKS += $(PUZZLES_ROCKS)
 
 PUZZLES_OPTIMIZE = -O2
@@ -49,6 +51,13 @@ $(PUZZLES_OBJDIR)/sgt-%.rock: $(PUZZLES_OBJDIR)/src/%.o $(PUZZLES_OBJDIR)/help/%
                 -lgcc $(filter-out -Wl%.map, $(PLUGINLDFLAGS)) -Wl,-Map,$(PUZZLES_OBJDIR)/src/$*.map
         $(SILENT)$(call objcopy,$(PUZZLES_OBJDIR)/$*.elf,$@)
 
+$(PUZZLES_OBJDIR)/sgt-%.rock: $(PUZZLES_OBJDIR)/src/unfinished/%.o $(PUZZLES_SHARED_OBJ) $(TLSFLIB)
+        $(call PRINTS,LD $(@F))$(CC) $(PLUGINFLAGS) -o $(PUZZLES_OBJDIR)/$*.elf \
+                $(filter %.o, $^) \
+                $(filter %.a, $+) \
+                -lgcc $(filter-out -Wl%.map, $(PLUGINLDFLAGS)) -Wl,-Map,$(PUZZLES_OBJDIR)/src/$*.map
+        $(SILENT)$(call objcopy,$(PUZZLES_OBJDIR)/$*.elf,$@)
+
 $(PUZZLES_SRCDIR)/rbcompat.h:   $(APPSDIR)/plugin.h                     \
                                 $(APPSDIR)/plugins/lib/pluginlib_exit.h \
                                 $(BUILDDIR)/sysfont.h                   \
diff --git a/apps/plugins/puzzles/resync.sh b/apps/plugins/puzzles/resync.sh
index 7c2df45c7e..3431a6f695 100755
--- a/apps/plugins/puzzles/resync.sh
+++ b/apps/plugins/puzzles/resync.sh
@@ -30,8 +30,8 @@ then
     echo "[1/5] Removing current src/ directory"
     rm -rf src
     echo "[2/5] Copying new sources"
-    mkdir src
-    cp -r "$1"/{*.h,puzzles.but,LICENCE,README,CMakeLists.txt} src
+    mkdir -p src/unfinished
+    cp -r "$1"/{*.h,puzzles.but,LICENCE,README,CMakeLists.txt,unfinished} src
 
     # Parse out definitions of core, core_obj, and common from
     # CMakeLists. Extract the .c filenames, except malloc.c, and store
@@ -46,17 +46,12 @@ then
     SRC="$(cat SOURCES.games SOURCES.core | sed 's/src\///' | tr '\n' ' ' | head -c-1) loopy.c pearl.c solo.c"
     echo "Detected sources:" $SRC
     pushd "$1" > /dev/null
-    cp $SRC "$ROOT"/src
+    cp -r $SRC "$ROOT"/src
     popd > /dev/null
 
-    cat <<EOF >> SOURCES.games
+    cat src/unfinished/CMakeLists.txt | awk '/puzzle\(/{p=1} p{print} /\)/{p=0}' | grep -Eo "\(.*$" | tr -dc "a-z\n" | awk '{print "src/unfinished/"$0".c"}' | grep -v "group" | grep -v "separate" >> SOURCES.games
 
-/* Disabled for now. Fix puzzles.make and CATEGORIES to accomodate these. */
-/* The help system would also need to be patched to compile these. */
-/*src/unfinished/group.c*/
-/*src/unfinished/separate.c*/
-/*src/unfinished/slide.c*/
-/*src/unfinished/sokoban.c*/
+    cat <<EOF >> SOURCES.games
 
 /* no c200v2 */
 #if PLUGIN_BUFFER_SIZE > 0x14000
diff --git a/apps/plugins/puzzles/rockbox.c b/apps/plugins/puzzles/rockbox.c
index 27005a447d..27060208fc 100644
--- a/apps/plugins/puzzles/rockbox.c
+++ b/apps/plugins/puzzles/rockbox.c
@@ -322,6 +322,7 @@ static struct viewport clip_rect;
 static bool clipped = false, zoom_enabled = false, view_mode = true, mouse_mode = false;
 
 static int mouse_x, mouse_y;
+static bool mouse_dragging = false; /* for sticky mode only */
 
 extern bool audiobuf_available; /* defined in rbmalloc.c */
 
@@ -346,6 +347,7 @@ static struct {
     bool ignore_repeats; /* ignore repeated button events (currently in all games but Untangle) */
     bool rclick_on_hold; /* if in mouse mode, send right-click on long-press of select */
     bool numerical_chooser; /* repurpose select to activate a numerical chooser */
+    bool sticky_mouse; /* if mouse left button should be persistent and toggled on/off */
 } input_settings;
 
 static bool accept_input = true;
@@ -748,7 +750,8 @@ static void rb_color(int n)
         fatal("bad color %d", n);
         return;
     }
-    rb->lcd_set_foreground(colors[n]);
+    if(colors)
+        rb->lcd_set_foreground(colors[n]);
 }
 
 /* clipping is implemented through viewports and offsetting
@@ -1284,7 +1287,8 @@ static void draw_title(bool clear_first)
     rb->lcd_setfont(cur_font = FONT_UI);
     rb->lcd_getstringsize(str, &w, &h);
 
-    rb->lcd_set_foreground(BG_COLOR);
+
+    rb->lcd_set_foreground(colors ? colors[0] : BG_COLOR);
     rb->lcd_fillrect(0, LCD_HEIGHT - h, clear_first ? LCD_WIDTH : w, h);
 
     rb->lcd_set_drawmode(DRMODE_FG);
@@ -1682,9 +1686,17 @@ static int process_input(int tmo, bool do_pausemenu)
                 LOGF("sending left click");
                 send_click(LEFT_BUTTON, true); /* right-click is handled earlier */
             }
-        }
-        else
-        {
+        } else if(input_settings.sticky_mouse) {
+            if(pressed & BTN_FIRE) {
+                send_click(LEFT_BUTTON, false);
+                accept_input = false;
+                mouse_dragging = !mouse_dragging;
+            } else if(mouse_dragging) {
+                send_click(LEFT_DRAG, false);
+            } else {
+                send_click(LEFT_RELEASE, false);
+            }
+        } else {
             if(pressed & BTN_FIRE) {
                 send_click(LEFT_BUTTON, false);
                 accept_input = false;
@@ -2482,6 +2494,7 @@ static bool presets_menu(void)
 
 static void quick_help(void)
 {
+#ifndef NO_HELP_TEXT
 #if defined(FOR_REAL) && defined(DEBUG_MENU)
     if(++help_times >= 5)
     {
@@ -2492,11 +2505,12 @@ static void quick_help(void)
 
     rb->splash(0, quick_help_text);
     rb->button_get(true);
-    return;
+#endif
 }
 
 static void full_help(const char *name)
 {
+#ifndef NO_HELP_TEXT
     unsigned old_bg = rb->lcd_get_background();
 
     bool orig_clipped = clipped;
@@ -2551,6 +2565,7 @@ static void full_help(const char *name)
 
     if(orig_clipped)
         rb_clip(NULL, clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height);
+#endif
 }
 
 static void init_default_settings(void)
@@ -2701,6 +2716,11 @@ static int pausemenu_cb(int action,
             if(!midend_which_game(me)->can_solve)
                 return ACTION_EXIT_MENUITEM;
             break;
+        case 7:
+        case 8:
+            if(!help_valid)
+                return ACTION_EXIT_MENUITEM;
+            break;
         case 9:
             if(audiobuf_available)
                 break;
@@ -2751,7 +2771,7 @@ static void reset_drawing(void)
     rb->lcd_set_viewport(NULL);
     rb->lcd_set_backdrop(NULL);
     rb->lcd_set_foreground(LCD_BLACK);
-    rb->lcd_set_background(BG_COLOR);
+    rb->lcd_set_background(colors ? colors[0] : BG_COLOR);
 }
 
 /* Make a new game, but tell the user through a splash so they don't
@@ -2876,7 +2896,7 @@ static int pause_menu(void)
             break;
         }
     }
-    rb->lcd_set_background(BG_COLOR);
+    rb->lcd_set_background(colors ? colors[0] : BG_COLOR);
     rb->lcd_clear_display();
     midend_force_redraw(me);
     rb->lcd_update();
@@ -2923,6 +2943,7 @@ static void init_colors(void)
     float *floatcolors = midend_colors(me, &ncolors);
 
     /* convert them to packed RGB */
+    sfree(colors);
     colors = smalloc(ncolors * sizeof(unsigned));
     unsigned *ptr = colors;
     float *floatptr = floatcolors;
@@ -3007,6 +3028,7 @@ static void tune_input(const char *name)
     static const char *no_rclick_on_hold[] = {
         "Map",
         "Signpost",
+        "Slide",
         "Untangle",
         NULL
     };
@@ -3015,11 +3037,21 @@ static void tune_input(const char *name)
 
     static const char *mouse_games[] = {
         "Loopy",
+        "Slide",
         NULL
     };
 
     mouse_mode = string_in_list(name, mouse_games);
 
+    static const char *sticky_mouse_games[] = {
+        "Map",
+        "Signpost",
+        "Slide",
+        "Untangle",
+    };
+
+    input_settings.sticky_mouse = string_in_list(name, sticky_mouse_games);
+
     static const char *number_chooser_games[] = {
         "Filling",
         "Keen",
@@ -3312,8 +3344,11 @@ static int mainmenu_cb(int action,
             if(!load_success)
                 return ACTION_EXIT_MENUITEM;
             break;
+        case 2:
         case 3:
-            break;
+            if(!help_valid)
+                return ACTION_EXIT_MENUITEM;
+            break;
         case 4:
             if(audiobuf_available)
                 break;
@@ -3476,12 +3511,14 @@ static void puzzles_main(void)
                     /* quit without saving */
                     midend_free(me);
                     sfree(colors);
+                    colors = NULL;
                     return;
                 case -3:
                     /* save and quit */
                     save_game();
                     midend_free(me);
                     sfree(colors);
+                    colors = NULL;
                     return;
                 default:
                     break;
@@ -3511,6 +3548,7 @@ static void puzzles_main(void)
             rb->yield();
         }
         sfree(colors);
+        colors = NULL;
     }
 }
 
diff --git a/apps/plugins/puzzles/src/unfinished/CMakeLists.txt b/apps/plugins/puzzles/src/unfinished/CMakeLists.txt
new file mode 100644
index 0000000000..0c1e331f9b
--- /dev/null
+++ b/apps/plugins/puzzles/src/unfinished/CMakeLists.txt
@@ -0,0 +1,31 @@
+puzzle(group
+  DISPLAYNAME "Group"
+  DESCRIPTION "Group theory puzzle"
+  OBJECTIVE "Complete the unfinished Cayley table of a group.")
+solver(group ${CMAKE_SOURCE_DIR}/latin.c)
+
+puzzle(separate
+  DISPLAYNAME "Separate"
+  DESCRIPTION "Rectangle-dividing puzzle"
+  OBJECTIVE "Partition the grid into regions containing one of each letter.")
+
+puzzle(slide
+  DISPLAYNAME "Slide"
+  DESCRIPTION "Sliding block puzzle"
+  OBJECTIVE "Slide the blocks to let the key block out.")
+solver(slide)
+
+puzzle(sokoban
+  DISPLAYNAME "Sokoban"
+  DESCRIPTION "Barrel-pushing puzzle"
+  OBJECTIVE "Push all the barrels into the target squares.")
+
+# These unfinished programs don't even have the structure of a puzzle
+# game yet; they're just command-line programs containing test
+# implementations of some of the needed functionality.
+
+cliprogram(numgame numgame.c)
+
+cliprogram(path path.c COMPILE_DEFINITIONS TEST_GEN)
+
+export_variables_to_parent_scope()
diff --git a/apps/plugins/puzzles/src/unfinished/README b/apps/plugins/puzzles/src/unfinished/README
new file mode 100644
index 0000000000..c96ccc935a
--- /dev/null
+++ b/apps/plugins/puzzles/src/unfinished/README
@@ -0,0 +1,14 @@
+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.
+
+The CMake build system will _build_ all of the source in this
+directory (to ensure it hasn't become unbuildable), but they won't be
+included in all-in-one puzzle binaries or installed by 'make install'
+targets. If you want to temporarily change that, you can reconfigure
+your build by defining the CMake variable PUZZLES_ENABLE_UNFINISHED.
+For example,
+
+  cmake . -DPUZZLES_ENABLE_UNFINISHED="group;slide"
+
+will build as if both Group and Slide were fully official puzzles.
diff --git a/apps/plugins/puzzles/src/unfinished/group.c b/apps/plugins/puzzles/src/unfinished/group.c
new file mode 100644
index 0000000000..faffa89485
--- /dev/null
+++ b/apps/plugins/puzzles/src/unfinished/group.c
@@ -0,0 +1,2497 @@
+/*
+ * 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>
+#ifdef NO_TGMATH_H
+#  include <math.h>
+#else
+#  include <tgmath.h>
+#endif
+
+#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,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 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;
+    bool id;
+};
+
+typedef struct group_common {
+    int refcount;
+    bool *immutable;
+} group_common;
+
+struct game_state {
+    game_params par;
+    digit *grid;
+    int *pencil;                       /* bitmaps using bits 1<<1..1<<n */
+    group_common *common;
+    bool 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;
+}
+
+static const 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 bool 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, bool 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].u.string.sval = dupstr(buf);
+
+    ret[1].name = "Difficulty";
+    ret[1].type = C_CHOICES;
+    ret[1].u.choices.choicenames = DIFFCONFIG;
+    ret[1].u.choices.selected = params->diff;
+
+    ret[2].name = "Show identity";
+    ret[2].type = C_BOOLEAN;
+    ret[2].u.boolean.bval = params->id;
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].u.string.sval);
+    ret->diff = cfg[1].u.choices.selected;
+    ret->id = cfg[2].u.boolean.bval;
+
+    return ret;
+}
+
+static const char *validate_params(const game_params *params, bool 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 find_identity(struct latin_solver *solver)
+{
+    int w = solver->o;
+    digit *grid = solver->grid;
+    int i, j;
+
+    for (i = 0; i < w; i++)
+        for (j = 0; j < w; j++) {
+            if (grid[i*w+j] == i+1)
+                return j+1;
+            if (grid[i*w+j] == j+1)
+                return i+1;
+        }
+
+    return 0;
+}
+
+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 = 0; i < w; i++)
+        for (j = 0; j < w; j++)
+            for (k = 0; 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
+                    }
+                }
+            }
+
+    /*
+     * Fill in the row and column for the group identity, if it's not
+     * already known and if we've just found out what it is.
+     */
+    i = find_identity(solver);
+    if (i) {
+        bool done_something = false;
+        for (j = 1; j <= w; j++) {
+            if (!grid[(i-1)*w+(j-1)] || !grid[(j-1)*w+(i-1)]) {
+                done_something = true;
+            }
+        }
+        if (done_something) {
+#ifdef STANDALONE_SOLVER
+            if (solver_show_working) {
+                printf("%*s%s is the group identity\n",
+                       solver_recurse_depth*4, "", names[i-1]);
+            }
+#endif
+            for (j = 1; j <= w; j++) {
+                if (!grid[(j-1)*w+(i-1)]) {
+                    if (!cube(i-1, j-1, j)) {
+#ifdef STANDALONE_SOLVER
+                        if (solver_show_working) {
+                            printf("%*s  but %s cannot go at (%d,%d) - "
+                                   "contradiction!\n",
+                                   solver_recurse_depth*4, "",
+                                   names[j-1], i, j);
+                        }
+#endif
+                        return -1;
+                    }
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*s  placing %s at (%d,%d)\n",
+                               solver_recurse_depth*4, "",
+                               names[j-1], i, j);
+                    }
+#endif
+                    latin_solver_place(solver, i-1, j-1, j);
+                }
+                if (!grid[(i-1)*w+(j-1)]) {
+                    if (!cube(j-1, i-1, j)) {
+#ifdef STANDALONE_SOLVER
+                        if (solver_show_working) {
+                            printf("%*s  but %s cannot go at (%d,%d) - "
+                                   "contradiction!\n",
+                                   solver_recurse_depth*4, "",
+                                   names[j-1], j, i);
+                        }
+#endif
+                        return -1;
+                    }
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*s  placing %s at (%d,%d)\n",
+                               solver_recurse_depth*4, "",
+                               names[j-1], j, i);
+                    }
+#endif
+                    latin_solver_place(solver, j-1, i-1, j);
+                }
+            }
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static int solver_hard(struct latin_solver *solver, void *vctx)
+{
+    bool done_something = false;
+    int w = solver->o;
+#ifdef STANDALONE_SOLVER
+    char **names = solver->names;
+#endif
+    int i, j;
+
+    /*
+     * In identity-hidden mode, systematically rule out possibilities
+     * for the group identity.
+     *
+     * In solver_normal, we used the fact that any filled square in
+     * the grid whose contents _does_ match one of the elements it's
+     * the product of - that is, ab=a or ab=b - tells you immediately
+     * that the other element is the identity.
+     *
+     * Here, we use the flip side of that: any filled square in the
+     * grid whose contents does _not_ match either its row or column -
+     * that is, if ab is neither a nor b - tells you immediately that
+     * _neither_ of those elements is the identity. And if that's
+     * true, then we can also immediately rule out the possibility
+     * that it acts as the identity on any element at all.
+     */
+    for (i = 0; i < w; i++) {
+        bool i_can_be_id = true;
+#ifdef STANDALONE_SOLVER
+        char title[80];
+#endif
+
+        for (j = 0; j < w; j++) {
+            if (grid(i,j) && grid(i,j) != j+1) {
+#ifdef STANDALONE_SOLVER
+                if (solver_show_working)
+                    sprintf(title, "%s cannot be the identity: "
+                            "%s%s = %s =/= %s", names[i], names[i], names[j],
+                            names[grid(i,j)-1], names[j]);
+#endif
+                i_can_be_id = false;
+                break;
+            }
+            if (grid(j,i) && grid(j,i) != j+1) {
+#ifdef STANDALONE_SOLVER
+                if (solver_show_working)
+                    sprintf(title, "%s cannot be the identity: "
+                            "%s%s = %s =/= %s", names[i], names[j], names[i],
+                            names[grid(j,i)-1], names[j]);
+#endif
+                i_can_be_id = false;
+                break;
+            }
+        }
+
+        if (!i_can_be_id) {
+            /* Now rule out ij=j or ji=j for all j. */
+            for (j = 0; j < w; j++) {
+                if (cube(i, j, j+1)) {
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        if (title[0]) {
+                            printf("%*s%s\n", solver_recurse_depth*4, "",
+                                   title);
+                            title[0] = '\0';
+                        }
+                        printf("%*s  ruling out %s at (%d,%d)\n",
+                               solver_recurse_depth*4, "", names[j], i, j);
+                    }
+#endif
+                    cube(i, j, j+1) = false;
+                }
+                if (cube(j, i, j+1)) {
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        if (title[0]) {
+                            printf("%*s%s\n", solver_recurse_depth*4, "",
+                                   title);
+                            title[0] = '\0';
+                        }
+                        printf("%*s  ruling out %s at (%d,%d)\n",
+                               solver_recurse_depth*4, "", names[j], j, i);
+                    }
+#endif
+                    cube(j, i, j+1) = false;
+                }
+            }
+        }
+    }
+
+    return done_something;
+}
+
+#define SOLVER(upper,title,func,lower) func,
+static usersolver_t const group_solvers[] = { DIFFLIST(SOLVER) };
+
+static bool group_valid(struct latin_solver *solver, void *ctx)
+{
+    int w = solver->o;
+#ifdef STANDALONE_SOLVER
+    char **names = solver->names;
+#endif
+    int i, j, k;
+
+    for (i = 0; i < w; i++)
+        for (j = 0; j < w; j++)
+            for (k = 0; k < w; k++) {
+                int ij = grid(i, j) - 1;
+                int jk = grid(j, k) - 1;
+                int ij_k = grid(ij, k) - 1;
+                int i_jk = grid(i, jk) - 1;
+                if (ij_k != i_jk) {
+#ifdef STANDALONE_SOLVER
+                    if (solver_show_working) {
+                        printf("%*sfailure of associativity: "
+                               "(%s%s)%s = %s%s = %s but "
+                               "%s(%s%s) = %s%s = %s\n",
+                               solver_recurse_depth*4, "",
+                               names[i], names[j], names[k],
+                               names[ij], names[k], names[ij_k],
+                               names[i], names[j], names[k],
+                               names[i], names[jk], names[i_jk]);
+                    }
+#endif
+                    return false;
+                }
+            }
+
+    return true;
+}
+
+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;
+
+    for (i = 0, p = text; i < w; i++) {
+        names[i] = p;
+        *p++ = TOCHAR(i+1, params->id);
+        *p++ = '\0';
+    }
+    solver.names = names;
+#endif
+
+    if (latin_solver_alloc(&solver, grid, w))
+        ret = latin_solver_main(&solver, maxdiff,
+                                DIFF_TRIVIAL, DIFF_HARD, DIFF_EXTREME,
+                                DIFF_EXTREME, DIFF_UNREASONABLE,
+                                group_solvers, group_valid, NULL, NULL, NULL);
+    else
+        ret = diff_impossible;
+
+    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, bool 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 const 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 const 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->common = snew(group_common);
+    state->common->refcount = 1;
+    state->common->immutable = snewn(a, bool);
+    state->pencil = snewn(a, int);
+    for (i = 0; i < a; i++) {
+        state->grid[i] = 0;
+        state->common->immutable[i] = false;
+        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->common->immutable[i] = true;
+
+    state->completed = false;
+    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->common = state->common;
+    ret->common->refcount++;
+    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->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);
+    if (--state->common->refcount == 0) {
+        sfree(state->common->immutable);
+        sfree(state->common);
+    }
+    sfree(state->pencil);
+    sfree(state->sequence);
+    sfree(state);
+}
+
+static char *solve_game(const game_state *state, const game_state *currstate,
+                        const char *aux, const 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 bool 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.
+     */
+    bool 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.
+     */
+    bool 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.
+     */
+    bool 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;
+
+    /*
+     * User preference option: if the user right-clicks in a square
+     * and presses a letter key to add/remove a pencil mark, do we
+     * hide the mouse highlight again afterwards?
+     *
+     * Historically our answer was yes. The Android port prefers no.
+     * There are advantages both ways, depending how much you dislike
+     * the highlight cluttering your view. So it's a preference.
+     */
+    bool pencil_keep_highlight;
+};
+
+static game_ui *new_ui(const game_state *state)
+{
+    game_ui *ui = snew(game_ui);
+
+    ui->hx = ui->hy = 0;
+    ui->hpencil = false;
+    ui->hshow = false;
+    ui->hcursor = false;
+    ui->drag = 0;
+
+    ui->pencil_keep_highlight = false;
+
+    return ui;
+}
+
+static void free_ui(game_ui *ui)
+{
+    sfree(ui);
+}
+
+static config_item *get_prefs(game_ui *ui)
+{
+    config_item *ret;
+
+    ret = snewn(2, config_item);
+
+    ret[0].name = "Keep mouse highlight after changing a pencil mark";
+    ret[0].kw = "pencil-keep-highlight";
+    ret[0].type = C_BOOLEAN;
+    ret[0].u.boolean.bval = ui->pencil_keep_highlight;
+
+    ret[1].name = NULL;
+    ret[1].type = C_END;
+
+    return ret;
+}
+
+static void set_prefs(game_ui *ui, const config_item *cfg)
+{
+    ui->pencil_keep_highlight = cfg[0].u.boolean.bval;
+}
+
+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 = false;
+    }
+    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 = false;
+                break;
+            }
+            if (oldstate->sequence[ui->ohy + i*ui->ody] !=
+                newstate->sequence[ui->ohy + i*ui->ody]) {
+                ui->hshow = false;
+                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;
+        }
+    }
+}
+
+static const char *current_key_label(const game_ui *ui,
+                                     const game_state *state, int button)
+{
+    if (ui->hshow && button == CURSOR_SELECT)
+        return ui->hpencil ? "Ink" : "Pencil";
+    if (ui->hshow && button == CURSOR_SELECT2) {
+        int w = state->par.w;
+        int i;
+        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;
+            if (ui->hpencil && state->grid[index]) return "";
+            if (state->common->immutable[index]) return "";
+        }
+        return "Clear";
+    }
+    return "";
+}
+
+#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;
+    bool started;
+    long *tiles, *legend, *pencil, *errors;
+    long *errtmp;
+    digit *sequence;
+};
+
+static bool 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;
+    bool 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 = STRIP_BUTTON_MODIFIERS(button);
+
+    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 MOVE_UI_UPDATE;
+            }
+        } else if (IS_MOUSE_RELEASE(button)) {
+            if (ui->drag & 4) {
+                ui->drag = 0;          /* end drag */
+                if (state->sequence[ui->dragpos] == ui->dragnum)
+                    return MOVE_UI_UPDATE;  /* 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 MOVE_UI_UPDATE;  /* 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) {
+                    ui->hshow = false;
+                } else {
+                    ui->hx = tx;
+                    ui->hy = ty;
+                    ui->ohx = otx;
+                    ui->ohy = oty;
+                    ui->odx = ui->ody = 0;
+                    ui->odn = 1;
+                    ui->hshow = !state->common->immutable[ty*w+tx];
+                    ui->hpencil = false;
+                }
+                ui->hcursor = false;
+                return MOVE_UI_UPDATE;
+            }
+            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 = false;
+                    } else {
+                        ui->hpencil = true;
+                        ui->hx = tx;
+                        ui->hy = ty;
+                        ui->ohx = otx;
+                        ui->ohy = oty;
+                        ui->odx = ui->ody = 0;
+                        ui->odn = 1;
+                        ui->hshow = true;
+                    }
+                } else {
+                    ui->hshow = false;
+                }
+                ui->hcursor = false;
+                return MOVE_UI_UPDATE;
+            }
+        } 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 MOVE_UI_UPDATE;
+        } 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 MOVE_UI_UPDATE;
+        }
+    } 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 MOVE_UI_UPDATE;
+    }
+
+    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, false, NULL);
+        ui->hx = state->sequence[cx];
+        ui->hy = state->sequence[cy];
+        ui->hshow = true;
+        ui->hcursor = true;
+        ui->ohx = cx;
+        ui->ohy = cy;
+        ui->odx = ui->ody = 0;
+        ui->odn = 1;
+        return MOVE_UI_UPDATE;
+    }
+    if (ui->hshow &&
+        (button == CURSOR_SELECT)) {
+        ui->hpencil = !ui->hpencil;
+        ui->hcursor = true;
+        return MOVE_UI_UPDATE;
+    }
+
+    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->common->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);
+
+        /*
+         * Hide the highlight after a keypress, if it was mouse-
+         * generated. Also, don't hide it if this move has changed
+         * pencil marks and the user preference says not to hide the
+         * highlight in that situation.
+         */
+        if (!ui->hcursor && !(ui->hpencil && ui->pencil_keep_highlight))
+            ui->hshow = false;
+
+        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;
+        bool 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->common->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,
+                              const game_ui *ui, 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) {
+        /*
+         * 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->common->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);
+                bool highlight = false;
+                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 = true;
+                } 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 void game_get_cursor_location(const game_ui *ui,
+                                     const game_drawstate *ds,
+                                     const game_state *state,
+                                     const game_params *params,
+                                     int *x, int *y, int *w, int *h)
+{
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static bool 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, const game_ui *ui,
+                            float *x, float *y)
+{
+    int pw, ph;
+
+    /*
+     * We use 9mm squares by default, like Solo.
+     */
+    game_compute_size(params, 900, ui, &pw, &ph);
+    *x = pw / 100.0F;
+    *y = ph / 100.0F;
+}
+
+static void game_print(drawing *dr, const game_state *state, const game_ui *ui,
+                       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, NULL,
+    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,
+    get_prefs, set_prefs,
+    new_ui,
+    free_ui,
+    NULL, /* encode_ui */
+    NULL, /* decode_ui */
+    NULL, /* game_request_keys */
+    game_changed_state,
+    current_key_label,
+    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_get_cursor_location,
+    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;
+    const char *err;
+    digit *grid;
+    bool grade = false;
+    int ret, diff;
+    bool 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 = 0;
+    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 (really_show_working) {
+            solver_show_working = true;
+            memcpy(grid, s->grid, p->w * p->w);
+            ret = solver(&s->par, grid, DIFFCOUNT - 1);
+        }
+        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/src/unfinished/group.gap b/apps/plugins/puzzles/src/unfinished/group.gap
new file mode 100644
index 0000000000..280adf4664
--- /dev/null
+++ b/apps/plugins/puzzles/src/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/src/unfinished/numgame.c b/apps/plugins/puzzles/src/unfinished/numgame.c
new file mode 100644
index 0000000000..cf919922e7
--- /dev/null
+++ b/apps/plugins/puzzles/src/unfinished/numgame.c
@@ -0,0 +1,1294 @@
+/*
+ * 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>
+#ifdef NO_TGMATH_H
+#  include <math.h>
+#else
+#  include <tgmath.h>
+#endif
+
+#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.
+     */
+    const 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);
+}
+
+static const struct operation op_add = {
+    true, "+", "+", 0, 10, 0, true, perform_add
+};
+static const struct operation op_sub = {
+    true, "-", "-", 0, 10, 2, false, perform_sub
+};
+static const struct operation op_mul = {
+    true, "*", "*", 0, 20, 0, true, perform_mul
+};
+static const struct operation op_div = {
+    true, "/", "/", 0, 20, 2, false, perform_div
+};
+static const struct operation op_xdiv = {
+    true, "/", "/", 0, 20, 2, false, perform_exact_div
+};
+static const struct operation op_concat = {
+    false, "", "concat", OPFLAG_NEEDS_CONCAT | OPFLAG_KEEPS_CONCAT,
+        1000, 0, false, perform_concat
+};
+static const struct operation op_exp = {
+    true, "^", "^", 0, 30, 1, false, perform_exp
+};
+static const struct operation op_factorial = {
+    true, "!", "!", OPFLAG_UNARY, 40, 0, false, perform_factorial
+};
+static const struct operation op_decimal = {
+    true, ".", ".", OPFLAG_UNARY | OPFLAG_UNARYPREFIX | OPFLAG_NEEDS_CONCAT | OPFLAG_KEEPS_CONCAT, 50, 0, false, perform_decimal
+};
+static const struct operation op_recur = {
+    true, "...", "recur", OPFLAG_UNARY | OPFLAG_NEEDS_CONCAT, 45, 2, false, perform_recur
+};
+static const struct operation op_root = {
+    true, "v~", "root", 0, 30, 1, false, perform_root
+};
+static const struct operation op_perc = {
+    true, "%", "%", OPFLAG_UNARY | OPFLAG_NEEDS_CONCAT, 45, 1, false, perform_perc
+};
+static const struct operation op_gamma = {
+    true, "gamma", "gamma", OPFLAG_UNARY | OPFLAG_UNARYPREFIX | OPFLAG_FN, 1, 3, false, perform_gamma
+};
+static const 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/
+ */
+static const struct operation *const ops_countdown[] = {
+    &op_add, &op_mul, &op_sub, &op_xdiv, NULL
+};
+static const 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.
+ */
+static const struct operation *const ops_3388[] = {
+    &op_add, &op_mul, &op_sub, &op_div, NULL
+};
+static const struct rules rules_3388 = {
+    ops_3388, true
+};
+
+/*
+ * A still more permissive rule set usable for the four-4s problem
+ * and similar things. Permits concatenation.
+ */
+static const struct operation *const ops_four4s[] = {
+    &op_add, &op_mul, &op_sub, &op_div, &op_concat, NULL
+};
+static const struct rules rules_four4s = {
+    ops_four4s, true
+};
+
+/*
+ * The most permissive ruleset I can think of. Permits
+ * exponentiation, and also silly unary operators like factorials.
+ */
+static const 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
+};
+static const 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.
+ */
+static void print_recurse(struct sets *s, struct set *ss, int pathindex,
+                          int index, int priority, int assoc, int child);
+static 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.
+         */
+        const 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]);
+    }
+}
+static 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;
+        }
+    }
+}
+static 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/src/unfinished/path.c b/apps/plugins/puzzles/src/unfinished/path.c
new file mode 100644
index 0000000000..2515ed0b71
--- /dev/null
+++ b/apps/plugins/puzzles/src/unfinished/path.c
@@ -0,0 +1,866 @@
+/*
+ * Experimental grid generator for Nikoli's `Number Link' puzzle.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.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).
+ */
+
+/*
+ * 2020-05-11: some thoughts on a solver.
+ *
+ * Consider this example puzzle, from Wikipedia:
+ *
+ *     ---4---
+ *     -3--25-
+ *     ---31--
+ *     ---5---
+ *     -------
+ *     --1----
+ *     2---4--
+ *
+ * The kind of deduction that a human wants to make here is: which way
+ * does the path between the 4s go? In particular, does it go round
+ * the left of the W-shaped cluster of endpoints, or round the right
+ * of it? It's clear at a glance that it must go to the right, because
+ * _any_ path between the 4s that goes to the left of that cluster, no
+ * matter what detailed direction it takes, will disconnect the
+ * remaining grid squares into two components, with the two 2s not in
+ * the same component. So we immediately know that the path between
+ * the 4s _must_ go round the right-hand side of the grid.
+ *
+ * How do you model that global and topological reasoning in a
+ * computer?
+ *
+ * The most plausible idea I've seen so far is to use fundamental
+ * groups. The fundamental group of loops based at a given point in a
+ * space is a free group, under loop concatenation and up to homotopy,
+ * generated by the loops that go in each direction around each hole
+ * in the space. In this case, the 'holes' are clues, or connected
+ * groups of clues.
+ *
+ * So you might be able to enumerate all the homotopy classes of paths
+ * between (say) the two 4s as follows. Start with any old path
+ * between them (say, find the first one that breadth-first search
+ * will give you). Choose one of the 4s to regard as the base point
+ * (arbitrarily). Then breadth-first search among the space of _paths_
+ * by the following procedure. Given a candidate path, append to it
+ * each of the possible loops that starts from the base point,
+ * circumnavigates one clue cluster, and returns to the base point.
+ * The result will typically be a path that retraces its steps and
+ * self-intersects. Now adjust it homotopically so that it doesn't. If
+ * that can't be done, then we haven't generated a fresh candidate
+ * path; if it can, then we've got a new path that is not homotopic to
+ * any path we already had, so add it to our list and queue it up to
+ * become the starting point of this search later.
+ *
+ * The idea is that this should exhaustively enumerate, up to
+ * homotopy, the different ways in which the two 4s can connect to
+ * each other within the constraint that you have to actually fit the
+ * path non-self-intersectingly into this grid. Then you can keep a
+ * list of those homotopy classes in mind, and start ruling them out
+ * by techniques like the connectivity approach described above.
+ * Hopefully you end up narrowing down to few enough homotopy classes
+ * that you can deduce something concrete about actual squares of the
+ * grid - for example, here, that if the path between 4s has to go
+ * round the right, then we know some specific squares it must go
+ * through, so we can fill those in. And then, having filled in a
+ * piece of the middle of a path, you can now regard connecting the
+ * ultimate endpoints to that mid-section as two separate subproblems,
+ * so you've reduced to a simpler instance of the same puzzle.
+ *
+ * But I don't know whether all of this actually works. I more or less
+ * believe the process for enumerating elements of the free group; but
+ * I'm not as confident that when you find a group element that won't
+ * fit in the grid, you'll never have to consider its descendants in
+ * the BFS either. And I'm assuming that 'unwind the self-intersection
+ * homotopically' is a thing that can actually be turned into a
+ * sensible algorithm.
+ *
+ * --------
+ *
+ * Another thing that might be needed is to characterise _which_
+ * homotopy class a given path is in.
+ *
+ * For this I think it's sufficient to choose a collection of paths
+ * along the _edges_ of the square grid, each of which connects two of
+ * the holes in the grid (including the grid exterior, which counts as
+ * a huge hole), such that they form a spanning tree between the
+ * holes. Then assign each of those paths an orientation, so that
+ * crossing it in one direction counts as 'positive' and the other
+ * 'negative'. Now analyse a candidate path from one square to another
+ * by following it and noting down which of those paths it crosses in
+ * which direction, then simplifying the result like a free group word
+ * (i.e. adjacent + and - crossings of the same path cancel out).
+ *
+ * --------
+ *
+ * If we choose those paths to be of minimal length, then we can get
+ * an upper bound on the number of homotopy classes by observing that
+ * you can't traverse any of those barriers more times than will fit
+ * non-self-intersectingly in the grid. That might be an alternative
+ * method of bounding the search through the fundamental group to only
+ * finitely many possibilities.
+ */
+
+/*
+ * 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_new("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
diff --git a/apps/plugins/puzzles/src/unfinished/separate.c b/apps/plugins/puzzles/src/unfinished/separate.c
new file mode 100644
index 0000000000..6ca07252ad
--- /dev/null
+++ b/apps/plugins/puzzles/src/unfinished/separate.c
@@ -0,0 +1,861 @@
+/*
+ * 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>
+#ifdef NO_TGMATH_H
+#  include <math.h>
+#else
+#  include <tgmath.h>
+#endif
+
+#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 bool 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, bool 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 const char *validate_params(const game_params *params, bool full)
+{
+    return NULL;
+}
+
+/* ----------------------------------------------------------------------
+ * Solver and generator.
+ */
+
+struct solver_scratch {
+    int w, h, k;
+
+    /*
+     * Tracks connectedness between squares.
+     */
+    DSF *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.
+     */
+    bool *disconnect;
+
+    /*
+     * Temporary space used only inside particular solver loops.
+     */
+    int *tmp;
+};
+
+static 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 = dsf_new(wh);
+    sc->size = snewn(wh, int);
+    sc->contents = snewn(wh * k, int);
+    sc->disconnect = snewn(wh*wh, bool);
+    sc->tmp = snewn(wh, int);
+
+    return sc;
+}
+
+static void solver_scratch_free(struct solver_scratch *sc)
+{
+    dsf_free(sc->dsf);
+    sfree(sc->size);
+    sfree(sc->contents);
+    sfree(sc->disconnect);
+    sfree(sc->tmp);
+    sfree(sc);
+}
+
+static 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]);
+}
+
+static 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] = true;
+    sc->disconnect[yx2*wh+yx1] = true;
+}
+
+static 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_reinit(sc->dsf);
+    for (i = 0; i < wh; i++) sc->size[i] = 1;
+    memset(sc->disconnect, 0, wh*wh * sizeof(bool));
+}
+
+static int solver_attempt(struct solver_scratch *sc, const unsigned char *grid,
+                          bool *gen_lock)
+{
+    int w = sc->w, h = sc->h, k = sc->k;
+    int wh = w*h;
+    int i, x, y;
+    bool 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) {
+        bool 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]] = true;
+                        gen_lock[sc->contents[yx2*k+i]] = true;
+                    }
+                }
+            }
+        }
+
+        /*
+         * 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;
+}
+
+static 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;
+    bool *gen_lock;
+
+    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, bool);
+
+    do {
+        DSF *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 * sizeof(bool));
+
+        /*
+         * 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 */
+        }
+
+        dsf_free(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, bool 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 const 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, const char **error)
+{
+    return NULL;
+}
+
+static bool 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 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,
+                              const game_ui *ui, 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)
+{
+}
+
+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 void game_get_cursor_location(const game_ui *ui,
+                                     const game_drawstate *ds,
+                                     const game_state *state,
+                                     const game_params *params,
+                                     int *x, int *y, int *w, int *h)
+{
+}
+
+static int game_status(const game_state *state)
+{
+    return 0;
+}
+
+static bool game_timing_state(const game_state *state, game_ui *ui)
+{
+    return true;
+}
+
+static void game_print_size(const game_params *params, const game_ui *ui,
+                            float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, const game_ui *ui,
+                       int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame separate
+#endif
+
+const struct game thegame = {
+    "Separate", NULL, NULL,
+    default_params,
+    game_fetch_preset, NULL,
+    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,
+    NULL, NULL, /* get_prefs, set_prefs */
+    new_ui,
+    free_ui,
+    NULL, /* encode_ui */
+    NULL, /* decode_ui */
+    NULL, /* game_request_keys */
+    game_changed_state,
+    NULL, /* current_key_label */
+    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_get_cursor_location,
+    game_status,
+    false, false, game_print_size, game_print,
+    false,                             /* wants_statusbar */
+    false, game_timing_state,
+    0,                                 /* flags */
+};
diff --git a/apps/plugins/puzzles/src/unfinished/slide.c b/apps/plugins/puzzles/src/unfinished/slide.c
new file mode 100644
index 0000000000..4c4d98943e
--- /dev/null
+++ b/apps/plugins/puzzles/src/unfinished/slide.c
@@ -0,0 +1,2444 @@
+/*
+ * 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>
+#ifdef NO_TGMATH_H
+#  include <math.h>
+#else
+#  include <tgmath.h>
+#endif
+
+#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;
+    bool *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;
+    bool 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 bool 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, bool 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].u.string.sval = dupstr(buf);
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].u.string.sval = dupstr(buf);
+
+    ret[2].name = "Solution length limit";
+    ret[2].type = C_STRING;
+    sprintf(buf, "%d", params->maxmoves);
+    ret[2].u.string.sval = dupstr(buf);
+
+    ret[3].name = NULL;
+    ret[3].type = C_END;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].u.string.sval);
+    ret->h = atoi(cfg[1].u.string.sval);
+    ret->maxmoves = atoi(cfg[2].u.string.sval);
+
+    return ret;
+}
+
+static const char *validate_params(const game_params *params, bool 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,
+                               bool *forcefield)
+{
+    int wh = w*h;
+    DSF *dsf = dsf_new(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,
+                       bool *forcefield, int tx, int ty,
+                       int movelimit, int **moveout)
+{
+    int wh = w*h;
+    struct board *b, *b2, *b3;
+    int *next, *which;
+    bool *anchors, *movereached;
+    int *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, bool);
+    which = snewn(wh, int);
+    movereached = snewn(wh, bool);
+    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,
+                           bool **rforcefield, int movelimit)
+{
+    int wh = w*h;
+    unsigned char *board, *board2;
+    bool *forcefield;
+    bool *tried_merge;
+    DSF *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, bool);
+    board2 = snewn(wh, unsigned char);
+    memset(board, ANCHOR, wh);
+    memset(forcefield, 0, wh * sizeof(bool));
+    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, bool);
+    memset(tried_merge, 0, wh*wh * sizeof(bool));
+    dsf = dsf_new(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] = true;
+    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] = true;
+            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]);
+        }
+    }
+
+    dsf_free(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, bool interactive)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    int tx, ty, minmoves;
+    unsigned char *board;
+    bool *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];
+            bool 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 const char *validate_desc(const game_params *params, const char *desc)
+{
+    int w = params->w, h = params->h, wh = w*h;
+    bool *active;
+    int *link;
+    int mains = 0;
+    int i, tx, ty, minmoves;
+    const char *ret;
+
+    active = snewn(wh, bool);
+    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, bool);
+
+    i = 0;
+
+    while (*desc && *desc != ',') {
+        bool 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, const 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 bool 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 {
+    bool dragging;
+    int drag_anchor;
+    int drag_offset_x, drag_offset_y;
+    int drag_currpos;
+    bool *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, bool);
+    memset(ui->reachable, 0, wh * sizeof(bool));
+    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 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 */
+};
+
+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, 0, wh * sizeof(bool));
+        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 MOVE_UI_UPDATE;
+    } 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 MOVE_UI_UPDATE;
+                    }
+                }
+        }
+        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 = MOVE_UI_UPDATE;
+        
+        ui->dragging = false;
+        ui->drag_anchor = ui->drag_currpos = -1;
+        ui->drag_offset_x = ui->drag_offset_y = -1;
+        memset(ui->reachable, 0, wh * sizeof(bool));
+
+        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 bool move_piece(int w, int h, const unsigned char *src,
+                       unsigned char *dst, bool *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,
+                              const game_ui *ui, 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->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, DSF *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;
+    DSF *dsf;
+    int x, y, mainanchor, mainpos, dragpos, solvepos, solvesrc, solvedst;
+
+    /*
+     * 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) {
+        bool 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 = dsf_new(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);
+    }
+
+    dsf_free(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 void game_get_cursor_location(const game_ui *ui,
+                                     const game_drawstate *ds,
+                                     const game_state *state,
+                                     const game_params *params,
+                                     int *x, int *y, int *w, int *h)
+{
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static bool game_timing_state(const game_state *state, game_ui *ui)
+{
+    return true;
+}
+
+static void game_print_size(const game_params *params, const game_ui *ui,
+                            float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, const game_ui *ui,
+                       int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame slide
+#endif
+
+const struct game thegame = {
+    "Slide", NULL, NULL,
+    default_params,
+    game_fetch_preset, NULL,
+    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,
+    NULL, NULL, /* get_prefs, set_prefs */
+    new_ui,
+    free_ui,
+    NULL, /* encode_ui */
+    NULL, /* decode_ui */
+    NULL, /* game_request_keys */
+    game_changed_state,
+    NULL, /* current_key_label */
+    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_get_cursor_location,
+    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;
+    const char *err;
+    bool 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) {
+            bool 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/src/unfinished/sokoban.c b/apps/plugins/puzzles/src/unfinished/sokoban.c
new file mode 100644
index 0000000000..1f3c688af1
--- /dev/null
+++ b/apps/plugins/puzzles/src/unfinished/sokoban.c
@@ -0,0 +1,1476 @@
+/*
+ * 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>
+#ifdef NO_TGMATH_H
+#  include <math.h>
+#else
+#  include <tgmath.h>
+#endif
+
+#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;
+    bool 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 bool 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, bool 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].u.string.sval = dupstr(buf);
+
+    ret[1].name = "Height";
+    ret[1].type = C_STRING;
+    sprintf(buf, "%d", params->h);
+    ret[1].u.string.sval = dupstr(buf);
+
+    ret[2].name = NULL;
+    ret[2].type = C_END;
+
+    return ret;
+}
+
+static game_params *custom_params(const config_item *cfg)
+{
+    game_params *ret = snew(game_params);
+
+    ret->w = atoi(cfg[0].u.string.sval);
+    ret->h = atoi(cfg[1].u.string.sval);
+
+    return ret;
+}
+
+static const char *validate_params(const game_params *params, bool 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,
+                             bool 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, bool 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 const 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, const char **error)
+{
+    return NULL;
+}
+
+static bool 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 void game_changed_state(game_ui *ui, const game_state *oldstate,
+                               const game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    game_params p;
+    int tilesize;
+    bool 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.
+ */
+static int move_type(const 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;
+    bool 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,
+                              const game_ui *ui, 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) {
+        /*
+         * 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 void game_get_cursor_location(const game_ui *ui,
+                                     const game_drawstate *ds,
+                                     const game_state *state,
+                                     const game_params *params,
+                                     int *x, int *y, int *w, int *h)
+{
+}
+
+static int game_status(const game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
+static bool game_timing_state(const game_state *state, game_ui *ui)
+{
+    return true;
+}
+
+static void game_print_size(const game_params *params, const game_ui *ui,
+                            float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, const game_state *state, const game_ui *ui,
+                       int tilesize)
+{
+}
+
+#ifdef COMBINED
+#define thegame sokoban
+#endif
+
+const struct game thegame = {
+    "Sokoban", NULL, NULL,
+    default_params,
+    game_fetch_preset, NULL,
+    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,
+    NULL, NULL, /* get_prefs, set_prefs */
+    new_ui,
+    free_ui,
+    NULL, /* encode_ui */
+    NULL, /* decode_ui */
+    NULL, /* game_request_keys */
+    game_changed_state,
+    NULL, /* current_key_label */
+    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_get_cursor_location,
+    game_status,
+    false, false, game_print_size, game_print,
+    false,                             /* wants_statusbar */
+    false, game_timing_state,
+    0,                                 /* flags */
+};